@oasys/oecs 0.5.4 → 0.6.0

package/dist/plugins/solid.js

@@ -0,0 +1,319 @@
+import { batch as u, createSignal as f } from "solid-js";
+import { createStore as b } from "solid-js/store";
+const w = "solid";
+class y {
+  eid = 0;
+  _cols;
+  constructor(e) {
+    this._cols = e;
+  }
+  field(e) {
+    return this._cols[e];
+  }
+}
+class m {
+  eid = 0;
+  row = 0;
+  _cols = /* @__PURE__ */ new Map();
+  _arch;
+  _def;
+  constructor(e) {
+    this._def = e;
+  }
+  bind(e) {
+    this._arch = e, this._cols.clear();
+  }
+  field(e) {
+    let s = this._cols.get(e);
+    return s === void 0 && (s = this._arch.getColumnRead(this._def, e), this._cols.set(e, s)), s[this.row];
+  }
+}
+function g(_, e) {
+  const s = _?.id;
+  if (typeof s != "number")
+    throw new TypeError(
+      `${e}: the definition is not a dense component, got ${String(_)}. Pass a dense component definition`
+    );
+  return s;
+}
+class p {
+  keys;
+  pending = /* @__PURE__ */ new Set();
+  cid;
+  wantsSet;
+  _owner;
+  _changes;
+  _def;
+  _project;
+  _cursor;
+  _entityReader;
+  _columnReader;
+  _setKeys;
+  /** What the view holds now, and the seed of a cell made later. The key set
+   * is derived from it, so a publish or a delete that changes its size marks
+   * the key signal dirty. */
+  _values = /* @__PURE__ */ new Map();
+  /** The cells a caller asked for. Two maps rather than one of pairs, so the
+   * publish takes one lookup and the accessor lookup stays off that path. */
+  _cellGet = /* @__PURE__ */ new Map();
+  _cellSet = /* @__PURE__ */ new Map();
+  _equals;
+  _keysDirty = !1;
+  _baseline;
+  _disposed = !1;
+  constructor(e, s, t, i, n, h, o) {
+    this._owner = e, this._changes = s.changes, this.cid = t, this._def = i, this._project = n, this.wantsSet = h === "entity", this._cursor = s.world.cursorRead(i), this._entityReader = new y(this._cursor), this._columnReader = h === "column" ? new m(i) : null, this._equals = o === void 0 ? void 0 : (r, l) => r === l || r !== void 0 && l !== void 0 && o(r, l), this._baseline = s.store.changeTick;
+    const [d, c] = f([]);
+    this.keys = d, this._setKeys = c;
+  }
+  cell(e) {
+    let s = this._cellGet.get(e);
+    if (s === void 0) {
+      const t = this._values.get(e), [i, n] = this._equals === void 0 ? f(t) : f(t, { equals: this._equals });
+      s = i, this._cellGet.set(e, i), this._cellSet.set(e, n);
+    }
+    return s;
+  }
+  /** Publish every current enabled member. Cold path, and the caller wraps it
+   * in a `batch`. */
+  seed() {
+    const e = this._changes.collectEnabledWith(this.cid);
+    for (let s = 0; s < e.length; s++) this._publishOne(e[s]);
+    this._flushKeys();
+  }
+  publish(e) {
+    if (this._columnReader !== null)
+      this._changes.forEachChangedArchetype(this.cid, this._baseline, this._onArchetype), this._baseline = e;
+    else {
+      const s = this._changes.drainSet(this.cid, e), t = s.scanned;
+      for (let n = 0; n < t.length; n++) this._publishOne(t[n]);
+      const i = s.listed;
+      for (let n = 0; n < i.length; n++) {
+        const h = i[n];
+        this._isPublishable(h) && this._publishOne(h);
+      }
+    }
+    this.pending.size !== 0 && (this.pending.forEach(this._resolvePending), this.pending.clear()), this._flushKeys();
+  }
+  dispose() {
+    this._disposed || (this._disposed = !0, this._owner._remove(this));
+  }
+  /** One archetype of the column grain. Bound once, so the sweep allocates no
+   * closure per tick. */
+  _onArchetype = (e) => {
+    const s = this._columnReader;
+    s.bind(e);
+    const t = e.entityIds, i = e.entityCount;
+    for (let n = 0; n < i; n++) {
+      s.row = n;
+      const h = t[n];
+      s.eid = h, this._writeRow(h, this._project(s));
+    }
+  };
+  /** One entity the structural hook recorded. Bound once, for the same
+   * reason as `_onArchetype`. */
+  _resolvePending = (e) => {
+    this._isPublishable(e) ? this._publishOne(e) : this._deleteOne(e);
+  };
+  _isPublishable(e) {
+    const s = this._changes;
+    return s.isAlive(e) && s.hasComponent(e, this._def) && !s.isDisabled(e);
+  }
+  _publishOne(e) {
+    this._cursor.at(e), this._entityReader.eid = e, this._writeRow(e, this._project(this._entityReader));
+  }
+  _writeRow(e, s) {
+    const t = this._values.size;
+    this._values.set(e, s), this._values.size !== t && (this._keysDirty = !0);
+    const i = this._cellSet.get(e);
+    i !== void 0 && i(s);
+  }
+  /** Drop the row. A row the view never held writes nothing, so a spawn and a
+   * despawn inside one tick leave Solid untouched. */
+  _deleteOne(e) {
+    if (!this._values.delete(e)) return;
+    this._keysDirty = !0;
+    const s = this._cellSet.get(e);
+    s !== void 0 && s(void 0);
+  }
+  _flushKeys() {
+    this._keysDirty && (this._keysDirty = !1, this._setKeys(Array.from(this._values.keys())));
+  }
+}
+class v {
+  value;
+  pending = /* @__PURE__ */ new Set();
+  cid;
+  wantsSet = !0;
+  _owner;
+  _changes;
+  _def;
+  _eid;
+  _fields;
+  /** The values the store held at creation, the reset target of a remove and
+   * of a disable. A Solid store has no row to delete here, so the channel
+   * states its empty value instead of a blind zero. */
+  _defaults;
+  _cursor;
+  _cols;
+  _write;
+  _disposed = !1;
+  constructor(e, s, t, i, n, h) {
+    this._owner = e, this._changes = s.changes, this.cid = t, this._def = i, this._eid = n, this._fields = h, this._cursor = s.world.cursorRead(i), this._cols = this._cursor;
+    const o = {};
+    for (let l = 0; l < h.length; l++) o[h[l]] = 0;
+    const [d, c] = b(o);
+    this.value = d, this._write = c;
+    const r = [];
+    for (let l = 0; l < h.length; l++) r.push(o[h[l]]);
+    this._defaults = r;
+  }
+  /** Publish the target's current fields, when it is there to read. Cold
+   * path, and the caller wraps it in a `batch`. */
+  seed() {
+    this._isPublishable() && this._publish();
+  }
+  publish(e) {
+    const s = this._changes.drainSet(this.cid, e), t = s.scanned;
+    let i = !1;
+    for (let n = 0; n < t.length; n++) t[n] === this._eid && (i = !0);
+    if (!i) {
+      const n = s.listed;
+      for (let h = 0; h < n.length; h++)
+        n[h] === this._eid && this._isPublishable() && (i = !0);
+    }
+    i && this._publish(), this.pending.size !== 0 && (this.pending.has(this._eid) && (this._isPublishable() ? this._publish() : this._reset()), this.pending.clear());
+  }
+  dispose() {
+    this._disposed || (this._disposed = !0, this._owner._remove(this));
+  }
+  _isPublishable() {
+    const e = this._changes, s = this._eid;
+    return e.isAlive(s) && e.hasComponent(s, this._def) && !e.isDisabled(s);
+  }
+  _publish() {
+    this._cursor.at(this._eid);
+    const e = this._fields;
+    for (let s = 0; s < e.length; s++) this._write(e[s], this._cols[e[s]]);
+  }
+  _reset() {
+    const e = this._fields;
+    for (let s = 0; s < e.length; s++) this._write(e[s], this._defaults[s]);
+  }
+}
+class S {
+  _host;
+  _views = [];
+  _byCid = /* @__PURE__ */ new Map();
+  constructor(e) {
+    this._host = e, e.changes.addStructuralHook(this._onStructural), e.onSettle(this._onSettle);
+  }
+  component(e, s, t = {}) {
+    const i = g(e, "solid.component"), n = new p(
+      this,
+      this._host,
+      i,
+      e,
+      s,
+      t.grain ?? "entity",
+      t.eq
+    );
+    return this._add(n), (t.seedExisting ?? !0) && u(() => n.seed()), n;
+  }
+  fields(e, s, t = {}) {
+    const i = (d) => {
+      const c = {};
+      for (let r = 0; r < s.length; r++) c[s[r]] = d.field(s[r]);
+      return c;
+    }, n = t.eq ?? ((d, c) => {
+      const r = d, l = c;
+      for (let a = 0; a < s.length; a++) if (r[s[a]] !== l[s[a]]) return !1;
+      return !0;
+    }), h = g(e, "solid.fields"), o = new p(
+      this,
+      this._host,
+      h,
+      e,
+      i,
+      t.grain ?? "entity",
+      n
+    );
+    return this._add(o), (t.seedExisting ?? !0) && u(() => o.seed()), o;
+  }
+  singleton(e, s, t, i = {}) {
+    const n = g(e, "solid.singleton"), h = new v(this, this._host, n, e, s, t);
+    return this._add(h), (i.seedExisting ?? !0) && u(() => h.seed()), h;
+  }
+  /** Drop a view and recompute its component's ask. Idempotent through the
+   * view's own disposed flag. */
+  _remove(e) {
+    const s = this._views.indexOf(e);
+    s >= 0 && this._views.splice(s, 1);
+    const t = this._byCid.get(e.cid);
+    if (t !== void 0) {
+      const i = t.indexOf(e);
+      i >= 0 && t.splice(i, 1), t.length === 0 && this._byCid.delete(e.cid);
+    }
+    this._reconfigure(e.cid);
+  }
+  _add(e) {
+    this._views.push(e);
+    let s = this._byCid.get(e.cid);
+    s === void 0 && (s = [], this._byCid.set(e.cid, s)), s.push(e), this._reconfigure(e.cid);
+  }
+  /** The OR of every live view's ask for `cid`. All-false on the last
+   * dispose, which is the same as never asking. Cold path. */
+  _reconfigure(e) {
+    const s = this._byCid.get(e);
+    let t = !1, i = !1;
+    if (s !== void 0)
+      for (let h = 0; h < s.length; h++)
+        t = !0, s[h].wantsSet && (i = !0);
+    const n = {
+      add: t,
+      remove: t,
+      disable: t,
+      enable: t,
+      set: i
+    };
+    this._host.changes.configureObservation(w, e, n);
+  }
+  /** Record the round's structural events, and write nothing. A view resolves
+   * them at settle, so an entity that arrives and leaves inside one tick
+   * never reaches Solid. */
+  _onStructural = (e) => {
+    this._views.length !== 0 && (this._record(e.addComp, e.addEid, e.addLen), this._record(e.remComp, e.remEid, e.remLen), this._record(e.disComp, e.disEid, e.disLen), this._record(e.enaComp, e.enaEid, e.enaLen));
+  };
+  _record(e, s, t) {
+    for (let i = 0; i < t; i++) {
+      const n = this._byCid.get(e[i]);
+      if (n === void 0) continue;
+      const h = s[i];
+      for (let o = 0; o < n.length; o++) n[o].pending.add(h);
+    }
+  }
+  /** The run tick of the settle in progress. It reaches `_publishAll` through
+   * a field so the batched body can be bound once. */
+  _run = 0;
+  _publishAll = () => {
+    const e = this._views, s = this._run;
+    for (let t = 0; t < e.length; t++) e[t].publish(s);
+  };
+  /** One Solid flush for the whole plugin, whatever the number of views.
+   * A world with no view calls `batch` never. */
+  _onSettle = (e) => {
+    this._views.length !== 0 && (this._run = e, u(this._publishAll));
+  };
+}
+function k() {
+  return {
+    name: "solid",
+    requires: [],
+    install(_) {
+      return { solid: new S(_) };
+    }
+  };
+}
+export {
+  k as solid
+};

