@oasys/oecs 0.5.4 → 0.6.0

package/dist/topological_sort-Cc_yXqPT.js

@@ -0,0 +1,346 @@
+const I = 5, A = 31;
+class w {
+  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, n = s.length < e.length ? s.length : e.length;
+    for (let r = 0; r < n; r++)
+      if ((s[r] & e[r]) !== 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, n = e.length;
+    for (let r = 0; r < s.length; r++) {
+      const o = s[r];
+      if (o !== 0 && (r >= n || (e[r] & o) !== o))
+        return !1;
+    }
+    return !0;
+  }
+  equals(t) {
+    const s = this.words, e = t.words, n = s.length > e.length ? s.length : e.length;
+    for (let r = 0; r < n; r++) {
+      const o = r < s.length ? s[r] : 0, i = r < e.length ? e[r] : 0;
+      if (o !== i) return !1;
+    }
+    return !0;
+  }
+  copy() {
+    return new w(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, n = s.length, r = e.length;
+    if (r >= n) {
+      for (let o = 0; o < n; o++) e[o] = s[o];
+      for (let o = n; o < r; o++) e[o] = 0;
+    } else {
+      let o = r > 0 ? r : 1;
+      for (; o < n; ) o *= 2;
+      const i = new Array(o).fill(0);
+      for (let l = 0; l < n; l++) i[l] = s[l];
+      t.words = i;
+    }
+    return t;
+  }
+  copyWithSet(t) {
+    const s = t >>> 5, e = s + 1, n = this.words.length > e ? this.words.length : e, r = new Array(n).fill(0);
+    for (let o = 0; o < this.words.length; o++) r[o] = this.words[o];
+    return r[s] |= 1 << (t & 31), new w(r);
+  }
+  copyWithClear(t) {
+    const s = this.words.slice(), e = t >>> 5;
+    return e < s.length && (s[e] &= ~(1 << (t & 31))), new w(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 n = 0; n <= e; n++)
+      t ^= s[n], 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 n = s[e];
+      if (n === 0) continue;
+      const r = e << 5;
+      for (; n !== 0; ) {
+        const o = n & -n >>> 0, i = 31 - Math.clz32(o);
+        t(r + i), n ^= o;
+      }
+    }
+  }
+  _grow(t) {
+    let s = this.words.length;
+    for (; s < t; ) s *= 2;
+    const e = new Array(s).fill(0);
+    for (let n = 0; n < this.words.length; n++) e[n] = this.words[n];
+    this.words = e;
+  }
+}
+const _ = 16, g = 2;
+class u {
+  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];
+  }
+  getAt(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). The
+   * caller guarantees `[0, len)` already holds valid data. Grows the backing if
+   * needed so the length is always representable. */
+  setLength(t) {
+    this.reserve(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 };
+      }
+    };
+  }
+  /** Grow the backing buffer to hold `capacity` elements. Reallocates and
+   * copies when the current buffer is short, so `buf` and `view()` go stale. */
+  reserve(t) {
+    if (t <= this._buf.length) return;
+    let s = this._buf.length || 1;
+    for (; s < t; ) s *= g;
+    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.reserve(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.reserve(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.reserve(this._len + s), this._buf.fill(t, this._len, this._len + s), this._len += s;
+  }
+  _grow() {
+    const t = new this._ctor(this._buf.length * g);
+    t.set(this._buf), this._buf = t;
+  }
+}
+class b extends u {
+  constructor(t = _) {
+    super(Float32Array, t);
+  }
+}
+class S extends u {
+  constructor(t = _) {
+    super(Float64Array, t);
+  }
+}
+class R extends u {
+  constructor(t = _) {
+    super(Int8Array, t);
+  }
+}
+class y extends u {
+  constructor(t = _) {
+    super(Int16Array, t);
+  }
+}
+class T extends u {
+  constructor(t = _) {
+    super(Int32Array, t);
+  }
+}
+class E extends u {
+  constructor(t = _) {
+    super(Uint8Array, t);
+  }
+}
+class F extends u {
+  constructor(t = _) {
+    super(Uint16Array, t);
+  }
+}
+class O extends u {
+  constructor(t = _) {
+    super(Uint32Array, t);
+  }
+}
+class p {
+  _compare;
+  _data = [];
+  constructor(t) {
+    this._compare = t;
+  }
+  get size() {
+    return this._data.length;
+  }
+  /** Returns the highest-priority element without removing it, or undefined if empty. */
+  peek() {
+    return this._data[0];
+  }
+  /** Inserts a value and restores heap order by sifting up. O(log n). */
+  push(t) {
+    this._data.push(t), this._siftUp(this._data.length - 1);
+  }
+  /** Removes and returns the highest-priority element, or undefined if empty. O(log n). */
+  pop() {
+    const t = this._data;
+    if (t.length === 0) return;
+    const e = t[0], n = t.pop();
+    return t.length > 0 && (t[0] = n, this._siftDown(0)), e;
+  }
+  /** Removes all elements. O(1). */
+  clear() {
+    this._data.length = 0;
+  }
+  /** Moves a node up toward the root until heap order is restored. */
+  _siftUp(t) {
+    const s = this._data, e = this._compare, n = s[t];
+    for (; t > 0; ) {
+      const r = t - 1 >> 1;
+      if (e(n, s[r]) >= 0) break;
+      s[t] = s[r], t = r;
+    }
+    s[t] = n;
+  }
+  /** Moves a node down away from the root until heap order is restored. */
+  _siftDown(t) {
+    const s = this._data, e = this._compare, n = s.length, r = n >> 1, o = s[t];
+    for (; t < r; ) {
+      let i = (t << 1) + 1;
+      const l = i + 1;
+      if (l < n && e(s[l], s[i]) < 0 && (i = l), e(s[i], o) >= 0) break;
+      s[t] = s[i], t = i;
+    }
+    s[t] = o;
+  }
+}
+function W(h, t, s, e) {
+  const n = e ?? ((l) => String(l)), r = /* @__PURE__ */ new Map();
+  for (let l = 0; l < h.length; l++)
+    r.set(h[l], 0);
+  for (const [, l] of t)
+    for (let a = 0; a < l.length; a++) {
+      const c = l[a];
+      r.has(c) && r.set(c, r.get(c) + 1);
+    }
+  const o = new p(s);
+  for (let l = 0; l < h.length; l++)
+    r.get(h[l]) === 0 && o.push(h[l]);
+  const i = [];
+  for (; o.size > 0; ) {
+    const l = o.pop();
+    i.push(l);
+    const a = t.get(l);
+    if (a !== void 0)
+      for (let c = 0; c < a.length; c++) {
+        const f = a[c];
+        if (!r.has(f)) continue;
+        const d = r.get(f) - 1;
+        r.set(f, d), d === 0 && o.push(f);
+      }
+  }
+  if (i.length !== h.length) {
+    const l = [];
+    for (const [a, c] of r)
+      c > 0 && l.push(n(a));
+    throw new TypeError(
+      `Cycle detected in topological sort. Nodes still pending: ${l.join(", ")}`
+    );
+  }
+  return i;
+}
+export {
+  w as B,
+  u as G,
+  b as a,
+  S as b,
+  R as c,
+  y as d,
+  T as e,
+  E as f,
+  F as g,
+  O as h,
+  p as i,
+  A as j,
+  I as k,
+  W as t
+};

package/dist/topological_sort-vp1imU6D.cjs

@@ -0,0 +1 @@
+"use strict";class w{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)))}isEmpty(){const t=this.words;for(let s=0;s<t.length;s++)if(t[s]!==0)return!1;return!0}overlaps(t){const s=this.words,e=t.words,n=s.length<e.length?s.length:e.length;for(let r=0;r<n;r++)if((s[r]&e[r])!==0)return!0;return!1}contains(t){const s=t.words,e=this.words,n=e.length;for(let r=0;r<s.length;r++){const o=s[r];if(o!==0&&(r>=n||(e[r]&o)!==o))return!1}return!0}equals(t){const s=this.words,e=t.words,n=s.length>e.length?s.length:e.length;for(let r=0;r<n;r++){const o=r<s.length?s[r]:0,i=r<e.length?e[r]:0;if(o!==i)return!1}return!0}copy(){return new w(this.words.slice())}copyInto(t){const s=this.words,e=t.words,n=s.length,r=e.length;if(r>=n){for(let o=0;o<n;o++)e[o]=s[o];for(let o=n;o<r;o++)e[o]=0}else{let o=r>0?r:1;for(;o<n;)o*=2;const i=new Array(o).fill(0);for(let l=0;l<n;l++)i[l]=s[l];t.words=i}return t}copyWithSet(t){const s=t>>>5,e=s+1,n=this.words.length>e?this.words.length:e,r=new Array(n).fill(0);for(let o=0;o<this.words.length;o++)r[o]=this.words[o];return r[s]|=1<<(t&31),new w(r)}copyWithClear(t){const s=this.words.slice(),e=t>>>5;return e<s.length&&(s[e]&=~(1<<(t&31))),new w(s)}hash(){let t=2166136261;const s=this.words;let e=s.length-1;for(;e>=0&&s[e]===0;)e--;for(let n=0;n<=e;n++)t^=s[n],t=Math.imul(t,16777619);return t}forEach(t){const s=this.words;for(let e=0;e<s.length;e++){let n=s[e];if(n===0)continue;const r=e<<5;for(;n!==0;){const o=n&-n>>>0,i=31-Math.clz32(o);t(r+i),n^=o}}}_grow(t){let s=this.words.length;for(;s<t;)s*=2;const e=new Array(s).fill(0);for(let n=0;n<this.words.length;n++)e[n]=this.words[n];this.words=e}}const u=16,g=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]}getAt(t){return this._buf[t]}setAt(t,s){this._buf[t]=s}swapRemove(t){const s=this._buf[t];return this._buf[t]=this._buf[--this._len],s}clear(){this._len=0}setLength(t){this.reserve(t),this._len=t}get buf(){return this._buf}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}}}}reserve(t){if(t<=this._buf.length)return;let s=this._buf.length||1;for(;s<t;)s*=g;const e=new this._ctor(s);e.set(this._buf.subarray(0,this._len)),this._buf=e}bulkAppend(t,s,e){this.reserve(this._len+e),this._buf.set(t.subarray(s,s+e),this._len),this._len+=e}bulkAppendZeroes(t){this.reserve(this._len+t),this._buf.fill(0,this._len,this._len+t),this._len+=t}bulkAppendValue(t,s){this.reserve(this._len+s),this._buf.fill(t,this._len,this._len+s),this._len+=s}_grow(){const t=new this._ctor(this._buf.length*g);t.set(this._buf),this._buf=t}}class A extends _{constructor(t=u){super(Float32Array,t)}}class I extends _{constructor(t=u){super(Float64Array,t)}}class b extends _{constructor(t=u){super(Int8Array,t)}}class S extends _{constructor(t=u){super(Int16Array,t)}}class y extends _{constructor(t=u){super(Int32Array,t)}}class R extends _{constructor(t=u){super(Uint8Array,t)}}class T extends _{constructor(t=u){super(Uint16Array,t)}}class E extends _{constructor(t=u){super(Uint32Array,t)}}class p{_compare;_data=[];constructor(t){this._compare=t}get size(){return this._data.length}peek(){return this._data[0]}push(t){this._data.push(t),this._siftUp(this._data.length-1)}pop(){const t=this._data;if(t.length===0)return;const e=t[0],n=t.pop();return t.length>0&&(t[0]=n,this._siftDown(0)),e}clear(){this._data.length=0}_siftUp(t){const s=this._data,e=this._compare,n=s[t];for(;t>0;){const r=t-1>>1;if(e(n,s[r])>=0)break;s[t]=s[r],t=r}s[t]=n}_siftDown(t){const s=this._data,e=this._compare,n=s.length,r=n>>1,o=s[t];for(;t<r;){let i=(t<<1)+1;const l=i+1;if(l<n&&e(s[l],s[i])<0&&(i=l),e(s[i],o)>=0)break;s[t]=s[i],t=i}s[t]=o}}function F(h,t,s,e){const n=e??(l=>String(l)),r=new Map;for(let l=0;l<h.length;l++)r.set(h[l],0);for(const[,l]of t)for(let a=0;a<l.length;a++){const c=l[a];r.has(c)&&r.set(c,r.get(c)+1)}const o=new p(s);for(let l=0;l<h.length;l++)r.get(h[l])===0&&o.push(h[l]);const i=[];for(;o.size>0;){const l=o.pop();i.push(l);const a=t.get(l);if(a!==void 0)for(let c=0;c<a.length;c++){const f=a[c];if(!r.has(f))continue;const d=r.get(f)-1;r.set(f,d),d===0&&o.push(f)}}if(i.length!==h.length){const l=[];for(const[a,c]of r)c>0&&l.push(n(a));throw new TypeError(`Cycle detected in topological sort. Nodes still pending: ${l.join(", ")}`)}return i}exports.BITS_PER_WORD_MASK=31;exports.BITS_PER_WORD_SHIFT=5;exports.BinaryHeap=p;exports.BitSet=w;exports.GrowableFloat32Array=A;exports.GrowableFloat64Array=I;exports.GrowableInt16Array=S;exports.GrowableInt32Array=y;exports.GrowableInt8Array=b;exports.GrowableTypedArray=_;exports.GrowableUint16Array=T;exports.GrowableUint32Array=E;exports.GrowableUint8Array=R;exports.topologicalSort=F;

