footprintjs 4.16.0 → 4.17.2

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

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.microtaskBatchDriver = exports.createMicrotaskBatchDriver = void 0;
+const handle_js_1 = require("../handle.js");
+const registry_js_1 = require("../registry.js");
+const runChild_js_1 = require("../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).
+ */
+function createMicrotaskBatchDriver(runChild = runChild_js_1.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 = (0, handle_js_1.createHandle)(refId);
+            (0, registry_js_1.register)(handle);
+            queue.push({ child, input, handle });
+            if (!scheduled) {
+                scheduled = true;
+                queueMicrotask(flush);
+            }
+            return handle;
+        },
+    };
+}
+exports.createMicrotaskBatchDriver = createMicrotaskBatchDriver;
+/**
+ * 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 = (0, handle_js_1.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 {
+        (0, registry_js_1.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).
+ */
+exports.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,4CAAoD;AACpD,gDAAsD;AACtD,gDAAmE;AASnE;;;;;;GAMG;AACH,SAAgB,0BAA0B,CAAC,WAAwB,6BAAe;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,IAAA,wBAAY,EAAC,KAAK,CAAC,CAAC;YACnC,IAAA,sBAAQ,EAAC,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;AArCD,gEAqCC;AAED;;;;GAIG;AACH,KAAK,UAAU,UAAU,CAAC,IAAc,EAAE,QAAqB;IAC7D,MAAM,IAAI,GAAG,IAAA,kBAAM,EAAC,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,IAAA,wBAAU,EAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACtB,CAAC;AACH,CAAC;AAED;;;;GAIG;AACU,QAAA,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/lib/detach/drivers/sendBeacon.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSendBeaconDriver = void 0;
+const handle_js_1 = require("../handle.js");
+const registry_js_1 = require("../registry.js");
+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 = (0, handle_js_1.createHandle)(refId);
+            (0, registry_js_1.register)(handle);
+            const impl = (0, handle_js_1.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 {
+                (0, registry_js_1.unregister)(impl.id);
+            }
+            return handle;
+        },
+    };
+}
+exports.createSendBeaconDriver = createSendBeaconDriver;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * 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)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setImmediateDriver = exports.createSetImmediateDriver = void 0;
+const handle_js_1 = require("../handle.js");
+const registry_js_1 = require("../registry.js");
+const runChild_js_1 = require("../runChild.js");
+function createSetImmediateDriver(runChild = runChild_js_1.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 = (0, handle_js_1.createHandle)(refId);
+            (0, registry_js_1.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;
+        },
+    };
+}
+exports.createSetImmediateDriver = createSetImmediateDriver;
+async function executeOne(item, runChild) {
+    const impl = (0, handle_js_1.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 {
+        (0, registry_js_1.unregister)(impl.id);
+    }
+}
+exports.setImmediateDriver = createSetImmediateDriver();
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setTimeoutDriver = exports.createSetTimeoutDriver = void 0;
+const handle_js_1 = require("../handle.js");
+const registry_js_1 = require("../registry.js");
+const runChild_js_1 = require("../runChild.js");
+function createSetTimeoutDriver(opts = {}) {
+    const delayMs = opts.delayMs ?? 0;
+    const runChild = opts.runChild ?? runChild_js_1.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 = (0, handle_js_1.createHandle)(refId);
+            (0, registry_js_1.register)(handle);
+            queue.push({ child, input, handle });
+            if (!scheduled) {
+                scheduled = true;
+                setTimeout(flush, delayMs);
+            }
+            return handle;
+        },
+    };
+}
+exports.createSetTimeoutDriver = createSetTimeoutDriver;
+async function executeOne(item, runChild) {
+    const impl = (0, handle_js_1.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 {
+        (0, registry_js_1.unregister)(impl.id);
+    }
+}
+/** Default singleton — zero-delay (next macrotask). For configurable
+ *  delays, use `createSetTimeoutDriver({ delayMs })`. */
+exports.setTimeoutDriver = createSetTimeoutDriver();
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,121 @@
+"use strict";
+/**
+ * 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) })`
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorkerThreadDriver = void 0;
+const handle_js_1 = require("../handle.js");
+const registry_js_1 = require("../registry.js");
+let nextMessageId = 0;
+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 = (0, handle_js_1.createHandle)(refId);
+            (0, registry_js_1.register)(handle);
+            const impl = (0, handle_js_1.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)));
+                (0, registry_js_1.unregister)(impl.id);
+                inFlight.delete(messageId);
+            }
+            return handle;
+        },
+    };
+}
+exports.createWorkerThreadDriver = createWorkerThreadDriver;
+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 = (0, handle_js_1.asImpl)(slot.handle);
+        if (m.ok) {
+            impl._markDone(m.result);
+        }
+        else {
+            impl._markFailed(new Error(m.error ?? 'worker reported failure'));
+        }
+        (0, registry_js_1.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"]}