David Snelling
e47fea0917
The JS fallback EntityIdMapper caps at u32::MAX to match the metadata index's Roaring32 bitmap width. Before this guard, a brain past 4.29 B entities would silently widen `nextId` into JS's safe-integer range, truncating ints inside the bitmaps and zeroing query results — the same silent under-count cortex 3.0's Piece 10 just closed on the native path. Brainy 8.0 surfaces the overflow loudly instead. When `nextId` would exceed `U32_ENTITY_ID_MAX`, `getOrAssign` throws `EntityIdSpaceExceeded` with a message pointing at the cortex 3.0 binary mapper's `idSpace: 'u64'` mode as the migration path (mmap- backed extendible-hash KV, persists the full u64 range losslessly). The existing-UUID lookup path bypasses the guard — only fresh allocations can overflow. Surfaces via `@soulcraft/brainy/internals`: - `EntityIdMapper` (already exported, behavior gated) - `EntityIdSpaceExceeded` (new) - `U32_ENTITY_ID_MAX` (new constant, = 0xFFFF_FFFF) This is the lockstep half of cortex 3.0 / Piece 10 / Step 15. Cortex's `NativeBinaryEntityIdMapperWrapper` ships the U64 binary mapper that takes over above this ceiling; brainy ships the bright-line failure that points consumers at it. New test: tests/unit/utils/entity-id-mapper-u32-ceiling.test.ts (6 assertions covering the constant, the error shape, normal allocations, the boundary case at exactly u32::MAX, the overflow throw, and the existing-uuid lookup bypass).
98 lines
3.6 KiB
TypeScript
98 lines
3.6 KiB
TypeScript
/**
|
|
* @description Brainy 8.0 IdSpace contract: the JS fallback
|
|
* `EntityIdMapper` caps at `u32::MAX` to match the metadata index's
|
|
* Roaring32 bitmap width. When `nextId` would exceed the ceiling,
|
|
* `getOrAssign` throws `EntityIdSpaceExceeded` with a message pointing
|
|
* at the cortex 3.0 binary mapper's `idSpace: 'u64'` mode as the
|
|
* migration path.
|
|
*
|
|
* This is the lockstep counterpart to cortex 3.0's Piece 10 / Step 15
|
|
* (TS wrapper + napi BigInt siblings + Roaring32-or-Treemap
|
|
* `PostingList` enum). Without this guard, a JS-only brainy install
|
|
* past 4.29 B entities would silently truncate entity ids into the
|
|
* low-32-bit range, zeroing query results and corrupting any
|
|
* persisted int-keyed structure that consumed the mapper.
|
|
*/
|
|
|
|
import { describe, it, expect } from 'vitest'
|
|
import {
|
|
EntityIdMapper,
|
|
EntityIdSpaceExceeded,
|
|
U32_ENTITY_ID_MAX,
|
|
} from '../../../src/utils/entityIdMapper.js'
|
|
|
|
/**
|
|
* Construct a fresh in-memory mapper without going through brainy's
|
|
* full storage adapter — we only exercise the in-RAM ceiling guard
|
|
* here, so a minimal `getMetadata`-returning shim is enough.
|
|
*/
|
|
function makeMapper(): EntityIdMapper {
|
|
const storage = {
|
|
getMetadata: async () => null,
|
|
setMetadata: async () => {},
|
|
getNouns: async () => ({ items: [], totalCount: 0 }),
|
|
} as any
|
|
return new EntityIdMapper({ storage })
|
|
}
|
|
|
|
describe('EntityIdMapper U32 IdSpace ceiling (Brainy 8.0)', () => {
|
|
it('U32_ENTITY_ID_MAX equals 0xFFFF_FFFF (u32 ceiling)', () => {
|
|
expect(U32_ENTITY_ID_MAX).toBe(0xffff_ffff)
|
|
})
|
|
|
|
it('EntityIdSpaceExceeded is an Error subclass with attempted + ceiling', () => {
|
|
const err = new EntityIdSpaceExceeded(0xffff_ffff + 1)
|
|
expect(err).toBeInstanceOf(Error)
|
|
expect(err.name).toBe('EntityIdSpaceExceeded')
|
|
expect(err.ceiling).toBe(0xffff_ffff)
|
|
expect(err.attempted).toBe(0x1_0000_0000)
|
|
expect(err.message).toMatch(/u32::MAX/)
|
|
expect(err.message).toMatch(/cortex/)
|
|
expect(err.message).toMatch(/idSpace: 'u64'/)
|
|
})
|
|
|
|
it('normal allocations under the ceiling succeed', async () => {
|
|
const m = makeMapper()
|
|
await m.init()
|
|
const a = m.getOrAssign('uuid-a')
|
|
const b = m.getOrAssign('uuid-b')
|
|
expect(a).toBe(1)
|
|
expect(b).toBe(2)
|
|
expect(a).not.toBe(b)
|
|
})
|
|
|
|
it('throws EntityIdSpaceExceeded when nextId would exceed u32::MAX', async () => {
|
|
const m = makeMapper()
|
|
await m.init()
|
|
// Reach into the mapper to bump `nextId` past the ceiling without
|
|
// actually allocating 4.29 B entities at test time. This mirrors
|
|
// the runtime invariant the guard protects.
|
|
;(m as any).nextId = U32_ENTITY_ID_MAX + 1
|
|
expect(() => m.getOrAssign('uuid-overflow')).toThrow(EntityIdSpaceExceeded)
|
|
})
|
|
|
|
it('the last representable u32 int IS allocatable (boundary case)', async () => {
|
|
const m = makeMapper()
|
|
await m.init()
|
|
;(m as any).nextId = U32_ENTITY_ID_MAX
|
|
// `nextId === U32_ENTITY_ID_MAX` is still within range — the
|
|
// guard checks `> U32_ENTITY_ID_MAX`, so this last allocation
|
|
// succeeds.
|
|
const id = m.getOrAssign('uuid-at-ceiling')
|
|
expect(id).toBe(U32_ENTITY_ID_MAX)
|
|
// The NEXT allocation overflows.
|
|
expect(() => m.getOrAssign('uuid-after-ceiling')).toThrow(
|
|
EntityIdSpaceExceeded,
|
|
)
|
|
})
|
|
|
|
it('existing uuid lookup never overflows even when nextId is past ceiling', async () => {
|
|
const m = makeMapper()
|
|
await m.init()
|
|
const assigned = m.getOrAssign('uuid-existing')
|
|
;(m as any).nextId = U32_ENTITY_ID_MAX + 1
|
|
// Looking up an already-assigned UUID does NOT allocate; the
|
|
// guard is on the assign path only.
|
|
expect(m.getOrAssign('uuid-existing')).toBe(assigned)
|
|
})
|
|
})
|