@offmain/workerkit 0.14.0 → 1.0.0

package/dist/index.js

@@ -1,7 +1,9 @@
-var S = Object.defineProperty;
-var x = (n, e, r) => e in n ? S(n, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : n[e] = r;
-var y = (n, e, r) => x(n, typeof e != "symbol" ? e + "" : e, r);
-const O = (n) => `
+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 ${n}(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) });
   }
 })
-`, R = (n) => `
-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 = ${n};
+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;
   }
 });
-`, F = (n) => `
-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 = ${n};
+`, 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__ */ ((n) => (n.Default = "default", n.Pipeline = "pipeline", n.Persistent = "persistent", n))(P || {});
-const C = Object.freeze({
-  persistent: F,
-  pipeline: R,
-  default: O
+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 W {
+class b {
   /**
    * Creates a new `Worker` from the given function or factory option.
    *
@@ -181,7 +213,7 @@ class W {
     if (r != null && r.createWorker)
       this._worker = r.createWorker();
     else if (e) {
-      const s = (r == null ? void 0 : r.mode) ?? "default", t = C[s](e.toString()), l = 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(l));
@@ -200,592 +232,1018 @@ class W {
     return this._worker;
   }
 }
-class L {
-  constructor(e) {
-    this.results = e;
+class z {
+  constructor() {
+    y(this, "store", /* @__PURE__ */ new Map());
   }
-}
-function m(n, e = /* @__PURE__ */ new Set()) {
-  return n === null || typeof n != "object" ? [] : e.has(n) ? [] : (e.add(n), n instanceof ArrayBuffer || n instanceof MessagePort || typeof ImageBitmap < "u" && n instanceof ImageBitmap || typeof OffscreenCanvas < "u" && n instanceof OffscreenCanvas ? [n] : ArrayBuffer.isView(n) ? [n.buffer] : Array.isArray(n) ? n.flatMap((r) => m(r, e)) : Object.values(n).flatMap(
-    (r) => m(r, e)
-  ));
-}
-class U {
   /**
-   * Creates a new `MainWorkerFactory`.
+   * Registers a ref in the registry.
    *
-   * @param options - Configuration object containing the `workers` registry.
+   * @param ref - The memory reference ID (generated by MemoryWorkerProxy).
+   * @param metadata - Optional metadata (size hint, type tag, etc.).
    */
-  constructor(e) {
-    y(this, "_workers");
-    y(this, "_threads");
-    y(this, "_persistentWorkers", /* @__PURE__ */ new Map());
-    y(this, "_activeWorkers", /* @__PURE__ */ new Set());
-    y(this, "_isTerminated", !1);
-    this._workers = e.workers, this._threads = navigator.hardwareConcurrency;
+  register(e, r = {}) {
+    this.store.set(e, r);
   }
   /**
-   * Returns `true` if the factory has been terminated.
+   * Checks if a reference ID is registered.
+   * @param refId - The reference ID to check.
    */
-  get isTerminated() {
-    return this._isTerminated;
+  has(e) {
+    return this.store.has(e);
   }
   /**
-   * Registers an active worker instance for lifecycle tracking.
+   * Unregisters a reference ID.
+   *
+   * @param refId - The reference ID to unregister.
+   * @returns `true` if the key existed and was removed, `false` otherwise.
    */
-  trackWorker(e) {
-    if (this._isTerminated)
-      throw e.terminate(), new Error("MainWorkerFactory has been terminated");
-    return this._activeWorkers.add(e), e;
+  delete(e) {
+    return this.store.delete(e);
   }
   /**
-   * Terminates a worker instance and removes it from tracking.
+   * Clears all registered references.
    */
-  terminateWorker(e) {
-    this._activeWorkers.delete(e);
-    try {
-      e.terminate();
-    } catch {
-    }
+  clear() {
+    this.store.clear();
   }
   /**
-   * Instantiates a {@link WorkerFactory} for the given worker configuration.
-   *
-   * @param config - The worker configuration containing `func` or `createWorker`.
-   * @returns A new `WorkerFactory` wrapping the worker.
+   * Returns statistics about current registered handles.
    */
-  initWorker(e) {
-    const r = new W(e.func, {
-      createWorker: e.createWorker
+  stats() {
+    return {
+      count: this.store.size,
+      refs: Array.from(this.store.keys())
+    };
+  }
+}
+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,
+    });
+  }
+}
+
+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) {
+    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
+      });
     });
-    return this.trackWorker(r.getWorker), r;
   }
   /**
-   * 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.
+   * Stores a dataset in the MemoryWorker.
    *
-   * @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]]
+   * @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.
    */
