@oasys/oecs 0.5.4 → 0.6.0

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

@@ -1,64 +1,68 @@
-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 };
+import { STORE_MAGIC, SIM_ABI_VERSION, LEGACY_ABSOLUTE_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, LEGACY_ABSOLUTE_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
+    /** 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
+    /** 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.
+    /** Monotonic. Incremented every time the host reallocates the SAB.
      * Cached TypedArray views become stale on bump. */
     readonly viewStamp: number;
-    /** Total SAB size in bytes. */
+    /** Store span in bytes, measured from the store base. The store writes
+     * only inside `[storeBase, storeBase + capacity)`. */
     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. */
+    /** Byte offset of the layout descriptor region, measured from the store
+     * base. */
     readonly layoutDescriptorOff: number;
     /** Byte offset of the WASM→TS command ring header. */
     readonly commandRingOff: number;
     /** Byte offset of the TS→WASM action ring header. */
     readonly actionRingOff: number;
     /** Byte offset of the entity-index region (entityId → archetype_id,
-     * row, generation lookup). 0 means absent — fixtures and bare-SAB
+     * 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). */
     readonly entityIndexOff: number;
     /** Byte offset of the event ring region (ECS signal payloads shared
-     * with the Zig sim). 0 means absent. */
+     * with a compute backend). 0 means absent. */
     readonly eventRingOff: number;
-    /** Byte offset of the region-table directory — a `RegionTableEntry[]`
+    /** 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. This de-games the SAB substrate. */
+     * declared. The engine treats `region_id` as opaque. A consumer resolves
+     * its region with `findRegionOffset(view, id)` in TS, or with the
+     * matching module-side lookup. Replaces the five consumer-named
+     * offset fields the SAB header used to hard-code. This de-games the SAB
+     * substrate. */
     readonly regionTableOff: number;
     /** Number of `RegionTableEntry` records at `region_table_off`. */
     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. (v5 / "SAB-is-the-interface".) */
+    /** Byte offset of the sim-bindings region, an opaque block of `u16`
+     * `(component_id, field_id)` ids. The consumer owns the layout, and the host
+     * writes the block once per layout. A WASM per-system export reads its 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, so a pure-TS world pays nothing for this
+     * region. The size is a runtime input, not an engine ABI constant. */
     readonly bindingsOff: number;
 }
+/** Write the header at offset 0 of `view`. The caller passes a `DataView`
+ * whose start is the store base, so every offset the header carries stays
+ * relative to that base. */
 export declare function writeStoreHeader(view: DataView, h: StoreHeader): void;
+/** Read the header at offset 0 of `view`. Pass a `DataView` whose start is the
+ * store base. */
 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. */
 export declare function bumpViewStamp(view: DataView): number;
-/** True iff the buffer's first four bytes are `STORE_MAGIC` AND the ABI
+/** 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;
+export declare function isValidStoreHeader(view: DataView): boolean;
 //# sourceMappingURL=header.d.ts.map

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

@@ -1,64 +1,68 @@
-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 };
+import { STORE_MAGIC, SIM_ABI_VERSION, LEGACY_ABSOLUTE_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, LEGACY_ABSOLUTE_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
+    /** 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
+    /** 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.
+    /** Monotonic. Incremented every time the host reallocates the SAB.
      * Cached TypedArray views become stale on bump. */
     readonly viewStamp: number;
-    /** Total SAB size in bytes. */
+    /** Store span in bytes, measured from the store base. The store writes
+     * only inside `[storeBase, storeBase + capacity)`. */
     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. */
+    /** Byte offset of the layout descriptor region, measured from the store
+     * base. */
     readonly layoutDescriptorOff: number;
     /** Byte offset of the WASM→TS command ring header. */
     readonly commandRingOff: number;
     /** Byte offset of the TS→WASM action ring header. */
     readonly actionRingOff: number;
     /** Byte offset of the entity-index region (entityId → archetype_id,
-     * row, generation lookup). 0 means absent — fixtures and bare-SAB
+     * 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). */
     readonly entityIndexOff: number;
     /** Byte offset of the event ring region (ECS signal payloads shared
-     * with the Zig sim). 0 means absent. */
+     * with a compute backend). 0 means absent. */
     readonly eventRingOff: number;
