footprintjs 9.32.0 → 9.33.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,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

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"]}

package/dist/esm/lib/memory/EventLog.d.ts

@@ -2,7 +2,22 @@
  * EventLog — Time-travel snapshot storage for flowchart execution
  *
  * Like git history: stores commit bundles (diffs), not full snapshots.
- * materialise(stepIdx) reconstructs state at any point by replaying commits.
+ *
+ * THE RECORD IS IMMUTABLE FROM `record` (F3, ruling R3). Every bundle is deep-frozen as it is
+ * recorded — the bundle, `overwrite` and `updates` at every depth, the trace and each row, the
+ * row's `readKeys`, `redactedPaths`, `tags`, `untrackedSources` — so a holder of a snapshot can no
+ * longer rewrite the history every later answer is folded from: an assignment into a bundle throws
+ * a `TypeError` in strict code. Safe because nothing outside the log holds a bundle's containers:
+ * the log's payload is the commit's own copy (`StageContext · commit` hands it the output of
+ * `scrubPatch`), and live state, the redacted mirror and write retention each take their own copy
+ * (`verbs.ts · foldRows` detaches, `StageContext · retainedForm` clones) — pinned by
+ * test/lib/memory/property/record-reachability.property.test.ts.
+ *
+ * Named holes — what `Object.freeze` cannot reach stays mutable: Map and Set contents, a Date's
+ * time, the bytes of a typed array (skipped: a non-empty one cannot be frozen), and an object hung
+ * on an array EXPANDO (arrays are walked by index — `deepFreeze`'s `'indices'` walk, which keeps
+ * the freeze inside its budget). A frozen RegExp's `lastIndex` is read-only, so a `/g` or `/y`
+ * regex read from a bundle throws when `exec` or `replace` advance it.
  */
 import type { CommitBundle } from './types.js';
 export declare class EventLog {
@@ -40,11 +55,21 @@ export declare class EventLog {
      * below the root, 9.29.0, so the fold and the live state agree at every
      * path). The result is the caller's: it shares nothing with the base or
      * the log.
+     *
+     * @deprecated Since 9.33.0 — use `stateAt` from `footprintjs/trace`, which folds the same log
+     * from the same base (`RuntimeSnapshot.initialState`) and says how it was derived (`basis`).
+     * Nothing in the library calls this; it stays for one minor and is then removed. Mind the
+     * index: `materialise(n)` folds commits `0..n-1`, `stateAt(source, n - 1)` the same commits.
      */
     materialise(stepIdx?: number): any;
-    /** Persists a commit bundle for a finished stage. */
+    /**
+     * Persists a commit bundle for a finished stage, and FREEZES it (see the module doc): the bundle
+     * is stamped with its position, then deep-frozen, then appended. The engine hands it a bundle
+     * built for the log alone; a caller of this class (`footprintjs/advanced`) hands over a bundle it
+     * will no longer edit — its own object is the one frozen.
+     */
     record(bundle: CommitBundle): void;
-    /** Gets all recorded commit bundles. */
+    /** Gets all recorded commit bundles — the live array; every bundle in it is frozen. */
     list(): CommitBundle[];
     /** Number of recorded commits. */
     get length(): number;

package/dist/esm/lib/memory/EventLog.js

@@ -2,8 +2,24 @@
  * EventLog — Time-travel snapshot storage for flowchart execution
  *
  * Like git history: stores commit bundles (diffs), not full snapshots.
- * materialise(stepIdx) reconstructs state at any point by replaying commits.
+ *
+ * THE RECORD IS IMMUTABLE FROM `record` (F3, ruling R3). Every bundle is deep-frozen as it is
+ * recorded — the bundle, `overwrite` and `updates` at every depth, the trace and each row, the
+ * row's `readKeys`, `redactedPaths`, `tags`, `untrackedSources` — so a holder of a snapshot can no
+ * longer rewrite the history every later answer is folded from: an assignment into a bundle throws
+ * a `TypeError` in strict code. Safe because nothing outside the log holds a bundle's containers:
+ * the log's payload is the commit's own copy (`StageContext · commit` hands it the output of
+ * `scrubPatch`), and live state, the redacted mirror and write retention each take their own copy
+ * (`verbs.ts · foldRows` detaches, `StageContext · retainedForm` clones) — pinned by
+ * test/lib/memory/property/record-reachability.property.test.ts.
+ *
+ * Named holes — what `Object.freeze` cannot reach stays mutable: Map and Set contents, a Date's
+ * time, the bytes of a typed array (skipped: a non-empty one cannot be frozen), and an object hung
+ * on an array EXPANDO (arrays are walked by index — `deepFreeze`'s `'indices'` walk, which keeps
+ * the freeze inside its budget). A frozen RegExp's `lastIndex` is read-only, so a `/g` or `/y`
+ * regex read from a bundle throws when `exec` or `replace` advance it.
  */
+import { deepFreeze } from '../capture/freeze.js';
 import { applySmartMergeInto } from './utils.js';
 export class EventLog {
     /** Base snapshot BEFORE the first stage mutates anything. */
@@ -48,6 +64,11 @@ export class EventLog {
      * below the root, 9.29.0, so the fold and the live state agree at every
      * path). The result is the caller's: it shares nothing with the base or
      * the log.
+     *
+     * @deprecated Since 9.33.0 — use `stateAt` from `footprintjs/trace`, which folds the same log
+     * from the same base (`RuntimeSnapshot.initialState`) and says how it was derived (`basis`).
+     * Nothing in the library calls this; it stays for one minor and is then removed. Mind the
+     * index: `materialise(n)` folds commits `0..n-1`, `stateAt(source, n - 1)` the same commits.
      */
     materialise(stepIdx = this.steps.length) {
         const out = structuredClone(this.base);
@@ -57,12 +78,18 @@ export class EventLog {
         }
         return out;
     }
-    /** Persists a commit bundle for a finished stage. */
+    /**
+     * Persists a commit bundle for a finished stage, and FREEZES it (see the module doc): the bundle
+     * is stamped with its position, then deep-frozen, then appended. The engine hands it a bundle
+     * built for the log alone; a caller of this class (`footprintjs/advanced`) hands over a bundle it
+     * will no longer edit — its own object is the one frozen.
+     */
     record(bundle) {
         bundle.idx = this.steps.length;
+        deepFreeze(bundle, 'indices');
         this.steps.push(bundle);
     }
-    /** Gets all recorded commit bundles. */
+    /** Gets all recorded commit bundles — the live array; every bundle in it is frozen. */
     list() {
         return this.steps;
     }
@@ -75,4 +102,4 @@ export class EventLog {
         this.steps = [];
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRXZlbnRMb2cuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL21lbW9yeS9FdmVudExvZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7R0FLRztBQUdILE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUVqRCxNQUFNLE9BQU8sUUFBUTtJQUNuQiw2REFBNkQ7SUFDckQsSUFBSSxDQUFNO0lBQ2xCLHNDQUFzQztJQUM5QixLQUFLLEdBQW1CLEVBQUUsQ0FBQztJQUVuQyxZQUFZLGFBQWtCO1FBQzVCLHVFQUF1RTtRQUN2RSxzRUFBc0U7UUFDdEUsc0VBQXNFO1FBQ3RFLCtDQUErQztRQUMvQyxJQUFJLENBQUMsSUFBSSxHQUFHLGFBQWEsS0FBSyxTQUFTLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsZUFBZSxDQUFDLGFBQWEsQ0FBQyxDQUFDO0lBQ2hGLENBQUM7SUFFRDs7Ozs7Ozs7Ozs7O09BWUc7SUFDSCxlQUFlO1FBQ2IsT0FBTyxlQUFlLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ3BDLENBQUM7SUFFRDs7Ozs7Ozs7Ozs7Ozs7O09BZUc7SUFDSCxXQUFXLENBQUMsT0FBTyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTTtRQUNyQyxNQUFNLEdBQUcsR0FBRyxlQUFlLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ3ZDLEtBQUssSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxPQUFPLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQztZQUNqQyxNQUFNLEVBQUUsU0FBUyxFQUFFLE9BQU8sRUFBRSxLQUFLLEVBQUUsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDO1lBQ3BELG1CQUFtQixDQUFDLEdBQUcsRUFBRSxPQUFzQixFQUFFLFNBQXdCLEVBQUUsS0FBSyxDQUFDLENBQUM7UUFDcEYsQ0FBQztRQUNELE9BQU8sR0FBRyxDQUFDO0lBQ2IsQ0FBQztJQUVELHFEQUFxRDtJQUNyRCxNQUFNLENBQUMsTUFBb0I7UUFDekIsTUFBTSxDQUFDLEdBQUcsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQztRQUMvQixJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUMxQixDQUFDO0lBRUQsd0NBQXdDO0lBQ3hDLElBQUk7UUFDRixPQUFPLElBQUksQ0FBQyxLQUFLLENBQUM7SUFDcEIsQ0FBQztJQUVELGtDQUFrQztJQUNsQyxJQUFJLE1BQU07UUFDUixPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDO0lBQzNCLENBQUM7SUFFRCw4Q0FBOEM7SUFDOUMsS0FBSztRQUNILElBQUksQ0FBQyxLQUFLLEdBQUcsRUFBRSxDQUFDO0lBQ2xCLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXZlbnRMb2cg4oCUIFRpbWUtdHJhdmVsIHNuYXBzaG90IHN0b3JhZ2UgZm9yIGZsb3djaGFydCBleGVjdXRpb25cbiAqXG4gKiBMaWtlIGdpdCBoaXN0b3J5OiBzdG9yZXMgY29tbWl0IGJ1bmRsZXMgKGRpZmZzKSwgbm90IGZ1bGwgc25hcHNob3RzLlxuICogbWF0ZXJpYWxpc2Uoc3RlcElkeCkgcmVjb25zdHJ1Y3RzIHN0YXRlIGF0IGFueSBwb2ludCBieSByZXBsYXlpbmcgY29tbWl0cy5cbiAqL1xuXG5pbXBvcnQgdHlwZSB7IENvbW1pdEJ1bmRsZSwgTWVtb3J5UGF0Y2ggfSBmcm9tICcuL3R5cGVzLmpzJztcbmltcG9ydCB7IGFwcGx5U21hcnRNZXJnZUludG8gfSBmcm9tICcuL3V0aWxzLmpzJztcblxuZXhwb3J0IGNsYXNzIEV2ZW50TG9nIHtcbiAgLyoqIEJhc2Ugc25hcHNob3QgQkVGT1JFIHRoZSBmaXJzdCBzdGFnZSBtdXRhdGVzIGFueXRoaW5nLiAqL1xuICBwcml2YXRlIGJhc2U6IGFueTtcbiAgLyoqIE9yZGVyZWQgbGlzdCBvZiBjb21taXQgYnVuZGxlcy4gKi9cbiAgcHJpdmF0ZSBzdGVwczogQ29tbWl0QnVuZGxlW10gPSBbXTtcblxuICBjb25zdHJ1Y3Rvcihpbml0aWFsTWVtb3J5OiBhbnkpIHtcbiAgICAvLyBOb3JtYWxpc2VkIHRvIGFuIG9iamVjdDogdGhlIGJhc2UgaXMgYSBTVEFURSwgYW5kIGV2ZXJ5IGZvbGQgb3ZlciBpdFxuICAgIC8vIChgbWF0ZXJpYWxpc2VgLCBgc3RhdGVBdGApIGFwcGxpZXMgcGF0aCB3cml0ZXMgdG8gaXQuIGB1bmRlZmluZWRgIOKAlFxuICAgIC8vIHdoYXQgYSBydW4gd2l0aCBubyBgaW5pdGlhbENvbnRleHRgIHVzZWQgdG8gc3RvcmUgaGVyZSDigJQgbWFkZSBldmVyeVxuICAgIC8vIG9uZSBvZiB0aG9zZSBmb2xkcyB0aHJvdyBvbiB0aGUgZmlyc3QgYHNldGAuXG4gICAgdGhpcy5iYXNlID0gaW5pdGlhbE1lbW9yeSA9PT0gdW5kZWZpbmVkID8ge30gOiBzdHJ1Y3R1cmVkQ2xvbmUoaW5pdGlhbE1lbW9yeSk7XG4gIH1cblxuICAvKipcbiAgICogVGhlIGZvbGQgQkFTRSDigJQgdGhlIHN0YXRlIGFzIGl0IHN0b29kIGJlZm9yZSB0aGUgZmlyc3QgY29tbWl0LlxuICAgKlxuICAgKiBUaGlzIGlzIHRoZSBvdGhlciBoYWxmIG9mIHRoZSBjb21taXQgbG9nOiBidW5kbGVzIGFyZSBESUZGUywgc28gYSBsb2dcbiAgICogYWxvbmUgY2Fubm90IHJlY29uc3RydWN0IHN0YXRlIHRoYXQgd2FzIHNlZWRlZCBiZWZvcmUgdGhlIHJ1biAoYW5cbiAgICogZXhlY3V0b3IgYGluaXRpYWxDb250ZXh0YCwgYGRlZmF1bHRWYWx1ZXNGb3JDb250ZXh0YCwgYSByZXN1bWUnc1xuICAgKiBgY2hlY2twb2ludC5zaGFyZWRTdGF0ZWAsIGEgc3ViZmxvdydzIGBpbnB1dE1hcHBlcmAgc2VlZCkuIFRyYXZlbGxpbmdcbiAgICogd2l0aCB0aGUgbG9nIOKAlCBgUnVudGltZVNuYXBzaG90LmluaXRpYWxTdGF0ZWAg4oCUIGlzIHdoYXQgbGV0cyBhbiBPRkZMSU5FXG4gICAqIGNvbnN1bWVyIGZvbGQ7IHdpdGhvdXQgaXQgdGhlIGhvbmVzdCBhbnN3ZXIgaXMgYSBwYXJ0aWFsIG9uZVxuICAgKiAoYHN0YXRlQXRgJ3MgYGJhc2lzOiAnbG9nLW9ubHknYCkuXG4gICAqXG4gICAqIFJldHVybnMgYSBmcmVzaCBkZXRhY2hlZCBjbG9uZSBvbiBldmVyeSBjYWxsIOKAlCB0aGUgY2FsbGVyIG93bnMgaXQuXG4gICAqL1xuICBnZXRJbml0aWFsU3RhdGUoKTogYW55IHtcbiAgICByZXR1cm4gc3RydWN0dXJlZENsb25lKHRoaXMuYmFzZSk7XG4gIH1cblxuICAvKipcbiAgICogUmVjb25zdHJ1Y3RzIHRoZSBmdWxsIHN0YXRlIGF0IGFueSBnaXZlbiBzdGVwLlxuICAgKiBSZXBsYXlzIGNvbW1pdHMgZnJvbSB0aGUgYmVnaW5uaW5nIOKAlCBPKG4pIGJ1dCBsb3cgbWVtb3J5IGZvb3RwcmludC5cbiAgICpcbiAgICogSU5ERVggQ09OVkVOVElPTiDigJQgYHN0ZXBJZHhgIGlzIEVYQ0xVU0lWRTogYG1hdGVyaWFsaXNlKDMpYCBmb2xkcyBjb21taXRzXG4gICAqIDAsIDEgYW5kIDIuIGBzdGF0ZUF0KHNvdXJjZSwgY29tbWl0SWR4KWAgKGZvb3RwcmludGpzL3RyYWNlKSBmb2xkcyB0aGVcbiAgICogc2FtZSBsb2cgYnV0IGl0cyBgY29tbWl0SWR4YCBpcyBJTkNMVVNJVkUsIGJlY2F1c2UgYSByZWFkZXIncyBjdXJzb3IgYXNrc1xuICAgKiBcInRoZSBzdGF0ZSBBVCB0aGlzIHN0b3BcIiwgd2hpY2ggbXVzdCBpbmNsdWRlIHRoYXQgc3RvcCdzIG93biBjb21taXQuIFR3b1xuICAgKiBmb2xkcyBvdmVyIG9uZSBsb2cgd2l0aCBvcHBvc2l0ZSBjb252ZW50aW9uczogY2hlY2sgd2hpY2ggb25lIHlvdSBob2xkLlxuICAgKlxuICAgKiBPbmUgY2xvbmUgb2YgdGhlIGJhc2UgcGVyIGNhbGwsIHRoZW4gZXZlcnkgYnVuZGxlIHJlcGxheWVkIElOVE8gdGhhdFxuICAgKiBwcml2YXRlIGNvcHkgKGBhcHBseVNtYXJ0TWVyZ2VJbnRvYCDigJQgdGhlIGxpdmUgY29tbWl0J3MgY29weS1vbi13cml0ZSBsYXdcbiAgICogYmVsb3cgdGhlIHJvb3QsIDkuMjkuMCwgc28gdGhlIGZvbGQgYW5kIHRoZSBsaXZlIHN0YXRlIGFncmVlIGF0IGV2ZXJ5XG4gICAqIHBhdGgpLiBUaGUgcmVzdWx0IGlzIHRoZSBjYWxsZXInczogaXQgc2hhcmVzIG5vdGhpbmcgd2l0aCB0aGUgYmFzZSBvclxuICAgKiB0aGUgbG9nLlxuICAgKi9cbiAgbWF0ZXJpYWxpc2Uoc3RlcElkeCA9IHRoaXMuc3RlcHMubGVuZ3RoKTogYW55IHtcbiAgICBjb25zdCBvdXQgPSBzdHJ1Y3R1cmVkQ2xvbmUodGhpcy5iYXNlKTtcbiAgICBmb3IgKGxldCBpID0gMDsgaSA8IHN0ZXBJZHg7IGkrKykge1xuICAgICAgY29uc3QgeyBvdmVyd3JpdGUsIHVwZGF0ZXMsIHRyYWNlIH0gPSB0aGlzLnN0ZXBzW2ldO1xuICAgICAgYXBwbHlTbWFydE1lcmdlSW50byhvdXQsIHVwZGF0ZXMgYXMgTWVtb3J5UGF0Y2gsIG92ZXJ3cml0ZSBhcyBNZW1vcnlQYXRjaCwgdHJhY2UpO1xuICAgIH1cbiAgICByZXR1cm4gb3V0O1xuICB9XG5cbiAgLyoqIFBlcnNpc3RzIGEgY29tbWl0IGJ1bmRsZSBmb3IgYSBmaW5pc2hlZCBzdGFnZS4gKi9cbiAgcmVjb3JkKGJ1bmRsZTogQ29tbWl0QnVuZGxlKTogdm9pZCB7XG4gICAgYnVuZGxlLmlkeCA9IHRoaXMuc3RlcHMubGVuZ3RoO1xuICAgIHRoaXMuc3RlcHMucHVzaChidW5kbGUpO1xuICB9XG5cbiAgLyoqIEdldHMgYWxsIHJlY29yZGVkIGNvbW1pdCBidW5kbGVzLiAqL1xuICBsaXN0KCk6IENvbW1pdEJ1bmRsZVtdIHtcbiAgICByZXR1cm4gdGhpcy5zdGVwcztcbiAgfVxuXG4gIC8qKiBOdW1iZXIgb2YgcmVjb3JkZWQgY29tbWl0cy4gKi9cbiAgZ2V0IGxlbmd0aCgpOiBudW1iZXIge1xuICAgIHJldHVybiB0aGlzLnN0ZXBzLmxlbmd0aDtcbiAgfVxuXG4gIC8qKiBXaXBlcyBoaXN0b3J5ICh1c2VmdWwgZm9yIHRlc3QgcmVzZXRzKS4gKi9cbiAgY2xlYXIoKTogdm9pZCB7XG4gICAgdGhpcy5zdGVwcyA9IFtdO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"EventLog.js","sourceRoot":"","sources":["../../../../src/lib/memory/EventLog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAElD,OAAO,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEjD,MAAM,OAAO,QAAQ;IACnB,6DAA6D;IACrD,IAAI,CAAM;IAClB,sCAAsC;IAC9B,KAAK,GAAmB,EAAE,CAAC;IAEnC,YAAY,aAAkB;QAC5B,uEAAuE;QACvE,sEAAsE;QACtE,sEAAsE;QACtE,+CAA+C;QAC/C,IAAI,CAAC,IAAI,GAAG,aAAa,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC;IAChF,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,eAAe;QACb,OAAO,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACpC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,WAAW,CAAC,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM;QACrC,MAAM,GAAG,GAAG,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACvC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC,EAAE,EAAE,CAAC;YACjC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACpD,mBAAmB,CAAC,GAAG,EAAE,OAAsB,EAAE,SAAwB,EAAE,KAAK,CAAC,CAAC;QACpF,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,MAAoB;QACzB,MAAM,CAAC,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;QAC/B,UAAU,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;QAC9B,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC1B,CAAC;IAED,uFAAuF;IACvF,IAAI;QACF,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED,kCAAkC;IAClC,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;IAC3B,CAAC;IAED,8CAA8C;IAC9C,KAAK;QACH,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;IAClB,CAAC;CACF","sourcesContent":["/**\n * EventLog — Time-travel snapshot storage for flowchart execution\n *\n * Like git history: stores commit bundles (diffs), not full snapshots.\n *\n * THE RECORD IS IMMUTABLE FROM `record` (F3, ruling R3). Every bundle is deep-frozen as it is\n * recorded — the bundle, `overwrite` and `updates` at every depth, the trace and each row, the\n * row's `readKeys`, `redactedPaths`, `tags`, `untrackedSources` — so a holder of a snapshot can no\n * longer rewrite the history every later answer is folded from: an assignment into a bundle throws\n * a `TypeError` in strict code. Safe because nothing outside the log holds a bundle's containers:\n * the log's payload is the commit's own copy (`StageContext · commit` hands it the output of\n * `scrubPatch`), and live state, the redacted mirror and write retention each take their own copy\n * (`verbs.ts · foldRows` detaches, `StageContext · retainedForm` clones) — pinned by\n * test/lib/memory/property/record-reachability.property.test.ts.\n *\n * Named holes — what `Object.freeze` cannot reach stays mutable: Map and Set contents, a Date's\n * time, the bytes of a typed array (skipped: a non-empty one cannot be frozen), and an object hung\n * on an array EXPANDO (arrays are walked by index — `deepFreeze`'s `'indices'` walk, which keeps\n * the freeze inside its budget). A frozen RegExp's `lastIndex` is read-only, so a `/g` or `/y`\n * regex read from a bundle throws when `exec` or `replace` advance it.\n */\n\nimport { deepFreeze } from '../capture/freeze.js';\nimport type { CommitBundle, MemoryPatch } from './types.js';\nimport { applySmartMergeInto } from './utils.js';\n\nexport class EventLog {\n  /** Base snapshot BEFORE the first stage mutates anything. */\n  private base: any;\n  /** Ordered list of commit bundles. */\n  private steps: CommitBundle[] = [];\n\n  constructor(initialMemory: any) {\n    // Normalised to an object: the base is a STATE, and every fold over it\n    // (`materialise`, `stateAt`) applies path writes to it. `undefined` —\n    // what a run with no `initialContext` used to store here — made every\n    // one of those folds throw on the first `set`.\n    this.base = initialMemory === undefined ? {} : structuredClone(initialMemory);\n  }\n\n  /**\n   * The fold BASE — the state as it stood before the first commit.\n   *\n   * This is the other half of the commit log: bundles are DIFFS, so a log\n   * alone cannot reconstruct state that was seeded before the run (an\n   * executor `initialContext`, `defaultValuesForContext`, a resume's\n   * `checkpoint.sharedState`, a subflow's `inputMapper` seed). Travelling\n   * with the log — `RuntimeSnapshot.initialState` — is what lets an OFFLINE\n   * consumer fold; without it the honest answer is a partial one\n   * (`stateAt`'s `basis: 'log-only'`).\n   *\n   * Returns a fresh detached clone on every call — the caller owns it.\n   */\n  getInitialState(): any {\n    return structuredClone(this.base);\n  }\n\n  /**\n   * Reconstructs the full state at any given step.\n   * Replays commits from the beginning — O(n) but low memory footprint.\n   *\n   * INDEX CONVENTION — `stepIdx` is EXCLUSIVE: `materialise(3)` folds commits\n   * 0, 1 and 2. `stateAt(source, commitIdx)` (footprintjs/trace) folds the\n   * same log but its `commitIdx` is INCLUSIVE, because a reader's cursor asks\n   * \"the state AT this stop\", which must include that stop's own commit. Two\n   * folds over one log with opposite conventions: check which one you hold.\n   *\n   * One clone of the base per call, then every bundle replayed INTO that\n   * private copy (`applySmartMergeInto` — the live commit's copy-on-write law\n   * below the root, 9.29.0, so the fold and the live state agree at every\n   * path). The result is the caller's: it shares nothing with the base or\n   * the log.\n   *\n   * @deprecated Since 9.33.0 — use `stateAt` from `footprintjs/trace`, which folds the same log\n   * from the same base (`RuntimeSnapshot.initialState`) and says how it was derived (`basis`).\n   * Nothing in the library calls this; it stays for one minor and is then removed. Mind the\n   * index: `materialise(n)` folds commits `0..n-1`, `stateAt(source, n - 1)` the same commits.\n   */\n  materialise(stepIdx = this.steps.length): any {\n    const out = structuredClone(this.base);\n    for (let i = 0; i < stepIdx; i++) {\n      const { overwrite, updates, trace } = this.steps[i];\n      applySmartMergeInto(out, updates as MemoryPatch, overwrite as MemoryPatch, trace);\n    }\n    return out;\n  }\n\n  /**\n   * Persists a commit bundle for a finished stage, and FREEZES it (see the module doc): the bundle\n   * is stamped with its position, then deep-frozen, then appended. The engine hands it a bundle\n   * built for the log alone; a caller of this class (`footprintjs/advanced`) hands over a bundle it\n   * will no longer edit — its own object is the one frozen.\n   */\n  record(bundle: CommitBundle): void {\n    bundle.idx = this.steps.length;\n    deepFreeze(bundle, 'indices');\n    this.steps.push(bundle);\n  }\n\n  /** Gets all recorded commit bundles — the live array; every bundle in it is frozen. */\n  list(): CommitBundle[] {\n    return this.steps;\n  }\n\n  /** Number of recorded commits. */\n  get length(): number {\n    return this.steps.length;\n  }\n\n  /** Wipes history (useful for test resets). */\n  clear(): void {\n    this.steps = [];\n  }\n}\n"]}