@oasys/oecs 0.4.0 → 0.5.0

package/dist/core/store/entity_index.d.cts

@@ -0,0 +1,108 @@
+/**
+ * Entity-index SAB region — `EntityID` → `(archetype_id, row, generation)`
+ * lookup table shared with the Zig sim. (#245 / Phase 4 PR 4B)
+ *
+ * Every hot fixed-update system that needs to resolve an `EntityID`
+ * held in a column (e.g. a component field that points at another
+ * entity → that entity's columns) has to do
+ * `entityId → archetype + row` translation. The plan forbids
+ * WASM-into-TS callbacks during `tick()` (§4 / §5.2), so the lookup
+ * tables must live in shared memory.
+ *
+ * Layout:
+ *
+ *   [ length:    u32 ]   high-water index (count of slots ever issued)
+ *   [ capacity:  u32 ]   backing-array length (slots × 1; not bytes)
+ *   [ _pad0:     u32 ]   alignment pad to 16 bytes
+ *   [ _pad1:     u32 ]   ───
+ *   [ generations[capacity]: i32 ]
+ *   [ archetypes[capacity]:  i32 ]
+ *   [ rows[capacity]:        i32 ]
+ *
+ * Sentinels:
+ *   - `generations[i] = 0` (INITIAL_GENERATION) for never-used slots.
+ *     Generation grows by 1 on every destroy; an `EntityID`'s generation
+ *     field matches `generations[index]` iff it's still alive.
+ *   - `archetypes[i] = -1` (UNASSIGNED) when the slot hasn't been placed
+ *     into an archetype, OR when the entity is destroyed.
+ *   - `rows[i]      = -1` (UNASSIGNED) on destroy / not-placed.
+ *
+ * Field width: i32 (signed) on the TS side so `-1` round-trips through
+ * `Int32Array` without unsigned coercion. Zig reads as i32 too — bit
+ * pattern is identical to u32 `0xFFFFFFFF` for the UNASSIGNED case, and
+ * for valid archetype_ids (bounded by `MAX_INDEX = 2^20`) the sign bit
+ * is never set, so signed/unsigned interpretation agrees.
+ *
+ * Region placement: between command ring and descriptor region so the
+ * offset is stable across descriptor / column-region growth (same
+ * property the command ring gets). Grow path (when entityHighWater
+ * exceeds `capacity`) uses `growColumnStore` — slow path, same as
+ * descriptor-region overflow.
+ *
+ * Reading from Zig: see `packages/sim/src/entity_index.zig` for the
+ * symmetric reader.
+ */
+/** Fixed bytes of the region header (length, capacity, two pad u32s for
+ * 16-byte alignment of the i32 arrays that follow). */
+export declare const ENTITY_INDEX_HEADER_BYTES = 16;
+/** Bytes per slot: three i32 columns. */
+export declare const ENTITY_INDEX_BYTES_PER_SLOT = 12;
+/** Byte offsets within the region header. Locked by the
+ * `entity_index.test.ts` golden bytes; any change here is a
+ * `SIM_ABI_VERSION` bump. */
+export declare const ENTITY_INDEX_HEADER_OFFSETS: {
+    readonly length: 0;
+    readonly capacity: 4;
+};
+/** Default initial slot count when the engine creates a Store. Matches
+ * `MAX_INDEX = (1 << 20) - 1 + 1 = 1_048_576` (the EntityID 20-bit index
+ * range, see `entity.ts`), so the region pre-sizes to the entire
+ * addressable entity space and `createEntity` can never run out under
+ * the default. 1M × 12 B ≈ 12 MiB SAB region — virtual memory only;
+ * physical pages allocate lazily via OS page-fault on first touch, so
+ * the typical 1000-entity workload pays for ~12 KiB physical even though the
+ * virtual reservation is 12 MiB.
+ *
+ * Tests / benches can pass a smaller `StoreOptions.entityIndexCapacity`
+ * to bench tighter reservations. A future PR will replace this with
+ * on-demand growth via `growColumnStore` so the default can drop. */
+export declare const ENTITY_INDEX_DEFAULT_CAPACITY: number;
+/** Total region bytes for `capacity` slots: header + 3 i32 columns. */
+export declare function entityIndexRegionBytes(capacity: number): number;
+/** Byte offset of the generations column within the region. */
+export declare function entityIndexGenerationsOff(regionOff: number): number;
+/** Byte offset of the archetype-id column. */
+export declare function entityIndexArchetypesOff(regionOff: number, capacity: number): number;
+/** Byte offset of the row column. */
+export declare function entityIndexRowsOff(regionOff: number, capacity: number): number;
+export declare class EntityIndexError extends Error {
+    constructor(message: string);
+}
+/** Initialise the region header at `regionOff`. Sets `length=0` and
+ * `capacity=<arg>`. The i32 arrays past the header are left untouched
+ * (callers normally allocate the region on a fresh, zero-initialised
+ * SAB; generation 0 is the INITIAL_GENERATION sentinel, archetype/row
+ * sentinels of 0 are caught by `length=0` so no read reaches them). */
+export declare function initEntityIndexRegion(view: DataView, regionOff: number, capacity: number): void;
+/** Read the region's current length (high-water index, ≤ capacity). */
+export declare function entityIndexLength(view: DataView, regionOff: number): number;
+/** Read the region's current capacity (backing-array length). */
+export declare function entityIndexCapacity(view: DataView, regionOff: number): number;
+/** Update the region's length (called from the engine's Store on every
+ * entity allocation that pushes `entityHighWater` past its previous
+ * value). */
+export declare function setEntityIndexLength(view: DataView, regionOff: number, length: number): void;
+/** Materialise the three Int32Array views over the region's column data
+ * for use by the engine's Store. The views live as long as the
+ * SharedArrayBuffer hasn't been reallocated — refresh on `view_stamp`
+ * bump (the engine's `_onBufferResized` callback).
+ *
+ * Three separate views (not a single struct-of-arrays object) because
+ * the engine's hot paths benefit from each being a direct typed-array
+ * read; V8 specialises `arr[i] = v` aggressively for typed arrays. */
+export declare function buildEntityIndexViews(buffer: ArrayBufferLike, regionOff: number, capacity: number): {
+    readonly generations: Int32Array;
+    readonly archetypes: Int32Array;
+    readonly rows: Int32Array;
+};
+//# sourceMappingURL=entity_index.d.ts.map

