@oasys/oecs 0.5.4 → 0.6.0

package/dist/plugins/workers.development.js

@@ -0,0 +1,596 @@
+import { C as f } from "./abi-NP8pNxpd.js";
+import { ECSError as l, ECS_ERROR as c } from "../index.development.js";
+async function N() {
+  const s = globalThis.process, e = s?.getBuiltinModule;
+  return typeof e == "function" ? e.call(s, "node:worker_threads") : await import(["node", "worker_threads"].join(":"));
+}
+const _ = 0, p = 1, k = 2, L = 3, R = 4, S = R + f, C = S + f, T = C + 1, $ = T + 1 >> 1, O = ($ + 1) * 8, P = -1, I = -2, E = 16, g = 65536, D = 3e4;
+function M(s) {
+  if (s === void 0) return 0;
+  if (!Number.isInteger(s) || s < 1)
+    throw new l(
+      c.WORKERS_COUNT_INVALID,
+      `workers.attach: stackBytes must be an integer >= 1, got ${String(s)}`
+    );
+  if (s % E !== 0)
+    throw new l(
+      c.WORKERS_COUNT_INVALID,
+      `workers.attach: stackBytes must be a multiple of ${E}, the frame alignment of a wasm shadow stack, got ${s}`
+    );
+  if (s < g)
+    throw new l(
+      c.WORKERS_COUNT_INVALID,
+      `workers.attach: stackBytes must be at least ${g}, one WASM page, got ${s}`
+    );
+  return s;
+}
+function W() {
+  try {
+    const s = new Int32Array(new SharedArrayBuffer(4));
+    return Atomics.wait(s, 0, 1, 0), !0;
+  } catch {
+    return !1;
+  }
+}
+function K() {
+  const s = globalThis.process;
+  return typeof s == "object" && s !== null && typeof s.versions?.node == "string";
+}
+function U() {
+  const s = globalThis.navigator?.hardwareConcurrency;
+  return typeof s != "number" || !Number.isFinite(s) ? 1 : Math.max(1, Math.floor(s) - 1);
+}
+function q() {
+  const s = new URL(import.meta.url), e = s.pathname, t = e.lastIndexOf("/"), o = e.slice(t + 1), n = o.indexOf("."), r = e.slice(0, t), a = r.slice(0, r.lastIndexOf("/") + 1);
+  return s.pathname = `${a}worker${n < 0 ? "" : o.slice(n)}`, s;
+}
+class v {
+  _waiting = /* @__PURE__ */ new Map();
+  _arrived = /* @__PURE__ */ new Map();
+  _failure = null;
+  deliver(e) {
+    const t = e.slot === void 0 ? e.type : `${e.type}:${e.slot}`, o = this._waiting.get(t);
+    if (o !== void 0 && o.length > 0) {
+      o.shift()(e);
+      return;
+    }
+    const n = this._arrived.get(t);
+    n === void 0 ? this._arrived.set(t, [e]) : n.push(e);
+  }
+  /** A worker that died answers nothing. Without this every wait outstanding
+   * on it would sit there for the life of the process. */
+  fail(e) {
+    this._failure = e;
+    for (const t of this._waiting.values())
+      for (; t.length > 0; ) t.shift()({ type: "kernel", error: e });
+    this._waiting.clear();
+  }
+  expect(e, t) {
+    if (this._failure !== null) return Promise.resolve({ type: e, slot: t, error: this._failure });
+    const o = t === void 0 ? e : `${e}:${t}`, n = this._arrived.get(o);
+    return n !== void 0 && n.length > 0 ? Promise.resolve(n.shift()) : new Promise((r) => {
+      const a = this._waiting.get(o);
+      a === void 0 ? this._waiting.set(o, [r]) : a.push(r);
+    });
+  }
+}
+async function B(s, e) {
+  const t = await N();
+  return e.map((o) => {
+    const n = new t.Worker(s, { workerData: o }), r = new v();
+    return n.on("message", (a) => r.deliver(a)), n.on("error", (a) => r.fail(a.message)), {
+      post: (a) => n.postMessage(a),
+      expect: (a, u) => r.expect(a, u),
+      terminate: () => n.terminate()
+    };
+  });
+}
+function j(s, e) {
+  return e.map((t) => {
+    const o = new Worker(s, { type: "module" }), n = new v();
+    return o.addEventListener(
+      "message",
+      (r) => n.deliver(r.data)
+    ), o.addEventListener("error", (r) => {
+      const a = r.message;
+      n.fail(
+        typeof a == "string" && a !== "" ? a : `the script at '${String(s)}' did not load`
+      );
+    }), o.postMessage(t), {
+      post: (r) => o.postMessage(r),
+      expect: (r, a) => n.expect(r, a),
+      terminate: () => (o.terminate(), Promise.resolve())
+    };
+  });
+}
+class y {
+  _world;
+  _workers;
+  _ctl;
+  _ctlF64;
+  _joinTimeoutMs;
+  _state = "idle";
+  _epoch = 0;
+  _nextSlot = 0;
+  _pending = [];
+  _syncing = Promise.resolve();
+  constructor(e, t, o, n) {
+    this._world = e, this._workers = t, this._ctl = new Int32Array(o), this._ctlF64 = new Float64Array(o), this._joinTimeoutMs = n;
+  }
+  /** 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(e, t) {
+    if (!W())
+      throw new l(
+        c.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 o = t?.count ?? U();
+    if (!Number.isInteger(o) || o < 1)
+      throw new l(
+        c.WORKERS_COUNT_INVALID,
+        `workers.attach: count must be an integer >= 1, got ${String(o)}`
+      );
+    const n = t?.joinTimeoutMs ?? D;
+    if (!Number.isInteger(n) || n < 1)
+      throw new l(
+        c.WORKERS_COUNT_INVALID,
+        `workers.attach: joinTimeoutMs must be an integer >= 1, got ${String(n)}`
+      );
+    const r = M(t?.stackBytes), a = new SharedArrayBuffer(O), u = [];
+    for (let d = 0; d < o; d++)
+      u.push({
+        store: e.store,
+        storeBase: e.storeBase,
+        control: a,
+        index: d,
+        count: o,
+        stackBytes: r
+      });
+    const m = t?.workerUrl ?? q(), h = K() ? await B(m, u) : j(m, u), i = await Promise.all(h.map((d) => d.expect("ready")));
+    for (let d = 0; d < i.length; d++) {
+      const A = i[d].error;
+      if (A !== void 0)
+        throw await Promise.all(h.map((x) => x.terminate())), new l(
+          c.WORKERS_ENTRY_UNREACHABLE,
+          `workers.attach: worker ${d} did not start from '${String(m)}': ${A}. Pass workerUrl with the URL your bundler emits for the '@oasys/oecs/worker' entry.`
+        );
+    }
+    const w = new y(e, h, a, n);
+    for (const d of e.plans()) w._pending.push(d);
+    w._kick();
+    try {
+      await w.settled();
+    } catch (d) {
+      throw await w.detach(), d;
+    }
+    return w;
+  }
+  /** Take one kernel. The system runs `fn` until every worker holds it. */
+  register(e) {
+    this._state === "detached" || this._state === "failed" || (this._pending.push(e), 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 e = this._pending;
+    this._pending = [], e.length > 0 && this._state === "running" && await this._park();
+    for (const t of e) {
+      t.slot = this._nextSlot++;
+      const o = {
+        type: "kernel",
+        slot: t.slot,
+        wasm: t.kernel.wasm,
+        js: t.kernel.js,
+        exportName: t.exportName,
+        specs: t.specs
+      }, n = await Promise.all(
+        this._workers.map((r) => (r.post(o), r.expect("kernel", t.slot)))
+      );
+      for (let r = 0; r < n.length; r++) {
+        const a = n[r].error;
+        if (a !== void 0)
+          throw new l(
+            c.PARALLEL_KERNEL_FAILED,
+            `worker ${r} could not load the kernel export '${t.exportName}': ${String(a).replace(/\.$/, "")}. Check the module and the export name.`
+          );
+      }
+      t.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 e = this._ctl;
+    Atomics.store(e, k, P), Atomics.store(e, _, ++this._epoch), Atomics.notify(e, _), await Promise.all(this._workers.map((t) => t.expect("yielded")));
+  }
+  _resume() {
+    if (this._state === "idle") {
+      for (const e of this._workers) e.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(e, t, o, n) {
+    if (!e.ready || this._state !== "running" || (t.publishRowCounts(), e.query.entityCount < e.minRows)) return !1;
+    const r = this._ctl, a = e.exclude;
+    Atomics.store(r, p, 0), Atomics.store(r, L, 0);
+    for (let i = 0; i < f; i++)
+      r[R + i] = e.include[i] | 0, r[S + i] = a === null ? 0 : a[i] | 0;
+    r[C] = a === null ? 0 : 1, this._ctlF64[$] = o, Atomics.store(r, k, e.slot), Atomics.store(r, _, ++this._epoch), Atomics.notify(r, _);
+    const u = this._workers.length, m = performance.now() + this._joinTimeoutMs;
+    for (; ; ) {
+      const i = Atomics.load(r, p);
+      if (i === u) break;
+      const w = m - performance.now();
+      if (w <= 0)
+        throw this._stamp(e, n), this._state = "failed", new l(
+          c.PARALLEL_KERNEL_FAILED,
+          `a worker did not reach the join of the kernel export '${e.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, i, w);
+    }
+    this._stamp(e, n);
+    const h = Atomics.load(r, L);
+    if (h !== 0)
+      throw new l(
+        c.PARALLEL_KERNEL_FAILED,
+        `worker ${h - 1} threw inside the kernel export '${e.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(e, t) {
+    const o = e.query.archetypes, n = e.writes;
+    for (let r = 0; r < o.length; r++) {
+      const a = o[r];
+      if (a.hasColumns)
+        for (let u = 0; u < n.length; u++) {
+          const m = n[u];
+          a.columnGroupMut(m, t);
+          const h = a.rowTicks[m.id];
+          h !== void 0 && h.fill(t, 0, a.enabledCount);
+        }
+    }
+    for (let r = 0; r < n.length; r++) this._world.noteScan(n[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 e = this._state === "running";
+    if (this._state = "detached", this._pending.length = 0, e) {
+      const t = this._ctl;
+      Atomics.store(t, k, I), Atomics.store(t, _, ++this._epoch), Atomics.notify(t, _);
+    }
+    await Promise.all(this._workers.map((t) => t.terminate()));
+    for (const t of this._world.plans())
+      t.ready = !1, t.slot = -1;
+    this._world.released();
+  }
+}
+const F = 2e5;
+function H(s, e, t) {
+  const o = WebAssembly.Module.imports(e);
+  let n = !1;
+  for (const a of o) {
+    if (a.module === "env" && a.name === "memory" && a.kind === "memory") {
+      n = !0;
+      continue;
+    }
+    throw new l(
+      c.PARALLEL_KERNEL_MODULE,
+      `${s} names a wasm kernel that imports '${a.module}.${a.name}' as a ${a.kind}, and a worker supplies only 'env.memory'. Drop the import, or move what it does into the kernel.`
+    );
+  }
+  if (!n)
+    throw new l(
+      c.PARALLEL_KERNEL_MODULE,
+      `${s} names a wasm kernel that imports no 'env.memory', so it addresses a linear memory of its own and never the store. Link the module with --import-memory.`
+    );
+  const r = WebAssembly.Module.exports(e).find((a) => a.name === t);
+  if (r === void 0)
+    throw new l(
+      c.PARALLEL_KERNEL_MODULE,
+      `${s} names the wasm kernel export '${t}' and the module exports no such name. Name an export the module carries.`
+    );
+  if (r.kind !== "function")
+    throw new l(
+      c.PARALLEL_KERNEL_MODULE,
+      `${s} names the wasm kernel export '${t}', and the module exports it as a ${r.kind}. A kernel must be a function.`
+    );
+}
+function b(s) {
+  const e = new Uint32Array(f);
+  for (let t = 0; t < f && t < s.length; t++) e[t] = s[t] >>> 0;
+  return e;
+}
+function G(s) {
+  const e = s.excludeWords;
+  return e === null ? null : b(e);
+}
+const V = [
+  ["spawns", "a worker makes no structural change"],
+  ["despawns", "a worker makes no structural change"],
+  ["transitions", "a worker makes no structural change"],
+  ["resourceReads", "a resource is a main-thread value"],
+  ["resourceWrites", "a resource is a main-thread value"],
+  ["sparseReads", "a sparse store is a main-thread object"],
+  ["sparseWrites", "a sparse store is a main-thread object"],
+  ["relationReads", "a relation store is a main-thread object"],
+  ["relationWrites", "a relation store is a main-thread object"]
+];
+function Y(s, e) {
+  const t = s.parallel, o = s.name !== void 0 ? `system '${s.name}'` : "a parallel system";
+  for (const [i, w] of V) {
+    const d = s[i];
+    if (d !== void 0 && d.length > 0)
+      throw new l(
+        c.PARALLEL_ACCESS,
+        `${o} declares '${i}' beside 'parallel', and ${w}. Drop the declaration, or run the system sequentially.`
+      );
+  }
+  if (s.exclusive === !0)
+    throw new l(
+      c.PARALLEL_ACCESS,
+      `${o} declares 'exclusive' beside 'parallel', and an exclusive system reaches state no worker can see. Drop 'exclusive', or run the system sequentially.`
+    );
+  if (s.backendHandle !== void 0)
+    throw new l(
+      c.PARALLEL_ACCESS,
+      `${o} declares 'backendHandle' beside 'parallel', and one system body cannot run in two places. Keep one of them.`
+    );
+  if (s.fn === void 0)
+    throw new l(
+      c.PARALLEL_ACCESS,
+      `${o} declares 'parallel' with no 'fn'. The sequential body runs below the row threshold, and on a world with no pool, so it is required.`
+    );
+  const n = e.terms;
+  if (n.sparseIncludes.length > 0 || n.sparseExcludes.length > 0 || n.relationIncludes.length > 0 || n.relationExcludes.length > 0 || n.hierarchyTerm !== null || n.includesDisabled)
+    throw new l(
+      c.PARALLEL_ACCESS,
+      `${o} runs over a query that carries a sparse, relation, hierarchy or disabled term, and a worker resolves a query from the archetype masks alone. Give it a query whose only terms are .and and .not.`
+    );
+  const r = /* @__PURE__ */ new Set();
+  for (const i of s.reads) r.add(i.id);
+  for (const i of s.writes) r.add(i.id);
+  const a = /* @__PURE__ */ new Set();
+  for (const i of e.defs) a.add(i.id);
+  const u = /* @__PURE__ */ new Set();
+  for (const [i] of t.columns) {
+    if (u.add(i.id), !r.has(i.id))
+      throw new l(
+        c.PARALLEL_ACCESS,
+        `${o} names component id ${i.id} in 'parallel.columns' but not in 'reads' or 'writes'. Add it to the access declaration.`
+      );
+    if (!a.has(i.id))
+      throw new l(
+        c.PARALLEL_ACCESS,
+        `${o} names component id ${i.id} in 'parallel.columns' but the query does not require it, so a matched archetype may hold no column for it. Add it to the query.`
+      );
+  }
+  for (const i of s.writes)
+    if (!u.has(i.id))
+      throw new l(
+        c.PARALLEL_ACCESS,
+        `${o} declares a write of component id ${i.id} that 'parallel.columns' does not name. The join stamps every declared write, and it needs the component's columns. Add a field of it to 'parallel.columns', or drop the write.`
+      );
+  for (const i of e.defs)
+    if (!r.has(i.id))
+      throw new l(
+        c.PARALLEL_ACCESS,
+        `${o} queries component id ${i.id} that is not in 'reads' or 'writes'. Add it to the access declaration.`
+      );
+  const m = t.minRows;
+  if (m !== void 0 && (!Number.isInteger(m) || m < 0))
+    throw new l(
+      c.PARALLEL_ACCESS,
+      `${o} declares parallel.minRows must be an integer >= 0, got ${String(m)}`
+    );
+  const h = t.kernel;
+  if (typeof h.export != "string" || h.export.length === 0)
+    throw new l(
+      c.PARALLEL_ACCESS,
+      `${o} declares parallel.kernel.export must be a non-empty export name, got ${String(h.export)}`
+    );
+  if (h.wasm === void 0 && h.js === void 0)
+    throw new l(
+      c.PARALLEL_ACCESS,
+      `${o} declares a parallel.kernel with neither 'wasm' nor 'js'. Give a compiled WebAssembly.Module, or an absolute module URL a worker can import.`
+    );
+  h.wasm !== void 0 && H(o, h.wasm, h.export);
+}
+function J(s, e, t, o) {
+  const n = new Int32Array(s.columns.length * 2);
+  for (let r = 0; r < s.columns.length; r++) {
+    const [a, u] = s.columns[r];
+    n[r * 2] = a.id, n[r * 2 + 1] = o(a, u);
+  }
+  return {
+    slot: -1,
+    ready: !1,
+    exportName: s.kernel.export,
+    query: e,
+    include: b(e.include.words),
+    exclude: G(e),
+    specs: n,
+    minRows: s.minRows ?? F,
+    writes: t,
+    kernel: s.kernel
+  };
+}
+class Q {
+  _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(e) {
+    const t = e.store, o = e.world;
+    this._resolveQuery = (n) => o.query(...n), this._fieldId = (n, r) => t.fieldIdOf(n, r), this._memory = e.memory, this._changes = e.changes, e.onDispose(() => this.dispose()), this._control = e.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(e) {
+    if (this._pool !== null)
+      throw new l(
+        c.WORKERS_ATTACHED,
+        "workers.attach: this world already holds a pool. One pool per world, detach it before you attach another."
+      );
+    const t = this._memory.backing;
+    if (t === null)
+      throw new l(
+        c.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 o = await y.attach(
+      {
+        store: t,
+        storeBase: this._memory.storeBase,
+        noteScan: (n) => this._changes.noteScan(n),
+        plans: () => this._plans,
+        released: () => {
+          this._pool = null, this._control.route(null);
+        }
+      },
+      e
+    );
+    return this._pool = o, this._control.route(o), o;
+  }
+  /** 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 e = this._pool;
+    e !== null && await e.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(e) {
+    const t = e.parallel;
+    if (t === void 0) return;
+    let o = t.query;
+    if (o === void 0) {
+      const r = e.queries?.[0];
+      if (r === void 0)
+        throw new l(
+          c.PARALLEL_ACCESS,
+          `registerSystem: config${e.name ? ` '${e.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.`
+        );
+      o = this._resolveQuery(r);
+    }
+    Y(e, o);
+    const n = J(t, o, e.writes, this._fieldId);
+    return this._plans.push(n), this._pool?.register(n), n;
+  }
+  /** @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 Z() {
+  return {
+    name: "workers",
+    install(s) {
+      return { workers: new Q(s) };
+    }
+  };
+}
+export {
+  D as DEFAULT_JOIN_TIMEOUT_MS,
+  Q as ECSWorkers,
+  y as WorkerPool,
+  Z as workers
+};