@oasys/oecs 0.5.3 → 0.5.4

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

@@ -1,10 +1,10 @@
 /**
- * BufferAllocator — pluggable buffer source for the SAB layer (#234 / PR 3D).
+ * BufferAllocator — pluggable buffer source for the SAB layer.
  *
  * The engine has historically allocated its SAB as a fresh
  * `new SharedArrayBuffer(totalBytes)` inside `createColumnStore`.
- * Phase 3D requires the SAB to optionally be backed by a
- * `WebAssembly.Memory.buffer` so the WASM sim can read/write the live
+ * A WASM backend needs the SAB to optionally be backed by a
+ * `WebAssembly.Memory.buffer` instead, so the sim can read and write the live
  * ECS columns through its own memory handle. This module abstracts the
  * "where does the buffer come from" decision behind a single function
  * type.
@@ -67,7 +67,7 @@ export interface BufferAllocator {
     readonly isInPlace?: boolean;
 }
 /**
- * The only allocator shape a **live `Store`** accepts (#682). ADR-0008 makes
+ * The only allocator shape a **live `Store`** accepts. The engine makes
  * "a live Store is backed by an in-place allocator" a correctness invariant —
  * the flush loops hoist entity-index views across grows. This brand moves
  * that invariant from runtime convention to the type/construction boundary:
@@ -86,10 +86,10 @@ export type InPlaceBufferAllocator = BufferAllocator & {
 };
 /**
  * Thrown when an allocator cannot satisfy a request because its by-design
- * byte ceiling is reached (#380: the cap is a runaway-growth signal, not a
+ * byte ceiling is reached (the cap is a runaway-growth signal, not a
  * limit to paper over — there is deliberately no grow-beyond-cap fallback).
  * Typed so `Store`'s grow handler can recognise the cap case and re-throw
- * with the caller's declared sizing intent attached (#682) without ever
+ * with the caller's declared sizing intent attached without ever
  * catching-to-recover.
  */
 export declare class StoreCapExceededError extends Error {
@@ -133,16 +133,16 @@ export declare const DEFAULT_SAB_ALLOCATOR: BufferAllocator;
  * in place rather than relocating).
  *
  * Sizing: `maxBytes` is committed *virtual* memory, not resident RAM —
- * physical pages fault in lazily as the SAB actually grows. Larger caps
- * cost more per allocation than smaller ones — Bun benchmark
- * `alloc(64,max=1GB)+grow(65568)` measures ~32 µs vs ~21 µs at 256 MB
- * and ~12 µs at 1 MB (V8 per-byte bookkeeping at construction).
- * Production callers with bigger worlds can pass a larger cap; the bench
- * gains are ~10 µs/Store-construction by staying under 256 MB.
+ * physical pages fault in lazily as the SAB actually grows. A larger cap costs
+ * more time per allocation than a smaller one, because V8 does per-byte
+ * bookkeeping when it constructs the buffer. The cost increases with the cap, so
+ * a 1 GiB cap is the slowest of the sizes we measured and a 1 MiB cap the
+ * quickest. A caller with a bigger world can pass a larger cap; a caller that
+ * stays under the 256 MiB default keeps the quicker Store construction.
  *
  * THE 256 MiB DEFAULT IS A HARD DESIGN CEILING, NOT A SOFT TARGET — and
  * exceeding it is INTENDED to be fatal. There is deliberately no
