@oasys/oecs 0.5.3 → 0.6.0

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

@@ -4,40 +4,46 @@ export { REGION_TABLE_ENTRY_BYTES, REGION_TABLE_ENTRY_OFFSETS };
  * distinct within its region set, that it also resolves on the read side),
  * computes `bytes`, and seeds the region header + contents in `init`.
  *
- * `init` runs ONCE at first allocation. Across a SAB grow/extend the region's
+ * `init` runs once at first allocation. Across a SAB grow and extend the region's
  * live bytes are snapshotted and restored verbatim (the table is
- * self-describing), so `init` is not re-run — a consumer must not rely on it
+ * self-describing), so `init` is not re-run, a consumer must not rely on it
  * firing per realloc. */
 export interface StoreRegionSpec {
-    /** Consumer-owned region id (nonzero, distinct). Written to the directory;
-     * resolved by the consumer via `findRegionOffset` / `abi.find_region`. */
+    /** Consumer-owned region id (nonzero, distinct). Written to the directory
+     * resolved by the consumer through `findRegionOffset`. */
     readonly id: number;
-    /** Human label for diagnostics / the self-documenting directory dump. */
+    /** Human label for diagnostics and the self-documenting directory dump. */
     readonly name: string;
     /** Byte size to allocate for this region (consumer computes from its knobs).
      * Must be > 0. */
     readonly bytes: number;
-    /** Initialise the region header + seed bytes at absolute byte offset `off`. */
+    /** Initialise the region header and seed bytes at `off`, which indexes
+     * `view`. `view` starts at the store base, so a consumer that needs a
+     * TypedArray builds it at `view.byteOffset + off`. */
     readonly init: (view: DataView, off: number) => void;
 }
-/** One decoded directory record. */
+/** One decoded directory record. `byteOffset` is measured from the store base,
+ * the same as every other offset in the bytes. */
 export interface RegionTableEntry {
     readonly regionId: number;
     readonly byteOffset: number;
     readonly byteLength: number;
 }
-/** A resolved handle to a consumer region, returned by `ECS.regionHandle` /
- * `Store.regionHandle`. Carries the live `buffer`/`view` plus the region's byte
+/** A resolved handle to a consumer region, returned by `ECS.regionHandle` or
+ * `Store.regionHandle`. Carries the live `buffer` and `view` plus the region's byte
  * `offset` and full `bytes`, so a consumer's region module can build a
  * TypedArray view over exactly the region's span without re-reading the
- * directory. Re-fetch after a SAB grow (the offset/view may have moved). */
+ * directory. Re-fetch after a SAB grow (the offset and view may have moved). */
 export interface ColumnStoreRegionHandle {
-    /** `ArrayBufferLike` — see `ColumnStore.buffer`. Consumer regions are a SAB-profile
-     * feature (WASM/worker), so in practice this is a `SharedArrayBuffer` wherever
-     * regions are declared; the type is widened only because it flows from the
+    /** `ArrayBufferLike`, see `ColumnStore.buffer`. Consumer regions are a SAB-profile
+     * feature (WASM or worker), so in practice this is a `SharedArrayBuffer` wherever
+     * regions are declared. The type is widened only because it flows from the
      * backing-agnostic store. */
     readonly buffer: ArrayBufferLike;
+    /** Starts at the store base, so `view.byteOffset` is that base. */
     readonly view: DataView;
+    /** Buffer-absolute, so `new Uint8Array(buffer, offset, bytes)` reads the
+     * region. Read it through `view` at `offset - view.byteOffset`. */
     readonly offset: number;
     readonly bytes: number;
 }