-  partitionArray(e, r) {
-    if (!e.length) return [];
-    if (r <= 0) throw new Error("numChunks must be positive");
-    const s = Math.min(r, e.length), t = Math.floor(e.length / s), l = e.length % s, c = [];
-    let f = 0;
-    for (let a = 0; a < s; a++) {
-      const o = t + (a < l ? 1 : 0);
-      c.push(e.slice(f, f + o)), f += o;
-    }
-    return c;
+  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;
   }
   /**
-   * Looks up a registered worker configuration by name.
+   * Retrieves a dataset from the MemoryWorker by ref ID.
    *
-   * @param name - The `name` field of the target {@link WorkerConfig}.
-   * @returns The matching config, or `undefined` if not found.
+   * @param ref - The ref ID to retrieve.
+   * @returns The stored dataset, or `undefined` if not found.
    */
-  findWorkerByName(e) {
-    return this._workers.find((r) => r.name === e);
+  async get(e) {
+    const r = await this.send("GET", { ref: e });
+    if (!r.ok) throw new Error(r.error);
+    return r.data;
   }
   /**
-   * 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.
-   *
-   * @typeParam TName - The literal name of the worker to run (inferred from
-   *   the registered `workers` tuple).
-   *
-   * @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.
+   * Checks if a ref ID exists in the MemoryWorker.
+   * @param ref - The ref ID to check.
+   */
+  async has(e) {
+    const r = await this.send("GET", { ref: e });
+    if (!r.ok) throw new Error(r.error);
+    return !!r.exists;
+  }
+  /**
+   * Deletes a ref from the MemoryWorker.
    *
-   * @example
-   * const settled = await foreman.runWorker('sum', { srcData: [1, 2, 3] });
+   * @param ref - The ref ID to delete.
+   * @returns `true` if the ref existed and was deleted.
    */
-  async runWorker(e, {
-    srcData: r,
-    ...s
-  }) {
-    if (this._isTerminated)
-      return Promise.reject(new Error("MainWorkerFactory has been terminated"));
-    const t = this.findWorkerByName(e);
-    if (!t)
-      return Promise.reject(new Error(`Worker "${e}" not found`));
-    const l = t.maxConcurrency ?? this._threads, c = !!(Array.isArray(r) && r.length > 1 && t.partition), f = c ? this.partitionArray(r, l) : r, a = this.createWorkerPromises(
-      t,
-      e,
-      { data: f, ...s },
-      l,
-      c
-    ), o = await Promise.allSettled(a);
-    return new L(o);
+  async delete(e) {
+    const r = await this.send("DELETE", { ref: e });
+    if (!r.ok) throw new Error(r.error);
+    return !!r.deleted;
+  }
+  /**
+   * Clears all data from the MemoryWorker.
+   */
+  async clear() {
+    const e = await this.send("CLEAR");
+    if (!e.ok) throw new Error(e.error);
   }
   /**
-   * Builds the array of per-thread worker promises for a single `runWorker`
-   * call.
+   * Returns statistics about data held in the MemoryWorker.
+   */
+  async stats() {
+    const e = await this.send("STATS");
+    if (!e.ok) throw new Error(e.error);
+    return e.stats;
+  }
+  /**
+   * Allocates a direct `MessagePort` to the MemoryWorker for a computing or
+   * reducer worker.
    *
-   * When `isPartitioned` is `true`, each promise receives its own slice of
-   * `srcData`; otherwise every thread receives the full payload.
+   * 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 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.
+   * @returns The worker-side `MessagePort` ready to be transferred.
    */
-  createWorkerPromises(e, r, s, t, l) {
-    const { data: c, ...f } = s;
-    return Array.from({ length: t }, (a, o) => {
-      const d = l && Array.isArray(c) ? c[o] : 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;
+  }
+  /**
+   * Terminates the MemoryWorker thread and clears all pending requests.
+   */
+  terminate() {
+    this.pending.clear(), this.worker.terminate();
+  }
+}
+class J {
+  constructor(e = "error") {
+    y(this, "level");
+    this.level = e;
+  }
+  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"
+    );
+    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;
+  }
+  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));
+    });
+  }
+  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: d, ...f }
+          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 (s) {
+    } catch (a) {
       if (r > 0)
-        return console.error(
+        return this.context.logger.info(
           `Worker ${e.index} failed, retrying (${r} left):`,
-          s
+          a
         ), this.runWorkerWithRetry(e, r - 1);
-      throw console.error("Worker failed after all retries:", s), s;
+      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: s,
+    workerName: a,
     index: t,
     data: l
   }) {
-    return new Promise((c, f) => {
-      const o = this.initWorker({
-        name: s,
-        role: "",
-        func: e,
-        createWorker: r
-      }).getWorker;
-      o.onerror = (p) => {
-        this.terminateWorker(o), f({
+    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: s,
+            workerName: a,
             index: t,
             data: l
           },
-          failedResult: p
+          failedResult: d
         });
-      }, o.onmessage = (p) => {
-        var i, u;
-        if (((i = p.data) == null ? void 0 : i.ok) === !1) {
-          this.terminateWorker(o), f({
+      }, 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: s,
+              workerName: a,
               index: t,
               data: l
             },
             failedResult: new ErrorEvent("error", {
-              message: p.data.error
+              message: d.data.error
             })
           });
           return;
         }
-        c({
+        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: s,
+            workerName: a,
             index: t,
             data: l
           },
           successResult: new MessageEvent("message", {
-            data: (u = p.data) == null ? void 0 : u.data
+            data: s
           })
-        }), this.terminateWorker(o);
+        }), this.context.terminateWorker(c);
       };
