@ecsia/core 0.1.0

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAGtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAE5D,qBAAa,iBAAiB;;gBAQhB,GAAG,OAAO,EAAE,SAAS,OAAO,EAAE;IAG1C,QAAQ,CAAC,UAAU,EAAE,SAAS,YAAY,CAAC,MAAM,CAAC,EAAE,GAAG,IAAI;IAU3D;;;;OAIG;IACH,gBAAgB,IAAI,WAAW;IAM/B;;;;;OAKG;IACH,iBAAiB,CAAC,GAAG,EAAE,YAAY,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,WAAW,GAAG,IAAI;IAMnE,IAAI,CAAC,GAAG,EAAE,YAAY,CAAC,MAAM,CAAC,GAAG,WAAW,GAAG,SAAS;IAIxD,KAAK,CAAC,EAAE,EAAE,WAAW,GAAG,YAAY,CAAC,MAAM,CAAC,GAAG,SAAS;IAIxD,iFAAiF;IACjF,IAAI,eAAe,IAAI,MAAM,CAE5B;CACF;AAED,YAAY,EAAE,gBAAgB,EAAE,CAAA"}

package/dist/registry.js

@@ -0,0 +1,58 @@
+// The component registry the world owns. Mints dense
+// ComponentIds from FIRST_USER_COMPONENT_ID in createWorld({ components }) declaration order, wires
+// each def's accessor factory, and exposes id↔def lookup. Column-set lifecycle moved to the storage
+// module at (each real archetype owns its own ColumnSets); the registry no longer holds a
+// (archetypeId, componentId) column cache or act as the accessor resolver.
+import { FIRST_USER_COMPONENT_ID } from './ids.js';
+import { registerComponentId } from './component/index.js';
+export class ComponentRegistry {
+    #nextId = FIRST_USER_COMPONENT_ID;
+    #byDef = new Map();
+    #byId = [];
+    // The legacy (buffers, world) constructor args are no longer used by the registry (storage owns
+    // column-set lifecycle at ); they are accepted and ignored so call sites that only mint ids
+    // through `new ComponentRegistry(buffers, world).register(...)` keep compiling.
+    constructor(..._legacy) { }
+    // Deterministic dense id assignment in createWorld({ components }) declaration order.
+    register(components) {
+        for (const def of components) {
+            const id = this.#nextId;
+            this.#nextId += 1;
+            registerComponentId(def, id);
+            this.#byDef.set(def, id);
+            this.#byId[id] = def;
+        }
+    }
+    /**
+     * Mint the next dense ComponentId WITHOUT binding a def (allocSyntheticComponentId).
+     * Pair/presence/overflow ids draw from the SAME dense space as ordinary
+     * components so storage, queries, and the bitmask treat them identically. Serial / main-thread.
+     */
+    allocSyntheticId() {
+        const id = this.#nextId;
+        this.#nextId += 1;
+        return id;
+    }
+    /**
+     * Intern a synthetic ComponentDef (a relation presence/overflow def, or a per-pair def) at an id
+     * already minted by `allocSyntheticId`, so `defOf`/`idOf` resolve it and storage can build its
+     * ColumnSet. Serial / main-thread; relations is the only caller (the acyclic boundary holds —
+     * the world exposes this through a seam, core never imports relations).
+     */
+    registerSynthetic(def, id) {
+        registerComponentId(def, id);
+        this.#byDef.set(def, id);
+        this.#byId[id] = def;
+    }
+    idOf(def) {
+        return this.#byDef.get(def);
+    }
+    defOf(id) {
+        return this.#byId[id];
+    }
+    /**: seeds the bitmask/sigWords fixed stride = ceil(nextComponentId/32) ( C4). */
+    get nextComponentId() {
+        return this.#nextId;
+    }
+}
+//# sourceMappingURL=registry.js.map

package/dist/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,oGAAoG;AACpG,oGAAoG;AACpG,0FAA0F;AAC1F,2EAA2E;AAG3E,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAA;AAClD,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAG1D,MAAM,OAAO,iBAAiB;IAC5B,OAAO,GAAW,uBAA4C,CAAA;IACrD,MAAM,GAAG,IAAI,GAAG,EAAqC,CAAA;IACrD,KAAK,GAA2B,EAAE,CAAA;IAE3C,gGAAgG;IAChG,4FAA4F;IAC5F,gFAAgF;IAChF,YAAY,GAAG,OAA2B,IAAG,CAAC;IAE9C,sFAAsF;IACtF,QAAQ,CAAC,UAA2C;QAClD,KAAK,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;YAC7B,MAAM,EAAE,GAAG,IAAI,CAAC,OAAsB,CAAA;YACtC,IAAI,CAAC,OAAO,IAAI,CAAC,CAAA;YACjB,mBAAmB,CAAC,GAAG,EAAE,EAAE,CAAC,CAAA;YAC5B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,CAAA;YACxB,IAAI,CAAC,KAAK,CAAC,EAAY,CAAC,GAAG,GAAG,CAAA;QAChC,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,gBAAgB;QACd,MAAM,EAAE,GAAG,IAAI,CAAC,OAAsB,CAAA;QACtC,IAAI,CAAC,OAAO,IAAI,CAAC,CAAA;QACjB,OAAO,EAAE,CAAA;IACX,CAAC;IAED;;;;;OAKG;IACH,iBAAiB,CAAC,GAAyB,EAAE,EAAe;QAC1D,mBAAmB,CAAC,GAAG,EAAE,EAAE,CAAC,CAAA;QAC5B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,CAAA;QACxB,IAAI,CAAC,KAAK,CAAC,EAAY,CAAC,GAAG,GAAG,CAAA;IAChC,CAAC;IAED,IAAI,CAAC,GAAyB;QAC5B,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;IAC7B,CAAC;IAED,KAAK,CAAC,EAAe;QACnB,OAAO,IAAI,CAAC,KAAK,CAAC,EAAY,CAAC,CAAA;IACjC,CAAC;IAED,iFAAiF;IACjF,IAAI,eAAe;QACjB,OAAO,IAAI,CAAC,OAAO,CAAA;IACrB,CAAC;CACF"}