-    /** Byte offset of the region-table directory — a `RegionTableEntry[]`
+    /** 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. This de-games the SAB substrate. */
+     * declared. The engine treats `region_id` as opaque. A consumer resolves
+     * its region with `findRegionOffset(view, id)` in TS, or with the
+     * matching module-side lookup. Replaces the five consumer-named
+     * offset fields the SAB header used to hard-code. This de-games the SAB
+     * substrate. */
     readonly regionTableOff: number;
     /** Number of `RegionTableEntry` records at `region_table_off`. */
     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. (v5 / "SAB-is-the-interface".) */
+    /** Byte offset of the sim-bindings region, an opaque block of `u16`
+     * `(component_id, field_id)` ids. The consumer owns the layout, and the host
+     * writes the block once per layout. A WASM per-system export reads its 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, so a pure-TS world pays nothing for this
+     * region. The size is a runtime input, not an engine ABI constant. */
     readonly bindingsOff: number;
 }
+/** Write the header at offset 0 of `view`. The caller passes a `DataView`
+ * whose start is the store base, so every offset the header carries stays
+ * relative to that base. */
 export declare function writeStoreHeader(view: DataView, h: StoreHeader): void;
+/** Read the header at offset 0 of `view`. Pass a `DataView` whose start is the
+ * store base. */
 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. */
 export declare function bumpViewStamp(view: DataView): number;
-/** True iff the buffer's first four bytes are `STORE_MAGIC` AND the ABI
+/** 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;
+export declare function isValidStoreHeader(view: DataView): boolean;
 //# sourceMappingURL=header.d.ts.map

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiFG;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;uDACmD;IACnD,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,sDAAsD;IACtD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,qDAAqD;IACrD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B;;;wCAGoC;IACpC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC;4CACwC;IACxC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;;;;;;;6DAOyD;IACzD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,kEAAkE;IAClE,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC;;;;;;;;;oEASgE;IAChE,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;;uCAEuC;AACvC,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AAmBH,OAAO,EACN,WAAW,EACX,eAAe,EACf,2BAA2B,EAC3B,kBAAkB,EAClB,oBAAoB,EACpB,wBAAwB,EACxB,0BAA0B,EAC1B,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACN,WAAW,EACX,eAAe,EACf,2BAA2B,EAC3B,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;uDACmD;IACnD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;0DACsD;IACtD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,sEAAsE;IACtE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC;eACW;IACX,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,sDAAsD;IACtD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,qDAAqD;IACrD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B;;;wCAGoC;IACpC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC;kDAC8C;IAC9C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;;;;;;;oBAOgB;IAChB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,kEAAkE;IAClE,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC;;;;;;0EAMsE;IACtE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC7B;AAED;;4BAE4B;AAC5B,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE,WAAW,GAAG,IAAI,CAcrE;AAED;iBACiB;AACjB,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,WAAW,CAgB3D;AAED;;uCAEuC;AACvC,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAIpD;AAED;;+DAE+D;AAC/D,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAK1D"}

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

@@ -1,17 +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 { STORE_MAGIC, SIM_ABI_VERSION, LEGACY_ABSOLUTE_ABI_VERSION, STORE_HEADER_BYTES, STORE_HEADER_OFFSETS, REGION_TABLE_ENTRY_BYTES, REGION_TABLE_ENTRY_OFFSETS, type StoreHeader, writeStoreHeader, readStoreHeader, bumpViewStamp, isValidStoreHeader } from './header.cjs';
+export { type StoreRegionSpec, type RegionTableEntry, type ColumnStoreRegionHandle, RegionRegistryError, regionTableBytes, assertRegionSpecs, 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, LEGACY_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, createArchetypeViews, columnKey, createColumnStore, StoreLayoutOverflowError, STORE_MAX_BYTE_OFFSET, STORE_BASE_ALIGNMENT, assertStoreBase, 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, eventRingCapacitySlots, eventRingOverflow, eventRingReadHead, eventRingWriteHead } from './event_ring.cjs';
+export { ENTITY_INDEX_HEADER_BYTES, ENTITY_INDEX_BYTES_PER_SLOT, ENTITY_INDEX_HEADER_OFFSETS, EntityIndexError, createEntityIndexViews, 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, commandRingCapacitySlots, commandRingOverflow, commandRingReadHead, commandRingWriteHead } 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 { snapshotLiveColumns, restoreLiveColumns } from './layout_ops.cjs';
+export { type BufferAllocator, type InPlaceBufferAllocator, StoreCapExceededError, SabUnavailableError, DEFAULT_SAB_ALLOCATOR, wasmMemoryAllocator, growableSabAllocator, heapArrayBufferAllocator, fixedSabAllocator } from './allocator.cjs';
+export { StoreRestoreError, type RestoreColumnStoreOptions, columnStoreBytesView, 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,17 +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.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 { STORE_MAGIC, SIM_ABI_VERSION, LEGACY_ABSOLUTE_ABI_VERSION, STORE_HEADER_BYTES, STORE_HEADER_OFFSETS, REGION_TABLE_ENTRY_BYTES, REGION_TABLE_ENTRY_OFFSETS, type StoreHeader, writeStoreHeader, readStoreHeader, bumpViewStamp, isValidStoreHeader } from './header.js';
+export { type StoreRegionSpec, type RegionTableEntry, type ColumnStoreRegionHandle, RegionRegistryError, regionTableBytes, assertRegionSpecs, 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, LEGACY_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, createArchetypeViews, columnKey, createColumnStore, StoreLayoutOverflowError, STORE_MAX_BYTE_OFFSET, STORE_BASE_ALIGNMENT, assertStoreBase, 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, eventRingCapacitySlots, eventRingOverflow, eventRingReadHead, eventRingWriteHead } from './event_ring.js';
+export { ENTITY_INDEX_HEADER_BYTES, ENTITY_INDEX_BYTES_PER_SLOT, ENTITY_INDEX_HEADER_OFFSETS, EntityIndexError, createEntityIndexViews, 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, commandRingCapacitySlots, commandRingOverflow, commandRingReadHead, commandRingWriteHead } 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 { snapshotLiveColumns, restoreLiveColumns } from './layout_ops.js';
+export { type BufferAllocator, type InPlaceBufferAllocator, StoreCapExceededError, SabUnavailableError, DEFAULT_SAB_ALLOCATOR, wasmMemoryAllocator, growableSabAllocator, heapArrayBufferAllocator, fixedSabAllocator } from './allocator.js';
+export { StoreRestoreError, type RestoreColumnStoreOptions, columnStoreBytesView, 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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"}

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

@@ -2,7 +2,7 @@ import { BufferAllocator } from './allocator.cjs';
 import { ArchetypeSpec, ColumnStore, ColumnStoreInternal, CreateColumnStoreOptions } from './column_store.cjs';
 import { ArchetypeDescriptor, TypeTagValue } from './descriptor.cjs';
 import { StoreRegionOffsetField } from './store_regions.cjs';
-/** Per-archetype resize/copy input, shared by `GrowPlan.archetypes` and
+/** Per-archetype resize and copy input, shared by `GrowPlan.archetypes` and
  * `ExtendPlan.existing` (so callers can reuse plan-building helpers). The
  * caller picks the new `row_capacity` and declares the current live
  * `row_count` so the copy knows how many rows matter. */
