@oasys/oecs 0.5.4 → 0.6.0

package/dist/plugins/workers.js

@@ -0,0 +1,474 @@
+import { C as m } from "./abi-NP8pNxpd.js";
+import { ECSError as l, ECS_ERROR as h } from "../index.js";
+async function I() {
+  const o = globalThis.process, t = o?.getBuiltinModule;
+  return typeof t == "function" ? t.call(o, "node:worker_threads") : await import(["node", "worker_threads"].join(":"));
+}
+const f = 0, p = 1, k = 2, A = 3, R = 4, N = R + m, S = N + m, v = S + 1, T = v + 1 >> 1, $ = (T + 1) * 8, b = -1, D = -2, E = 16, L = 65536, M = 3e4;
+function W(o) {
+  if (o === void 0) return 0;
+  if (!Number.isInteger(o) || o < 1)
+    throw new l(
+      h.WORKERS_COUNT_INVALID,
+      `workers.attach: stackBytes must be an integer >= 1, got ${String(o)}`
+    );
+  if (o % E !== 0)
+    throw new l(
+      h.WORKERS_COUNT_INVALID,
+      `workers.attach: stackBytes must be a multiple of ${E}, the frame alignment of a wasm shadow stack, got ${o}`
+    );
+  if (o < L)
+    throw new l(
+      h.WORKERS_COUNT_INVALID,
+      `workers.attach: stackBytes must be at least ${L}, one WASM page, got ${o}`
+    );
+  return o;
+}
+function P() {
+  try {
+    const o = new Int32Array(new SharedArrayBuffer(4));
+    return Atomics.wait(o, 0, 1, 0), !0;
+  } catch {
+    return !1;
+  }
+}
+function B() {
+  const o = globalThis.process;
+  return typeof o == "object" && o !== null && typeof o.versions?.node == "string";
+}
+function K() {
+  const o = globalThis.navigator?.hardwareConcurrency;
+  return typeof o != "number" || !Number.isFinite(o) ? 1 : Math.max(1, Math.floor(o) - 1);
+}
+function U() {
+  const o = new URL(import.meta.url), t = o.pathname, e = t.lastIndexOf("/"), n = t.slice(e + 1), s = n.indexOf("."), r = t.slice(0, e), i = r.slice(0, r.lastIndexOf("/") + 1);
+  return o.pathname = `${i}worker${s < 0 ? "" : n.slice(s)}`, o;
+}
+class C {
+  _waiting = /* @__PURE__ */ new Map();
+  _arrived = /* @__PURE__ */ new Map();
+  _failure = null;
+  deliver(t) {
+    const e = t.slot === void 0 ? t.type : `${t.type}:${t.slot}`, n = this._waiting.get(e);
+    if (n !== void 0 && n.length > 0) {
+      n.shift()(t);
+      return;
+    }
+    const s = this._arrived.get(e);
+    s === void 0 ? this._arrived.set(e, [t]) : s.push(t);
+  }
+  /** A worker that died answers nothing. Without this every wait outstanding
+   * on it would sit there for the life of the process. */
+  fail(t) {
+    this._failure = t;
+    for (const e of this._waiting.values())
+      for (; e.length > 0; ) e.shift()({ type: "kernel", error: t });
+    this._waiting.clear();
+  }
+  expect(t, e) {
+    if (this._failure !== null) return Promise.resolve({ type: t, slot: e, error: this._failure });
+    const n = e === void 0 ? t : `${t}:${e}`, s = this._arrived.get(n);
+    return s !== void 0 && s.length > 0 ? Promise.resolve(s.shift()) : new Promise((r) => {
+      const i = this._waiting.get(n);
+      i === void 0 ? this._waiting.set(n, [r]) : i.push(r);
+    });
+  }
+}
+async function j(o, t) {
+  const e = await I();
+  return t.map((n) => {
+    const s = new e.Worker(o, { workerData: n }), r = new C();
+    return s.on("message", (i) => r.deliver(i)), s.on("error", (i) => r.fail(i.message)), {
+      post: (i) => s.postMessage(i),
+      expect: (i, c) => r.expect(i, c),
+      terminate: () => s.terminate()
+    };
+  });
+}
+function q(o, t) {
+  return t.map((e) => {
+    const n = new Worker(o, { type: "module" }), s = new C();
+    return n.addEventListener(
+      "message",
+      (r) => s.deliver(r.data)
+    ), n.addEventListener("error", (r) => {
+      const i = r.message;
+      s.fail(
+        typeof i == "string" && i !== "" ? i : `the script at '${String(o)}' did not load`
+      );
+    }), n.postMessage(e), {
+      post: (r) => n.postMessage(r),
+      expect: (r, i) => s.expect(r, i),
+      terminate: () => (n.terminate(), Promise.resolve())
+    };
+  });
+}
+class g {
+  _world;
+  _workers;
+  _ctl;
+  _ctlF64;
+  _joinTimeoutMs;
+  _state = "idle";
+  _epoch = 0;
+  _nextSlot = 0;
+  _pending = [];
+  _syncing = Promise.resolve();
+  constructor(t, e, n, s) {
+    this._world = t, this._workers = e, this._ctl = new Int32Array(n), this._ctlF64 = new Float64Array(n), this._joinTimeoutMs = s;
+  }
+  /** How many workers the pool runs. */
+  get count() {
+    return this._workers.length;
+  }
+  /**
+   * Start the workers, hand each the store and the control buffer, and load
+   * every kernel the world has declared. Resolves when each worker is parked on
+   * the barrier with its kernels in hand. Cold path, and a caller runs it once.
+   *
+   * Throws `WORKERS_ENTRY_UNREACHABLE` when a worker's script does not load,
+   * which is what a wrong `workerUrl` looks like from here.
+   */
+  static async attach(t, e) {
+    if (!P())
+      throw new l(
+        h.WORKERS_HOST_CANNOT_PARK,
+        "workers.attach: this host refuses Atomics.wait, so it cannot park while the workers run. Host the world inside a worker and attach the pool from there."
+      );
+    const n = e?.count ?? K();
+    if (!Number.isInteger(n) || n < 1)
+      throw new l(
+        h.WORKERS_COUNT_INVALID,
+        `workers.attach: count must be an integer >= 1, got ${String(n)}`
+      );
+    const s = e?.joinTimeoutMs ?? M;
+    if (!Number.isInteger(s) || s < 1)
+      throw new l(
+        h.WORKERS_COUNT_INVALID,
+        `workers.attach: joinTimeoutMs must be an integer >= 1, got ${String(s)}`
+      );
+    const r = W(e?.stackBytes), i = new SharedArrayBuffer($), c = [];
+    for (let a = 0; a < n; a++)
+      c.push({
+        store: t.store,
+        storeBase: t.storeBase,
+        control: i,
+        index: a,
+        count: n,
+        stackBytes: r
+      });
+    const _ = e?.workerUrl ?? U(), d = B() ? await j(_, c) : q(_, c), u = await Promise.all(d.map((a) => a.expect("ready")));
+    for (let a = 0; a < u.length; a++) {
+      const y = u[a].error;
+      if (y !== void 0)
+        throw await Promise.all(d.map((x) => x.terminate())), new l(
+          h.WORKERS_ENTRY_UNREACHABLE,
+          `workers.attach: worker ${a} did not start from '${String(_)}': ${y}. Pass workerUrl with the URL your bundler emits for the '@oasys/oecs/worker' entry.`
+        );
+    }
+    const w = new g(t, d, i, s);
+    for (const a of t.plans()) w._pending.push(a);
+    w._kick();
+    try {
+      await w.settled();
+    } catch (a) {
+      throw await w.detach(), a;
+    }
+    return w;
+  }
+  /** Take one kernel. The system runs `fn` until every worker holds it. */
+  register(t) {
+    this._state === "detached" || this._state === "failed" || (this._pending.push(t), this._kick());
+  }
+  _kick() {
+    this._syncing = this._syncing.then(() => this._sync());
+  }
+  /** Resolves when every kernel registered so far is loaded on every worker.
+   * Rejects with `PARALLEL_KERNEL_FAILED` when one would not load. */
+  settled() {
+    return this._syncing;
+  }
+  async _sync() {
+    if (this._state === "detached" || this._state === "failed") return;
+    const t = this._pending;
+    this._pending = [], t.length > 0 && this._state === "running" && await this._park();
+    for (const e of t) {
+      e.slot = this._nextSlot++;
+      const n = {
+        type: "kernel",
+        slot: e.slot,
+        wasm: e.kernel.wasm,
+        js: e.kernel.js,
+        exportName: e.exportName,
+        specs: e.specs
+      }, s = await Promise.all(
+        this._workers.map((r) => (r.post(n), r.expect("kernel", e.slot)))
+      );
+      for (let r = 0; r < s.length; r++) {
+        const i = s[r].error;
+        if (i !== void 0)
+          throw new l(
+            h.PARALLEL_KERNEL_FAILED,
+            `worker ${r} could not load the kernel export '${e.exportName}': ${String(i).replace(/\.$/, "")}. Check the module and the export name.`
+          );
+      }
+      e.ready = !0;
+    }
+    this._resume();
+  }
+  /** Release every worker out of the barrier loop, so each can take a message
+   * again. A parked worker runs no message callback. */
+  async _park() {
+    this._state = "idle";
+    const t = this._ctl;
+    Atomics.store(t, k, b), Atomics.store(t, f, ++this._epoch), Atomics.notify(t, f), await Promise.all(this._workers.map((e) => e.expect("yielded")));
+  }
+  _resume() {
+    if (this._state === "idle") {
+      for (const t of this._workers) t.post({ type: "run" });
+      this._state = "running";
+    }
+  }
+  /**
+   * Run one parallel system across the pool, or say no.
+   *
+   * Returns `false` when the kernel is not loaded yet, when the pool is not on
+   * the barrier, when an earlier pass timed out, or when the matched row count
+   * is below the system's threshold. The caller then runs the sequential body,
+   * which is the same answer.
+   *
+   * Throws `PARALLEL_KERNEL_FAILED` when a kernel throws, and when a worker
+   * misses the join inside `joinTimeoutMs`. The second case is a dead or hung
+   * worker, which reports nothing, so the pool fails the pass itself.
+   *
+   * Hot path. The host parks for the length of the pass, so no structural
+   * change can overlap it.
+   */
+  run(t, e, n, s) {
+    if (!t.ready || this._state !== "running" || (e.publishRowCounts(), t.query.entityCount < t.minRows)) return !1;
+    const r = this._ctl, i = t.exclude;
+    Atomics.store(r, p, 0), Atomics.store(r, A, 0);
+    for (let u = 0; u < m; u++)
+      r[R + u] = t.include[u] | 0, r[N + u] = i === null ? 0 : i[u] | 0;
+    r[S] = i === null ? 0 : 1, this._ctlF64[T] = n, Atomics.store(r, k, t.slot), Atomics.store(r, f, ++this._epoch), Atomics.notify(r, f);
+    const c = this._workers.length, _ = performance.now() + this._joinTimeoutMs;
+    for (; ; ) {
+      const u = Atomics.load(r, p);
+      if (u === c) break;
+      const w = _ - performance.now();
+      if (w <= 0)
+        throw this._stamp(t, s), this._state = "failed", new l(
+          h.PARALLEL_KERNEL_FAILED,
+          `a worker did not reach the join of the kernel export '${t.exportName}' within joinTimeoutMs of ${this._joinTimeoutMs}. The world holds whatever the pass wrote, and every later frame runs the sequential body. Detach the pool and fix the kernel.`
+        );
+      Atomics.wait(r, p, u, w);
+    }
+    this._stamp(t, s);
+    const d = Atomics.load(r, A);
+    if (d !== 0)
+      throw new l(
+        h.PARALLEL_KERNEL_FAILED,
+        `worker ${d - 1} threw inside the kernel export '${t.exportName}'. The world is unchanged for the rows that worker owned. Fix the kernel, or lower parallel.minRows to keep the system sequential.`
+      );
+    return !0;
+  }
+  /**
+   * Stamp what the pass changed.
+   *
+   * The row tick plane and the dirty lists are main-thread JS, so the join does
+   * this and not the workers. `columnGroupMut` makes the same archetype stamp a
+   * system body makes, which is why that logic is not written twice here.
+   *
+   * The row ticks follow the same shape a chunk loop takes when it reads
+   * `cols.ticks`: fill the plane, then tell the store to scan it. Without the
+   * fill an entity-level `onSet` observer would see nothing, because the
+   * archetype stamp alone carries no row.
+   *
+   * Coarse on purpose: a parallel system reports every row of every matched
+   * archetype as changed. A finer stamp is open.
+   */
+  _stamp(t, e) {
+    const n = t.query.archetypes, s = t.writes;
+    for (let r = 0; r < n.length; r++) {
+      const i = n[r];
+      if (i.hasColumns)
+        for (let c = 0; c < s.length; c++) {
+          const _ = s[c];
+          i.columnGroupMut(_, e);
+          const d = i.rowTicks[_.id];
+          d !== void 0 && d.fill(e, 0, i.enabledCount);
+        }
+    }
+    for (let r = 0; r < s.length; r++) this._world.noteScan(s[r].id);
+  }
+  /**
+   * Stop every worker and release the pool. Idempotent.
+   *
+   * `terminate` ends a worker that is spinning inside a kernel, so this is the
+   * way out of a pool a join timeout failed. A failed pool is never released
+   * back into the barrier, so no stop job is written for it.
+   */
+  async detach() {
+    if (this._state === "detached") return;
+    try {
+      await this._syncing;
+    } catch {
+    }
+    const t = this._state === "running";
+    if (this._state = "detached", this._pending.length = 0, t) {
+      const e = this._ctl;
+      Atomics.store(e, k, D), Atomics.store(e, f, ++this._epoch), Atomics.notify(e, f);
+    }
+    await Promise.all(this._workers.map((e) => e.terminate()));
+    for (const e of this._world.plans())
+      e.ready = !1, e.slot = -1;
+    this._world.released();
+  }
+}
+const F = 2e5;
+function O(o) {
+  const t = new Uint32Array(m);
+  for (let e = 0; e < m && e < o.length; e++) t[e] = o[e] >>> 0;
+  return t;
+}
+function H(o) {
+  const t = o.excludeWords;
+  return t === null ? null : O(t);
+}
+function V(o, t, e, n) {
+  const s = new Int32Array(o.columns.length * 2);
+  for (let r = 0; r < o.columns.length; r++) {
+    const [i, c] = o.columns[r];
+    s[r * 2] = i.id, s[r * 2 + 1] = n(i, c);
+  }
+  return {
+    slot: -1,
+    ready: !1,
+    exportName: o.kernel.export,
+    query: t,
+    include: O(t.include.words),
+    exclude: H(t),
+    specs: s,
+    minRows: o.minRows ?? F,
+    writes: e,
+    kernel: o.kernel
+  };
+}
+class Y {
+  _memory;
+  _changes;
+  _control;
+  /** Resolve the default query of a `parallel` config, which is the first
+   * entry of `queries` read as a with-only query. */
+  _resolveQuery;
+  _fieldId;
+  /** Every parallel plan, in registration order. The pool loads a kernel for
+   * each and clears them all on detach. */
+  _plans = [];
+  _pool = null;
+  /** @internal Built by `workers()`, never by a caller. */
+  constructor(t) {
+    const e = t.store, n = t.world;
+    this._resolveQuery = (s) => n.query(...s), this._fieldId = (s, r) => e.fieldIdOf(s, r), this._memory = t.memory, this._changes = t.changes, t.onDispose(() => this.dispose()), this._control = t.installRoute(this);
+  }
+  /** The attached pool, or `null`. */
+  get pool() {
+    return this._pool;
+  }
+  /**
+   * Start a pool of workers and run this world's parallel systems on it.
+   *
+   * Each worker gets the store bytes, the store base and a control buffer, and
+   * loads the kernel of every parallel system already registered. The promise
+   * resolves when every worker is parked on the barrier with its kernels in
+   * hand. A system registered later runs `fn` until `pool.settled()` resolves.
+   *
+   * The world's backing must be `shared` or `wasm`, because a worker reads the
+   * bytes directly. The host must be able to block on `Atomics.wait`, which a
+   * browser main thread refuses. One pool per world.
+   *
+   * The host parks on every pass, so a worker that dies would park it for the
+   * life of the process. `joinTimeoutMs` bounds that wait, fails the frame
+   * with `PARALLEL_KERNEL_FAILED`, and leaves every later frame on the
+   * sequential body until the caller detaches.
+   *
+   * Cold path. Call it once, outside any frame.
+   *
+   * @example
+   * const pool = await world.workers.attach({ count: 4 });
+   * // later
+   * await world.workers.detach();
+   */
+  async attach(t) {
+    if (this._pool !== null)
+      throw new l(
+        h.WORKERS_ATTACHED,
+        "workers.attach: this world already holds a pool. One pool per world, detach it before you attach another."
+      );
+    const e = this._memory.backing;
+    if (e === null)
+      throw new l(
+        h.WORKERS_NEED_SHARED_BACKING,
+        `workers.attach: this world's backing is '${this._memory.backingSource}', and a worker cannot reach its bytes. Build the world with memory.backing "shared" or { wasm }.`
+      );
+    const n = await g.attach(
+      {
+        store: e,
+        storeBase: this._memory.storeBase,
+        noteScan: (s) => this._changes.noteScan(s),
+        plans: () => this._plans,
+        released: () => {
+          this._pool = null, this._control.route(null);
+        }
+      },
+      t
+    );
+    return this._pool = n, this._control.route(n), n;
+  }
+  /** Stop the workers and put every parallel system back on its `fn`.
+   * Resolves at once on a world that holds no pool. */
+  async detach() {
+    const t = this._pool;
+    t !== null && await t.detach();
+  }
+  /** @internal The registration seam. Resolves one `parallel` config into the
+   * plan the dispatch reads, and refuses what a worker cannot serve. The
+   * world asks about every system, so a system that declares no `parallel`
+   * answers `undefined` and keeps its own `fn`. */
+  plan(t) {
+    const e = t.parallel;
+    if (e === void 0) return;
+    let n = e.query;
+    if (n === void 0) {
+      const r = t.queries?.[0];
+      if (r === void 0)
+        throw new l(
+          h.PARALLEL_ACCESS,
+          `registerSystem: config${t.name ? ` '${t.name}'` : ""} declares 'parallel' with neither 'parallel.query' nor a first entry in 'queries'. A worker resolves the matched archetypes from a query, so one is required.`
+        );
+      n = this._resolveQuery(r);
+    }
+    const s = V(e, n, t.writes, this._fieldId);
+    return this._plans.push(s), this._pool?.register(s), s;
+  }
+  /** @internal The world is going away. The workers hold the store bytes and
+   * keep the process alive, so they stop with it. `ECS.dispose` is
+   * synchronous and the stop is not, so this starts it and awaits nothing. */
+  dispose() {
+    this._pool?.detach(), this._plans.length = 0;
+  }
+}
+function Q() {
+  return {
+    name: "workers",
+    install(o) {
+      return { workers: new Y(o) };
+    }
+  };
+}
+export {
+  M as DEFAULT_JOIN_TIMEOUT_MS,
+  Y as ECSWorkers,
+  g as WorkerPool,
+  Q as workers
+};