package/dist/serialize-surface.d.ts

@@ -0,0 +1,170 @@
+import type { ComponentId, EntityHandle, FieldDescriptor, RelationId, StorageStrategy } from '@ecsia/schema';
+import type { Column, RuntimeCapabilities } from './memory/index.js';
+/**
+ * One persisted structural op (Create/Destroy/ComponentAdd/ComponentRemove/AddPair/RemovePair/
+ * SetPayload) the delta serializer reads from the since-T structural journal.
+ * `kind` is the SHARED structural-op ordinal (= reactivity ShapeKind = serialization
+ * DeltaOp). Handles are FULL portable handles; `componentId` is a user id (Add/Remove) or a synthetic
+ * pair id (AddPair/RemovePair); `target` is the full pair-target handle (0 when not a pair op).
+ */
+export interface SerializeStructuralRecord {
+    readonly tick: number;
+    readonly kind: number;
+    readonly handle: number;
+    readonly componentId: number;
+    readonly target: number;
+}
+/** One column-bearing component's columns on a hot archetype, with its field descriptors. */
+export interface SerializeComponentColumns {
+    readonly componentId: ComponentId;
+    /** One Column per column-backed field (object fields contribute no column). */
+    readonly columns: readonly Column[];
+    /** The resolved field descriptors for the column-backed fields (parallel to `columns`). */
+    readonly fields: readonly FieldDescriptor[];
+}
+/** A hot archetype's serializable view: identity, signature, occupants, and column-bearing members. */
+export interface SerializeArchetype {
+    readonly id: number;
+    /** The sorted canonical signature (ComponentIds, including tag/pair/presence ids). */
+    readonly signature: readonly number[];
+    readonly count: number;
+    /** rows[r] = the FULL EntityHandle occupying row r (memory-buffers ). */
+    readonly rows: Uint32Array;
+    /** Column-bearing components only (tags skipped — ). */
+    readonly components: readonly SerializeComponentColumns[];
+}
+/**
+ * One rich (sidecar-backed) field across the registered component set. The
+ * snapshot/delta JSON sidecar section enumerates these — CRITICALLY independent of `SerializeArchetype`,
+ * because `archetypeView`/`SerializeComponentColumns` skip no-ColumnSet components and strip `ctor===null`
+ * fields, so a rich-ONLY component (e.g. `{ name: 'string' }`) never appears in `a.components`. The
+ * writer joins `a.signature ∩ richFields()` per entity rather than reading `a.components`.
+ */
+export interface SerializeRichField {
+    readonly componentId: ComponentId;
+    /** The field's index in `def.fields` (declaration order) — parallel on producer + receiver. */
+    readonly fieldIndex: number;
+    readonly name: string;
+    readonly kind: 'string' | 'object';
+}
+/** Component-registry metadata for the snapshot registry section. */
+export interface SerializeComponentMeta {
+    readonly name: string;
+    readonly id: ComponentId;
+    readonly fieldCount: number;
+    readonly storage: StorageStrategy;
+}
+/** One logical live relation pair. */
+export interface SerializePair {
+    readonly subject: EntityHandle;
+    readonly relationId: RelationId;
+    /** The target handle, or null for a cleared exclusive target. */
+    readonly target: EntityHandle | null;
+    /** Payload field values keyed by field name, or undefined for tag relations. */
+    readonly payload: Record<string, unknown> | undefined;
+}
+/** Relation metadata + live-pair enumeration + re-apply, provided by @ecsia/relations ( seam). */
+export interface SerializeRelationProvider {
+    /** Dense relation metadata, in registration (relationId-ascending) order. */
+    relations(): readonly {
+        readonly name: string;
+        readonly id: RelationId;
+        readonly exclusive: boolean;
+        readonly hasPayload: boolean;
+        readonly presenceId: ComponentId;
+    }[];
+    /** Every live pair across all relations, in deterministic (relationId, subject, target) order. */
+    livePairs(): readonly SerializePair[];
+    /** Re-establish a pair on deserialize (re-mints the receiver-local pair id). */
+    addPair(subject: EntityHandle, relationId: RelationId, target: EntityHandle | null, payload: Record<string, unknown> | undefined): void;
+    /** Map a synthetic pair ComponentId back to its logical RelationId (delta structural pair records). */
+    relationIdOfPair(pairId: ComponentId): RelationId | undefined;
+    /**
+     * Read a live pair's CURRENT payload by logical (subject, relationId, target), or undefined for a tag
+     * relation / absent pair. The delta structural section reads this at emit time so PairAdd/PairPayload
+     * records carry values-on-add.
+     */
+    pairPayloadOf(subject: EntityHandle, relationId: RelationId, target: EntityHandle): Record<string, unknown> | undefined;
+    /** Tear down a pair on a delta-apply receiver (PairRemove). */
+    removePair(subject: EntityHandle, relationId: RelationId, target: EntityHandle): void;
+}
+/** The full surface @ecsia/serialization drives. All members are serial / main-thread. */
+export interface SerializationSurface {
+    /** FNV-1a hash of the canonical (componentName, fieldName, token)* + relation names. */
+    schemaHash(): number;
+    /** Registry component metadata in dense-id order (real user components only; not synthetic). */
+    components(): readonly SerializeComponentMeta[];
+    /** A registered component's resolved field descriptors (for payload encode/decode by name). */
+    fieldsOf(id: ComponentId): readonly FieldDescriptor[] | undefined;
+    /** Resolve a component id by registered name (deserialize id-remap-by-name). */
+    componentIdByName(name: string): ComponentId | undefined;
+    /** Number of registered component types at snapshot time (sanity check). */
+    numComponentTypes(): number;
+    /** Hot archetypes with >=1 row, in id-ascending order. */
+    archetypes(): readonly SerializeArchetype[];
+    /** Relation provider, or undefined in a relation-free world. */
+    relations(): SerializeRelationProvider | undefined;
+    /**
+     * Rich-field descriptors across ALL registered components, in (componentId, fieldIndex) order. The
+     * snapshot/delta rich-value walk MUST use this, NOT `archetypes()[].components`, which cannot surface
+     * rich-only components. Empty in a world with no `'string'`/`object<T>` fields.
+     */
+    richFields(): readonly SerializeRichField[];
+    /**
+     * Read a live entity's rich value by (handle, componentId, fieldIndex). Returns the field default for a
+     * never-written / recycled slot (RF-HYGIENE). Returns `undefined` for an unknown column or dead handle.
+     */
+    richValueOf(handle: EntityHandle, componentId: ComponentId, fieldIndex: number): unknown;
+    /**
+     * Whether a live entity has a WRITTEN rich value (vs the lazy default) at (handle, componentId,
+     * fieldIndex). The snapshot/delta writers emit only present values — a
+     * default/empty slot is skipped and re-defaulted on the receiver.
+     */
+    richIsPresent(handle: EntityHandle, componentId: ComponentId, fieldIndex: number): boolean;
+    /**
+     * Write a rich value on a deserialize/apply receiver. Routes through the sidecar AND `trackWrite` so the
+     * loaded value is change-tracked identically to a live write (a subsequent delta from the receiver picks
+     * it up). No-op for a dead handle / unknown column.
+     */
+    setRichValue(handle: EntityHandle, componentId: ComponentId, fieldIndex: number, value: unknown): void;
+    /**
+     * Turn on the persistent structural journal: the since-T STRUCTURAL source a
+     * delta serializer needs. Idempotent; the structural twin of enabling changeVersion stamping. Call
+     * once at delta-serializer construction so subsequent structural ops are journaled.
+     */
+    enableStructuralJournal(): void;
+    /**
+     * /: the structural ops committed with tick > since, in commit order, as portable
+     * full-handle records. `gap` is true when `since` predates the bounded journal's live window (the
+     * caller must resync from a snapshot — the no-partial-apply delta-gap rule).
+     */
+    drainStructuralSince(since: number): {
+        records: readonly SerializeStructuralRecord[];
+        gap: boolean;
+    };
+    /** Map a synthetic pair ComponentId to its logical RelationId (for delta structural pair records). */
+    relationIdOfPair(pairId: ComponentId): RelationId | undefined;
+    /** Spawn a fresh entity (PASS 1 remap-table build). */
+    spawn(): EntityHandle;
+    /** Place a live handle into the target signature in ONE migration. */
+    spawnInto(handle: EntityHandle, componentIds: readonly ComponentId[]): void;
+    /** Remove the given components from `handle` in ONE migration (delta apply: ComponentRemove). */
+    removeComponents(handle: EntityHandle, componentIds: readonly ComponentId[]): void;
+    /** Destroy a live entity (delta apply: EntityDestroy). Idempotent on a dead handle. */
+    despawn(handle: EntityHandle): void;
+    /** The (hot) ColumnSet columns + row for `componentId` on `handle`, or null if absent/cold/tag. */
+    columnsOf(handle: EntityHandle, componentId: ComponentId): {
+        columns: readonly Column[];
+        fields: readonly FieldDescriptor[];
+        row: number;
+    } | null;
+    /** Despawn every alive entity (mode:'replace' precondition, / world.clear). */
+    clearAll(): void;
+    /** Count of currently-alive entities (mode:'replace' empty-check). */
+    aliveCount(): number;
+    readonly indexBits: number;
+    handleIndex(handle: EntityHandle): number;
+    /** Frozen runtime capabilities (memory-buffers ) for the worker bootstrap manifest. */
+    capabilities(): RuntimeCapabilities;
+}
+//# sourceMappingURL=serialize-surface.d.ts.map

