footprintjs 4.16.0 → 4.17.2

package/dist/esm/lib/detach/drivers/microtaskBatch.js

@@ -0,0 +1,113 @@
+/**
+ * detach/drivers/microtaskBatch.ts — Batch detached work into ONE microtask.
+ *
+ * Pattern:  Producer-consumer with batched flush. Same shape as
+ *           agentfootprint's `EventDispatcher` flush queue and the React
+ *           reconciler's microtask scheduling — accumulate during the
+ *           current sync slice, drain at the next microtask boundary.
+ * Role:     Default driver for in-process detach. Cheapest scheduling
+ *           primitive on V8/JSC: one `queueMicrotask` per batch
+ *           regardless of how many work items, so the perf budget
+ *           amortizes. Suitable for browser AND node AND edge runtimes
+ *           (queueMicrotask is universal since 2018).
+ *
+ * Lifecycle:
+ *
+ *   schedule(child, input, refId)            ← driver entry
+ *     └─ create handle (queued)
+ *     └─ register in detachRegistry
+ *     └─ push work item onto local queue
+ *     └─ if no microtask scheduled yet → queueMicrotask(flush)
+ *     └─ return handle (sync — passive recorder rule)
+ *
+ *   flush() (microtask)                       ← deferred
+ *     └─ swap out queue (drain races safely)
+ *     └─ for each item: _markRunning, await runChild, _markDone/_markFailed
+ *     └─ unregister handle from detachRegistry
+ *
+ * Why microtask (and not setImmediate / setTimeout):
+ *   - Microtasks run BEFORE returning to the event loop — guarantees
+ *     the work finishes within the current "tick" if the runtime allows
+ *   - Lowest possible deferral cost (~50ns on modern V8)
+ *   - Works in EVERY JS runtime (browser, node, deno, bun, edge)
+ *   - Doesn't require any timer infrastructure → no GC pressure
+ *
+ * Re-entrancy:
+ *   - If `runChild` calls `schedule()` for nested detach, the new item
+ *     lands on the SAME queue. Because `scheduled` flips back to false
+ *     at the start of `flush`, the new item triggers a fresh microtask.
+ *   - Worst-case: O(n) microtasks for n nested levels. Acceptable —
+ *     real-world detach trees are shallow.
+ */
+import { asImpl, createHandle } from '../handle.js';
+import { register, unregister } from '../registry.js';
+import { defaultRunChild } from '../runChild.js';
+/**
+ * Build a microtask-batch driver wired to a custom child runner. Most
+ * consumers want the default singleton `microtaskBatchDriver` instead;
+ * this factory exists for tests and for advanced consumers who want to
+ * inject their own runner (e.g., a runner that wraps the child in a
+ * tracing context).
+ */
+export function createMicrotaskBatchDriver(runChild = defaultRunChild) {
+    // Per-driver-instance queue and flush guard. Closed over by `schedule`
+    // and `flush` so each call to `createMicrotaskBatchDriver` gets its
+    // own isolated batch (test isolation, multi-tenant scenarios).
+    const queue = [];
+    let scheduled = false;
+    function flush() {
+        // Reset BEFORE draining so re-entrant schedule()s during runChild
+        // queue a fresh microtask instead of joining the in-flight drain.
+        scheduled = false;
+        const items = queue.splice(0);
+        for (const item of items) {
+            // Each item runs concurrently — no awaits here, so the outer
+            // for-loop completes within this microtask. Errors inside
+            // `executeOne` are routed to the handle, not thrown. The promise
+            // is intentionally not awaited; ignore-promise-returned via the
+            // explicit no-op .then() pattern that the project's lint config
+            // accepts (vs `void`, which `no-void` rejects).
+            executeOne(item, runChild).then(undefined, undefined);
+        }
+    }
+    return {
+        name: 'microtask-batch',
+        capabilities: { browserSafe: true, nodeSafe: true, edgeSafe: true },
+        schedule(child, input, refId) {
+            const handle = createHandle(refId);
+            register(handle);
+            queue.push({ child, input, handle });
+            if (!scheduled) {
+                scheduled = true;
+                queueMicrotask(flush);
+            }
+            return handle;
+        },
+    };
+}
+/**
+ * Per-item execution. Marks the handle running, awaits the runner,
+ * routes outcome to the handle, cleans up the registry entry. Never
+ * throws — errors land on the handle (passive recorder rule).
+ */
+async function executeOne(item, runChild) {
+    const impl = asImpl(item.handle);
+    impl._markRunning();
+    try {
+        const result = await runChild(item.child, item.input);
+        impl._markDone(result);
+    }
+    catch (err) {
+        impl._markFailed(err instanceof Error ? err : new Error(String(err)));
+    }
+    finally {
+        unregister(impl.id);
+    }
+}
+/**
+ * Default singleton. Most consumers import this and pass it to
+ * `executor.detachAndJoinLater(child, input, { driver: microtaskBatchDriver })`
+ * (or rely on it being the executor's default driver, set in T5b).
+ */
+export const microtaskBatchDriver = createMicrotaskBatchDriver();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"microtaskBatch.js","sourceRoot":"","sources":["../../../../../src/lib/detach/drivers/microtaskBatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAGH,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAoB,eAAe,EAAE,MAAM,gBAAgB,CAAC;AASnE;;;;;;GAMG;AACH,MAAM,UAAU,0BAA0B,CAAC,WAAwB,eAAe;IAChF,uEAAuE;IACvE,oEAAoE;IACpE,+DAA+D;IAC/D,MAAM,KAAK,GAAe,EAAE,CAAC;IAC7B,IAAI,SAAS,GAAG,KAAK,CAAC;IAEtB,SAAS,KAAK;QACZ,kEAAkE;QAClE,kEAAkE;QAClE,SAAS,GAAG,KAAK,CAAC;QAClB,MAAM,KAAK,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QAC9B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,6DAA6D;YAC7D,0DAA0D;YAC1D,iEAAiE;YACjE,gEAAgE;YAChE,gEAAgE;YAChE,gDAAgD;YAChD,UAAU,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QACxD,CAAC;IACH,CAAC;IAED,OAAO;QACL,IAAI,EAAE,iBAAiB;QACvB,YAAY,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE;QACnE,QAAQ,CAAC,KAAgB,EAAE,KAAc,EAAE,KAAa;YACtD,MAAM,MAAM,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;YACnC,QAAQ,CAAC,MAAM,CAAC,CAAC;YACjB,KAAK,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;YACrC,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,SAAS,GAAG,IAAI,CAAC;gBACjB,cAAc,CAAC,KAAK,CAAC,CAAC;YACxB,CAAC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,KAAK,UAAU,UAAU,CAAC,IAAc,EAAE,QAAqB;IAC7D,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACjC,IAAI,CAAC,YAAY,EAAE,CAAC;IACpB,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;QACtD,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IACzB,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,IAAI,CAAC,WAAW,CAAC,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IACxE,CAAC;YAAS,CAAC;QACT,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACtB,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAiB,0BAA0B,EAAE,CAAC","sourcesContent":["/**\n * detach/drivers/microtaskBatch.ts — Batch detached work into ONE microtask.\n *\n * Pattern:  Producer-consumer with batched flush. Same shape as\n *           agentfootprint's `EventDispatcher` flush queue and the React\n *           reconciler's microtask scheduling — accumulate during the\n *           current sync slice, drain at the next microtask boundary.\n * Role:     Default driver for in-process detach. Cheapest scheduling\n *           primitive on V8/JSC: one `queueMicrotask` per batch\n *           regardless of how many work items, so the perf budget\n *           amortizes. Suitable for browser AND node AND edge runtimes\n *           (queueMicrotask is universal since 2018).\n *\n * Lifecycle:\n *\n *   schedule(child, input, refId)            ← driver entry\n *     └─ create handle (queued)\n *     └─ register in detachRegistry\n *     └─ push work item onto local queue\n *     └─ if no microtask scheduled yet → queueMicrotask(flush)\n *     └─ return handle (sync — passive recorder rule)\n *\n *   flush() (microtask)                       ← deferred\n *     └─ swap out queue (drain races safely)\n *     └─ for each item: _markRunning, await runChild, _markDone/_markFailed\n *     └─ unregister handle from detachRegistry\n *\n * Why microtask (and not setImmediate / setTimeout):\n *   - Microtasks run BEFORE returning to the event loop — guarantees\n *     the work finishes within the current \"tick\" if the runtime allows\n *   - Lowest possible deferral cost (~50ns on modern V8)\n *   - Works in EVERY JS runtime (browser, node, deno, bun, edge)\n *   - Doesn't require any timer infrastructure → no GC pressure\n *\n * Re-entrancy:\n *   - If `runChild` calls `schedule()` for nested detach, the new item\n *     lands on the SAME queue. Because `scheduled` flips back to false\n *     at the start of `flush`, the new item triggers a fresh microtask.\n *   - Worst-case: O(n) microtasks for n nested levels. Acceptable —\n *     real-world detach trees are shallow.\n */\n\nimport type { FlowChart } from '../../builder/types.js';\nimport { asImpl, createHandle } from '../handle.js';\nimport { register, unregister } from '../registry.js';\nimport { type ChildRunner, defaultRunChild } from '../runChild.js';\nimport type { DetachDriver, DetachHandle } from '../types.js';\n\ninterface WorkItem {\n  readonly child: FlowChart;\n  readonly input: unknown;\n  readonly handle: DetachHandle;\n}\n\n/**\n * Build a microtask-batch driver wired to a custom child runner. Most\n * consumers want the default singleton `microtaskBatchDriver` instead;\n * this factory exists for tests and for advanced consumers who want to\n * inject their own runner (e.g., a runner that wraps the child in a\n * tracing context).\n */\nexport function createMicrotaskBatchDriver(runChild: ChildRunner = defaultRunChild): DetachDriver {\n  // Per-driver-instance queue and flush guard. Closed over by `schedule`\n  // and `flush` so each call to `createMicrotaskBatchDriver` gets its\n  // own isolated batch (test isolation, multi-tenant scenarios).\n  const queue: WorkItem[] = [];\n  let scheduled = false;\n\n  function flush(): void {\n    // Reset BEFORE draining so re-entrant schedule()s during runChild\n    // queue a fresh microtask instead of joining the in-flight drain.\n    scheduled = false;\n    const items = queue.splice(0);\n    for (const item of items) {\n      // Each item runs concurrently — no awaits here, so the outer\n      // for-loop completes within this microtask. Errors inside\n      // `executeOne` are routed to the handle, not thrown. The promise\n      // is intentionally not awaited; ignore-promise-returned via the\n      // explicit no-op .then() pattern that the project's lint config\n      // accepts (vs `void`, which `no-void` rejects).\n      executeOne(item, runChild).then(undefined, undefined);\n    }\n  }\n\n  return {\n    name: 'microtask-batch',\n    capabilities: { browserSafe: true, nodeSafe: true, edgeSafe: true },\n    schedule(child: FlowChart, input: unknown, refId: string): DetachHandle {\n      const handle = createHandle(refId);\n      register(handle);\n      queue.push({ child, input, handle });\n      if (!scheduled) {\n        scheduled = true;\n        queueMicrotask(flush);\n      }\n      return handle;\n    },\n  };\n}\n\n/**\n * Per-item execution. Marks the handle running, awaits the runner,\n * routes outcome to the handle, cleans up the registry entry. Never\n * throws — errors land on the handle (passive recorder rule).\n */\nasync function executeOne(item: WorkItem, runChild: ChildRunner): Promise<void> {\n  const impl = asImpl(item.handle);\n  impl._markRunning();\n  try {\n    const result = await runChild(item.child, item.input);\n    impl._markDone(result);\n  } catch (err) {\n    impl._markFailed(err instanceof Error ? err : new Error(String(err)));\n  } finally {\n    unregister(impl.id);\n  }\n}\n\n/**\n * Default singleton. Most consumers import this and pass it to\n * `executor.detachAndJoinLater(child, input, { driver: microtaskBatchDriver })`\n * (or rely on it being the executor's default driver, set in T5b).\n */\nexport const microtaskBatchDriver: DetachDriver = createMicrotaskBatchDriver();\n"]}