package/dist/core/store/event_ring.d.cts

@@ -0,0 +1,95 @@
+/**
+ * Event ring — SPSC ring buffer for ECS signal/event payloads shared
+ * between TS and the Zig sim. (#247 / Phase 4 PR 4C)
+ *
+ * Same byte layout as the command ring (`command_ring.ts`); the two
+ * could share a primitive but keeping them separate makes the
+ * direction of flow explicit: command ring is WASM→TS (structural
+ * intents to drain post-tick); event ring is bidirectional during
+ * `tick()` — Zig systems push events, TS readers (or other Zig
+ * systems) drain.
+ *
+ * Layout (identical to command ring):
+ *
+ *   [ write_head:    u32 ]   slot 0..N-1, monotonic (NOT slot-modulo)
+ *   [ read_head:     u32 ]   slot 0..N-1, monotonic
+ *   [ capacity:      u32 ]   slot count, power-of-two
+ *   [ overflow_flag: u32 ]   0 = OK; 1 = sticky overflow witness
+ *   [ slot 0:        16 B ]  opCode: u8, payload: [15]u8
+ *   [ slot 1:        16 B ]  ...
+ *
+ * Op codes: event-def IDs (assigned by `ECS.registerEvent()` at
+ * registration time; #247 plan §required-FFI). The 0 op-code is
+ * reserved as the empty-slot marker so a zero-initialised SAB does not
+ * appear to hold a valid event. Event-def registration starts numbering
+ * from 1 to honour this; the engine integration in 4D+ enforces it.
+ *
+ * SPSC contract (Phase 4 scope, single host thread):
+ *   - Producer: Zig sim `tick()` (post-4D) OR TS host (test producers /
+ *     existing JS-side emitters bridged into the ring).
+ *   - Consumer: TS host drain (post-4D) OR Zig system that reads
+ *     queued events from a sibling system.
+ *   - The two never run concurrently in Phase 4 (single host thread
+ *     orchestrates both). Phase 5's worker offload promotes the head
+ *     bumps to `Atomics.store`; that's an additive change without
+ *     altering the layout.
+ *
+ * Payload size: fixed 15 bytes per slot. Today's events all fit
+ * (e.g. a 12-byte 3-field event, a 4-byte 1-field event, a 0-field
+ * signal). Larger payloads require a separate variable-size ring
+ * design — out of scope here.
+ *
+ * Region placement: between the entity-index region and the descriptor
+ * region so its offset is stable across descriptor / column growth.
+ * `header.event_ring_off` (the field promoted out of `_reserved0` in
+ * #245's reservation) carries the offset; 0 means absent.
+ */
+/** Total bytes for the ring header. Matches command ring exactly. */
+export declare const EVENT_RING_HEADER_BYTES = 16;
+/** Fixed slot size — 1-byte opCode + 15-byte payload. Matches
+ * command ring exactly. */
+export declare const EVENT_RING_SLOT_BYTES = 16;
+/** Default ring capacity in slots. 256 × 16 B = 4 KiB of slot data
+ * plus 16 B header. Mirrors `COMMAND_RING_DEFAULT_CAPACITY_SLOTS`. */
+export declare const EVENT_RING_DEFAULT_CAPACITY_SLOTS = 256;
+/** Byte offsets within the ring header. Mirrored on the Zig side in
+ * `packages/sim/src/event_ring.zig` — keep in sync. */
+export declare const EVENT_RING_HEADER_OFFSETS: {
+    readonly write_head: 0;
+    readonly read_head: 4;
+    readonly capacity_slots: 8;
+    readonly overflow_flag: 12;
+};
+/** Op-code = `0` is reserved across the SAB layer as "empty slot"
+ * (see file header). Event-def IDs start at 1; `ECS.registerEvent`
+ * shifts to honour this when wiring SAB-backed channels in 4D+. */
+export declare const EVENT_OP_EMPTY = 0;
+/** Total bytes the ring occupies for `capacity_slots` slots. */
+export declare function eventRingBytes(capacitySlots: number): number;
+export declare class EventRingError extends Error {
+    constructor(message: string);
+}
+/** Initialise the ring header at `ringOff` in the SAB. Zeroes
+ * `write_head`, `read_head`, and `overflow_flag`; sets `capacity_slots`.
+ * Slot bytes are left as-is (callers normally allocate the ring on a
+ * fresh, zero-initialised SAB). */
+export declare function initEventRing(view: DataView, ringOff: number, capacitySlots: number): void;
+export declare function ringWriteHead(view: DataView, ringOff: number): number;
+export declare function ringReadHead(view: DataView, ringOff: number): number;
+export declare function ringCapacitySlots(view: DataView, ringOff: number): number;
+export declare function ringOverflow(view: DataView, ringOff: number): boolean;
+/** Pending event count = `(write_head - read_head) mod 2^32`. */
+export declare function pendingEventCount(view: DataView, ringOff: number): number;
+/** Push an event into the ring. Returns `false` on overflow and sets
+ * the (sticky) overflow flag. `opCode` must be > 0 — 0 is reserved as
+ * the empty-slot marker. Payload must be exactly 15 bytes. */
+export declare function pushEvent(view: DataView, ringOff: number, opCode: number, payload: Uint8Array): boolean;
+/** Read one event from the ring. Returns opCode (0 = empty/no event)
+ * and fills `outPayload` with 15 bytes. When 0 is returned,
+ * `outPayload` is untouched. */
+export declare function popEvent(view: DataView, ringOff: number, outPayload: Uint8Array): number;
+/** Drain every pending event, calling `handler` for each. Yields a
+ * freshly-copied 15-byte Uint8Array per event so handlers can hold the
+ * payload past the next iteration. Returns the count drained. */
+export declare function drainEventRing(view: DataView, ringOff: number, handler: (opCode: number, payload: Uint8Array) => void): number;
+//# sourceMappingURL=event_ring.d.ts.map

package/dist/core/store/extend.d.cts