package/dist/serialize-surface.d.ts.map

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

package/dist/serialize-surface.js

@@ -0,0 +1,6 @@
+// The internal seam @ecsia/serialization reads/writes through, exposed on World as `__serialize`.
+// Keeps the dependency direction acyclic: serialization imports @ecsia/core for this surface; core
+// NEVER imports serialization. Everything here is serial / main-thread (snapshots run at a flush
+// point). The world wires a concrete implementation in createWorld.
+export {};
+//# sourceMappingURL=serialize-surface.js.map

package/dist/serialize-surface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize-surface.js","sourceRoot":"","sources":["../src/serialize-surface.ts"],"names":[],"mappings":"AAAA,kGAAkG;AAClG,mGAAmG;AACnG,iGAAiG;AACjG,oEAAoE"}

package/dist/storage/archetype.d.ts

@@ -0,0 +1,38 @@
+import type { ComponentId, ComponentDef, Schema } from '@ecsia/schema';
+import type { ArchetypeId } from '@ecsia/schema';
+import type { Buffers, Column } from '../memory/index.js';
+import type { AccessorWorld, ColumnSet } from '../component/index.js';
+import type { Signature } from './signature.js';
+/** Synthetic component id keying each archetype's row-list column (never in any signature). */
+declare const ROWLIST_COMPONENT_ID = 4294967294;
+export interface Archetype {
+    readonly id: ArchetypeId;
+    readonly signature: Signature;
+    readonly sigWords: Uint32Array;
+    readonly hash: number;
+    /** componentId → its ColumnSet. Hot archetypes only; tag/cold archetypes leave it empty. */
+    readonly columnSets: Map<ComponentId, ColumnSet>;
+    /** Dense entity-row list column: rows[r] = the FULL EntityHandle occupying row r. */
+    rowsColumn: Column | null;
+    rows: Uint32Array;
+    count: number;
+    /** Lazy edge cache keyed by single ComponentId. */
+    readonly edges: Map<ComponentId, {
+        add?: Archetype;
+        remove?: Archetype;
+    }>;
+    /** Fragmentation policy state. */
+    cold: boolean;
+    lastAccessTick: number;
+}
+export interface ArchetypeColumnDeps {
+    readonly buffers: Buffers;
+    readonly accessorWorld: AccessorWorld;
+    readonly initialCapacity: number;
+    defOf(c: ComponentId): ComponentDef<Schema> | undefined;
+}
+/** Allocate the row-list column + one ColumnSet per column-bearing component (hot archetype only). */
+export declare function attachHotColumns(arch: Archetype, deps: ArchetypeColumnDeps): void;
+export declare function makeArchetype(id: ArchetypeId, sig: Signature, hash: number, stride: number, tick: number, cold: boolean): Archetype;
+export { ROWLIST_COMPONENT_ID };
+//# sourceMappingURL=archetype.d.ts.map

