@flighthq/registry 0.3.1-next.1041.35b950c

package/dist/contract.d.ts

@@ -0,0 +1,2 @@
+export * from './registryTable';
+//# sourceMappingURL=contract.d.ts.map

package/dist/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../src/contract.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC"}

package/dist/contract.js

@@ -0,0 +1,2 @@
+export * from './registryTable';
+//# sourceMappingURL=contract.js.map

package/dist/contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.js","sourceRoot":"","sources":["../src/contract.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { concatRegistryTable, createKeyedTable, createOrdinalTable, createSlotTable, getOrdinalTableEntry, getRegistryTableEntry, getRegistryTableKeys, hasRegistryTableEntry, withoutRegistryTableEntry, withRegistryTableEntry, withRegistryTableTombstone, } from './registryTable';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,oBAAoB,EACpB,qBAAqB,EACrB,oBAAoB,EACpB,qBAAqB,EACrB,yBAAyB,EACzB,sBAAsB,EACtB,0BAA0B,GAC3B,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { concatRegistryTable, createKeyedTable, createOrdinalTable, createSlotTable, getOrdinalTableEntry, getRegistryTableEntry, getRegistryTableKeys, hasRegistryTableEntry, withoutRegistryTableEntry, withRegistryTableEntry, withRegistryTableTombstone, } from './registryTable';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,oBAAoB,EACpB,qBAAqB,EACrB,oBAAoB,EACpB,qBAAqB,EACrB,yBAAyB,EACzB,sBAAsB,EACtB,0BAA0B,GAC3B,MAAM,iBAAiB,CAAC"}

package/dist/registryTable.d.ts

@@ -0,0 +1,16 @@
+import type { Kind, KeyedTable, OrdinalTable, RegistryId, RegistryMissPolicy, RegistryTable, SlotTable } from '@flighthq/types/contract';
+export declare function concatRegistryTable<T>(base: Readonly<KeyedTable<T>> | Readonly<SlotTable<T>>, overlay: Readonly<KeyedTable<T>> | Readonly<SlotTable<T>>): KeyedTable<T> | SlotTable<T>;
+/** An empty keyed table for `registry`, carrying the miss policy every replacement of it preserves. */
+export declare function createKeyedTable<T>(registry: RegistryId, onMiss: RegistryMissPolicy): KeyedTable<T>;
+/** An ordinal table over `vocabulary`, every ordinal unbound. */
+export declare function createOrdinalTable<T>(registry: RegistryId, onMiss: RegistryMissPolicy, vocabulary: readonly Kind[]): OrdinalTable<T>;
+/** An empty slot table for `registry`. Its key is its own `RegistryId`. */
+export declare function createSlotTable<T>(registry: RegistryId, onMiss: RegistryMissPolicy): SlotTable<T>;
+export declare function getOrdinalTableEntry<T>(table: Readonly<OrdinalTable<T>>, ordinal: number): T | null;
+export declare function getRegistryTableEntry<T>(table: Readonly<RegistryTable<T>>, key: Kind): T | null;
+export declare function getRegistryTableKeys(out: Kind[], table: Readonly<RegistryTable<unknown>>): void;
+export declare function hasRegistryTableEntry(table: Readonly<RegistryTable<unknown>>, key: Kind): boolean;
+export declare function withoutRegistryTableEntry<T>(table: Readonly<KeyedTable<T>>, key: Kind): KeyedTable<T>;
+export declare function withRegistryTableEntry<T>(table: Readonly<KeyedTable<T>>, key: Kind, value: T): KeyedTable<T>;
+export declare function withRegistryTableTombstone<T>(table: Readonly<KeyedTable<T>>, key: Kind): KeyedTable<T>;
+//# sourceMappingURL=registryTable.d.ts.map