@@ -0,0 +1,39 @@
+import { ArchetypeSpec, ColumnStore } from './column_store.cjs';
+import { BufferAllocator } from './allocator.cjs';
+import { ArchetypeGrowSpec } from './layout_ops.cjs';
+export interface ExtendPlan {
+    /** Archetypes to append. Each `archetype_id` MUST be absent from
+     * `old.archetypes`; collisions throw `StoreExtendError`. */
+    readonly newArchetypes: readonly ArchetypeSpec[];
+    /** Per-existing-archetype live row counts. Same shape as
+     * `GrowPlan.archetypes` so callers can reuse plan-building helpers.
+     * Omitted or `0` ⇒ no rows to copy (the archetype is empty). */
+    readonly existing?: readonly ArchetypeGrowSpec[];
+}
+export interface ExtendResult {
+    readonly store: ColumnStore;
+    readonly oldViewStamp: number;
+    readonly newViewStamp: number;
+    /** True when the in-place fast path (#237 Option A) was taken: the SAB
+     * instance is reused, existing column TypedArray views are unchanged,
+     * and callers may skip `refreshViews` on every pre-existing
+     * Archetype. False when the slow path ran (fresh SAB or wasm-memory
+     * grow with detached views); callers MUST refresh every Archetype's
+     * SAB-backed columns from the returned `store` before reading them. */
+    readonly viewsPreserved: boolean;
+}
+export declare class StoreExtendError extends Error {
+    constructor(message: string);
+}
+/** Allocate a new SAB sized for `old` + `plan.newArchetypes`, copy
+ * existing rows, bump `view_stamp`.
+ *
+ * `allocator` (PR 3D / #234): pluggable buffer source forwarded into
+ * `createColumnStore`. When the allocator is `wasmMemoryAllocator`,
+ * `memory.grow` may detach `old`'s typed-array views before the copy
+ * runs — so live rows are snapshotted into heap `Uint8Array`s BEFORE the
+ * allocator call and restored into the new views afterwards. The cost
+ * is one extra heap allocation per live archetype-column; negligible
+ * compared to the SAB walk itself. */
+export declare function extendColumnStore(old: ColumnStore, plan: ExtendPlan, allocator?: BufferAllocator): ExtendResult;
+//# sourceMappingURL=extend.d.ts.map

package/dist/core/store/extend.d.ts

