@oasys/oecs 0.4.0 → 0.5.0

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

@@ -1 +1 @@
-{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../src/type_primitives/error.ts"],"names":[],"mappings":"AAAA;;;;;;KAMK;AAEL,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,oBAAY,UAAU;IACrB,wBAAwB,6BAA6B;IACrD,yBAAyB,8BAA8B;IACvD,2BAA2B,gCAAgC;CAC3D;AAED;;;GAGG;AACH,qBAAa,SAAU,SAAQ,QAAQ;aAErB,QAAQ,EAAE,UAAU;gBAApB,QAAQ,EAAE,UAAU,EACpC,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAIlC"}
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../src/type_primitives/error.ts"],"names":[],"mappings":"AAAA;;;;;;KAMK;AAEL,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,oBAAY,UAAU;IACrB,wBAAwB,6BAA6B;IACrD,yBAAyB,8BAA8B;IACvD,2BAA2B,gCAAgC;IAC3D,0BAA0B,+BAA+B;CACzD;AAED;;;GAGG;AACH,qBAAa,cAAe,SAAQ,QAAQ;aAE1B,QAAQ,EAAE,UAAU;gBAApB,QAAQ,EAAE,UAAU,EACpC,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAIlC"}

package/dist/type_primitives/index.d.cts

@@ -0,0 +1,13 @@
+/**
+ * Type-primitives barrel — assertions, brands, errors, plus data-structure primitives.
+ */
+export * from './assertions.cjs';
+export * from './brand.cjs';
+export * from './error.cjs';
+export * from './bitset/bitset.cjs';
+export * from './sparse_set/sparse_set.cjs';
+export * from './sparse_map/sparse_map.cjs';
+export * from './typed_arrays/typed_arrays.cjs';
+export * from './binary_heap/binary_heap.cjs';
+export * from './topological_sort/topological_sort.cjs';
+//# sourceMappingURL=index.d.ts.map

package/dist/type_primitives/index.d.ts

@@ -1,13 +1,13 @@
 /**
  * Type-primitives barrel — assertions, brands, errors, plus data-structure primitives.
  */
-export * from './assertions';
-export * from './brand';
-export * from './error';
-export * from './bitset/bitset';
-export * from './sparse_set/sparse_set';
-export * from './sparse_map/sparse_map';
-export * from './typed_arrays/typed_arrays';
-export * from './binary_heap/binary_heap';
-export * from './topological_sort/topological_sort';
+export * from './assertions.js';
+export * from './brand.js';
+export * from './error.js';
+export * from './bitset/bitset.js';
+export * from './sparse_set/sparse_set.js';
+export * from './sparse_map/sparse_map.js';
+export * from './typed_arrays/typed_arrays.js';
+export * from './binary_heap/binary_heap.js';
+export * from './topological_sort/topological_sort.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/type_primitives/sparse_map/sparse_map.d.cts

@@ -0,0 +1,30 @@
+/***
+ * SparseMap — O(1) integer-keyed map with cache-friendly dense iteration.
+ *
+ * Keys are non-negative integers. Two parallel dense arrays (keys + values)
+ * enable linear iteration. A sparse number[] maps key → dense index for
+ * O(1) get/set/delete.
+ *
+ * Membership is verified by cross-referencing dense_keys[sparse[key]] === key,
+ * so stale sparse entries are harmless. Deletion uses swap-and-pop.
+ *
+ ***/
+/**
+ * O(1) integer-keyed map with cache-friendly dense iteration.
+ *
+ */
+export declare class SparseMap<V> {
+    private _denseKeys;
+    private _denseVals;
+    private _sparse;
+    get size(): number;
+    get keys(): readonly number[];
+    has(key: number): boolean;
+    get(key: number): V | undefined;
+    set(key: number, value: V): void;
+    delete(key: number): boolean;
+    clear(): void;
+    forEach(fn: (key: number, value: V) => void): void;
+    [Symbol.iterator](): Iterator<[number, V]>;
+}
+//# sourceMappingURL=sparse_map.d.ts.map

package/dist/type_primitives/sparse_set/sparse_set.d.cts

@@ -0,0 +1,28 @@
+/***
+ * SparseSet — O(1) integer-key set with cache-friendly dense iteration.
+ *
+ * Keys are non-negative integers. A dense number[] holds members packed
+ * at 0..size-1 for linear iteration. A sparse number[] maps
+ * key → dense index for O(1) has/add/delete.
+ *
+ * Membership is verified by cross-referencing dense[sparse[key]] === key,
+ * so stale sparse entries are harmless (no clearing needed on delete).
+ * Deletion uses swap-and-pop to keep data contiguous.
+ *
+ ***/
+/**
+ * O(1) integer-key set with cache-friendly dense iteration.
+ *
+ */
+export declare class SparseSet {
+    private _dense;
+    private _sparse;
+    get size(): number;
+    get values(): readonly number[];
+    has(key: number): boolean;
+    add(key: number): void;
+    delete(key: number): boolean;
+    clear(): void;
+    [Symbol.iterator](): Iterator<number>;
+}
+//# sourceMappingURL=sparse_set.d.ts.map

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/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/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/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"}