package/dist/type_primitives/assertions.d.cts

@@ -1,31 +1,27 @@
 /***
- * Assertions — Dev-only runtime validation and branded casting.
+ * Assertions. Dev-only runtime validation and branded casting.
  *
- * All checks are guarded by DEV and tree-shaken in production builds.
- * validateAndCast is the primary tool for creating branded IDs:
- * it validates the input in dev and returns the value as the branded type.
- * unsafeCast bypasses all checks (used when the caller guarantees validity).
+ * Every check but `assertNever` is guarded by DEV and tree-shaken in a
+ * production build. `validateAndCast` is the primary tool for creating branded
+ * ids: it validates the input in dev and returns the value as the branded type.
+ * `unsafeCast` bypasses every check, for a caller that guarantees validity.
  *
  ***/
 export declare const isNonNegativeInteger: (v: number) => boolean;
-export declare const isNonNull: (v: unknown) => boolean;
-/**
- * Dev-only assertion that value is not null/undefined.
- *
- */
+export declare const isNotNull: (v: unknown) => boolean;
 export declare function assertNonNull<T>(value: T): asserts value is NonNullable<T>;
 export declare function assert<T, Result extends T = T>(value: T, condition: (v: T) => v is Result, errMessage: string): asserts value is Result;
 export declare function validateAndCast<T, Result extends T = T>(value: T, validator: (v: T) => boolean, errMessage: string): Result;
 export declare function unsafeCast<T>(value: unknown): T;
 /**
  * Exhaustiveness backstop for tagged-union dispatches. Put it in the
- * `default` arm (or after the final `case`) of a switch over a closed union:
- * the `never` parameter makes "a union gained a variant but this dispatch
- * didn't" a COMPILE error at the call site, and the throw catches runtime
- * values that bypassed the type layer (deserialized/foreign data).
+ * `default` arm (or after the final `case`) of a switch over a closed union.
+ * The `never` parameter makes "a union gained a variant but this dispatch
+ * did not" a compile error at the call site. The throw catches runtime values
+ * that bypassed the type layer, such as deserialized and foreign data.
  *
- * Deliberately NOT `DEV`-gated, unlike the rest of this file: it marks a
- * can't-happen branch, so it costs nothing until the day it fires — and that
+ * Deliberately not `DEV`-gated, unlike the rest of this file: it marks a
+ * can't-happen branch, so it costs nothing until the day it fires, and that
  * day it must fire in production too, not silently fall through.
  */
 export declare function assertNever(value: never, label: string): never;