@@ -11,9 +11,9 @@ export interface ArchetypeGrowSpec {
     readonly newRowCapacity: number;
     readonly rowCount: number;
 }
-/** One archetype's column-layout request for `layoutColumnsAtTail`. `stride`
- * is resolved by the caller — grow reuses the old column's stride verbatim;
- * extend derives it from `TYPE_TAG_STRIDE[typeTag]` for brand-new columns. */
+/** One archetype's column-layout request for `layoutColumnsAtTail`. The caller
+ * resolves `stride`. Grow reuses the old column's stride verbatim. Extend
+ * derives it from `TYPE_TAG_STRIDE[typeTag]` for a brand-new column. */
 export interface TailArchetypeLayout {
     readonly archetypeId: number;
     readonly componentMask: ArchetypeDescriptor["componentMask"];
@@ -25,23 +25,24 @@ export interface TailArchetypeLayout {
         readonly stride: number;
     }[];
 }
-/** Tail-cursor column placement — the single home for the in-place paths'
- * layout rule and the 2³¹ offset cap. Starting at `startCursor`
- * (the current buffer byteLength), each archetype's columns are placed
- * `alignUp(cursor, stride)` then advanced by `stride * rowCapacity`; the
+/** Tail-cursor column placement, the single home for the in-place paths'
+ * layout rule and the 2³¹ offset cap. `startCursor` and every offset it
+ * produces are relative to the store base. Starting at `startCursor`
+ * (the current store span), each archetype's columns are placed
+ * `alignUp(cursor, stride)` then advanced by `stride * rowCapacity`. The
  * final tail (last column's advance, not re-aligned) becomes the grown
  * buffer's byteLength and is guarded past `STORE_MAX_BYTE_OFFSET` exactly
  * like `planLayout` guards the create-time layout. Descriptors come back
- * with `rowCount` / `enabledCount` zeroed (the store side of those counters
+ * with `rowCount` and `enabledCount` zeroed (the store side of those counters
  * lives with the caller). */
 export declare function layoutColumnsAtTail(startCursor: number, archetypes: readonly TailArchetypeLayout[]): {
     descriptors: ArchetypeDescriptor[];
     newTotal: number;
 };
 /** Grow an in-place-backed store's buffer to `newTotal` and mint the DataView
- * the caller must write headers/descriptors through. `growableSabAllocator` /
- * `heapArraybufferAllocator` return the SAME buffer instance grown in place;
- * `wasmMemoryAllocator` returns a NEW ref over the same linear memory — old
+ * the caller must write headers and descriptors through. `growableSabAllocator`
+ * and `heapArrayBufferAllocator` return the same buffer instance grown in place.
+ * `wasmMemoryAllocator` returns a new ref over the same linear memory, old
  * typed-array views stay valid either way (the `isInPlace` contract), but
  * when the ref changed the old DataView's byteLength is frozen at the
  * pre-grow size, so a fresh DataView over the new ref is required for any
@@ -51,39 +52,47 @@ export declare function growBufferInPlace(old: ColumnStoreInternal, newTotal: nu
     newView: DataView;
 };
 /**
- * Byte offset where the next appended column region begins — the tail cursor
- * the in-place grow/extend paths pass to `layoutColumnsAtTail`.
+ * Byte offset where the next appended column region begins, measured from the
+ * store base. This is the tail cursor the in-place grow and extend paths pass
+ * to `layoutColumnsAtTail`.
  *
- * For the growable-SAB and wasm backings the buffer is sized to the live extent
- * (`SharedArrayBuffer.grow` resizes exactly; wasm rounds up to a page, and its
- * fast path deliberately lands new regions past that page-rounded tail), so
- * `buffer.byteLength` IS the tail. For the pure-TS **heap** backing (0.5.3) the
- * buffer is a FIXED `ArrayBuffer` reserved at the full cap for V8 fast-path
- * element access, so its `byteLength` is `maxBytes`, NOT the used size — the
- * true tail is the header `capacity` (the logical high-water; new columns land
- * in still-zero fixed-buffer space just past the last live column).
+ * For the growable-SAB and wasm backings the buffer is sized to the live extent,
+ * so `buffer.byteLength` minus the base is the tail. `SharedArrayBuffer.grow`
+ * resizes exactly.
+ * Wasm rounds up to a page, and its fast path deliberately lands new regions
+ * past that page-rounded tail.
  *
- * A plain (non-shared) `ArrayBuffer` is uniquely the heap profile's fixed
- * reservation — every other in-place backing is a `SharedArrayBuffer`. Keying
- * off the backing keeps the SAB/wasm layouts byte-for-byte unchanged.
+ * The pure-TS **heap** backing differs. Its buffer is a fixed `ArrayBuffer`
+ * reserved at the full cap for V8 fast-path element access, so its `byteLength`
+ * is `maxBytes`, not the used size. The true tail is the header `capacity`, the
+ * logical high-water. New columns land in still-zero fixed-buffer space
+ * immediately past the last live column.
+ *
+ * The question is whether the allocator reserved the cap, not which buffer
+ * class it returned: `fixedSabAllocator` reserves a fixed `SharedArrayBuffer`
+ * and needs the header rule, while `growableSabAllocator` grows a
+ * `SharedArrayBuffer` to the live extent and needs the `byteLength` rule. So
+ * the allocator's `reservedAtCap` marker decides. The plain-`ArrayBuffer` test
+ * stays as the fallback for a store whose allocator predates the marker, which
+ * keeps the SAB and wasm layouts byte-for-byte unchanged.
  */
 export declare function tailCursorBytes(old: ColumnStoreInternal): number;
 /**
  * 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
+ * new SAB. Without this, an extend or 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`.
+ * not only the default. Live state (write_head, length, …) is preserved
+ * separately via `snapshotRegions`.
  *
  * Also re-applies the descriptor-region headroom policy
- * (`reservedDescriptorBytes`). 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
+ * (`reservedDescriptorBytes`). 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
@@ -92,75 +101,75 @@ export declare function tailCursorBytes(old: ColumnStoreInternal): number;
 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`. */