package/dist/esm/lib/detach/drivers/sendBeacon.js

@@ -0,0 +1,78 @@
+/**
+ * detach/drivers/sendBeacon.ts — Browser-only driver that ships work
+ *                                via `navigator.sendBeacon` so it
+ *                                survives page-unload.
+ *
+ * Pattern:  Strategy / Adapter — translates the consumer's child
+ *           flowchart into a sendBeacon POST. The "child" is expected
+ *           to produce a JSON-serializable payload via its
+ *           `inputMapper`; the URL endpoint is set at driver creation.
+ * Role:     The narrow but high-value driver for analytics / error
+ *           reporting / page-leave telemetry — the one case where
+ *           "fire-and-forget" must really mean "ships even if the
+ *           user closes the tab right after."
+ *
+ * `navigator.sendBeacon` semantics:
+ *   - Browser queues the POST in the OS network stack BEFORE returning
+ *     control. Survives page-unload, navigation, refresh.
+ *   - Limited to ~64 KB per call (per HTML5 spec).
+ *   - Fire-and-forget — no response observable.
+ *
+ * Caveats:
+ *   - Browser-only (`browserSafe: true, survivesUnload: true`).
+ *     `validate()` throws helpfully if `navigator.sendBeacon` isn't a
+ *     function (e.g., when imported in Node).
+ *   - The driver does NOT run the child flowchart through a
+ *     `FlowChartExecutor` — it serializes the input and POSTs. This
+ *     is an intentional simplification: sendBeacon's semantics
+ *     wouldn't survive an executor's async stages anyway.
+ */
+import { asImpl, createHandle } from '../handle.js';
+import { register, unregister } from '../registry.js';
+export function createSendBeaconDriver(opts) {
+    if (!opts.url) {
+        throw new TypeError('[detach] createSendBeaconDriver requires a `url` option.');
+    }
+    function serialize(input) {
+        if (opts.serialize)
+            return opts.serialize(input);
+        return new Blob([JSON.stringify(input ?? null)], { type: 'application/json' });
+    }
+    return {
+        name: 'send-beacon',
+        capabilities: {
+            browserSafe: true,
+            survivesUnload: true,
+        },
+        validate() {
+            if (typeof navigator === 'undefined' || typeof navigator.sendBeacon !== 'function') {
+                throw new Error('[detach] sendBeaconDriver requires a browser environment with `navigator.sendBeacon`. ' +
+                    'Use `microtaskBatchDriver` for in-process detach, or `setImmediateDriver` for Node.js.');
+            }
+        },
+        schedule(_child, input, refId) {
+            const handle = createHandle(refId);
+            register(handle);
+            const impl = asImpl(handle);
+            impl._markRunning();
+            try {
+                const payload = serialize(input);
+                const accepted = navigator.sendBeacon(opts.url, payload);
+                if (accepted) {
+                    impl._markDone({ accepted: true, url: opts.url });
+                }
+                else {
+                    impl._markFailed(new Error('[detach] navigator.sendBeacon refused the payload (likely over the ~64 KB limit).'));
+                }
+            }
+            catch (err) {
+                impl._markFailed(err instanceof Error ? err : new Error(String(err)));
+            }
+            finally {
+                unregister(impl.id);
+            }
+            return handle;
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/detach/drivers/setImmediate.js

@@ -0,0 +1,81 @@
+/**
+ * detach/drivers/setImmediate.ts — Defer detached work to a Node.js
+ *                                  `setImmediate` boundary.
+ *
+ * Pattern:  Same producer-consumer batch flush as `microtaskBatch`,
+ *           but the deferral is `setImmediate` instead of
+ *           `queueMicrotask`. Yields control back to the event loop
+ *           BEFORE running — allows pending I/O callbacks to drain
+ *           first, which microtasks would block.
+ * Role:     Node-specific driver for "fire-and-forget after the
+ *           current I/O tick." Use when the parent stage handles
+ *           latency-sensitive work and you don't want detached work
+ *           to compete for the synchronous slice.
+ *
+ * When to pick this over microtaskBatch:
+ *   - You're shipping logs / metrics in a hot HTTP path and don't
+ *     want them blocking the response from being flushed
+ *   - The detached work itself is CPU-heavy enough that running it on
+ *     the same microtask cycle would delay other microtasks
+ *   - You explicitly want "next event-loop tick" semantics — useful
+ *     when interacting with third-party libraries that expect at
+ *     least one I/O tick between schedule and execution
+ *
+ * Capability:
+ *   - `nodeSafe: true` — relies on Node's `setImmediate`, NOT
+ *     available in browsers / Deno / Cloudflare Workers (use
+ *     `setTimeoutDriver` for cross-runtime alternative)
+ */
+import { asImpl, createHandle } from '../handle.js';
+import { register, unregister } from '../registry.js';
+import { defaultRunChild } from '../runChild.js';
+export function createSetImmediateDriver(runChild = defaultRunChild) {
+    const queue = [];
+    let scheduled = false;
+    function flush() {
+        scheduled = false;
+        const items = queue.splice(0);
+        for (const item of items) {
+            executeOne(item, runChild).then(undefined, undefined);
+        }
+    }
+    return {
+        name: 'set-immediate',
+        capabilities: { nodeSafe: true },
+        validate() {
+            if (typeof setImmediate !== 'function') {
+                throw new Error('[detach] setImmediateDriver requires Node.js — global `setImmediate` is not defined ' +
+                    'in this runtime. Use `microtaskBatchDriver` for cross-runtime use, or `setTimeoutDriver` ' +
+                    'for browser/edge environments.');
+            }
+        },
+        schedule(child, input, refId) {
+            const handle = createHandle(refId);
+            register(handle);
+            queue.push({ child, input, handle });
+            if (!scheduled) {
+                scheduled = true;
+                // `setImmediate` is non-undefined here in Node; runtime guard
+                // is in `validate()`. The `!` is a deliberate assertion.
+                setImmediate(flush);
+            }
+            return handle;
+        },
+    };
+}
+async function executeOne(item, runChild) {
+    const impl = asImpl(item.handle);
+    impl._markRunning();
+    try {
+        const result = await runChild(item.child, item.input);
+        impl._markDone(result);
+    }
+    catch (err) {
+        impl._markFailed(err instanceof Error ? err : new Error(String(err)));
+    }
+    finally {
+        unregister(impl.id);
+    }
+}
+export const setImmediateDriver = createSetImmediateDriver();
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/detach/drivers/setTimeout.js

@@ -0,0 +1,69 @@
+/**
+ * detach/drivers/setTimeout.ts — Defer detached work via `setTimeout(..., delayMs)`.
+ *
+ * Pattern:  Producer-consumer batch flush; deferral mechanism is
+ *           `setTimeout` with a configurable delay (default `0`).
+ * Role:     Cross-runtime "next macrotask" driver. Works in browsers,
+ *           Node.js, Deno, Cloudflare Workers, Bun, etc.
+ *
+ * When to pick this:
+ *   - Consumer wants a SPECIFIC delay (e.g. "ship telemetry in 5
+ *     seconds, batched") — pass `createSetTimeoutDriver({ delayMs: 5000 })`
+ *   - Cross-runtime detach where `setImmediate` isn't available
+ *   - Coalescing high-frequency events into a low-frequency flush
+ *
+ * Caveats:
+ *   - Not for low-latency hot paths — minimum delay is ~4ms in
+ *     browsers per the HTML5 spec, ~1ms in Node. Use
+ *     `microtaskBatchDriver` for sub-ms scheduling.
+ *   - Browser tab freezing / throttling can extend the delay
+ *     significantly. Don't rely on precise timing.
+ */
+import { asImpl, createHandle } from '../handle.js';
+import { register, unregister } from '../registry.js';
+import { defaultRunChild } from '../runChild.js';
+export function createSetTimeoutDriver(opts = {}) {
+    const delayMs = opts.delayMs ?? 0;
+    const runChild = opts.runChild ?? defaultRunChild;
+    const queue = [];
+    let scheduled = false;
+    function flush() {
+        scheduled = false;
+        const items = queue.splice(0);
+        for (const item of items) {
+            executeOne(item, runChild).then(undefined, undefined);
+        }
+    }
+    return {
+        name: delayMs === 0 ? 'set-timeout' : `set-timeout-${delayMs}ms`,
+        capabilities: { browserSafe: true, nodeSafe: true, edgeSafe: true },
+        schedule(child, input, refId) {
+            const handle = createHandle(refId);
+            register(handle);
+            queue.push({ child, input, handle });
+            if (!scheduled) {
+                scheduled = true;
+                setTimeout(flush, delayMs);
+            }
+            return handle;
+        },
+    };
+}
+async function executeOne(item, runChild) {
+    const impl = asImpl(item.handle);
+    impl._markRunning();
+    try {
+        const result = await runChild(item.child, item.input);
+        impl._markDone(result);
+    }
+    catch (err) {
+        impl._markFailed(err instanceof Error ? err : new Error(String(err)));
+    }
+    finally {
+        unregister(impl.id);
+    }
+}
+/** Default singleton — zero-delay (next macrotask). For configurable
+ *  delays, use `createSetTimeoutDriver({ delayMs })`. */
+export const setTimeoutDriver = createSetTimeoutDriver();
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/detach/drivers/workerThread.js

@@ -0,0 +1,117 @@
+/**
+ * detach/drivers/workerThread.ts — Run detached work in a Node.js
+ *                                  Worker Thread (or browser Web Worker).
+ *
+ * Pattern:  Adapter — translates the consumer's child flowchart into
+ *           a worker message + lifecycle handoff. The worker is owned
+ *           by the driver instance; restarted on crash.
+ * Role:     CPU-isolation driver — when detached work is genuinely
+ *           expensive (heavy parsing, hashing, image processing) and
+ *           you don't want it blocking the main thread's event loop
+ *           even for a microtask burst.
+ *
+ * Caveats / IMPORTANT v1 limitations:
+ *   - The worker entry point is a CONSUMER-PROVIDED file path / URL —
+ *     this driver does NOT auto-spawn FlowChartExecutor in a worker.
+ *     Workers can't `import('footprintjs')` portably without setup,
+ *     and the worker file's lifecycle differs by runtime
+ *     (Node Worker vs Web Worker vs Bun). Consumer writes the worker
+ *     code; this driver just hands them a uniform `(input, handle)`
+ *     API.
+ *   - The "child flowchart" parameter is IGNORED in v1 (we only ship
+ *     the input). The chart shape doesn't survive structuredClone +
+ *     postMessage anyway. v2 may add a serialization protocol.
+ *
+ * Two ways to consume:
+ *
+ *   1. Node.js: pass a file path
+ *      `createWorkerThreadDriver({ workerScript: '/path/to/worker.js' })`
+ *
+ *   2. Browser: pass a URL or pre-built Worker instance
+ *      `createWorkerThreadDriver({ worker: new Worker(url) })`
+ */
+import { asImpl, createHandle } from '../handle.js';
+import { register, unregister } from '../registry.js';
+let nextMessageId = 0;
+export function createWorkerThreadDriver(opts) {
+    let worker;
+    const inFlight = new Map();
+    // If consumer provided a Worker at construction time, bind its
+    // 'message' handler eagerly so replies are routed back to handles.
+    // Lazy construction (via `workerScript`) defers binding to first use.
+    if (opts.worker) {
+        worker = opts.worker;
+        bindWorker(worker, inFlight);
+    }
+    function ensureWorker() {
+        if (worker)
+            return worker;
+        if (!opts.workerScript) {
+            throw new Error('[detach] workerThreadDriver: provide either `worker` (a constructed Worker) ' +
+                'or `workerScript` (a path/URL) at driver creation.');
+        }
+        // Lazy-import Node's worker_threads — keeps browser bundles clean.
+        if (typeof require !== 'function') {
+            throw new Error('[detach] workerThreadDriver: `workerScript` requires Node.js (CommonJS `require`).');
+        }
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { Worker } = require('worker_threads');
+        worker = new Worker(opts.workerScript);
+        bindWorker(worker, inFlight);
+        return worker;
+    }
+    return {
+        name: 'worker-thread',
+        capabilities: { nodeSafe: true, cpuIsolated: true },
+        validate() {
+            if (!opts.worker && !opts.workerScript) {
+                throw new Error('[detach] workerThreadDriver requires either a pre-built `worker` or a `workerScript` path.');
+            }
+        },
+        schedule(_child, input, refId) {
+            const handle = createHandle(refId);
+            register(handle);
+            const impl = asImpl(handle);
+            impl._markRunning();
+            const messageId = nextMessageId++;
+            inFlight.set(messageId, { handle });
+            try {
+                const w = ensureWorker();
+                w.postMessage({ messageId, refId, input });
+            }
+            catch (err) {
+                impl._markFailed(err instanceof Error ? err : new Error(String(err)));
+                unregister(impl.id);
+                inFlight.delete(messageId);
+            }
+            return handle;
+        },
+    };
+}
+function bindWorker(worker, inFlight) {
+    const handler = (msg) => {
+        const m = msg;
+        if (!m || typeof m.messageId !== 'number')
+            return;
+        const slot = inFlight.get(m.messageId);
+        if (!slot)
+            return;
+        inFlight.delete(m.messageId);
+        const impl = asImpl(slot.handle);
+        if (m.ok) {
+            impl._markDone(m.result);
+        }
+        else {
+            impl._markFailed(new Error(m.error ?? 'worker reported failure'));
+        }
+        unregister(impl.id);
+    };
+    // Node Worker (worker_threads): EventEmitter-shape (`on('message', ...)`).
+    if (typeof worker.on === 'function')
+        worker.on('message', handler);
+    // Browser Worker / Web Worker: EventTarget-shape (`addEventListener`).
+    else if (typeof worker.addEventListener === 'function') {
+        worker.addEventListener('message', (evt) => handler(evt?.data));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workerThread.js","sourceRoot":"","sources":["../../../../../src/lib/detach/drivers/workerThread.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * detach/drivers/workerThread.ts — Run detached work in a Node.js\n *                                  Worker Thread (or browser Web Worker).\n *\n * Pattern:  Adapter — translates the consumer's child flowchart into\n *           a worker message + lifecycle handoff. The worker is owned\n *           by the driver instance; restarted on crash.\n * Role:     CPU-isolation driver — when detached work is genuinely\n *           expensive (heavy parsing, hashing, image processing) and\n *           you don't want it blocking the main thread's event loop\n *           even for a microtask burst.\n *\n * Caveats / IMPORTANT v1 limitations:\n *   - The worker entry point is a CONSUMER-PROVIDED file path / URL —\n *     this driver does NOT auto-spawn FlowChartExecutor in a worker.\n *     Workers can't `import('footprintjs')` portably without setup,\n *     and the worker file's lifecycle differs by runtime\n *     (Node Worker vs Web Worker vs Bun). Consumer writes the worker\n *     code; this driver just hands them a uniform `(input, handle)`\n *     API.\n *   - The \"child flowchart\" parameter is IGNORED in v1 (we only ship\n *     the input). The chart shape doesn't survive structuredClone +\n *     postMessage anyway. v2 may add a serialization protocol.\n *\n * Two ways to consume:\n *\n *   1. Node.js: pass a file path\n *      `createWorkerThreadDriver({ workerScript: '/path/to/worker.js' })`\n *\n *   2. Browser: pass a URL or pre-built Worker instance\n *      `createWorkerThreadDriver({ worker: new Worker(url) })`\n */\n\nimport type { FlowChart } from '../../builder/types.js';\nimport { asImpl, createHandle } from '../handle.js';\nimport { register, unregister } from '../registry.js';\nimport type { DetachDriver, DetachHandle } from '../types.js';\n\n// Node-only CommonJS `require`. We don't ship @types/node, so declare\n// the minimal shape here. Used only in the lazy `workerScript` path;\n// browser consumers pass a pre-constructed `Worker` and never hit it.\ndeclare const require: ((mod: string) => unknown) | undefined;\n\ninterface WorkerLike {\n  postMessage(message: unknown, transfer?: Transferable[]): void;\n  terminate?(): unknown;\n  on?(event: string, listener: (msg: unknown) => void): void;\n  addEventListener?(event: string, listener: (msg: unknown) => void): void;\n}\n\nexport interface WorkerThreadDriverOptions {\n  /** Pre-constructed Worker instance. Pass either this OR\n   *  `workerScript` — not both. */\n  readonly worker?: WorkerLike;\n  /** Path / URL to the worker script. Used only when `worker` is\n   *  not provided; the driver constructs a Worker from this on demand\n   *  (Node `worker_threads` API). */\n  readonly workerScript?: string;\n}\n\ninterface InFlight {\n  readonly handle: DetachHandle;\n}\n\nlet nextMessageId = 0;\n\nexport function createWorkerThreadDriver(opts: WorkerThreadDriverOptions): DetachDriver {\n  let worker: WorkerLike | undefined;\n  const inFlight = new Map<number, InFlight>();\n\n  // If consumer provided a Worker at construction time, bind its\n  // 'message' handler eagerly so replies are routed back to handles.\n  // Lazy construction (via `workerScript`) defers binding to first use.\n  if (opts.worker) {\n    worker = opts.worker;\n    bindWorker(worker, inFlight);\n  }\n\n  function ensureWorker(): WorkerLike {\n    if (worker) return worker;\n    if (!opts.workerScript) {\n      throw new Error(\n        '[detach] workerThreadDriver: provide either `worker` (a constructed Worker) ' +\n          'or `workerScript` (a path/URL) at driver creation.',\n      );\n    }\n    // Lazy-import Node's worker_threads — keeps browser bundles clean.\n    if (typeof require !== 'function') {\n      throw new Error('[detach] workerThreadDriver: `workerScript` requires Node.js (CommonJS `require`).');\n    }\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    const { Worker } = require('worker_threads') as { Worker: new (s: string) => WorkerLike };\n    worker = new Worker(opts.workerScript);\n    bindWorker(worker, inFlight);\n    return worker;\n  }\n\n  return {\n    name: 'worker-thread',\n    capabilities: { nodeSafe: true, cpuIsolated: true },\n    validate(): void {\n      if (!opts.worker && !opts.workerScript) {\n        throw new Error('[detach] workerThreadDriver requires either a pre-built `worker` or a `workerScript` path.');\n      }\n    },\n    schedule(_child: FlowChart, input: unknown, refId: string): DetachHandle {\n      const handle = createHandle(refId);\n      register(handle);\n      const impl = asImpl(handle);\n      impl._markRunning();\n\n      const messageId = nextMessageId++;\n      inFlight.set(messageId, { handle });\n\n      try {\n        const w = ensureWorker();\n        w.postMessage({ messageId, refId, input });\n      } catch (err) {\n        impl._markFailed(err instanceof Error ? err : new Error(String(err)));\n        unregister(impl.id);\n        inFlight.delete(messageId);\n      }\n\n      return handle;\n    },\n  };\n}\n\nfunction bindWorker(worker: WorkerLike, inFlight: Map<number, InFlight>): void {\n  const handler = (msg: unknown): void => {\n    const m = msg as { messageId?: number; ok?: boolean; result?: unknown; error?: string } | undefined;\n    if (!m || typeof m.messageId !== 'number') return;\n    const slot = inFlight.get(m.messageId);\n    if (!slot) return;\n    inFlight.delete(m.messageId);\n\n    const impl = asImpl(slot.handle);\n    if (m.ok) {\n      impl._markDone(m.result);\n    } else {\n      impl._markFailed(new Error(m.error ?? 'worker reported failure'));\n    }\n    unregister(impl.id);\n  };\n\n  // Node Worker (worker_threads): EventEmitter-shape (`on('message', ...)`).\n  if (typeof worker.on === 'function') worker.on('message', handler);\n  // Browser Worker / Web Worker: EventTarget-shape (`addEventListener`).\n  else if (typeof worker.addEventListener === 'function') {\n    worker.addEventListener('message', (evt: unknown) => handler((evt as { data?: unknown })?.data));\n  }\n}\n"]}