- * grow-beyond-cap fallback or compaction pass (see #380, and the loud
+ * grow-beyond-cap fallback or compaction pass (see the loud
  * note at the `bytes > maxBytes` throw below). If you are here because
  * a workload died at the cap and you are tempted to add a fresh-allocator
  * realloc fallback: don't, unless the numbers below have changed. They
@@ -169,40 +169,38 @@ export declare const DEFAULT_SAB_ALLOCATOR: BufferAllocator;
  * therefore signals a real defect upstream (runaway entity creation), not
  * a sizing shortfall to paper over.
  *
- * Cited verification (#237 audit, this branch): Bun runtime check
+ * Cited verification: a Bun runtime check
  * confirms `new Int32Array(buffer, off, len)` retains identical byteOffset,
  * length, and stored values after `.grow()`; DataView byteLength
  * auto-tracks the grown buffer.
  *
  * Used by the `extendColumnStore` fast path during lazy archetype
- * registration (#237 Option A) — keeps existing column views valid so
+ * registration — keeps existing column views valid so
  * `refreshViews` is a no-op for old archetypes.
  */
 export declare function growableSabAllocator(maxBytes?: number): InPlaceBufferAllocator;
 /**
  * Allocator that backs the store by a single **fixed (non-resizable) plain
  * `ArrayBuffer`** reserved at the full `maxBytes` cap up front. This is the
- * pure-TS **heap profile** — the oecs default and the answer to ADR-0018's
- * deferred §1B: no `SharedArrayBuffer`, hence no cross-origin isolation
+ * pure-TS **heap profile** — the oecs default: no `SharedArrayBuffer`,
+ * hence no cross-origin isolation
  * (COOP/COEP) requirement, and no worker/WASM transfer (single-process worlds
  * only).
  *
  * WHY FIXED, NOT RESIZABLE (the 0.5.3 iteration-perf fix): V8 has no fast
- * element-access path for TypedArray views over a **resizable/growable**
- * `ArrayBuffer` — every `col[i]` re-checks bounds against the buffer's mutable
- * length, a ~4× per-element tax measured on V8 13.6 (an isolated `col[i] *= 2`
- * loop: fixed `ArrayBuffer` ~1.6G vs a view over a resizable buffer ~0.37G
- * element-accesses/s). oecs 0.3.x gave each column its own fixed buffer and sat
- * mid-pack among SoA ECS libs; the 0.5.0 switch to one resizable arena silently
- * regressed all iteration-bound systems ~5× (the cross-library `packed_5`
- * scenario: 0.5.2 ~86k op/s → 0.5.3 ~420k). A fixed buffer restores the fast path.
+ * element-access path for TypedArray views over a **resizable or growable**
+ * `ArrayBuffer`, because each `col[i]` reads the mutable length again. Thus a
+ * loop over a column is much slower than the same loop over a fixed buffer.
+ * Version 0.3.x gave each column its own fixed buffer. The change in 0.5.0 to
+ * one resizable arena made every iteration-bound system slower, and it gave no
+ * signal. A fixed buffer restores the fast path.
  *
  * How growth still works in place: the cap is reserved as one fixed buffer at
  * construction. A resizable buffer was originally chosen so `.resize()` could
  * grow in place without moving views; a fixed buffer never moves EITHER — the
  * store's grow/extend relocate columns to the tail *within* this buffer
  * (`copyWithin`), so the buffer object and every existing view stay valid.
- * `isInPlace: true` therefore still holds, and ADR-0008's
+ * `isInPlace: true` therefore still holds, and the
  * entity-index-hoist-across-grow invariant is preserved. The store keys its
  * tail cursor off the header `capacity` (the logical high-water), NOT
  * `buffer.byteLength` — which is now always `maxBytes` (the same decoupling the
@@ -213,7 +211,7 @@ export declare function growableSabAllocator(maxBytes?: number): InPlaceBufferAl
  *     `maxByteLength` reservation — a 256 MiB reservation on a 1000-entity world
  *     stays a few MiB resident (measured ~4 MiB RSS, within ~1 MiB of the old
  *     resizable buffer).
- *   - same 256 MiB default cap with hard-ceiling semantics (#380): a request
+ *   - same 256 MiB default cap with hard-ceiling semantics: a request
  *     past `maxBytes` throws `StoreCapExceededError` — runaway growth signal,
  *     not a limit to route around.
  *
@@ -228,7 +226,7 @@ export declare function heapArraybufferAllocator(maxBytes?: number): InPlaceBuff
  * live SAB *be* a WASM module's `WebAssembly.Memory`. Grows the memory in
  * 64 KiB page increments when `bytes` exceeds the current buffer.
  *
- * This is the **opt-in storage backing for the WASM path** (#625). A consumer
+ * This is the **opt-in storage backing for the WASM path**. A consumer
  * that attaches a WASM `ComputeBackend` passes
  * `bufferAllocator: wasmMemoryAllocator(memory)` so the Zig systems read/write
  * the same bytes the host's columns live in — zero-copy across the FFI boundary.

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

@@ -1 +1 @@
-{"version":3,"file":"allocator.d.ts","sourceRoot":"","sources":["../../../src/core/store/allocator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,WAAW,eAAe;IAC/B;;;;;;;8BAO0B;IAC1B,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,CAAC;IACjC,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,sBAAsB,GAAG,eAAe,GAAG;IAAE,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAA;CAAE,CAAC;AAEpF;;;;;;;GAOG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;aAG9B,cAAc,EAAE,MAAM;IACtC;6DACyD;aACzC,QAAQ,EAAE,MAAM,GAAG,IAAI;gBAJvC,OAAO,EAAE,MAAM,EACC,cAAc,EAAE,MAAM;IACtC;6DACyD;IACzC,QAAQ,EAAE,MAAM,GAAG,IAAI,EACvC,OAAO,CAAC,EAAE,YAAY;CAKvB;AAED;;;;;;oEAMoE;AACpE,qBAAa,mBAAoB,SAAQ,KAAK;;CAe7C;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,EAAE,eAGnC,CAAC;AAgEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,GAAE,MAA0B,GAAG,sBAAsB,CA6BjG;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,wBAAwB,CACvC,QAAQ,GAAE,MAA0B,GAClC,sBAAsB,CAsBxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,GAAG,sBAAsB,CA6DtF"}
+{"version":3,"file":"allocator.d.ts","sourceRoot":"","sources":["../../../src/core/store/allocator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,WAAW,eAAe;IAC/B;;;;;;;8BAO0B;IAC1B,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,CAAC;IACjC,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,sBAAsB,GAAG,eAAe,GAAG;IAAE,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAA;CAAE,CAAC;AAEpF;;;;;;;GAOG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;aAG9B,cAAc,EAAE,MAAM;IACtC;6DACyD;aACzC,QAAQ,EAAE,MAAM,GAAG,IAAI;gBAJvC,OAAO,EAAE,MAAM,EACC,cAAc,EAAE,MAAM;IACtC;6DACyD;IACzC,QAAQ,EAAE,MAAM,GAAG,IAAI,EACvC,OAAO,CAAC,EAAE,YAAY;CAKvB;AAED;;;;;;oEAMoE;AACpE,qBAAa,mBAAoB,SAAQ,KAAK;;CAe7C;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,EAAE,eAGnC,CAAC;AAgEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,GAAE,MAA0B,GAAG,sBAAsB,CA6BjG;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,wBAAwB,CACvC,QAAQ,GAAE,MAA0B,GAClC,sBAAsB,CAsBxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,GAAG,sBAAsB,CA4DtF"}

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

@@ -23,8 +23,8 @@ export declare class BufferBackedColumn<T extends AnyTypedArray> implements Colu
      * `newView` already (`growColumnStore` does this). The logical length is
      * preserved across the swap; capacity becomes `newView.length`.
      *
-     * Used to honour the `view_stamp` invariant after a host-side SAB realloc
-     * (#171 §6.1.4 / §8.1): every cached column view must be rebuilt before
+     * Used to honour the `view_stamp` invariant after a host-side SAB realloc:
+     * every cached column view must be rebuilt before
      * the next read/write. */
     refreshView(newView: T): void;
     get length(): number;
@@ -39,15 +39,14 @@ export declare class BufferBackedColumn<T extends AnyTypedArray> implements Colu
     clear(): void;
     /** Set the logical length directly, declaring that `[0, len)` of the backing
      * SAB view already holds valid data. The snapshot-mount path
-     * (`Archetype.restoreHostRows`, #789) uses this to re-sync the column's
+     * (`Archetype.restoreHostRows`) uses this to re-sync the column's
      * logical length with the restored `Archetype.length` — the bytes come from
      * the restored SAB, but `_len` is host state. Throws on overrun (cannot grow
      * a fixed SAB view here — the mount already adopted the restored capacity). */
     setLength(len: number): void;
     /** Raw backing view. Stable for the lifetime of the SAB; views over a
      * SAB do not invalidate the way a `GrowableTypedArray`'s `buf` does
-     * after a grow. (`view_stamp` will signal "underlying SAB swapped"
-     * once #171 §6.1.4 lands.) */
+     * after a grow. (`view_stamp` signals "underlying SAB swapped".) */
     get buf(): T;
     /** Zero-copy subarray of valid data (`0..length-1`). */
     view(): T;
@@ -55,7 +54,7 @@ export declare class BufferBackedColumn<T extends AnyTypedArray> implements Colu
     /** Throw if the backing view cannot hold `capacity` elements. Mirrors
      * `GrowableTypedArray.ensureCapacity` but cannot allocate — a SAB
      * grow requires republishing the underlying buffer and rebuilding views
-     * across every archetype, which is the §6.1.4 invariant. */
+     * across every archetype, which is the republish invariant. */
     ensureCapacity(capacity: number): void;
     /** Append `count` elements from `src[srcOffset..srcOffset+count]`.
      * Throws on overrun. */

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

@@ -23,8 +23,8 @@ export declare class BufferBackedColumn<T extends AnyTypedArray> implements Colu
      * `newView` already (`growColumnStore` does this). The logical length is
      * preserved across the swap; capacity becomes `newView.length`.
      *
-     * Used to honour the `view_stamp` invariant after a host-side SAB realloc
-     * (#171 §6.1.4 / §8.1): every cached column view must be rebuilt before
+     * Used to honour the `view_stamp` invariant after a host-side SAB realloc:
+     * every cached column view must be rebuilt before
      * the next read/write. */
     refreshView(newView: T): void;
     get length(): number;
@@ -39,15 +39,14 @@ export declare class BufferBackedColumn<T extends AnyTypedArray> implements Colu
     clear(): void;
     /** Set the logical length directly, declaring that `[0, len)` of the backing
      * SAB view already holds valid data. The snapshot-mount path
-     * (`Archetype.restoreHostRows`, #789) uses this to re-sync the column's
+     * (`Archetype.restoreHostRows`) uses this to re-sync the column's
      * logical length with the restored `Archetype.length` — the bytes come from
      * the restored SAB, but `_len` is host state. Throws on overrun (cannot grow
      * a fixed SAB view here — the mount already adopted the restored capacity). */
     setLength(len: number): void;
     /** Raw backing view. Stable for the lifetime of the SAB; views over a
      * SAB do not invalidate the way a `GrowableTypedArray`'s `buf` does
-     * after a grow. (`view_stamp` will signal "underlying SAB swapped"
-     * once #171 §6.1.4 lands.) */
+     * after a grow. (`view_stamp` signals "underlying SAB swapped".) */
     get buf(): T;
     /** Zero-copy subarray of valid data (`0..length-1`). */
     view(): T;
@@ -55,7 +54,7 @@ export declare class BufferBackedColumn<T extends AnyTypedArray> implements Colu
     /** Throw if the backing view cannot hold `capacity` elements. Mirrors
      * `GrowableTypedArray.ensureCapacity` but cannot allocate — a SAB
      * grow requires republishing the underlying buffer and rebuilding views
-     * across every archetype, which is the §6.1.4 invariant. */
+     * across every archetype, which is the republish invariant. */
     ensureCapacity(capacity: number): void;
     /** Append `count` elements from `src[srcOffset..srcOffset+count]`.
      * Throws on overrun. */

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

@@ -1 +1 @@
-{"version":3,"file":"buffer_backed_column.d.ts","sourceRoot":"","sources":["../../../src/core/store/buffer_backed_column.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEpD;;;6EAG6E;AAC7E,qBAAa,wBAAyB,SAAQ,KAAK;IAClD,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,SAAS,EAAE,MAAM,CAAC;gBAEtB,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;CAM/C;AAED,qBAAa,kBAAkB,CAAC,CAAC,SAAS,aAAa,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;IACnF,OAAO,CAAC,IAAI,CAAI;IAChB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,IAAI,CAAK;IAEjB;;;0EAGsE;gBAC1D,IAAI,EAAE,CAAC;IAKnB;;;;;;;8BAO0B;IACnB,WAAW,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI;IAQpC,IAAW,MAAM,IAAI,MAAM,CAE1B;IAED,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAEM,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAOzB,GAAG,IAAI,MAAM;IAIb,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAItB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAI5C;gFAC4E;IACrE,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAM7B,KAAK,IAAI,IAAI;IAIpB;;;;;mFAK+E;IACxE,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAOnC;;;kCAG8B;IAC9B,IAAW,GAAG,IAAI,CAAC,CAElB;IAED,wDAAwD;IACjD,IAAI,IAAI,CAAC;IAQhB,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC;IAYrC;;;gEAG4D;IACrD,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAM7C;4BACwB;IACjB,UAAU,CAAC,GAAG,EAAE,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAQjE,gDAAgD;IACzC,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAM5C;gEAC4D;IACrD,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;CAK1D"}
+{"version":3,"file":"buffer_backed_column.d.ts","sourceRoot":"","sources":["../../../src/core/store/buffer_backed_column.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEpD;;;6EAG6E;AAC7E,qBAAa,wBAAyB,SAAQ,KAAK;IAClD,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,SAAS,EAAE,MAAM,CAAC;gBAEtB,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;CAM/C;AAED,qBAAa,kBAAkB,CAAC,CAAC,SAAS,aAAa,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;IACnF,OAAO,CAAC,IAAI,CAAI;IAChB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,IAAI,CAAK;IAEjB;;;0EAGsE;gBAC1D,IAAI,EAAE,CAAC;IAKnB;;;;;;;8BAO0B;IACnB,WAAW,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI;IAQpC,IAAW,MAAM,IAAI,MAAM,CAE1B;IAED,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAEM,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAOzB,GAAG,IAAI,MAAM;IAIb,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAItB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAI5C;gFAC4E;IACrE,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAM7B,KAAK,IAAI,IAAI;IAIpB;;;;;mFAK+E;IACxE,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAOnC;;wEAEoE;IACpE,IAAW,GAAG,IAAI,CAAC,CAElB;IAED,wDAAwD;IACjD,IAAI,IAAI,CAAC;IAQhB,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC;IAYrC;;;mEAG+D;IACxD,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAM7C;4BACwB;IACjB,UAAU,CAAC,GAAG,EAAE,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAQjE,gDAAgD;IACzC,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAM5C;gEAC4D;IACrD,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;CAK1D"}

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

@@ -88,12 +88,12 @@ export declare function columnKey(componentId: number, fieldId: number): number;
  * real matches three orders of magnitude below this, but the cap is tunable
  * and callers are invited to raise it for bigger worlds — so the layout step
  * guards the hard 2³¹ ceiling explicitly rather than relying on the policy
- * cap to stay in front of it (#382). */
+ * cap to stay in front of it. */
 export declare const STORE_MAX_BYTE_OFFSET: number;
 /** Thrown when a SAB column layout would place an offset at or beyond
  * {@link STORE_MAX_BYTE_OFFSET} (2³¹), past which the signed-32-bit bitwise
  * `alignUp` can no longer produce correct offsets. This is a hard ceiling,
- * not the (tunable, much lower) 256 MiB allocator cap — see #382. */
+ * not the (tunable, much lower) 256 MiB allocator cap. */
 export declare class StoreLayoutOverflowError extends Error {
     constructor(byteOff: number);
 }
@@ -102,7 +102,7 @@ export declare class StoreLayoutOverflowError extends Error {
  *
  * Throws {@link StoreLayoutOverflowError} when the rounded offset would reach
  * {@link STORE_MAX_BYTE_OFFSET}, because the `& ~(align-1)` step coerces to a
- * signed 32-bit int and wraps past 2³¹ (#382). The guard fires before the
+ * signed 32-bit int and wraps past 2³¹. The guard fires before the
  * bitwise op so any returned offset is always a correct, in-range value.
  * Shared by `extend.ts` and `grow.ts`, whose in-place paths compute tail
  * byte_offs without going through `planLayout`. */
@@ -114,12 +114,12 @@ export declare function alignUp(off: number, align: number): number;
  * `headroomBytes` reserves slack at the end of the descriptor region — ON
  * TOP OF the natural size for `specs` — so future extends can append new
  * descriptor entries without shifting existing column byte_offs. Used by
- * the growable-SAB path (#237 Option A) — column views stay valid across
+ * the growable-SAB path — column views stay valid across
  * `extendColumnStore` because their byte_offs don't move.
  *
- * Additive, not a floor (#541): `regionSize = natural + headroom`, NOT
+ * Additive, not a floor: `regionSize = natural + headroom`, NOT
  * `max(natural, headroom)`. A floor only yields slack while `natural` is
- * below it; the moment the descriptor region outgrows the floor (the #237
+ * below it; the moment the descriptor region outgrows the floor (the
  * headroom exhausts and a realloc re-plans the merged spec set), a floor
  * would size the region to exactly `natural` — zero slack — and every
  * subsequent extend would take the slow realloc path forever after. The
@@ -138,11 +138,11 @@ export { planLayout };
 /** Optional configuration for `createColumnStore`. */
 export interface CreateColumnStoreOptions {
     /** Extra slack to reserve at the end of the layout descriptor region,
-     * ON TOP OF the natural size for `specs` (#541 — additive, not a floor).
+     * ON TOP OF the natural size for `specs` (additive, not a floor).
      * The descriptor region is padded with this many unused bytes so future
      * `extendColumnStore` calls can append new archetype descriptors into the
      * slack without shifting existing column byte_offs. Pairs with
-     * `growableSabAllocator` to give the #237 Option A fast path: existing
+     * `growableSabAllocator` to give the in-place fast path: existing
      * TypedArray column views stay valid across extends because their offsets
      * and the underlying buffer both stay put.
      *
@@ -150,9 +150,9 @@ export interface CreateColumnStoreOptions {
      * value lives on `ColumnStoreInternal._reservedDescriptorBytes` and
      * `optionsFromOld` re-applies it, so a store that exhausts its headroom
      * and reallocs gets a fresh margin rather than dropping to zero slack and
-     * going permanently slow (#541). */
+     * going permanently slow. */
     readonly reservedDescriptorBytes?: number;
-    /** When provided, allocates a command ring (#171 §7.5, Phase 4) inside
+    /** When provided, allocates a command ring inside
      * the SAB at a stable offset right after the 48-byte header. Slot
      * count MUST be a power of two; `COMMAND_RING_DEFAULT_CAPACITY_SLOTS`
      * (256) is the canonical value. Omitted ⇒ no ring; `command_ring_off`
@@ -164,8 +164,8 @@ export interface CreateColumnStoreOptions {
      * `growColumnStore` calls, since those grow the descriptor region and
      * the column tail but never the bytes between header and descriptor. */
     readonly commandRingCapacitySlots?: number;
-    /** When provided, allocates the entity-index region (#245 / Phase 4
-     * PR 4B) inside the SAB at a stable offset between the command ring
+    /** When provided, allocates the entity-index region inside the SAB at a
+     * stable offset between the command ring
      * (or header) and the descriptor region. Holds `(generations,
      * archetypes, rows)` triples indexed by entity slot; the engine's
      * `Store` populates them as entities are created/moved/destroyed,
@@ -176,7 +176,7 @@ export interface CreateColumnStoreOptions {
      * `ENTITY_INDEX_DEFAULT_CAPACITY`; bare-SAB tests can leave it
      * absent. */
     readonly entityIndexCapacity?: number;
-    /** When provided, allocates the event ring (#247 / Phase 4 PR 4C)
+    /** When provided, allocates the event ring
      * inside the SAB at a stable offset between the entity-index region
      * and the descriptor region. Same SPSC shape as the command ring;
      * carries ECS signal payloads so Zig systems can emit and consume
@@ -185,9 +185,9 @@ export interface CreateColumnStoreOptions {
      * Slot count MUST be a power of two; `EVENT_RING_DEFAULT_CAPACITY_SLOTS`
      * (256) is the canonical value. Omitted ⇒ no ring; `event_ring_off`
      * stays at 0 ("absent"); existing test fixtures with hand-rolled
-     * SABs see the pre-#247 layout. */
+     * SABs see the layout without it. */
     readonly eventRingCapacitySlots?: number;
-    /** When provided, allocates the action ring (#291 / Phase 5 PR 5L)
+    /** When provided, allocates the action ring
      * inside the SAB at a stable offset between the entity-index/event-ring
      * and the region-table directory. Main writes encoded actions to it;
      * the sim worker drains them on each apply.
@@ -197,7 +197,7 @@ export interface CreateColumnStoreOptions {
      * stays at 0 ("absent"); bare-SAB tests skip it. (Engine mechanism — the
      * `Store` allocates one always-on; it is no longer a public ECS option.) */
     readonly actionRingCapacitySlots?: number;
-    /** Consumer-declared SAB regions (#623). Each `StoreRegionSpec` carries an
+    /** Consumer-declared SAB regions. Each `StoreRegionSpec` carries an
      * opaque `region_id`, a precomputed byte size, and an `init` closure; the
      * engine lays them out after the mechanism regions, writes a generic
      * region-table directory (`region_table.ts`) keyed by `region_id`, and
@@ -216,7 +216,7 @@ export interface CreateColumnStoreOptions {
      * Omitted / 0 ⇒ NO bindings region (`bindings_off` stays 0, "absent") — the
      * default for a pure-TS game that pays nothing for the WASM seam. This used
      * to be the engine-baked `SIM_BINDINGS_BYTES` ABI constant reflected from the
-     * game's Zig struct; #625 de-welded it so a manifest edit no longer dirties
+     * game's Zig struct; it is now de-welded, so a manifest edit no longer dirties
      * the engine ABI golden. Re-derived across realloc by `optionsFromOld`
      * (= `layout_descriptor_off - bindings_off`), so it survives grow/extend
      * without a carried policy field. */
@@ -235,12 +235,12 @@ export interface ColumnStoreInternal extends ColumnStore {
      * holds the absolute region size (natural + this), and once `natural`
      * outgrows the margin the two are indistinguishable. The realloc slow path
      * reads it via `optionsFromOld` and re-reserves the same margin, so a
-     * store that exhausts its headroom and reallocs keeps taking the #237
-     * in-place fast path instead of going permanently slow (#541). The
+     * store that exhausts its headroom and reallocs keeps taking the
+     * in-place fast path instead of going permanently slow. The
      * `*_in_place` paths carry it forward verbatim. */
     readonly _reservedDescriptorBytes: number;
 }
-/** Typed recovery of `ColumnStoreInternal` from a public `ColumnStore` (M8).
+/** Typed recovery of `ColumnStoreInternal` from a public `ColumnStore`.
  * Not every store is internal: `restoreColumnStore` deliberately returns a
  * plain `{ buffer, view, header, archetypes }` (a snapshot carries no JS-side
  * allocator or headroom policy), and grow/extend must send such a store down
@@ -252,8 +252,8 @@ export declare function isColumnStoreInternal(store: ColumnStore): store is Colu
  * and construct one TypedArray view per column.
  *
  * The returned `ColumnStore` is the source of truth for "where every column
- * lives in this SAB". `view_stamp` is initialised to 0 — a Phase 4 SAB
- * grow flow will bump it. (#171 §6.1.4 / §8.1) */
+ * lives in this SAB". `view_stamp` is initialised to 0 — a SAB
+ * grow flow bumps it. */
 export declare function createColumnStore(specs: readonly ArchetypeSpec[], allocator?: BufferAllocator, options?: CreateColumnStoreOptions): ColumnStore;
 /** Default command-ring slot count used by `ECS.Store` when constructing
  * its SAB. Re-exported here so the Store doesn't reach across modules. */

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

@@ -88,12 +88,12 @@ export declare function columnKey(componentId: number, fieldId: number): number;
  * real matches three orders of magnitude below this, but the cap is tunable
  * and callers are invited to raise it for bigger worlds — so the layout step
  * guards the hard 2³¹ ceiling explicitly rather than relying on the policy
- * cap to stay in front of it (#382). */
+ * cap to stay in front of it. */
 export declare const STORE_MAX_BYTE_OFFSET: number;
 /** Thrown when a SAB column layout would place an offset at or beyond
  * {@link STORE_MAX_BYTE_OFFSET} (2³¹), past which the signed-32-bit bitwise
  * `alignUp` can no longer produce correct offsets. This is a hard ceiling,
- * not the (tunable, much lower) 256 MiB allocator cap — see #382. */
+ * not the (tunable, much lower) 256 MiB allocator cap. */
 export declare class StoreLayoutOverflowError extends Error {
     constructor(byteOff: number);
 }
@@ -102,7 +102,7 @@ export declare class StoreLayoutOverflowError extends Error {
  *
  * Throws {@link StoreLayoutOverflowError} when the rounded offset would reach
  * {@link STORE_MAX_BYTE_OFFSET}, because the `& ~(align-1)` step coerces to a
- * signed 32-bit int and wraps past 2³¹ (#382). The guard fires before the
+ * signed 32-bit int and wraps past 2³¹. The guard fires before the
  * bitwise op so any returned offset is always a correct, in-range value.
  * Shared by `extend.ts` and `grow.ts`, whose in-place paths compute tail
  * byte_offs without going through `planLayout`. */
@@ -114,12 +114,12 @@ export declare function alignUp(off: number, align: number): number;
  * `headroomBytes` reserves slack at the end of the descriptor region — ON
  * TOP OF the natural size for `specs` — so future extends can append new
  * descriptor entries without shifting existing column byte_offs. Used by
- * the growable-SAB path (#237 Option A) — column views stay valid across
+ * the growable-SAB path — column views stay valid across
  * `extendColumnStore` because their byte_offs don't move.
  *
- * Additive, not a floor (#541): `regionSize = natural + headroom`, NOT
+ * Additive, not a floor: `regionSize = natural + headroom`, NOT
  * `max(natural, headroom)`. A floor only yields slack while `natural` is
- * below it; the moment the descriptor region outgrows the floor (the #237
+ * below it; the moment the descriptor region outgrows the floor (the
  * headroom exhausts and a realloc re-plans the merged spec set), a floor
  * would size the region to exactly `natural` — zero slack — and every
  * subsequent extend would take the slow realloc path forever after. The
@@ -138,11 +138,11 @@ export { planLayout };
 /** Optional configuration for `createColumnStore`. */
 export interface CreateColumnStoreOptions {
     /** Extra slack to reserve at the end of the layout descriptor region,
-     * ON TOP OF the natural size for `specs` (#541 — additive, not a floor).
+     * ON TOP OF the natural size for `specs` (additive, not a floor).
      * The descriptor region is padded with this many unused bytes so future
      * `extendColumnStore` calls can append new archetype descriptors into the
      * slack without shifting existing column byte_offs. Pairs with
-     * `growableSabAllocator` to give the #237 Option A fast path: existing
+     * `growableSabAllocator` to give the in-place fast path: existing
      * TypedArray column views stay valid across extends because their offsets
      * and the underlying buffer both stay put.
      *
@@ -150,9 +150,9 @@ export interface CreateColumnStoreOptions {
      * value lives on `ColumnStoreInternal._reservedDescriptorBytes` and
      * `optionsFromOld` re-applies it, so a store that exhausts its headroom
      * and reallocs gets a fresh margin rather than dropping to zero slack and
-     * going permanently slow (#541). */
+     * going permanently slow. */
     readonly reservedDescriptorBytes?: number;
-    /** When provided, allocates a command ring (#171 §7.5, Phase 4) inside
+    /** When provided, allocates a command ring inside
      * the SAB at a stable offset right after the 48-byte header. Slot
      * count MUST be a power of two; `COMMAND_RING_DEFAULT_CAPACITY_SLOTS`
      * (256) is the canonical value. Omitted ⇒ no ring; `command_ring_off`
@@ -164,8 +164,8 @@ export interface CreateColumnStoreOptions {
      * `growColumnStore` calls, since those grow the descriptor region and
      * the column tail but never the bytes between header and descriptor. */
     readonly commandRingCapacitySlots?: number;
-    /** When provided, allocates the entity-index region (#245 / Phase 4
-     * PR 4B) inside the SAB at a stable offset between the command ring
+    /** When provided, allocates the entity-index region inside the SAB at a
+     * stable offset between the command ring
      * (or header) and the descriptor region. Holds `(generations,
      * archetypes, rows)` triples indexed by entity slot; the engine's
      * `Store` populates them as entities are created/moved/destroyed,
@@ -176,7 +176,7 @@ export interface CreateColumnStoreOptions {
      * `ENTITY_INDEX_DEFAULT_CAPACITY`; bare-SAB tests can leave it
      * absent. */
     readonly entityIndexCapacity?: number;
-    /** When provided, allocates the event ring (#247 / Phase 4 PR 4C)
+    /** When provided, allocates the event ring
      * inside the SAB at a stable offset between the entity-index region
      * and the descriptor region. Same SPSC shape as the command ring;
      * carries ECS signal payloads so Zig systems can emit and consume
@@ -185,9 +185,9 @@ export interface CreateColumnStoreOptions {
      * Slot count MUST be a power of two; `EVENT_RING_DEFAULT_CAPACITY_SLOTS`
      * (256) is the canonical value. Omitted ⇒ no ring; `event_ring_off`
      * stays at 0 ("absent"); existing test fixtures with hand-rolled
-     * SABs see the pre-#247 layout. */
+     * SABs see the layout without it. */
     readonly eventRingCapacitySlots?: number;
-    /** When provided, allocates the action ring (#291 / Phase 5 PR 5L)
+    /** When provided, allocates the action ring
      * inside the SAB at a stable offset between the entity-index/event-ring
      * and the region-table directory. Main writes encoded actions to it;
      * the sim worker drains them on each apply.
@@ -197,7 +197,7 @@ export interface CreateColumnStoreOptions {
      * stays at 0 ("absent"); bare-SAB tests skip it. (Engine mechanism — the
      * `Store` allocates one always-on; it is no longer a public ECS option.) */
     readonly actionRingCapacitySlots?: number;
-    /** Consumer-declared SAB regions (#623). Each `StoreRegionSpec` carries an
+    /** Consumer-declared SAB regions. Each `StoreRegionSpec` carries an
      * opaque `region_id`, a precomputed byte size, and an `init` closure; the
      * engine lays them out after the mechanism regions, writes a generic
      * region-table directory (`region_table.ts`) keyed by `region_id`, and
@@ -216,7 +216,7 @@ export interface CreateColumnStoreOptions {
      * Omitted / 0 ⇒ NO bindings region (`bindings_off` stays 0, "absent") — the
      * default for a pure-TS game that pays nothing for the WASM seam. This used
      * to be the engine-baked `SIM_BINDINGS_BYTES` ABI constant reflected from the
-     * game's Zig struct; #625 de-welded it so a manifest edit no longer dirties
+     * game's Zig struct; it is now de-welded, so a manifest edit no longer dirties
      * the engine ABI golden. Re-derived across realloc by `optionsFromOld`
      * (= `layout_descriptor_off - bindings_off`), so it survives grow/extend
      * without a carried policy field. */
@@ -235,12 +235,12 @@ export interface ColumnStoreInternal extends ColumnStore {
      * holds the absolute region size (natural + this), and once `natural`
      * outgrows the margin the two are indistinguishable. The realloc slow path
      * reads it via `optionsFromOld` and re-reserves the same margin, so a
-     * store that exhausts its headroom and reallocs keeps taking the #237
-     * in-place fast path instead of going permanently slow (#541). The
+     * store that exhausts its headroom and reallocs keeps taking the
+     * in-place fast path instead of going permanently slow. The
      * `*_in_place` paths carry it forward verbatim. */
     readonly _reservedDescriptorBytes: number;
 }
-/** Typed recovery of `ColumnStoreInternal` from a public `ColumnStore` (M8).
+/** Typed recovery of `ColumnStoreInternal` from a public `ColumnStore`.
  * Not every store is internal: `restoreColumnStore` deliberately returns a
  * plain `{ buffer, view, header, archetypes }` (a snapshot carries no JS-side
  * allocator or headroom policy), and grow/extend must send such a store down
@@ -252,8 +252,8 @@ export declare function isColumnStoreInternal(store: ColumnStore): store is Colu
  * and construct one TypedArray view per column.
  *
  * The returned `ColumnStore` is the source of truth for "where every column
- * lives in this SAB". `view_stamp` is initialised to 0 — a Phase 4 SAB
- * grow flow will bump it. (#171 §6.1.4 / §8.1) */
+ * lives in this SAB". `view_stamp` is initialised to 0 — a SAB
+ * grow flow bumps it. */
 export declare function createColumnStore(specs: readonly ArchetypeSpec[], allocator?: BufferAllocator, options?: CreateColumnStoreOptions): ColumnStore;
 /** Default command-ring slot count used by `ECS.Store` when constructing
  * its SAB. Re-exported here so the Store doesn't reach across modules. */

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

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

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

@@ -1,6 +1,6 @@
 /**
  * Command dispatch — the generic drain surface a consumer registers against
- * (#624, game-agnostic ECS / epic #616).
+ * (a game-agnostic ECS).
  *
  * The command ring (`command_ring.ts`) carries opaque `(opCode, payload)`
  * slots; the engine never interprets a code. This module is the thin,

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

@@ -1,6 +1,6 @@
 /**
  * Command dispatch — the generic drain surface a consumer registers against
- * (#624, game-agnostic ECS / epic #616).
+ * (a game-agnostic ECS).
  *
  * The command ring (`command_ring.ts`) carries opaque `(opCode, payload)`
  * slots; the engine never interprets a code. This module is the thin,

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

@@ -1,7 +1,6 @@
 /**
  * Command ring — WASM-side producer / TS-side consumer SPSC ring buffer
- * for structural-change intents emitted during `sim.tick()`. Plan §7.5
- * (`docs/ideas/buffer-wasm-sim-plan-2026-05-14T1600.md`).
+ * for structural-change intents emitted during `sim.tick()`.
  *
  * Layout:
  *
@@ -13,13 +12,13 @@
  *   [ slot 1:       16 B ]  ...
  *   ...
  *
- * SPSC contract (Phase 4 scope):
+ * SPSC contract (single host thread):
  *   - Producer: WASM `sim.tick()`. Pushes 0..N commands during one tick;
  *     bumps `write_head` after each.
  *   - Consumer: TS host, immediately after `wasm.tick()` returns. Drains
  *     0..N pending commands; bumps `read_head` after each.
- *   - The two never run concurrently in Phase 4 (single host thread
- *     orchestrates both). Phase 5's worker offload promotes the head
+ *   - The two never run concurrently (one host thread orchestrates
+ *     both). A later worker offload promotes the head
  *     bumps to `Atomics.store`; that's an additive change without
  *     altering the layout.
  *
@@ -29,7 +28,7 @@
  *     a hard error in dev builds; production logs and continues (a command
  *     might be lost rather than crash the host).
  *
- * Slot format (plan §7.5):
+ * Slot format:
  *   byte 0:       opCode (u8). 0 is reserved as the empty-slot marker
  *                 (`COMMAND_OP_EMPTY`); all other codes are consumer-defined.
  *                 The engine never interprets a code — it drains
@@ -52,7 +51,7 @@ export declare const COMMAND_RING_HEADER_BYTES = 16;
 export declare const COMMAND_RING_SLOT_BYTES = 16;
 /** Default ring capacity in slots. 256 × 16 B = 4 KiB of ring data plus
  * 16 B header. Sized for the worst-case burst (peak spawn intents per
- * tick) × small safety margin. Tune up if a Phase 4 burst pushes past it
+ * tick) × small safety margin. Tune up if a burst pushes past it
  * in the bench harness. */
 export declare const COMMAND_RING_DEFAULT_CAPACITY_SLOTS = 256;
 /** Byte offsets within the ring header. Mirrored on the Zig side in