footprintjs 9.32.0 → 9.34.0

package/dist/esm/lib/capture/freeze.d.ts

@@ -0,0 +1,47 @@
+/**
+ * freeze.ts — the ONE deep-freeze walk (moved here from `scope/protection/readonlyInput.ts` in F3).
+ *
+ * WHY HERE. Five places freeze a tree, all through this walk: run args (`readonlyInput ·
+ * createFrozenArgs`), the fold base served as `initialState` (`ExecutionRuntime · getFoldBase`), the
+ * dev-mode snapshot (`FlowChartExecutor · getSnapshot`), every state `stateAt` hands out
+ * (`time-travel/stateAt.ts`) and, since F3, every commit bundle (`EventLog · record`). `memory/` must
+ * not import `scope/` (that edge closed the memory ⇄ scope ⇄ recorder module cycle F0 removed), so the
+ * walk lives in this leaf, which imports nothing.
+ *
+ * @example
+ * ```typescript
+ * import { deepFreeze } from './freeze.js';
+ *
+ * const args = deepFreeze({ order: { lines: [{ sku: 'A' }] }, bytes: new Uint8Array([1]) });
+ * Object.isFrozen(args.order.lines[0]); // true
+ * Object.isFrozen(args.bytes); // false — a typed array cannot be frozen; it is skipped
+ * ```
+ */
+/**
+ * How {@link deepFreeze} walks an ARRAY.
+ *
+ * - `'every-key'` (the default) — every own property, as for any other object: the index elements
+ *   AND any expando (`arr.note = { … }`). The contract args protection and the dev-mode snapshot
+ *   rely on.
+ * - `'indices'` — the index elements only, so no key string is allocated per element; this is what
+ *   keeps freezing a 10,000-element commit inside its budget (`bench/element-writes.ts`). An object
+ *   hung on an array EXPANDO is then left unfrozen — the commit log's named hole
+ *   (`EventLog · record`).
+ */
+export type ArrayWalk = 'every-key' | 'indices';
+/**
+ * Freezes `obj` and every object reachable through its own properties, and returns `obj`.
+ *
+ * - An object that is ALREADY frozen is left as it is, and not descended — 9.32.0's contract, kept:
+ *   args may hold a caller's frozen object with live parts inside (a class instance a stage calls),
+ *   and freezing past it would break them. It is also what ends a cycle. The commit log never meets
+ *   one: its payloads are fresh `structuredClone`s.
+ * - ArrayBuffer views (typed arrays, `DataView`) are skipped: `Object.freeze` throws on a non-empty
+ *   typed array, so a `Uint8Array` in state, args or the fold base used to fail the run or the
+ *   snapshot here.
+ * - What `Object.freeze` cannot reach stays mutable — Map and Set contents, a Date's time, the
+ *   bytes behind a buffer. A frozen RegExp's `lastIndex` is read-only, so a `/g` or `/y` regex
+ *   taken from a frozen tree throws when `exec` or `replace` advance it.
+ * - Functions are not descended (they are not values the engine stores).
+ */
+export declare function deepFreeze<T>(obj: T, arrays?: ArrayWalk): T;

package/dist/esm/lib/capture/freeze.js