@@ -48,9 +54,9 @@ export declare class RegionRegistryError extends Error {
 export declare function regionTableBytes(count: number): number;
 /** Validate a consumer region set before layout: ids must be nonzero (0 is the
  * "absent" sentinel `findRegionOffset` returns) and distinct, and each region
- * must request a positive byte size. Throws `RegionRegistryError` otherwise —
+ * must request a positive byte size. Throws `RegionRegistryError` otherwise,
  * the same loud-failure stance the mechanism registry's paired-knob guards take. */
-export declare function validateRegionSpecs(regions: readonly StoreRegionSpec[]): void;
+export declare function assertRegionSpecs(regions: readonly StoreRegionSpec[]): void;
 /** Write one directory record at absolute byte offset `off`. */
 export declare function writeRegionTableEntry(view: DataView, off: number, e: RegionTableEntry): void;
 /** Read one directory record at absolute byte offset `off`. */
@@ -59,16 +65,17 @@ export declare function readRegionTableEntry(view: DataView, off: number): Regio
 export declare function writeRegionTable(view: DataView, tableOff: number, entries: readonly RegionTableEntry[]): void;
 /** Read all `count` directory records starting at `tableOff`, in order. */
 export declare function readRegionTable(view: DataView, tableOff: number, count: number): RegionTableEntry[];
-/** Read the directory described by the SAB header (`region_table_off` /
+/** Read the directory described by the SAB header (`region_table_off` and
  * `region_table_count`). Empty when no consumer regions were declared. */
 export declare function readHeaderRegionTable(view: DataView): RegionTableEntry[];
-/** Resolve a consumer region's byte offset by `region_id`, or 0 when absent
- * (no directory, or no matching entry). The TS twin of Zig
- * `abi.find_region(header_addr, region_id)`; 0 is an unambiguous "absent"
- * sentinel because a real region never starts at SAB byte 0 (the header does). */
+/** Resolve a consumer region's store-relative byte offset by `region_id`, or 0
+ * when absent (no directory, or no matching entry). The TS twin of the
+ * module-side lookup. 0 is an unambiguous "absent"
+ * sentinel because a real region never starts at relative offset 0, which the
+ * header occupies. */
 export declare function findRegionOffset(view: DataView, regionId: number): number;
 /** Resolve a consumer region's `(byte_offset, byte_length)` by `region_id`, or
  * `null` when absent. Use when a reader needs the region's size (e.g. to
- * materialise a TypedArray view) and not just its start. */
+ * materialise a TypedArray view) and not only its start. */
 export declare function findRegionEntry(view: DataView, regionId: number): RegionTableEntry | null;
 //# sourceMappingURL=region_table.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"region_table.d.ts","sourceRoot":"","sources":["../../../src/core/store/region_table.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EACN,wBAAwB,EACxB,0BAA0B,EAE1B,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,wBAAwB,EAAE,0BAA0B,EAAE,CAAC;AAEhE;;;;;;;yBAOyB;AACzB,MAAM,WAAW,eAAe;IAC/B;8EAC0E;IAC1E,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;sBACkB;IAClB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CACrD;AAED,oCAAoC;AACpC,MAAM,WAAW,gBAAgB;IAChC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC5B;AAED;;;;4EAI4E;AAC5E,MAAM,WAAW,uBAAuB;IACvC;;;iCAG6B;IAC7B,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACvB;AAED,qBAAa,mBAAoB,SAAQ,KAAK;gBACjC,OAAO,EAAE,MAAM;CAI3B;AAED,kEAAkE;AAClE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEtD;AAiBD;;;oFAGoF;AACpF,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,GAAG,IAAI,CAqB7E;AAED,gEAAgE;AAChE,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAI5F;AAED,+DAA+D;AAC/D,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,gBAAgB,CAMlF;AAED,4DAA4D;AAC5D,wBAAgB,gBAAgB,CAC/B,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,SAAS,gBAAgB,EAAE,GAClC,IAAI,CAIN;AAED,2EAA2E;AAC3E,wBAAgB,eAAe,CAC9B,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,GACX,gBAAgB,EAAE,CAMpB;AAED;0EAC0E;AAC1E,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,QAAQ,GAAG,gBAAgB,EAAE,CAKxE;AAED;;;kFAGkF;AAClF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAWzE;AAED;;4DAE4D;AAC5D,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CASzF"}