package/dist/registryTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registryTable.d.ts","sourceRoot":"","sources":["../src/registryTable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,IAAI,EACJ,UAAU,EACV,YAAY,EACZ,UAAU,EACV,kBAAkB,EAClB,aAAa,EAEb,SAAS,EACV,MAAM,0BAA0B,CAAC;AAsBlC,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EACtD,OAAO,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GACxD,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CA0C9B;AAED,uGAAuG;AACvG,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,EAAE,kBAAkB,GAAG,UAAU,CAAC,CAAC,CAAC,CAEnG;AAED,iEAAiE;AACjE,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,QAAQ,EAAE,UAAU,EACpB,MAAM,EAAE,kBAAkB,EAC1B,UAAU,EAAE,SAAS,IAAI,EAAE,GAC1B,YAAY,CAAC,CAAC,CAAC,CAEjB;AAED,2EAA2E;AAC3E,wBAAgB,eAAe,CAAC,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,EAAE,kBAAkB,GAAG,SAAS,CAAC,CAAC,CAAC,CAEjG;AAKD,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI,CAGnG;AAOD,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,GAAG,CAAC,GAAG,IAAI,CAI/F;AAKD,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI,CAc/F;AAID,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,GAAG,OAAO,CAGjG;AAQD,wBAAgB,yBAAyB,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,GAAG,UAAU,CAAC,CAAC,CAAC,CAIrG;AAKD,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAI5G;AASD,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,GAAG,UAAU,CAAC,CAAC,CAAC,CAItG"}

package/dist/registryTable.js