package/dist/primitives.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("./typed_arrays-D3NmwtCG.cjs"),t=require("./topological_sort-BDvEyb9W.cjs");class o{_dense=[];_sparse=[];get size(){return this._dense.length}get values(){return this._dense}has(e){return this._dense[this._sparse[e]]===e}add(e){this.has(e)||(this._sparse[e]=this._dense.length,this._dense.push(e))}delete(e){if(!this.has(e))return!1;const a=this._sparse[e],s=this._dense[this._dense.length-1];return this._dense[a]=s,this._sparse[s]=a,this._dense.pop(),!0}clear(){this._dense.length=0,this._sparse.length=0}[Symbol.iterator](){return this._dense[Symbol.iterator]()}}exports.BitSet=r.BitSet;exports.GrowableFloat32Array=r.GrowableFloat32Array;exports.GrowableFloat64Array=r.GrowableFloat64Array;exports.GrowableInt16Array=r.GrowableInt16Array;exports.GrowableInt32Array=r.GrowableInt32Array;exports.GrowableInt8Array=r.GrowableInt8Array;exports.GrowableTypedArray=r.GrowableTypedArray;exports.GrowableUint16Array=r.GrowableUint16Array;exports.GrowableUint32Array=r.GrowableUint32Array;exports.GrowableUint8Array=r.GrowableUint8Array;exports.BinaryHeap=t.BinaryHeap;exports.SparseMap=t.SparseMap;exports.topologicalSort=t.topologicalSort;exports.SparseSet=o;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("./topological_sort-vp1imU6D.cjs");class n{_dense=[];_sparse=[];get size(){return this._dense.length}get values(){return this._dense}has(e){return this._dense[this._sparse[e]]===e}add(e){this.has(e)||(this._sparse[e]=this._dense.length,this._dense.push(e))}delete(e){if(!this.has(e))return!1;const s=this._sparse[e],r=this._dense[this._dense.length-1];return this._dense[s]=r,this._sparse[r]=s,this._dense.pop(),!0}clear(){this._dense.length=0,this._sparse.length=0}[Symbol.iterator](){return this._dense[Symbol.iterator]()}}class i{_denseKeys=[];_denseVals=[];_sparse=[];get size(){return this._denseKeys.length}get keys(){return this._denseKeys}has(e){return this._denseKeys[this._sparse[e]]===e}get(e){return this.has(e)?this._denseVals[this._sparse[e]]:void 0}set(e,s){if(this.has(e)){this._denseVals[this._sparse[e]]=s;return}this._sparse[e]=this._denseKeys.length,this._denseKeys.push(e),this._denseVals.push(s)}delete(e){if(!this.has(e))return!1;const s=this._sparse[e],r=this._denseKeys[this._denseKeys.length-1];return this._denseKeys[s]=r,this._denseVals[s]=this._denseVals[this._denseVals.length-1],this._sparse[r]=s,this._denseKeys.pop(),this._denseVals.pop(),!0}clear(){this._denseKeys.length=0,this._denseVals.length=0,this._sparse.length=0}forEach(e){for(let s=0;s<this._denseKeys.length;s++)e(this._denseKeys[s],this._denseVals[s])}[Symbol.iterator](){let e=0;const s=this._denseKeys,r=this._denseVals;return{next(){return e<s.length?{value:[s[e],r[e++]],done:!1}:{value:void 0,done:!0}}}}}exports.BinaryHeap=t.BinaryHeap;exports.BitSet=t.BitSet;exports.GrowableFloat32Array=t.GrowableFloat32Array;exports.GrowableFloat64Array=t.GrowableFloat64Array;exports.GrowableInt16Array=t.GrowableInt16Array;exports.GrowableInt32Array=t.GrowableInt32Array;exports.GrowableInt8Array=t.GrowableInt8Array;exports.GrowableTypedArray=t.GrowableTypedArray;exports.GrowableUint16Array=t.GrowableUint16Array;exports.GrowableUint32Array=t.GrowableUint32Array;exports.GrowableUint8Array=t.GrowableUint8Array;exports.topologicalSort=t.topologicalSort;exports.SparseMap=i;exports.SparseSet=n;