package/dist/plugins/workers/index.d.cts

@@ -0,0 +1,75 @@
+import { WorkerPool, AttachWorkersOptions } from './pool.cjs';
+import { ParallelPlan } from './plan.cjs';
+import { Plugin, PluginHost, SystemRoutePlanner } from '../../core/ecs/plugin.cjs';
+import { SystemConfig } from '../../core/ecs/system.cjs';
+export { WorkerPool, DEFAULT_JOIN_TIMEOUT_MS } from './pool.cjs';
+export type { AttachWorkersOptions } from './pool.cjs';
+/**
+ * Start, report and stop the one pool a world runs its parallel systems on.
+ *
+ * It is also what the world calls back into. `plan` runs at registration, for
+ * every system, and claims the ones that declare `parallel`. The dispose hook
+ * runs with the world. Both are the plugin's half of the seam, not surface a
+ * caller uses.
+ */
+export declare class ECSWorkers implements SystemRoutePlanner {
+    private readonly _memory;
+    private readonly _changes;
+    private readonly _control;
+    /** Resolve the default query of a `parallel` config, which is the first
+     * entry of `queries` read as a with-only query. */
+    private readonly _resolveQuery;
+    private readonly _fieldId;
+    /** Every parallel plan, in registration order. The pool loads a kernel for
+     * each and clears them all on detach. */
+    private readonly _plans;
+    private _pool;
+    /** @internal Built by `workers()`, never by a caller. */
+    constructor(host: PluginHost);
+    /** The attached pool, or `null`. */
+    get pool(): WorkerPool | null;
+    /**
+     * 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();
+     */
+    attach(options?: AttachWorkersOptions): Promise<WorkerPool>;
+    /** Stop the workers and put every parallel system back on its `fn`.
+     * Resolves at once on a world that holds no pool. */
+    detach(): Promise<void>;
+    /** @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(config: SystemConfig): ParallelPlan | undefined;
+    /** @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(): void;
+}
+/** The world surface this plugin adds. */
+export interface WorkersPlugin {
+    readonly workers: ECSWorkers;
+}
+/** The workers plugin, for `ECS.create({ plugins: [workers()] })`. */
+export declare function workers(): Plugin<WorkersPlugin>;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/workers/index.d.ts

@@ -0,0 +1,75 @@
+import { WorkerPool, AttachWorkersOptions } from './pool.js';
+import { ParallelPlan } from './plan.js';
+import { Plugin, PluginHost, SystemRoutePlanner } from '../../core/ecs/plugin.js';
+import { SystemConfig } from '../../core/ecs/system.js';
+export { WorkerPool, DEFAULT_JOIN_TIMEOUT_MS } from './pool.js';
+export type { AttachWorkersOptions } from './pool.js';
+/**
+ * Start, report and stop the one pool a world runs its parallel systems on.
+ *
+ * It is also what the world calls back into. `plan` runs at registration, for
+ * every system, and claims the ones that declare `parallel`. The dispose hook
+ * runs with the world. Both are the plugin's half of the seam, not surface a
+ * caller uses.
+ */
+export declare class ECSWorkers implements SystemRoutePlanner {
+    private readonly _memory;
+    private readonly _changes;
+    private readonly _control;
+    /** Resolve the default query of a `parallel` config, which is the first
+     * entry of `queries` read as a with-only query. */
+    private readonly _resolveQuery;
+    private readonly _fieldId;
+    /** Every parallel plan, in registration order. The pool loads a kernel for
+     * each and clears them all on detach. */
+    private readonly _plans;
+    private _pool;
+    /** @internal Built by `workers()`, never by a caller. */
+    constructor(host: PluginHost);
+    /** The attached pool, or `null`. */
+    get pool(): WorkerPool | null;
+    /**
+     * 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();
+     */
+    attach(options?: AttachWorkersOptions): Promise<WorkerPool>;
+    /** Stop the workers and put every parallel system back on its `fn`.
+     * Resolves at once on a world that holds no pool. */
+    detach(): Promise<void>;
+    /** @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(config: SystemConfig): ParallelPlan | undefined;
+    /** @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(): void;
+}
+/** The world surface this plugin adds. */
+export interface WorkersPlugin {
+    readonly workers: ECSWorkers;
+}
+/** The workers plugin, for `ECS.create({ plugins: [workers()] })`. */
+export declare function workers(): Plugin<WorkersPlugin>;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/workers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/workers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;KAoBK;AAEL,OAAO,EAAE,UAAU,EAAE,KAAK,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAC/D,OAAO,EAA4C,KAAK,YAAY,EAAE,MAAM,QAAQ,CAAC;AACrF,OAAO,KAAK,EAEX,MAAM,EACN,UAAU,EAGV,kBAAkB,EAClB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAI1D,OAAO,EAAE,UAAU,EAAE,uBAAuB,EAAE,MAAM,QAAQ,CAAC;AAC7D,YAAY,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAEnD;;;;;;;GAOG;AACH,qBAAa,UAAW,YAAW,kBAAkB;IACpD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IACvC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAa;IACtC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAe;IACxC;uDACmD;IACnD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAuC;IACrE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoD;IAC7E;6CACyC;IACzC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAC7C,OAAO,CAAC,KAAK,CAA2B;IAExC,yDAAyD;gBAC7C,IAAI,EAAE,UAAU;IAe5B,oCAAoC;IACpC,IAAW,IAAI,IAAI,UAAU,GAAG,IAAI,CAEnC;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACU,MAAM,CAAC,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,UAAU,CAAC;IAmCxE;yDACqD;IACxC,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAMpC;;;qDAGiD;IAC1C,IAAI,CAAC,MAAM,EAAE,YAAY,GAAG,YAAY,GAAG,SAAS;IAuB3D;;gFAE4E;IACrE,OAAO,IAAI,IAAI;CAItB;AAED,0CAA0C;AAC1C,MAAM,WAAW,aAAa;IAC7B,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;CAC7B;AAED,sEAAsE;AACtE,wBAAgB,OAAO,IAAI,MAAM,CAAC,aAAa,CAAC,CAO/C"}

package/dist/plugins/workers/node_threads.d.cts

@@ -0,0 +1,25 @@
+/***
+ * `node:worker_threads`, reached without a specifier a bundler can see.
+ *
+ * The pool and the worker entry both need the node threads module, and both
+ * ship in a bundle an app may compile for the browser. A literal
+ * `import("node:worker_threads")` is visible to the bundler, so the bundler
+ * reports an externalized node builtin and ships a stub module in its place.
+ * The report is noise, because the browser branch never evaluates the call, and
+ * an app author cannot act on it.
+ *
+ * `process.getBuiltinModule` reads the builtin with no specifier for a bundler
+ * to resolve. Node gained it after the version this package supports, so the
+ * fallback builds the specifier at run time, which no bundler resolves either.
+ ***/
+type NodeThreads = typeof import("node:worker_threads");
+/**
+ * The node threads module, on a node-compatible runtime.
+ *
+ * The caller decides that the runtime is node-compatible. On a browser this
+ * rejects, because there is no builtin to read. Cold path, and a caller runs it
+ * once for each pool and once for each worker.
+ */
+export declare function loadNodeThreads(): Promise<NodeThreads>;
+export {};
+//# sourceMappingURL=node_threads.d.ts.map

package/dist/plugins/workers/node_threads.d.ts

@@ -0,0 +1,25 @@
+/***
+ * `node:worker_threads`, reached without a specifier a bundler can see.
+ *
+ * The pool and the worker entry both need the node threads module, and both
+ * ship in a bundle an app may compile for the browser. A literal
+ * `import("node:worker_threads")` is visible to the bundler, so the bundler
+ * reports an externalized node builtin and ships a stub module in its place.
+ * The report is noise, because the browser branch never evaluates the call, and
+ * an app author cannot act on it.
+ *
+ * `process.getBuiltinModule` reads the builtin with no specifier for a bundler
+ * to resolve. Node gained it after the version this package supports, so the
+ * fallback builds the specifier at run time, which no bundler resolves either.
+ ***/
+type NodeThreads = typeof import("node:worker_threads");
+/**
+ * The node threads module, on a node-compatible runtime.
+ *
+ * The caller decides that the runtime is node-compatible. On a browser this
+ * rejects, because there is no builtin to read. Cold path, and a caller runs it
+ * once for each pool and once for each worker.
+ */
+export declare function loadNodeThreads(): Promise<NodeThreads>;
+export {};
+//# sourceMappingURL=node_threads.d.ts.map

package/dist/plugins/workers/node_threads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node_threads.d.ts","sourceRoot":"","sources":["../../../src/plugins/workers/node_threads.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;KAaK;AAEL,KAAK,WAAW,GAAG,cAAc,qBAAqB,CAAC,CAAC;AAMxD;;;;;;GAMG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,WAAW,CAAC,CAS5D"}

package/dist/plugins/workers/plan.d.cts

@@ -0,0 +1,61 @@
+import { ComponentDef } from '../../core/ecs/component.cjs';
+import { Query } from '../../core/ecs/query.cjs';
+import { ParallelConfig, SystemConfig } from '../../core/ecs/system.cjs';
+/**
+ * The total matched row count below which a parallel system runs `fn` on the
+ * main thread.
+ *
+ * Measured, and deliberately conservative. A probe sweeps a memory-bound body
+ * and a compute-bound one, each as a `js` kernel and as a `wasm` kernel, over
+ * the shared backing and the wasm backing, on more than one engine family. This
+ * value sits above every crossover it found. So a world that never tunes it
+ * never pays a pooled frame that the sequential frame would have won.
+ *
+ * One number cannot serve two costs, and this one serves the memory-bound case.
+ * A compute-bound body crosses far earlier, and this value costs it most of its
+ * gain. Give such a system its own `minRows`.
+ *
+ * The crossover also rises with the worker count, because the barrier grows
+ * while the work for each worker shrinks. The plan cannot scale by that count,
+ * because the pool attaches after the plan is built.
+ *
+ * `parallel.minRows` from the caller always wins, and zero is a value.
+ */
+export declare const DEFAULT_PARALLEL_MIN_ROWS = 200000;
+/** What one dispatch reads. Mutable, because the pool fills `slot` and `ready`
+ * when the workers report the kernel loaded. */
+export interface ParallelPlan {
+    /** The kernel's slot in the pool, or -1 before the pool takes it. */
+    slot: number;
+    /** Whether every worker holds the kernel. False until then, and the system
+     * runs `fn` in the meantime. */
+    ready: boolean;
+    readonly exportName: string;
+    /** The query whose archetypes the kernel runs over. */
+    readonly query: Query<any>;
+    readonly include: Uint32Array;
+    readonly exclude: Uint32Array | null;
+    /** `(component_id, field_id)` pairs, flat, in the kernel's argument order. */
+    readonly specs: Int32Array;
+    readonly minRows: number;
+    /** The components whose changed tick the join stamps. */
+    readonly writes: readonly ComponentDef<any>[];
+    readonly kernel: ParallelConfig["kernel"];
+}
+/**
+ * Refuse a parallel config a worker cannot serve. Dev guard, and it runs at
+ * registration so the fault names the config instead of a frame.
+ *
+ * `query` is the resolved first query, because the dense-only rule is a
+ * property of the query and not of the declaration list.
+ */
+export declare function assertParallelConfig(config: SystemConfig, query: Query<any>): void;
+/**
+ * Resolve one parallel config into the plan the dispatch reads. Runs in every
+ * build, because the masks and the column specs are not diagnostics.
+ *
+ * `fieldId` maps a field name to the id the descriptor carries, which is the
+ * world's own mapping.
+ */
+export declare function createParallelPlan(parallel: ParallelConfig, query: Query<any>, writes: readonly ComponentDef<any>[], fieldId: (def: ComponentDef<any>, field: string) => number): ParallelPlan;
+//# sourceMappingURL=plan.d.ts.map

package/dist/plugins/workers/plan.d.ts

@@ -0,0 +1,61 @@
+import { ComponentDef } from '../../core/ecs/component.js';
+import { Query } from '../../core/ecs/query.js';
+import { ParallelConfig, SystemConfig } from '../../core/ecs/system.js';
+/**
+ * The total matched row count below which a parallel system runs `fn` on the
+ * main thread.
+ *
+ * Measured, and deliberately conservative. A probe sweeps a memory-bound body
+ * and a compute-bound one, each as a `js` kernel and as a `wasm` kernel, over
+ * the shared backing and the wasm backing, on more than one engine family. This
+ * value sits above every crossover it found. So a world that never tunes it
+ * never pays a pooled frame that the sequential frame would have won.
+ *
+ * One number cannot serve two costs, and this one serves the memory-bound case.
+ * A compute-bound body crosses far earlier, and this value costs it most of its
+ * gain. Give such a system its own `minRows`.
+ *
+ * The crossover also rises with the worker count, because the barrier grows
+ * while the work for each worker shrinks. The plan cannot scale by that count,
+ * because the pool attaches after the plan is built.
+ *
+ * `parallel.minRows` from the caller always wins, and zero is a value.
+ */
+export declare const DEFAULT_PARALLEL_MIN_ROWS = 200000;
+/** What one dispatch reads. Mutable, because the pool fills `slot` and `ready`
+ * when the workers report the kernel loaded. */
+export interface ParallelPlan {
+    /** The kernel's slot in the pool, or -1 before the pool takes it. */
+    slot: number;
+    /** Whether every worker holds the kernel. False until then, and the system
+     * runs `fn` in the meantime. */
+    ready: boolean;
+    readonly exportName: string;
+    /** The query whose archetypes the kernel runs over. */
+    readonly query: Query<any>;
+    readonly include: Uint32Array;
+    readonly exclude: Uint32Array | null;
+    /** `(component_id, field_id)` pairs, flat, in the kernel's argument order. */
+    readonly specs: Int32Array;
+    readonly minRows: number;
+    /** The components whose changed tick the join stamps. */
+    readonly writes: readonly ComponentDef<any>[];
+    readonly kernel: ParallelConfig["kernel"];
+}
+/**
+ * Refuse a parallel config a worker cannot serve. Dev guard, and it runs at
+ * registration so the fault names the config instead of a frame.
+ *
+ * `query` is the resolved first query, because the dense-only rule is a
+ * property of the query and not of the declaration list.
+ */
+export declare function assertParallelConfig(config: SystemConfig, query: Query<any>): void;
+/**
+ * Resolve one parallel config into the plan the dispatch reads. Runs in every
+ * build, because the masks and the column specs are not diagnostics.
+ *
+ * `fieldId` maps a field name to the id the descriptor carries, which is the
+ * world's own mapping.
+ */
+export declare function createParallelPlan(parallel: ParallelConfig, query: Query<any>, writes: readonly ComponentDef<any>[], fieldId: (def: ComponentDef<any>, field: string) => number): ParallelPlan;
+//# sourceMappingURL=plan.d.ts.map

package/dist/plugins/workers/plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../../src/plugins/workers/plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;KAYK;AAGL,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAG1E;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,yBAAyB,SAAU,CAAC;AAEjD;gDACgD;AAChD,MAAM,WAAW,YAAY;IAC5B,qEAAqE;IACrE,IAAI,EAAE,MAAM,CAAC;IACb;oCACgC;IAChC,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,uDAAuD;IACvD,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,CAAC;IACrC,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,yDAAyD;IACzD,QAAQ,CAAC,MAAM,EAAE,SAAS,YAAY,CAAC,GAAG,CAAC,EAAE,CAAC;IAC9C,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAC;CAC1C;AA8ED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,CA0GlF;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CACjC,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,EACjB,MAAM,EAAE,SAAS,YAAY,CAAC,GAAG,CAAC,EAAE,EACpC,OAAO,EAAE,CAAC,GAAG,EAAE,YAAY,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,GACxD,YAAY,CAmBd"}