@@ -0,0 +1,60 @@
+/**
+ * freeze.ts — the ONE deep-freeze walk (moved here from `scope/protection/readonlyInput.ts` in F3).
+ *
+ * WHY HERE. Five places freeze a tree, all through this walk: run args (`readonlyInput ·
+ * createFrozenArgs`), the fold base served as `initialState` (`ExecutionRuntime · getFoldBase`), the
+ * dev-mode snapshot (`FlowChartExecutor · getSnapshot`), every state `stateAt` hands out
+ * (`time-travel/stateAt.ts`) and, since F3, every commit bundle (`EventLog · record`). `memory/` must
+ * not import `scope/` (that edge closed the memory ⇄ scope ⇄ recorder module cycle F0 removed), so the
+ * walk lives in this leaf, which imports nothing.
+ *
+ * @example
+ * ```typescript
+ * import { deepFreeze } from './freeze.js';
+ *
+ * const args = deepFreeze({ order: { lines: [{ sku: 'A' }] }, bytes: new Uint8Array([1]) });
+ * Object.isFrozen(args.order.lines[0]); // true
+ * Object.isFrozen(args.bytes); // false — a typed array cannot be frozen; it is skipped
+ * ```
+ */
+/**
+ * Freezes `obj` and every object reachable through its own properties, and returns `obj`.
+ *
+ * - An object that is ALREADY frozen is left as it is, and not descended — 9.32.0's contract, kept:
+ *   args may hold a caller's frozen object with live parts inside (a class instance a stage calls),
+ *   and freezing past it would break them. It is also what ends a cycle. The commit log never meets
+ *   one: its payloads are fresh `structuredClone`s.
+ * - ArrayBuffer views (typed arrays, `DataView`) are skipped: `Object.freeze` throws on a non-empty
+ *   typed array, so a `Uint8Array` in state, args or the fold base used to fail the run or the
+ *   snapshot here.
+ * - What `Object.freeze` cannot reach stays mutable — Map and Set contents, a Date's time, the
+ *   bytes behind a buffer. A frozen RegExp's `lastIndex` is read-only, so a `/g` or `/y` regex
+ *   taken from a frozen tree throws when `exec` or `replace` advance it.
+ * - Functions are not descended (they are not values the engine stores).
+ */
+export function deepFreeze(obj, arrays = 'every-key') {
+    freezeValue(obj, arrays === 'indices');
+    return obj;
+}
+function freezeValue(value, indices) {
+    if (value === null || typeof value !== 'object' || ArrayBuffer.isView(value) || Object.isFrozen(value))
+        return;
+    Object.freeze(value);
+    // The two loops are written out rather than shared through a callback: this runs once per object of
+    // every commit, and a closure per object is measurable.
+    if (indices && Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+            const child = value[i];
+            if (child !== null && typeof child === 'object')
+                freezeValue(child, indices);
+        }
+        return;
+    }
+    const names = Object.getOwnPropertyNames(value);
+    for (let i = 0; i < names.length; i++) {
+        const child = value[names[i]];
+        if (child !== null && typeof child === 'object')
+            freezeValue(child, indices);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/capture/index.d.ts

@@ -16,6 +16,7 @@
  * module — see the mapping notes in `policies.ts`.
  */
 export { hasCircularReference } from './circular.js';
+export { type ArrayWalk, deepFreeze } from './freeze.js';
 export { invokeRecorderHook } from './invokeHook.js';
 export type { RetentionPolicy } from './policies.js';
 export type { ReadSummaryMarker, SummaryValueType, WriteSummaryMarker } from './summarize.js';

package/dist/esm/lib/capture/index.js

@@ -17,6 +17,7 @@
  * module — see the mapping notes in `policies.ts`.
  */
 export { hasCircularReference } from './circular.js';
+export { deepFreeze } from './freeze.js';
 export { invokeRecorderHook } from './invokeHook.js';
 export { READ_PREVIEW_LENGTH, summarizeReadValue, summarizeValue, summarizeWriteValue, SUMMARY_PREVIEW_LENGTH, } from './summarize.js';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,32 +1,33 @@
 /**
- * detach/drivers/immediate.ts — Run detached work synchronously inside `schedule()`.
+ * detach/drivers/immediate.ts — Start detached work at once: no batch, no timer.
  *
- * Pattern:  Null-object driver for the "no actual deferral" case. Same
- *           intent as a `setTimeout(fn, 0)` shim that just calls `fn()`
- *           — keeps the API surface uniform so consumers can swap drivers
- *           without changing call sites.
- * Role:     Test fixture + opt-in for consumers who want fire-and-forget
- *           ergonomics (the handle API) without actually deferring. Useful
- *           for:
+ * Pattern:  The thinnest driver. `schedule()` registers the handle, marks it
+ *           `running` SYNCHRONOUSLY and starts `runChild` on the next
+ *           microtask (`Promise.resolve().then(...)`) — one microtask per
+ *           call, nothing shared with other calls. It keeps the API surface
+ *           uniform so consumers can swap drivers without changing call sites.
+ * Role:     Test fixture + opt-in for consumers who want the handle API
+ *           without a queue to flush. Useful for:
  *
- *             - unit tests where deterministic, synchronous completion
- *               beats microtask gymnastics
- *             - very small detach payloads where the overhead of a
- *               microtask roundtrip exceeds the work itself
- *             - debugging — easier to step through with breakpoints
+ *             - unit tests where a handle that reads `running` the moment
+ *               `schedule()` returns beats waiting for a batch flush
+ *             - very small detach payloads where batching buys nothing
+ *             - debugging — fewer moving parts to step through
  *
- * Performance:
- *   - Sync runChild → handle becomes terminal before `schedule()` returns
- *   - Async runChild → handle marks running sync, terminal at runChild's
- *     resolution. The `wait()` Promise is the same one consumers use for
- *     any other driver; behaviour is uniform.
+ * What is synchronous, and what is not (test/lib/detach/immediate.test.ts, P1, pins the `running` status):
+ *   - SYNC:  the registry entry exists and `_markRunning()` has run before
+ *            `schedule()` returns, so the handle reads `running`.
+ *   - LATER: `runChild` is called on the next microtask EVEN when it is a
+ *            sync function, and the handle becomes terminal only after the
+ *            returned promise settles. The `wait()` Promise is the same one
+ *            consumers use for any other driver; behaviour is uniform.
  *
- * Caveat — this is NOT a passive-recorder by default:
- *   When runChild is sync, the parent stage observes the work's side
- *   effects WITHIN its own slice. That's intentional for the test/debug
- *   use case but means consumers should NOT use `immediateDriver` for
- *   long-running work in production hot paths — pick `microtaskBatchDriver`
- *   for that.
+ * Caveat — this does NOT run the work inside the parent's slice:
+ *   The child starts once the parent's current synchronous code has
+ *   finished, but it is neither batched nor deferred beyond that one
+ *   microtask, so it can interleave with the parent's next `await`. For
+ *   work that should leave the hot path as a single batch, pick
+ *   `microtaskBatchDriver`.
  */
 import { type ChildRunner } from '../runChild.js';
 import type { DetachDriver } from '../types.js';

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

@@ -1,32 +1,33 @@
 /**
- * detach/drivers/immediate.ts — Run detached work synchronously inside `schedule()`.
+ * detach/drivers/immediate.ts — Start detached work at once: no batch, no timer.
  *
- * Pattern:  Null-object driver for the "no actual deferral" case. Same
- *           intent as a `setTimeout(fn, 0)` shim that just calls `fn()`
- *           — keeps the API surface uniform so consumers can swap drivers
- *           without changing call sites.
- * Role:     Test fixture + opt-in for consumers who want fire-and-forget
- *           ergonomics (the handle API) without actually deferring. Useful
- *           for:
+ * Pattern:  The thinnest driver. `schedule()` registers the handle, marks it
+ *           `running` SYNCHRONOUSLY and starts `runChild` on the next
+ *           microtask (`Promise.resolve().then(...)`) — one microtask per
+ *           call, nothing shared with other calls. It keeps the API surface
+ *           uniform so consumers can swap drivers without changing call sites.
+ * Role:     Test fixture + opt-in for consumers who want the handle API
+ *           without a queue to flush. Useful for:
  *
- *             - unit tests where deterministic, synchronous completion
- *               beats microtask gymnastics
- *             - very small detach payloads where the overhead of a
- *               microtask roundtrip exceeds the work itself
- *             - debugging — easier to step through with breakpoints
+ *             - unit tests where a handle that reads `running` the moment
+ *               `schedule()` returns beats waiting for a batch flush
+ *             - very small detach payloads where batching buys nothing
+ *             - debugging — fewer moving parts to step through
  *
- * Performance:
- *   - Sync runChild → handle becomes terminal before `schedule()` returns
- *   - Async runChild → handle marks running sync, terminal at runChild's
- *     resolution. The `wait()` Promise is the same one consumers use for
- *     any other driver; behaviour is uniform.
+ * What is synchronous, and what is not (test/lib/detach/immediate.test.ts, P1, pins the `running` status):
+ *   - SYNC:  the registry entry exists and `_markRunning()` has run before
+ *            `schedule()` returns, so the handle reads `running`.
+ *   - LATER: `runChild` is called on the next microtask EVEN when it is a
+ *            sync function, and the handle becomes terminal only after the
+ *            returned promise settles. The `wait()` Promise is the same one
+ *            consumers use for any other driver; behaviour is uniform.
  *
- * Caveat — this is NOT a passive-recorder by default:
- *   When runChild is sync, the parent stage observes the work's side
- *   effects WITHIN its own slice. That's intentional for the test/debug
- *   use case but means consumers should NOT use `immediateDriver` for
- *   long-running work in production hot paths — pick `microtaskBatchDriver`
- *   for that.
+ * Caveat — this does NOT run the work inside the parent's slice:
+ *   The child starts once the parent's current synchronous code has
+ *   finished, but it is neither batched nor deferred beyond that one
+ *   microtask, so it can interleave with the parent's next `await`. For
+ *   work that should leave the hot path as a single batch, pick
+ *   `microtaskBatchDriver`.
  */
 import { asImpl, createHandle } from '../handle.js';
 import { register, unregister } from '../registry.js';
@@ -63,4 +64,4 @@ export function createImmediateDriver(runChild = defaultRunChild) {
 }
 /** Default singleton — most consumers use this. */
 export const immediateDriver = createImmediateDriver();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW1tZWRpYXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2xpYi9kZXRhY2gvZHJpdmVycy9pbW1lZGlhdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQThCRztBQUdILE9BQU8sRUFBRSxNQUFNLEVBQUUsWUFBWSxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBQ3BELE9BQU8sRUFBRSxRQUFRLEVBQUUsVUFBVSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDdEQsT0FBTyxFQUFvQixlQUFlLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUduRTs7O0dBR0c7QUFDSCxNQUFNLFVBQVUscUJBQXFCLENBQUMsV0FBd0IsZUFBZTtJQUMzRSxPQUFPO1FBQ0wsSUFBSSxFQUFFLFdBQVc7UUFDakIsWUFBWSxFQUFFLEVBQUUsV0FBVyxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRSxJQUFJLEVBQUU7UUFDbkUsUUFBUSxDQUFDLEtBQWdCLEVBQUUsS0FBYyxFQUFFLEtBQWE7WUFDdEQsTUFBTSxNQUFNLEdBQUcsWUFBWSxDQUFDLEtBQUssQ0FBQyxDQUFDO1lBQ25DLFFBQVEsQ0FBQyxNQUFNLENBQUMsQ0FBQztZQUNqQixNQUFNLElBQUksR0FBRyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUM7WUFDNUIsSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDO1lBQ3BCLGlFQUFpRTtZQUNqRSxpRUFBaUU7WUFDakUsa0VBQWtFO1lBQ2xFLGlFQUFpRTtZQUNqRSxPQUFPLENBQUMsT0FBTyxFQUFFO2lCQUNkLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQyxRQUFRLENBQUMsS0FBSyxFQUFFLEtBQUssQ0FBQyxDQUFDO2lCQUNsQyxJQUFJLENBQ0gsQ0FBQyxNQUFNLEVBQUUsRUFBRTtnQkFDVCxJQUFJLENBQUMsU0FBUyxDQUFDLE1BQU0sQ0FBQyxDQUFDO2dCQUN2QixVQUFVLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxDQUFDO1lBQ3RCLENBQUMsRUFDRCxDQUFDLEdBQVksRUFBRSxFQUFFO2dCQUNmLElBQUksQ0FBQyxXQUFXLENBQUMsR0FBRyxZQUFZLEtBQUssQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxJQUFJLEtBQUssQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDO2dCQUN0RSxVQUFVLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxDQUFDO1lBQ3RCLENBQUMsQ0FDRixDQUFDO1lBQ0osT0FBTyxNQUFNLENBQUM7UUFDaEIsQ0FBQztLQUNGLENBQUM7QUFDSixDQUFDO0FBRUQsbURBQW1EO0FBQ25ELE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBaUIscUJBQXFCLEVBQUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogZGV0YWNoL2RyaXZlcnMvaW1tZWRpYXRlLnRzIOKAlCBTdGFydCBkZXRhY2hlZCB3b3JrIGF0IG9uY2U6IG5vIGJhdGNoLCBubyB0aW1lci5cbiAqXG4gKiBQYXR0ZXJuOiAgVGhlIHRoaW5uZXN0IGRyaXZlci4gYHNjaGVkdWxlKClgIHJlZ2lzdGVycyB0aGUgaGFuZGxlLCBtYXJrcyBpdFxuICogICAgICAgICAgIGBydW5uaW5nYCBTWU5DSFJPTk9VU0xZIGFuZCBzdGFydHMgYHJ1bkNoaWxkYCBvbiB0aGUgbmV4dFxuICogICAgICAgICAgIG1pY3JvdGFzayAoYFByb21pc2UucmVzb2x2ZSgpLnRoZW4oLi4uKWApIOKAlCBvbmUgbWljcm90YXNrIHBlclxuICogICAgICAgICAgIGNhbGwsIG5vdGhpbmcgc2hhcmVkIHdpdGggb3RoZXIgY2FsbHMuIEl0IGtlZXBzIHRoZSBBUEkgc3VyZmFjZVxuICogICAgICAgICAgIHVuaWZvcm0gc28gY29uc3VtZXJzIGNhbiBzd2FwIGRyaXZlcnMgd2l0aG91dCBjaGFuZ2luZyBjYWxsIHNpdGVzLlxuICogUm9sZTogICAgIFRlc3QgZml4dHVyZSArIG9wdC1pbiBmb3IgY29uc3VtZXJzIHdobyB3YW50IHRoZSBoYW5kbGUgQVBJXG4gKiAgICAgICAgICAgd2l0aG91dCBhIHF1ZXVlIHRvIGZsdXNoLiBVc2VmdWwgZm9yOlxuICpcbiAqICAgICAgICAgICAgIC0gdW5pdCB0ZXN0cyB3aGVyZSBhIGhhbmRsZSB0aGF0IHJlYWRzIGBydW5uaW5nYCB0aGUgbW9tZW50XG4gKiAgICAgICAgICAgICAgIGBzY2hlZHVsZSgpYCByZXR1cm5zIGJlYXRzIHdhaXRpbmcgZm9yIGEgYmF0Y2ggZmx1c2hcbiAqICAgICAgICAgICAgIC0gdmVyeSBzbWFsbCBkZXRhY2ggcGF5bG9hZHMgd2hlcmUgYmF0Y2hpbmcgYnV5cyBub3RoaW5nXG4gKiAgICAgICAgICAgICAtIGRlYnVnZ2luZyDigJQgZmV3ZXIgbW92aW5nIHBhcnRzIHRvIHN0ZXAgdGhyb3VnaFxuICpcbiAqIFdoYXQgaXMgc3luY2hyb25vdXMsIGFuZCB3aGF0IGlzIG5vdCAodGVzdC9saWIvZGV0YWNoL2ltbWVkaWF0ZS50ZXN0LnRzLCBQMSwgcGlucyB0aGUgYHJ1bm5pbmdgIHN0YXR1cyk6XG4gKiAgIC0gU1lOQzogIHRoZSByZWdpc3RyeSBlbnRyeSBleGlzdHMgYW5kIGBfbWFya1J1bm5pbmcoKWAgaGFzIHJ1biBiZWZvcmVcbiAqICAgICAgICAgICAgYHNjaGVkdWxlKClgIHJldHVybnMsIHNvIHRoZSBoYW5kbGUgcmVhZHMgYHJ1bm5pbmdgLlxuICogICAtIExBVEVSOiBgcnVuQ2hpbGRgIGlzIGNhbGxlZCBvbiB0aGUgbmV4dCBtaWNyb3Rhc2sgRVZFTiB3aGVuIGl0IGlzIGFcbiAqICAgICAgICAgICAgc3luYyBmdW5jdGlvbiwgYW5kIHRoZSBoYW5kbGUgYmVjb21lcyB0ZXJtaW5hbCBvbmx5IGFmdGVyIHRoZVxuICogICAgICAgICAgICByZXR1cm5lZCBwcm9taXNlIHNldHRsZXMuIFRoZSBgd2FpdCgpYCBQcm9taXNlIGlzIHRoZSBzYW1lIG9uZVxuICogICAgICAgICAgICBjb25zdW1lcnMgdXNlIGZvciBhbnkgb3RoZXIgZHJpdmVyOyBiZWhhdmlvdXIgaXMgdW5pZm9ybS5cbiAqXG4gKiBDYXZlYXQg4oCUIHRoaXMgZG9lcyBOT1QgcnVuIHRoZSB3b3JrIGluc2lkZSB0aGUgcGFyZW50J3Mgc2xpY2U6XG4gKiAgIFRoZSBjaGlsZCBzdGFydHMgb25jZSB0aGUgcGFyZW50J3MgY3VycmVudCBzeW5jaHJvbm91cyBjb2RlIGhhc1xuICogICBmaW5pc2hlZCwgYnV0IGl0IGlzIG5laXRoZXIgYmF0Y2hlZCBub3IgZGVmZXJyZWQgYmV5b25kIHRoYXQgb25lXG4gKiAgIG1pY3JvdGFzaywgc28gaXQgY2FuIGludGVybGVhdmUgd2l0aCB0aGUgcGFyZW50J3MgbmV4dCBgYXdhaXRgLiBGb3JcbiAqICAgd29yayB0aGF0IHNob3VsZCBsZWF2ZSB0aGUgaG90IHBhdGggYXMgYSBzaW5nbGUgYmF0Y2gsIHBpY2tcbiAqICAgYG1pY3JvdGFza0JhdGNoRHJpdmVyYC5cbiAqL1xuXG5pbXBvcnQgdHlwZSB7IEZsb3dDaGFydCB9IGZyb20gJy4uLy4uL2J1aWxkZXIvdHlwZXMuanMnO1xuaW1wb3J0IHsgYXNJbXBsLCBjcmVhdGVIYW5kbGUgfSBmcm9tICcuLi9oYW5kbGUuanMnO1xuaW1wb3J0IHsgcmVnaXN0ZXIsIHVucmVnaXN0ZXIgfSBmcm9tICcuLi9yZWdpc3RyeS5qcyc7XG5pbXBvcnQgeyB0eXBlIENoaWxkUnVubmVyLCBkZWZhdWx0UnVuQ2hpbGQgfSBmcm9tICcuLi9ydW5DaGlsZC5qcyc7XG5pbXBvcnQgdHlwZSB7IERldGFjaERyaXZlciwgRGV0YWNoSGFuZGxlIH0gZnJvbSAnLi4vdHlwZXMuanMnO1xuXG4vKipcbiAqIEJ1aWxkIGFuIGltbWVkaWF0ZSBkcml2ZXIgd2lyZWQgdG8gYSBjdXN0b20gY2hpbGQgcnVubmVyLiBNb3N0XG4gKiBjb25zdW1lcnMgd2FudCB0aGUgZGVmYXVsdCBzaW5nbGV0b24gYGltbWVkaWF0ZURyaXZlcmAuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjcmVhdGVJbW1lZGlhdGVEcml2ZXIocnVuQ2hpbGQ6IENoaWxkUnVubmVyID0gZGVmYXVsdFJ1bkNoaWxkKTogRGV0YWNoRHJpdmVyIHtcbiAgcmV0dXJuIHtcbiAgICBuYW1lOiAnaW1tZWRpYXRlJyxcbiAgICBjYXBhYmlsaXRpZXM6IHsgYnJvd3NlclNhZmU6IHRydWUsIG5vZGVTYWZlOiB0cnVlLCBlZGdlU2FmZTogdHJ1ZSB9LFxuICAgIHNjaGVkdWxlKGNoaWxkOiBGbG93Q2hhcnQsIGlucHV0OiB1bmtub3duLCByZWZJZDogc3RyaW5nKTogRGV0YWNoSGFuZGxlIHtcbiAgICAgIGNvbnN0IGhhbmRsZSA9IGNyZWF0ZUhhbmRsZShyZWZJZCk7XG4gICAgICByZWdpc3RlcihoYW5kbGUpO1xuICAgICAgY29uc3QgaW1wbCA9IGFzSW1wbChoYW5kbGUpO1xuICAgICAgaW1wbC5fbWFya1J1bm5pbmcoKTtcbiAgICAgIC8vIERvbid0IGF3YWl0IGhlcmUg4oCUIGRyaXZlciBzY2hlZHVsZSgpIG11c3QgcmV0dXJuIHN5bmNocm9ub3VzbHlcbiAgICAgIC8vIChwYXNzaXZlIHJlY29yZGVyIHJ1bGUpLiBUaGUgUHJvbWlzZSBmcm9tIHJ1bkNoaWxkIGhhbmRsZXMgdGhlXG4gICAgICAvLyByZXN0OyBpZiBpdCdzIGFscmVhZHktcmVzb2x2ZWQgKHN5bmMgcnVubmVyKSwgdGhlIC50aGVuIHJ1bnMgb25cbiAgICAgIC8vIHRoZSBuZXh0IG1pY3JvdGFzayBidXQgdGhlIHNjaGVkdWxlKCkgY2FsbCBzdGlsbCByZXR1cm5zIHN5bmMuXG4gICAgICBQcm9taXNlLnJlc29sdmUoKVxuICAgICAgICAudGhlbigoKSA9PiBydW5DaGlsZChjaGlsZCwgaW5wdXQpKVxuICAgICAgICAudGhlbihcbiAgICAgICAgICAocmVzdWx0KSA9PiB7XG4gICAgICAgICAgICBpbXBsLl9tYXJrRG9uZShyZXN1bHQpO1xuICAgICAgICAgICAgdW5yZWdpc3RlcihpbXBsLmlkKTtcbiAgICAgICAgICB9LFxuICAgICAgICAgIChlcnI6IHVua25vd24pID0+IHtcbiAgICAgICAgICAgIGltcGwuX21hcmtGYWlsZWQoZXJyIGluc3RhbmNlb2YgRXJyb3IgPyBlcnIgOiBuZXcgRXJyb3IoU3RyaW5nKGVycikpKTtcbiAgICAgICAgICAgIHVucmVnaXN0ZXIoaW1wbC5pZCk7XG4gICAgICAgICAgfSxcbiAgICAgICAgKTtcbiAgICAgIHJldHVybiBoYW5kbGU7XG4gICAgfSxcbiAgfTtcbn1cblxuLyoqIERlZmF1bHQgc2luZ2xldG9uIOKAlCBtb3N0IGNvbnN1bWVycyB1c2UgdGhpcy4gKi9cbmV4cG9ydCBjb25zdCBpbW1lZGlhdGVEcml2ZXI6IERldGFjaERyaXZlciA9IGNyZWF0ZUltbWVkaWF0ZURyaXZlcigpO1xuIl19

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

@@ -5,7 +5,8 @@
  *           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
+ * 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
@@ -50,8 +51,8 @@ import type { DetachDriver } from '../types.js';
  */
 export declare function createMicrotaskBatchDriver(runChild?: ChildRunner): DetachDriver;
 /**
- * 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).
+ * 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 declare const microtaskBatchDriver: DetachDriver;

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

@@ -5,7 +5,8 @@
  *           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
+ * 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
@@ -105,9 +106,9 @@ async function executeOne(item, runChild) {
     }
 }
 /**
- * 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).
+ * 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"]}
+//# 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"]}