footprintjs 9.41.0 → 9.43.0

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

@@ -0,0 +1,79 @@
+/**
+ * One lifecycle for the three deferred batching drivers. Adapters supply
+ * the deferral mechanism; this module owns each batch from registration
+ * through dispatch or refusal, and each child's terminal cleanup.
+ * Internal only: the consumer contract remains `types.ts · DetachDriver`.
+ */
+import { extractErrorInfo } from '../../errors/errorInfo.js';
+import { asImpl, createHandle } from '../handle.js';
+import { register, unregister } from '../registry.js';
+export function createBatchSchedule(defer, runChild) {
+    let pending;
+    // Taking a batch retires its callback and releases its captured inputs.
+    // A callback captured by a scheduler that then threw must never take
+    // a newer batch. Retire BEFORE children/error formatting can re-enter.
+    function take(batch) {
+        if (pending !== batch)
+            return [];
+        pending = undefined;
+        return batch.splice(0);
+    }
+    return (child, input, refId) => {
+        const handle = createHandle(refId);
+        register(handle);
+        const item = { child, input, handle };
+        if (pending) {
+            pending.push(item);
+            return handle;
+        }
+        const batch = [item];
+        pending = batch;
+        try {
+            defer(() => {
+                // Start siblings in order without awaiting them. Reentrant
+                // scheduling belongs to a fresh batch with its own callback.
+                for (const work of take(batch)) {
+                    executeOne(work, runChild).then(undefined, undefined);
+                }
+            });
+        }
+        catch (error) {
+            const refused = take(batch);
+            if (refused.length > 0) {
+                const failure = asError(error);
+                for (const work of refused) {
+                    asImpl(work.handle)._markFailed(failure);
+                    unregister(work.handle.id);
+                }
+            }
+        }
+        return handle;
+    };
+}
+async function executeOne(item, runChild) {
+    const impl = asImpl(item.handle);
+    impl._markRunning();
+    try {
+        impl._markDone(await runChild(item.child, item.input));
+    }
+    catch (error) {
+        impl._markFailed(asError(error));
+    }
+    finally {
+        unregister(impl.id);
+    }
+}
+function asError(error) {
+    try {
+        if (error instanceof Error)
+            return error;
+        return new Error(extractErrorInfo(error).message);
+    }
+    catch {
+        // Even classification can invoke user code (for example a revoked
+        // or stateful Proxy). Describing a refusal must not prevent it from
+        // settling the handle. Do not inspect the thrown value again here.
+        return new Error('Detached work failed; its thrown value could not be described.');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/detach/drivers/microtaskBatch.d.ts

@@ -1,16 +1,15 @@
 /**
  * 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.
+ * Pattern:  Producer-consumer with batched flush — accumulate during
+ *           the current sync slice, drain at the next microtask boundary.
+ *           `batch.ts · createBatchSchedule` owns the lifecycle shared
+ *           with the timeout and immediate-tick drivers.
  * Role:     The in-process driver the docs name (no driver is the default:
- *           every detach call passes one). 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).
+ *           every detach call passes one). One `queueMicrotask` per
+ *           batch amortizes scheduling cost across its work items.
+ *           Suitable for browser, Node and edge runtimes that provide
+ *           `queueMicrotask`.
  *
  * Lifecycle:
  *
@@ -18,7 +17,8 @@
  *     └─ create handle (queued)
  *     └─ register in detachRegistry
  *     └─ push work item onto local queue
- *     └─ if no microtask scheduled yet → queueMicrotask(flush)
+ *     └─ if this is a new batch → queueMicrotask(flush)
+ *     └─ on scheduling failure → retire batch, fail + unregister handles
  *     └─ return handle (sync — passive recorder rule)
  *
  *   flush() (microtask)                       ← deferred
@@ -27,18 +27,15 @@
  *     └─ 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
+ *   - Microtasks start BEFORE returning to the event loop; an async
+ *     child can still finish on a later tick
+ *   - No timer delay or Node-only scheduling API is required
  *
  * 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.
+ *   - A flush retires its batch before starting children. If `runChild`
+ *     calls `schedule()` for nested detach, it opens a fresh batch and
+ *     schedules a new microtask.
+ *   - A chain of n nested detaches needs n microtask boundaries
  */
 import { type ChildRunner } from '../runChild.js';
 import type { DetachDriver } from '../types.js';

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

@@ -1,16 +1,15 @@
 /**
  * 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.
+ * Pattern:  Producer-consumer with batched flush — accumulate during
+ *           the current sync slice, drain at the next microtask boundary.
+ *           `batch.ts · createBatchSchedule` owns the lifecycle shared
+ *           with the timeout and immediate-tick drivers.
  * Role:     The in-process driver the docs name (no driver is the default:
- *           every detach call passes one). 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).
+ *           every detach call passes one). One `queueMicrotask` per
+ *           batch amortizes scheduling cost across its work items.
+ *           Suitable for browser, Node and edge runtimes that provide
+ *           `queueMicrotask`.
  *
  * Lifecycle:
  *
@@ -18,7 +17,8 @@
  *     └─ create handle (queued)
  *     └─ register in detachRegistry
  *     └─ push work item onto local queue
- *     └─ if no microtask scheduled yet → queueMicrotask(flush)
+ *     └─ if this is a new batch → queueMicrotask(flush)
+ *     └─ on scheduling failure → retire batch, fail + unregister handles
  *     └─ return handle (sync — passive recorder rule)
  *
  *   flush() (microtask)                       ← deferred
@@ -27,22 +27,18 @@
  *     └─ 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
+ *   - Microtasks start BEFORE returning to the event loop; an async
+ *     child can still finish on a later tick
+ *   - No timer delay or Node-only scheduling API is required
  *
  * 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.
+ *   - A flush retires its batch before starting children. If `runChild`
+ *     calls `schedule()` for nested detach, it opens a fresh batch and
+ *     schedules a new microtask.
+ *   - A chain of n nested detaches needs n microtask boundaries
  */
-import { asImpl, createHandle } from '../handle.js';
-import { register, unregister } from '../registry.js';
 import { defaultRunChild } from '../runChild.js';
+import { createBatchSchedule } from './batch.js';
 /**
  * Build a microtask-batch driver wired to a custom child runner. Most
  * consumers want the default singleton `microtaskBatchDriver` instead;
@@ -51,64 +47,16 @@ import { defaultRunChild } from '../runChild.js';
  * 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;
-        },
+        schedule: createBatchSchedule((flush) => queueMicrotask(flush), runChild),
     };
 }
-/**
- * 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);
-    }
-}
 /**
  * Ready-made singleton. Most consumers import this and pass it as the first
  * argument: `executor.detachAndJoinLater(microtaskBatchDriver, child, input)`.
  * It is not an implicit default — nothing picks a driver for you.
  */
 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;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:     The in-process driver the docs name (no driver is the default:\n *           every detach call passes one). 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 * Ready-made singleton. Most consumers import this and pass it as the first\n * argument: `executor.detachAndJoinLater(microtaskBatchDriver, child, input)`.\n * It is not an implicit default — nothing picks a driver for you.\n */\nexport const microtaskBatchDriver: DetachDriver = createMicrotaskBatchDriver();\n"]}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -26,56 +26,25 @@
  *     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';
+import { createBatchSchedule } from './batch.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;
+            scheduler();
         },
+        schedule: createBatchSchedule((flush) => scheduler()(flush), runChild),
     };
 }