package/dist/storage/archetype.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archetype.d.ts","sourceRoot":"","sources":["../../src/storage/archetype.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAChD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAGzD,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAoB,MAAM,uBAAuB,CAAA;AACvF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAG/C,+FAA+F;AAC/F,QAAA,MAAM,oBAAoB,aAAc,CAAA;AAIxC,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAA;IACxB,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAA;IAC7B,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAA;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IAErB,4FAA4F;IAC5F,QAAQ,CAAC,UAAU,EAAE,GAAG,CAAC,WAAW,EAAE,SAAS,CAAC,CAAA;IAEhD,qFAAqF;IACrF,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,IAAI,EAAE,WAAW,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IAEb,mDAAmD;IACnD,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,WAAW,EAAE;QAAE,GAAG,CAAC,EAAE,SAAS,CAAC;QAAC,MAAM,CAAC,EAAE,SAAS,CAAA;KAAE,CAAC,CAAA;IAEzE,kCAAkC;IAClC,IAAI,EAAE,OAAO,CAAA;IACb,cAAc,EAAE,MAAM,CAAA;CACvB;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAA;IACrC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;IAChC,KAAK,CAAC,CAAC,EAAE,WAAW,GAAG,YAAY,CAAC,MAAM,CAAC,GAAG,SAAS,CAAA;CACxD;AAED,sGAAsG;AACtG,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,mBAAmB,GAAG,IAAI,CAoBjF;AAED,wBAAgB,aAAa,CAAC,EAAE,EAAE,WAAW,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,SAAS,CAcnI;AAED,OAAO,EAAE,oBAAoB,EAAE,CAAA"}

