@oasys/oecs 0.3.1 → 0.5.0

package/dist/type_primitives/topological_sort/topological_sort.d.cts

@@ -0,0 +1,29 @@
+/***
+ * topologicalSort — Kahn's algorithm with a BinaryHeap ready queue.
+ *
+ * Accepts an arbitrary node set, a dependency edge map, and a tiebreaker
+ * comparator used to order nodes that are simultaneously ready (zero in-degree).
+ * This makes the output deterministic and priority-driven rather than
+ * insertion-order dependent.
+ *
+ * Throws a built-in TypeError when a cycle is detected, listing the names of
+ * the nodes that could not be scheduled.
+ *
+ ***/
+/**
+ * Topologically sorts `nodes` respecting the dependency edges, breaking ties
+ * with the supplied comparator.
+ *
+ * @param nodes      - All items to sort.
+ * @param edges      - Adjacency list: `edges.get(a)` = items that must come after `a`.
+ * @param tiebreaker - Comparator for the ready queue (min-heap semantics: lower = higher priority).
+ * @param nodeName  - Optional label function for cycle error messages. Defaults to `String(node)`.
+ * @returns Sorted array in topological order.
+ * @throws {TypeError} If a cycle is detected among the nodes.
+ */
+/**
+ * Topologically sorts `nodes` respecting dependency edges, breaking ties with the comparator.
+ *
+ */
+export declare function topologicalSort<T>(nodes: readonly T[], edges: Map<T, T[]>, tiebreaker: (a: T, b: T) => number, nodeName?: (node: T) => string): T[];
+//# sourceMappingURL=topological_sort.d.ts.map

package/dist/type_primitives/topological_sort/topological_sort.d.ts

@@ -1,5 +1,5 @@
 /***
- * topological_sort — Kahn's algorithm with a BinaryHeap ready queue.
+ * topologicalSort — Kahn's algorithm with a BinaryHeap ready queue.
  *
  * Accepts an arbitrary node set, a dependency edge map, and a tiebreaker
  * comparator used to order nodes that are simultaneously ready (zero in-degree).
@@ -17,9 +17,13 @@
  * @param nodes      - All items to sort.
  * @param edges      - Adjacency list: `edges.get(a)` = items that must come after `a`.
  * @param tiebreaker - Comparator for the ready queue (min-heap semantics: lower = higher priority).
- * @param node_name  - Optional label function for cycle error messages. Defaults to `String(node)`.
+ * @param nodeName  - Optional label function for cycle error messages. Defaults to `String(node)`.
  * @returns Sorted array in topological order.
  * @throws {TypeError} If a cycle is detected among the nodes.
  */
-export declare function topological_sort<T>(nodes: readonly T[], edges: Map<T, T[]>, tiebreaker: (a: T, b: T) => number, node_name?: (node: T) => string): T[];
+/**
+ * Topologically sorts `nodes` respecting dependency edges, breaking ties with the comparator.
+ *
+ */
+export declare function topologicalSort<T>(nodes: readonly T[], edges: Map<T, T[]>, tiebreaker: (a: T, b: T) => number, nodeName?: (node: T) => string): T[];
 //# sourceMappingURL=topological_sort.d.ts.map