+{"version":3,"file":"region_table.d.ts","sourceRoot":"","sources":["../../../src/core/store/region_table.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EACN,wBAAwB,EACxB,0BAA0B,EAE1B,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,wBAAwB,EAAE,0BAA0B,EAAE,CAAC;AAEhE;;;;;;;yBAOyB;AACzB,MAAM,WAAW,eAAe;IAC/B;8DAC0D;IAC1D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,2EAA2E;IAC3E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;sBACkB;IAClB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;;0DAEsD;IACtD,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CACrD;AAED;kDACkD;AAClD,MAAM,WAAW,gBAAgB;IAChC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC5B;AAED;;;;gFAIgF;AAChF,MAAM,WAAW,uBAAuB;IACvC;;;iCAG6B;IAC7B,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC,mEAAmE;IACnE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB;uEACmE;IACnE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACvB;AAED,qBAAa,mBAAoB,SAAQ,KAAK;gBACjC,OAAO,EAAE,MAAM;CAI3B;AAED,kEAAkE;AAClE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEtD;AAiBD;;;oFAGoF;AACpF,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,GAAG,IAAI,CAqB3E;AAED,gEAAgE;AAChE,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAI5F;AAED,+DAA+D;AAC/D,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,gBAAgB,CAMlF;AAED,4DAA4D;AAC5D,wBAAgB,gBAAgB,CAC/B,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,SAAS,gBAAgB,EAAE,GAClC,IAAI,CAIN;AAED,2EAA2E;AAC3E,wBAAgB,eAAe,CAC9B,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,GACX,gBAAgB,EAAE,CAMpB;AAED;0EAC0E;AAC1E,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,QAAQ,GAAG,gBAAgB,EAAE,CAKxE;AAED;;;;sBAIsB;AACtB,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAWzE;AAED;;4DAE4D;AAC5D,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CASzF"}

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

@@ -1,43 +1,58 @@
 import { ColumnStore } from './column_store.cjs';
 import { BufferAllocator } from './allocator.cjs';
-export declare class StoreRestoreError extends Error {
-    constructor(message: string);
+import { StoreRestoreError } from '../restore_errors.cjs';
+export { StoreRestoreError };
+/** Options for `restoreColumnStore`. */
+export interface RestoreColumnStoreOptions {
+    /** Byte offset inside the fresh backing where the restored header goes.
+     * Default 0. A snapshot carries no base, so a store taken at one base
+     * restores at any other. */
+    readonly storeBase?: number;
 }
 /** Zero-copy `Uint8Array` view over the SAB's used byte range. Length is
- * `header.capacity` — the canonical size, NOT `buffer.byteLength`. The two
+ * `header.capacity`, the canonical size, not `buffer.byteLength`. The two
  * coincide for `DEFAULT_SAB_ALLOCATOR` (it allocates exactly `totalBytes`),
- * but `wasmMemoryAllocator` / `growableSabAllocator` round the buffer up
- * to 64 KiB page boundaries, so `buffer.byteLength` can exceed `capacity` by up
- * to a page of trailing slack (see the allocator contract in `allocator.ts`).
+ * but `wasmMemoryAllocator` rounds the buffer up to 64 KiB page boundaries,
+ * and `heapArrayBufferAllocator` and `fixedSabAllocator` reserve the whole cap,
+ * so `buffer.byteLength` can exceed `capacity` (see the allocator contract in
+ * `allocator.ts`).
  * Hashing or round-tripping that slack would make two logically-identical
  * stores with different grow trajectories (or different allocators) diverge,
  * so we size to `capacity` here.
  *
  * Capacity is read live from `store.view` rather than the cached
- * `store.header` — the in-place grow path bumps the header fields in the
+ * `store.header`, the in-place grow path bumps the header fields in the
  * view but leaves `store.header` a stale snapshot (see `grow.ts`).
  *
- * The view shares storage with the SAB; subsequent writes to columns are
+ * The span starts at `store.storeBase`, so the bytes are base free: two stores
+ * with the same history at different bases give the same snapshot and the same
+ * digest.
+ *
+ * The view shares storage with the backing. Subsequent writes to columns are
  * visible through it. Callers that need a stable snapshot should slice
  * (`new Uint8Array(view)`) before mutating the store further. */
-export declare function snapshotColumnStore(store: ColumnStore): Uint8Array;
+export declare function columnStoreBytesView(store: ColumnStore): Uint8Array;
 /** Allocate a fresh backing buffer of `bytes.byteLength`, copy the snapshot
  * bytes in, validate the header, and reconstruct the `ColumnStore` (header cache +
  * DataView + per-archetype `ArchetypeViews`).
  *
  * `allocator` selects the backing: the default `DEFAULT_SAB_ALLOCATOR`
- * (`SharedArrayBuffer`) keeps existing callers' behaviour; pass
- * `heapArraybufferAllocator()` to round-trip a snapshot into a pure-TS heap
- * world (no SAB required). Either way only one allocation happens — restore
- * never grows — so a non-in-place allocator is fine here.
+ * (`SharedArrayBuffer`) keeps existing callers' behaviour. Pass
+ * `heapArrayBufferAllocator()` to round-trip a snapshot into a pure-TS heap
+ * world (no SAB required). Either way only one allocation happens, restore
+ * never grows, so a non-in-place allocator is fine here.
  *
- * The input can be any `Uint8Array` — a view from `snapshotColumnStore`,
- * a sliced copy, or bytes read off disk / postMessage. The function
+ * The input can be any `Uint8Array`, a view from `columnStoreBytesView`,
+ * a sliced copy, or bytes read off disk or off `postMessage`. The function
  * honours `bytes.byteOffset` and `bytes.byteLength`, so passing a
  * subarray that doesn't start at offset 0 of its backing buffer is
  * supported.
  *
+ * `options.storeBase` places the restored header at that byte offset in the
+ * fresh backing, default 0. The snapshot itself carries no base, so a store
+ * taken at one base restores at any other and both digests agree.
+ *
  * Throws `StoreRestoreError` if the bytes are too short for the header,
  * have the wrong magic, or carry an incompatible `sim_abi_version`. */
-export declare function restoreColumnStore(bytes: Uint8Array, allocator?: BufferAllocator): ColumnStore;
+export declare function restoreColumnStore(bytes: Uint8Array, allocator?: BufferAllocator, options?: RestoreColumnStoreOptions): ColumnStore;
 //# sourceMappingURL=snapshot.d.ts.map

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

@@ -1,43 +1,58 @@
 import { ColumnStore } from './column_store.js';
 import { BufferAllocator } from './allocator.js';
-export declare class StoreRestoreError extends Error {
-    constructor(message: string);
+import { StoreRestoreError } from '../restore_errors.js';
+export { StoreRestoreError };
+/** Options for `restoreColumnStore`. */
+export interface RestoreColumnStoreOptions {
+    /** Byte offset inside the fresh backing where the restored header goes.
+     * Default 0. A snapshot carries no base, so a store taken at one base
+     * restores at any other. */
+    readonly storeBase?: number;
 }
 /** Zero-copy `Uint8Array` view over the SAB's used byte range. Length is
- * `header.capacity` — the canonical size, NOT `buffer.byteLength`. The two
+ * `header.capacity`, the canonical size, not `buffer.byteLength`. The two
  * coincide for `DEFAULT_SAB_ALLOCATOR` (it allocates exactly `totalBytes`),
- * but `wasmMemoryAllocator` / `growableSabAllocator` round the buffer up
- * to 64 KiB page boundaries, so `buffer.byteLength` can exceed `capacity` by up
- * to a page of trailing slack (see the allocator contract in `allocator.ts`).
+ * but `wasmMemoryAllocator` rounds the buffer up to 64 KiB page boundaries,
+ * and `heapArrayBufferAllocator` and `fixedSabAllocator` reserve the whole cap,
+ * so `buffer.byteLength` can exceed `capacity` (see the allocator contract in
+ * `allocator.ts`).
  * Hashing or round-tripping that slack would make two logically-identical
  * stores with different grow trajectories (or different allocators) diverge,
  * so we size to `capacity` here.
  *
  * Capacity is read live from `store.view` rather than the cached
- * `store.header` — the in-place grow path bumps the header fields in the
+ * `store.header`, the in-place grow path bumps the header fields in the
  * view but leaves `store.header` a stale snapshot (see `grow.ts`).
  *
- * The view shares storage with the SAB; subsequent writes to columns are
+ * The span starts at `store.storeBase`, so the bytes are base free: two stores
+ * with the same history at different bases give the same snapshot and the same
+ * digest.
+ *
+ * The view shares storage with the backing. Subsequent writes to columns are
  * visible through it. Callers that need a stable snapshot should slice
  * (`new Uint8Array(view)`) before mutating the store further. */
-export declare function snapshotColumnStore(store: ColumnStore): Uint8Array;
+export declare function columnStoreBytesView(store: ColumnStore): Uint8Array;
 /** Allocate a fresh backing buffer of `bytes.byteLength`, copy the snapshot
  * bytes in, validate the header, and reconstruct the `ColumnStore` (header cache +
  * DataView + per-archetype `ArchetypeViews`).
  *
  * `allocator` selects the backing: the default `DEFAULT_SAB_ALLOCATOR`
- * (`SharedArrayBuffer`) keeps existing callers' behaviour; pass
- * `heapArraybufferAllocator()` to round-trip a snapshot into a pure-TS heap
- * world (no SAB required). Either way only one allocation happens — restore
- * never grows — so a non-in-place allocator is fine here.
+ * (`SharedArrayBuffer`) keeps existing callers' behaviour. Pass
+ * `heapArrayBufferAllocator()` to round-trip a snapshot into a pure-TS heap
+ * world (no SAB required). Either way only one allocation happens, restore
+ * never grows, so a non-in-place allocator is fine here.
  *
- * The input can be any `Uint8Array` — a view from `snapshotColumnStore`,
- * a sliced copy, or bytes read off disk / postMessage. The function
+ * The input can be any `Uint8Array`, a view from `columnStoreBytesView`,
+ * a sliced copy, or bytes read off disk or off `postMessage`. The function
  * honours `bytes.byteOffset` and `bytes.byteLength`, so passing a
  * subarray that doesn't start at offset 0 of its backing buffer is
  * supported.
  *
+ * `options.storeBase` places the restored header at that byte offset in the
+ * fresh backing, default 0. The snapshot itself carries no base, so a store
+ * taken at one base restores at any other and both digests agree.
+ *
  * Throws `StoreRestoreError` if the bytes are too short for the header,
  * have the wrong magic, or carry an incompatible `sim_abi_version`. */
-export declare function restoreColumnStore(bytes: Uint8Array, allocator?: BufferAllocator): ColumnStore;
+export declare function restoreColumnStore(bytes: Uint8Array, allocator?: BufferAllocator, options?: RestoreColumnStoreOptions): ColumnStore;
 //# sourceMappingURL=snapshot.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"snapshot.d.ts","sourceRoot":"","sources":["../../../src/core/store/snapshot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAUH,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACvE,OAAO,EAAyB,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAE1E,qBAAa,iBAAkB,SAAQ,KAAK;gBAC/B,OAAO,EAAE,MAAM;CAI3B;AAED;;;;;;;;;;;;;;;;iEAgBiE;AACjE,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,WAAW,GAAG,UAAU,CAGlE;AAED;;;;;;;;;;;;;;;;;uEAiBuE;AACvE,wBAAgB,kBAAkB,CACjC,KAAK,EAAE,UAAU,EACjB,SAAS,GAAE,eAAuC,GAChD,WAAW,CAiEb"}
+{"version":3,"file":"snapshot.d.ts","sourceRoot":"","sources":["../../../src/core/store/snapshot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAkBH,OAAO,EAAkD,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClG,OAAO,EAAyB,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAG1E,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtD,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAE7B,wCAAwC;AACxC,MAAM,WAAW,yBAAyB;IACzC;;gCAE4B;IAC5B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;iEAqBiE;AACjE,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,WAAW,GAAG,UAAU,CAGnE;AAoED;;;;;;;;;;;;;;;;;;;;;uEAqBuE;AACvE,wBAAgB,kBAAkB,CACjC,KAAK,EAAE,UAAU,EACjB,SAAS,GAAE,eAAuC,EAClD,OAAO,GAAE,yBAA8B,GACrC,WAAW,CAoGb"}

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

@@ -1,23 +1,23 @@
 import { ColumnStore } from './column_store.cjs';
-/** FNV-1a 32-bit offset basis (Fowler/Noll/Vo). */
+/** FNV-1a 32-bit offset basis (Fowler, Noll and Vo). */
 export declare const FNV1A_OFFSET_BASIS = 2166136261;
 /** FNV-1a 32-bit prime. */
 export declare const FNV1A_PRIME = 16777619;
 /** One FNV-1a round folding a single **byte** (the low 8 bits of `b`) into the
  * running `hash`: `hash = imul((hash ^ (b & 0xff)) >>> 0, PRIME) >>> 0`. The
- * single canonical definition of the byte step (#498) — reused by `fnv1a32`
- * here, by the sparse-store `schemaFingerprint`, and by the server determinism
- * byte/u32 folds, so the constants and the round live in exactly one place.
+ * single canonical definition of the byte step, reused by `fnv1a32`
+ * here, by the sparse-store `schemaFingerprint`, and by the determinism
+ * byte and u32 folds, so the constants and the round live in exactly one place.
  *
- * Trivially inlinable (monomorphic, no allocation); the intermediate `>>> 0`s
- * never change a later round (xor/imul see the same 32-bit pattern signed or
- * unsigned), they just keep the value unsigned for readers. */
+ * Trivially inlinable, monomorphic and allocation-free. The intermediate `>>> 0`s
+ * never change a later round (xor and imul see the same 32-bit pattern signed or
+ * unsigned), they only keep the value unsigned for readers. */
 export declare function fnv1aStep(hash: number, b: number): number;
-/** One FNV-1a round folding a full 32-bit **word** into `hash` — the whole word
+/** One FNV-1a round folding a full 32-bit **word** into `hash`, the whole word
  * xored at once, not four byte rounds. A coarser fold than per-byte FNV-1a, but
- * equally deterministic and ~4× cheaper, which is why `Store.stateHash` folds
- * its columns this way (#326). This is the canonical word-step definition its
- * cold sparse/relation folds call; its hot dense-column inner loop inlines this
+ * equally deterministic and far cheaper, which is why `Store.stateHash` folds
+ * its columns this way. This is the canonical word-step definition its
+ * cold sparse and relation folds call. Its hot dense-column inner loop inlines this
  * exact step for speed and must stay in sync. Same `>>> 0` reasoning as
  * `fnv1aStep`. */
 export declare function fnv1aStepWord(hash: number, word: number): number;
@@ -28,11 +28,11 @@ export declare function fnv1aStepWord(hash: number, word: number): number;
  * snapshot, bytes off disk, a hot subrange) can hash without round-tripping
  * through `ColumnStore`. */
 export declare function fnv1a32(bytes: Uint8Array): number;
-/** FNV-1a 32-bit hash of the entire SAB region — header + descriptors +
+/** FNV-1a 32-bit hash of the entire SAB region, header + descriptors +
  * column bytes. The canonical state identifier for cross-replay determinism
- * checks (#171 plan exit criterion §6.1.7).
+ * checks.
  *
- * The snapshot view is zero-copy (`snapshotColumnStore` is a view, not a
+ * The snapshot view is zero-copy (`columnStoreBytesView` is a view, not a
  * copy), so this is one scan over the live SAB with no allocation. */
 export declare function columnStoreStateHash(store: ColumnStore): number;
 //# sourceMappingURL=state_hash.d.ts.map

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

@@ -1,23 +1,23 @@
 import { ColumnStore } from './column_store.js';
-/** FNV-1a 32-bit offset basis (Fowler/Noll/Vo). */
+/** FNV-1a 32-bit offset basis (Fowler, Noll and Vo). */
 export declare const FNV1A_OFFSET_BASIS = 2166136261;
 /** FNV-1a 32-bit prime. */
 export declare const FNV1A_PRIME = 16777619;
 /** One FNV-1a round folding a single **byte** (the low 8 bits of `b`) into the
  * running `hash`: `hash = imul((hash ^ (b & 0xff)) >>> 0, PRIME) >>> 0`. The
- * single canonical definition of the byte step (#498) — reused by `fnv1a32`
- * here, by the sparse-store `schemaFingerprint`, and by the server determinism
- * byte/u32 folds, so the constants and the round live in exactly one place.
+ * single canonical definition of the byte step, reused by `fnv1a32`
+ * here, by the sparse-store `schemaFingerprint`, and by the determinism
+ * byte and u32 folds, so the constants and the round live in exactly one place.
  *
- * Trivially inlinable (monomorphic, no allocation); the intermediate `>>> 0`s
- * never change a later round (xor/imul see the same 32-bit pattern signed or
- * unsigned), they just keep the value unsigned for readers. */
+ * Trivially inlinable, monomorphic and allocation-free. The intermediate `>>> 0`s
+ * never change a later round (xor and imul see the same 32-bit pattern signed or
+ * unsigned), they only keep the value unsigned for readers. */
 export declare function fnv1aStep(hash: number, b: number): number;
-/** One FNV-1a round folding a full 32-bit **word** into `hash` — the whole word
+/** One FNV-1a round folding a full 32-bit **word** into `hash`, the whole word
  * xored at once, not four byte rounds. A coarser fold than per-byte FNV-1a, but
- * equally deterministic and ~4× cheaper, which is why `Store.stateHash` folds
- * its columns this way (#326). This is the canonical word-step definition its
- * cold sparse/relation folds call; its hot dense-column inner loop inlines this
+ * equally deterministic and far cheaper, which is why `Store.stateHash` folds
+ * its columns this way. This is the canonical word-step definition its
+ * cold sparse and relation folds call. Its hot dense-column inner loop inlines this
  * exact step for speed and must stay in sync. Same `>>> 0` reasoning as
  * `fnv1aStep`. */
 export declare function fnv1aStepWord(hash: number, word: number): number;
@@ -28,11 +28,11 @@ export declare function fnv1aStepWord(hash: number, word: number): number;
  * snapshot, bytes off disk, a hot subrange) can hash without round-tripping
  * through `ColumnStore`. */
 export declare function fnv1a32(bytes: Uint8Array): number;
-/** FNV-1a 32-bit hash of the entire SAB region — header + descriptors +
+/** FNV-1a 32-bit hash of the entire SAB region, header + descriptors +
  * column bytes. The canonical state identifier for cross-replay determinism
- * checks (#171 plan exit criterion §6.1.7).
+ * checks.
  *
- * The snapshot view is zero-copy (`snapshotColumnStore` is a view, not a
+ * The snapshot view is zero-copy (`columnStoreBytesView` is a view, not a
  * copy), so this is one scan over the live SAB with no allocation. */
 export declare function columnStoreStateHash(store: ColumnStore): number;
 //# sourceMappingURL=state_hash.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"state_hash.d.ts","sourceRoot":"","sources":["../../../src/core/store/state_hash.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,mDAAmD;AACnD,eAAO,MAAM,kBAAkB,aAAa,CAAC;AAC7C,2BAA2B;AAC3B,eAAO,MAAM,WAAW,WAAa,CAAC;AAEtC;;;;;;;;+DAQ+D;AAC/D,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAGzD;AAED;;;;;;kBAMkB;AAClB,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAGhE;AAED;;;;;4BAK4B;AAC5B,wBAAgB,OAAO,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAIjD;AAED;;;;;sEAKsE;AACtE,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAE/D"}
+{"version":3,"file":"state_hash.d.ts","sourceRoot":"","sources":["../../../src/core/store/state_hash.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,wDAAwD;AACxD,eAAO,MAAM,kBAAkB,aAAa,CAAC;AAC7C,2BAA2B;AAC3B,eAAO,MAAM,WAAW,WAAa,CAAC;AAEtC;;;;;;;;+DAQ+D;AAC/D,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAGzD;AAED;;;;;;kBAMkB;AAClB,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAGhE;AAED;;;;;4BAK4B;AAC5B,wBAAgB,OAAO,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAIjD;AAED;;;;;sEAKsE;AACtE,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAE/D"}

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

@@ -1,8 +1,8 @@
 import { CreateColumnStoreOptions } from './column_store.cjs';
-/** The `StoreHeader` fields that hold a MECHANISM region's byte offset (0 ⇒
- * region absent). Exactly the four fields a `MechanismRegionSpec` can own; the
- * always-present `bindings_off` / `layout_descriptor_off` and the generic
- * `region_table_off` / `region_table_count` pair are not mechanism regions in
+/** The `StoreHeader` fields that hold a mechanism region's byte offset (0 ⇒
+ * region absent). Exactly the four fields a `MechanismRegionSpec` can own. The
+ * always-present `bindings_off` and `layout_descriptor_off`, and the generic
+ * `region_table_off` and `region_table_count` pair, are not mechanism regions in
  * this sense and are computed directly outside the loop. */
 export type StoreRegionOffsetField = "command_ring_off" | "entity_index_off" | "event_ring_off" | "action_ring_off";
 /** Mutable accumulator for building `CreateColumnStoreOptions` field by field as
@@ -10,18 +10,18 @@ export type StoreRegionOffsetField = "command_ring_off" | "entity_index_off" | "
 export type MutableColumnStoreOptions = {
     -readonly [K in keyof CreateColumnStoreOptions]: CreateColumnStoreOptions[K];
 };
-/** One engine MECHANISM region. The four closures are the per-region half of
- * each generic pass; see the module doc for which consumer drives which.
+/** One engine mechanism region. The four closures are the per-region half of
+ * each generic pass. See the module doc for which consumer drives which.
  *
- * (Consumer/game regions use the separate self-contained `StoreRegionSpec` in
- * `region_table.ts` — they carry a precomputed `bytes` + `init` and are
+ * (A consumer's own regions use the separate self-contained `StoreRegionSpec` in
+ * `region_table.ts`. They carry a precomputed `bytes` + `init` and are
  * addressed by an opaque `region_id`, not a named header field.) */
 export interface MechanismRegionSpec {
-    /** Stable name — reads in diagnostics and keeps the array self-documenting. */
+    /** Stable name, reads in diagnostics and keeps the array self-documenting. */
     readonly name: string;
     /** `StoreHeader` field this region's byte offset is written to. */
     readonly headerOff: StoreRegionOffsetField;
-    /** Byte size implied by `options` (0 ⇒ region absent, so no offset/init). */
+    /** Byte size implied by `options` (0 ⇒ region absent, so no offset and no init). */
     readonly sizeFromOptions: (options: CreateColumnStoreOptions) => number;
     /** Initialise the region's header at `off`. Called by `createColumnStore`
      * only when the region is present (`off !== 0`). */

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

@@ -1,8 +1,8 @@
 import { CreateColumnStoreOptions } from './column_store.js';
-/** The `StoreHeader` fields that hold a MECHANISM region's byte offset (0 ⇒
- * region absent). Exactly the four fields a `MechanismRegionSpec` can own; the
- * always-present `bindings_off` / `layout_descriptor_off` and the generic
- * `region_table_off` / `region_table_count` pair are not mechanism regions in
+/** The `StoreHeader` fields that hold a mechanism region's byte offset (0 ⇒
+ * region absent). Exactly the four fields a `MechanismRegionSpec` can own. The
+ * always-present `bindings_off` and `layout_descriptor_off`, and the generic
+ * `region_table_off` and `region_table_count` pair, are not mechanism regions in
  * this sense and are computed directly outside the loop. */
 export type StoreRegionOffsetField = "command_ring_off" | "entity_index_off" | "event_ring_off" | "action_ring_off";
 /** Mutable accumulator for building `CreateColumnStoreOptions` field by field as
@@ -10,18 +10,18 @@ export type StoreRegionOffsetField = "command_ring_off" | "entity_index_off" | "
 export type MutableColumnStoreOptions = {
     -readonly [K in keyof CreateColumnStoreOptions]: CreateColumnStoreOptions[K];
 };
-/** One engine MECHANISM region. The four closures are the per-region half of
- * each generic pass; see the module doc for which consumer drives which.
+/** One engine mechanism region. The four closures are the per-region half of
+ * each generic pass. See the module doc for which consumer drives which.
  *
- * (Consumer/game regions use the separate self-contained `StoreRegionSpec` in
- * `region_table.ts` — they carry a precomputed `bytes` + `init` and are
+ * (A consumer's own regions use the separate self-contained `StoreRegionSpec` in
+ * `region_table.ts`. They carry a precomputed `bytes` + `init` and are
  * addressed by an opaque `region_id`, not a named header field.) */
 export interface MechanismRegionSpec {
-    /** Stable name — reads in diagnostics and keeps the array self-documenting. */
+    /** Stable name, reads in diagnostics and keeps the array self-documenting. */
     readonly name: string;
     /** `StoreHeader` field this region's byte offset is written to. */
     readonly headerOff: StoreRegionOffsetField;
-    /** Byte size implied by `options` (0 ⇒ region absent, so no offset/init). */
+    /** Byte size implied by `options` (0 ⇒ region absent, so no offset and no init). */
     readonly sizeFromOptions: (options: CreateColumnStoreOptions) => number;
     /** Initialise the region's header at `off`. Called by `createColumnStore`
      * only when the region is present (`off !== 0`). */

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

@@ -1 +1 @@
-{"version":3,"file":"store_regions.d.ts","sourceRoot":"","sources":["../../../src/core/store/store_regions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAUH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAE/D;;;;4DAI4D;AAC5D,MAAM,MAAM,sBAAsB,GAC/B,kBAAkB,GAClB,kBAAkB,GAClB,gBAAgB,GAChB,iBAAiB,CAAC;AAErB;2EAC2E;AAC3E,MAAM,MAAM,yBAAyB,GAAG;IACvC,CAAC,UAAU,CAAC,IAAI,MAAM,wBAAwB,GAAG,wBAAwB,CAAC,CAAC,CAAC;CAC5E,CAAC;AAEF;;;;;oEAKoE;AACpE,MAAM,WAAW,mBAAmB;IACnC,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,mEAAmE;IACnE,QAAQ,CAAC,SAAS,EAAE,sBAAsB,CAAC;IAC3C,6EAA6E;IAC7E,QAAQ,CAAC,eAAe,EAAE,CAAC,OAAO,EAAE,wBAAwB,KAAK,MAAM,CAAC;IACxE;wDACoD;IACpD,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,wBAAwB,KAAK,IAAI,CAAC;IACxF;mEAC+D;IAC/D,QAAQ,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,KAAK,MAAM,CAAC;IAC9D;qEACiE;IACjE,QAAQ,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,yBAAyB,KAAK,IAAI,CAAC;CAC5F;AAED,+EAA+E;AAC/E,eAAO,MAAM,oBAAoB,EAAE,SAAS,mBAAmB,EAgE9D,CAAC"}
+{"version":3,"file":"store_regions.d.ts","sourceRoot":"","sources":["../../../src/core/store/store_regions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAUH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAE/D;;;;4DAI4D;AAC5D,MAAM,MAAM,sBAAsB,GAC/B,kBAAkB,GAClB,kBAAkB,GAClB,gBAAgB,GAChB,iBAAiB,CAAC;AAErB;2EAC2E;AAC3E,MAAM,MAAM,yBAAyB,GAAG;IACvC,CAAC,UAAU,CAAC,IAAI,MAAM,wBAAwB,GAAG,wBAAwB,CAAC,CAAC,CAAC;CAC5E,CAAC;AAEF;;;;;oEAKoE;AACpE,MAAM,WAAW,mBAAmB;IACnC,8EAA8E;IAC9E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,mEAAmE;IACnE,QAAQ,CAAC,SAAS,EAAE,sBAAsB,CAAC;IAC3C,oFAAoF;IACpF,QAAQ,CAAC,eAAe,EAAE,CAAC,OAAO,EAAE,wBAAwB,KAAK,MAAM,CAAC;IACxE;wDACoD;IACpD,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,wBAAwB,KAAK,IAAI,CAAC;IACxF;mEAC+D;IAC/D,QAAQ,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,KAAK,MAAM,CAAC;IAC9D;qEACiE;IACjE,QAAQ,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,yBAAyB,KAAK,IAAI,CAAC;CAC5F;AAED,+EAA+E;AAC/E,eAAO,MAAM,oBAAoB,EAAE,SAAS,mBAAmB,EA0D9D,CAAC"}

package/dist/core/store/vendored_abi/abi.d.cts

@@ -1,5 +1,29 @@
 export declare const STORE_MAGIC = 827148627;
-export declare const SIM_ABI_VERSION = 0;
+/** Schema version of the header, the descriptors and the region table.
+ *
+ * Version 1 makes every `*_off` in the header, every `byte_off` in a column
+ * descriptor and every region-table offset relative to the store base, and
+ * makes `capacity` the store span measured from that base. Version 0 measured
+ * all of them from buffer byte 0. Restore and resume reject a version they do
+ * not know, because the two readings of one offset disagree.
+ *
+ * Version 1 also reserves `entity_ids_off` in the archetype descriptor header.
+ * The version stays at 1 because no store of version 1 has shipped. Nothing
+ * outside this repository can hold the narrower header, so growing it now
+ * costs nothing. Reserving the field after the release costs a version bump
+ * and a reader that must branch on two header widths. */
+export declare const SIM_ABI_VERSION = 1;
+/** The version the published 0.5 line wrote. Every store of that version sat
+ * at buffer byte 0, so its offsets read correctly as version 1 offsets from the
+ * header. Restore and resume accept it and stamp the current version. */
+export declare const LEGACY_ABSOLUTE_ABI_VERSION = 0;
+/** The archetype descriptor header width version 0 wrote, before
+ * `entity_ids_off` joined the header. Every field version 0 carries sits at the
+ * offset version 1 gives it, so a version 0 region differs from a version 1
+ * region only in where the columns start and how far one record reaches.
+ * Restore walks a version 0 region with this width and re-emits it at the
+ * current width. */
+export declare const LEGACY_ARCHETYPE_DESCRIPTOR_HEADER_BYTES = 36;
 export declare const COMPONENT_MASK_WORDS = 4;
 export declare const STORE_HEADER_BYTES = 52;
 export declare const STORE_HEADER_OFFSETS: {
@@ -31,7 +55,7 @@ export declare const COLUMN_DESCRIPTOR_OFFSETS: {
     readonly byte_off: 8;
     readonly stride: 12;
 };
-export declare const ARCHETYPE_DESCRIPTOR_HEADER_BYTES = 36;
+export declare const ARCHETYPE_DESCRIPTOR_HEADER_BYTES = 40;
 export declare const ARCHETYPE_DESCRIPTOR_OFFSETS: {
     readonly archetype_id: 0;
     readonly component_mask: 4;
@@ -39,5 +63,6 @@ export declare const ARCHETYPE_DESCRIPTOR_OFFSETS: {
     readonly row_capacity: 24;
     readonly column_count: 28;
     readonly enabled_count: 32;
+    readonly entity_ids_off: 36;
 };
 //# sourceMappingURL=abi.d.ts.map

package/dist/core/store/vendored_abi/abi.d.ts

@@ -1,5 +1,29 @@
 export declare const STORE_MAGIC = 827148627;
-export declare const SIM_ABI_VERSION = 0;
+/** Schema version of the header, the descriptors and the region table.
+ *
+ * Version 1 makes every `*_off` in the header, every `byte_off` in a column
+ * descriptor and every region-table offset relative to the store base, and
+ * makes `capacity` the store span measured from that base. Version 0 measured
+ * all of them from buffer byte 0. Restore and resume reject a version they do
+ * not know, because the two readings of one offset disagree.
+ *
+ * Version 1 also reserves `entity_ids_off` in the archetype descriptor header.
+ * The version stays at 1 because no store of version 1 has shipped. Nothing
+ * outside this repository can hold the narrower header, so growing it now
+ * costs nothing. Reserving the field after the release costs a version bump
+ * and a reader that must branch on two header widths. */
+export declare const SIM_ABI_VERSION = 1;
+/** The version the published 0.5 line wrote. Every store of that version sat
+ * at buffer byte 0, so its offsets read correctly as version 1 offsets from the
+ * header. Restore and resume accept it and stamp the current version. */
+export declare const LEGACY_ABSOLUTE_ABI_VERSION = 0;
+/** The archetype descriptor header width version 0 wrote, before
+ * `entity_ids_off` joined the header. Every field version 0 carries sits at the
+ * offset version 1 gives it, so a version 0 region differs from a version 1
+ * region only in where the columns start and how far one record reaches.
+ * Restore walks a version 0 region with this width and re-emits it at the
+ * current width. */
+export declare const LEGACY_ARCHETYPE_DESCRIPTOR_HEADER_BYTES = 36;
 export declare const COMPONENT_MASK_WORDS = 4;
 export declare const STORE_HEADER_BYTES = 52;
 export declare const STORE_HEADER_OFFSETS: {
@@ -31,7 +55,7 @@ export declare const COLUMN_DESCRIPTOR_OFFSETS: {
     readonly byte_off: 8;
     readonly stride: 12;
 };
-export declare const ARCHETYPE_DESCRIPTOR_HEADER_BYTES = 36;
+export declare const ARCHETYPE_DESCRIPTOR_HEADER_BYTES = 40;
 export declare const ARCHETYPE_DESCRIPTOR_OFFSETS: {
     readonly archetype_id: 0;
     readonly component_mask: 4;
@@ -39,5 +63,6 @@ export declare const ARCHETYPE_DESCRIPTOR_OFFSETS: {
     readonly row_capacity: 24;
     readonly column_count: 28;
     readonly enabled_count: 32;
+    readonly entity_ids_off: 36;
 };
 //# sourceMappingURL=abi.d.ts.map

package/dist/core/store/vendored_abi/abi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"abi.d.ts","sourceRoot":"","sources":["../../../../src/core/store/vendored_abi/abi.ts"],"names":[],"mappings":"AAqBA,eAAO,MAAM,WAAW,YAAa,CAAC;AACtC,eAAO,MAAM,eAAe,IAAI,CAAC;AACjC,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC,eAAO,MAAM,kBAAkB,KAAK,CAAC;AACrC,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;CAcvB,CAAC;AAEX,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAC3C,eAAO,MAAM,0BAA0B;;;;CAI7B,CAAC;AAEX,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAC1C,eAAO,MAAM,yBAAyB;;;;;;CAM5B,CAAC;AAEX,eAAO,MAAM,iCAAiC,KAAK,CAAC;AACpD,eAAO,MAAM,4BAA4B;;;;;;;CAO/B,CAAC"}
+{"version":3,"file":"abi.d.ts","sourceRoot":"","sources":["../../../../src/core/store/vendored_abi/abi.ts"],"names":[],"mappings":"AAkBA,eAAO,MAAM,WAAW,YAAa,CAAC;AACtC;;;;;;;;;;;;yDAYyD;AACzD,eAAO,MAAM,eAAe,IAAI,CAAC;AACjC;;yEAEyE;AACzE,eAAO,MAAM,2BAA2B,IAAI,CAAC;AAC7C;;;;;oBAKoB;AACpB,eAAO,MAAM,wCAAwC,KAAK,CAAC;AAC3D,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC,eAAO,MAAM,kBAAkB,KAAK,CAAC;AACrC,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;CAcvB,CAAC;AAEX,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAC3C,eAAO,MAAM,0BAA0B;;;;CAI7B,CAAC;AAEX,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAC1C,eAAO,MAAM,yBAAyB;;;;;;CAM5B,CAAC;AAoBX,eAAO,MAAM,iCAAiC,KAAK,CAAC;AACpD,eAAO,MAAM,4BAA4B;;;;;;;;CAQ/B,CAAC"}