+ * region's offset. `consumer` is keyed by `region_id` (consumer regions have no
+ * named header field). Pairs `snapshotRegions` with
+ * `restoreRegions`. */
 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
+ * 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
+ * an allocator-induced detach. `restoreRegions` places it back at the
  * matching offset in the new SAB.
  *
- * Header bytes themselves are NOT snapshotted — `createColumnStore` writes the
+ * 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;
+export declare function snapshotRegions(old: ColumnStore): PrefixRegionSnapshot;
 /** Restore prefix-region byte snapshots into `newStore` at the matching
- * region offsets. Pairs with `snapshotPrefixRegions`. The new SAB's regions
+ * region offsets. Pairs with `snapshotRegions`. 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,
+ * 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;
+export declare function restoreRegions(newStore: ColumnStore, snap: PrefixRegionSnapshot): void;
 /**
- * Snapshot per-archetype live column bytes from `old` BEFORE any
+ * 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.
+ * with `row_count === 0` are omitted, nothing to copy.
  */
 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
+ * into `newStore`'s column views. The snapshot's column order must match
+ * the new archetype's `columnsInOrder` (extend and grow guarantee this
  * because they carry the column spec forward unchanged).
  */
-export declare function restoreColumnSnapshots(newStore: ColumnStore, snapshots: Map<number, Uint8Array[]>): void;
+export declare function restoreLiveColumns(newStore: ColumnStore, snapshots: Map<number, Uint8Array[]>): void;
 /**
  * The realloc-and-republish slow path shared by `growColumnStore` and
- * `extendColumnStore` — everything between "the specs are decided" and "the
+ * `extendColumnStore`, everything between "the specs are decided" and "the
  * caller shapes its result":
  *
- *   1. Capture `view_stamp` and snapshot live rows AND prefix regions
- *      (command ring, entity-index) BEFORE the allocator call — the
+ *   1. Capture `view_stamp` and snapshot live rows and prefix regions
+ *      (command ring, entity-index) before the allocator call, the
  *      wasmMemoryAllocator may detach `old`'s views on grow, so everything
  *      needed is captured first. The prefix-region preservation is the
- *      contract `Store` relies on to keep its entity table across resizes;
- * `optionsFromOld` re-reserves regions and descriptor headroom
- * so the republished store keeps its layout and fast paths.
- *   2. `createColumnStore` with the derived options (fresh buffer; the same
+ *      contract `Store` relies on to keep its entity table across resizes.
+ *      `optionsFromOld` re-reserves the regions and the descriptor headroom,
+ *      so the republished store keeps its layout and its fast paths.
+ *   2. `createColumnStore` with the derived options (fresh buffer, the same
  *      growable allocator carries forward so the new buffer also grows in
  *      place).
  *   3. Restore live rows + prefix regions. Archetypes without a row count
- *      contributed no snapshot and stay zero-initialised; prefix regions
+ *      contributed no snapshot and stay zero-initialised. Prefix regions
  *      overwrite the empty state `createColumnStore` initialised.
  *   4. Bump `view_stamp` from the pre-capture value and patch the returned
- *      header so its cached `viewStamp` matches the buffer bytes just
- *      written — `createColumnStore` stamped it 0. `capacity` /
+ *      header so its cached `viewStamp` matches the bytes written above.
+ *      `createColumnStore` stamped it 0. `capacity` and
  *      `archetype_count` are already correct (createColumnStore sized them),
- *      so the spread carries them — and the internal `_allocator` /
- *      `_regionBytes` fields — through unchanged.
+ *      so the spread carries them, and the internal `_allocator` and
+ *      `_regionBytes` fields, through unchanged.
  *
- * Every view in the returned store is fresh; callers MUST refresh
- * (`viewsPreserved: false` is the callers' contract with THEIR callers).
+ * Every view in the returned store is fresh. Callers must refresh
+ * (`viewsPreserved: false` is the callers' contract with their callers).
  */
 export declare function reallocAndRepublish(old: ColumnStore, specs: readonly ArchetypeSpec[], rowCountsById: Map<number, number>, allocator: BufferAllocator | undefined): {
     store: ColumnStore;