@@ -0,0 +1,162 @@
+import { RegistryEntryState } from '@flighthq/types/contract';
+// Registry tables are PERSISTENT: every operation that changes one returns a REPLACEMENT and mutates
+// nothing, and the owner assigns the result. That is why the mutating verbs are named `with*` rather
+// than `set*` — this repo reserves `set*` for in-place mutation, and a `set*` that does not set
+// contradicts a stated rule at the call site, where the reader has only the name to go on.
+//
+// Every operation here is cold: construction, composition, enumeration, diagnostics. None is on a draw
+// path. `getOrdinalTableEntry` is the one hot-path form and does a direct index with no dispatch.
+// Composes `overlay` onto `base`, entry by entry. The overlay wins wherever it has an opinion.
+//
+// Refuses rather than guesses: composing two tables of different SHAPE, or belonging to different
+// registries, is a programmer error and throws. It is not an expected failure a caller could handle.
+//
+// Three refusals, all the same kind of programmer error: a different SHAPE, a different REGISTRY, or a
+// different MISS POLICY. The policy comparison is equality only — composition never interprets a policy,
+// which is why the table layer needs no vocabulary of its own and the type is an open alias.
+//
+// `OrdinalTable` is not accepted, and that is structural rather than an oversight — nothing composes an
+// ordinal table, so it carries no composition operations at all. The signature refuses it.
+export function concatRegistryTable(base, overlay) {
+    if (base.shape !== overlay.shape) {
+        throw new Error(`concatRegistryTable: cannot compose a '${base.shape}' table with a '${overlay.shape}' table`);
+    }
+    if (base.registry !== overlay.registry) {
+        throw new Error(`concatRegistryTable: cannot compose registry '${base.registry}' with registry '${overlay.registry}'`);
+    }
+    if (base.onMiss !== overlay.onMiss) {
+        throw new Error(`concatRegistryTable: cannot compose miss policy '${base.onMiss}' with miss policy '${overlay.onMiss}'`);
+    }
+    if (base.shape === 'slot') {
+        const overlaySlot = overlay;
+        // `null` on the overlay is "no opinion" — inherit. A tombstone is "explicitly omitted" and wins.
+        return { entry: overlaySlot.entry ?? base.entry, onMiss: base.onMiss, registry: base.registry, shape: 'slot' };
+    }
+    const baseKeyed = base;
+    const overlayKeyed = overlay;
+    const entries = new Map(baseKeyed.entries);
+    for (const [key, entry] of overlayKeyed.entries) {
+        // The switch is what makes a THIRD state a build failure rather than a silent fall-through. Both
+        // arms carry the entry forward; a tombstone is copied AS a tombstone, never resolved to a binding,
+        // because resolving it here would resurrect the entry the overlay meant to omit.
+        switch (entry.state) {
+            case RegistryEntryState.Bound:
+                entries.set(key, entry);
+                break;
+            case RegistryEntryState.Tombstoned:
+                entries.set(key, entry);
+                break;
+            default: {
+                const unreachable = entry;
+                return unreachable;
+            }
+        }
+    }
+    return { entries, onMiss: baseKeyed.onMiss, registry: baseKeyed.registry, shape: 'keyed' };
+}
+/** An empty keyed table for `registry`, carrying the miss policy every replacement of it preserves. */
+export function createKeyedTable(registry, onMiss) {
+    return { entries: new Map(), onMiss, registry, shape: 'keyed' };
+}
+/** An ordinal table over `vocabulary`, every ordinal unbound. */
+export function createOrdinalTable(registry, onMiss, vocabulary) {
+    return { entries: vocabulary.map(() => null), onMiss, registry, shape: 'ordinal', vocabulary };
+}
+/** An empty slot table for `registry`. Its key is its own `RegistryId`. */
+export function createSlotTable(registry, onMiss) {
+    return { entry: null, onMiss, registry, shape: 'slot' };
+}
+// The hot-path ordinal form: a direct index, no hash and no string. Out-of-range returns `null`, which
+// is the format's skip-what-you-do-not-know path rather than a miss — a caller distinguishing "unknown
+// token" from "unregistered reader" compares the ordinal against `vocabulary.length`.
+export function getOrdinalTableEntry(table, ordinal) {
+    if (!Number.isInteger(ordinal) || ordinal < 0 || ordinal >= table.entries.length)
+        return null;
+    return table.entries[ordinal];
+}
+// What is bound to `key`, or `null`.
+//
+// RESOLUTION collapses a tombstone to `null`, and that is correct rather than lossy: the caller asked
+// what is bound and the answer is nothing. No tombstone escapes into caller code through this door,
+// which is why this returns `T | null` while composition deals in entries.
+export function getRegistryTableEntry(table, key) {
+    const entry = getRegistryTableEntryState(table, key);
+    if (entry === null || entry.state !== RegistryEntryState.Bound)
+        return null;
+    return entry.value;
+}
+// Clears `out`, then appends every BOUND key in sorted order — a tombstoned key is NOT listed, and a
+// caller that enumerates and then resolves therefore cannot get `null` for a key this just reported.
+// Sorting here rather than in storage is what lets the keyed shape stay a map.
+export function getRegistryTableKeys(out, table) {
+    out.length = 0;
+    if (table.shape === 'keyed') {
+        for (const [key, entry] of table.entries) {
+            if (entry.state === RegistryEntryState.Bound)
+                out.push(key);
+        }
+    }
+    else if (table.shape === 'slot') {
+        if (table.entry !== null && table.entry.state === RegistryEntryState.Bound)
+            out.push(table.registry);
+    }
+    else {
+        for (let ordinal = 0; ordinal < table.entries.length; ordinal++) {
+            if (table.entries[ordinal] !== null)
+                out.push(table.vocabulary[ordinal]);
+        }
+    }
+    out.sort();
+}
+// FALSE for a tombstoned key — the same rule as `getRegistryTableKeys`, one call apart: `has` answering
+// true where `get` answers null is that disagreement wearing a different name.
+export function hasRegistryTableEntry(table, key) {
+    const entry = getRegistryTableEntryState(table, key);
+    return entry !== null && entry.state === RegistryEntryState.Bound;
+}
+// NO OPINION. Removes `key` from the table entirely, so under composition the base's entry is INHERITED.
+//
+// The opposite of `withRegistryTableTombstone`: that one overrides the base with nothing, this one
+// declines to override at all. There is no third union variant for this and there should not be — "no
+// opinion" IS the key being absent from the map, so there is nothing to store and therefore nothing to
+// type. Typing it would be the tombstone.
+export function withoutRegistryTableEntry(table, key) {
+    const entries = new Map(table.entries);
+    entries.delete(key);
+    return { entries, onMiss: table.onMiss, registry: table.registry, shape: 'keyed' };
+}
+// Binds `key` to `value`, returning a REPLACEMENT table. Not `setRegistryTableEntry`: this mutates
+// nothing, and `set*` is reserved for in-place mutation. The owner assigns the result:
+//   registries.textureResolvers = withRegistryTableEntry(registries.textureResolvers, kind, resolver);
+export function withRegistryTableEntry(table, key, value) {
+    const entries = new Map(table.entries);
+    entries.set(key, { state: RegistryEntryState.Bound, value });
+    return { entries, onMiss: table.onMiss, registry: table.registry, shape: 'keyed' };
+}
+// OMIT. Binds `key` to the tombstone: this table has an opinion about `key`, and the opinion is NOTHING.
+// Under composition the overlay's tombstone WINS and the base's entry does not survive.
+//
+// The opposite of `withoutRegistryTableEntry`, which reads almost identically in English and composes the
+// other way. Both leave `getRegistryTableEntry` answering `null` on a table with no base, so the
+// difference is invisible until the table is composed. Choose by what you MEAN — override-with-nothing,
+// or decline-to-override — never by which looks right at the call site.
+export function withRegistryTableTombstone(table, key) {
+    const entries = new Map(table.entries);
+    entries.set(key, { state: RegistryEntryState.Tombstoned });
+    return { entries, onMiss: table.onMiss, registry: table.registry, shape: 'keyed' };
+}
+// The stored entry for `key`, tombstones included — the shape-dispatch every resolution query shares.
+// Deliberately not exported: entries are composition currency, and handing one to a caller that only
+// wanted a value is how a tombstone reaches somewhere that has never heard of one.
+function getRegistryTableEntryState(table, key) {
+    if (table.shape === 'keyed')
+        return table.entries.get(key) ?? null;
+    if (table.shape === 'slot')
+        return key === table.registry ? table.entry : null;
+    const ordinal = table.vocabulary.indexOf(key);
+    if (ordinal === -1)
+        return null;
+    const value = table.entries[ordinal];
+    return value === null ? null : { state: RegistryEntryState.Bound, value };
+}
+//# sourceMappingURL=registryTable.js.map