package/dist/type_primitives/assertions.d.ts

@@ -1,31 +1,27 @@
 /***
- * Assertions — Dev-only runtime validation and branded casting.
+ * Assertions. Dev-only runtime validation and branded casting.
  *
- * All checks are guarded by DEV and tree-shaken in production builds.
- * validateAndCast is the primary tool for creating branded IDs:
- * it validates the input in dev and returns the value as the branded type.
- * unsafeCast bypasses all checks (used when the caller guarantees validity).
+ * Every check but `assertNever` is guarded by DEV and tree-shaken in a
+ * production build. `validateAndCast` is the primary tool for creating branded
+ * ids: it validates the input in dev and returns the value as the branded type.
+ * `unsafeCast` bypasses every check, for a caller that guarantees validity.
  *
  ***/
 export declare const isNonNegativeInteger: (v: number) => boolean;
-export declare const isNonNull: (v: unknown) => boolean;
-/**
- * Dev-only assertion that value is not null/undefined.
- *
- */
+export declare const isNotNull: (v: unknown) => boolean;
 export declare function assertNonNull<T>(value: T): asserts value is NonNullable<T>;
 export declare function assert<T, Result extends T = T>(value: T, condition: (v: T) => v is Result, errMessage: string): asserts value is Result;
 export declare function validateAndCast<T, Result extends T = T>(value: T, validator: (v: T) => boolean, errMessage: string): Result;
 export declare function unsafeCast<T>(value: unknown): T;
 /**
  * Exhaustiveness backstop for tagged-union dispatches. Put it in the
- * `default` arm (or after the final `case`) of a switch over a closed union:
- * the `never` parameter makes "a union gained a variant but this dispatch
- * didn't" a COMPILE error at the call site, and the throw catches runtime
- * values that bypassed the type layer (deserialized/foreign data).
+ * `default` arm (or after the final `case`) of a switch over a closed union.
+ * The `never` parameter makes "a union gained a variant but this dispatch
+ * did not" a compile error at the call site. The throw catches runtime values
+ * that bypassed the type layer, such as deserialized and foreign data.
  *
- * Deliberately NOT `DEV`-gated, unlike the rest of this file: it marks a
- * can't-happen branch, so it costs nothing until the day it fires — and that
+ * Deliberately not `DEV`-gated, unlike the rest of this file: it marks a
+ * can't-happen branch, so it costs nothing until the day it fires, and that
  * day it must fire in production too, not silently fall through.
  */
 export declare function assertNever(value: never, label: string): never;

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