package/dist/storage/archetype.js

@@ -0,0 +1,47 @@
+// The archetype table: a ColumnSet per column-bearing component in the
+// signature + a dense entity-row list. Tag / zero-field components contribute NO ColumnSet
+// (presence is pure signature membership). The rows list is itself a u32 column allocated
+// through Buffers so it grows under the same length-tracking protocol as data columns.
+import { columnKey, makeColumnLayout } from '../memory/index.js';
+import { buildColumnSet } from '../component/index.js';
+import { buildSigWords } from './signature.js';
+/** Synthetic component id keying each archetype's row-list column (never in any signature). */
+const ROWLIST_COMPONENT_ID = 0xffff_fffe;
+const ROW_LAYOUT = makeColumnLayout('u32', 1, 0);
+/** Allocate the row-list column + one ColumnSet per column-bearing component (hot archetype only). */
+export function attachHotColumns(arch, deps) {
+    const { buffers, accessorWorld, initialCapacity, defOf } = deps;
+    const rowsKey = columnKey(arch.id, ROWLIST_COMPONENT_ID, 0);
+    const rowsColumn = buffers.column(rowsKey, ROW_LAYOUT, initialCapacity);
+    arch.rowsColumn = rowsColumn;
+    arch.rows = rowsColumn.view;
+    for (let i = 0; i < arch.signature.length; i++) {
+        const c = arch.signature[i];
+        const def = defOf(c);
+        if (def === undefined)
+            continue; // pair/synthetic id with no registered def yet (relations)
+        const rt = def;
+        // A pure tag (no columns AND no rich fields) gets no ColumnSet. A rich-only or mixed component DOES
+        // get one — its accessor carries the sidecar getters/setters even with zero columns.
+        if (rt.columnLayouts.length === 0 && !rt.hasRichFields)
+            continue;
+        arch.columnSets.set(c, buildColumnSet({ buffers, archetypeId: arch.id, def, world: accessorWorld, initialCapacity }));
+    }
+}
+export function makeArchetype(id, sig, hash, stride, tick, cold) {
+    return {
+        id,
+        signature: sig,
+        sigWords: buildSigWords(sig, stride),
+        hash,
+        columnSets: new Map(),
+        rowsColumn: null,
+        rows: new Uint32Array(0),
+        count: 0,
+        edges: new Map(),
+        cold,
+        lastAccessTick: tick,
+    };
+}
+export { ROWLIST_COMPONENT_ID };
+//# sourceMappingURL=archetype.js.map

package/dist/storage/archetype.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"archetype.js","sourceRoot":"","sources":["../../src/storage/archetype.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,2FAA2F;AAC3F,0FAA0F;AAC1F,uFAAuF;AAKvF,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAGtD,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAE9C,+FAA+F;AAC/F,MAAM,oBAAoB,GAAG,WAAW,CAAA;AAExC,MAAM,UAAU,GAAG,gBAAgB,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;AA+BhD,sGAAsG;AACtG,MAAM,UAAU,gBAAgB,CAAC,IAAe,EAAE,IAAyB;IACzE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,KAAK,EAAE,GAAG,IAAI,CAAA;IAC/D,MAAM,OAAO,GAAG,SAAS,CAAC,IAAI,CAAC,EAAY,EAAE,oBAAoB,EAAE,CAAC,CAAC,CAAA;IACrE,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,UAAU,EAAE,eAAe,CAAC,CAAA;IACvE,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;IAC5B,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC,IAAmB,CAAA;IAE1C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC/C,MAAM,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAA0B,CAAA;QACpD,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;QACpB,IAAI,GAAG,KAAK,SAAS;YAAE,SAAQ,CAAC,2DAA2D;QAC3F,MAAM,EAAE,GAAG,GAA+B,CAAA;QAC1C,oGAAoG;QACpG,qFAAqF;QACrF,IAAI,EAAE,CAAC,aAAa,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,aAAa;YAAE,SAAQ;QAChE,IAAI,CAAC,UAAU,CAAC,GAAG,CACjB,CAAC,EACD,cAAc,CAAC,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,CAAC,EAAY,EAAE,GAAG,EAAE,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,CAAC,CACxG,CAAA;IACH,CAAC;AACH,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,EAAe,EAAE,GAAc,EAAE,IAAY,EAAE,MAAc,EAAE,IAAY,EAAE,IAAa;IACtH,OAAO;QACL,EAAE;QACF,SAAS,EAAE,GAAG;QACd,QAAQ,EAAE,aAAa,CAAC,GAAG,EAAE,MAAM,CAAC;QACpC,IAAI;QACJ,UAAU,EAAE,IAAI,GAAG,EAAE;QACrB,UAAU,EAAE,IAAI;QAChB,IAAI,EAAE,IAAI,WAAW,CAAC,CAAC,CAAC;QACxB,KAAK,EAAE,CAAC;QACR,KAAK,EAAE,IAAI,GAAG,EAAE;QAChB,IAAI;QACJ,cAAc,EAAE,IAAI;KACrB,CAAA;AACH,CAAC;AAED,OAAO,EAAE,oBAAoB,EAAE,CAAA"}