-      const d = {
+      const k = {
         index: t,
         ...Array.isArray(l) ? { data: l } : l
       };
-      o.postMessage(d, m(d));
+      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).
-   *
-   * @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);
+   * Initializes a new MainWorkerFactory.
    *
-   * @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 = {}) {
-    if (this._isTerminated)
-      throw new Error("MainWorkerFactory has been terminated");
-    const s = e.results.filter(
-      (a) => a.status === "fulfilled"
-    ), t = e.results.filter(
-      (a) => a.status === "rejected"
-    ), l = s.map((a) => a.value.successResult.data), c = r.reducer ? r.reducer.toString() : "(shards) => shards.flat()";
-    return {
-      data: await new Promise((a, o) => {
-        const d = `
-        const reducer = ${c};
-        self.addEventListener('message', (event) => {
-          try {
-            const result = reducer(event.data);
-            self.postMessage({ ok: true, data: result });
-          } catch (err) {
-            self.postMessage({ ok: false, error: String(err) });
-          }
-        });
-      `, p = new Blob([d], { type: "application/javascript" }), i = this.trackWorker(new Worker(URL.createObjectURL(p)));
-        i.onmessage = (u) => {
-          this.terminateWorker(i), u.data.ok ? a(u.data.data) : o(new Error(u.data.error));
-        }, i.onerror = (u) => {
-          this.terminateWorker(i), o(u);
-        }, i.postMessage(l);
-      }),
-      succeeded: s.length,
-      failed: t.length,
-      errors: t
+  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);
   }
   /**
-   * 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.
+   * Indicates whether the factory has been terminated.
+   */
+  get isTerminated() {
+    return this._isTerminated;
+  }
+  trackWorker(e) {
+    if (this._isTerminated)
+      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 {
+    }
+  }
+  /**
+   * 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: s, srcData: t, ...l } = r, c = this.findWorkerByName(r.worker);
-      if (!c) throw new Error(`Worker "${r.worker}" not found`);
-      const a = this.initWorker(c).getWorker;
-      return new Promise((o, d) => {
-        a.onmessage = (u) => {
-          var k, g;
-          this.terminateWorker(a), ((k = u.data) == null ? void 0 : k.ok) === !1 ? d(new Error(u.data.error)) : o((g = u.data) == null ? void 0 : g.data);
-        }, a.onerror = (u) => {
-          this.terminateWorker(a), d(u);
-        };
-        const i = { data: t ?? {}, ...l, index: 0 };
-        a.postMessage(i, m(i));
-      });
-    }
-    return new Promise((r, s) => {
-      const t = [], l = [];
-      for (const i of e) {
-        const u = this.findWorkerByName(i.worker);
-        if (!u) {
-          s(new Error(`Worker "${i.worker}" not found`));
-          return;
-        }
-        const k = new W(u.func, {
-          mode: P.Pipeline,
-          createWorker: u.createWorker
-        }), g = this.trackWorker(k.getWorker);
-        t.push(g);
-      }
-      for (let i = 0; i < t.length - 1; i++)
-        l.push(new MessageChannel());
-      for (let i = 0; i < t.length; i++) {
-        const { worker: u, srcData: k, ...g } = e[i], v = [], w = {};
-        if (i > 0 && (w.inputPort = l[i - 1].port1, v.push(w.inputPort)), i < t.length - 1 && (w.outputPort = l[i].port2, v.push(w.outputPort)), t[i].postMessage(
-          { __pipeline_ports__: !0, stepParams: g, ...w },
-          v
-        ), i < t.length - 1) {
-          const _ = t[i], A = t[i + 1], { worker: j, srcData: $, ...D } = e[i + 1];
-          _.onmessage = (h) => {
-            var E, T;
-            if (h.data && h.data.__pipeline_ports__) return;
-            if (((E = h.data) == null ? void 0 : E.ok) === !1) {
-              t.forEach((B) => this.terminateWorker(B)), s(new Error(h.data.error));
-              return;
-            }
-            const b = { data: ((T = h.data) == null ? void 0 : T.ok) !== void 0 ? h.data.data : h.data, ...D, index: 0 };
-            A.postMessage(b, m(b));
-          }, _.onerror = (h) => {
-            t.forEach((M) => this.terminateWorker(M)), s(h);
-          };
-        }
-      }
-      const c = t[t.length - 1];
-      c.onmessage = (i) => {
-        var u, k;
-        t.forEach((g) => this.terminateWorker(g)), ((u = i.data) == null ? void 0 : u.ok) === !1 ? s(new Error(i.data.error)) : r((k = i.data) == null ? void 0 : k.data);
-      }, c.onerror = (i) => {
-        t.forEach((u) => this.terminateWorker(u)), s(i);
-      };
-      const { worker: f, srcData: a, ...o } = e[0], p = { data: a ?? {}, ...o, index: 0 };
-      t[0].postMessage(p, m(p));
+  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.
-   *
-   * 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.
+   * Deletes a specific reference from the memory store and MemoryWorker.
    *
-   * @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 s = this.findWorkerByName(e);
-    if (!s) throw new Error(`Worker "${e}" not found`);
-    let t = this._persistentWorkers.get(e);
-    if (!t) {
-      const l = new W(s.func, {
-        mode: P.Persistent,
-        createWorker: s.createWorker
-      });
-      t = this.trackWorker(l.getWorker), this._persistentWorkers.set(e, t);
-    }
-    return new Promise((l, c) => {
-      t.onmessage = (a) => {
-        var o, d;
-        ((o = a.data) == null ? void 0 : o.ok) === !1 ? c(new Error(a.data.error)) : l((d = a.data) == null ? void 0 : d.data);
-      }, t.onerror = (a) => {
-        c(a);
-      };
-      const f = {
-        type: "run",
-        config: r.config
-      };
-      r.dataset !== void 0 && (f.dataset = r.dataset), t.postMessage(f, m(f));
+  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._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 V(n) {
-  if (typeof self > "u") return;
-  let e = null, r = null, s = null, t = {};
-  const l = (f, a) => {
-    self.postMessage(f, a);
-  };
-  async function c(f) {
-    try {
-      const a = typeof f == "object" && f !== null && "data" in f ? { ...t, ...f } : { data: f, ...t, index: 0 }, o = await n(a), d = { ok: !0, data: o }, p = m(o);
-      e ? e.postMessage(d, p) : l(d, p);
-    } catch (a) {
-      const o = {
-        ok: !1,
-        error: a instanceof Error ? a.message : String(a)
-      };
-      e ? e.postMessage(o) : l(o);
-    }
-  }
-  self.addEventListener("message", (f) => {
-    const a = f.data;
-    if (a && a.__pipeline_ports__) {
-      a.stepParams && (t = a.stepParams), a.outputPort && (e = a.outputPort), a.inputPort && (r = a.inputPort, r.onmessage = (o) => {
-        var d;
-        o.data && o.data.ok === !1 ? e ? e.postMessage(o.data) : l(o.data) : c({ data: (d = o.data) == null ? void 0 : d.data, ...t, index: 0 });
-      }), s !== null && (c(s), s = null);
-      return;
-    }
-    r ? s = a : c(a);
-  });
+function oe(o) {
+  return o === void 0 ? (e) => e : o;
+}
+function ae(...o) {
+  return o;
 }
 export {
-  U as MainWorkerFactory,
-  W as WorkerFactory,
-  V as defineWorker
+  te as MainWorkerFactory,
+  b as WorkerFactory,
+  D as WorkerMode,
+  ie as defineWorker,
+  oe as defineWorkerConfig,
+  ae as defineWorkerConfigs
 };