@@ -1 +1 @@
-{"version":3,"file":"assertions.d.ts","sourceRoot":"","sources":["../../src/type_primitives/assertions.ts"],"names":[],"mappings":"AAAA;;;;;;;;KAQK;AAKL,eAAO,MAAM,oBAAoB,MAAO,MAAM,KAAG,OAAwC,CAAC;AAE1F,eAAO,MAAM,SAAS,MAAO,OAAO,KAAG,OAAqB,CAAC;AAE7D;;;GAGG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,KAAK,IAAI,WAAW,CAAC,CAAC,CAAC,CAU1E;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,SAAS,CAAC,GAAG,CAAC,EAC7C,KAAK,EAAE,CAAC,EACR,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,MAAM,EAChC,UAAU,EAAE,MAAM,GAChB,OAAO,CAAC,KAAK,IAAI,MAAM,CAOzB;AAED,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,SAAS,CAAC,GAAG,CAAC,EACtD,KAAK,EAAE,CAAC,EACR,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,EAC5B,UAAU,EAAE,MAAM,GAChB,MAAM,CAQR;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,CAAC,CAE/C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAK9D"}
+{"version":3,"file":"assertions.d.ts","sourceRoot":"","sources":["../../src/type_primitives/assertions.ts"],"names":[],"mappings":"AAAA;;;;;;;;KAQK;AAKL,eAAO,MAAM,oBAAoB,MAAO,MAAM,KAAG,OAAwC,CAAC;AAE1F,eAAO,MAAM,SAAS,MAAO,OAAO,KAAG,OAAqB,CAAC;AAE7D,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,KAAK,IAAI,WAAW,CAAC,CAAC,CAAC,CAQ1E;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,SAAS,CAAC,GAAG,CAAC,EAC7C,KAAK,EAAE,CAAC,EACR,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,MAAM,EAChC,UAAU,EAAE,MAAM,GAChB,OAAO,CAAC,KAAK,IAAI,MAAM,CAOzB;AAED,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,SAAS,CAAC,GAAG,CAAC,EACtD,KAAK,EAAE,CAAC,EACR,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,EAC5B,UAAU,EAAE,MAAM,GAChB,MAAM,CAQR;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,CAAC,CAE/C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAK9D"}