package/dist/primitives.d.cts

@@ -1,11 +1,11 @@
 /**
- * `@oasys/oecs/primitives` — the general-purpose data-structure primitives the
- * ECS is built on, surfaced for direct consumer use: a bit set, sparse set/map,
+ * `@oasys/oecs/primitives`, the general-purpose data-structure primitives the
+ * ECS is built on, surfaced for direct consumer use: a bit set, sparse set and map,
  * growable typed arrays, a binary heap, and a topological sort.
  *
- * These are the low-level building blocks only; the ECS itself is the default
+ * These are the low-level building blocks only. The ECS itself is the default
  * `@oasys/oecs` entry. The internal assertion, brand, and error helpers under
- * `src/type_primitives/` are intentionally NOT re-exported here.
+ * `src/type_primitives/` are intentionally not re-exported here.
  *
  * @module
  */

package/dist/primitives.d.ts

@@ -1,11 +1,11 @@
 /**
- * `@oasys/oecs/primitives` — the general-purpose data-structure primitives the
- * ECS is built on, surfaced for direct consumer use: a bit set, sparse set/map,
+ * `@oasys/oecs/primitives`, the general-purpose data-structure primitives the
+ * ECS is built on, surfaced for direct consumer use: a bit set, sparse set and map,
  * growable typed arrays, a binary heap, and a topological sort.
  *
- * These are the low-level building blocks only; the ECS itself is the default
+ * These are the low-level building blocks only. The ECS itself is the default
  * `@oasys/oecs` entry. The internal assertion, brand, and error helpers under
- * `src/type_primitives/` are intentionally NOT re-exported here.
+ * `src/type_primitives/` are intentionally not re-exported here.
  *
  * @module
  */