package/dist/storage/cold-store.d.ts

@@ -0,0 +1,41 @@
+import type { ComponentId, ComponentDef, Schema } from '@ecsia/schema';
+import type { ArchetypeId } from '@ecsia/schema';
+import type { Buffers } from '../memory/index.js';
+import type { AccessorWorld, ColumnSet } from '../component/index.js';
+declare const COLD_ARCHETYPE_ID = 4294967040;
+export interface ColdStore {
+    /** componentId → a packed SoA block (one ColumnSet per component TYPE, not per archetype). */
+    readonly blocks: Map<ComponentId, ColumnSet>;
+    /** (entityIndex, componentId) → row in that component's block. key = entityIndex * SCALE + componentId. */
+    readonly rowOf: Map<number, number>;
+    /** entityIndex → its cold archetype id (so resolveLocation still yields an ArchetypeId). */
+    readonly archOf: Map<number, ArchetypeId>;
+    /** entityIndex → the full EntityHandle occupying the cold slot (for promotion's hot row list). */
+    readonly handleOf: Map<number, number>;
+    /** Next free row per component block. */
+    readonly nextRow: Map<ComponentId, number>;
+    /** Reclaimed rows per component block, reused before advancing nextRow (prevents leak). */
+    readonly freeRows: Map<ComponentId, number[]>;
+}
+export declare function makeColdStore(): ColdStore;
+export interface ColdDeps {
+    readonly buffers: Buffers;
+    readonly accessorWorld: AccessorWorld;
+    readonly initialCapacity: number;
+    defOf(c: ComponentId): ComponentDef<Schema> | undefined;
+}
+declare function coldKey(entityIndex: number, componentId: number): number;
+export declare function blockFor(cold: ColdStore, c: ComponentId, deps: ColdDeps): ColumnSet | null;
+/** Reserve a cold row for `componentId` under `entityIndex`, growing the block as needed. */
+export declare function coldAllocRow(cold: ColdStore, entityIndex: number, c: ComponentId, deps: ColdDeps): number;
+/** The cold block row for (entityIndex, componentId), or -1 if absent. */
+export declare function coldRowOf(cold: ColdStore, entityIndex: number, c: ComponentId): number;
+/**
+ * Reclaim the cold rows this entity holds for the components in `comps`, returning each to its
+ * block's free-list. Stale (index,componentId) mappings would otherwise leak monotonically and
+ * survive generational index reuse. When `dropEntity` (the entity is leaving the cold store
+ * entirely — despawn or promotion to a hot archetype) also drop its archOf/handleOf entries.
+ */
+export declare function coldReclaim(cold: ColdStore, entityIndex: number, comps: Iterable<number>, dropEntity?: boolean): void;
+export { COLD_ARCHETYPE_ID, coldKey };
+//# sourceMappingURL=cold-store.d.ts.map

package/dist/storage/cold-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cold-store.d.ts","sourceRoot":"","sources":["../../src/storage/cold-store.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAChD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AACjD,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AAIrE,QAAA,MAAM,iBAAiB,aAAc,CAAA;AAErC,MAAM,WAAW,SAAS;IACxB,8FAA8F;IAC9F,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,WAAW,EAAE,SAAS,CAAC,CAAA;IAC5C,2GAA2G;IAC3G,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,4FAA4F;IAC5F,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;IACzC,kGAAkG;IAClG,QAAQ,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACtC,yCAAyC;IACzC,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,WAAW,EAAE,MAAM,CAAC,CAAA;IAC1C,2FAA2F;IAC3F,QAAQ,CAAC,QAAQ,EAAE,GAAG,CAAC,WAAW,EAAE,MAAM,EAAE,CAAC,CAAA;CAC9C;AAID,wBAAgB,aAAa,IAAI,SAAS,CASzC;AAED,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAA;IACrC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;IAChC,KAAK,CAAC,CAAC,EAAE,WAAW,GAAG,YAAY,CAAC,MAAM,CAAC,GAAG,SAAS,CAAA;CACxD;AAED,iBAAS,OAAO,CAAC,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAEjE;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,IAAI,CAmB1F;AAED,6FAA6F;AAC7F,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,CAAC,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,GAAG,MAAM,CAgBzG;AAED,0EAA0E;AAC1E,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,CAAC,EAAE,WAAW,GAAG,MAAM,CAEtF;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,SAAS,EACf,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,EACvB,UAAU,UAAO,GAChB,IAAI,CAkBN;AAED,OAAO,EAAE,iBAAiB,EAAE,OAAO,EAAE,CAAA"}

package/dist/storage/cold-store.js