@@ -1,76 +1,6 @@
-import { ArchetypeGrowSpec } from './grow';
-import { ArchetypeSpec, CreateColumnStoreOptions, ColumnStore } from './column_store';
-import { BufferAllocator } from './allocator';
-import { StoreRegionOffsetField } from './store_regions';
-/**
- * Derive `CreateColumnStoreOptions` from an old ColumnStore so a slow-path realloc
- * preserves the same set of optional regions at the same byte offsets in the
- * new SAB. Without this, an extend / grow would silently drop a region — the
- * command ring's pending commands, every entity placement in the index, etc.
- * would be lost.
- *
- * Walks `STORE_PREFIX_REGIONS`: each present region's `readOptions` replays the
- * exact capacity the engine configured (regions may carry non-default sizes),
- * not just the default. Live state (write_head, length, …) is preserved
- * separately via `snapshotPrefixRegions`.
- *
- * Also re-applies the descriptor-region headroom policy
- * (`reservedDescriptorBytes`, #541). Unlike the prefix regions this is NOT
- * read from the SAB bytes — it's a JS-side policy carried on
- * `ColumnStoreInternal._reservedDescriptorBytes` — but it belongs here for the
- * same reason: without it the realloc'd store drops to zero descriptor
- * headroom and every later `extendColumnStore` takes the slow path forever.
- * Re-reserving the same margin (additive, see `planLayout`) keeps the #237
- * in-place fast path alive across reallocs.
- */
-export declare function optionsFromOld(old: ColumnStore): CreateColumnStoreOptions;
-/** A prefix-region snapshot: the live bytes of every present region from the
- * old SAB. `mechanism` is keyed by the `StoreHeader` field holding a mechanism
- * region's offset; `consumer` is keyed by `region_id` (consumer regions have no
- * named header field). Pairs `snapshotPrefixRegions` with
- * `restorePrefixRegions`. */
-export interface PrefixRegionSnapshot {
-    readonly mechanism: Map<StoreRegionOffsetField, Uint8Array>;
-    readonly consumer: Map<number, Uint8Array>;
-}
-/**
- * Snapshot the live bytes of every present region — both engine MECHANISM
- * regions (STORE_PREFIX_REGIONS) and CONSUMER regions (the region-table
- * directory) — from the old SAB BEFORE any allocator call that may detach
- * views. Each entry is a heap `Uint8Array` copy (via `slice()`) so it survives
- * an allocator-induced detach; `restorePrefixRegions` places it back at the
- * matching offset in the new SAB.
- *
- * Header bytes themselves are NOT snapshotted — `createColumnStore` writes the
- * header (and the region-table directory) from scratch with the correct
- * view_stamp (bumped after this call) and offsets.
- */
-export declare function snapshotPrefixRegions(old: ColumnStore): PrefixRegionSnapshot;
-/** Restore prefix-region byte snapshots into `newStore` at the matching
- * region offsets. Pairs with `snapshotPrefixRegions`. The new SAB's regions
- * were sized identically by `optionsFromOld`, so each snapshot lands at the
- * same length its source had — mechanism regions at their named header offset,
- * consumer regions at the offset the rebuilt region-table resolves their id to. */
-export declare function restorePrefixRegions(newStore: ColumnStore, snap: PrefixRegionSnapshot): void;
-/**
- * Snapshot per-archetype live column bytes from `old` BEFORE any
- * subsequent allocator call may detach the underlying typed-array views.
- * Returned shape: `{ archetype_id → Uint8Array[] }`, one entry per
- * column in `columnsInOrder`. Each `Uint8Array` is a fresh copy
- * (not a view) so it survives a `WebAssembly.Memory.grow`. Archetypes
- * with `row_count === 0` are omitted — nothing to copy.
- *
- * Shared with `growColumnStore`; both functions need the same
- * snapshot-before-allocate pattern under the wasm-memory allocator.
- */
-export declare function snapshotLiveColumns(old: ColumnStore, rowCountsById: Map<number, number>): Map<number, Uint8Array[]>;
-/**
- * Write per-archetype column snapshots produced by `snapshotLiveColumns`
- * into `newStore`'s column views. The snapshot's column ORDER must match
- * the new archetype's `columnsInOrder` (extend / grow guarantee this
- * because they carry the column spec forward unchanged).
- */
-export declare function restoreColumnSnapshots(newStore: ColumnStore, snapshots: Map<number, Uint8Array[]>): void;
+import { ArchetypeSpec, ColumnStore } from './column_store.js';
+import { BufferAllocator } from './allocator.js';
+import { ArchetypeGrowSpec } from './layout_ops.js';
 export interface ExtendPlan {
     /** Archetypes to append. Each `archetype_id` MUST be absent from
      * `old.archetypes`; collisions throw `StoreExtendError`. */

package/dist/core/store/extend.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extend.d.ts","sourceRoot":"","sources":["../../../src/core/store/extend.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAC;AAEhD,OAAO,EAMN,KAAK,aAAa,EAElB,KAAK,wBAAwB,EAC7B,KAAK,WAAW,EAEhB,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAQnD,OAAO,EAGN,KAAK,sBAAsB,EAC3B,MAAM,iBAAiB,CAAC;AAGzB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,WAAW,GAAG,wBAAwB,CAyCzE;AAED;;;;6BAI6B;AAC7B,MAAM,WAAW,oBAAoB;IACpC,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,sBAAsB,EAAE,UAAU,CAAC,CAAC;IAC5D,QAAQ,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CAC3C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,WAAW,GAAG,oBAAoB,CAsB5E;AAED;;;;mFAImF;AACnF,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAE,oBAAoB,GAAG,IAAI,CAc5F;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAClC,GAAG,EAAE,WAAW,EAChB,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAChC,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,CAAC,CAmB3B;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACrC,QAAQ,EAAE,WAAW,EACrB,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,CAAC,GAClC,IAAI,CAeN;AAED,MAAM,WAAW,UAAU;IAC1B;gEAC4D;IAC5D,QAAQ,CAAC,aAAa,EAAE,SAAS,aAAa,EAAE,CAAC;IACjD;;oEAEgE;IAChE,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACjD;AAED,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;;;;;2EAKuE;IACvE,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;CACjC;AAED,qBAAa,gBAAiB,SAAQ,KAAK;gBAC9B,OAAO,EAAE,MAAM;CAI3B;AAED;;;;;;;;;sCASsC;AACtC,wBAAgB,iBAAiB,CAChC,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,UAAU,EAChB,SAAS,CAAC,EAAE,eAAe,GACzB,YAAY,CAoLd"}
+{"version":3,"file":"extend.d.ts","sourceRoot":"","sources":["../../../src/core/store/extend.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,EAEN,KAAK,aAAa,EAElB,KAAK,WAAW,EAGhB,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAMnD,OAAO,EAIN,KAAK,iBAAiB,EAEtB,MAAM,cAAc,CAAC;AAEtB,MAAM,WAAW,UAAU;IAC1B;gEAC4D;IAC5D,QAAQ,CAAC,aAAa,EAAE,SAAS,aAAa,EAAE,CAAC;IACjD;;oEAEgE;IAChE,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACjD;AAED,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;;;;;2EAKuE;IACvE,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;CACjC;AAED,qBAAa,gBAAiB,SAAQ,KAAK;gBAC9B,OAAO,EAAE,MAAM;CAI3B;AAED;;;;;;;;;sCASsC;AACtC,wBAAgB,iBAAiB,CAChC,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,UAAU,EAChB,SAAS,CAAC,EAAE,eAAe,GACzB,YAAY,CAoId"}

package/dist/core/store/grow.d.cts

@@ -0,0 +1,34 @@
+import { ColumnStore } from './column_store.cjs';
+import { BufferAllocator } from './allocator.cjs';
+import { ArchetypeGrowSpec } from './layout_ops.cjs';
+export type { ArchetypeGrowSpec } from './layout_ops.cjs';
+export interface GrowPlan {
+    readonly archetypes: readonly ArchetypeGrowSpec[];
+}
+/** Returned alongside the new `ColumnStore` so callers can sanity-check the
+ * grow (and so tests can assert it without re-reading the SAB). */
+export interface GrowResult {
+    readonly store: ColumnStore;
+    readonly oldViewStamp: number;
+    readonly newViewStamp: number;
+    /** True when the in-place fast path ran: every archetype EXCEPT those in
+     * `grownArchetypeIds` kept its column views, so the caller only needs to
+     * `refreshViews` the grown ones. False on the realloc path, where the
+     * whole store moved and every view must be refreshed. */
+    readonly viewsPreserved: boolean;
+    /** Archetype ids whose columns were relocated (in-place path). Empty on
+     * the realloc path. */
+    readonly grownArchetypeIds: readonly number[];
+}
+export declare class StoreGrowError extends Error {
+    constructor(message: string);
+}
+/** Allocate a new SAB sized for `plan`, copy live rows from `old`, bump
+ * `view_stamp`. With the default allocator the old SAB is untouched and
+ * callers may continue reading from it until they finish swapping in
+ * the new views. With a `wasmMemoryAllocator`, `old`'s typed-array
+ * views may be detached as soon as `createColumnStore` returns — live
+ * data is snapshotted before the allocator call to make both code paths
+ * behave identically from the caller's perspective. (PR 3D / #234) */
+export declare function growColumnStore(old: ColumnStore, plan: GrowPlan, allocator?: BufferAllocator): GrowResult;
+//# sourceMappingURL=grow.d.ts.map

package/dist/core/store/grow.d.ts

@@ -1,12 +1,7 @@
-import { ColumnStore } from './column_store';
-import { BufferAllocator } from './allocator';
-/** Per-archetype growth input. The caller picks the new `row_capacity` and
- * declares the current live `row_count` so we know how many rows to copy. */
-export interface ArchetypeGrowSpec {
-    readonly archetypeId: number;
-    readonly newRowCapacity: number;
-    readonly rowCount: number;
-}
+import { ColumnStore } from './column_store.js';
+import { BufferAllocator } from './allocator.js';
+import { ArchetypeGrowSpec } from './layout_ops.js';
+export type { ArchetypeGrowSpec } from './layout_ops.js';
 export interface GrowPlan {
     readonly archetypes: readonly ArchetypeGrowSpec[];
 }

package/dist/core/store/grow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"grow.d.ts","sourceRoot":"","sources":["../../../src/core/store/grow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAUH,OAAO,EAQN,KAAK,WAAW,EAEhB,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AASnD;6EAC6E;AAC7E,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,QAAQ;IACxB,QAAQ,CAAC,UAAU,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAClD;AAED;mEACmE;AACnE,MAAM,WAAW,UAAU;IAC1B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;;;6DAGyD;IACzD,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC;2BACuB;IACvB,QAAQ,CAAC,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9C;AA4KD,qBAAa,cAAe,SAAQ,KAAK;gBAC5B,OAAO,EAAE,MAAM;CAI3B;AAED;;;;;;sEAMsE;AACtE,wBAAgB,eAAe,CAC9B,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,QAAQ,EACd,SAAS,CAAC,EAAE,eAAe,GACzB,UAAU,CAgIZ"}
+{"version":3,"file":"grow.d.ts","sourceRoot":"","sources":["../../../src/core/store/grow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AASH,OAAO,EAIN,KAAK,WAAW,EAGhB,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAIN,KAAK,iBAAiB,EAEtB,MAAM,cAAc,CAAC;AAMtB,YAAY,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEtD,MAAM,WAAW,QAAQ;IACxB,QAAQ,CAAC,UAAU,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAClD;AAED;mEACmE;AACnE,MAAM,WAAW,UAAU;IAC1B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;;;6DAGyD;IACzD,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC;2BACuB;IACvB,QAAQ,CAAC,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9C;AAyJD,qBAAa,cAAe,SAAQ,KAAK;gBAC5B,OAAO,EAAE,MAAM;CAI3B;AAED;;;;;;sEAMsE;AACtE,wBAAgB,eAAe,CAC9B,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,QAAQ,EACd,SAAS,CAAC,EAAE,eAAe,GACzB,UAAU,CAmGZ"}

package/dist/core/store/header.d.cts

@@ -0,0 +1,64 @@
+import { STORE_MAGIC, SIM_ABI_VERSION, STORE_HEADER_BYTES, STORE_HEADER_OFFSETS, REGION_TABLE_ENTRY_BYTES, REGION_TABLE_ENTRY_OFFSETS } from './vendored_abi/abi.cjs';
+export { STORE_MAGIC, SIM_ABI_VERSION, STORE_HEADER_BYTES, STORE_HEADER_OFFSETS, REGION_TABLE_ENTRY_BYTES, REGION_TABLE_ENTRY_OFFSETS };
+export interface StoreHeader {
+    /** Magic value `STORE_MAGIC`; used to detect a stale or foreign buffer
+     * before any other field is trusted. */
+    readonly magic: number;
+    /** ABI version; mismatch means the WASM and TS disagree on layout and
+     * the SAB must not be used. */
+    readonly simAbiVersion: number;
+    /** Monotonic; incremented every time the host reallocates the SAB.
+     * Cached TypedArray views become stale on bump. (#171 §8.1) */
+    readonly viewStamp: number;
+    /** Total SAB size in bytes. */
+    readonly capacity: number;
+    /** Number of archetype regions described by the layout descriptor. */
+    readonly archetypeCount: number;
+    /** Byte offset into the SAB where the layout descriptor region starts. */
+    readonly layoutDescriptorOff: number;
+    /** Byte offset of the WASM→TS command ring header. (#171 §7.5) */
+    readonly commandRingOff: number;
+    /** Byte offset of the TS→WASM action ring header. (#171 §7.5, Phase 5) */
+    readonly actionRingOff: number;
+    /** Byte offset of the entity-index region (entityId → archetype_id,
+     * row, generation lookup). 0 means absent — fixtures and bare-SAB
+     * tests that don't need the index see the v1 layout (the engine's
+     * `Store` always allocates one). (#245 / Phase 4 PR 4B) */
+    readonly entityIndexOff: number;
+    /** Byte offset of the event ring region (ECS signal payloads shared
+     * with the Zig sim). 0 means absent. (#247 / Phase 4 PR 4C) */
+    readonly eventRingOff: number;
+    /** Byte offset of the region-table directory — a `RegionTableEntry[]`
+     * (`(region_id, byte_offset, byte_length)` triples) holding one entry
+     * per consumer-declared region. 0 means no consumer regions were
+     * declared. The engine treats `region_id` as opaque; a consumer resolves
+     * its region with `findRegionOffset(view, header, id)` (TS) /
+     * `abi.find_region(header_addr, id)` (Zig). Replaces the five game-named
+     * offset fields (`terrain_off`/`spatial_grid_off`/… ) the SAB header
+     * used to hard-code. (#623 — de-game the SAB substrate; ADR-0018.) */
+    readonly regionTableOff: number;
+    /** Number of `RegionTableEntry` records at `region_table_off`. (#623) */
+    readonly regionTableCount: number;
+    /** Byte offset of the sim-bindings region — an opaque block of `u16`
+     * `(component_id, field_id)` IDs (layout owned by the game, in
+     * `@internal/sim`'s `sim_bindings.ts` / `bindings.zig`). The host writes it
+     * once per layout via `write_sim_bindings`; the Zig per-system exports
+     * (`tick_cooldown_ready` / `tick_movement_tick` / `tick_faith_production`
+     * and the batched `tick_all`) read their IDs from here instead of taking
+     * them as call args. Present only when the consumer opts into a WASM backend
+     * by passing `bindingsRegionBytes` to `createColumnStore`; 0 = absent (a
+     * pure-TS game pays nothing for this region). The size is a runtime input,
+     * not an engine ABI constant, since #625. (v5 / "SAB-is-the-interface".) */
+    readonly bindingsOff: number;
+}
+export declare function writeStoreHeader(view: DataView, h: StoreHeader): void;
+export declare function readStoreHeader(view: DataView): StoreHeader;
+/** Increment `view_stamp` in place after a host-side SAB reallocation. The
+ * monotonic counter is the trigger for cached-view invalidation on the TS
+ * side and for re-pointing in WASM. (#171 §8.1) */
+export declare function bumpViewStamp(view: DataView): number;
+/** True iff the buffer's first four bytes are `STORE_MAGIC` AND the ABI
+ * version matches the current build. Used by both TS and WASM as a
+ * pre-flight before treating any other field as meaningful. */
+export declare function isValidSab(view: DataView): boolean;
+//# sourceMappingURL=header.d.ts.map

package/dist/core/store/header.d.ts

@@ -1,4 +1,4 @@
-import { STORE_MAGIC, SIM_ABI_VERSION, STORE_HEADER_BYTES, STORE_HEADER_OFFSETS, REGION_TABLE_ENTRY_BYTES, REGION_TABLE_ENTRY_OFFSETS } from './__generated__/abi';
+import { STORE_MAGIC, SIM_ABI_VERSION, STORE_HEADER_BYTES, STORE_HEADER_OFFSETS, REGION_TABLE_ENTRY_BYTES, REGION_TABLE_ENTRY_OFFSETS } from './vendored_abi/abi.js';
 export { STORE_MAGIC, SIM_ABI_VERSION, STORE_HEADER_BYTES, STORE_HEADER_OFFSETS, REGION_TABLE_ENTRY_BYTES, REGION_TABLE_ENTRY_OFFSETS };
 export interface StoreHeader {
     /** Magic value `STORE_MAGIC`; used to detect a stale or foreign buffer

package/dist/core/store/header.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"header.d.ts","sourceRoot":"","sources":["../../../src/core/store/header.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkFG;AAoBH,OAAO,EACN,WAAW,EACX,eAAe,EACf,kBAAkB,EAClB,oBAAoB,EACpB,wBAAwB,EACxB,0BAA0B,EAC1B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACN,WAAW,EACX,eAAe,EACf,kBAAkB,EAClB,oBAAoB,EACpB,wBAAwB,EACxB,0BAA0B,EAC1B,CAAC;AAEF,MAAM,WAAW,WAAW;IAC3B;4CACwC;IACxC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;mCAC+B;IAC/B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B;mEAC+D;IAC/D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,+BAA+B;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,sEAAsE;IACtE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,0EAA0E;IAC1E,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,kEAAkE;IAClE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,0EAA0E;IAC1E,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B;;;+DAG2D;IAC3D,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC;mEAC+D;IAC/D,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;;;;;;;0EAOsE;IACtE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,yEAAyE;IACzE,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC;;;;;;;;;gFAS4E;IAC5E,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC7B;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE,WAAW,GAAG,IAAI,CAcrE;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,WAAW,CAgB3D;AAED;;mDAEmD;AACnD,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAIpD;AAED;;+DAE+D;AAC/D,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAKlD"}
+{"version":3,"file":"header.d.ts","sourceRoot":"","sources":["../../../src/core/store/header.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkFG;AAoBH,OAAO,EACN,WAAW,EACX,eAAe,EACf,kBAAkB,EAClB,oBAAoB,EACpB,wBAAwB,EACxB,0BAA0B,EAC1B,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACN,WAAW,EACX,eAAe,EACf,kBAAkB,EAClB,oBAAoB,EACpB,wBAAwB,EACxB,0BAA0B,EAC1B,CAAC;AAEF,MAAM,WAAW,WAAW;IAC3B;4CACwC;IACxC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;mCAC+B;IAC/B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B;mEAC+D;IAC/D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,+BAA+B;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,sEAAsE;IACtE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,0EAA0E;IAC1E,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,kEAAkE;IAClE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,0EAA0E;IAC1E,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B;;;+DAG2D;IAC3D,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC;mEAC+D;IAC/D,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;;;;;;;0EAOsE;IACtE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,yEAAyE;IACzE,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC;;;;;;;;;gFAS4E;IAC5E,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC7B;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE,WAAW,GAAG,IAAI,CAcrE;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,WAAW,CAgB3D;AAED;;mDAEmD;AACnD,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAIpD;AAED;;+DAE+D;AAC/D,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAKlD"}

package/dist/core/store/index.d.cts

@@ -0,0 +1,17 @@
+export { STORE_MAGIC, SIM_ABI_VERSION, STORE_HEADER_BYTES, STORE_HEADER_OFFSETS, REGION_TABLE_ENTRY_BYTES, REGION_TABLE_ENTRY_OFFSETS, type StoreHeader, writeStoreHeader, readStoreHeader, bumpViewStamp, isValidSab } from './header.cjs';
+export { type StoreRegionSpec, type RegionTableEntry, type ColumnStoreRegionHandle, RegionRegistryError, regionTableBytes, validateRegionSpecs, writeRegionTableEntry, readRegionTableEntry, writeRegionTable, readRegionTable, readHeaderRegionTable, findRegionOffset, findRegionEntry } from './region_table.cjs';
+export { TYPE_TAG, type TypeTagValue, TYPE_TAG_STRIDE, TYPED_ARRAY_TAG_TO_TYPE_TAG, COLUMN_DESCRIPTOR_BYTES, COLUMN_DESCRIPTOR_OFFSETS, type ColumnDescriptor, writeColumnDescriptor, readColumnDescriptor, ARCHETYPE_DESCRIPTOR_HEADER_BYTES, ARCHETYPE_DESCRIPTOR_OFFSETS, COMPONENT_MASK_WORDS, STORE_DESCRIPTOR_COMPONENT_LIMIT, type ArchetypeDescriptor, archetypeDescriptorBytes, writeArchetypeDescriptor, readArchetypeDescriptor, writeLayoutDescriptorRegion, readLayoutDescriptorRegion, layoutDescriptorRegionBytes } from './descriptor.cjs';
+export { type ColumnSpec, type ArchetypeSpec, type ColumnView, type ArchetypeViews, type ColumnStore, type AnyTypedArray, type CreateColumnStoreOptions, alignUp, buildArchetypeViews, columnKey, createColumnStore, StoreLayoutOverflowError, STORE_MAX_BYTE_OFFSET, COMMAND_RING_DEFAULT_CAPACITY_SLOTS, ENTITY_INDEX_DEFAULT_CAPACITY, EVENT_RING_DEFAULT_CAPACITY_SLOTS } from './column_store.cjs';
+export { EVENT_OP_EMPTY, EVENT_RING_HEADER_BYTES, EVENT_RING_SLOT_BYTES, EVENT_RING_HEADER_OFFSETS, EventRingError, drainEventRing, eventRingBytes, initEventRing, pendingEventCount, popEvent, pushEvent, ringCapacitySlots as eventRingCapacitySlots, ringOverflow as eventRingOverflow, ringReadHead as eventRingReadHead, ringWriteHead as eventRingWriteHead } from './event_ring.cjs';
+export { ENTITY_INDEX_HEADER_BYTES, ENTITY_INDEX_BYTES_PER_SLOT, ENTITY_INDEX_HEADER_OFFSETS, EntityIndexError, buildEntityIndexViews, entityIndexCapacity, entityIndexLength, entityIndexRegionBytes, initEntityIndexRegion, setEntityIndexLength } from './entity_index.cjs';
+export { COMMAND_OP_EMPTY, COMMAND_RING_HEADER_BYTES, COMMAND_RING_SLOT_BYTES, COMMAND_RING_HEADER_OFFSETS, CommandRingError, commandRingBytes, drainCommandRing, initCommandRing, pendingCommandCount, popCommand, pushCommand, ringCapacitySlots, ringOverflow, ringReadHead, ringWriteHead } from './command_ring.cjs';
+export { type PayloadCodec, CommandDispatcher } from './command_dispatch.cjs';
+export { BufferBackedColumn, StoreColumnOverflowError } from './buffer_backed_column.cjs';
+export { type ArchetypeGrowSpec, type GrowPlan, type GrowResult, StoreGrowError, growColumnStore } from './grow.cjs';
+export { type ExtendPlan, type ExtendResult, StoreExtendError, extendColumnStore } from './extend.cjs';
+export { snapshotLiveColumns, restoreColumnSnapshots } from './layout_ops.cjs';
+export { type BufferAllocator, type InPlaceBufferAllocator, StoreCapExceededError, SabUnavailableError, DEFAULT_SAB_ALLOCATOR, wasmMemoryAllocator, growableSabAllocator, heapArraybufferAllocator } from './allocator.cjs';
+export { StoreRestoreError, snapshotColumnStore, restoreColumnStore } from './snapshot.cjs';
+export { FNV1A_OFFSET_BASIS, FNV1A_PRIME, fnv1a32, fnv1aStep, fnv1aStepWord, columnStoreStateHash } from './state_hash.cjs';
+export { ACTION_RING_DEFAULT_CAPACITY_SLOTS, ACTION_RING_HEADER_BYTES, ACTION_RING_HEADER_OFFSETS, ACTION_RING_MAX_PAYLOAD_BYTES, ACTION_RING_SLOT_BYTES, ActionRingError, actionRingBytes, actionRingCapacitySlots, actionRingOverflow, actionRingReadHead, actionRingWriteHead, clearActionRingOverflow, drainActionRing, initActionRing, pendingActionCount, popAction, pushAction } from './action_ring.cjs';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/store/index.d.ts

@@ -1,16 +1,17 @@
-export { STORE_MAGIC, SIM_ABI_VERSION, STORE_HEADER_BYTES, STORE_HEADER_OFFSETS, REGION_TABLE_ENTRY_BYTES, REGION_TABLE_ENTRY_OFFSETS, type StoreHeader, writeStoreHeader, readStoreHeader, bumpViewStamp, isValidSab } from './header';
-export { type StoreRegionSpec, type RegionTableEntry, type ColumnStoreRegionHandle, RegionRegistryError, regionTableBytes, validateRegionSpecs, writeRegionTableEntry, readRegionTableEntry, writeRegionTable, readRegionTable, readHeaderRegionTable, findRegionOffset, findRegionEntry } from './region_table';
-export { TYPE_TAG, type TypeTagValue, TYPE_TAG_STRIDE, TYPED_ARRAY_TAG_TO_TYPE_TAG, COLUMN_DESCRIPTOR_BYTES, COLUMN_DESCRIPTOR_OFFSETS, type ColumnDescriptor, writeColumnDescriptor, readColumnDescriptor, ARCHETYPE_DESCRIPTOR_HEADER_BYTES, ARCHETYPE_DESCRIPTOR_OFFSETS, COMPONENT_MASK_WORDS, STORE_DESCRIPTOR_COMPONENT_LIMIT, type ArchetypeDescriptor, archetypeDescriptorBytes, writeArchetypeDescriptor, readArchetypeDescriptor, writeLayoutDescriptorRegion, readLayoutDescriptorRegion, layoutDescriptorRegionBytes } from './descriptor';
-export { type ColumnSpec, type ArchetypeSpec, type ColumnView, type ArchetypeViews, type ColumnStore, type AnyTypedArray, type CreateColumnStoreOptions, alignUp, buildArchetypeViews, columnKey, createColumnStore, StoreLayoutOverflowError, STORE_MAX_BYTE_OFFSET, COMMAND_RING_DEFAULT_CAPACITY_SLOTS, ENTITY_INDEX_DEFAULT_CAPACITY, EVENT_RING_DEFAULT_CAPACITY_SLOTS } from './column_store';
-export { EVENT_OP_EMPTY, EVENT_RING_HEADER_BYTES, EVENT_RING_SLOT_BYTES, EVENT_RING_HEADER_OFFSETS, EventRingError, drainEventRing, eventRingBytes, initEventRing, pendingEventCount, popEvent, pushEvent, ringCapacitySlots as eventRingCapacitySlots, ringOverflow as eventRingOverflow, ringReadHead as eventRingReadHead, ringWriteHead as eventRingWriteHead } from './event_ring';
-export { ENTITY_INDEX_HEADER_BYTES, ENTITY_INDEX_BYTES_PER_SLOT, ENTITY_INDEX_HEADER_OFFSETS, EntityIndexError, buildEntityIndexViews, entityIndexCapacity, entityIndexLength, entityIndexRegionBytes, initEntityIndexRegion, setEntityIndexLength } from './entity_index';
-export { COMMAND_OP_EMPTY, COMMAND_RING_HEADER_BYTES, COMMAND_RING_SLOT_BYTES, COMMAND_RING_HEADER_OFFSETS, CommandRingError, commandRingBytes, drainCommandRing, initCommandRing, pendingCommandCount, popCommand, pushCommand, ringCapacitySlots, ringOverflow, ringReadHead, ringWriteHead } from './command_ring';
-export { type PayloadCodec, CommandDispatcher } from './command_dispatch';
-export { BufferBackedColumn, StoreColumnOverflowError } from './buffer_backed_column';
-export { type ArchetypeGrowSpec, type GrowPlan, type GrowResult, StoreGrowError, growColumnStore } from './grow';
-export { type ExtendPlan, type ExtendResult, StoreExtendError, extendColumnStore, snapshotLiveColumns, restoreColumnSnapshots } from './extend';
-export { type BufferAllocator, type InPlaceBufferAllocator, StoreCapExceededError, SabUnavailableError, DEFAULT_SAB_ALLOCATOR, wasmMemoryAllocator, growableSabAllocator, heapArraybufferAllocator } from './allocator';
-export { StoreRestoreError, snapshotColumnStore, restoreColumnStore } from './snapshot';
-export { FNV1A_OFFSET_BASIS, FNV1A_PRIME, fnv1a32, fnv1aStep, fnv1aStepWord, columnStoreStateHash } from './state_hash';
-export { ACTION_RING_DEFAULT_CAPACITY_SLOTS, ACTION_RING_HEADER_BYTES, ACTION_RING_HEADER_OFFSETS, ACTION_RING_MAX_PAYLOAD_BYTES, ACTION_RING_SLOT_BYTES, ActionRingError, actionRingBytes, actionRingCapacitySlots, actionRingOverflow, actionRingReadHead, actionRingWriteHead, clearActionRingOverflow, drainActionRing, initActionRing, pendingActionCount, popAction, pushAction } from './action_ring';
+export { STORE_MAGIC, SIM_ABI_VERSION, STORE_HEADER_BYTES, STORE_HEADER_OFFSETS, REGION_TABLE_ENTRY_BYTES, REGION_TABLE_ENTRY_OFFSETS, type StoreHeader, writeStoreHeader, readStoreHeader, bumpViewStamp, isValidSab } from './header.js';
+export { type StoreRegionSpec, type RegionTableEntry, type ColumnStoreRegionHandle, RegionRegistryError, regionTableBytes, validateRegionSpecs, writeRegionTableEntry, readRegionTableEntry, writeRegionTable, readRegionTable, readHeaderRegionTable, findRegionOffset, findRegionEntry } from './region_table.js';
+export { TYPE_TAG, type TypeTagValue, TYPE_TAG_STRIDE, TYPED_ARRAY_TAG_TO_TYPE_TAG, COLUMN_DESCRIPTOR_BYTES, COLUMN_DESCRIPTOR_OFFSETS, type ColumnDescriptor, writeColumnDescriptor, readColumnDescriptor, ARCHETYPE_DESCRIPTOR_HEADER_BYTES, ARCHETYPE_DESCRIPTOR_OFFSETS, COMPONENT_MASK_WORDS, STORE_DESCRIPTOR_COMPONENT_LIMIT, type ArchetypeDescriptor, archetypeDescriptorBytes, writeArchetypeDescriptor, readArchetypeDescriptor, writeLayoutDescriptorRegion, readLayoutDescriptorRegion, layoutDescriptorRegionBytes } from './descriptor.js';
+export { type ColumnSpec, type ArchetypeSpec, type ColumnView, type ArchetypeViews, type ColumnStore, type AnyTypedArray, type CreateColumnStoreOptions, alignUp, buildArchetypeViews, columnKey, createColumnStore, StoreLayoutOverflowError, STORE_MAX_BYTE_OFFSET, COMMAND_RING_DEFAULT_CAPACITY_SLOTS, ENTITY_INDEX_DEFAULT_CAPACITY, EVENT_RING_DEFAULT_CAPACITY_SLOTS } from './column_store.js';
+export { EVENT_OP_EMPTY, EVENT_RING_HEADER_BYTES, EVENT_RING_SLOT_BYTES, EVENT_RING_HEADER_OFFSETS, EventRingError, drainEventRing, eventRingBytes, initEventRing, pendingEventCount, popEvent, pushEvent, ringCapacitySlots as eventRingCapacitySlots, ringOverflow as eventRingOverflow, ringReadHead as eventRingReadHead, ringWriteHead as eventRingWriteHead } from './event_ring.js';
+export { ENTITY_INDEX_HEADER_BYTES, ENTITY_INDEX_BYTES_PER_SLOT, ENTITY_INDEX_HEADER_OFFSETS, EntityIndexError, buildEntityIndexViews, entityIndexCapacity, entityIndexLength, entityIndexRegionBytes, initEntityIndexRegion, setEntityIndexLength } from './entity_index.js';
+export { COMMAND_OP_EMPTY, COMMAND_RING_HEADER_BYTES, COMMAND_RING_SLOT_BYTES, COMMAND_RING_HEADER_OFFSETS, CommandRingError, commandRingBytes, drainCommandRing, initCommandRing, pendingCommandCount, popCommand, pushCommand, ringCapacitySlots, ringOverflow, ringReadHead, ringWriteHead } from './command_ring.js';
+export { type PayloadCodec, CommandDispatcher } from './command_dispatch.js';
+export { BufferBackedColumn, StoreColumnOverflowError } from './buffer_backed_column.js';
+export { type ArchetypeGrowSpec, type GrowPlan, type GrowResult, StoreGrowError, growColumnStore } from './grow.js';
+export { type ExtendPlan, type ExtendResult, StoreExtendError, extendColumnStore } from './extend.js';
+export { snapshotLiveColumns, restoreColumnSnapshots } from './layout_ops.js';
+export { type BufferAllocator, type InPlaceBufferAllocator, StoreCapExceededError, SabUnavailableError, DEFAULT_SAB_ALLOCATOR, wasmMemoryAllocator, growableSabAllocator, heapArraybufferAllocator } from './allocator.js';
+export { StoreRestoreError, snapshotColumnStore, restoreColumnStore } from './snapshot.js';
+export { FNV1A_OFFSET_BASIS, FNV1A_PRIME, fnv1a32, fnv1aStep, fnv1aStepWord, columnStoreStateHash } from './state_hash.js';
+export { ACTION_RING_DEFAULT_CAPACITY_SLOTS, ACTION_RING_HEADER_BYTES, ACTION_RING_HEADER_OFFSETS, ACTION_RING_MAX_PAYLOAD_BYTES, ACTION_RING_SLOT_BYTES, ActionRingError, actionRingBytes, actionRingCapacitySlots, actionRingOverflow, actionRingReadHead, actionRingWriteHead, clearActionRingOverflow, drainActionRing, initActionRing, pendingActionCount, popAction, pushAction } from './action_ring.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/store/index.d.ts.map

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