package/dist/primitives.development.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("./typed_arrays-D3NmwtCG.cjs"),t=require("./topological_sort-BDvEyb9W.cjs");class o{_dense=[];_sparse=[];get size(){return this._dense.length}get values(){return this._dense}has(e){return this._dense[this._sparse[e]]===e}add(e){this.has(e)||(this._sparse[e]=this._dense.length,this._dense.push(e))}delete(e){if(!this.has(e))return!1;const a=this._sparse[e],s=this._dense[this._dense.length-1];return this._dense[a]=s,this._sparse[s]=a,this._dense.pop(),!0}clear(){this._dense.length=0,this._sparse.length=0}[Symbol.iterator](){return this._dense[Symbol.iterator]()}}exports.BitSet=r.BitSet;exports.GrowableFloat32Array=r.GrowableFloat32Array;exports.GrowableFloat64Array=r.GrowableFloat64Array;exports.GrowableInt16Array=r.GrowableInt16Array;exports.GrowableInt32Array=r.GrowableInt32Array;exports.GrowableInt8Array=r.GrowableInt8Array;exports.GrowableTypedArray=r.GrowableTypedArray;exports.GrowableUint16Array=r.GrowableUint16Array;exports.GrowableUint32Array=r.GrowableUint32Array;exports.GrowableUint8Array=r.GrowableUint8Array;exports.BinaryHeap=t.BinaryHeap;exports.SparseMap=t.SparseMap;exports.topologicalSort=t.topologicalSort;exports.SparseSet=o;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("./topological_sort-vp1imU6D.cjs");class n{_dense=[];_sparse=[];get size(){return this._dense.length}get values(){return this._dense}has(e){return this._dense[this._sparse[e]]===e}add(e){this.has(e)||(this._sparse[e]=this._dense.length,this._dense.push(e))}delete(e){if(!this.has(e))return!1;const s=this._sparse[e],r=this._dense[this._dense.length-1];return this._dense[s]=r,this._sparse[r]=s,this._dense.pop(),!0}clear(){this._dense.length=0,this._sparse.length=0}[Symbol.iterator](){return this._dense[Symbol.iterator]()}}class i{_denseKeys=[];_denseVals=[];_sparse=[];get size(){return this._denseKeys.length}get keys(){return this._denseKeys}has(e){return this._denseKeys[this._sparse[e]]===e}get(e){return this.has(e)?this._denseVals[this._sparse[e]]:void 0}set(e,s){if(this.has(e)){this._denseVals[this._sparse[e]]=s;return}this._sparse[e]=this._denseKeys.length,this._denseKeys.push(e),this._denseVals.push(s)}delete(e){if(!this.has(e))return!1;const s=this._sparse[e],r=this._denseKeys[this._denseKeys.length-1];return this._denseKeys[s]=r,this._denseVals[s]=this._denseVals[this._denseVals.length-1],this._sparse[r]=s,this._denseKeys.pop(),this._denseVals.pop(),!0}clear(){this._denseKeys.length=0,this._denseVals.length=0,this._sparse.length=0}forEach(e){for(let s=0;s<this._denseKeys.length;s++)e(this._denseKeys[s],this._denseVals[s])}[Symbol.iterator](){let e=0;const s=this._denseKeys,r=this._denseVals;return{next(){return e<s.length?{value:[s[e],r[e++]],done:!1}:{value:void 0,done:!0}}}}}exports.BinaryHeap=t.BinaryHeap;exports.BitSet=t.BitSet;exports.GrowableFloat32Array=t.GrowableFloat32Array;exports.GrowableFloat64Array=t.GrowableFloat64Array;exports.GrowableInt16Array=t.GrowableInt16Array;exports.GrowableInt32Array=t.GrowableInt32Array;exports.GrowableInt8Array=t.GrowableInt8Array;exports.GrowableTypedArray=t.GrowableTypedArray;exports.GrowableUint16Array=t.GrowableUint16Array;exports.GrowableUint32Array=t.GrowableUint32Array;exports.GrowableUint8Array=t.GrowableUint8Array;exports.topologicalSort=t.topologicalSort;exports.SparseMap=i;exports.SparseSet=n;