@@ -0,0 +1,100 @@
+// The cold-archetype overflow store. When hotCount reaches
+// maxHotArchetypes, new archetypes are marked cold: they have NO dedicated columns; their entities
+// live in a shared SoA block keyed per component type (NOT per archetype). Membership still uses
+// the per-entity bitmask + signature, so has()/matching/iteration are transparent.
+//
+// This module is the cold-path SCAFFOLDING, built for correctness: per-component blocks allocated lazily via
+// Buffers.column, an (entityIndex, componentId) → row map, and an entityIndex → cold ArchetypeId
+// map so resolveLocation still yields an ArchetypeId. Relation-driven fragmentation is exercised at
+// explicit world.warm promotion is wired here.
+import { buildColumnSet } from '../component/index.js';
+const COLD_ARCHETYPE_ID = 0xffff_ff00; // synthetic archetype id keying every cold component block
+const KEY_SCALE = 0x1_0000_0000; // entityIndex occupies the high bits, componentId the low 32
+export function makeColdStore() {
+    return {
+        blocks: new Map(),
+        rowOf: new Map(),
+        archOf: new Map(),
+        handleOf: new Map(),
+        nextRow: new Map(),
+        freeRows: new Map(),
+    };
+}
+function coldKey(entityIndex, componentId) {
+    return entityIndex * KEY_SCALE + componentId;
+}
+export function blockFor(cold, c, deps) {
+    let block = cold.blocks.get(c);
+    if (block !== undefined)
+        return block;
+    const def = deps.defOf(c);
+    if (def === undefined)
+        return null;
+    const rt = def;
+    // Pure tag: no cold block. A rich-only/mixed component DOES get one so its accessor (carrying the
+    // sidecar getters) is resolvable cold; the 0-column block allocates no column storage.
+    if (rt.columnLayouts.length === 0 && !rt.hasRichFields)
+        return null;
+    block = buildColumnSet({
+        buffers: deps.buffers,
+        archetypeId: COLD_ARCHETYPE_ID,
+        def,
+        world: deps.accessorWorld,
+        initialCapacity: deps.initialCapacity,
+    });
+    cold.blocks.set(c, block);
+    cold.nextRow.set(c, 0);
+    return block;
+}
+/** Reserve a cold row for `componentId` under `entityIndex`, growing the block as needed. */
+export function coldAllocRow(cold, entityIndex, c, deps) {
+    const block = blockFor(cold, c, deps);
+    if (block === null)
+        return -1;
+    const free = cold.freeRows.get(c);
+    const reclaimed = free !== undefined && free.length > 0 ? free.pop() : undefined;
+    if (reclaimed !== undefined) {
+        cold.rowOf.set(coldKey(entityIndex, c), reclaimed);
+        return reclaimed;
+    }
+    const next = cold.nextRow.get(c) ?? 0;
+    for (const col of block.columns) {
+        if (next + 1 > col.capacity())
+            deps.buffers.grow(col, next + 1);
+    }
+    cold.nextRow.set(c, next + 1);
+    cold.rowOf.set(coldKey(entityIndex, c), next);
+    return next;
+}
+/** The cold block row for (entityIndex, componentId), or -1 if absent. */
+export function coldRowOf(cold, entityIndex, c) {
+    return cold.rowOf.get(coldKey(entityIndex, c)) ?? -1;
+}
+/**
+ * Reclaim the cold rows this entity holds for the components in `comps`, returning each to its
+ * block's free-list. Stale (index,componentId) mappings would otherwise leak monotonically and
+ * survive generational index reuse. When `dropEntity` (the entity is leaving the cold store
+ * entirely — despawn or promotion to a hot archetype) also drop its archOf/handleOf entries.
+ */
+export function coldReclaim(cold, entityIndex, comps, dropEntity = true) {
+    for (const cn of comps) {
+        const c = cn;
+        const key = coldKey(entityIndex, cn);
+        const row = cold.rowOf.get(key);
+        if (row === undefined)
+            continue;
+        cold.rowOf.delete(key);
+        let free = cold.freeRows.get(c);
+        if (free === undefined) {
+            free = [];
+            cold.freeRows.set(c, free);
+        }
+        free.push(row);
+    }
+    if (dropEntity) {
+        cold.archOf.delete(entityIndex);
+        cold.handleOf.delete(entityIndex);
+    }
+}
+export { COLD_ARCHETYPE_ID, coldKey };
+//# sourceMappingURL=cold-store.js.map

package/dist/storage/cold-store.js.map

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

package/dist/storage/index.d.ts

@@ -0,0 +1,10 @@
+export { ArchetypeStore, EMPTY_ARCHETYPE_ID, ARCHETYPE_NONE, } from './store.js';
+export type { RecordSurface, StorageDeps } from './store.js';
+export { Storage } from './storage.js';
+export type { StorageConfig, DefRegistry } from './storage.js';
+export type { Archetype } from './archetype.js';
+export type { ColdStore } from './cold-store.js';
+export { makeColdStore, coldRowOf, coldReclaim } from './cold-store.js';
+export type { Signature, MatchTerm } from './signature.js';
+export { canonicalize, sigEquals, sigHash, sigHas, sigWithAdded, sigWithRemoved, buildSigWords, signatureMatches, } from './signature.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/storage/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,cAAc,GACf,MAAM,YAAY,CAAA;AACnB,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAE5D,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAE9D,YAAY,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE/C,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAChD,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAEvE,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1D,OAAO,EACL,YAAY,EACZ,SAAS,EACT,OAAO,EACP,MAAM,EACN,YAAY,EACZ,cAAc,EACd,aAAa,EACb,gBAAgB,GACjB,MAAM,gBAAgB,CAAA"}