package/dist/registryTable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registryTable.js","sourceRoot":"","sources":["../src/registryTable.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@flighthq/registry",
+  "version": "0.3.1-next.1041.35b950c",
+  "author": "Joshua Granick and other contributors",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/flighthq/flight.git",
+    "directory": "packages/registry"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./contract": {
+      "types": "./dist/contract.d.ts",
+      "default": "./dist/contract.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src/**/*.test.ts",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.js.map",
+    "!dist/**/*.test.d.ts.map"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "tsc -b --clean",
+    "test": "vitest run --config vitest.config.ts",
+    "test:watch": "vitest --watch --config vitest.config.ts",
+    "prepack": "npm run clean && npm run clean:dist && npm run build",
+    "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
+  },
+  "dependencies": {
+    "@flighthq/types": "0.3.1-next.1041.35b950c"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  },
+  "description": "Registry tables — persistent keyed/slot/ordinal registries with explicit omission",
+  "sideEffects": false
+}

package/src/registryTable.test.ts

@@ -0,0 +1,272 @@
+import type { KeyedTable, SlotTable } from '@flighthq/types/contract';
+import { RegistryEntryState } from '@flighthq/types/contract';
+
+import {
+  concatRegistryTable,
+  createKeyedTable,
+  createOrdinalTable,
+  createSlotTable,
+  getOrdinalTableEntry,
+  getRegistryTableEntry,
+  getRegistryTableKeys,
+  hasRegistryTableEntry,
+  withoutRegistryTableEntry,
+  withRegistryTableEntry,
+  withRegistryTableTombstone,
+} from './registryTable';
+
+describe('concatRegistryTable', () => {
+  it('lets a bound overlay entry win over the base', () => {
+    const base = withRegistryTableEntry(createKeyedTable<string>('r', 'none'), 'a', 'base');
+    const overlay = withRegistryTableEntry(createKeyedTable<string>('r', 'none'), 'a', 'overlay');
+
+    expect(getRegistryTableEntry(concatRegistryTable(base, overlay), 'a')).toBe('overlay');
+  });
+
+  it('carries a TOMBSTONE through as a tombstone, so the omitted base entry does NOT come back', () => {
+    // The defect this arm exists to prevent: resolving a tombstone to a binding during composition
+    // resurrects exactly the entry the overlay meant to omit.
+    const base = withRegistryTableEntry(createKeyedTable<string>('r', 'none'), 'a', 'base');
+    const overlay = withRegistryTableTombstone(createKeyedTable<string>('r', 'none'), 'a');
+    const composed = concatRegistryTable(base, overlay) as KeyedTable<string>;
+
+    expect(getRegistryTableEntry(composed, 'a')).toBeNull();
+    // And it is a tombstone in the result, not an absence — so composing again still omits.
+    expect(composed.entries.get('a')).toEqual({ state: RegistryEntryState.Tombstoned });
+  });
+
+  it('INHERITS the base where the overlay merely has no opinion — the opposite of a tombstone', () => {
+    // withoutRegistryTableEntry and withRegistryTableTombstone read almost identically and compose
+    // oppositely. This pins the difference; without it the two verbs are interchangeable.
+    const base = withRegistryTableEntry(createKeyedTable<string>('r', 'none'), 'a', 'base');
+    const overlay = withoutRegistryTableEntry(
+      withRegistryTableEntry(createKeyedTable<string>('r', 'none'), 'a', 'x'),
+      'a',
+    );
+
+    expect(getRegistryTableEntry(concatRegistryTable(base, overlay), 'a')).toBe('base');
+  });
+
+  it('throws on a shape mismatch, which is a programmer error rather than an expected failure', () => {
+    const keyed = createKeyedTable<string>('r', 'none');
+    const slot = createSlotTable<string>('r', 'none');
+
+    expect(() => concatRegistryTable(keyed, slot)).toThrow(/cannot compose a 'keyed' table with a 'slot' table/);
+  });
+
+  it('throws when the two tables are different registries', () => {
+    expect(() =>
+      concatRegistryTable(createKeyedTable<string>('a', 'none'), createKeyedTable<string>('b', 'none')),
+    ).toThrow(/cannot compose registry 'a' with registry 'b'/);
+  });
+
+  it('throws when the two tables carry a different MISS POLICY', () => {
+    // The third refusal, alongside shape and registry id. Composition only ever compares policies for
+    // equality — it never interprets one — which is why the table layer needs no policy vocabulary and
+    // the type is an open alias. Same registry and same shape here, so the policy is the only difference.
+    expect(() =>
+      concatRegistryTable(createKeyedTable<string>('r', 'fallback'), createKeyedTable<string>('r', 'none')),
+    ).toThrow(/cannot compose miss policy 'fallback' with miss policy 'none'/);
+  });
+
+  it('preserves the miss policy through composition and through every replacement', () => {
+    // A policy that survives concat but is dropped by withEntry would make the refusal above fire
+    // spuriously on the NEXT compose — so the preservation is pinned here rather than assumed.
+    const base = withRegistryTableEntry(createKeyedTable<string>('r', 'fallback'), 'a', 'v');
+    const overlay = withRegistryTableTombstone(createKeyedTable<string>('r', 'fallback'), 'b');
+
+    expect(base.onMiss).toBe('fallback');
+    expect(withoutRegistryTableEntry(base, 'a').onMiss).toBe('fallback');
+    expect((concatRegistryTable(base, overlay) as KeyedTable<string>).onMiss).toBe('fallback');
+  });
+
+  it('composes a slot, where null is inherit and a tombstone is omit', () => {
+    const base: SlotTable<string> = {
+      entry: { state: RegistryEntryState.Bound, value: 'base' },
+      onMiss: 'none',
+      registry: 'r',
+      shape: 'slot',
+    };
+    const noOpinion = createSlotTable<string>('r', 'none');
+    const omit: SlotTable<string> = {
+      entry: { state: RegistryEntryState.Tombstoned },
+      onMiss: 'none',
+      registry: 'r',
+      shape: 'slot',
+    };
+
+    expect(getRegistryTableEntry(concatRegistryTable(base, noOpinion), 'r')).toBe('base');
+    expect(getRegistryTableEntry(concatRegistryTable(base, omit), 'r')).toBeNull();
+  });
+});
+
+describe('createKeyedTable', () => {
+  it('starts empty and carries its registry id', () => {
+    const table = createKeyedTable<string>('textureResolvers', 'none');
+
+    expect(table.registry).toBe('textureResolvers');
+    expect(table.entries.size).toBe(0);
+  });
+});
+
+describe('createOrdinalTable', () => {
+  it('starts with every ordinal unbound, one per vocabulary entry', () => {
+    const table = createOrdinalTable<string>('swfTags', 'none', ['Tag0', 'Tag1', 'Tag2']);
+
+    expect(table.entries.length).toBe(3);
+    expect(table.entries.every((entry) => entry === null)).toBe(true);
+  });
+});
+
+describe('createSlotTable', () => {
+  it('starts with no opinion, which is not the same as an explicit omission', () => {
+    expect(createSlotTable<string>('shapeRasterizer', 'none').entry).toBeNull();
+  });
+});
+
+describe('getOrdinalTableEntry', () => {
+  it('returns null out of range, which is the format skip path rather than a miss', () => {
+    const table = createOrdinalTable<string>('swfTags', 'none', ['Tag0']);
+
+    expect(getOrdinalTableEntry(table, 1)).toBeNull();
+    expect(getOrdinalTableEntry(table, -1)).toBeNull();
+    expect(getOrdinalTableEntry(table, 1.5)).toBeNull();
+  });
+
+  it('indexes directly when the ordinal is in range', () => {
+    const table = createOrdinalTable<string>('swfTags', 'none', ['Tag0', 'Tag1']);
+    const bound = { ...table, entries: ['zero', null] };
+
+    expect(getOrdinalTableEntry(bound, 0)).toBe('zero');
+    expect(getOrdinalTableEntry(bound, 1)).toBeNull();
+  });
+});
+
+describe('getRegistryTableEntry', () => {
+  it('resolves a bound value', () => {
+    expect(getRegistryTableEntry(withRegistryTableEntry(createKeyedTable<string>('r', 'none'), 'a', 'v'), 'a')).toBe(
+      'v',
+    );
+  });
+
+  it('collapses a tombstone to null, because at resolution a tombstone IS a miss', () => {
+    expect(
+      getRegistryTableEntry(withRegistryTableTombstone(createKeyedTable<string>('r', 'none'), 'a'), 'a'),
+    ).toBeNull();
+  });
+
+  it('returns null for a key nobody has an opinion about', () => {
+    expect(getRegistryTableEntry(createKeyedTable<string>('r', 'none'), 'a')).toBeNull();
+  });
+});
+
+describe('getRegistryTableKeys', () => {
+  it('lists ONLY bound keys, so enumeration and resolution cannot disagree', () => {
+    // The trap: listing a tombstoned key means a caller that enumerates then resolves gets null for a
+    // key this function just said was there.
+    const table = withRegistryTableTombstone(
+      withRegistryTableEntry(withRegistryTableEntry(createKeyedTable<string>('r', 'none'), 'b', '1'), 'a', '2'),
+      'c',
+    );
+    const out: string[] = [];
+    getRegistryTableKeys(out, table);
+
+    expect(out).toEqual(['a', 'b']);
+    for (const key of out) expect(getRegistryTableEntry(table, key)).not.toBeNull();
+  });
+
+  it('clears `out` first, so a reused array does not accumulate', () => {
+    const out = ['stale'];
+    getRegistryTableKeys(out, createKeyedTable<string>('r', 'none'));
+
+    expect(out).toEqual([]);
+  });
+
+  it('names an ordinal table by vocabulary and a slot by its registry id', () => {
+    const ordinal = createOrdinalTable<string>('swfTags', 'none', ['Tag0', 'Tag1']);
+    const outOrdinal: string[] = [];
+    getRegistryTableKeys(outOrdinal, { ...ordinal, entries: [null, 'one'] });
+    expect(outOrdinal).toEqual(['Tag1']);
+
+    const outSlot: string[] = [];
+    getRegistryTableKeys(outSlot, {
+      entry: { state: RegistryEntryState.Bound, value: 'x' },
+      onMiss: 'none',
+      registry: 'shapeRasterizer',
+      shape: 'slot',
+    });
+    expect(outSlot).toEqual(['shapeRasterizer']);
+  });
+});
+
+describe('hasRegistryTableEntry', () => {
+  it('is FALSE on a tombstone, matching what get answers', () => {
+    const table = withRegistryTableTombstone(createKeyedTable<string>('r', 'none'), 'a');
+
+    expect(hasRegistryTableEntry(table, 'a')).toBe(false);
+    expect(getRegistryTableEntry(table, 'a')).toBeNull();
+  });
+
+  it('is true for a bound key and false for an unknown one', () => {
+    const table = withRegistryTableEntry(createKeyedTable<string>('r', 'none'), 'a', 'v');
+
+    expect(hasRegistryTableEntry(table, 'a')).toBe(true);
+    expect(hasRegistryTableEntry(table, 'b')).toBe(false);
+  });
+});
+
+describe('withoutRegistryTableEntry', () => {
+  it('leaves NO opinion — the key is absent, not tombstoned', () => {
+    const table = withoutRegistryTableEntry(
+      withRegistryTableEntry(createKeyedTable<string>('r', 'none'), 'a', 'v'),
+      'a',
+    );
+
+    expect(table.entries.has('a')).toBe(false);
+  });
+
+  it('does not mutate the table it was given', () => {
+    const before = withRegistryTableEntry(createKeyedTable<string>('r', 'none'), 'a', 'v');
+    withoutRegistryTableEntry(before, 'a');
+
+    expect(getRegistryTableEntry(before, 'a')).toBe('v');
+  });
+});
+
+describe('withRegistryTableEntry', () => {
+  it('returns a REPLACEMENT and mutates nothing — the persistence contract', () => {
+    // This is why it is not named set*: the input is untouched and the caller must assign the result.
+    const before = createKeyedTable<string>('r', 'none');
+    const after = withRegistryTableEntry(before, 'a', 'v');
+
+    expect(before.entries.size).toBe(0);
+    expect(getRegistryTableEntry(after, 'a')).toBe('v');
+    expect(after).not.toBe(before);
+  });
+
+  it('is last-write-wins for a key', () => {
+    const table = withRegistryTableEntry(
+      withRegistryTableEntry(createKeyedTable<string>('r', 'none'), 'a', '1'),
+      'a',
+      '2',
+    );
+
+    expect(getRegistryTableEntry(table, 'a')).toBe('2');
+  });
+});
+
+describe('withRegistryTableTombstone', () => {
+  it('stores an explicit omission rather than removing the key', () => {
+    const table = withRegistryTableTombstone(createKeyedTable<string>('r', 'none'), 'a');
+
+    expect(table.entries.has('a')).toBe(true);
+    expect(table.entries.get('a')).toEqual({ state: RegistryEntryState.Tombstoned });
+  });
+
+  it('does not mutate the table it was given', () => {
+    const before = createKeyedTable<string>('r', 'none');
+    withRegistryTableTombstone(before, 'a');
+
+    expect(before.entries.size).toBe(0);
+  });
+});