package/dist/type_primitives/binary_heap/binary_heap.d.cts

@@ -1,21 +1,17 @@
 /***
- * BinaryHeap — generic array-backed binary heap with configurable ordering.
+ * BinaryHeap, generic array-backed binary heap with configurable ordering.
  *
  * Array layout uses implicit indexing: root at index 0, children of node `i`
  * at `2i + 1` and `2i + 2`, parent of node `i` at `(i - 1) >> 1`.
  *
  * The comparator determines ordering: when `compare(a, b) < 0`, `a` has
  * higher priority and floats toward the root. A standard `(a, b) => a - b`
- * comparator yields a min-heap; `(a, b) => b - a` yields a max-heap.
+ * comparator yields a min-heap. `(a, b) => b - a` yields a max-heap.
  *
  * push and pop are O(log n). peek and clear are O(1).
  *
  ***/
 export type CompareFn<T> = (a: T, b: T) => number;
-/**
- * Generic array-backed binary heap with configurable comparator.
- *
- */
 export declare class BinaryHeap<T> {
     private readonly _compare;
     private readonly _data;

package/dist/type_primitives/binary_heap/binary_heap.d.ts

@@ -1,21 +1,17 @@
 /***
- * BinaryHeap — generic array-backed binary heap with configurable ordering.
+ * BinaryHeap, generic array-backed binary heap with configurable ordering.
  *
  * Array layout uses implicit indexing: root at index 0, children of node `i`
  * at `2i + 1` and `2i + 2`, parent of node `i` at `(i - 1) >> 1`.
  *
  * The comparator determines ordering: when `compare(a, b) < 0`, `a` has
  * higher priority and floats toward the root. A standard `(a, b) => a - b`
- * comparator yields a min-heap; `(a, b) => b - a` yields a max-heap.
+ * comparator yields a min-heap. `(a, b) => b - a` yields a max-heap.
  *
  * push and pop are O(log n). peek and clear are O(1).
  *
  ***/
 export type CompareFn<T> = (a: T, b: T) => number;
-/**
- * Generic array-backed binary heap with configurable comparator.
- *
- */
 export declare class BinaryHeap<T> {
     private readonly _compare;
     private readonly _data;

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

@@ -1 +1 @@
-{"version":3,"file":"binary_heap.d.ts","sourceRoot":"","sources":["../../../src/type_primitives/binary_heap/binary_heap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;KAYK;AAEL,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC;AAElD;;;GAGG;AACH,qBAAa,UAAU,CAAC,CAAC;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAe;IACxC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAW;gBAErB,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC;IAIjC,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,uFAAuF;IAChF,IAAI,IAAI,CAAC,GAAG,SAAS;IAI5B,uEAAuE;IAChE,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IAK3B,yFAAyF;IAClF,GAAG,IAAI,CAAC,GAAG,SAAS;IAc3B,kCAAkC;IAC3B,KAAK,IAAI,IAAI;IAIpB,oEAAoE;IACpE,OAAO,CAAC,OAAO;IAcf,yEAAyE;IACzE,OAAO,CAAC,SAAS;CAsBjB"}
+{"version":3,"file":"binary_heap.d.ts","sourceRoot":"","sources":["../../../src/type_primitives/binary_heap/binary_heap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;KAYK;AAEL,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC;AAElD,qBAAa,UAAU,CAAC,CAAC;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAe;IACxC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAW;gBAErB,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC;IAIjC,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,uFAAuF;IAChF,IAAI,IAAI,CAAC,GAAG,SAAS;IAI5B,uEAAuE;IAChE,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IAK3B,yFAAyF;IAClF,GAAG,IAAI,CAAC,GAAG,SAAS;IAc3B,kCAAkC;IAC3B,KAAK,IAAI,IAAI;IAIpB,oEAAoE;IACpE,OAAO,CAAC,OAAO;IAcf,yEAAyE;IACzE,OAAO,CAAC,SAAS;CAsBjB"}

package/dist/type_primitives/bitset/bitset.d.cts

@@ -1,8 +1,8 @@
 /***
- * BitSet — number[]-backed bit set with auto-grow.
+ * BitSet, number[]-backed bit set with auto-grow.
  *
  * Used as the archetype component signature. Each bit position corresponds
- * to a ComponentID. Operations (has/set/clear) are O(1), and mask
+ * to a ComponentID. Operations (has, set and clear) are O(1), and mask
  * comparisons (contains, equals, overlaps) are O(words) where
  * words = ceil(maxComponentId / 32).
  *
@@ -17,14 +17,10 @@
 export declare const BITS_PER_WORD = 32;
 export declare const BITS_PER_WORD_SHIFT = 5;
 export declare const BITS_PER_WORD_MASK = 31;
-export declare const FNV_OFFSET_BASIS = 2166136261;
-export declare const FNV_PRIME = 16777619;
-/**
- * number[]-backed bit set with auto-grow. Used as the archetype component signature.
- *
- */
+export declare const FNV1A_OFFSET_BASIS = 2166136261;
+export declare const FNV1A_PRIME = 16777619;
 export declare class BitSet {
-    _words: number[];
+    words: number[];
     constructor(words?: number[]);
     has(bit: number): boolean;
     set(bit: number): void;
@@ -38,7 +34,7 @@ export declare class BitSet {
     equals(other: BitSet): boolean;
     copy(): BitSet;
     /** Mutate `target` so it has the same set bits as `this`. Reuses
-     * `target._words` storage when capacity allows (no allocation) and
+     * `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. */
@@ -49,6 +45,6 @@ export declare class BitSet {
     hash(): number;
     /** Iterate all set bits via lowest-set-bit extraction. */
     forEach(fn: (bit: number) => void): void;
-    private grow;
+    private _grow;
 }
 //# sourceMappingURL=bitset.d.ts.map

package/dist/type_primitives/bitset/bitset.d.ts

@@ -1,8 +1,8 @@
 /***
- * BitSet — number[]-backed bit set with auto-grow.
+ * BitSet, number[]-backed bit set with auto-grow.
  *
  * Used as the archetype component signature. Each bit position corresponds
- * to a ComponentID. Operations (has/set/clear) are O(1), and mask
+ * to a ComponentID. Operations (has, set and clear) are O(1), and mask
  * comparisons (contains, equals, overlaps) are O(words) where
  * words = ceil(maxComponentId / 32).
  *
@@ -17,14 +17,10 @@
 export declare const BITS_PER_WORD = 32;
 export declare const BITS_PER_WORD_SHIFT = 5;
 export declare const BITS_PER_WORD_MASK = 31;
-export declare const FNV_OFFSET_BASIS = 2166136261;
-export declare const FNV_PRIME = 16777619;
-/**
- * number[]-backed bit set with auto-grow. Used as the archetype component signature.
- *
- */
+export declare const FNV1A_OFFSET_BASIS = 2166136261;
+export declare const FNV1A_PRIME = 16777619;
 export declare class BitSet {
-    _words: number[];
+    words: number[];
     constructor(words?: number[]);
     has(bit: number): boolean;
     set(bit: number): void;
@@ -38,7 +34,7 @@ export declare class BitSet {
     equals(other: BitSet): boolean;
     copy(): BitSet;
     /** Mutate `target` so it has the same set bits as `this`. Reuses
-     * `target._words` storage when capacity allows (no allocation) and
+     * `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. */
@@ -49,6 +45,6 @@ export declare class BitSet {
     hash(): number;
     /** Iterate all set bits via lowest-set-bit extraction. */
     forEach(fn: (bit: number) => void): void;
-    private grow;
+    private _grow;
 }
 //# sourceMappingURL=bitset.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"bitset.d.ts","sourceRoot":"","sources":["../../../src/type_primitives/bitset/bitset.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;KAeK;AAGL,eAAO,MAAM,aAAa,KAAK,CAAC;AAChC,eAAO,MAAM,mBAAmB,IAAI,CAAC;AACrC,eAAO,MAAM,kBAAkB,KAAK,CAAC;AAGrC,eAAO,MAAM,gBAAgB,aAAa,CAAC;AAC3C,eAAO,MAAM,SAAS,WAAa,CAAC;AAIpC;;;GAGG;AACH,qBAAa,MAAM;IACX,MAAM,EAAE,MAAM,EAAE,CAAC;gBAEZ,KAAK,CAAC,EAAE,MAAM,EAAE;IAIrB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAMzB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAMtB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAM/B,6BAA6B;IACtB,OAAO,IAAI,OAAO;IAQzB,8EAA8E;IACvE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAUvC,+EAA+E;IACxE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAehC,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAa9B,IAAI,IAAI,MAAM;IAIrB;;;;6DAIyD;IAClD,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAoBhC,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAUhC,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IASzC,0GAA0G;IACnG,IAAI,IAAI,MAAM;IAarB,0DAA0D;IACnD,OAAO,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI;IAmB/C,OAAO,CAAC,IAAI;CAOZ"}
+{"version":3,"file":"bitset.d.ts","sourceRoot":"","sources":["../../../src/type_primitives/bitset/bitset.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;KAeK;AAGL,eAAO,MAAM,aAAa,KAAK,CAAC;AAChC,eAAO,MAAM,mBAAmB,IAAI,CAAC;AACrC,eAAO,MAAM,kBAAkB,KAAK,CAAC;AAGrC,eAAO,MAAM,kBAAkB,aAAa,CAAC;AAC7C,eAAO,MAAM,WAAW,WAAa,CAAC;AAItC,qBAAa,MAAM;IACX,KAAK,EAAE,MAAM,EAAE,CAAC;gBAEX,KAAK,CAAC,EAAE,MAAM,EAAE;IAIrB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAMzB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAMtB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAM/B,6BAA6B;IACtB,OAAO,IAAI,OAAO;IAQzB,8EAA8E;IACvE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAUvC,+EAA+E;IACxE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAehC,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAa9B,IAAI,IAAI,MAAM;IAIrB;;;;6DAIyD;IAClD,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAoBhC,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAUhC,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IASzC,0GAA0G;IACnG,IAAI,IAAI,MAAM;IAarB,0DAA0D;IACnD,OAAO,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI;IAmB/C,OAAO,CAAC,KAAK;CAOb"}

package/dist/type_primitives/brand.d.cts

@@ -1,8 +1,8 @@
 /***
- * Brand — Nominal typing for TypeScript.
+ * Brand. Nominal typing for TypeScript.
  *
  * Brand<T, Name> intersects T with a phantom readonly symbol property
- * tagged with Name. The symbol never exists at runtime — it only prevents
+ * tagged with Name. The symbol never exists at runtime. It only prevents
  * accidental assignment between structurally identical types.
  *
  * Example: EntityID and ComponentID are both numbers at runtime, but
@@ -11,11 +11,6 @@
  *
  ***/
 declare const brand: unique symbol;
-/**
- * Nominal typing helper — intersects T with a phantom readonly symbol
- * so structurally identical types become compile-time incompatible.
- *
- */
 export type Brand<T, BrandName extends string> = T & {
     readonly [brand]: BrandName;
 };

package/dist/type_primitives/brand.d.ts

@@ -1,8 +1,8 @@
 /***
- * Brand — Nominal typing for TypeScript.
+ * Brand. Nominal typing for TypeScript.
  *
  * Brand<T, Name> intersects T with a phantom readonly symbol property
- * tagged with Name. The symbol never exists at runtime — it only prevents
+ * tagged with Name. The symbol never exists at runtime. It only prevents
  * accidental assignment between structurally identical types.
  *
  * Example: EntityID and ComponentID are both numbers at runtime, but
@@ -11,11 +11,6 @@
  *
  ***/
 declare const brand: unique symbol;
-/**
- * Nominal typing helper — intersects T with a phantom readonly symbol
- * so structurally identical types become compile-time incompatible.
- *
- */
 export type Brand<T, BrandName extends string> = T & {
     readonly [brand]: BrandName;
 };

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

@@ -1 +1 @@
-{"version":3,"file":"brand.d.ts","sourceRoot":"","sources":["../../src/type_primitives/brand.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;KAWK;AAEL,OAAO,CAAC,MAAM,KAAK,EAAE,OAAO,MAAM,CAAC;AAEnC;;;;GAIG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,SAAS,SAAS,MAAM,IAAI,CAAC,GAAG;IACpD,QAAQ,CAAC,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC;CAC5B,CAAC"}
+{"version":3,"file":"brand.d.ts","sourceRoot":"","sources":["../../src/type_primitives/brand.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;KAWK;AAEL,OAAO,CAAC,MAAM,KAAK,EAAE,OAAO,MAAM,CAAC;AAEnC,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,SAAS,SAAS,MAAM,IAAI,CAAC,GAAG;IACpD,QAAQ,CAAC,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC;CAC5B,CAAC"}