package/dist/storage/index.js

@@ -0,0 +1,5 @@
+export { ArchetypeStore, EMPTY_ARCHETYPE_ID, ARCHETYPE_NONE, } from './store.js';
+export { Storage } from './storage.js';
+export { makeColdStore, coldRowOf, coldReclaim } from './cold-store.js';
+export { canonicalize, sigEquals, sigHash, sigHas, sigWithAdded, sigWithRemoved, buildSigWords, signatureMatches, } from './signature.js';
+//# sourceMappingURL=index.js.map

package/dist/storage/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,cAAc,GACf,MAAM,YAAY,CAAA;AAGnB,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAMtC,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAGvE,OAAO,EACL,YAAY,EACZ,SAAS,EACT,OAAO,EACP,MAAM,EACN,YAAY,EACZ,cAAc,EACd,aAAa,EACb,gBAAgB,GACjB,MAAM,gBAAgB,CAAA"}

package/dist/storage/signature.d.ts

@@ -0,0 +1,27 @@
+import type { ComponentId } from '@ecsia/schema';
+/** Canonical, sorted, de-duplicated component ids. Owned (never aliased) per archetype. */
+export type Signature = Uint32Array & {
+    readonly __ecsiaSignature: unique symbol;
+};
+/** O(n) equality of two sorted signatures. */
+export declare function sigEquals(a: Signature, b: Signature): boolean;
+/** FNV-1a over the sorted ids → 32-bit hash for the archetype lookup map. */
+export declare function sigHash(a: Signature): number;
+/** Sort + de-dup an arbitrary id multiset into the canonical form ( holds). */
+export declare function canonicalize(ids: Iterable<ComponentId | number>): Signature;
+/** The neighbor signature reached by adding `c` (sorted insert). Idempotent if `c` already present. */
+export declare function sigWithAdded(sig: Signature, c: ComponentId): Signature;
+/** The neighbor signature reached by removing `c`. Returns `sig` unchanged if `c` is absent. */
+export declare function sigWithRemoved(sig: Signature, c: ComponentId): Signature;
+/** Packed membership words for fast bitwise-AND query matching. */
+export declare function buildSigWords(sig: Signature, stride: number): Uint32Array;
+/** Exact membership test against the sorted signature array, O(log |sig|). */
+export declare function sigHas(sig: Signature, c: ComponentId | number): boolean;
+/** One AND-term against a packed signature word. */
+export interface MatchTerm {
+    readonly wordIndex: number;
+    readonly mask: number;
+}
+/** Signature-AND helper the query module calls; exposed for testing. */
+export declare function signatureMatches(sigWords: Uint32Array, withW: readonly MatchTerm[], notW: readonly MatchTerm[], orW: readonly MatchTerm[]): boolean;
+//# sourceMappingURL=signature.d.ts.map

package/dist/storage/signature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature.d.ts","sourceRoot":"","sources":["../../src/storage/signature.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAEhD,2FAA2F;AAC3F,MAAM,MAAM,SAAS,GAAG,WAAW,GAAG;IAAE,QAAQ,CAAC,gBAAgB,EAAE,OAAO,MAAM,CAAA;CAAE,CAAA;AAElF,8CAA8C;AAC9C,wBAAgB,SAAS,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,OAAO,CAI7D;AAED,6EAA6E;AAC7E,wBAAgB,OAAO,CAAC,CAAC,EAAE,SAAS,GAAG,MAAM,CAO5C;AAED,+EAA+E;AAC/E,wBAAgB,YAAY,CAAC,GAAG,EAAE,QAAQ,CAAC,WAAW,GAAG,MAAM,CAAC,GAAG,SAAS,CAI3E;AAED,uGAAuG;AACvG,wBAAgB,YAAY,CAAC,GAAG,EAAE,SAAS,EAAE,CAAC,EAAE,WAAW,GAAG,SAAS,CAiBtE;AAED,gGAAgG;AAChG,wBAAgB,cAAc,CAAC,GAAG,EAAE,SAAS,EAAE,CAAC,EAAE,WAAW,GAAG,SAAS,CAoBxE;AAED,mEAAmE;AACnE,wBAAgB,aAAa,CAAC,GAAG,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW,CAOzE;AAED,8EAA8E;AAC9E,wBAAgB,MAAM,CAAC,GAAG,EAAE,SAAS,EAAE,CAAC,EAAE,WAAW,GAAG,MAAM,GAAG,OAAO,CAYvE;AAED,oDAAoD;AACpD,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED,wEAAwE;AACxE,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,WAAW,EACrB,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,IAAI,EAAE,SAAS,SAAS,EAAE,EAC1B,GAAG,EAAE,SAAS,SAAS,EAAE,GACxB,OAAO,CAKT"}