package/dist/primitives.development.js

@@ -1,5 +1,4 @@
-import { B as h, a as o, b as l, d as p, e as _, c as d, G as b, g as u, h as w, f as G } from "./typed_arrays-DIVwVy5_.js";
-import { B as y, S as A, t as S } from "./topological_sort-DK6EjpWa.js";
+import { i as l, B as _, a as d, b as o, d as p, e as u, c as g, G as y, g as K, h as b, f as c, t as f } from "./topological_sort-Cc_yXqPT.js";
 class a {
   _dense = [];
   _sparse = [];
@@ -9,16 +8,16 @@ class a {
   get values() {
     return this._dense;
   }
-  has(e) {
-    return this._dense[this._sparse[e]] === e;
+  has(s) {
+    return this._dense[this._sparse[s]] === s;
   }
-  add(e) {
-    this.has(e) || (this._sparse[e] = this._dense.length, this._dense.push(e));
+  add(s) {
+    this.has(s) || (this._sparse[s] = this._dense.length, this._dense.push(s));
   }
-  delete(e) {
-    if (!this.has(e)) return !1;
-    const s = this._sparse[e], r = this._dense[this._dense.length - 1];
-    return this._dense[s] = r, this._sparse[r] = s, this._dense.pop(), !0;
+  delete(s) {
+    if (!this.has(s)) return !1;
+    const e = this._sparse[s], t = this._dense[this._dense.length - 1];
+    return this._dense[e] = t, this._sparse[t] = e, this._dense.pop(), !0;
   }
   clear() {
     this._dense.length = 0, this._sparse.length = 0;
@@ -27,19 +26,64 @@ class a {
     return this._dense[Symbol.iterator]();
   }
 }
+class n {
+  _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, e) {
+    if (this.has(s)) {
+      this._denseVals[this._sparse[s]] = e;
+      return;
+    }
+    this._sparse[s] = this._denseKeys.length, this._denseKeys.push(s), this._denseVals.push(e);
+  }
+  delete(s) {
+    if (!this.has(s)) return !1;
+    const e = this._sparse[s], t = this._denseKeys[this._denseKeys.length - 1];
+    return this._denseKeys[e] = t, this._denseVals[e] = this._denseVals[this._denseVals.length - 1], this._sparse[t] = e, this._denseKeys.pop(), this._denseVals.pop(), !0;
+  }
+  clear() {
+    this._denseKeys.length = 0, this._denseVals.length = 0, this._sparse.length = 0;
+  }
+  forEach(s) {
+    for (let e = 0; e < this._denseKeys.length; e++)
+      s(this._denseKeys[e], this._denseVals[e]);
+  }
+  [Symbol.iterator]() {
+    let s = 0;
+    const e = this._denseKeys, t = this._denseVals;
+    return {
+      next() {
+        return s < e.length ? { value: [e[s], t[s++]], done: !1 } : { value: void 0, done: !0 };
+      }
+    };
+  }
+}
 export {
-  y as BinaryHeap,
-  h as BitSet,
-  o as GrowableFloat32Array,
-  l as GrowableFloat64Array,
+  l as BinaryHeap,
+  _ as BitSet,
+  d as GrowableFloat32Array,
+  o as GrowableFloat64Array,
   p as GrowableInt16Array,
-  _ as GrowableInt32Array,
-  d as GrowableInt8Array,
-  b as GrowableTypedArray,
-  u as GrowableUint16Array,
-  w as GrowableUint32Array,
-  G as GrowableUint8Array,
-  A as SparseMap,
+  u as GrowableInt32Array,
+  g as GrowableInt8Array,
+  y as GrowableTypedArray,
+  K as GrowableUint16Array,
+  b as GrowableUint32Array,
+  c as GrowableUint8Array,
+  n as SparseMap,
   a as SparseSet,
-  S as topologicalSort
+  f as topologicalSort
 };