-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);
+function scheduler() {
+    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.');
     }
+    return setImmediate;
 }
 export const setImmediateDriver = createSetImmediateDriver();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -19,51 +19,18 @@
  *   - 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';
+import { createBatchSchedule } from './batch.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;
-        },
+        schedule: createBatchSchedule((flush) => setTimeout(flush, delayMs), runChild),
     };
 }
-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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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/detach/types.d.ts

@@ -1,8 +1,7 @@
 /**
  * detach/types.ts — Type definitions for the fire-and-forget primitive.
  *
- * Pattern:  Strategy + Bridge (GoF). Same shape as cache strategies in
- *           agentfootprint v2.6 — ONE interface, N concrete drivers,
+ * Pattern:  One strategy interface, concrete scheduling drivers,
  *           consumer picks via explicit import.
  * Role:     Foundation. Every other detach file imports from here.
  *           This is the lockable contract; downstream files implement it.
@@ -17,20 +16,19 @@
  *
  *   2. `DetachHandle` — the consumer-facing handle returned by
  *      `detachAndJoinLater`. Exposes status as PROPERTIES (sync read)
- *      and `wait()` (Promise — opt-in async join). Style 2 from the
- *      panel review: properties for sync, single method for async.
+ *      and `wait()` (Promise — opt-in async join).
  *
  * Naming policy (locked from naming review):
  *   - Public API uses simple verbs / properties (product-engineer friendly)
  *   - Internal class names CAN use CS terms (Scheduler, Continuation, etc.)
  *   - Drivers are algorithm-named (semantic at the algorithm level)
  *
- * Locked design decisions (panel review captured in
- * `docs/inspiration/detach-primitive.md`):
- *   - Sync hot path; async only at flush boundaries
- *   - Errors → commitLog + typed event, NEVER thrown to parent
- *   - Scope isolation between parent and detached child
- *   - Lifecycle tied to executor disposal
+ * Current lifecycle contract:
+ *   - Return a handle synchronously; the selected driver owns dispatch
+ *   - Scheduling/child errors → failed handle, never thrown to parent
+ *   - `runChild.ts · defaultRunChild` uses an isolated child executor
+ *   - `registry.ts` tracks in-flight handles for `flushAllDetached`
+ *   - No automatic commit-log event or executor-disposal integration
  *   - Type-level rejection of `outputMapper` on detach options
  */
 import type { FlowChart } from '../builder/types.js';
