@oasys/oecs 0.3.1 → 0.4.0

package/dist/topological_sort-DlRpSrxu.js

@@ -0,0 +1,391 @@
+const y = 5, b = 31;
+class f {
+  _words;
+  constructor(s) {
+    this._words = s ?? new Array(4).fill(0);
+  }
+  has(s) {
+    const t = s >>> 5;
+    return t >= this._words.length ? !1 : (this._words[t] & 1 << (s & 31)) !== 0;
+  }
+  set(s) {
+    const t = s >>> 5;
+    t >= this._words.length && this.grow(t + 1), this._words[t] |= 1 << (s & 31);
+  }
+  clear(s) {
+    const t = s >>> 5;
+    t >= this._words.length || (this._words[t] &= ~(1 << (s & 31)));
+  }
+  /** True if no bit is set. */
+  isEmpty() {
+    const s = this._words;
+    for (let t = 0; t < s.length; t++)
+      if (s[t] !== 0) return !1;
+    return !0;
+  }
+  /** True if any bit is set in both this and other (non-empty intersection). */
+  overlaps(s) {
+    const t = this._words, e = s._words, r = t.length < e.length ? t.length : e.length;
+    for (let n = 0; n < r; n++)
+      if ((t[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(s) {
+    const t = s._words, e = this._words, r = e.length;
+    for (let n = 0; n < t.length; n++) {
+      const o = t[n];
+      if (o !== 0 && (n >= r || (e[n] & o) !== o))
+        return !1;
+    }
+    return !0;
+  }
+  equals(s) {
+    const t = this._words, e = s._words, r = t.length > e.length ? t.length : e.length;
+    for (let n = 0; n < r; n++) {
+      const o = n < t.length ? t[n] : 0, l = n < e.length ? e[n] : 0;
+      if (o !== l) return !1;
+    }
+    return !0;
+  }
+  copy() {
+    return new f(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(s) {
+    const t = this._words, e = s._words, r = t.length, n = e.length;
+    if (n >= r) {
+      for (let o = 0; o < r; o++) e[o] = t[o];
+      for (let o = r; o < n; o++) e[o] = 0;
+    } else {
+      let o = n > 0 ? n : 1;
+      for (; o < r; ) o *= 2;
+      const l = new Array(o).fill(0);
+      for (let i = 0; i < r; i++) l[i] = t[i];
+      s._words = l;
+    }
+    return s;
+  }
+  copyWithSet(s) {
+    const t = s >>> 5, e = t + 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[t] |= 1 << (s & 31), new f(n);
+  }
+  copyWithClear(s) {
+    const t = this._words.slice(), e = s >>> 5;
+    return e < t.length && (t[e] &= ~(1 << (s & 31))), new f(t);
+  }
+  /** FNV-1a hash. Skips trailing zero words so differently-sized arrays with the same bits hash equally. */
+  hash() {
+    let s = 2166136261;
+    const t = this._words;
+    let e = t.length - 1;
+    for (; e >= 0 && t[e] === 0; ) e--;
+    for (let r = 0; r <= e; r++)
+      s ^= t[r], s = Math.imul(s, 16777619);
+    return s;
+  }
+  /** Iterate all set bits via lowest-set-bit extraction. */
+  forEach(s) {
+    const t = this._words;
+    for (let e = 0; e < t.length; e++) {
+      let r = t[e];
+      if (r === 0) continue;
+      const n = e << 5;
+      for (; r !== 0; ) {
+        const o = r & -r >>> 0, l = 31 - Math.clz32(o);
+        s(n + l), r ^= o;
+      }
+    }
+  }
+  grow(s) {
+    let t = this._words.length;
+    for (; t < s; ) t *= 2;
+    const e = new Array(t).fill(0);
+    for (let r = 0; r < this._words.length; r++) e[r] = this._words[r];
+    this._words = e;
+  }
+}
+class I {
+  _denseKeys = [];
+  _denseVals = [];
+  _sparse = [];
+  get size() {
+    return this._denseKeys.length;
+  }
+  get keys() {
+    return this._denseKeys;
+  }
+  has(s) {
+    return this._denseKeys[this._sparse[s]] === s;
+  }
+  get(s) {
+    return this.has(s) ? this._denseVals[this._sparse[s]] : void 0;
+  }
+  set(s, t) {
+    if (this.has(s)) {
+      this._denseVals[this._sparse[s]] = t;
+      return;
+    }
+    this._sparse[s] = this._denseKeys.length, this._denseKeys.push(s), this._denseVals.push(t);
+  }
+  delete(s) {
+    if (!this.has(s)) return !1;
+    const t = this._sparse[s], e = this._denseKeys[this._denseKeys.length - 1];
+    return this._denseKeys[t] = e, this._denseVals[t] = this._denseVals[this._denseVals.length - 1], this._sparse[e] = t, this._denseKeys.pop(), this._denseVals.pop(), !0;
+  }
+  clear() {
+    this._denseKeys.length = 0, this._denseVals.length = 0, this._sparse.length = 0;
+  }
+  forEach(s) {
+    for (let t = 0; t < this._denseKeys.length; t++)
+      s(this._denseKeys[t], this._denseVals[t]);
+  }
+  [Symbol.iterator]() {
+    let s = 0;
+    const t = this._denseKeys, e = this._denseVals;
+    return {
+      next() {
+        return s < t.length ? { value: [t[s], e[s++]], done: !1 } : { value: void 0, done: !0 };
+      }
+    };
+  }
+}
+const c = 16, p = 2;
+class u {
+  constructor(s, t = 16) {
+    this._ctor = s, this._buf = new s(t);
+  }
+  _buf;
+  _len = 0;
+  get length() {
+    return this._len;
+  }
+  push(s) {
+    this._len >= this._buf.length && this._grow(), this._buf[this._len++] = s;
+  }
+  pop() {
+    return this._buf[--this._len];
+  }
+  get(s) {
+    return this._buf[s];
+  }
+  setAt(s, t) {
+    this._buf[s] = t;
+  }
+  /**
+   * Move the last element into slot i, decrement length.
+   * Returns the value that was removed from slot i.
+   */
+  swapRemove(s) {
+    const t = this._buf[s];
+    return this._buf[s] = this._buf[--this._len], t;
+  }
+  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(s) {
+    this.ensureCapacity(s), this._len = s;
+  }
+  /**
+   * 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 s = 0;
+    const t = this._buf, e = this._len;
+    return {
+      next() {
+        return s < e ? { value: t[s++], done: !1 } : { value: 0, done: !0 };
+      }
+    };
+  }
+  /** Ensure the backing buffer can hold at least `capacity` elements without growing. */
+  ensureCapacity(s) {
+    if (s <= this._buf.length) return;
+    let t = this._buf.length || 1;
+    for (; t < s; ) t *= p;
+    const e = new this._ctor(t);
+    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(s, t, e) {
+    this.ensureCapacity(this._len + e), this._buf.set(s.subarray(t, t + e), this._len), this._len += e;
+  }
+  /** Append `count` zeroes. Grows if needed. */
+  bulkAppendZeroes(s) {
+    this.ensureCapacity(this._len + s), this._buf.fill(0, this._len, this._len + s), this._len += s;
+  }
+  /** Append `count` copies of `value`. Grows if needed. Single-pass
+   * analogue of `bulkAppendZeroes` for a non-zero default. */
+  bulkAppendValue(s, t) {
+    this.ensureCapacity(this._len + t), this._buf.fill(s, this._len, this._len + t), this._len += t;
+  }
+  _grow() {
+    const s = new this._ctor(this._buf.length * p);
+    s.set(this._buf), this._buf = s;
+  }
+}
+class A extends u {
+  constructor(s = c) {
+    super(Float32Array, s);
+  }
+}
+class S extends u {
+  constructor(s = c) {
+    super(Float64Array, s);
+  }
+}
+class R extends u {
+  constructor(s = c) {
+    super(Int8Array, s);
+  }
+}
+class T extends u {
+  constructor(s = c) {
+    super(Int16Array, s);
+  }
+}
+class E extends u {
+  constructor(s = c) {
+    super(Int32Array, s);
+  }
+}
+class K extends u {
+  constructor(s = c) {
+    super(Uint8Array, s);
+  }
+}
+class F extends u {
+  constructor(s = c) {
+    super(Uint16Array, s);
+  }
+}
+class O extends u {
+  constructor(s = c) {
+    super(Uint32Array, s);
+  }
+}
+class g {
+  _compare;
+  _data = [];
+  constructor(s) {
+    this._compare = s;
+  }
+  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(s) {
+    this._data.push(s), this._siftUp(this._data.length - 1);
+  }
+  /** Removes and returns the highest-priority element, or undefined if empty. O(log n). */
+  pop() {
+    const s = this._data;
+    if (s.length === 0) return;
+    const e = s[0], r = s.pop();
+    return s.length > 0 && (s[0] = r, 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(s) {
+    const t = this._data, e = this._compare, r = t[s];
+    for (; s > 0; ) {
+      const n = s - 1 >> 1;
+      if (e(r, t[n]) >= 0) break;
+      t[s] = t[n], s = n;
+    }
+    t[s] = r;
+  }
+  /** Moves a node down away from the root until heap order is restored. */
+  _siftDown(s) {
+    const t = this._data, e = this._compare, r = t.length, n = r >> 1, o = t[s];
+    for (; s < n; ) {
+      let l = (s << 1) + 1;
+      const i = l + 1;
+      if (i < r && e(t[i], t[l]) < 0 && (l = i), e(t[l], o) >= 0) break;
+      t[s] = t[l], s = l;
+    }
+    t[s] = o;
+  }
+}
+function W(h, s, t, e) {
+  const r = e ?? ((i) => String(i)), n = /* @__PURE__ */ new Map();
+  for (let i = 0; i < h.length; i++)
+    n.set(h[i], 0);
+  for (const [, i] of s)
+    for (let a = 0; a < i.length; a++) {
+      const _ = i[a];
+      n.has(_) && n.set(_, n.get(_) + 1);
+    }
+  const o = new g(t);
+  for (let i = 0; i < h.length; i++)
+    n.get(h[i]) === 0 && o.push(h[i]);
+  const l = [];
+  for (; o.size > 0; ) {
+    const i = o.pop();
+    l.push(i);
+    const a = s.get(i);
+    if (a !== void 0)
+      for (let _ = 0; _ < a.length; _++) {
+        const d = a[_];
+        if (!n.has(d)) continue;
+        const w = n.get(d) - 1;
+        n.set(d, w), w === 0 && o.push(d);
+      }
+  }
+  if (l.length !== h.length) {
+    const i = [];
+    for (const [a, _] of n)
+      _ > 0 && i.push(r(a));
+    throw new globalThis.TypeError(
+      `Cycle detected in topological sort. Nodes still pending: ${i.join(", ")}`
+    );
+  }
+  return l;
+}
+export {
+  f as B,
+  u as G,
+  I as S,
+  A as a,
+  S as b,
+  R as c,
+  T as d,
+  E as e,
+  K as f,
+  F as g,
+  O as h,
+  g as i,
+  b as j,
+  y as k,
+  W as t
+};

package/dist/topological_sort-WAT-VHb-.cjs

@@ -0,0 +1 @@
+"use strict";class d{_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,h=r<e.length?e[r]:0;if(o!==h)return!1}return!0}copy(){return new d(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 h=new Array(o).fill(0);for(let i=0;i<n;i++)h[i]=s[i];t._words=h}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 d(r)}copyWithClear(t){const s=this._words.slice(),e=t>>>5;return e<s.length&&(s[e]&=~(1<<(t&31))),new d(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,h=31-Math.clz32(o);t(r+h),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}}class y{_denseKeys=[];_denseVals=[];_sparse=[];get size(){return this._denseKeys.length}get keys(){return this._denseKeys}has(t){return this._denseKeys[this._sparse[t]]===t}get(t){return this.has(t)?this._denseVals[this._sparse[t]]:void 0}set(t,s){if(this.has(t)){this._denseVals[this._sparse[t]]=s;return}this._sparse[t]=this._denseKeys.length,this._denseKeys.push(t),this._denseVals.push(s)}delete(t){if(!this.has(t))return!1;const s=this._sparse[t],e=this._denseKeys[this._denseKeys.length-1];return this._denseKeys[s]=e,this._denseVals[s]=this._denseVals[this._denseVals.length-1],this._sparse[e]=s,this._denseKeys.pop(),this._denseVals.pop(),!0}clear(){this._denseKeys.length=0,this._denseVals.length=0,this._sparse.length=0}forEach(t){for(let s=0;s<this._denseKeys.length;s++)t(this._denseKeys[s],this._denseVals[s])}[Symbol.iterator](){let t=0;const s=this._denseKeys,e=this._denseVals;return{next(){return t<s.length?{value:[s[t],e[t++]],done:!1}:{value:void 0,done:!0}}}}}const u=16,p=2;class c{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}swapRemove(t){const s=this._buf[t];return this._buf[t]=this._buf[--this._len],s}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 s=this._buf,e=this._len;return{next(){return t<e?{value:s[t++],done:!1}:{value:0,done:!0}}}}ensureCapacity(t){if(t<=this._buf.length)return;let s=this._buf.length||1;for(;s<t;)s*=p;const e=new this._ctor(s);e.set(this._buf.subarray(0,this._len)),this._buf=e}bulkAppend(t,s,e){this.ensureCapacity(this._len+e),this._buf.set(t.subarray(s,s+e),this._len),this._len+=e}bulkAppendZeroes(t){this.ensureCapacity(this._len+t),this._buf.fill(0,this._len,this._len+t),this._len+=t}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*p);t.set(this._buf),this._buf=t}}class I extends c{constructor(t=u){super(Float32Array,t)}}class b extends c{constructor(t=u){super(Float64Array,t)}}class A extends c{constructor(t=u){super(Int8Array,t)}}class S extends c{constructor(t=u){super(Int16Array,t)}}class R extends c{constructor(t=u){super(Int32Array,t)}}class T extends c{constructor(t=u){super(Uint8Array,t)}}class E extends c{constructor(t=u){super(Uint16Array,t)}}class F extends c{constructor(t=u){super(Uint32Array,t)}}class g{_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 h=(t<<1)+1;const i=h+1;if(i<n&&e(s[i],s[h])<0&&(h=i),e(s[h],o)>=0)break;s[t]=s[h],t=h}s[t]=o}}function O(l,t,s,e){const n=e??(i=>String(i)),r=new Map;for(let i=0;i<l.length;i++)r.set(l[i],0);for(const[,i]of t)for(let a=0;a<i.length;a++){const _=i[a];r.has(_)&&r.set(_,r.get(_)+1)}const o=new g(s);for(let i=0;i<l.length;i++)r.get(l[i])===0&&o.push(l[i]);const h=[];for(;o.size>0;){const i=o.pop();h.push(i);const a=t.get(i);if(a!==void 0)for(let _=0;_<a.length;_++){const f=a[_];if(!r.has(f))continue;const w=r.get(f)-1;r.set(f,w),w===0&&o.push(f)}}if(h.length!==l.length){const i=[];for(const[a,_]of r)_>0&&i.push(n(a));throw new globalThis.TypeError(`Cycle detected in topological sort. Nodes still pending: ${i.join(", ")}`)}return h}exports.BITS_PER_WORD_MASK=31;exports.BITS_PER_WORD_SHIFT=5;exports.BinaryHeap=g;exports.BitSet=d;exports.GrowableFloat32Array=I;exports.GrowableFloat64Array=b;exports.GrowableInt16Array=S;exports.GrowableInt32Array=R;exports.GrowableInt8Array=A;exports.GrowableTypedArray=c;exports.GrowableUint16Array=E;exports.GrowableUint32Array=F;exports.GrowableUint8Array=T;exports.SparseMap=y;exports.topologicalSort=O;

package/dist/type_primitives/assertions.d.ts

@@ -2,15 +2,19 @@
  * Assertions — Dev-only runtime validation and branded casting.
  *
  * All checks are guarded by __DEV__ and tree-shaken in production builds.
- * validate_and_cast is the primary tool for creating branded IDs:
+ * validateAndCast is the primary tool for creating branded IDs:
  * it validates the input in dev and returns the value as the branded type.
- * unsafe_cast bypasses all checks (used when the caller guarantees validity).
+ * unsafeCast bypasses all checks (used when the caller guarantees validity).
  *
  ***/
-export declare const is_non_negative_integer: (v: number) => boolean;
-export declare const is_non_null: (v: unknown) => boolean;
-export declare function assert_non_null<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, err_message: string): asserts value is Result;
-export declare function validate_and_cast<T, Result extends T = T>(value: T, validator: (v: T) => boolean, err_message: string): Result;
-export declare function unsafe_cast<T>(value: unknown): T;
+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 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;
 //# sourceMappingURL=assertions.d.ts.map

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;AAIL,eAAO,MAAM,uBAAuB,MAAO,MAAM,KAAG,OAAwC,CAAC;AAE7F,eAAO,MAAM,WAAW,MAAO,OAAO,KAAG,OAAqB,CAAC;AAE/D,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,KAAK,IAAI,WAAW,CAAC,CAAC,CAAC,CAU5E;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,SAAS,CAAC,GAAG,CAAC,EAC5C,KAAK,EAAE,CAAC,EACR,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,MAAM,EAChC,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,KAAK,IAAI,MAAM,CAOzB;AAED,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,SAAS,CAAC,GAAG,CAAC,EACvD,KAAK,EAAE,CAAC,EACR,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,EAC5B,WAAW,EAAE,MAAM,GAClB,MAAM,CAQR;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,CAAC,CAEhD"}
+{"version":3,"file":"assertions.d.ts","sourceRoot":"","sources":["../../src/type_primitives/assertions.ts"],"names":[],"mappings":"AAAA;;;;;;;;KAQK;AAIL,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"}

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

@@ -12,6 +12,10 @@
  *
  ***/
 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;
@@ -26,8 +30,8 @@ export declare class BinaryHeap<T> {
     /** Removes all elements. O(1). */
     clear(): void;
     /** Moves a node up toward the root until heap order is restored. */
-    private _sift_up;
+    private _siftUp;
     /** Moves a node down away from the root until heap order is restored. */
-    private _sift_down;
+    private _siftDown;
 }
 //# sourceMappingURL=binary_heap.d.ts.map

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,qBAAa,UAAU,CAAC,CAAC;IACvB,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,QAAQ;IAchB,yEAAyE;IACzE,OAAO,CAAC,UAAU;CAsBnB"}
+{"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"}

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

@@ -7,7 +7,7 @@
  * words = ceil(maxComponentId / 32).
  *
  * Bit layout within each 32-bit word:
- *   word_index = bit >>> BITS_PER_WORD_SHIFT   (divide by 32)
+ *   wordIndex = bit >>> BITS_PER_WORD_SHIFT   (divide by 32)
  *   bit_offset = bit & BITS_PER_WORD_MASK      (mod 32)
  *   test:  word & (1 << offset)
  *   set:   word |= (1 << offset)
@@ -19,24 +19,36 @@ 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 class BitSet {
     _words: number[];
     constructor(words?: number[]);
     has(bit: number): boolean;
     set(bit: number): void;
     clear(bit: number): void;
+    /** True if no bit is set. */
+    isEmpty(): boolean;
     /** True if any bit is set in both this and other (non-empty intersection). */
     overlaps(other: BitSet): boolean;
     /** True if this is a superset of other (all bits in other are set in this). */
     contains(other: BitSet): boolean;
     equals(other: BitSet): boolean;
     copy(): BitSet;
-    copy_with_set(bit: number): BitSet;
-    copy_with_clear(bit: number): BitSet;
+    /** 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(target: BitSet): BitSet;
+    copyWithSet(bit: number): BitSet;
+    copyWithClear(bit: number): BitSet;
     /** FNV-1a hash. Skips trailing zero words so differently-sized arrays with the same bits hash equally. */
     hash(): number;
     /** Iterate all set bits via lowest-set-bit extraction. */
-    for_each(fn: (bit: number) => void): void;
+    forEach(fn: (bit: number) => void): void;
     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,qBAAa,MAAM;IACV,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,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;IAId,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAUlC,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAS3C,0GAA0G;IACnG,IAAI,IAAI,MAAM;IAarB,0DAA0D;IACnD,QAAQ,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI;IAmBhD,OAAO,CAAC,IAAI;CAOb"}
+{"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"}

package/dist/type_primitives/brand.d.ts

@@ -6,11 +6,16 @@
  * accidental assignment between structurally identical types.
  *
  * Example: EntityID and ComponentID are both numbers at runtime, but
- * Brand<number, "entity_id"> and Brand<number, "component_id"> are
+ * Brand<number, "entityId"> and Brand<number, "component_id"> are
  * incompatible at compile time.
  *
  ***/
 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,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,SAAS,SAAS,MAAM,IAAI,CAAC,GAAG;IACnD,QAAQ,CAAC,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC;CAC7B,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;;;;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"}

package/dist/type_primitives/error.d.ts

@@ -4,6 +4,10 @@ export declare enum TYPE_ERROR {
     VALIDATION_FAIL_CONDITION = "VALIDATION_FAIL_CONDITION",
     ASSERTION_FAIL_NON_NULLABLE = "ASSERTION_FAIL_NON_NULLABLE"
 }
+/**
+ * Error class thrown by std's runtime assertions. Non-operational.
+ *
+ */
 export declare class TypeError extends AppError {
     readonly category: TYPE_ERROR;
     constructor(category: TYPE_ERROR, message: string, context?: Record<string, unknown>);

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;IACpB,wBAAwB,6BAA6B;IACrD,yBAAyB,8BAA8B;IACvD,2BAA2B,gCAAgC;CAC5D;AAED,qBAAa,SAAU,SAAQ,QAAQ;aAEnB,QAAQ,EAAE,UAAU;gBAApB,QAAQ,EAAE,UAAU,EACpC,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAIpC"}
+{"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"}

package/dist/type_primitives/index.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Type-primitives barrel — assertions, brands, errors, plus data-structure primitives.
+ */
 export * from './assertions';
 export * from './brand';
 export * from './error';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/type_primitives/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qCAAqC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/type_primitives/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qCAAqC,CAAC"}

package/dist/type_primitives/sparse_map/sparse_map.d.ts

@@ -9,9 +9,13 @@
  * 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 _dense_keys;
-    private _dense_vals;
+    private _denseKeys;
+    private _denseVals;
     private _sparse;
     get size(): number;
     get keys(): readonly number[];
@@ -20,7 +24,7 @@ export declare class SparseMap<V> {
     set(key: number, value: V): void;
     delete(key: number): boolean;
     clear(): void;
-    for_each(fn: (key: number, value: V) => void): 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_map/sparse_map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sparse_map.d.ts","sourceRoot":"","sources":["../../../src/type_primitives/sparse_map/sparse_map.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;KAUK;AAEL,qBAAa,SAAS,CAAC,CAAC;IACtB,OAAO,CAAC,WAAW,CAAgB;IACnC,OAAO,CAAC,WAAW,CAAW;IAC9B,OAAO,CAAC,OAAO,CAAgB;IAE/B,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,IAAW,IAAI,IAAI,SAAS,MAAM,EAAE,CAEnC;IAEM,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAI/B,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAUhC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAa5B,KAAK,IAAI,IAAI;IAMb,QAAQ,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,KAAK,IAAI,GAAG,IAAI;IAM1D,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;CAa3C"}
+{"version":3,"file":"sparse_map.d.ts","sourceRoot":"","sources":["../../../src/type_primitives/sparse_map/sparse_map.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;KAUK;AAEL;;;GAGG;AACH,qBAAa,SAAS,CAAC,CAAC;IACvB,OAAO,CAAC,UAAU,CAAgB;IAClC,OAAO,CAAC,UAAU,CAAW;IAC7B,OAAO,CAAC,OAAO,CAAgB;IAE/B,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,IAAW,IAAI,IAAI,SAAS,MAAM,EAAE,CAEnC;IAEM,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAI/B,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAUhC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAa5B,KAAK,IAAI,IAAI;IAMb,OAAO,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,KAAK,IAAI,GAAG,IAAI;IAMzD,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;CAe1C"}

package/dist/type_primitives/sparse_set/sparse_set.d.ts

@@ -10,6 +10,10 @@
  * 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;

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

@@ -1 +1 @@
-{"version":3,"file":"sparse_set.d.ts","sourceRoot":"","sources":["../../../src/type_primitives/sparse_set/sparse_set.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;KAWK;AAEL,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,OAAO,CAAgB;IAE/B,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,IAAW,MAAM,IAAI,SAAS,MAAM,EAAE,CAErC;IAEM,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAMtB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAW5B,KAAK,IAAI,IAAI;IAKpB,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC;CAGtC"}
+{"version":3,"file":"sparse_set.d.ts","sourceRoot":"","sources":["../../../src/type_primitives/sparse_set/sparse_set.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;KAWK;AAEL;;;GAGG;AACH,qBAAa,SAAS;IACrB,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,OAAO,CAAgB;IAE/B,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,IAAW,MAAM,IAAI,SAAS,MAAM,EAAE,CAErC;IAEM,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAMtB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAW5B,KAAK,IAAI,IAAI;IAKpB,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC;CAGrC"}

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