footprintjs 9.24.0 → 9.25.0

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

@@ -221,4 +221,14 @@ export declare function supersededByNextSet(rows: readonly {
  * here; there is no second replay loop to keep in step.
  */
 export declare function applySmartMerge(base: any, updates: MemoryPatch, overwrite: MemoryPatch, trace: TraceEntry[]): any;
+/**
+ * The same replay, INTO `target` — the one verb switch, no clone of its own.
+ * For a caller that already holds a private working copy (the read-side fold
+ * in `time-travel/stateAt.ts`, which clones its base ONCE and then applies
+ * every bundle here), so a fold over N bundles costs N row applications, not
+ * N clones of the whole state. Never hand it committed state: it mutates.
+ * The values it writes are its own (`set`/`append` clone the recorded value;
+ * `merge` builds new containers), so `target` never aliases the log.
+ */
+export declare function applySmartMergeInto(target: any, updates: MemoryPatch, overwrite: MemoryPatch, trace: TraceEntry[]): any;
 export {};

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

@@ -416,7 +416,19 @@ export function supersededByNextSet(rows, i) {
  * here; there is no second replay loop to keep in step.
  */
 export function applySmartMerge(base, updates, overwrite, trace) {
-    const out = structuredClone(base);
+    return applySmartMergeInto(structuredClone(base), updates, overwrite, trace);
+}
+/**
+ * The same replay, INTO `target` — the one verb switch, no clone of its own.
+ * For a caller that already holds a private working copy (the read-side fold
+ * in `time-travel/stateAt.ts`, which clones its base ONCE and then applies
+ * every bundle here), so a fold over N bundles costs N row applications, not
+ * N clones of the whole state. Never hand it committed state: it mutates.
+ * The values it writes are its own (`set`/`append` clone the recorded value;
+ * `merge` builds new containers), so `target` never aliases the log.
+ */
+export function applySmartMergeInto(target, updates, overwrite, trace) {
+    const out = target;
     for (let i = 0; i < trace.length; i++) {
         if (supersededByNextSet(trace, i))
             continue;
@@ -440,4 +452,4 @@ export function applySmartMerge(base, updates, overwrite, trace) {
     }
     return out;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/lib/memory/utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * utils.ts — Helper functions for nested object manipulation\n *\n * Provides consistent path traversal and value manipulation for the memory system.\n * Zero external dependencies.\n */\n\nimport { nativeDelete, nativeGet as _get, nativeHas as _has, nativeSet as _set } from './pathOps.js';\nimport type { MemoryPatch, TraceEntry } from './types.js';\n\n/**\n * The separator that joins path SEGMENTS into a `TraceEntry.path`.\n *\n * WHY NOT `'.'` — the ambiguity this exists to prevent: a state key may itself\n * CONTAIN a dot, and this library creates such keys routinely. `$setValue`\n * takes a KEY, not a path, so `$setValue('a.b', v)` makes one top-level key\n * literally named `a.b`. With a dot separator that key's path and the nested\n * path `['a', 'b']` would both encode as `\"a.b\"`, and every reader of the\n * commit log — `applySmartMerge`, `commitValueAt`, `redactPatch`,\n * `findLastWriter`, the slice layer — would have to guess which one a bundle\n * meant. Splitting the wrong way writes into (or reads from) the wrong place.\n *\n * ASCII Unit-Separator is the choice because it cannot appear in a JS\n * identifier and is vanishingly unlikely in a hand-written key, so the\n * encoding stays unambiguous. It is NOT a display character: a path rendered\n * straight to a UI or a log looks like one broken word. Split it with\n * {@link pathSegments} — that, not this constant, is the contract consumers\n * should hold.\n */\nexport const DELIM = '\\u001F';\n\ntype NestedObject = { [key: string]: any };\n\n/**\n * Resolves run-namespaced and global paths.\n * Each flowchart execution (run) stores data under `runs/{id}/` to prevent collisions.\n */\nexport function getRunAndGlobalPaths(runId?: string, path: (string | number)[] = []) {\n  return {\n    runPath: runId ? ['runs', runId, ...path] : undefined,\n    globalPath: [...path],\n  };\n}\n\n/**\n * Sets a value at a nested path, creating intermediate objects as needed.\n */\nexport function setNestedValue<T>(\n  obj: NestedObject,\n  runId: string,\n  _path: string[],\n  field: string,\n  value: T,\n  defaultValues?: unknown,\n): NestedObject {\n  const { runPath, globalPath } = getRunAndGlobalPaths(runId, _path);\n  const path = runPath || globalPath;\n  const pathCopy = [...path];\n  let current: NestedObject = obj;\n  while (pathCopy.length > 0) {\n    const key = pathCopy.shift() as string;\n    if (!Object.prototype.hasOwnProperty.call(current, key)) {\n      current[key] = key === runId && defaultValues ? defaultValues : {};\n    }\n    current = current[key];\n  }\n  current[field] = value;\n  return obj;\n}\n\n/**\n * Deep-merges a value into the object at the specified path.\n * - Arrays: concatenate\n * - Objects: shallow merge at each level\n * - Primitives: replace\n */\nexport function updateNestedValue<T>(\n  obj: any,\n  runId: string | undefined,\n  _path: (string | number)[],\n  field: string | number,\n  value: T,\n  defaultValues?: unknown,\n): any {\n  const { runPath, globalPath } = getRunAndGlobalPaths(runId, _path);\n  const path = runPath || globalPath;\n  const pathCopy = [...path];\n  let current: NestedObject = obj;\n  while (pathCopy.length > 0) {\n    const key = pathCopy.shift() as string;\n    if (!Object.prototype.hasOwnProperty.call(current, key)) {\n      current[key] = key === runId && defaultValues ? defaultValues : {};\n    }\n    current = current[key];\n  }\n  updateValue(current, field, value);\n  return obj;\n}\n\n/**\n * In-place value update with merge semantics.\n * - Arrays (non-empty): concatenate onto existing\n * - Arrays (empty):     direct replace — writing `[]` clears the field\n * - Objects (non-empty): shallow merge (spread)\n * - Objects (empty):    direct replace — writing `{}` clears the field\n * - Primitives: direct assignment\n *\n * Note on empty arrays: both `value && Array.isArray(value)` and\n * `Array.isArray(value)` evaluate the same for arrays — `[]` is truthy in\n * JavaScript, so the `&&` guard was never the issue. The actual bug was the\n * concat path: `[...cur, ...[]]` silently returned `cur` unchanged when `value`\n * was `[]`, making `updateValue(obj, 'tags', [])` a no-op instead of a clear.\n * The fix is the explicit `value.length === 0` early-return branch.\n */\nexport function updateValue(object: any, key: string | number, value: any): void {\n  if (Array.isArray(value)) {\n    if (value.length === 0) {\n      object[key] = value; // clear: [] replaces whatever was there\n    } else {\n      const cur = object[key] as any;\n      object[key] = cur === undefined ? value : [...cur, ...value];\n    }\n  } else if (value && typeof value === 'object' && Object.keys(value).length) {\n    const cur = object[key] as any;\n    object[key] = cur === undefined ? value : { ...cur, ...value };\n  } else {\n    object[key] = value;\n  }\n}\n\n/**\n * Gets a value at a nested path with prototype-pollution protection.\n */\nexport function getNestedValue(root: any, path: (string | number)[], field?: string | number): any {\n  const node = path && path.length > 0 ? _get(root, path) : root;\n  if (field === undefined || node === undefined) return node;\n  if (node !== null && typeof node === 'object' && Object.prototype.hasOwnProperty.call(node, field)) {\n    return node[field];\n  }\n  return undefined;\n}\n\n/**\n * Redacts sensitive values in a patch for logging/debugging.\n */\nexport function redactPatch(patch: MemoryPatch, redactedSet: Set<string>): MemoryPatch {\n  const out = structuredClone(patch);\n  for (const flat of redactedSet) {\n    const pathArr = flat.split(DELIM);\n    if (_has(out, pathArr)) {\n      const curr = _get(out, pathArr);\n      if (typeof curr !== 'undefined') {\n        _set(out, pathArr, 'REDACTED');\n      }\n    }\n  }\n  return out;\n}\n\n/**\n * Normalises an array path into a stable string key using DELIM.\n */\nexport function normalisePath(path: (string | number)[]): string {\n  return path.map(String).join(DELIM);\n}\n\n/**\n * The inverse of {@link normalisePath}: the SEGMENTS of a `TraceEntry.path`.\n *\n * A path in the commit log is DELIM-joined (see {@link DELIM}), which is not a\n * display encoding — printing one verbatim shows a single broken-looking word,\n * as a consumer rendering a path discovered. This is the supported way to take\n * it apart; the delimiter itself stays an implementation detail, so a path can\n * be read, rendered or re-joined without anyone hard-coding a control\n * character.\n *\n * A single-segment path (the common case — a top-level state key) returns a\n * one-element array, so callers need no special case.\n *\n * ```ts\n * import { pathSegments } from 'footprintjs/trace';\n *\n * for (const entry of bundle.trace) {\n *   console.log(pathSegments(entry.path).join(' › ')); // 'order › lines'\n * }\n * ```\n */\nexport function pathSegments(path: string): string[] {\n  return path.split(DELIM);\n}\n\n/**\n * Structural deep equality for committed-state values.\n *\n * Used by {@link TransactionBuffer} to decide whether a stage actually CHANGED\n * a path or merely re-wrote / reverted it to the value it already held (a\n * \"no-op write\"), and by `borrowedMutation.firstDifferingPath` to find where a\n * borrowed read moved. Committed state must survive `structuredClone`, and\n * `structuredClone` keeps `Date`, `Map` and `Set` — so those are legal state\n * values (a `$setValue` bypasses the proxy's JSON round-trip) and this must\n * tell two of them apart. Before 9.22.0 it compared them as plain objects, and\n * a `Date`/`Map`/`Set` has no own enumerable keys: every pair was \"equal\", so\n * `$setValue('k', new Date(1999))` over a 2020 date was dropped as a no-op —\n * no trace row, state unchanged — and a `setFullYear` in place slipped past\n * the dev-mode guard.\n *\n * Semantics:\n *   - reference / identical-primitive short-circuits first (cheap fast path)\n *   - `NaN` equals `NaN` (primitive compare falls back to `Object.is`)\n *   - `Date`: same `getTime()` (two invalid dates are equal)\n *   - `Map`: same size AND, per key of `a`, `b` holds a deep-equal value —\n *     keys by `Map` identity (`SameValueZero`), values deep\n *   - `Set`: same size AND every member of `a` is deep-equal to SOME member\n *     of `b` (order-insensitive — a Set has no order to compare by)\n *   - a typed value against a plain value, or two different typed kinds → not\n *     equal (a `Date` is never `{}`)\n *   - arrays: equal length AND deep-equal element-wise (order-sensitive)\n *   - objects: identical set of keys that HOLD a value AND deep-equal per key.\n *     An own key whose value is `undefined` counts as ABSENT: it is this\n *     library's other spelling of a deleted key (`'full'` mode flattens\n *     `delete` into `key: undefined`; `'delta'` mode's `delete` verb removes\n *     the key), and every consumer — JSON, the fold, `commitValueAt`, the\n *     mirror — reads the two spellings as one state. So must the net-change\n *     filter (9.19.1): `{}` and `{ k: undefined }` are not a change. Arrays\n *     are untouched — a slot holding `undefined` is still a slot.\n *   - mismatched kinds (array vs object, object vs null) → not equal\n *\n * Cost & safety:\n *   - Allocates NOTHING but transient `Object.keys` arrays — no clones. It is\n *     strictly cheaper than the `structuredClone` the commit already performs.\n *   - Primitive comparisons (the bulk of state) are O(1) via the `===` /\n *     `Object.is` fast paths; only nested objects/arrays incur a walk, bounded\n *     by the value's own size.\n *   - Terminates on CYCLIC values (9.18.1): a state value must survive\n *     `structuredClone`, and `structuredClone` preserves cycles — so a\n *     self-referencing value is a legal value, not an out-of-contract one. A\n *     pair of objects already under comparison is treated as equal (the\n *     structural answer, lodash `isEqual` semantics); acyclic inputs see no\n *     change. Dev mode still warns about cycles at write time\n *     (`ScopeFacade.setValue`) because they surprise narrative and JSON.\n */\nexport function deepEqual(a: any, b: any): boolean {\n  return equalPairs(a, b, undefined);\n}\n\n/**\n * Object pairs met so far, keyed `a → the b's it has been paired with`. Created\n * lazily by the first object pair, so primitive compares allocate nothing.\n * Never pruned: every `false` returns straight up to the caller (each recursive\n * call short-circuits on it), so nothing is looked up after a mismatch — a\n * stored pair is either still under comparison or already known equal.\n */\ntype SeenPairs = WeakMap<object, WeakSet<object>>;\n\nfunction equalPairs(a: any, b: any, seen: SeenPairs | undefined): boolean {\n  if (a === b) return true; // same reference or identical primitive\n  if (typeof a !== typeof b) return false;\n  if (a === null || b === null) return a === b; // one is null, the other isn't\n  if (typeof a !== 'object') return Object.is(a, b); // NaN-safe primitive compare\n\n  // Typed arms first — a Date/Map/Set has no own enumerable keys, so the\n  // plain-object walk below would call any two of them equal.\n  const aKind = typedKind(a);\n  if (aKind !== typedKind(b)) return false;\n  if (aKind === 'date') return Object.is(a.getTime(), b.getTime());\n\n  const aIsArray = Array.isArray(a);\n  if (aIsArray !== Array.isArray(b)) return false; // array vs plain object\n\n  // Cycle guard — a pair we are already inside is equal by assumption.\n  seen ??= new WeakMap();\n  let partners = seen.get(a);\n  if (partners?.has(b)) return true;\n  if (!partners) seen.set(a, (partners = new WeakSet()));\n  partners.add(b);\n\n  if (aKind === 'map') return equalMaps(a, b, seen);\n  if (aKind === 'set') return equalSets(a, b, seen);\n\n  if (aIsArray) {\n    if (a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) {\n      if (!equalPairs(a[i], b[i], seen)) return false;\n    }\n    return true;\n  }\n\n  // Objects: only keys that HOLD a value take part — an own `undefined` is a\n  // deleted key, the same state as an absent one (see the contract above).\n  let aHeld = 0;\n  for (const key of Object.keys(a)) {\n    if (a[key] === undefined) continue;\n    aHeld++;\n    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;\n    if (!equalPairs(a[key], b[key], seen)) return false;\n  }\n  let bHeld = 0;\n  for (const key of Object.keys(b)) if (b[key] !== undefined) bHeld++;\n  return aHeld === bHeld;\n}\n\n/** The typed state values `structuredClone` keeps and a key walk cannot see. */\nfunction typedKind(value: object): 'date' | 'map' | 'set' | undefined {\n  if (value instanceof Date) return 'date';\n  if (value instanceof Map) return 'map';\n  if (value instanceof Set) return 'set';\n  return undefined;\n}\n\nfunction equalMaps(a: Map<unknown, unknown>, b: Map<unknown, unknown>, seen: SeenPairs): boolean {\n  if (a.size !== b.size) return false;\n  for (const [key, value] of a) {\n    if (!b.has(key)) return false;\n    if (!equalPairs(value, b.get(key), seen)) return false;\n  }\n  return true;\n}\n\n/**\n * Order-insensitive, deep per member. Quadratic in the worst case for sets of\n * objects — a set of primitives (the common shape) is one `has` per member.\n */\nfunction equalSets(a: Set<unknown>, b: Set<unknown>, seen: SeenPairs): boolean {\n  if (a.size !== b.size) return false;\n  const unmatched = [...b];\n  for (const member of a) {\n    // SameValueZero first — primitives and shared references, one `has`.\n    // Each match retires its slot so two structurally-equal members of `a`\n    // cannot both claim the same member of `b`.\n    const at = unmatched.indexOf(member);\n    const found = at >= 0 ? at : unmatched.findIndex((candidate) => equalPairs(member, candidate, seen));\n    if (found < 0) return false;\n    unmatched.splice(found, 1);\n  }\n  return true;\n}\n\n/**\n * Deep union merge helper.\n * - Arrays (non-empty): union without duplicates (encounter order preserved)\n * - Arrays (empty):     replace — src `[]` clears the destination array.\n *   Rationale: writing `scope.tags = []` means \"clear tags\", not \"append nothing\".\n *   Without this rule, an empty-array write silently becomes a no-op which is\n *   impossible to distinguish from a bug.\n * - Objects: recursive merge\n * - Primitives: source wins\n *\n * Terminates on a CYCLIC `src` (9.18.1, same law as {@link deepEqual}: a\n * state value survives `structuredClone`, which preserves cycles). A `src`\n * object re-entered while it is still being merged higher up the stack hands\n * back the output being built for it, so the merged value mirrors the cycle\n * instead of unrolling it forever. Only the ancestors on the stack are\n * guarded — a shared (acyclic) `src` reference met again at a different\n * `dst` merges against THAT `dst`, exactly as before.\n */\nexport function deepSmartMerge(dst: any, src: any): any {\n  return mergeGuarded(dst, src, undefined);\n}\n\nfunction mergeGuarded(dst: any, src: any, inFlight: WeakMap<object, any> | undefined): any {\n  if (src === null || typeof src !== 'object') return src;\n\n  if (Array.isArray(src)) {\n    if (src.length === 0) return []; // empty src = clear, not no-op\n    if (Array.isArray(dst)) return [...new Set([...dst, ...src])];\n    return [...src];\n  }\n\n  if (inFlight?.has(src)) return inFlight.get(src); // cycle — re-enter the value being built\n\n  const out: any = { ...(dst && typeof dst === 'object' ? dst : {}) };\n  (inFlight ??= new WeakMap()).set(src, out);\n  // Object.keys() is own-enumerable-only by spec — no DENIED check needed here.\n  for (const k of Object.keys(src)) {\n    out[k] = mergeGuarded(out[k], src[k], inFlight);\n  }\n  inFlight.delete(src);\n  return out;\n}\n\n/**\n * Is row `i` a `set` that the NEXT row sets again — same path, same verb — so\n * that applying it is work the next row redoes?\n *\n * The one skip every replay iterator shares (9.22.1). A `set` row writes a\n * clone of the recorded value at its path; the next row, a `set` of the same\n * path, writes a clone of the SAME recorded value over it (the bundle's patch\n * tree is fixed), and nothing runs in between — so the first write is\n * unobservable, container creation and key order included. Only CONSECUTIVE\n * rows qualify: a row in between (an ancestor `merge`, a sibling `set` that\n * creates a container) can see the intermediate value, and a `merge`,\n * `append` or `delete` next row depends on what is there. Rows are never\n * dropped from the log — the 9.22.0 element-write funnel records N\n * whole-array `set` rows on one path, and this is what makes replaying them\n * O(N) instead of O(N × rows).\n *\n * Shared by {@link applySmartMerge} (live state, `EventLog.materialise`,\n * `stateAt`, the redacted mirror) and `TransactionBuffer.replayFamilyVerbs`\n * (the delta encoder's per-family fold) — the two loops that clone per row.\n * `commitValueAt` needs no skip: it anchors at the LAST `set` by construction.\n */\nexport function supersededByNextSet(rows: readonly { path: string; verb: string }[], i: number): boolean {\n  const row = rows[i];\n  if (row.verb !== 'set') return false;\n  const next = rows[i + 1];\n  return next !== undefined && next.verb === 'set' && next.path === row.path;\n}\n\n/**\n * Applies a commit bundle to a base state by replaying operations in order.\n * Guarantees \"last writer wins\" semantics.\n *\n * The single replay primitive — three consumers inherit every verb from it:\n * live state (`SharedMemory.applyPatch`), time travel\n * (`EventLog.materialise`), and the redacted mirror\n * (`StageContext.commit`'s second `applyPatch`).\n *\n * Verb arms:\n *   - `'set'`    — overwrite with `overwrite[path]` (the full final value).\n *   - `'merge'`  — `deepSmartMerge` the accumulated `updates[path]` delta in.\n *   - `'append'` — (#13c-B delta mode) `overwrite[path]` holds ONLY the tail;\n *     reconstruct by concatenating it onto the current array. When the\n *     current value or the recorded tail is not an array (out-of-order\n *     replay base, or a REDACTED tail — `redactPatch` replaces matched\n *     payloads with the `'REDACTED'` string), degrade to a direct set of the\n *     recorded value — the same terminal value a redacted/corrupt `'set'`\n *     produces.\n *   - `'delete'` — (#13c-B delta mode) remove the key (`nativeDelete`,\n *     prototype-pollution-safe). The path stays enumerated in `overwrite`\n *     (value `undefined`) for key-set consumers; replay ignores that value.\n *\n * Work, not bytes (9.22.1): a `set` row the NEXT row re-sets is skipped\n * ({@link supersededByNextSet}) — the rows stay in the log, only the clone\n * each would have paid is not. Every consumer above inherits the skip from\n * here; there is no second replay loop to keep in step.\n */\nexport function applySmartMerge(base: any, updates: MemoryPatch, overwrite: MemoryPatch, trace: TraceEntry[]): any {\n  const out = structuredClone(base);\n  for (let i = 0; i < trace.length; i++) {\n    if (supersededByNextSet(trace, i)) continue;\n    const { path, verb } = trace[i];\n    const segs = path.split(DELIM);\n    if (verb === 'set') {\n      _set(out, segs, structuredClone(_get(overwrite, segs)));\n    } else if (verb === 'append') {\n      const tail = structuredClone(_get(overwrite, segs));\n      const current = _get(out, segs);\n      _set(out, segs, Array.isArray(current) && Array.isArray(tail) ? [...current, ...tail] : tail);\n    } else if (verb === 'delete') {\n      nativeDelete(out, segs);\n    } else {\n      const current = _get(out, segs) ?? {};\n      _set(out, segs, deepSmartMerge(current, _get(updates, segs)));\n    }\n  }\n  return out;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/lib/memory/utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * utils.ts — Helper functions for nested object manipulation\n *\n * Provides consistent path traversal and value manipulation for the memory system.\n * Zero external dependencies.\n */\n\nimport { nativeDelete, nativeGet as _get, nativeHas as _has, nativeSet as _set } from './pathOps.js';\nimport type { MemoryPatch, TraceEntry } from './types.js';\n\n/**\n * The separator that joins path SEGMENTS into a `TraceEntry.path`.\n *\n * WHY NOT `'.'` — the ambiguity this exists to prevent: a state key may itself\n * CONTAIN a dot, and this library creates such keys routinely. `$setValue`\n * takes a KEY, not a path, so `$setValue('a.b', v)` makes one top-level key\n * literally named `a.b`. With a dot separator that key's path and the nested\n * path `['a', 'b']` would both encode as `\"a.b\"`, and every reader of the\n * commit log — `applySmartMerge`, `commitValueAt`, `redactPatch`,\n * `findLastWriter`, the slice layer — would have to guess which one a bundle\n * meant. Splitting the wrong way writes into (or reads from) the wrong place.\n *\n * ASCII Unit-Separator is the choice because it cannot appear in a JS\n * identifier and is vanishingly unlikely in a hand-written key, so the\n * encoding stays unambiguous. It is NOT a display character: a path rendered\n * straight to a UI or a log looks like one broken word. Split it with\n * {@link pathSegments} — that, not this constant, is the contract consumers\n * should hold.\n */\nexport const DELIM = '\\u001F';\n\ntype NestedObject = { [key: string]: any };\n\n/**\n * Resolves run-namespaced and global paths.\n * Each flowchart execution (run) stores data under `runs/{id}/` to prevent collisions.\n */\nexport function getRunAndGlobalPaths(runId?: string, path: (string | number)[] = []) {\n  return {\n    runPath: runId ? ['runs', runId, ...path] : undefined,\n    globalPath: [...path],\n  };\n}\n\n/**\n * Sets a value at a nested path, creating intermediate objects as needed.\n */\nexport function setNestedValue<T>(\n  obj: NestedObject,\n  runId: string,\n  _path: string[],\n  field: string,\n  value: T,\n  defaultValues?: unknown,\n): NestedObject {\n  const { runPath, globalPath } = getRunAndGlobalPaths(runId, _path);\n  const path = runPath || globalPath;\n  const pathCopy = [...path];\n  let current: NestedObject = obj;\n  while (pathCopy.length > 0) {\n    const key = pathCopy.shift() as string;\n    if (!Object.prototype.hasOwnProperty.call(current, key)) {\n      current[key] = key === runId && defaultValues ? defaultValues : {};\n    }\n    current = current[key];\n  }\n  current[field] = value;\n  return obj;\n}\n\n/**\n * Deep-merges a value into the object at the specified path.\n * - Arrays: concatenate\n * - Objects: shallow merge at each level\n * - Primitives: replace\n */\nexport function updateNestedValue<T>(\n  obj: any,\n  runId: string | undefined,\n  _path: (string | number)[],\n  field: string | number,\n  value: T,\n  defaultValues?: unknown,\n): any {\n  const { runPath, globalPath } = getRunAndGlobalPaths(runId, _path);\n  const path = runPath || globalPath;\n  const pathCopy = [...path];\n  let current: NestedObject = obj;\n  while (pathCopy.length > 0) {\n    const key = pathCopy.shift() as string;\n    if (!Object.prototype.hasOwnProperty.call(current, key)) {\n      current[key] = key === runId && defaultValues ? defaultValues : {};\n    }\n    current = current[key];\n  }\n  updateValue(current, field, value);\n  return obj;\n}\n\n/**\n * In-place value update with merge semantics.\n * - Arrays (non-empty): concatenate onto existing\n * - Arrays (empty):     direct replace — writing `[]` clears the field\n * - Objects (non-empty): shallow merge (spread)\n * - Objects (empty):    direct replace — writing `{}` clears the field\n * - Primitives: direct assignment\n *\n * Note on empty arrays: both `value && Array.isArray(value)` and\n * `Array.isArray(value)` evaluate the same for arrays — `[]` is truthy in\n * JavaScript, so the `&&` guard was never the issue. The actual bug was the\n * concat path: `[...cur, ...[]]` silently returned `cur` unchanged when `value`\n * was `[]`, making `updateValue(obj, 'tags', [])` a no-op instead of a clear.\n * The fix is the explicit `value.length === 0` early-return branch.\n */\nexport function updateValue(object: any, key: string | number, value: any): void {\n  if (Array.isArray(value)) {\n    if (value.length === 0) {\n      object[key] = value; // clear: [] replaces whatever was there\n    } else {\n      const cur = object[key] as any;\n      object[key] = cur === undefined ? value : [...cur, ...value];\n    }\n  } else if (value && typeof value === 'object' && Object.keys(value).length) {\n    const cur = object[key] as any;\n    object[key] = cur === undefined ? value : { ...cur, ...value };\n  } else {\n    object[key] = value;\n  }\n}\n\n/**\n * Gets a value at a nested path with prototype-pollution protection.\n */\nexport function getNestedValue(root: any, path: (string | number)[], field?: string | number): any {\n  const node = path && path.length > 0 ? _get(root, path) : root;\n  if (field === undefined || node === undefined) return node;\n  if (node !== null && typeof node === 'object' && Object.prototype.hasOwnProperty.call(node, field)) {\n    return node[field];\n  }\n  return undefined;\n}\n\n/**\n * Redacts sensitive values in a patch for logging/debugging.\n */\nexport function redactPatch(patch: MemoryPatch, redactedSet: Set<string>): MemoryPatch {\n  const out = structuredClone(patch);\n  for (const flat of redactedSet) {\n    const pathArr = flat.split(DELIM);\n    if (_has(out, pathArr)) {\n      const curr = _get(out, pathArr);\n      if (typeof curr !== 'undefined') {\n        _set(out, pathArr, 'REDACTED');\n      }\n    }\n  }\n  return out;\n}\n\n/**\n * Normalises an array path into a stable string key using DELIM.\n */\nexport function normalisePath(path: (string | number)[]): string {\n  return path.map(String).join(DELIM);\n}\n\n/**\n * The inverse of {@link normalisePath}: the SEGMENTS of a `TraceEntry.path`.\n *\n * A path in the commit log is DELIM-joined (see {@link DELIM}), which is not a\n * display encoding — printing one verbatim shows a single broken-looking word,\n * as a consumer rendering a path discovered. This is the supported way to take\n * it apart; the delimiter itself stays an implementation detail, so a path can\n * be read, rendered or re-joined without anyone hard-coding a control\n * character.\n *\n * A single-segment path (the common case — a top-level state key) returns a\n * one-element array, so callers need no special case.\n *\n * ```ts\n * import { pathSegments } from 'footprintjs/trace';\n *\n * for (const entry of bundle.trace) {\n *   console.log(pathSegments(entry.path).join(' › ')); // 'order › lines'\n * }\n * ```\n */\nexport function pathSegments(path: string): string[] {\n  return path.split(DELIM);\n}\n\n/**\n * Structural deep equality for committed-state values.\n *\n * Used by {@link TransactionBuffer} to decide whether a stage actually CHANGED\n * a path or merely re-wrote / reverted it to the value it already held (a\n * \"no-op write\"), and by `borrowedMutation.firstDifferingPath` to find where a\n * borrowed read moved. Committed state must survive `structuredClone`, and\n * `structuredClone` keeps `Date`, `Map` and `Set` — so those are legal state\n * values (a `$setValue` bypasses the proxy's JSON round-trip) and this must\n * tell two of them apart. Before 9.22.0 it compared them as plain objects, and\n * a `Date`/`Map`/`Set` has no own enumerable keys: every pair was \"equal\", so\n * `$setValue('k', new Date(1999))` over a 2020 date was dropped as a no-op —\n * no trace row, state unchanged — and a `setFullYear` in place slipped past\n * the dev-mode guard.\n *\n * Semantics:\n *   - reference / identical-primitive short-circuits first (cheap fast path)\n *   - `NaN` equals `NaN` (primitive compare falls back to `Object.is`)\n *   - `Date`: same `getTime()` (two invalid dates are equal)\n *   - `Map`: same size AND, per key of `a`, `b` holds a deep-equal value —\n *     keys by `Map` identity (`SameValueZero`), values deep\n *   - `Set`: same size AND every member of `a` is deep-equal to SOME member\n *     of `b` (order-insensitive — a Set has no order to compare by)\n *   - a typed value against a plain value, or two different typed kinds → not\n *     equal (a `Date` is never `{}`)\n *   - arrays: equal length AND deep-equal element-wise (order-sensitive)\n *   - objects: identical set of keys that HOLD a value AND deep-equal per key.\n *     An own key whose value is `undefined` counts as ABSENT: it is this\n *     library's other spelling of a deleted key (`'full'` mode flattens\n *     `delete` into `key: undefined`; `'delta'` mode's `delete` verb removes\n *     the key), and every consumer — JSON, the fold, `commitValueAt`, the\n *     mirror — reads the two spellings as one state. So must the net-change\n *     filter (9.19.1): `{}` and `{ k: undefined }` are not a change. Arrays\n *     are untouched — a slot holding `undefined` is still a slot.\n *   - mismatched kinds (array vs object, object vs null) → not equal\n *\n * Cost & safety:\n *   - Allocates NOTHING but transient `Object.keys` arrays — no clones. It is\n *     strictly cheaper than the `structuredClone` the commit already performs.\n *   - Primitive comparisons (the bulk of state) are O(1) via the `===` /\n *     `Object.is` fast paths; only nested objects/arrays incur a walk, bounded\n *     by the value's own size.\n *   - Terminates on CYCLIC values (9.18.1): a state value must survive\n *     `structuredClone`, and `structuredClone` preserves cycles — so a\n *     self-referencing value is a legal value, not an out-of-contract one. A\n *     pair of objects already under comparison is treated as equal (the\n *     structural answer, lodash `isEqual` semantics); acyclic inputs see no\n *     change. Dev mode still warns about cycles at write time\n *     (`ScopeFacade.setValue`) because they surprise narrative and JSON.\n */\nexport function deepEqual(a: any, b: any): boolean {\n  return equalPairs(a, b, undefined);\n}\n\n/**\n * Object pairs met so far, keyed `a → the b's it has been paired with`. Created\n * lazily by the first object pair, so primitive compares allocate nothing.\n * Never pruned: every `false` returns straight up to the caller (each recursive\n * call short-circuits on it), so nothing is looked up after a mismatch — a\n * stored pair is either still under comparison or already known equal.\n */\ntype SeenPairs = WeakMap<object, WeakSet<object>>;\n\nfunction equalPairs(a: any, b: any, seen: SeenPairs | undefined): boolean {\n  if (a === b) return true; // same reference or identical primitive\n  if (typeof a !== typeof b) return false;\n  if (a === null || b === null) return a === b; // one is null, the other isn't\n  if (typeof a !== 'object') return Object.is(a, b); // NaN-safe primitive compare\n\n  // Typed arms first — a Date/Map/Set has no own enumerable keys, so the\n  // plain-object walk below would call any two of them equal.\n  const aKind = typedKind(a);\n  if (aKind !== typedKind(b)) return false;\n  if (aKind === 'date') return Object.is(a.getTime(), b.getTime());\n\n  const aIsArray = Array.isArray(a);\n  if (aIsArray !== Array.isArray(b)) return false; // array vs plain object\n\n  // Cycle guard — a pair we are already inside is equal by assumption.\n  seen ??= new WeakMap();\n  let partners = seen.get(a);\n  if (partners?.has(b)) return true;\n  if (!partners) seen.set(a, (partners = new WeakSet()));\n  partners.add(b);\n\n  if (aKind === 'map') return equalMaps(a, b, seen);\n  if (aKind === 'set') return equalSets(a, b, seen);\n\n  if (aIsArray) {\n    if (a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) {\n      if (!equalPairs(a[i], b[i], seen)) return false;\n    }\n    return true;\n  }\n\n  // Objects: only keys that HOLD a value take part — an own `undefined` is a\n  // deleted key, the same state as an absent one (see the contract above).\n  let aHeld = 0;\n  for (const key of Object.keys(a)) {\n    if (a[key] === undefined) continue;\n    aHeld++;\n    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;\n    if (!equalPairs(a[key], b[key], seen)) return false;\n  }\n  let bHeld = 0;\n  for (const key of Object.keys(b)) if (b[key] !== undefined) bHeld++;\n  return aHeld === bHeld;\n}\n\n/** The typed state values `structuredClone` keeps and a key walk cannot see. */\nfunction typedKind(value: object): 'date' | 'map' | 'set' | undefined {\n  if (value instanceof Date) return 'date';\n  if (value instanceof Map) return 'map';\n  if (value instanceof Set) return 'set';\n  return undefined;\n}\n\nfunction equalMaps(a: Map<unknown, unknown>, b: Map<unknown, unknown>, seen: SeenPairs): boolean {\n  if (a.size !== b.size) return false;\n  for (const [key, value] of a) {\n    if (!b.has(key)) return false;\n    if (!equalPairs(value, b.get(key), seen)) return false;\n  }\n  return true;\n}\n\n/**\n * Order-insensitive, deep per member. Quadratic in the worst case for sets of\n * objects — a set of primitives (the common shape) is one `has` per member.\n */\nfunction equalSets(a: Set<unknown>, b: Set<unknown>, seen: SeenPairs): boolean {\n  if (a.size !== b.size) return false;\n  const unmatched = [...b];\n  for (const member of a) {\n    // SameValueZero first — primitives and shared references, one `has`.\n    // Each match retires its slot so two structurally-equal members of `a`\n    // cannot both claim the same member of `b`.\n    const at = unmatched.indexOf(member);\n    const found = at >= 0 ? at : unmatched.findIndex((candidate) => equalPairs(member, candidate, seen));\n    if (found < 0) return false;\n    unmatched.splice(found, 1);\n  }\n  return true;\n}\n\n/**\n * Deep union merge helper.\n * - Arrays (non-empty): union without duplicates (encounter order preserved)\n * - Arrays (empty):     replace — src `[]` clears the destination array.\n *   Rationale: writing `scope.tags = []` means \"clear tags\", not \"append nothing\".\n *   Without this rule, an empty-array write silently becomes a no-op which is\n *   impossible to distinguish from a bug.\n * - Objects: recursive merge\n * - Primitives: source wins\n *\n * Terminates on a CYCLIC `src` (9.18.1, same law as {@link deepEqual}: a\n * state value survives `structuredClone`, which preserves cycles). A `src`\n * object re-entered while it is still being merged higher up the stack hands\n * back the output being built for it, so the merged value mirrors the cycle\n * instead of unrolling it forever. Only the ancestors on the stack are\n * guarded — a shared (acyclic) `src` reference met again at a different\n * `dst` merges against THAT `dst`, exactly as before.\n */\nexport function deepSmartMerge(dst: any, src: any): any {\n  return mergeGuarded(dst, src, undefined);\n}\n\nfunction mergeGuarded(dst: any, src: any, inFlight: WeakMap<object, any> | undefined): any {\n  if (src === null || typeof src !== 'object') return src;\n\n  if (Array.isArray(src)) {\n    if (src.length === 0) return []; // empty src = clear, not no-op\n    if (Array.isArray(dst)) return [...new Set([...dst, ...src])];\n    return [...src];\n  }\n\n  if (inFlight?.has(src)) return inFlight.get(src); // cycle — re-enter the value being built\n\n  const out: any = { ...(dst && typeof dst === 'object' ? dst : {}) };\n  (inFlight ??= new WeakMap()).set(src, out);\n  // Object.keys() is own-enumerable-only by spec — no DENIED check needed here.\n  for (const k of Object.keys(src)) {\n    out[k] = mergeGuarded(out[k], src[k], inFlight);\n  }\n  inFlight.delete(src);\n  return out;\n}\n\n/**\n * Is row `i` a `set` that the NEXT row sets again — same path, same verb — so\n * that applying it is work the next row redoes?\n *\n * The one skip every replay iterator shares (9.22.1). A `set` row writes a\n * clone of the recorded value at its path; the next row, a `set` of the same\n * path, writes a clone of the SAME recorded value over it (the bundle's patch\n * tree is fixed), and nothing runs in between — so the first write is\n * unobservable, container creation and key order included. Only CONSECUTIVE\n * rows qualify: a row in between (an ancestor `merge`, a sibling `set` that\n * creates a container) can see the intermediate value, and a `merge`,\n * `append` or `delete` next row depends on what is there. Rows are never\n * dropped from the log — the 9.22.0 element-write funnel records N\n * whole-array `set` rows on one path, and this is what makes replaying them\n * O(N) instead of O(N × rows).\n *\n * Shared by {@link applySmartMerge} (live state, `EventLog.materialise`,\n * `stateAt`, the redacted mirror) and `TransactionBuffer.replayFamilyVerbs`\n * (the delta encoder's per-family fold) — the two loops that clone per row.\n * `commitValueAt` needs no skip: it anchors at the LAST `set` by construction.\n */\nexport function supersededByNextSet(rows: readonly { path: string; verb: string }[], i: number): boolean {\n  const row = rows[i];\n  if (row.verb !== 'set') return false;\n  const next = rows[i + 1];\n  return next !== undefined && next.verb === 'set' && next.path === row.path;\n}\n\n/**\n * Applies a commit bundle to a base state by replaying operations in order.\n * Guarantees \"last writer wins\" semantics.\n *\n * The single replay primitive — three consumers inherit every verb from it:\n * live state (`SharedMemory.applyPatch`), time travel\n * (`EventLog.materialise`), and the redacted mirror\n * (`StageContext.commit`'s second `applyPatch`).\n *\n * Verb arms:\n *   - `'set'`    — overwrite with `overwrite[path]` (the full final value).\n *   - `'merge'`  — `deepSmartMerge` the accumulated `updates[path]` delta in.\n *   - `'append'` — (#13c-B delta mode) `overwrite[path]` holds ONLY the tail;\n *     reconstruct by concatenating it onto the current array. When the\n *     current value or the recorded tail is not an array (out-of-order\n *     replay base, or a REDACTED tail — `redactPatch` replaces matched\n *     payloads with the `'REDACTED'` string), degrade to a direct set of the\n *     recorded value — the same terminal value a redacted/corrupt `'set'`\n *     produces.\n *   - `'delete'` — (#13c-B delta mode) remove the key (`nativeDelete`,\n *     prototype-pollution-safe). The path stays enumerated in `overwrite`\n *     (value `undefined`) for key-set consumers; replay ignores that value.\n *\n * Work, not bytes (9.22.1): a `set` row the NEXT row re-sets is skipped\n * ({@link supersededByNextSet}) — the rows stay in the log, only the clone\n * each would have paid is not. Every consumer above inherits the skip from\n * here; there is no second replay loop to keep in step.\n */\nexport function applySmartMerge(base: any, updates: MemoryPatch, overwrite: MemoryPatch, trace: TraceEntry[]): any {\n  return applySmartMergeInto(structuredClone(base), updates, overwrite, trace);\n}\n\n/**\n * The same replay, INTO `target` — the one verb switch, no clone of its own.\n * For a caller that already holds a private working copy (the read-side fold\n * in `time-travel/stateAt.ts`, which clones its base ONCE and then applies\n * every bundle here), so a fold over N bundles costs N row applications, not\n * N clones of the whole state. Never hand it committed state: it mutates.\n * The values it writes are its own (`set`/`append` clone the recorded value;\n * `merge` builds new containers), so `target` never aliases the log.\n */\nexport function applySmartMergeInto(\n  target: any,\n  updates: MemoryPatch,\n  overwrite: MemoryPatch,\n  trace: TraceEntry[],\n): any {\n  const out = target;\n  for (let i = 0; i < trace.length; i++) {\n    if (supersededByNextSet(trace, i)) continue;\n    const { path, verb } = trace[i];\n    const segs = path.split(DELIM);\n    if (verb === 'set') {\n      _set(out, segs, structuredClone(_get(overwrite, segs)));\n    } else if (verb === 'append') {\n      const tail = structuredClone(_get(overwrite, segs));\n      const current = _get(out, segs);\n      _set(out, segs, Array.isArray(current) && Array.isArray(tail) ? [...current, ...tail] : tail);\n    } else if (verb === 'delete') {\n      nativeDelete(out, segs);\n    } else {\n      const current = _get(out, segs) ?? {};\n      _set(out, segs, deepSmartMerge(current, _get(updates, segs)));\n    }\n  }\n  return out;\n}\n"]}

package/dist/esm/lib/time-travel/stateAt.d.ts

@@ -35,6 +35,32 @@ export declare function readSource(source: FoldSource | undefined): ReadSource;
  * With a single leg this is the 9.17.0 fold, unchanged.
  */
 export declare function foldLegs(legs: readonly ReadSource[], legIdx: number, through: number): FoldedState;
+/**
+ * What a fold leaves behind for the NEXT one (9.25.0): the private working
+ * copy and the facts accumulated so far. A cursor stepping forward on the
+ * same leg hands it back and only the bundles after `through` are applied —
+ * one bundle per step instead of a replay from the base. Any other ask (an
+ * earlier stop, another leg) folds from scratch; the memo is never a claim.
+ */
+export interface FoldMemo {
+    readonly legIdx: number;
+    readonly through: number;
+    readonly out: Record<string, unknown>;
+    readonly based: boolean;
+    readonly redactedPaths: ReadonlySet<string>;
+    readonly skipped: readonly LogGap[] | undefined;
+}
+/**
+ * The fold, resumable. ONE clone per fold: the base is cloned once (or `{}`
+ * stands in), every bundle is applied INTO that copy, and the state handed
+ * out is one more clone, frozen — so the working copy stays private and a
+ * later step can continue from it. Same answer as the 9.17.0 fold, pinned by
+ * test/lib/time-travel/fold-memo.test.ts against a fresh fold at every stop.
+ */
+export declare function foldLegsFrom(legs: readonly ReadSource[], legIdx: number, through: number, memo?: FoldMemo): {
+    readonly folded: FoldedState;
+    readonly memo: FoldMemo;
+};
 /**
  * Fold `source`'s log from its base up to and including `commitIdx`.
  *

package/dist/esm/lib/time-travel/stateAt.js

@@ -7,7 +7,7 @@
  * runs through `applySmartMerge`, the one verb switch the live commit itself
  * uses. There is deliberately no second implementation of the verbs here.
  */
-import { applySmartMerge } from '../memory/utils.js';
+import { applySmartMergeInto } from '../memory/utils.js';
 import { readLog } from './bundles.js';
 /** Deeply freeze a POJO tree so a fold result cannot be mutated by its holder. */
 function freezeDeep(value) {
@@ -53,49 +53,65 @@ export function readSource(source) {
  * With a single leg this is the 9.17.0 fold, unchanged.
  */
 export function foldLegs(legs, legIdx, through) {
-    let based = false;
-    let out = {};
-    const redactedPaths = new Set();
-    let skipped;
-    let lastThrough = -1;
-    for (let leg = 0; leg <= legIdx && leg < legs.length; leg++) {
-        const { log, gaps, base } = legs[leg];
-        if (base && typeof base === 'object') {
-            out = structuredClone(base);
-            based = true;
-        }
-        const end = leg === legIdx ? Math.min(through, log.length - 1) : log.length - 1;
-        if (leg === legIdx)
-            lastThrough = end < -1 ? -1 : end;
-        for (const gap of gaps) {
-            if (gap.index <= end)
-                (skipped ??= []).push(gap);
-        }
-        for (let i = 0; i <= end; i++) {
-            const bundle = log[i];
-            if (!bundle)
-                continue;
-            for (const path of bundle.redactedPaths ?? [])
-                redactedPaths.add(path);
-            out = applySmartMerge(out, bundle.updates, bundle.overwrite, bundle.trace);
+    return foldLegsFrom(legs, legIdx, through).folded;
+}
+/** Apply `log[from + 1 .. end]` of one leg into `out`, collecting the leg's facts. */
+function applyLeg(out, leg, from, end, redactedPaths, skipped) {
+    for (const gap of leg.gaps) {
+        if (gap.index > from && gap.index <= end)
+            (skipped ??= []).push(gap);
+    }
+    for (let i = from + 1; i <= end; i++) {
+        const bundle = leg.log[i];
+        if (!bundle)
+            continue;
+        for (const path of bundle.redactedPaths ?? [])
+            redactedPaths.add(path);
+        applySmartMergeInto(out, bundle.updates, bundle.overwrite, bundle.trace);
+    }
+    return skipped;
+}
+/**
+ * The fold, resumable. ONE clone per fold: the base is cloned once (or `{}`
+ * stands in), every bundle is applied INTO that copy, and the state handed
+ * out is one more clone, frozen — so the working copy stays private and a
+ * later step can continue from it. Same answer as the 9.17.0 fold, pinned by
+ * test/lib/time-travel/fold-memo.test.ts against a fresh fold at every stop.
+ */
+export function foldLegsFrom(legs, legIdx, through, memo) {
+    const last = legs[legIdx];
+    const endOnLeg = last ? Math.min(through, last.log.length - 1) : -1;
+    const lastThrough = endOnLeg < -1 ? -1 : endOnLeg;
+    const resumable = memo !== undefined && memo.legIdx === legIdx && lastThrough >= memo.through;
+    let based = resumable ? memo.based : false;
+    let out = resumable ? memo.out : {};
+    const redactedPaths = new Set(resumable ? memo.redactedPaths : []);
+    let skipped = resumable && memo.skipped ? [...memo.skipped] : undefined;
+    if (resumable) {
+        if (last)
+            skipped = applyLeg(out, last, memo.through, lastThrough, redactedPaths, skipped);
+    }
+    else {
+        for (let leg = 0; leg <= legIdx && leg < legs.length; leg++) {
+            const source = legs[leg];
+            if (source.base && typeof source.base === 'object') {
+                out = structuredClone(source.base);
+                based = true;
+            }
+            const end = leg === legIdx ? lastThrough : source.log.length - 1;
+            skipped = applyLeg(out, source, -1, end, redactedPaths, skipped);
         }
     }
     const basis = based ? 'initial+log' : 'log-only';
-    return {
-        // Law 3, both halves. `applySmartMerge` clones what it OVERWRITES, but the
-        // merge arm's array union (`deepSmartMerge`) carries source element
-        // REFERENCES out of `bundle.updates`. Freezing that directly would freeze
-        // the engine's own recorded bundle — a read-only query mutating the
-        // record. Cloning first detaches those leaves, and costs one clone of the
-        // final state, not one per bundle.
+    const folded = {
         state: freezeDeep(structuredClone(out)),
         basis,
         redacted: redactedPaths.size > 0,
         redactedPaths: Object.freeze([...redactedPaths].sort()),
         throughCommitIdx: lastThrough,
-        // ABSENT when clean: a fold over a live snapshot keeps the 9.17.0 shape.
         ...(skipped ? { skipped: Object.freeze(skipped) } : {}),
     };
+    return { folded, memo: { legIdx, through: lastThrough, out, based, redactedPaths, skipped } };
 }
 /**
  * Fold `source`'s log from its base up to and including `commitIdx`.
@@ -143,4 +159,4 @@ export function stateAt(source, commitIdx) {
     const asked = Number.isNaN(commitIdx) ? -1 : Math.floor(commitIdx);
     return foldLegs([readSource(source)], 0, asked);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stateAt.js","sourceRoot":"","sources":["../../../../src/lib/time-travel/stateAt.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * stateAt — the fold at a stop.\n *\n * The commit log stores DIFFS. Replaying them onto the run's fold base\n * reproduces the state as it stood after any commit — byte-for-byte the state\n * the next stage saw, in both `commitValues` encodings, because the replay\n * runs through `applySmartMerge`, the one verb switch the live commit itself\n * uses. There is deliberately no second implementation of the verbs here.\n */\n\nimport type { CommitBundle, MemoryPatch } from '../memory/types.js';\nimport { applySmartMerge } from '../memory/utils.js';\nimport { readLog } from './bundles.js';\nimport type { FoldBasis, FoldedState, FoldSource, LogGap } from './types.js';\n\n/** Deeply freeze a POJO tree so a fold result cannot be mutated by its holder. */\nfunction freezeDeep<T>(value: T): T {\n  if (value === null || typeof value !== 'object') return value;\n  Object.freeze(value);\n  for (const key of Object.getOwnPropertyNames(value)) {\n    const inner = (value as Record<string, unknown>)[key];\n    if (inner && typeof inner === 'object' && !Object.isFrozen(inner)) freezeDeep(inner);\n  }\n  return value;\n}\n\n/** One source, read: its log (gaps held in place) and its fold base. */\nexport interface ReadSource {\n  readonly log: readonly CommitBundle[];\n  readonly gaps: readonly LogGap[];\n  readonly base: Record<string, unknown> | undefined;\n}\n\n/**\n * Read whichever shape the caller handed us — `commitLog` (a run snapshot) or\n * `history` (a subflow's own log) — narrowing the rows to commit bundles as it\n * goes (see `bundles.ts`: a row that is not one becomes an index-holding gap).\n */\nexport function readSource(source: FoldSource | undefined): ReadSource {\n  const base = (source as { initialState?: Record<string, unknown> } | undefined)?.initialState;\n  if (!source) return { log: [], gaps: [], base };\n  const withLog = source as { commitLog?: readonly unknown[] };\n  const raw = Array.isArray(withLog.commitLog)\n    ? withLog.commitLog\n    : Array.isArray((source as { history?: readonly unknown[] }).history)\n    ? (source as { history: readonly unknown[] }).history\n    : undefined;\n  const { log, gaps } = readLog(raw);\n  return { log, gaps, base };\n}\n\n/**\n * Fold one chain of legs: every leg BEFORE `legIdx` in full, then `legIdx`\n * through `through`.\n *\n * THE LEG RULE. A leg that carries its own `initialState` RESTARTS the\n * accumulation from it — on a pause/resume that base IS the state at the\n * pause, recorded by the engine, and is authoritative over anything the\n * previous leg's log rebuilt. A leg with no base (a pre-9.17 snapshot, a\n * hand-built log) CONTINUES from what the earlier legs folded, which is the\n * best honest answer available and is exactly what `basis` then reports.\n *\n * With a single leg this is the 9.17.0 fold, unchanged.\n */\nexport function foldLegs(legs: readonly ReadSource[], legIdx: number, through: number): FoldedState {\n  let based = false;\n  let out: Record<string, unknown> = {};\n  const redactedPaths = new Set<string>();\n  let skipped: LogGap[] | undefined;\n  let lastThrough = -1;\n\n  for (let leg = 0; leg <= legIdx && leg < legs.length; leg++) {\n    const { log, gaps, base } = legs[leg];\n    if (base && typeof base === 'object') {\n      out = structuredClone(base);\n      based = true;\n    }\n    const end = leg === legIdx ? Math.min(through, log.length - 1) : log.length - 1;\n    if (leg === legIdx) lastThrough = end < -1 ? -1 : end;\n    for (const gap of gaps) {\n      if (gap.index <= end) (skipped ??= []).push(gap);\n    }\n    for (let i = 0; i <= end; i++) {\n      const bundle = log[i];\n      if (!bundle) continue;\n      for (const path of bundle.redactedPaths ?? []) redactedPaths.add(path);\n      out = applySmartMerge(out, bundle.updates as MemoryPatch, bundle.overwrite as MemoryPatch, bundle.trace);\n    }\n  }\n\n  const basis: FoldBasis = based ? 'initial+log' : 'log-only';\n  return {\n    // Law 3, both halves. `applySmartMerge` clones what it OVERWRITES, but the\n    // merge arm's array union (`deepSmartMerge`) carries source element\n    // REFERENCES out of `bundle.updates`. Freezing that directly would freeze\n    // the engine's own recorded bundle — a read-only query mutating the\n    // record. Cloning first detaches those leaves, and costs one clone of the\n    // final state, not one per bundle.\n    state: freezeDeep(structuredClone(out)),\n    basis,\n    redacted: redactedPaths.size > 0,\n    redactedPaths: Object.freeze([...redactedPaths].sort()),\n    throughCommitIdx: lastThrough,\n    // ABSENT when clean: a fold over a live snapshot keeps the 9.17.0 shape.\n    ...(skipped ? { skipped: Object.freeze(skipped) } : {}),\n  };\n}\n\n/**\n * Fold `source`'s log from its base up to and including `commitIdx`.\n *\n * @param source    A run snapshot (`commitLog` + `initialState`) or a subflow\n *                  subtree (`history` + `initialState`). Both spellings work,\n *                  and the rows may be unvalidated (`unknown[]`) — a row that\n *                  is not a commit bundle is skipped and REPORTED, by index,\n *                  in {@link FoldedState.skipped}, never crashed on.\n * @param commitIdx ARRAY INDEX of the last bundle to fold, inclusive. `-1`\n *                  (or any negative) folds nothing and returns the base —\n *                  the state before the run's first commit. Past the end\n *                  clamps to the end; the result's `throughCommitIdx` reports\n *                  where the fold actually stopped.\n *\n * @returns A detached, deeply frozen state plus how it was derived: `basis`\n *   says whether the real fold base was available, `redacted` /\n *   `redactedPaths` say where the log was scrubbed at write time, and\n *   `skipped` says which rows could not be read. The engine redacts values as\n *   it records them, so a replay of a redacted run yields `'REDACTED'` in\n *   those places — correct, and said out loud rather than presented as the\n *   real value.\n *\n * @example\n * ```typescript\n * const snapshot = executor.getSnapshot();\n * const { state, basis } = stateAt(snapshot, 3);   // after the 4th commit\n * console.log(basis, state);                        // 'initial+log' { ... }\n *\n * // A subflow's own log folds identically:\n * const inner = getSubtreeSnapshot(snapshot, 'sf-payment')!;\n * stateAt(inner, 0).state;                          // after the subflow's first commit\n *\n * // A STORED recording needs no cast — its rows are `unknown[]`:\n * const stored = JSON.parse(await fs.readFile(path, 'utf8'));\n * stateAt(stored, 3).skipped;                       // undefined, or the bad rows\n * ```\n */\nexport function stateAt(source: FoldSource | undefined, commitIdx: number): FoldedState {\n  // `NaN` is out of contract; treat it as \"fold nothing\" rather than letting\n  // it flow through the arithmetic into `throughCommitIdx`, where it would\n  // serialize as `null` and tell a consumer nothing about where the fold\n  // stopped. (±Infinity needs no special case: it clamps like any index past\n  // either end.)\n  const asked = Number.isNaN(commitIdx) ? -1 : Math.floor(commitIdx);\n  return foldLegs([readSource(source)], 0, asked);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stateAt.js","sourceRoot":"","sources":["../../../../src/lib/time-travel/stateAt.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAGvC,kFAAkF;AAClF,SAAS,UAAU,CAAI,KAAQ;IAC7B,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC9D,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACrB,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,mBAAmB,CAAC,KAAK,CAAC,EAAE,CAAC;QACpD,MAAM,KAAK,GAAI,KAAiC,CAAC,GAAG,CAAC,CAAC;QACtD,IAAI,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;YAAE,UAAU,CAAC,KAAK,CAAC,CAAC;IACvF,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AASD;;;;GAIG;AACH,MAAM,UAAU,UAAU,CAAC,MAA8B;IACvD,MAAM,IAAI,GAAI,MAAiE,EAAE,YAAY,CAAC;IAC9F,IAAI,CAAC,MAAM;QAAE,OAAO,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC;IAChD,MAAM,OAAO,GAAG,MAA4C,CAAC;IAC7D,MAAM,GAAG,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC;QAC1C,CAAC,CAAC,OAAO,CAAC,SAAS;QACnB,CAAC,CAAC,KAAK,CAAC,OAAO,CAAE,MAA2C,CAAC,OAAO,CAAC;YACrE,CAAC,CAAE,MAA0C,CAAC,OAAO;YACrD,CAAC,CAAC,SAAS,CAAC;IACd,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACnC,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;AAC7B,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,QAAQ,CAAC,IAA2B,EAAE,MAAc,EAAE,OAAe;IACnF,OAAO,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,MAAM,CAAC;AACpD,CAAC;AAkBD,sFAAsF;AACtF,SAAS,QAAQ,CACf,GAA4B,EAC5B,GAAe,EACf,IAAY,EACZ,GAAW,EACX,aAA0B,EAC1B,OAA6B;IAE7B,KAAK,MAAM,GAAG,IAAI,GAAG,CAAC,IAAI,EAAE,CAAC;QAC3B,IAAI,GAAG,CAAC,KAAK,GAAG,IAAI,IAAI,GAAG,CAAC,KAAK,IAAI,GAAG;YAAE,CAAC,OAAO,KAAK,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACvE,CAAC;IACD,KAAK,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,MAAM,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAC1B,IAAI,CAAC,MAAM;YAAE,SAAS;QACtB,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,aAAa,IAAI,EAAE;YAAE,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACvE,mBAAmB,CAAC,GAAG,EAAE,MAAM,CAAC,OAAsB,EAAE,MAAM,CAAC,SAAwB,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACzG,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAC1B,IAA2B,EAC3B,MAAc,EACd,OAAe,EACf,IAAe;IAEf,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;IAC1B,MAAM,QAAQ,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACpE,MAAM,WAAW,GAAG,QAAQ,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;IAClD,MAAM,SAAS,GAAG,IAAI,KAAK,SAAS,IAAI,IAAI,CAAC,MAAM,KAAK,MAAM,IAAI,WAAW,IAAI,IAAI,CAAC,OAAO,CAAC;IAE9F,IAAI,KAAK,GAAG,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;IAC3C,IAAI,GAAG,GAA4B,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;IAC7D,MAAM,aAAa,GAAG,IAAI,GAAG,CAAS,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAC3E,IAAI,OAAO,GAAyB,SAAS,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAE9F,IAAI,SAAS,EAAE,CAAC;QACd,IAAI,IAAI;YAAE,OAAO,GAAG,QAAQ,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;IAC7F,CAAC;SAAM,CAAC;QACN,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,IAAI,MAAM,IAAI,GAAG,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,CAAC;YAC5D,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;YACzB,IAAI,MAAM,CAAC,IAAI,IAAI,OAAO,MAAM,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACnD,GAAG,GAAG,eAAe,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;gBACnC,KAAK,GAAG,IAAI,CAAC;YACf,CAAC;YACD,MAAM,GAAG,GAAG,GAAG,KAAK,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC;YACjE,OAAO,GAAG,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;QACnE,CAAC;IACH,CAAC;IAED,MAAM,KAAK,GAAc,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,UAAU,CAAC;IAC5D,MAAM,MAAM,GAAgB;QAC1B,KAAK,EAAE,UAAU,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;QACvC,KAAK;QACL,QAAQ,EAAE,aAAa,CAAC,IAAI,GAAG,CAAC;QAChC,aAAa,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,IAAI,EAAE,CAAC;QACvD,gBAAgB,EAAE,WAAW;QAC7B,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACxD,CAAC;IACF,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,GAAG,EAAE,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,EAAE,CAAC;AAChG,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,UAAU,OAAO,CAAC,MAA8B,EAAE,SAAiB;IACvE,2EAA2E;IAC3E,yEAAyE;IACzE,uEAAuE;IACvE,2EAA2E;IAC3E,eAAe;IACf,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IACnE,OAAO,QAAQ,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;AAClD,CAAC","sourcesContent":["/**\n * stateAt — the fold at a stop.\n *\n * The commit log stores DIFFS. Replaying them onto the run's fold base\n * reproduces the state as it stood after any commit — byte-for-byte the state\n * the next stage saw, in both `commitValues` encodings, because the replay\n * runs through `applySmartMerge`, the one verb switch the live commit itself\n * uses. There is deliberately no second implementation of the verbs here.\n */\n\nimport type { CommitBundle, MemoryPatch } from '../memory/types.js';\nimport { applySmartMergeInto } from '../memory/utils.js';\nimport { readLog } from './bundles.js';\nimport type { FoldBasis, FoldedState, FoldSource, LogGap } from './types.js';\n\n/** Deeply freeze a POJO tree so a fold result cannot be mutated by its holder. */\nfunction freezeDeep<T>(value: T): T {\n  if (value === null || typeof value !== 'object') return value;\n  Object.freeze(value);\n  for (const key of Object.getOwnPropertyNames(value)) {\n    const inner = (value as Record<string, unknown>)[key];\n    if (inner && typeof inner === 'object' && !Object.isFrozen(inner)) freezeDeep(inner);\n  }\n  return value;\n}\n\n/** One source, read: its log (gaps held in place) and its fold base. */\nexport interface ReadSource {\n  readonly log: readonly CommitBundle[];\n  readonly gaps: readonly LogGap[];\n  readonly base: Record<string, unknown> | undefined;\n}\n\n/**\n * Read whichever shape the caller handed us — `commitLog` (a run snapshot) or\n * `history` (a subflow's own log) — narrowing the rows to commit bundles as it\n * goes (see `bundles.ts`: a row that is not one becomes an index-holding gap).\n */\nexport function readSource(source: FoldSource | undefined): ReadSource {\n  const base = (source as { initialState?: Record<string, unknown> } | undefined)?.initialState;\n  if (!source) return { log: [], gaps: [], base };\n  const withLog = source as { commitLog?: readonly unknown[] };\n  const raw = Array.isArray(withLog.commitLog)\n    ? withLog.commitLog\n    : Array.isArray((source as { history?: readonly unknown[] }).history)\n    ? (source as { history: readonly unknown[] }).history\n    : undefined;\n  const { log, gaps } = readLog(raw);\n  return { log, gaps, base };\n}\n\n/**\n * Fold one chain of legs: every leg BEFORE `legIdx` in full, then `legIdx`\n * through `through`.\n *\n * THE LEG RULE. A leg that carries its own `initialState` RESTARTS the\n * accumulation from it — on a pause/resume that base IS the state at the\n * pause, recorded by the engine, and is authoritative over anything the\n * previous leg's log rebuilt. A leg with no base (a pre-9.17 snapshot, a\n * hand-built log) CONTINUES from what the earlier legs folded, which is the\n * best honest answer available and is exactly what `basis` then reports.\n *\n * With a single leg this is the 9.17.0 fold, unchanged.\n */\nexport function foldLegs(legs: readonly ReadSource[], legIdx: number, through: number): FoldedState {\n  return foldLegsFrom(legs, legIdx, through).folded;\n}\n\n/**\n * What a fold leaves behind for the NEXT one (9.25.0): the private working\n * copy and the facts accumulated so far. A cursor stepping forward on the\n * same leg hands it back and only the bundles after `through` are applied —\n * one bundle per step instead of a replay from the base. Any other ask (an\n * earlier stop, another leg) folds from scratch; the memo is never a claim.\n */\nexport interface FoldMemo {\n  readonly legIdx: number;\n  readonly through: number;\n  readonly out: Record<string, unknown>;\n  readonly based: boolean;\n  readonly redactedPaths: ReadonlySet<string>;\n  readonly skipped: readonly LogGap[] | undefined;\n}\n\n/** Apply `log[from + 1 .. end]` of one leg into `out`, collecting the leg's facts. */\nfunction applyLeg(\n  out: Record<string, unknown>,\n  leg: ReadSource,\n  from: number,\n  end: number,\n  redactedPaths: Set<string>,\n  skipped: LogGap[] | undefined,\n): LogGap[] | undefined {\n  for (const gap of leg.gaps) {\n    if (gap.index > from && gap.index <= end) (skipped ??= []).push(gap);\n  }\n  for (let i = from + 1; i <= end; i++) {\n    const bundle = leg.log[i];\n    if (!bundle) continue;\n    for (const path of bundle.redactedPaths ?? []) redactedPaths.add(path);\n    applySmartMergeInto(out, bundle.updates as MemoryPatch, bundle.overwrite as MemoryPatch, bundle.trace);\n  }\n  return skipped;\n}\n\n/**\n * The fold, resumable. ONE clone per fold: the base is cloned once (or `{}`\n * stands in), every bundle is applied INTO that copy, and the state handed\n * out is one more clone, frozen — so the working copy stays private and a\n * later step can continue from it. Same answer as the 9.17.0 fold, pinned by\n * test/lib/time-travel/fold-memo.test.ts against a fresh fold at every stop.\n */\nexport function foldLegsFrom(\n  legs: readonly ReadSource[],\n  legIdx: number,\n  through: number,\n  memo?: FoldMemo,\n): { readonly folded: FoldedState; readonly memo: FoldMemo } {\n  const last = legs[legIdx];\n  const endOnLeg = last ? Math.min(through, last.log.length - 1) : -1;\n  const lastThrough = endOnLeg < -1 ? -1 : endOnLeg;\n  const resumable = memo !== undefined && memo.legIdx === legIdx && lastThrough >= memo.through;\n\n  let based = resumable ? memo.based : false;\n  let out: Record<string, unknown> = resumable ? memo.out : {};\n  const redactedPaths = new Set<string>(resumable ? memo.redactedPaths : []);\n  let skipped: LogGap[] | undefined = resumable && memo.skipped ? [...memo.skipped] : undefined;\n\n  if (resumable) {\n    if (last) skipped = applyLeg(out, last, memo.through, lastThrough, redactedPaths, skipped);\n  } else {\n    for (let leg = 0; leg <= legIdx && leg < legs.length; leg++) {\n      const source = legs[leg];\n      if (source.base && typeof source.base === 'object') {\n        out = structuredClone(source.base);\n        based = true;\n      }\n      const end = leg === legIdx ? lastThrough : source.log.length - 1;\n      skipped = applyLeg(out, source, -1, end, redactedPaths, skipped);\n    }\n  }\n\n  const basis: FoldBasis = based ? 'initial+log' : 'log-only';\n  const folded: FoldedState = {\n    state: freezeDeep(structuredClone(out)),\n    basis,\n    redacted: redactedPaths.size > 0,\n    redactedPaths: Object.freeze([...redactedPaths].sort()),\n    throughCommitIdx: lastThrough,\n    ...(skipped ? { skipped: Object.freeze(skipped) } : {}),\n  };\n  return { folded, memo: { legIdx, through: lastThrough, out, based, redactedPaths, skipped } };\n}\n\n/**\n * Fold `source`'s log from its base up to and including `commitIdx`.\n *\n * @param source    A run snapshot (`commitLog` + `initialState`) or a subflow\n *                  subtree (`history` + `initialState`). Both spellings work,\n *                  and the rows may be unvalidated (`unknown[]`) — a row that\n *                  is not a commit bundle is skipped and REPORTED, by index,\n *                  in {@link FoldedState.skipped}, never crashed on.\n * @param commitIdx ARRAY INDEX of the last bundle to fold, inclusive. `-1`\n *                  (or any negative) folds nothing and returns the base —\n *                  the state before the run's first commit. Past the end\n *                  clamps to the end; the result's `throughCommitIdx` reports\n *                  where the fold actually stopped.\n *\n * @returns A detached, deeply frozen state plus how it was derived: `basis`\n *   says whether the real fold base was available, `redacted` /\n *   `redactedPaths` say where the log was scrubbed at write time, and\n *   `skipped` says which rows could not be read. The engine redacts values as\n *   it records them, so a replay of a redacted run yields `'REDACTED'` in\n *   those places — correct, and said out loud rather than presented as the\n *   real value.\n *\n * @example\n * ```typescript\n * const snapshot = executor.getSnapshot();\n * const { state, basis } = stateAt(snapshot, 3);   // after the 4th commit\n * console.log(basis, state);                        // 'initial+log' { ... }\n *\n * // A subflow's own log folds identically:\n * const inner = getSubtreeSnapshot(snapshot, 'sf-payment')!;\n * stateAt(inner, 0).state;                          // after the subflow's first commit\n *\n * // A STORED recording needs no cast — its rows are `unknown[]`:\n * const stored = JSON.parse(await fs.readFile(path, 'utf8'));\n * stateAt(stored, 3).skipped;                       // undefined, or the bad rows\n * ```\n */\nexport function stateAt(source: FoldSource | undefined, commitIdx: number): FoldedState {\n  // `NaN` is out of contract; treat it as \"fold nothing\" rather than letting\n  // it flow through the arithmetic into `throughCommitIdx`, where it would\n  // serialize as `null` and tell a consumer nothing about where the fold\n  // stopped. (±Infinity needs no special case: it clamps like any index past\n  // either end.)\n  const asked = Number.isNaN(commitIdx) ? -1 : Math.floor(commitIdx);\n  return foldLegs([readSource(source)], 0, asked);\n}\n"]}