@@ -72,7 +70,8 @@ export interface DetachWaitResult {
  *   failed  → terminal: error available
  *
  * `done` and `failed` are TERMINAL — once reached, status never
- * changes again.
+ * changes again. A scheduling refusal can go straight from `queued`
+ * to `failed`, without starting the child.
  */
 export interface DetachHandle {
     /** Stable id assigned at detach time. Used as the lookup key in
@@ -150,8 +149,9 @@ export interface DriverCapabilities {
  *     never waits for the driver's deferred work to complete
  *
  * Drivers MAY:
- *   - Implement `validate()` for one-time configuration checks at
- *     registration / use time (e.g., assert `navigator.sendBeacon` exists)
+ *   - Implement `validate()` for explicit caller-controlled preflight
+ *     checks (e.g., assert `navigator.sendBeacon` exists). Scheduling
+ *     must still contain failures when preflight was not requested.
  *   - Build their internal pipeline as a footprintjs flowChart for
  *     observability — driver implementation detail, not consumer-facing
  *
@@ -184,17 +184,14 @@ export interface DetachDriver {
      */
     schedule(child: FlowChart, input: unknown, refId: string): DetachHandle;
     /**
-     * Optional one-time validation hook. Called at first use (or
-     * registration time, depending on driver) — drivers throw if their
-     * configuration is invalid (missing peer dep, unreachable endpoint,
-     * wrong API key shape, etc.).
+     * Optional preflight hook, invoked explicitly by the caller, never
+     * automatically by the detach entry points. It may throw if the
+     * configuration is invalid. `schedule()` must independently report
+     * scheduling failures through its handle, even without preflight.
      *
      * Example: `sendBeaconDriver.validate()` checks
      * `typeof navigator?.sendBeacon === 'function'` and throws with a
      * helpful message if absent (e.g., in Node).
-     *
-     * Per the New Relic panel review: early-fail-with-useful-message
-     * beats silent zero-emission.
      */
     validate?(): void;
 }