@offmain/workerkit 0.14.1 → 1.0.0

package/dist/index.js

@@ -1,7 +1,9 @@
-var x = Object.defineProperty;
-var O = (l, e, r) => e in l ? x(l, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : l[e] = r;
-var _ = (l, e, r) => O(l, typeof e != "symbol" ? e + "" : e, r);
-const j = (l) => `
+var C = Object.defineProperty;
+var O = (o, e, r) => e in o ? C(o, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : o[e] = r;
+var y = (o, e, r) => O(o, typeof e != "symbol" ? e + "" : e, r);
+import { e as E } from "./index-2AONniOz.js";
+import { d as ie } from "./index-2AONniOz.js";
+const R = `
 const extractTransferables = (value, seen = new Set()) => {
   if (value === null || typeof value !== 'object') return [];
   if (seen.has(value)) return [];
@@ -15,31 +17,73 @@ const extractTransferables = (value, seen = new Set()) => {
   if (Array.isArray(value)) return value.flatMap(i => extractTransferables(i, seen));
   return Object.values(value).flatMap(v => extractTransferables(v, seen));
 };
-
+`, U = (o) => `
+${R}
 self.addEventListener('message', async (event) => {
   try {
-    const output = await ${l}(event.data);
+    const output = await ${o}(event.data);
     self.postMessage({ ok: true, data: output }, extractTransferables(output));
   } catch (err) {
     self.postMessage({ ok: false, error: err instanceof Error ? err.message : String(err) });
   }
 })
-`, L = (l) => `
-const extractTransferables = (value, seen = new Set()) => {
-  if (value === null || typeof value !== 'object') return [];
-  if (seen.has(value)) return [];
-  seen.add(value);
-  if (value instanceof ArrayBuffer || value instanceof MessagePort ||
-      (typeof ImageBitmap !== 'undefined' && value instanceof ImageBitmap) ||
-      (typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas)) {
-    return [value];
+`, N = (o) => `
+${R}
+const workerFn = ${o};
+let memPort = null;
+let factoryToken = null;
+let pendingPayload = null;
+
+async function runAndStore(payload) {
+  try {
+    const output = await workerFn(payload);
+    if (!memPort) {
+      // Fallback: no port provided, post data directly (legacy / opt-out path)
+      self.postMessage({ ok: true, data: output }, extractTransferables(output));
+      return;
+    }
+    // Store directly into MemoryWorker
+    const ref = 'mem_' + crypto.randomUUID();
+    await new Promise((resolve, reject) => {
+      memPort.onmessage = (e) => {
+        if (e.data && e.data.ref === ref) {
+          if (e.data.ok) resolve(e.data.ref);
+          else reject(new Error(e.data.error || 'MemoryWorker SET failed'));
+        }
+      };
+      memPort.postMessage({ action: 'SET', factoryToken, ref, data: output });
+    });
+    // Only the token reaches the main thread
+    self.postMessage({ ok: true, __memory_ref__: ref });
+  } catch (err) {
+    self.postMessage({ ok: false, error: err instanceof Error ? err.message : String(err) });
   }
-  if (ArrayBuffer.isView(value)) return [value.buffer];
-  if (Array.isArray(value)) return value.flatMap(i => extractTransferables(i, seen));
-  return Object.values(value).flatMap(v => extractTransferables(v, seen));
-};
+}
 
-const workerFn = ${l};
+self.addEventListener('message', async (event) => {
+  // Init message: receive the MemoryWorker port and factory token
+  if (event.data && event.data.__init_memory_port__) {
+    memPort = event.ports[0] ?? event.data.memPort;
+    factoryToken = event.data.factoryToken;
+    if (memPort) memPort.start();
+    // If a payload arrived before the port, process it now
+    if (pendingPayload !== null) {
+      const p = pendingPayload;
+      pendingPayload = null;
+      await runAndStore(p);
+    }
+    return;
+  }
+  // If port not yet received, queue the payload
+  if (!memPort) {
+    pendingPayload = event.data;
+    return;
+  }
+  await runAndStore(event.data);
+});
+`, j = (o) => `
+${R}
+const workerFn = ${o};
 let outputPort = null;
 let inputPort = null;
 let pendingData = null;
@@ -104,22 +148,9 @@ self.addEventListener('message', (event) => {
     pendingData = event.data;
   }
 });
-`, C = (l) => `
-const extractTransferables = (value, seen = new Set()) => {
-  if (value === null || typeof value !== 'object') return [];
-  if (seen.has(value)) return [];
-  seen.add(value);
-  if (value instanceof ArrayBuffer || value instanceof MessagePort ||
-      (typeof ImageBitmap !== 'undefined' && value instanceof ImageBitmap) ||
-      (typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas)) {
-    return [value];
-  }
-  if (ArrayBuffer.isView(value)) return [value.buffer];
-  if (Array.isArray(value)) return value.flatMap(i => extractTransferables(i, seen));
-  return Object.values(value).flatMap(v => extractTransferables(v, seen));
-};
-
-const workerFn = ${l};
+`, G = (o) => `
+${R}
+const workerFn = ${o};
 let cachedDataset = null;
 
 self.addEventListener('message', async (event) => {
@@ -161,13 +192,14 @@ self.addEventListener('message', async (event) => {
   }
 });
 `;
-var P = /* @__PURE__ */ ((l) => (l.Default = "default", l.Pipeline = "pipeline", l.Persistent = "persistent", l))(P || {});
-const F = Object.freeze({
-  persistent: C,
-  pipeline: L,
-  default: j
+var D = /* @__PURE__ */ ((o) => (o.Default = "default", o.Pipeline = "pipeline", o.Persistent = "persistent", o.Memory = "memory", o))(D || {});
+const q = Object.freeze({
+  persistent: G,
+  pipeline: j,
+  default: U,
+  memory: N
 });
-class M {
+class b {
   /**
    * Creates a new `Worker` from the given function or factory option.
    *
@@ -177,14 +209,14 @@ class M {
    * @param options - Optional configuration containing `createWorker` or `mode`.
    */
   constructor(e, r) {
-    _(this, "_worker");
+    y(this, "_worker");
     if (r != null && r.createWorker)
       this._worker = r.createWorker();
     else if (e) {
-      const a = (r == null ? void 0 : r.mode) ?? "default", t = F[a](e.toString()), i = new Blob([t], {
+      const a = (r == null ? void 0 : r.mode) ?? "default", t = q[a](e.toString()), l = new Blob([t], {
         type: "application/javascript"
       });
-      this._worker = new Worker(URL.createObjectURL(i));
+      this._worker = new Worker(URL.createObjectURL(l));
     } else
       throw new Error(
         "Either workerFunction or options.createWorker must be provided to WorkerFactory."
@@ -200,58 +232,43 @@ class M {
     return this._worker;
   }
 }
-class I {
-  constructor(e) {
-    this.results = e;
-  }
-}
-class $ {
+class z {
   constructor() {
-    _(this, "store", /* @__PURE__ */ new Map());
+    y(this, "store", /* @__PURE__ */ new Map());
   }
   /**
-   * Stores a dataset in RAM under an unguessable reference ID.
+   * Registers a ref in the registry.
    *
-   * @param data - The dataset to store.
-   * @param refId - Optional reference ID; if omitted, a UUID will be generated.
-   * @returns The reference ID under which the dataset is stored.
+   * @param ref - The memory reference ID (generated by MemoryWorkerProxy).
+   * @param metadata - Optional metadata (size hint, type tag, etc.).
    */
-  set(e, r) {
-    const a = r ?? `mem_${crypto.randomUUID()}`;
-    return this.store.set(a, e), a;
+  register(e, r = {}) {
+    this.store.set(e, r);
   }
   /**
-   * Retrieves a dataset from RAM by its reference ID.
-   *
-   * @param refId - The reference ID to retrieve.
-   * @returns The stored dataset, or undefined if not found.
+   * Checks if a reference ID is registered.
+   * @param refId - The reference ID to check.
    */
-  get(e) {
-    return this.store.get(e);
+  has(e) {
+    return this.store.has(e);
   }
   /**
-   * Deletes a dataset reference from RAM.
+   * Unregisters a reference ID.
    *
-   * @param refId - The reference ID to delete.
+   * @param refId - The reference ID to unregister.
    * @returns `true` if the key existed and was removed, `false` otherwise.
    */
   delete(e) {
     return this.store.delete(e);
   }
   /**
-   * Clears all dataset handles from RAM.
+   * Clears all registered references.
    */
   clear() {
     this.store.clear();
   }
   /**
-   * Checks if a reference ID exists in RAM.
-   */
-  has(e) {
-    return this.store.has(e);
-  }
-  /**
-   * Returns statistics about current memory handles.
+   * Returns statistics about current registered handles.
    */
   stats() {
     return {
@@ -260,708 +277,973 @@ class $ {
     };
   }
 }
-function w(l, e = /* @__PURE__ */ new Set()) {
-  return l === null || typeof l != "object" ? [] : e.has(l) ? [] : (e.add(l), l instanceof ArrayBuffer || l instanceof MessagePort || typeof ImageBitmap < "u" && l instanceof ImageBitmap || typeof OffscreenCanvas < "u" && l instanceof OffscreenCanvas ? [l] : ArrayBuffer.isView(l) ? [l.buffer] : Array.isArray(l) ? l.flatMap((r) => w(r, e)) : Object.values(l).flatMap(
-    (r) => w(r, e)
-  ));
+const K = `
+const store = new Map();
+
+function handleMessage(msg, replyTarget) {
+  if (!msg || typeof msg !== 'object') return;
+
+  const { action, factoryToken, expectedToken, ref, data, id } = msg;
+
+  // Initial handshake to set expected token if needed
+  if (action === 'INIT_TOKEN') {
+    self.__expectedToken = expectedToken;
+    replyTarget.postMessage({ ok: true, action: 'INIT_TOKEN_ACK' });
+    return;
+  }
+
+  // Validate factory token
+  if (self.__expectedToken && factoryToken !== self.__expectedToken) {
+    replyTarget.postMessage({ ok: false, error: 'Unauthorized: invalid factory token', id });
+    return;
+  }
+
+  try {
+    switch (action) {
+      case 'SET': {
+        const refId = ref || ('mem_' + crypto.randomUUID());
+        store.set(refId, data);
+        replyTarget.postMessage({ ok: true, ref: refId, id });
+        break;
+      }
+      case 'GET': {
+        const resultData = store.get(ref);
+        const exists = store.has(ref);
+        replyTarget.postMessage({ ok: true, exists, data: resultData, ref, id });
+        break;
+      }
+      case 'DELETE': {
+        const deleted = store.delete(ref);
+        replyTarget.postMessage({ ok: true, deleted, ref, id });
+        break;
+      }
+      case 'CLEAR': {
+        store.clear();
+        replyTarget.postMessage({ ok: true, action: 'CLEAR_ACK', id });
+        break;
+      }
+      case 'STATS': {
+        replyTarget.postMessage({
+          ok: true,
+          stats: {
+            count: store.size,
+            refs: Array.from(store.keys()),
+          },
+          id,
+        });
+        break;
+      }
+      case 'REGISTER_PORT': {
+        // Register a MessagePort from a computing or reducer worker.
+        // All messages arriving on this port are handled with the same
+        // store operations, enabling direct worker-to-MemoryWorker data flow.
+        const port = msg.port;
+        if (!port) {
+          replyTarget.postMessage({ ok: false, error: 'REGISTER_PORT requires a port', id });
+          break;
+        }
+        port.onmessage = (event) => handleMessage(event.data, port);
+        port.start();
+        replyTarget.postMessage({ ok: true, action: 'PORT_REGISTERED', id });
+        break;
+      }
+      default:
+        replyTarget.postMessage({ ok: false, error: 'Unknown action: ' + action, id });
+    }
+  } catch (err) {
+    replyTarget.postMessage({
+      ok: false,
+      error: err instanceof Error ? err.message : String(err),
+      id,
+    });
+  }
 }
-class q {
-  /**
-   * Creates a new `MainWorkerFactory`.
-   *
-   * @param options - Configuration object containing the `workers` registry.
-   */
+
+self.addEventListener('message', (event) => {
+  // Handle REGISTER_PORT specially — the port itself is a Transferable in event.ports
+  if (event.data && event.data.action === 'REGISTER_PORT') {
+    const port = event.ports[0] ?? event.data.port;
+    const msg = { ...event.data, port };
+    handleMessage(msg, self);
+    return;
+  }
+  handleMessage(event.data, self);
+});
+`;
+class H {
   constructor(e) {
-    _(this, "_workers");
-    _(this, "_threads");
-    _(this, "_persistentWorkers", /* @__PURE__ */ new Map());
-    _(this, "_activeWorkers", /* @__PURE__ */ new Set());
-    _(this, "_memoryStore", new $());
-    _(this, "_isTerminated", !1);
-    this._workers = e.workers, this._threads = navigator.hardwareConcurrency;
+    y(this, "worker");
+    y(this, "factoryToken");
+    y(this, "pending", /* @__PURE__ */ new Map());
+    this.factoryToken = e;
+    const r = new Blob([K], {
+      type: "application/javascript"
+    });
+    this.worker = new Worker(URL.createObjectURL(r)), this.worker.onmessage = (a) => {
+      const { id: t } = a.data ?? {};
+      if (t && this.pending.has(t)) {
+        const l = this.pending.get(t);
+        this.pending.delete(t), l(a.data);
+      }
+    }, this.worker.postMessage({
+      action: "INIT_TOKEN",
+      expectedToken: e
+    });
+  }
+  send(e, r = {}) {
+    return new Promise((a) => {
+      const t = `req_${crypto.randomUUID()}`;
+      this.pending.set(t, a), this.worker.postMessage({
+        action: e,
+        factoryToken: this.factoryToken,
+        id: t,
+        ...r
+      });
+    });
   }
   /**
-   * Returns `true` if the factory has been terminated.
+   * Stores a dataset in the MemoryWorker.
+   *
+   * @param data - The dataset to store.
+   * @param ref - Optional ref ID; if omitted, MemoryWorker generates one.
+   * @returns The ref ID under which the data is stored.
    */
-  get isTerminated() {
-    return this._isTerminated;
+  async set(e, r) {
+    const a = await this.send("SET", { data: e, ref: r });
+    if (!a.ok) throw new Error(a.error);
+    return a.ref;
   }
   /**
-   * Registers an active worker instance for lifecycle tracking.
+   * Retrieves a dataset from the MemoryWorker by ref ID.
+   *
+   * @param ref - The ref ID to retrieve.
+   * @returns The stored dataset, or `undefined` if not found.
    */
-  trackWorker(e) {
-    if (this._isTerminated)
-      throw e.terminate(), new Error("MainWorkerFactory has been terminated");
-    return this._activeWorkers.add(e), e;
+  async get(e) {
+    const r = await this.send("GET", { ref: e });
+    if (!r.ok) throw new Error(r.error);
+    return r.data;
   }
   /**
-   * Terminates a worker instance and removes it from tracking.
+   * Checks if a ref ID exists in the MemoryWorker.
+   * @param ref - The ref ID to check.
    */
-  terminateWorker(e) {
-    this._activeWorkers.delete(e);
-    try {
-      e.terminate();
-    } catch {
-    }
+  async has(e) {
+    const r = await this.send("GET", { ref: e });
+    if (!r.ok) throw new Error(r.error);
+    return !!r.exists;
   }
   /**
-   * Instantiates a {@link WorkerFactory} for the given worker configuration.
+   * Deletes a ref from the MemoryWorker.
    *
-   * @param config - The worker configuration containing `func` or `createWorker`.
-   * @returns A new `WorkerFactory` wrapping the worker.
+   * @param ref - The ref ID to delete.
+   * @returns `true` if the ref existed and was deleted.
    */
-  initWorker(e) {
-    const r = new M(e.func, {
-      createWorker: e.createWorker
-    });
-    return this.trackWorker(r.getWorker), r;
+  async delete(e) {
+    const r = await this.send("DELETE", { ref: e });
+    if (!r.ok) throw new Error(r.error);
+    return !!r.deleted;
   }
   /**
-   * Splits an array into up to `numChunks` evenly-sized sub-arrays.
-   *
-   * When the array length is not evenly divisible, the first `remainder`
-   * chunks receive one extra element so no data is lost.
-   *
-   * @param array     - The source array to partition.
-   * @param numChunks - Maximum number of chunks to produce.
-   *   Clamped to `array.length` so you never get empty chunks.
-   * @returns An array of sub-arrays. Returns `[]` when `array` is empty.
-   * @throws {Error} When `numChunks` is not a positive integer.
-   *
-   * @example
-   * partitionArray([1, 2, 3, 4, 5], 3);
-   * // → [[1, 2], [3, 4], [5]]
+   * Clears all data from the MemoryWorker.
    */
-  partitionArray(e, r) {
-    if (!e.length) return [];
-    if (r <= 0) throw new Error("numChunks must be positive");
-    const a = Math.min(r, e.length), t = Math.floor(e.length / a), i = e.length % a, f = [];
-    let d = 0;
-    for (let s = 0; s < a; s++) {
-      const o = t + (s < i ? 1 : 0);
-      f.push(e.slice(d, d + o)), d += o;
-    }
-    return f;
+  async clear() {
+    const e = await this.send("CLEAR");
+    if (!e.ok) throw new Error(e.error);
   }
   /**
-   * Looks up a registered worker configuration by name.
-   *
-   * @param name - The `name` field of the target {@link WorkerConfig}.
-   * @returns The matching config, or `undefined` if not found.
+   * Returns statistics about data held in the MemoryWorker.
    */
-  findWorkerByName(e) {
-    return this._workers.find((r) => r.name === e);
+  async stats() {
+    const e = await this.send("STATS");
+    if (!e.ok) throw new Error(e.error);
+    return e.stats;
   }
   /**
-   * Runs a named worker against the provided data, distributing work across
-   * threads when the worker is configured for partitioning.
-   *
-   * When `config.partition` is `true` and `srcData` is an array with more
-   * than one element, the array is split into up to `maxConcurrency` (or
-   * `navigator.hardwareConcurrency`) shards and each shard is processed by
-   * a separate worker thread in parallel.
-   *
-   * All threads are awaited with `Promise.allSettled`, so a failure in one
-   * shard does not cancel the others. Use {@link collectResults} to merge
-   * the settled output.
+   * Allocates a direct `MessagePort` to the MemoryWorker for a computing or
+   * reducer worker.
    *
-   * @typeParam TName - The literal name of the worker to run (inferred from
-   *   the registered `workers` tuple).
+   * Creates a `MessageChannel` and registers one port with MemoryWorker via
+   * `REGISTER_PORT`. The other port (the "worker-side" port) is returned as a
+   * `Transferable` — it should be passed to the target worker via
+   * `postMessage(..., [workerPort])` so the worker can communicate with
+   * MemoryWorker directly without routing through the main thread.
    *
-   * @param workerName - Name of the worker as declared in the `workers` config.
-   * @param params     - Object containing `srcData` (the payload) plus any
-   *   additional key/value pairs forwarded to the worker verbatim.
-   *
-   * @returns A {@link TypedSettledResults} wrapping the settled promises from
-   *   all spawned worker threads.
-   *
-   * @example
-   * const settled = await foreman.runWorker('sum', { srcData: [1, 2, 3] });
+   * @returns The worker-side `MessagePort` ready to be transferred.
    */
-  async runWorker(e, r) {
-    if (this._isTerminated)
-      return Promise.reject(new Error("MainWorkerFactory has been terminated"));
-    const a = this.findWorkerByName(e);
-    if (!a)
-      return Promise.reject(new Error(`Worker "${e}" not found`));
-    let { srcData: t, ...i } = r || {};
-    const f = i.__memory_ref__, d = !!i.deleteMemory;
-    if (t === void 0 && f) {
-      if (!this._memoryStore.has(f))
-        return Promise.reject(
-          new Error(`Memory reference "${f}" not found in MemoryStore`)
-        );
-      t = this._memoryStore.get(f), delete i.__memory_ref__, delete i.deleteMemory;
-    } else
-      delete i.deleteMemory;
-    const s = a.maxConcurrency ?? this._threads, o = !!(Array.isArray(t) && a.partition), u = o ? this.partitionArray(t, s) : t, m = o && Array.isArray(u) ? u.length : s, p = this.createWorkerPromises(
-      a,
-      e,
-      { data: u, ...i },
-      m,
-      o
-    ), c = await Promise.allSettled(p);
-    return d && f && this._memoryStore.delete(f), (a.memoryOnly || a.memory) && this.storeWorkerMemoryResult(c, {
-      memoryOnly: !!a.memoryOnly,
-      shouldPartition: o
-    }), new I(c);
+  async allocateWorkerPort() {
+    const e = new MessageChannel(), { port1: r, port2: a } = e, t = `req_${crypto.randomUUID()}`;
+    return this.pending.set(t, () => {
+    }), this.worker.postMessage(
+      {
+        action: "REGISTER_PORT",
+        factoryToken: this.factoryToken,
+        id: t
+      },
+      [r]
+    ), await new Promise((l) => {
+      const f = this.pending.get(t);
+      this.pending.set(t, (m) => {
+        f(m), l();
+      });
+    }), a;
   }
   /**
-   * Deletes a specific memory reference from the factory's memory store.
-   *
-   * @param ref - The `__memory_ref__` token string to delete.
-   * @returns A promise that resolves to `true` if deleted, `false` otherwise.
+   * Terminates the MemoryWorker thread and clears all pending requests.
    */
-  async deleteMemory(e) {
-    return this._memoryStore.delete(e);
+  terminate() {
+    this.pending.clear(), this.worker.terminate();
   }
-  /**
-   * Clears all stored dataset references from the factory's memory store.
-   */
-  async clearMemory() {
-    this._memoryStore.clear();
+}
+class J {
+  constructor(e = "error") {
+    y(this, "level");
+    this.level = e;
   }
-  /**
-   * Saves the output of a completed worker execution into MemoryStore
-   * and modifies the returned settled results with a `__memory_ref__` token.
-   */
-  storeWorkerMemoryResult(e, {
-    memoryOnly: r,
-    shouldPartition: a
-  }) {
-    const t = e.filter(
-      (s) => s.status === "fulfilled" && !!s.value.successResult
+  setLevel(e) {
+    this.level = e;
+  }
+  verbose(...e) {
+    this.level === "verbose" && console.debug("[WorkerManager]", ...e);
+  }
+  info(...e) {
+    (this.level === "verbose" || this.level === "info") && console.info("[WorkerManager]", ...e);
+  }
+  error(...e) {
+    this.level !== "silent" && console.error("[WorkerManager]", ...e);
+  }
+}
+class V {
+  constructor(e) {
+    this.results = e;
+  }
+}
+function B(o, e) {
+  if (!o.length) return [];
+  if (e <= 0) throw new Error("numChunks must be positive");
+  const r = Math.min(e, o.length), a = Math.floor(o.length / r), t = o.length % r, l = [];
+  let f = 0;
+  for (let m = 0; m < r; m++) {
+    const i = a + (m < t ? 1 : 0);
+    l.push(o.slice(f, f + i)), f += i;
+  }
+  return l;
+}
+async function x(o, e = {}, r) {
+  if (r.isTerminated())
+    throw r.logger.error(
+      "Attempted to collect results after MainWorkerFactory was terminated"
+    ), new Error("MainWorkerFactory has been terminated");
+  const a = o.results.filter(
+    (n) => n.status === "fulfilled"
+  ), t = o.results.filter(
+    (n) => n.status === "rejected"
+  );
+  if (a.length === 0)
+    return {
+      data: [],
+      succeeded: 0,
+      failed: t.length,
+      errors: t
+    };
+  const l = a.map((n) => {
+    var k;
+    const c = (k = n.value.successResult) == null ? void 0 : k.data;
+    return c == null ? void 0 : c.__memory_ref__;
+  }), f = l.every((n) => typeof n == "string"), m = e.reducer ? e.reducer.toString() : "(shards) => shards.flat()";
+  let i;
+  if (f && typeof Worker < "u" && typeof Blob < "u" && typeof MessageChannel < "u") {
+    const n = await r.memoryWorkerProxy.allocateWorkerPort(), c = `
+      const refs = ${JSON.stringify(l)};
+      const factoryToken = ${JSON.stringify(r.factoryToken)};
+      const reducer = ${m};
+
+    // collect-results.ts
+
+      self.addEventListener('message', async (event) => {
+        // event.ports[0] is the direct line to MemoryWorker
+        const memPort = event.ports[0];
+        if (!memPort) {
+          self.postMessage({ ok: false, error: 'No MemoryWorker port provided' });
+          self.close();
+          return;
+        }
+        memPort.start();
+
+        try {
+          // Fetch each shard directly from MemoryWorker
+          const shards = await Promise.all(refs.map((ref) =>
+            new Promise((resolve, reject) => {
+              const reqId = 'fetch_' + ref;
+              memPort.addEventListener('message', function handler(e) {
+                if (e.data && e.data.ref === ref) {
+                  memPort.removeEventListener('message', handler);
+                  if (e.data.ok) resolve(e.data.data);
+                  else reject(new Error(e.data.error));
+                }
+              });
+              memPort.postMessage({ action: 'GET', factoryToken, ref, id: reqId });
+            })
+          ));
+
+          const result = reducer(shards);
+          self.postMessage({ ok: true, data: result });
+        } catch (error) {
+          self.postMessage({ ok: false, error: String(error) });
+        } finally {
+          self.close();
+        }
+      });
+    `;
+    try {
+      i = await new Promise((k, d) => {
+        const p = new Blob([c], { type: "application/javascript" }), s = r.trackWorker(
+          new Worker(URL.createObjectURL(p))
+        );
+        s.onmessage = (u) => {
+          r.terminateWorker(s), u.data.ok ? k(u.data.data) : (r.logger.error(
+            "Collect results reducer worker failed",
+            u.data.error
+          ), d(new Error(u.data.error)));
+        }, s.onerror = (u) => {
+          r.terminateWorker(s), r.logger.error(
+            "Collect results reducer worker encountered an error event",
+            u
+          ), d(u);
+        }, s.postMessage({ __start__: !0 }, [n]);
+      });
+    } catch {
+      const k = await Promise.all(
+        l.map((s) => r.memoryWorkerProxy.get(s))
+      ), d = (s) => s.flat();
+      i = (e.reducer ?? d)(k);
+    }
+  } else if (f) {
+    const n = await Promise.all(
+      l.map((d) => r.memoryWorkerProxy.get(d))
+    ), c = (d) => d.flat();
+    i = (e.reducer ?? c)(n);
+  } else {
+    const n = a.map((d) => d.value.successResult.data), c = (d) => d.flat();
+    i = (e.reducer ?? c)(n);
+  }
+  return {
+    data: i,
+    succeeded: a.length,
+    failed: t.length,
+    errors: t
+  };
+}
+async function X(o, e, r) {
+  var v, S;
+  if (r.isTerminated())
+    return r.logger.error(
+      "Attempted to execute worker after MainWorkerFactory was terminated"
+    ), Promise.reject(new Error("MainWorkerFactory has been terminated"));
+  const a = r.findWorkerByName(o);
+  if (!a)
+    return r.logger.error(`Worker config not found for worker: "${o}"`), Promise.reject(new Error(`Worker "${o}" not found`));
+  const {
+    srcData: t,
+    reducer: l,
+    autoCollect: f = !0,
+    ...m
+  } = e || {};
+  let i = t;
+  const n = m.__memory_ref__, c = !!m.deleteMemory;
+  if (i === void 0 && n) {
+    if (!r.memoryStore.has(n))
+      return r.logger.error(
+        `Attempted to use invalid memory reference: "${n}"`
+      ), Promise.reject(
+        new Error(`Memory reference "${n}" not found in MemoryStore`)
+      );
+    i = await r.memoryWorkerProxy.get(n), delete m.__memory_ref__, delete m.deleteMemory;
+  } else
+    delete m.deleteMemory;
+  const k = a.maxConcurrency ?? r.threads, d = !!(Array.isArray(i) && a.partition), p = d ? B(i, k) : i, s = d && Array.isArray(p) ? p.length : k, u = r.orchestrator.createWorkerPromises(
+    a,
+    o,
+    { data: p, ...m },
+    s,
+    d
+  ), h = await Promise.allSettled(u);
+  c && n && (await r.memoryWorkerProxy.delete(n), r.memoryStore.delete(n));
+  for (const g of h)
+    if (g.status === "fulfilled") {
+      const W = (v = g.value.successResult) == null ? void 0 : v.data, w = W == null ? void 0 : W.__memory_ref__;
+      w && r.memoryStore.register(w);
+    }
+  const _ = new V(h);
+  if (!f) {
+    const g = h.filter((w) => w.status === "fulfilled").length, W = h.filter(
+      (w) => w.status === "rejected"
     );
-    if (t.length === 0) return;
-    const i = t.map(
-      (s) => s.value.successResult.data
-    ), f = a && i.every(Array.isArray) ? i.flat() : i.length === 1 ? i[0] : i, d = this._memoryStore.set(f);
-    for (const s of t) {
-      const o = r ? { __memory_ref__: d } : { data: s.value.successResult.data, __memory_ref__: d };
-      s.value.successResult = new MessageEvent("message", {
-        data: o
+    return {
+      data: _,
+      succeeded: g,
+      failed: W.length,
+      errors: W
+    };
+  }
+  const T = await x(
+    _,
+    { reducer: l },
+    {
+      isTerminated: () => r.isTerminated(),
+      trackWorker: r.orchestrator.context ? (g) => g : (g) => g,
+      terminateWorker: (g) => {
+      },
+      logger: r.logger,
+      memoryWorkerProxy: r.memoryWorkerProxy,
+      factoryToken: r.factoryToken
+    }
+  ), M = !!(a.memory || a.memoryOnly);
+  for (const g of h)
+    if (g.status === "fulfilled") {
+      const W = (S = g.value.successResult) == null ? void 0 : S.data, w = W == null ? void 0 : W.__memory_ref__;
+      w && (r.memoryStore.delete(w), await r.memoryWorkerProxy.delete(w));
+    }
+  if (M) {
+    const g = await r.memoryWorkerProxy.set(T.data);
+    return r.memoryStore.register(g), { ...T, __memory_ref__: g };
+  }
+  return T;
+}
+async function Q(o, e) {
+  if (e.isTerminated())
+    throw e.logger.error(
+      "Attempted to execute pipeline after MainWorkerFactory was terminated"
+    ), new Error("MainWorkerFactory has been terminated");
+  if (o.length === 0)
+    throw e.logger.error("Attempted to execute an empty pipeline"), new Error("Pipeline requires at least one step");
+  if (o.length === 1) {
+    const r = o[0], { worker: a, srcData: t, ...l } = r, f = e.findWorkerByName(r.worker);
+    if (!f)
+      throw e.logger.error(
+        `Pipeline step config not found for worker: "${r.worker}"`
+      ), new Error(`Worker "${r.worker}" not found`);
+    const m = new b(f.func, {
+      createWorker: f.createWorker
+    });
+    e.trackWorker(m.getWorker);
+    const i = m.getWorker;
+    return new Promise((n, c) => {
+      i.onmessage = (p) => {
+        var s, u;
+        e.terminateWorker(i), ((s = p.data) == null ? void 0 : s.ok) === !1 ? (e.logger.error(
+          `Pipeline step ${r.worker} failed`,
+          p.data.error
+        ), c(new Error(p.data.error))) : n({
+          data: (u = p.data) == null ? void 0 : u.data,
+          succeeded: 1,
+          failed: 0,
+          errors: []
+        });
+      }, i.onerror = (p) => {
+        e.terminateWorker(i), e.logger.error(
+          `Pipeline step ${r.worker} encountered an error event`,
+          p
+        ), c(p);
+      };
+      const d = { data: t ?? {}, ...l, index: 0 };
+      e.logger.verbose(
+        `Starting single-step pipeline for worker ${r.worker}`
+      ), i.postMessage(d, E(d));
+    });
+  }
+  return new Promise(async (r, a) => {
+    const t = [], l = [];
+    for (const s of o) {
+      const u = e.findWorkerByName(s.worker);
+      if (!u) {
+        e.logger.error(
+          `Pipeline step config not found for worker: "${s.worker}"`
+        ), a(new Error(`Worker "${s.worker}" not found`));
+        return;
+      }
+      const h = new b(u.func, {
+        mode: D.Pipeline,
+        createWorker: u.createWorker
+      }), _ = e.trackWorker(h.getWorker);
+      t.push(_);
+    }
+    for (let s = 0; s < t.length - 1; s++)
+      l.push(new MessageChannel());
+    for (let s = 0; s < t.length; s++) {
+      const {
+        worker: u,
+        srcData: h,
+        ..._
+      } = o[s], T = [], M = {};
+      if (s > 0 && (M.inputPort = l[s - 1].port1, T.push(M.inputPort)), s < t.length - 1 && (M.outputPort = l[s].port2, T.push(M.outputPort)), t[s].postMessage(
+        { __pipeline_ports__: !0, stepParams: _, ...M },
+        T
+      ), s < t.length - 1) {
+        const v = t[s], S = t[s + 1], {
+          worker: g,
+          srcData: W,
+          ...w
+        } = o[s + 1];
+        v.onmessage = (P) => {
+          var I, F;
+          if (P.data && P.data.__pipeline_ports__) return;
+          if (((I = P.data) == null ? void 0 : I.ok) === !1) {
+            e.logger.error(
+              `Pipeline step ${o[s].worker} failed`,
+              P.data.error
+            ), t.forEach((L) => e.terminateWorker(L)), a(new Error(P.data.error));
+            return;
+          }
+          const $ = { data: ((F = P.data) == null ? void 0 : F.ok) !== void 0 ? P.data.data : P.data, ...w, index: 0 };
+          S.postMessage($, E($));
+        }, v.onerror = (P) => {
+          e.logger.error(
+            `Pipeline step ${o[s].worker} encountered an error event`,
+            P
+          ), t.forEach((A) => e.terminateWorker(A)), a(P);
+        };
+      }
+    }
+    const f = t[t.length - 1];
+    f.onmessage = (s) => {
+      var u, h;
+      t.forEach((_) => e.terminateWorker(_)), ((u = s.data) == null ? void 0 : u.ok) === !1 ? (e.logger.error("Final pipeline step failed", s.data.error), a(new Error(s.data.error))) : r({
+        data: (h = s.data) == null ? void 0 : h.data,
+        succeeded: 1,
+        failed: 0,
+        errors: []
       });
+    }, f.onerror = (s) => {
+      t.forEach((u) => e.terminateWorker(u)), e.logger.error(
+        "Final pipeline step encountered an error event",
+        s
+      ), a(s);
+    };
+    const {
+      worker: m,
+      srcData: i,
+      ...n
+    } = o[0];
+    let c = i;
+    const k = n.__memory_ref__, d = !!n.deleteMemory;
+    if (c === void 0 && k) {
+      if (!e.memoryStore.has(k)) {
+        t.forEach((s) => e.terminateWorker(s)), e.logger.error(
+          `Memory reference "${k}" not found in MemoryStore`
+        ), a(
+          new Error(`Memory reference "${k}" not found in MemoryStore`)
+        );
+        return;
+      }
+      c = await e.memoryWorkerProxy.get(k), d && (e.memoryStore.delete(k), await e.memoryWorkerProxy.delete(k)), delete n.__memory_ref__, delete n.deleteMemory;
     }
+    c === void 0 && (c = {});
+    const p = {
+      data: c,
+      ...n,
+      index: 0
+    };
+    e.logger.verbose(`Starting full pipeline with ${o.length} steps`), t[0].postMessage(p, E(p));
+  });
+}
+class Y {
+  constructor(e) {
+    y(this, "_persistentWorkers", /* @__PURE__ */ new Map());
+    this.context = e;
   }
-  /**
-   * Returns statistics about active memory references in the factory.
-   */
-  async getMemoryStats() {
-    return this._memoryStore.stats();
+  async runPersistent(e, r) {
+    if (this.context.isTerminated())
+      throw this.context.logger.error(
+        "Attempted to run persistent worker after MainWorkerFactory was terminated"
+      ), new Error("MainWorkerFactory has been terminated");
+    const a = this.context.findWorkerByName(e);
+    if (!a)
+      throw this.context.logger.error(
+        `Persistent worker config not found for worker: "${e}"`
+      ), new Error(`Worker "${e}" not found`);
+    let t = this._persistentWorkers.get(e);
+    if (!t) {
+      const l = new b(a.func, {
+        mode: D.Persistent,
+        createWorker: a.createWorker
+      });
+      t = this.context.trackWorker(l.getWorker), this.context.logger.verbose(
+        `Created persistent worker for ${e}`
+      ), this._persistentWorkers.set(e, t);
+    }
+    return new Promise((l, f) => {
+      t.onmessage = (i) => {
+        var n, c;
+        ((n = i.data) == null ? void 0 : n.ok) === !1 ? (this.context.logger.error(
+          `Persistent worker ${e} failed`,
+          i.data.error
+        ), f(new Error(i.data.error))) : l((c = i.data) == null ? void 0 : c.data);
+      }, t.onerror = (i) => {
+        this.context.logger.error(
+          `Persistent worker ${e} encountered an error event`,
+          i
+        ), f(i);
+      };
+      const m = {
+        type: "run",
+        config: r.config
+      };
+      r.dataset !== void 0 && (m.dataset = r.dataset), t.postMessage(m, E(m));
+    });
   }
-  /**
-   * Builds the array of per-thread worker promises for a single `runWorker`
-   * call.
-   *
-   * When `isPartitioned` is `true`, each promise receives its own slice of
-   * `srcData`; otherwise every thread receives the full payload.
-   *
-   * @param config         - The resolved {@link WorkerConfig} for this run.
-   * @param workerName     - Name used in error/retry logging.
-   * @param srcWorkerData  - Combined `{ data, ...otherParams }` payload.
-   * @param threadCount    - Number of parallel worker threads to spawn.
-   * @param isPartitioned  - Whether `data` is a pre-split array of shards.
-   * @returns An array of promises, one per thread.
-   */
-  createWorkerPromises(e, r, a, t, i) {
-    const { data: f, ...d } = a;
-    return Array.from({ length: t }, (s, o) => {
-      const u = i && Array.isArray(f) ? f[o] : f;
+  release(e) {
+    const r = this._persistentWorkers.get(e);
+    if (r) {
+      try {
+        r.postMessage({ type: "release" });
+      } catch {
+      }
+      this.context.terminateWorker(r), this._persistentWorkers.delete(e);
+    }
+  }
+  terminateAll() {
+    for (const e of this._persistentWorkers.values()) {
+      try {
+        e.postMessage({ type: "release" });
+      } catch {
+      }
+      this.context.terminateWorker(e);
+    }
+    this._persistentWorkers.clear();
+  }
+}
+class Z {
+  constructor(e) {
+    this.context = e;
+  }
+  createWorkerPromises(e, r, a, t, l) {
+    const { data: f, ...m } = a;
+    return Array.from({ length: t }, (i, n) => {
+      const c = l && Array.isArray(f) ? f[n] : f;
       return this.runWorkerWithRetry(
         {
           workerFunc: e.func,
           createWorker: e.createWorker,
           workerName: r,
-          index: o,
-          data: { data: u, ...d }
+          index: n,
+          data: { data: c, ...m }
         },
         e.retries
       );
     });
   }
-  /**
-   * Runs a single worker instance, retrying on failure up to `retryCount`
-   * times before re-throwing the last error.
-   *
-   * Each retry is logged to `console.error` with the remaining attempt count
-   * so failures are visible during development.
-   *
-   * @param instanceConfig - Full configuration for the worker instance.
-   * @param retryCount     - Remaining retry attempts (default `2`).
-   * @returns The successful {@link WorkerResult} once the worker resolves.
-   * @throws The last caught error when all retries are exhausted.
-   */
   async runWorkerWithRetry(e, r = 2) {
     try {
       return await this.initiateWorker(e);
     } catch (a) {
       if (r > 0)
-        return console.error(
+        return this.context.logger.info(
           `Worker ${e.index} failed, retrying (${r} left):`,
           a
         ), this.runWorkerWithRetry(e, r - 1);
-      throw console.error("Worker failed after all retries:", a), a;
+      throw this.context.logger.error("Worker failed after all retries:", a), a;
     }
   }
-  /**
-   * Spawns a single worker thread, posts the payload, and resolves or rejects
-   * based on the message the worker sends back.
-   *
-   * The worker is expected to respond with either:
-   * - `{ ok: true, data: T }` — success; resolves with a {@link WorkerResult}.
-   * - `{ ok: false, error: string }` — logical failure; rejects with a
-   *   structured error object.
-   *
-   * Any transferable objects found in the payload are moved (not copied) to
-   * the worker via the `transfer` list of `postMessage`.
-   *
-   * The underlying `Worker` is always terminated after the message completes.
-   *
-   * @param instanceConfig - Worker function, factory, name, shard index, and data.
-   * @returns A promise that resolves with the worker's result.
-   */
-  initiateWorker({
+  async initiateWorker({
     workerFunc: e,
     createWorker: r,
     workerName: a,
     index: t,
-    data: i
+    data: l
   }) {
-    return new Promise((f, d) => {
-      const o = this.initWorker({
-        name: a,
-        role: "",
-        func: e,
-        createWorker: r
-      }).getWorker;
-      o.onerror = (m) => {
-        this.terminateWorker(o), d({
+    const f = await this.context.memoryWorkerProxy.allocateWorkerPort();
+    return new Promise((m, i) => {
+      if (this.context.isTerminated()) {
+        i(new Error("MainWorkerFactory has been terminated"));
+        return;
+      }
+      const n = new b(e, {
+        createWorker: r,
+        mode: D.Memory
+      }), c = this.context.trackWorker(n.getWorker);
+      c.onerror = (d) => {
+        this.context.terminateWorker(c), i({
           index: t,
           workerConfigs: {
             workerFunc: e,
             createWorker: r,
             workerName: a,
             index: t,
-            data: i
+            data: l
           },
-          failedResult: m
+          failedResult: d
         });
-      }, o.onmessage = (m) => {
-        var c, n;
-        if (((c = m.data) == null ? void 0 : c.ok) === !1) {
-          this.terminateWorker(o), d({
+      }, c.onmessage = (d) => {
+        var u, h, _;
+        if (((u = d.data) == null ? void 0 : u.ok) === !1) {
+          this.context.terminateWorker(c), i({
             index: t,
             workerConfigs: {
               workerFunc: e,
               createWorker: r,
               workerName: a,
               index: t,
-              data: i
+              data: l
             },
             failedResult: new ErrorEvent("error", {
-              message: m.data.error
+              message: d.data.error
             })
           });
           return;
         }
-        const p = ((n = m.data) == null ? void 0 : n.ok) !== void 0 ? m.data.data : m.data;
-        f({
+        const p = (h = d.data) == null ? void 0 : h.__memory_ref__, s = p !== void 0 ? { __memory_ref__: p } : ((_ = d.data) == null ? void 0 : _.ok) !== void 0 ? d.data.data : d.data;
+        m({
           index: t,
           workerConfigs: {
             workerFunc: e,
             createWorker: r,
             workerName: a,
             index: t,
-            data: i
+            data: l
           },
           successResult: new MessageEvent("message", {
-            data: p
+            data: s
           })
-        }), this.terminateWorker(o);
+        }), this.context.terminateWorker(c);
       };
-      const u = {
+      const k = {
         index: t,
-        ...Array.isArray(i) ? { data: i } : i
+        ...Array.isArray(l) ? { data: l } : l
       };
-      o.postMessage(u, w(u));
+      c.postMessage(
+        {
+          __init_memory_port__: !0,
+          factoryToken: this.context.factoryToken
+        },
+        [f]
+      ), c.postMessage(k, E(k));
     });
   }
+}
+class te {
   /**
-   * Collects and merges the settled results from {@link runWorker} — off the
-   * main thread.
-   *
-   * Fulfilled shards are extracted and passed to the `reducer` function, which
-   * runs inside a dedicated inline worker so the merge itself never blocks the
-   * main thread. Failed shards are counted and their raw rejection reasons are
-   * preserved in `errors`.
-   *
-   * @typeParam T - The per-shard data type (inferred from `settled`).
-   * @typeParam R - The final merged output type (defaults to a flat array of
-   *   `T` items when no custom reducer is provided).
+   * Initializes a new MainWorkerFactory.
    *
-   * @param settled  - The {@link TypedSettledResults} returned by `runWorker`.
-   * @param options  - Optional {@link CollectOptions}. Supply a `reducer` to
-   *   control how shards are merged. The reducer **must be self-contained**
-   *   (no closures over external variables) because it is serialised and run
-   *   inside a worker.
-   *
-   * @returns A {@link CollectedResult} with the merged `data`, counts of
-   *   `succeeded`/`failed` shards, and the raw `errors` array.
-   *
-   * @example
-   * // default: flat array of all shard data
-   * const { data, succeeded, failed } = await foreman.collectResults(res);
-   *
-   * @example
-   * // custom reducer: sum numbers across shards
-   * const { data } = await foreman.collectResults<number[], number>(res, {
-   *   reducer: (shards) => shards.flat().reduce((a, b) => a + b, 0),
-   * });
+   * @param options - Configuration options.
+   * @param options.workers - The list of worker configurations.
+   * @param options.logLevel - Optional logging level (defaults to 'error').
    */
-  async collectResults(e, r = {}) {
+  constructor(e) {
+    y(this, "_workers");
+    y(this, "_threads");
+    y(this, "_activeWorkers", /* @__PURE__ */ new Set());
+    y(this, "_memoryStore", new z());
+    y(this, "_memoryWorkerProxy");
+    y(this, "_factoryToken");
+    y(this, "_isTerminated", !1);
+    y(this, "_persistentManager");
+    y(this, "_orchestrator");
+    /**
+     * The logger instance used by this factory.
+     */
+    y(this, "logger");
+    this._workers = e.workers, this.logger = new J(e.logLevel ?? "error"), this._threads = typeof navigator < "u" && navigator.hardwareConcurrency ? navigator.hardwareConcurrency : 4, this._factoryToken = crypto.randomUUID(), this._memoryWorkerProxy = new H(this._factoryToken);
+    const r = {
+      isTerminated: () => this.isTerminated,
+      findWorkerByName: this.findWorkerByName.bind(this),
+      trackWorker: this.trackWorker.bind(this),
+      terminateWorker: this.terminateWorker.bind(this),
+      logger: this.logger,
+      memoryWorkerProxy: this._memoryWorkerProxy,
+      factoryToken: this._factoryToken
+    };
+    this._persistentManager = new Y(r), this._orchestrator = new Z(r);
+  }
+  /**
+   * Indicates whether the factory has been terminated.
+   */
+  get isTerminated() {
+    return this._isTerminated;
+  }
+  trackWorker(e) {
     if (this._isTerminated)
-      throw new Error("MainWorkerFactory has been terminated");
-    const a = e.results.filter(
-      (p) => p.status === "fulfilled"
-    ), t = e.results.filter(
-      (p) => p.status === "rejected"
-    );
-    if (a.length > 0 && a.every((p) => {
-      var n;
-      const c = (n = p.value.successResult) == null ? void 0 : n.data;
-      return c && typeof c == "object" && "__memory_ref__" in c && !("data" in c);
-    }))
-      return {
-        data: a[0].value.successResult.data,
-        succeeded: a.length,
-        failed: t.length,
-        errors: t
-      };
-    const f = a.length > 0 && a.every((p) => {
-      var n;
-      const c = (n = p.value.successResult) == null ? void 0 : n.data;
-      return c && typeof c == "object" && "__memory_ref__" in c && "data" in c;
-    }), d = f ? a[0].value.successResult.data.__memory_ref__ : void 0, s = a.map((p) => {
-      const c = p.value.successResult.data;
-      return f && c && typeof c == "object" && "data" in c ? c.data : c;
-    }), o = r.reducer ? r.reducer.toString() : "(shards) => shards.flat()";
-    let u;
-    if (typeof Worker < "u" && typeof Blob < "u" && typeof URL < "u" && typeof URL.createObjectURL == "function")
-      try {
-        u = await new Promise((p, c) => {
-          const n = `
-            const reducer = ${o};
-            self.addEventListener('message', (event) => {
-              try {
-                const result = reducer(event.data);
-                self.postMessage({ ok: true, data: result });
-              } catch (error) {
-                self.postMessage({ ok: false, error: String(error) });
-              }
-            });
-          `, h = new Blob([n], {
-            type: "application/javascript"
-          }), y = this.trackWorker(
-            new Worker(URL.createObjectURL(h))
-          );
-          y.onmessage = (k) => {
-            this.terminateWorker(y), k.data.ok ? p(k.data.data) : c(new Error(k.data.error));
-          }, y.onerror = (k) => {
-            this.terminateWorker(y), c(k);
-          }, y.postMessage(s);
-        });
-      } catch {
-        const p = (n) => n.flat();
-        u = (r.reducer ?? p)(s);
-      }
-    else {
-      const p = (n) => n.flat();
-      u = (r.reducer ?? p)(s);
+      throw e.terminate(), new Error("MainWorkerFactory has been terminated");
+    return this._activeWorkers.add(e), e;
+  }
+  terminateWorker(e) {
+    this._activeWorkers.delete(e);
+    try {
+      e.terminate();
+    } catch {
     }
-    return {
-      data: f ? { data: u, __memory_ref__: d } : u,
-      succeeded: a.length,
-      failed: t.length,
-      errors: t
-    };
   }
   /**
-   * Runs a chain of workers where each step's output feeds directly into the
-   * next step — **without passing through the main thread**.
-   *
-   * Internally, adjacent workers are connected via `MessageChannel` ports.
-   * Only the final result is sent back to the main thread, minimising
-   * serialisation overhead for large intermediate data.
+   * Helper utility to partition an array into a specified number of chunks.
    *
-   * @typeParam TResult - The expected type of the final pipeline output.
-   *   Defaults to `unknown` if not specified.
+   * @param array - The array to partition.
+   * @param numChunks - The desired number of chunks.
+   * @returns An array of array chunks.
+   * @template T - The type of elements in the array.
+   */
+  partitionArray(e, r) {
+    return B(e, r);
+  }
+  findWorkerByName(e) {
+    return this._workers.find((r) => r.name === e);
+  }
+  /**
+   * Dispatches a worker task with the given parameters.
    *
-   * @param steps - An ordered array of {@link PipelineStep} objects. The first
-   *   step must include `srcData`; subsequent steps receive the previous
-   *   step's output as `{ data: previousOutput, index: 0 }`.
+   * Workers store their results directly in the `MemoryWorker` thread — large data
+   * never touches the main thread heap. Results are auto-collected and merged in a
+   * dedicated reducer worker. Returns a `CollectedResult<R>` directly.
    *
-   * @returns A promise that resolves with the final step's output.
-   * @throws {Error} When `steps` is empty or a worker name is not found.
+   * Pass `autoCollect: false` in `rawParams` to skip auto-collection and receive
+   * the raw settled state (escape hatch for advanced custom reducers).
    *
-   * @example
-   * const result = await foreman.pipeline<FilteredPost[]>([
-   *   { worker: 'fetchPosts', srcData: { url: '/api/posts' } },
-   *   { worker: 'transformPosts' },
-   *   { worker: 'filterPosts' },
-   * ]);
-   * console.log(result); // final transformed + filtered data
+   * @param workerName - The name of the registered worker to execute.
+   * @param rawParams - The payload, options, and reducer for the worker.
+   * @returns A promise resolving to a CollectedResult with merged data and shard stats.
+   * @template TName - The name of the registered worker.
+   * @template T - The return type of the worker function.
+   * @template R - The merged return type after reducing shards.
    */
-  async pipeline(e) {
-    if (this._isTerminated)
-      throw new Error("MainWorkerFactory has been terminated");
-    if (e.length === 0)
-      throw new Error("Pipeline requires at least one step");
-    if (e.length === 1) {
-      const r = e[0], { worker: a, srcData: t, ...i } = r, f = this.findWorkerByName(r.worker);
-      if (!f) throw new Error(`Worker "${r.worker}" not found`);
-      const s = this.initWorker(f).getWorker;
-      return new Promise((o, u) => {
-        s.onmessage = (c) => {
-          var n, h;
-          this.terminateWorker(s), ((n = c.data) == null ? void 0 : n.ok) === !1 ? u(new Error(c.data.error)) : o((h = c.data) == null ? void 0 : h.data);
-        }, s.onerror = (c) => {
-          this.terminateWorker(s), u(c);
-        };
-        const p = { data: t ?? {}, ...i, index: 0 };
-        s.postMessage(p, w(p));
-      });
-    }
-    return new Promise((r, a) => {
-      const t = [], i = [];
-      for (const n of e) {
-        const h = this.findWorkerByName(n.worker);
-        if (!h) {
-          a(new Error(`Worker "${n.worker}" not found`));
-          return;
-        }
-        const y = new M(h.func, {
-          mode: P.Pipeline,
-          createWorker: h.createWorker
-        }), k = this.trackWorker(y.getWorker);
-        t.push(k);
-      }
-      for (let n = 0; n < t.length - 1; n++)
-        i.push(new MessageChannel());
-      for (let n = 0; n < t.length; n++) {
-        const {
-          worker: h,
-          srcData: y,
-          ...k
-        } = e[n], v = [], W = {};
-        if (n > 0 && (W.inputPort = i[n - 1].port1, v.push(W.inputPort)), n < t.length - 1 && (W.outputPort = i[n].port2, v.push(W.outputPort)), t[n].postMessage(
-          { __pipeline_ports__: !0, stepParams: k, ...W },
-          v
-        ), n < t.length - 1) {
-          const b = t[n], A = t[n + 1], {
-            worker: U,
-            srcData: z,
-            ...T
-          } = e[n + 1];
-          b.onmessage = (g) => {
-            var S, R;
-            if (g.data && g.data.__pipeline_ports__) return;
-            if (((S = g.data) == null ? void 0 : S.ok) === !1) {
-              t.forEach((B) => this.terminateWorker(B)), a(new Error(g.data.error));
-              return;
-            }
-            const E = { data: ((R = g.data) == null ? void 0 : R.ok) !== void 0 ? g.data.data : g.data, ...T, index: 0 };
-            A.postMessage(E, w(E));
-          }, b.onerror = (g) => {
-            t.forEach((D) => this.terminateWorker(D)), a(g);
-          };
-        }
-      }
-      const f = t[t.length - 1];
-      f.onmessage = (n) => {
-        var h, y;
-        t.forEach((k) => this.terminateWorker(k)), ((h = n.data) == null ? void 0 : h.ok) === !1 ? a(new Error(n.data.error)) : r((y = n.data) == null ? void 0 : y.data);
-      }, f.onerror = (n) => {
-        t.forEach((h) => this.terminateWorker(h)), a(n);
-      };
-      const {
-        worker: d,
-        srcData: s,
-        ...o
-      } = e[0];
-      let u = s;
-      const m = o.__memory_ref__, p = !!o.deleteMemory;
-      if (u === void 0 && m) {
-        if (!this._memoryStore.has(m)) {
-          t.forEach((n) => this.terminateWorker(n)), a(
-            new Error(
-              `Memory reference "${m}" not found in MemoryStore`
-            )
-          );
-          return;
-        }
-        u = this._memoryStore.get(m), p && this._memoryStore.delete(m), delete o.__memory_ref__, delete o.deleteMemory;
-      }
-      u === void 0 && (u = {});
-      const c = {
-        data: u,
-        ...o,
-        index: 0
-      };
-      t[0].postMessage(c, w(c));
+  async runWorker(e, r) {
+    return X(e, r, {
+      isTerminated: () => this.isTerminated,
+      findWorkerByName: this.findWorkerByName.bind(this),
+      memoryStore: this._memoryStore,
+      memoryWorkerProxy: this._memoryWorkerProxy,
+      factoryToken: this._factoryToken,
+      threads: this._threads,
+      orchestrator: this._orchestrator,
+      logger: this.logger
     });
   }
   /**
-   * Runs a persistent worker that caches its dataset between calls.
+   * Deletes a specific reference from the memory store and MemoryWorker.
    *
-   * On the first call, provide both `dataset` and `config`. The worker stores
-   * the dataset in memory. On subsequent calls, only `config` is needed — the
-   * worker reuses the cached dataset and reprocesses it with the new config.
-   *
-   * The worker stays alive until {@link release} is called.
-   *
-   * @param workerName - Name of the registered worker.
-   * @param params - Object with optional `dataset` and required `config`.
-   * @returns The worker function's return value.
+   * @param ref - The memory reference ID to delete.
+   * @returns True if the reference existed and was deleted, false otherwise.
+   */
+  async deleteMemory(e) {
+    return this._memoryStore.delete(e), this._memoryWorkerProxy.delete(e);
+  }
+  /**
+   * Clears all references from the memory store and MemoryWorker.
+   */
+  async clearMemory() {
+    this._memoryStore.clear(), await this._memoryWorkerProxy.clear();
+  }
+  /**
+   * Retrieves statistics about the currently stored memory handles.
    *
-   * @example
-   * // First call: send dataset + config
-   * const r1 = await factory.runPersistent('transform', {
-   *   dataset: largeArray,
-   *   config: { multiplier: 2 },
-   * });
+   * @returns The MemoryStats containing count and active reference IDs.
+   */
+  async getMemoryStats() {
+    return this._memoryWorkerProxy.stats();
+  }
+  /**
+   * Collects and reduces the results from a `runWorker` execution.
    *
-   * // Subsequent calls: only config, dataset is cached
-   * const r2 = await factory.runPersistent('transform', {
-   *   config: { multiplier: 5 },
-   * });
+   * @deprecated `runWorker` now auto-collects results. This method is kept as
+   * an escape hatch for advanced cases where `autoCollect: false` was passed to
+   * `runWorker`. In the common case, the return value of `runWorker` already
+   * contains the merged `CollectedResult`.
    *
-   * // Update dataset when needed
-   * const r3 = await factory.runPersistent('transform', {
-   *   dataset: newArray,
-   *   config: { multiplier: 3 },
-   * });
+   * @param settled - The settled results from `runWorker` (when `autoCollect: false`).
+   * @param options - Options containing the reducer function.
+   * @returns A structured CollectedResult object.
+   * @template T - The type of the worker result data.
+   * @template R - The type of the merged result data.
+   */
+  async collectResults(e, r = {}) {
+    return x(e, r, {
+      isTerminated: () => this.isTerminated,
+      trackWorker: this.trackWorker.bind(this),
+      terminateWorker: this.terminateWorker.bind(this),
+      logger: this.logger,
+      memoryWorkerProxy: this._memoryWorkerProxy,
+      factoryToken: this._factoryToken
+    });
+  }
+  /**
+   * Executes a sequential pipeline of worker steps.
+   * Passes the output of one step as the input to the next step.
    *
-   * // Release when done
-   * factory.release('transform');
+   * @param steps - An array of PipelineStep configurations.
+   * @returns A CollectedResult containing the final pipeline output and shard stats,
+   *          consistent with the shape returned by `runWorker()`.
+   * @template TResult - The type of the pipeline result.
    */
-  async runPersistent(e, r) {
-    if (this._isTerminated)
-      throw new Error("MainWorkerFactory has been terminated");
-    const a = this.findWorkerByName(e);
-    if (!a) throw new Error(`Worker "${e}" not found`);
-    let t = this._persistentWorkers.get(e);
-    if (!t) {
-      const i = new M(a.func, {
-        mode: P.Persistent,
-        createWorker: a.createWorker
-      });
-      t = this.trackWorker(i.getWorker), this._persistentWorkers.set(e, t);
-    }
-    return new Promise((i, f) => {
-      t.onmessage = (s) => {
-        var o, u;
-        ((o = s.data) == null ? void 0 : o.ok) === !1 ? f(new Error(s.data.error)) : i((u = s.data) == null ? void 0 : u.data);
-      }, t.onerror = (s) => {
-        f(s);
-      };
-      const d = {
-        type: "run",
-        config: r.config
-      };
-      r.dataset !== void 0 && (d.dataset = r.dataset), t.postMessage(d, w(d));
+  async pipeline(e) {
+    return Q(e, {
+      memoryStore: this._memoryStore,
+      memoryWorkerProxy: this._memoryWorkerProxy,
+      isTerminated: () => this.isTerminated,
+      findWorkerByName: this.findWorkerByName.bind(this),
+      trackWorker: this.trackWorker.bind(this),
+      terminateWorker: this.terminateWorker.bind(this),
+      logger: this.logger
     });
   }
   /**
-   * Releases a persistent worker, freeing its cached dataset and terminating
-   * the thread.
+   * Executes a task on a persistent (long-lived) worker thread.
+   * Useful for workers that maintain local state (like WebAssembly modules or databases)
+   * across multiple invocations.
    *
-   * After calling `release`, subsequent `runPersistent` calls for this worker
-   * will create a fresh instance (requiring a new dataset).
+   * @param workerName - The name of the persistent worker to run.
+   * @param params - The input data and configuration for the task.
+   * @returns The result from the persistent worker thread.
+   * @template TResult - The expected type of the result from the worker thread.
+   */
+  async runPersistent(e, r) {
+    return this._persistentManager.runPersistent(e, r);
+  }
+  /**
+   * Releases and terminates a persistent worker by name.
    *
-   * @param workerName - Name of the persistent worker to release.
+   * @param workerName - The name of the persistent worker to release.
    */
   release(e) {
-    const r = this._persistentWorkers.get(e);
-    if (r) {
-      try {
-        r.postMessage({ type: "release" });
-      } catch {
-      }
-      this.terminateWorker(r), this._persistentWorkers.delete(e);
-    }
+    this._persistentManager.release(e);
   }
   /**
-   * Terminates the factory and all active and persistent worker instances.
-   *
-   * Calling `terminate()` immediately stops all running worker threads, releases
-   * cached persistent workers, and clears all internal worker state.
+   * Terminates all active worker threads, persistent workers, MemoryWorker, and clears the memory store.
+   * Marks this factory instance as terminated.
    */
   terminate() {
-    this._isTerminated = !0;
-    for (const e of this._persistentWorkers.values()) {
-      try {
-        e.postMessage({ type: "release" });
-      } catch {
-      }
-      this.terminateWorker(e);
-    }
-    this._persistentWorkers.clear();
+    this._isTerminated = !0, this._persistentManager.terminateAll();
     for (const e of Array.from(this._activeWorkers))
       this.terminateWorker(e);
-    this._activeWorkers.clear(), this._memoryStore.clear();
+    this._activeWorkers.clear(), this._memoryStore.clear(), this._memoryWorkerProxy.terminate();
   }
   /**
-   * Alias for {@link terminate}. Terminates the factory and all worker instances.
+   * Alias for {@link terminate}. Terminates all active resources.
    */
   destroy() {
     this.terminate();
   }
   /**
-   * Resets the factory by terminating all active and persistent workers
-   * and resetting the factory state, allowing new worker instances to be initiated.
+   * Terminates all resources and resets the factory to an active state.
    */
   reset() {
     this.terminate(), this._isTerminated = !1;
   }
   /**
-   * Alias for {@link reset}. Resets the factory state to initiate new worker instances.
+   * Alias for {@link reset}. Terminates and reactivates the factory.
    */
   restart() {
     this.reset();
   }
 }
-function N(l) {
-  if (typeof self > "u") return;
-  let e = null, r = null, a = null, t = {};
-  const i = (d, s) => {
-    self.postMessage(d, s);
-  };
-  async function f(d) {
-    try {
-      const s = typeof d == "object" && d !== null && "data" in d ? { ...t, ...d } : { data: d, ...t, index: 0 }, o = await l(s), u = { ok: !0, data: o }, m = w(o);
-      e ? e.postMessage(u, m) : i(u, m);
-    } catch (s) {
-      const o = {
-        ok: !1,
-        error: s instanceof Error ? s.message : String(s)
-      };
-      e ? e.postMessage(o) : i(o);
-    }
-  }
-  self.addEventListener("message", (d) => {
-    const s = d.data;
-    if (s && s.__pipeline_ports__) {
-      s.stepParams && (t = s.stepParams), s.outputPort && (e = s.outputPort), s.inputPort && (r = s.inputPort, r.onmessage = (o) => {
-        var u;
-        o.data && o.data.ok === !1 ? e ? e.postMessage(o.data) : i(o.data) : f({ data: (u = o.data) == null ? void 0 : u.data, ...t, index: 0 });
-      }), a !== null && (f(a), a = null);
-      return;
-    }
-    r ? a = s : f(s);
-  });
+function oe(o) {
+  return o === void 0 ? (e) => e : o;
+}
+function ae(...o) {
+  return o;
 }
 export {
-  q as MainWorkerFactory,
-  M as WorkerFactory,
-  N as defineWorker
+  te as MainWorkerFactory,
+  b as WorkerFactory,
+  D as WorkerMode,
+  ie as defineWorker,
+  oe as defineWorkerConfig,
+  ae as defineWorkerConfigs
 };