package/dist/type_primitives/topological_sort/topological_sort.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"topological_sort.d.ts","sourceRoot":"","sources":["../../../src/type_primitives/topological_sort/topological_sort.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;KAWK;AAIL;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,KAAK,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAClB,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,EAClC,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAC9B,CAAC,EAAE,CA8DL"}
+{"version":3,"file":"topological_sort.d.ts","sourceRoot":"","sources":["../../../src/type_primitives/topological_sort/topological_sort.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;KAWK;AAIL;;;;;;;;;;GAUG;AACH;;;GAGG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAChC,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,KAAK,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAClB,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,EAClC,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAC5B,CAAC,EAAE,CA8DL"}

package/dist/type_primitives/typed_arrays/typed_arrays.d.cts

@@ -0,0 +1,127 @@
+/***
+ * GrowableTypedArray — TypedArray wrapper with amortised O(1) append.
+ *
+ * TypedArrays have fixed length — resizing requires allocating a new
+ * buffer and copying. GrowableTypedArray wraps one with a separate
+ * logical length and doubles the backing buffer on overflow.
+ *
+ * Named subclasses (GrowableFloat32Array etc.) are provided for each
+ * numeric type. TypedArrayFor maps TypeTag strings to their class so
+ * component columns can be allocated by tag.
+ *
+ ***/
+export declare const DEFAULT_INITIAL_CAPACITY = 16;
+export declare const GROWTH_FACTOR = 2;
+export type TypedArrayTag = "f32" | "f64" | "i8" | "i16" | "i32" | "u8" | "u16" | "u32";
+export type AnyTypedArray = Float32Array | Float64Array | Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array;
+/**
+ * Common surface of a row-addressable column buffer. `GrowableTypedArray<T>`
+ * implements it over a heap-allocated TypedArray; SAB-backed columns (see
+ * `packages/engine/src/core/sab/sab_backed_column.ts`) implement it over a
+ * `SharedArrayBuffer` view at a known offset. Archetype column storage
+ * targets this interface so a single code path serves both backings.
+ */
+export interface ColumnBacking<T extends AnyTypedArray> {
+    readonly length: number;
+    readonly buf: T;
+    push(value: number): void;
+    pop(): number;
+    swapRemove(i: number): number;
+    clear(): void;
+    view(): T;
+    ensureCapacity(capacity: number): void;
+    bulkAppend(src: T, srcOffset: number, count: number): void;
+    bulkAppendZeroes(count: number): void;
+    bulkAppendValue(value: number, count: number): void;
+    /** Set the logical length directly, declaring that `[0, len)` already holds
+     * valid data. The snapshot-mount path (`Archetype.restoreHostRows`, #789)
+     * uses this: a restored SAB carries the column bytes, but the column's logical
+     * length is host state that must be re-synced with `Archetype.length`. Throws
+     * if `len` exceeds capacity. NOT a hot-path method — push/pop track length. */
+    setLength(len: number): void;
+}
+/**
+ * TypedArray wrapper with amortised O(1) append. Doubles the backing buffer on overflow.
+ *
+ */
+export declare class GrowableTypedArray<T extends AnyTypedArray> implements ColumnBacking<T> {
+    private readonly _ctor;
+    private _buf;
+    private _len;
+    constructor(_ctor: new (n: number) => T, initialCapacity?: number);
+    get length(): number;
+    push(value: number): void;
+    pop(): number;
+    get(i: number): number;
+    setAt(i: number, value: number): void;
+    /**
+     * Move the last element into slot i, decrement length.
+     * Returns the value that was removed from slot i.
+     */
+    swapRemove(i: number): number;
+    clear(): void;
+    /** Set the logical length directly (snapshot-mount reconstruction, #789). The
+     * caller guarantees `[0, len)` already holds valid data. Grows the backing if
+     * needed so the length is always representable. */
+    setLength(len: number): void;
+    /**
+     * Raw backing buffer. Valid data: indices 0..length-1.
+     * This reference is stable until the next push() that triggers a grow —
+     * do not cache across entity additions.
+     */
+    get buf(): T;
+    /**
+     * Zero-copy subarray view of valid data (0..length-1).
+     * Shares the backing buffer — invalidated if a subsequent push() grows.
+     */
+    view(): T;
+    [Symbol.iterator](): Iterator<number>;
+    /** Ensure the backing buffer can hold at least `capacity` elements without growing. */
+    ensureCapacity(capacity: number): void;
+    /**
+     * Append `count` elements from `src` starting at `srcOffset`.
+     * Grows if needed. Equivalent to push() in a loop but uses TypedArray.set().
+     */
+    bulkAppend(src: T, srcOffset: number, count: number): void;
+    /** Append `count` zeroes. Grows if needed. */
+    bulkAppendZeroes(count: number): void;
+    /** Append `count` copies of `value`. Grows if needed. Single-pass
+     * analogue of `bulkAppendZeroes` for a non-zero default. */
+    bulkAppendValue(value: number, count: number): void;
+    private _grow;
+}
+export declare class GrowableFloat32Array extends GrowableTypedArray<Float32Array> {
+    constructor(initialCapacity?: number);
+}
+export declare class GrowableFloat64Array extends GrowableTypedArray<Float64Array> {
+    constructor(initialCapacity?: number);
+}
+export declare class GrowableInt8Array extends GrowableTypedArray<Int8Array> {
+    constructor(initialCapacity?: number);
+}
+export declare class GrowableInt16Array extends GrowableTypedArray<Int16Array> {
+    constructor(initialCapacity?: number);
+}
+export declare class GrowableInt32Array extends GrowableTypedArray<Int32Array> {
+    constructor(initialCapacity?: number);
+}
+export declare class GrowableUint8Array extends GrowableTypedArray<Uint8Array> {
+    constructor(initialCapacity?: number);
+}
+export declare class GrowableUint16Array extends GrowableTypedArray<Uint16Array> {
+    constructor(initialCapacity?: number);
+}
+export declare class GrowableUint32Array extends GrowableTypedArray<Uint32Array> {
+    constructor(initialCapacity?: number);
+}
+export declare const TypedArrayFor: {
+    readonly f32: typeof GrowableFloat32Array;
+    readonly f64: typeof GrowableFloat64Array;
+    readonly i8: typeof GrowableInt8Array;
+    readonly i16: typeof GrowableInt16Array;
+    readonly i32: typeof GrowableInt32Array;
+    readonly u8: typeof GrowableUint8Array;
+    readonly u16: typeof GrowableUint16Array;
+    readonly u32: typeof GrowableUint32Array;
+};
+//# sourceMappingURL=typed_arrays.d.ts.map

package/dist/type_primitives/typed_arrays/typed_arrays.d.ts

@@ -14,22 +14,56 @@ export declare const DEFAULT_INITIAL_CAPACITY = 16;
 export declare const GROWTH_FACTOR = 2;
 export type TypedArrayTag = "f32" | "f64" | "i8" | "i16" | "i32" | "u8" | "u16" | "u32";
 export type AnyTypedArray = Float32Array | Float64Array | Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array;
-export declare class GrowableTypedArray<T extends AnyTypedArray> {
+/**
+ * Common surface of a row-addressable column buffer. `GrowableTypedArray<T>`
+ * implements it over a heap-allocated TypedArray; SAB-backed columns (see
+ * `packages/engine/src/core/sab/sab_backed_column.ts`) implement it over a
+ * `SharedArrayBuffer` view at a known offset. Archetype column storage
+ * targets this interface so a single code path serves both backings.
+ */
+export interface ColumnBacking<T extends AnyTypedArray> {
+    readonly length: number;
+    readonly buf: T;
+    push(value: number): void;
+    pop(): number;
+    swapRemove(i: number): number;
+    clear(): void;
+    view(): T;
+    ensureCapacity(capacity: number): void;
+    bulkAppend(src: T, srcOffset: number, count: number): void;
+    bulkAppendZeroes(count: number): void;
+    bulkAppendValue(value: number, count: number): void;
+    /** Set the logical length directly, declaring that `[0, len)` already holds
+     * valid data. The snapshot-mount path (`Archetype.restoreHostRows`, #789)
+     * uses this: a restored SAB carries the column bytes, but the column's logical
+     * length is host state that must be re-synced with `Archetype.length`. Throws
+     * if `len` exceeds capacity. NOT a hot-path method — push/pop track length. */
+    setLength(len: number): void;
+}
+/**
+ * TypedArray wrapper with amortised O(1) append. Doubles the backing buffer on overflow.
+ *
+ */
+export declare class GrowableTypedArray<T extends AnyTypedArray> implements ColumnBacking<T> {
     private readonly _ctor;
     private _buf;
     private _len;
-    constructor(_ctor: new (n: number) => T, initial_capacity?: number);
+    constructor(_ctor: new (n: number) => T, initialCapacity?: number);
     get length(): number;
     push(value: number): void;
     pop(): number;
     get(i: number): number;
-    set_at(i: number, value: number): void;
+    setAt(i: number, value: number): void;
     /**
      * Move the last element into slot i, decrement length.
      * Returns the value that was removed from slot i.
      */
-    swap_remove(i: number): number;
+    swapRemove(i: number): number;
     clear(): void;
+    /** Set the logical length directly (snapshot-mount reconstruction, #789). The
+     * caller guarantees `[0, len)` already holds valid data. Grows the backing if
+     * needed so the length is always representable. */
+    setLength(len: number): void;
     /**
      * Raw backing buffer. Valid data: indices 0..length-1.
      * This reference is stable until the next push() that triggers a grow —
@@ -43,39 +77,42 @@ export declare class GrowableTypedArray<T extends AnyTypedArray> {
     view(): T;
     [Symbol.iterator](): Iterator<number>;
     /** Ensure the backing buffer can hold at least `capacity` elements without growing. */
-    ensure_capacity(capacity: number): void;
+    ensureCapacity(capacity: number): void;
     /**
-     * Append `count` elements from `src` starting at `src_offset`.
+     * Append `count` elements from `src` starting at `srcOffset`.
      * Grows if needed. Equivalent to push() in a loop but uses TypedArray.set().
      */
-    bulk_append(src: T, src_offset: number, count: number): void;
+    bulkAppend(src: T, srcOffset: number, count: number): void;
     /** Append `count` zeroes. Grows if needed. */
-    bulk_append_zeroes(count: number): void;
+    bulkAppendZeroes(count: number): void;
+    /** Append `count` copies of `value`. Grows if needed. Single-pass
+     * analogue of `bulkAppendZeroes` for a non-zero default. */
+    bulkAppendValue(value: number, count: number): void;
     private _grow;
 }
 export declare class GrowableFloat32Array extends GrowableTypedArray<Float32Array> {
-    constructor(initial_capacity?: number);
+    constructor(initialCapacity?: number);
 }
 export declare class GrowableFloat64Array extends GrowableTypedArray<Float64Array> {
-    constructor(initial_capacity?: number);
+    constructor(initialCapacity?: number);
 }
 export declare class GrowableInt8Array extends GrowableTypedArray<Int8Array> {
-    constructor(initial_capacity?: number);
+    constructor(initialCapacity?: number);
 }
 export declare class GrowableInt16Array extends GrowableTypedArray<Int16Array> {
-    constructor(initial_capacity?: number);
+    constructor(initialCapacity?: number);
 }
 export declare class GrowableInt32Array extends GrowableTypedArray<Int32Array> {
-    constructor(initial_capacity?: number);
+    constructor(initialCapacity?: number);
 }
 export declare class GrowableUint8Array extends GrowableTypedArray<Uint8Array> {
-    constructor(initial_capacity?: number);
+    constructor(initialCapacity?: number);
 }
 export declare class GrowableUint16Array extends GrowableTypedArray<Uint16Array> {
-    constructor(initial_capacity?: number);
+    constructor(initialCapacity?: number);
 }
 export declare class GrowableUint32Array extends GrowableTypedArray<Uint32Array> {
-    constructor(initial_capacity?: number);
+    constructor(initialCapacity?: number);
 }
 export declare const TypedArrayFor: {
     readonly f32: typeof GrowableFloat32Array;

package/dist/type_primitives/typed_arrays/typed_arrays.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typed_arrays.d.ts","sourceRoot":"","sources":["../../../src/type_primitives/typed_arrays/typed_arrays.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;KAWK;AAEL,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAC3C,eAAO,MAAM,aAAa,IAAI,CAAC;AAE/B,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,GAAG,KAAK,CAAC;AAExF,MAAM,MAAM,aAAa,GACrB,YAAY,GACZ,YAAY,GACZ,SAAS,GACT,UAAU,GACV,UAAU,GACV,UAAU,GACV,WAAW,GACX,WAAW,CAAC;AAEhB,qBAAa,kBAAkB,CAAC,CAAC,SAAS,aAAa;IAKnD,OAAO,CAAC,QAAQ,CAAC,KAAK;IAJxB,OAAO,CAAC,IAAI,CAAI;IAChB,OAAO,CAAC,IAAI,CAAK;gBAGE,KAAK,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,CAAC,EAC5C,gBAAgB,SAAK;IAKvB,IAAW,MAAM,IAAI,MAAM,CAE1B;IAEM,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAKzB,GAAG,IAAI,MAAM;IAIb,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAItB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAI7C;;;OAGG;IACI,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAM9B,KAAK,IAAI,IAAI;IAIpB;;;;OAIG;IACH,IAAW,GAAG,IAAI,CAAC,CAElB;IAED;;;OAGG;IACI,IAAI,IAAI,CAAC;IAIhB,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC;IAYrC,uFAAuF;IAChF,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAS9C;;;OAGG;IACI,WAAW,CAAC,GAAG,EAAE,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAMnE,8CAA8C;IACvC,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAM9C,OAAO,CAAC,KAAK;CAKd;AAED,qBAAa,oBAAqB,SAAQ,kBAAkB,CAAC,YAAY,CAAC;gBAC5D,gBAAgB,SAA2B;CAGxD;AAED,qBAAa,oBAAqB,SAAQ,kBAAkB,CAAC,YAAY,CAAC;gBAC5D,gBAAgB,SAA2B;CAGxD;AAED,qBAAa,iBAAkB,SAAQ,kBAAkB,CAAC,SAAS,CAAC;gBACtD,gBAAgB,SAA2B;CAGxD;AAED,qBAAa,kBAAmB,SAAQ,kBAAkB,CAAC,UAAU,CAAC;gBACxD,gBAAgB,SAA2B;CAGxD;AAED,qBAAa,kBAAmB,SAAQ,kBAAkB,CAAC,UAAU,CAAC;gBACxD,gBAAgB,SAA2B;CAGxD;AAED,qBAAa,kBAAmB,SAAQ,kBAAkB,CAAC,UAAU,CAAC;gBACxD,gBAAgB,SAA2B;CAGxD;AAED,qBAAa,mBAAoB,SAAQ,kBAAkB,CAAC,WAAW,CAAC;gBAC1D,gBAAgB,SAA2B;CAGxD;AAED,qBAAa,mBAAoB,SAAQ,kBAAkB,CAAC,WAAW,CAAC;gBAC1D,gBAAgB,SAA2B;CAGxD;AAED,eAAO,MAAM,aAAa;;;;;;;;;CASyE,CAAC"}
+{"version":3,"file":"typed_arrays.d.ts","sourceRoot":"","sources":["../../../src/type_primitives/typed_arrays/typed_arrays.ts"],"names":[],"mappings":"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"}

package/dist/typed_arrays-BcXcnzB4.js

@@ -0,0 +1,258 @@
+const w = 5, d = 31;
+class c {
+  _words;
+  constructor(t) {
+    this._words = t ?? new Array(4).fill(0);
+  }
+  has(t) {
+    const s = t >>> 5;
+    return s >= this._words.length ? !1 : (this._words[s] & 1 << (t & 31)) !== 0;
+  }
+  set(t) {
+    const s = t >>> 5;
+    s >= this._words.length && this.grow(s + 1), this._words[s] |= 1 << (t & 31);
+  }
+  clear(t) {
+    const s = t >>> 5;
+    s >= this._words.length || (this._words[s] &= ~(1 << (t & 31)));
+  }
+  /** True if no bit is set. */
+  isEmpty() {
+    const t = this._words;
+    for (let s = 0; s < t.length; s++)
+      if (t[s] !== 0) return !1;
+    return !0;
+  }
+  /** True if any bit is set in both this and other (non-empty intersection). */
+  overlaps(t) {
+    const s = this._words, e = t._words, r = s.length < e.length ? s.length : e.length;
+    for (let n = 0; n < r; n++)
+      if ((s[n] & e[n]) !== 0) return !0;
+    return !1;
+  }
+  /** True if this is a superset of other (all bits in other are set in this). */
+  contains(t) {
+    const s = t._words, e = this._words, r = e.length;
+    for (let n = 0; n < s.length; n++) {
+      const o = s[n];
+      if (o !== 0 && (n >= r || (e[n] & o) !== o))
+        return !1;
+    }
+    return !0;
+  }
+  equals(t) {
+    const s = this._words, e = t._words, r = s.length > e.length ? s.length : e.length;
+    for (let n = 0; n < r; n++) {
+      const o = n < s.length ? s[n] : 0, h = n < e.length ? e[n] : 0;
+      if (o !== h) return !1;
+    }
+    return !0;
+  }
+  copy() {
+    return new c(this._words.slice());
+  }
+  /** Mutate `target` so it has the same set bits as `this`. Reuses
+   * `target._words` storage when capacity allows (no allocation) and
+   * grows it only when `this` is wider. Designed for hot-path scratch
+   * BitSets where callers want `.copy()` semantics without the
+   * per-call allocation. Returns `target` for chaining. */
+  copyInto(t) {
+    const s = this._words, e = t._words, r = s.length, n = e.length;
+    if (n >= r) {
+      for (let o = 0; o < r; o++) e[o] = s[o];
+      for (let o = r; o < n; o++) e[o] = 0;
+    } else {
+      let o = n > 0 ? n : 1;
+      for (; o < r; ) o *= 2;
+      const h = new Array(o).fill(0);
+      for (let a = 0; a < r; a++) h[a] = s[a];
+      t._words = h;
+    }
+    return t;
+  }
+  copyWithSet(t) {
+    const s = t >>> 5, e = s + 1, r = this._words.length > e ? this._words.length : e, n = new Array(r).fill(0);
+    for (let o = 0; o < this._words.length; o++) n[o] = this._words[o];
+    return n[s] |= 1 << (t & 31), new c(n);
+  }
+  copyWithClear(t) {
+    const s = this._words.slice(), e = t >>> 5;
+    return e < s.length && (s[e] &= ~(1 << (t & 31))), new c(s);
+  }
+  /** FNV-1a hash. Skips trailing zero words so differently-sized arrays with the same bits hash equally. */
+  hash() {
+    let t = 2166136261;
+    const s = this._words;
+    let e = s.length - 1;
+    for (; e >= 0 && s[e] === 0; ) e--;
+    for (let r = 0; r <= e; r++)
+      t ^= s[r], t = Math.imul(t, 16777619);
+    return t;
+  }
+  /** Iterate all set bits via lowest-set-bit extraction. */
+  forEach(t) {
+    const s = this._words;
+    for (let e = 0; e < s.length; e++) {
+      let r = s[e];
+      if (r === 0) continue;
+      const n = e << 5;
+      for (; r !== 0; ) {
+        const o = r & -r >>> 0, h = 31 - Math.clz32(o);
+        t(n + h), r ^= o;
+      }
+    }
+  }
+  grow(t) {
+    let s = this._words.length;
+    for (; s < t; ) s *= 2;
+    const e = new Array(s).fill(0);
+    for (let r = 0; r < this._words.length; r++) e[r] = this._words[r];
+    this._words = e;
+  }
+}
+const i = 16, u = 2;
+class _ {
+  constructor(t, s = 16) {
+    this._ctor = t, this._buf = new t(s);
+  }
+  _buf;
+  _len = 0;
+  get length() {
+    return this._len;
+  }
+  push(t) {
+    this._len >= this._buf.length && this._grow(), this._buf[this._len++] = t;
+  }
+  pop() {
+    return this._buf[--this._len];
+  }
+  get(t) {
+    return this._buf[t];
+  }
+  setAt(t, s) {
+    this._buf[t] = s;
+  }
+  /**
+   * Move the last element into slot i, decrement length.
+   * Returns the value that was removed from slot i.
+   */
+  swapRemove(t) {
+    const s = this._buf[t];
+    return this._buf[t] = this._buf[--this._len], s;
+  }
+  clear() {
+    this._len = 0;
+  }
+  /** Set the logical length directly (snapshot-mount reconstruction, #789). The
+   * caller guarantees `[0, len)` already holds valid data. Grows the backing if
+   * needed so the length is always representable. */
+  setLength(t) {
+    this.ensureCapacity(t), this._len = t;
+  }
+  /**
+   * Raw backing buffer. Valid data: indices 0..length-1.
+   * This reference is stable until the next push() that triggers a grow —
+   * do not cache across entity additions.
+   */
+  get buf() {
+    return this._buf;
+  }
+  /**
+   * Zero-copy subarray view of valid data (0..length-1).
+   * Shares the backing buffer — invalidated if a subsequent push() grows.
+   */
+  view() {
+    return this._buf.subarray(0, this._len);
+  }
+  [Symbol.iterator]() {
+    let t = 0;
+    const s = this._buf, e = this._len;
+    return {
+      next() {
+        return t < e ? { value: s[t++], done: !1 } : { value: 0, done: !0 };
+      }
+    };
+  }
+  /** Ensure the backing buffer can hold at least `capacity` elements without growing. */
+  ensureCapacity(t) {
+    if (t <= this._buf.length) return;
+    let s = this._buf.length || 1;
+    for (; s < t; ) s *= u;
+    const e = new this._ctor(s);
+    e.set(this._buf.subarray(0, this._len)), this._buf = e;
+  }
+  /**
+   * Append `count` elements from `src` starting at `srcOffset`.
+   * Grows if needed. Equivalent to push() in a loop but uses TypedArray.set().
+   */
+  bulkAppend(t, s, e) {
+    this.ensureCapacity(this._len + e), this._buf.set(t.subarray(s, s + e), this._len), this._len += e;
+  }
+  /** Append `count` zeroes. Grows if needed. */
+  bulkAppendZeroes(t) {
+    this.ensureCapacity(this._len + t), this._buf.fill(0, this._len, this._len + t), this._len += t;
+  }
+  /** Append `count` copies of `value`. Grows if needed. Single-pass
+   * analogue of `bulkAppendZeroes` for a non-zero default. */
+  bulkAppendValue(t, s) {
+    this.ensureCapacity(this._len + s), this._buf.fill(t, this._len, this._len + s), this._len += s;
+  }
+  _grow() {
+    const t = new this._ctor(this._buf.length * u);
+    t.set(this._buf), this._buf = t;
+  }
+}
+class f extends _ {
+  constructor(t = i) {
+    super(Float32Array, t);
+  }
+}
+class I extends _ {
+  constructor(t = i) {
+    super(Float64Array, t);
+  }
+}
+class b extends _ {
+  constructor(t = i) {
+    super(Int8Array, t);
+  }
+}
+class A extends _ {
+  constructor(t = i) {
+    super(Int16Array, t);
+  }
+}
+class g extends _ {
+  constructor(t = i) {
+    super(Int32Array, t);
+  }
+}
+class y extends _ {
+  constructor(t = i) {
+    super(Uint8Array, t);
+  }
+}
+class R extends _ {
+  constructor(t = i) {
+    super(Uint16Array, t);
+  }
+}
+class S extends _ {
+  constructor(t = i) {
+    super(Uint32Array, t);
+  }
+}
+export {
+  c as B,
+  _ as G,
+  f as a,
+  I as b,
+  b as c,
+  A as d,
+  g as e,
+  y as f,
+  R as g,
+  S as h,
+  d as i,
+  w as j
+};

package/dist/typed_arrays-D3NmwtCG.cjs

@@ -0,0 +1 @@
+"use strict";class a{_words;constructor(t){this._words=t??new Array(4).fill(0)}has(t){const r=t>>>5;return r>=this._words.length?!1:(this._words[r]&1<<(t&31))!==0}set(t){const r=t>>>5;r>=this._words.length&&this.grow(r+1),this._words[r]|=1<<(t&31)}clear(t){const r=t>>>5;r>=this._words.length||(this._words[r]&=~(1<<(t&31)))}isEmpty(){const t=this._words;for(let r=0;r<t.length;r++)if(t[r]!==0)return!1;return!0}overlaps(t){const r=this._words,s=t._words,e=r.length<s.length?r.length:s.length;for(let n=0;n<e;n++)if((r[n]&s[n])!==0)return!0;return!1}contains(t){const r=t._words,s=this._words,e=s.length;for(let n=0;n<r.length;n++){const o=r[n];if(o!==0&&(n>=e||(s[n]&o)!==o))return!1}return!0}equals(t){const r=this._words,s=t._words,e=r.length>s.length?r.length:s.length;for(let n=0;n<e;n++){const o=n<r.length?r[n]:0,h=n<s.length?s[n]:0;if(o!==h)return!1}return!0}copy(){return new a(this._words.slice())}copyInto(t){const r=this._words,s=t._words,e=r.length,n=s.length;if(n>=e){for(let o=0;o<e;o++)s[o]=r[o];for(let o=e;o<n;o++)s[o]=0}else{let o=n>0?n:1;for(;o<e;)o*=2;const h=new Array(o).fill(0);for(let c=0;c<e;c++)h[c]=r[c];t._words=h}return t}copyWithSet(t){const r=t>>>5,s=r+1,e=this._words.length>s?this._words.length:s,n=new Array(e).fill(0);for(let o=0;o<this._words.length;o++)n[o]=this._words[o];return n[r]|=1<<(t&31),new a(n)}copyWithClear(t){const r=this._words.slice(),s=t>>>5;return s<r.length&&(r[s]&=~(1<<(t&31))),new a(r)}hash(){let t=2166136261;const r=this._words;let s=r.length-1;for(;s>=0&&r[s]===0;)s--;for(let e=0;e<=s;e++)t^=r[e],t=Math.imul(t,16777619);return t}forEach(t){const r=this._words;for(let s=0;s<r.length;s++){let e=r[s];if(e===0)continue;const n=s<<5;for(;e!==0;){const o=e&-e>>>0,h=31-Math.clz32(o);t(n+h),e^=o}}}grow(t){let r=this._words.length;for(;r<t;)r*=2;const s=new Array(r).fill(0);for(let e=0;e<this._words.length;e++)s[e]=this._words[e];this._words=s}}const i=16,u=2;class l{constructor(t,r=16){this._ctor=t,this._buf=new t(r)}_buf;_len=0;get length(){return this._len}push(t){this._len>=this._buf.length&&this._grow(),this._buf[this._len++]=t}pop(){return this._buf[--this._len]}get(t){return this._buf[t]}setAt(t,r){this._buf[t]=r}swapRemove(t){const r=this._buf[t];return this._buf[t]=this._buf[--this._len],r}clear(){this._len=0}setLength(t){this.ensureCapacity(t),this._len=t}get buf(){return this._buf}view(){return this._buf.subarray(0,this._len)}[Symbol.iterator](){let t=0;const r=this._buf,s=this._len;return{next(){return t<s?{value:r[t++],done:!1}:{value:0,done:!0}}}}ensureCapacity(t){if(t<=this._buf.length)return;let r=this._buf.length||1;for(;r<t;)r*=u;const s=new this._ctor(r);s.set(this._buf.subarray(0,this._len)),this._buf=s}bulkAppend(t,r,s){this.ensureCapacity(this._len+s),this._buf.set(t.subarray(r,r+s),this._len),this._len+=s}bulkAppendZeroes(t){this.ensureCapacity(this._len+t),this._buf.fill(0,this._len,this._len+t),this._len+=t}bulkAppendValue(t,r){this.ensureCapacity(this._len+r),this._buf.fill(t,this._len,this._len+r),this._len+=r}_grow(){const t=new this._ctor(this._buf.length*u);t.set(this._buf),this._buf=t}}class w extends l{constructor(t=i){super(Float32Array,t)}}class d extends l{constructor(t=i){super(Float64Array,t)}}class f extends l{constructor(t=i){super(Int8Array,t)}}class I extends l{constructor(t=i){super(Int16Array,t)}}class A extends l{constructor(t=i){super(Int32Array,t)}}class b extends l{constructor(t=i){super(Uint8Array,t)}}class y extends l{constructor(t=i){super(Uint16Array,t)}}class R extends l{constructor(t=i){super(Uint32Array,t)}}exports.BITS_PER_WORD_MASK=31;exports.BITS_PER_WORD_SHIFT=5;exports.BitSet=a;exports.GrowableFloat32Array=w;exports.GrowableFloat64Array=d;exports.GrowableInt16Array=I;exports.GrowableInt32Array=A;exports.GrowableInt8Array=f;exports.GrowableTypedArray=l;exports.GrowableUint16Array=y;exports.GrowableUint32Array=R;exports.GrowableUint8Array=b;

package/dist/utils/error.d.cts

@@ -0,0 +1,6 @@
+export declare abstract class AppError extends Error {
+    readonly isOperational: boolean;
+    readonly context?: Record<string, unknown> | undefined;
+    constructor(message: string, isOperational: boolean, context?: Record<string, unknown> | undefined);
+}
+//# sourceMappingURL=error.d.ts.map

package/dist/utils/error.d.ts

@@ -1,24 +1,6 @@
 export declare abstract class AppError extends Error {
-    readonly is_operational: boolean;
+    readonly isOperational: boolean;
     readonly context?: Record<string, unknown> | undefined;
-    constructor(message: string, is_operational: boolean, context?: Record<string, unknown> | undefined);
+    constructor(message: string, isOperational: boolean, context?: Record<string, unknown> | undefined);
 }
-export declare enum ECS_ERROR {
-    EID_MAX_INDEX_OVERFLOW = "EID_MAX_INDEX_OVERFLOW",
-    EID_MAX_GEN_OVERFLOW = "EID_MAX_GEN_OVERFLOW",
-    COMPONENT_NOT_REGISTERED = "COMPONENT_NOT_REGISTERED",
-    ENTITY_NOT_ALIVE = "ENTITY_NOT_ALIVE",
-    CIRCULAR_SYSTEM_DEPENDENCY = "CIRCULAR_SYSTEM_DEPENDENCY",
-    DUPLICATE_SYSTEM = "DUPLICATE_SYSTEM",
-    ARCHETYPE_NOT_FOUND = "ARCHETYPE_NOT_FOUND",
-    RESOURCE_NOT_REGISTERED = "RESOURCE_NOT_REGISTERED",
-    RESOURCE_ALREADY_REGISTERED = "RESOURCE_ALREADY_REGISTERED",
-    EVENT_ALREADY_REGISTERED = "EVENT_ALREADY_REGISTERED",
-    EVENT_NOT_REGISTERED = "EVENT_NOT_REGISTERED"
-}
-export declare class ECSError extends AppError {
-    readonly category: ECS_ERROR;
-    constructor(category: ECS_ERROR, message?: string, context?: Record<string, unknown>);
-}
-export declare function is_ecs_error(error: unknown): error is ECSError;
 //# sourceMappingURL=error.d.ts.map

package/dist/utils/error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../src/utils/error.ts"],"names":[],"mappings":"AAAA,8BAAsB,QAAS,SAAQ,KAAK;aAGxB,cAAc,EAAE,OAAO;aACvB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;gBAFjD,OAAO,EAAE,MAAM,EACC,cAAc,EAAE,OAAO,EACvB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YAAA;CAMpD;AAED,oBAAY,SAAS;IACnB,sBAAsB,2BAA2B;IACjD,oBAAoB,yBAAyB;IAC7C,wBAAwB,6BAA6B;IACrD,gBAAgB,qBAAqB;IACrC,0BAA0B,+BAA+B;IACzD,gBAAgB,qBAAqB;IACrC,mBAAmB,wBAAwB;IAC3C,uBAAuB,4BAA4B;IACnD,2BAA2B,gCAAgC;IAC3D,wBAAwB,6BAA6B;IACrD,oBAAoB,yBAAyB;CAC9C;AAED,qBAAa,QAAS,SAAQ,QAAQ;aAElB,QAAQ,EAAE,SAAS;gBAAnB,QAAQ,EAAE,SAAS,EACnC,OAAO,CAAC,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAIpC;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE9D"}
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../src/utils/error.ts"],"names":[],"mappings":"AAGA,8BAAsB,QAAS,SAAQ,KAAK;aAGxB,aAAa,EAAE,OAAO;aACtB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;gBAFjD,OAAO,EAAE,MAAM,EACC,aAAa,EAAE,OAAO,EACtB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YAAA;CAMpD"}

package/dist/version.d.cts

@@ -0,0 +1,10 @@
+/**
+ * The package version, readable at runtime (POLISH_AUDIT M21).
+ *
+ * A literal, not a build-time injection, so raw-source (JSR) consumers get the
+ * same value as the npm bundle. Kept in lock-step with `package.json` /
+ * `jsr.json` by `src/__tests__/version_sync.test.ts` — bump all three
+ * together.
+ */
+export declare const VERSION = "0.5.0";
+//# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The package version, readable at runtime (POLISH_AUDIT M21).
+ *
+ * A literal, not a build-time injection, so raw-source (JSR) consumers get the
+ * same value as the npm bundle. Kept in lock-step with `package.json` /
+ * `jsr.json` by `src/__tests__/version_sync.test.ts` — bump all three
+ * together.
+ */
+export declare const VERSION = "0.5.0";
+//# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,OAAO,UAAU,CAAC"}