footprintjs 9.6.0 → 9.7.0

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

@@ -26,9 +26,12 @@ export class TransactionBuffer {
     updatePatch = {};
     opTrace = [];
     redactedPaths = new Set();
-    constructor(base) {
+    /** Commit-value encoding policy (#13c-B). `'full'` = historical bytes. */
+    commitValues;
+    constructor(base, commitValues = 'full') {
         this.baseSnapshot = structuredClone(base);
         this.workingCopy = structuredClone(base);
+        this.commitValues = commitValues;
     }
     /** Hard overwrite at the specified path. */
     set(path, value, shouldRedact = false) {
@@ -39,6 +42,25 @@ export class TransactionBuffer {
         }
         this.opTrace.push({ path: normalisePath(path), verb: 'set' });
     }
+    /**
+     * Explicit key deletion at the specified path (#13c-B; absorbs backlog B8).
+     *
+     * Stages EXACTLY the same buffer mutations as `set(path, undefined)` —
+     * `workingCopy`/`overwritePatch` get an own `undefined` at the path (the
+     * historical flattening, preserving read behavior and the dedup diff base
+     * across modes) — but records the op verb as `'delete'`. At commit:
+     * `'full'` mode maps it back to a `'set'` trace entry (byte-identical to
+     * today); `'delta'` mode emits a real `'delete'` entry whose replay
+     * REMOVES the key instead of leaving `key: undefined` behind.
+     */
+    delete(path, shouldRedact = false) {
+        _set(this.workingCopy, path, undefined);
+        _set(this.overwritePatch, path, undefined);
+        if (shouldRedact) {
+            this.redactedPaths.add(normalisePath(path));
+        }
+        this.opTrace.push({ path: normalisePath(path), verb: 'delete' });
+    }
     /** Deep union merge at the specified path. */
     merge(path, value, shouldRedact = false) {
         const existing = _get(this.workingCopy, path) ?? {};
@@ -101,10 +123,11 @@ export class TransactionBuffer {
      * commit-indexed slider stable while making the highlight truthful.
      *
      * ── KNOWN LIMITATIONS / FUTURE ──────────────────────────────────────────
-     *   • Explicit key DELETION is still unrepresentable in MemoryPatch (a removed
-     *     key cannot be expressed). Setting a key to `undefined` is treated as a
-     *     change (value differs from base), not a deletion. Tracked for a future
-     *     `delete` verb.
+     *   • Explicit key DELETION under the default 'full' mode is still
+     *     flattened to set-of-`undefined` (a removed key cannot be expressed
+     *     in MemoryPatch alone). CLOSED under `commitValues: 'delta'` (#13c-B):
+     *     {@link delete} stages a distinct op and the bundle carries a real
+     *     `delete` trace verb whose replay removes the key.
      *   • Array-merge dedup in {@link deepSmartMerge} still uses reference equality
      *     (`new Set`), so deep-equal *objects* in a merged array are not deduped.
      *     Orthogonal to this change; tracked separately.
@@ -112,7 +135,7 @@ export class TransactionBuffer {
      * Resets the buffer to empty state after commit.
      */
     commit() {
-        const payload = this.toChangeOnlyPayload();
+        const payload = this.commitValues === 'delta' ? this.toDeltaPayload() : this.toChangeOnlyPayload();
         this.overwritePatch = {};
         this.updatePatch = {};
         this.opTrace.length = 0;
@@ -131,6 +154,11 @@ export class TransactionBuffer {
      * surviving `merge` paths copy their accumulated delta from `updatePatch` —
      * preserving the set-vs-merge verb so replay ({@link applySmartMerge}) is
      * byte-for-byte identical to recording only the real changes.
+     *
+     * This is the DEFAULT (`commitValues: 'full'`) payload — byte-identical to
+     * the historical behavior, including flattening staged `delete` ops into
+     * `set`-of-`undefined` trace entries. The delta encoding lives in
+     * {@link toDeltaPayload}.
      */
     toChangeOnlyPayload() {
         const overwrite = {};
@@ -143,17 +171,146 @@ export class TransactionBuffer {
             const after = _get(this.workingCopy, segments);
             if (deepEqual(before, after))
                 continue; // no-op or write-then-revert → no net change
-            trace.push(op);
+            // Historical flattening: an explicit delete commits as set-of-undefined.
+            trace.push(op.verb === 'delete' ? { path: op.path, verb: 'set' } : op);
             survivingPaths.add(op.path);
-            if (op.verb === 'set') {
+            if (op.verb === 'merge') {
+                _set(updates, segments, structuredClone(_get(this.updatePatch, segments)));
+            }
+            else {
                 _set(overwrite, segments, structuredClone(_get(this.overwritePatch, segments)));
             }
+        }
+        const redactedPaths = new Set([...this.redactedPaths].filter((path) => survivingPaths.has(path)));
+        return { overwrite, updates, redactedPaths, trace };
+    }
+    /**
+     * Delta-encoded payload (`commitValues: 'delta'`, #13c-B) — same net-change
+     * filter as {@link toChangeOnlyPayload}, two encoding differences:
+     *
+     * 1. **One trace entry per surviving path** (the §2.5 dedup rule — `append`
+     *    is NOT idempotent on replay, so duplicate entries would multiply
+     *    tails). The verb is resolved from the path's op mix + base→final
+     *    relationship; entries are ordered by each path's LAST touch,
+     *    preserving last-writer-wins for nested/overlapping paths.
+     * 2. **Verb resolution per path**:
+     *    - last op `'delete'` AND final value gone → `delete` (the path stays
+     *      enumerated in `overwrite` with `undefined` for key-set consumers);
+     *    - ONLY `'merge'` ops → `merge` with the accumulated `updatePatch`
+     *      delta (replaying the accumulated delta once ≡ the full mode's
+     *      k sequential replays — `deepSmartMerge` is reference-idempotent
+     *      within one replay pass);
+     *    - otherwise (`set`/mixed): the committed value is computed by
+     *      replaying the path's op sequence EXACTLY the way `applySmartMerge`
+     *      replays the full-mode bundle ({@link replayPathVerbs}) — for
+     *      pure-set paths that is simply the last set value; for mixed
+     *      set+merge interleavings it reproduces the full mode's quirk of
+     *      applying the ACCUMULATED merge delta at every merge position
+     *      (which can differ from the buffer's read-your-writes view; parity
+     *      with the `'full'` mode's committed state is the contract). If base
+     *      and that value are arrays and base is a STRICT PREFIX → `append`
+     *      storing only the tail; else `set` storing the full value.
+     *
+     * Losslessness never depends on detection succeeding — every fallback is
+     * today's full-value `set`.
+     */
+    toDeltaPayload() {
+        const overwrite = {};
+        const updates = {};
+        const trace = [];
+        const survivingPaths = new Set();
+        // Path → its op-verb sequence, ordered by LAST touch (delete +
+        // re-insert moves a re-touched path to the end of the Map's insertion
+        // order — preserving last-writer-wins for nested/overlapping paths).
+        const byPath = new Map();
+        for (const op of this.opTrace) {
+            const prev = byPath.get(op.path);
+            if (prev) {
+                prev.push(op.verb);
+                byPath.delete(op.path);
+                byPath.set(op.path, prev);
+            }
             else {
+                byPath.set(op.path, [op.verb]);
+            }
+        }
+        for (const [path, verbs] of byPath) {
+            const segments = path.split(DELIM);
+            const before = _get(this.baseSnapshot, segments);
+            const after = _get(this.workingCopy, segments);
+            if (deepEqual(before, after))
+                continue; // no-op or write-then-revert → no net change (same filter as 'full')
+            survivingPaths.add(path);
+            const lastVerb = verbs[verbs.length - 1];
+            if (lastVerb === 'delete' && after === undefined) {
+                // Real deletion — replay removes the key. Keep the path enumerated
+                // in `overwrite` (undefined) so Object.keys consumers see it.
+                trace.push({ path, verb: 'delete' });
+                _set(overwrite, segments, undefined);
+            }
+            else if (verbs.every((v) => v === 'merge')) {
+                trace.push({ path, verb: 'merge' });
                 _set(updates, segments, structuredClone(_get(this.updatePatch, segments)));
             }
+            else {
+                // Committed-equivalent value: replay this path's op sequence the way
+                // applySmartMerge replays the FULL-mode bundle, so both modes commit
+                // byte-identical state (see the method JSDoc).
+                const committed = this.replayPathVerbs(before, segments, verbs);
+                if (isStrictArrayPrefix(before, committed)) {
+                    trace.push({ path, verb: 'append' });
+                    _set(overwrite, segments, structuredClone(committed.slice(before.length)));
+                }
+                else {
+                    trace.push({ path, verb: 'set' });
+                    _set(overwrite, segments, structuredClone(committed));
+                }
+            }
         }
         const redactedPaths = new Set([...this.redactedPaths].filter((path) => survivingPaths.has(path)));
         return { overwrite, updates, redactedPaths, trace };
     }
+    /**
+     * Replay ONE path's op-verb sequence against its base value, exactly the
+     * way `applySmartMerge` replays the corresponding full-mode bundle: every
+     * `set`/`delete` position applies the LAST staged overwrite value (the
+     * bag holds one value per path — last writer wins), every `merge`
+     * position applies the ACCUMULATED `updatePatch` delta. This reproduces
+     * the full mode's committed value for any interleaving — including the
+     * mixed set+merge quirk where the accumulated delta re-applies pre-set
+     * merge keys (full-mode replay semantics, kept for byte-parity across
+     * modes; property-tested in delta-replay-equivalence).
+     */
+    replayPathVerbs(before, segments, verbs) {
+        const setValue = _get(this.overwritePatch, segments);
+        const mergeDelta = _get(this.updatePatch, segments);
+        let value = before;
+        for (const verb of verbs) {
+            value = verb === 'merge' ? deepSmartMerge(value ?? {}, mergeDelta) : setValue;
+        }
+        return value;
+    }
+}
+/**
+ * Append-detection predicate (#13c-B §2.2): both values are arrays, the
+ * final is strictly longer, and the base is a structural prefix of the
+ * final. Element compares short-circuit on reference identity (`deepEqual`'s
+ * `===` fast path) before walking structure, and bail at the first mismatch
+ * — worst case one structural compare of the base array, strictly cheaper
+ * than the full-value `structuredClone` the fallback pays.
+ *
+ * `before === undefined` (first write) fails `Array.isArray` → `set`, which
+ * keeps the first write as the causal anchor for "who initialized this key".
+ */
+function isStrictArrayPrefix(before, after) {
+    if (!Array.isArray(before) || !Array.isArray(after))
+        return false;
+    if (after.length <= before.length)
+        return false;
+    for (let i = 0; i < before.length; i++) {
+        if (!deepEqual(before[i], after[i]))
+            return false;
+    }
+    return true;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TransactionBuffer.js","sourceRoot":"","sources":["../../../../src/lib/memory/TransactionBuffer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * TransactionBuffer — Per-stage STAGING buffer for state mutations\n *\n * What it IS: a staging buffer with read-your-writes and net-change commits.\n * - Changes are staged here during stage execution and flushed to\n *   SharedMemory in ONE batch per stage (`commit()`) — other stages and\n *   parallel siblings never observe a stage's half-finished writes.\n * - Read-after-write consistency within a stage — a stage sees its own\n *   staged writes immediately.\n * - `commit()` records the stage's NET change (see {@link commit}), plus an\n *   operation trace for deterministic replay.\n *\n * What it is NOT: a rollback mechanism. Despite the name, there is no\n * abort/rollback path — when a stage THROWS, the engine still commits\n * everything staged so far before re-throwing (commit-on-error in\n * `FlowchartTraverser`). That is deliberate: the audit trail must record\n * what the failing stage changed. Do not rely on \"stage failed → its\n * writes vanished\".\n */\n\nimport { nativeGet as _get, nativeSet as _set } from './pathOps.js';\nimport type { MemoryPatch } from './types.js';\nimport { deepEqual, deepSmartMerge, DELIM, normalisePath } from './utils.js';\n\nexport class TransactionBuffer {\n  private readonly baseSnapshot: any;\n  private workingCopy: any;\n\n  private overwritePatch: MemoryPatch = {};\n  private updatePatch: MemoryPatch = {};\n  private opTrace: { path: string; verb: 'set' | 'merge' }[] = [];\n  private redactedPaths = new Set<string>();\n\n  constructor(base: any) {\n    this.baseSnapshot = structuredClone(base);\n    this.workingCopy = structuredClone(base);\n  }\n\n  /** Hard overwrite at the specified path. */\n  set(path: (string | number)[], value: any, shouldRedact = false): void {\n    _set(this.workingCopy, path, value);\n    _set(this.overwritePatch, path, structuredClone(value));\n    if (shouldRedact) {\n      this.redactedPaths.add(normalisePath(path));\n    }\n    this.opTrace.push({ path: normalisePath(path), verb: 'set' });\n  }\n\n  /** Deep union merge at the specified path. */\n  merge(path: (string | number)[], value: any, shouldRedact = false): void {\n    const existing = _get(this.workingCopy, path) ?? {};\n    const merged = deepSmartMerge(existing, value);\n    _set(this.workingCopy, path, merged);\n    _set(this.updatePatch, path, deepSmartMerge(_get(this.updatePatch, path) ?? {}, value));\n    if (shouldRedact) {\n      this.redactedPaths.add(normalisePath(path));\n    }\n    this.opTrace.push({ path: normalisePath(path), verb: 'merge' });\n  }\n\n  /** Read current value at path (includes uncommitted changes). */\n  get(path: (string | number)[], defaultValue?: any) {\n    return _get(this.workingCopy, path, defaultValue);\n  }\n\n  /**\n   * Flush all staged mutations and return the commit bundle — recording the\n   * stage's NET CHANGE, not its raw write log.\n   *\n   * ── WHY (the defect this fixes) ─────────────────────────────────────────\n   * Previously every `set`/`merge` was recorded verbatim, so the commit bundle\n   * was a log of *operations* rather than *changes*. Two operations produce no\n   * net change yet were still committed as \"mutations\":\n   *\n   *   1. No-op write   — writing a key the value it already holds (e.g. an\n   *                      agent context slot re-emitting identical content every\n   *                      turn). base K=1, stage writes K=1.\n   *   2. Write-revert  — changing then restoring a key within one stage.\n   *                      base K=1, stage writes K=2 then K=1.\n   *\n   * Recording these as mutations (a) bloated causal slicing / backtracking with\n   * spurious dependencies on intermediate values that never reach final state,\n   * and (b) made downstream \"what changed here?\" consumers light up stages that\n   * changed nothing — most visibly the lens highlight flagging every slot.\n   *\n   * ── HOW ─────────────────────────────────────────────────────────────────\n   * At commit we hold BOTH `baseSnapshot` (state when the stage began) and\n   * `workingCopy` (state after all its writes). For each path the stage touched\n   * we keep it in the bundle ONLY if its final value differs from the base\n   * value ({@link deepEqual}). No-op AND write-revert paths drop out, because\n   * both compare equal to base. This is a single net-delta diff at commit time\n   * — one deep compare per touched path, O(changed state), paid once per stage\n   * (NOT per write). A naive per-write deep-equal skip would be more expensive\n   * and would still miss write-revert (the intermediate write differs from the\n   * value present at the moment of writing).\n   *\n   * ── TWO HONEST TIERS (by design — do not \"unify\" them) ──────────────────\n   *   • commit (here)   = CHANGE-level — truthful net delta. Feeds the commit\n   *                       log, causal chain, narrative, and the lens highlight.\n   *   • `onWrite` event = OP-level — fires on EVERY write attempt regardless of\n   *                       net change. Feeds metrics / behavioural observability\n   *                       (a debugger wants to see \"wrote 2, then reverted\").\n   * `onWrite` is unchanged by this method; only the COMMIT becomes change-only.\n   *\n   * ── EMPTY COMMITS ARE INTENTIONAL ───────────────────────────────────────\n   * A stage that nets no change commits an EMPTY patch — NOT nothing.\n   * {@link StageContext.commit} still records the bundle unconditionally, so\n   * every executed stage remains a time-travel cursor stop (its `runtimeStageId`\n   * marker is preserved); only its PATCH is empty. This is what keeps the\n   * commit-indexed slider stable while making the highlight truthful.\n   *\n   * ── KNOWN LIMITATIONS / FUTURE ──────────────────────────────────────────\n   *   • Explicit key DELETION is still unrepresentable in MemoryPatch (a removed\n   *     key cannot be expressed). Setting a key to `undefined` is treated as a\n   *     change (value differs from base), not a deletion. Tracked for a future\n   *     `delete` verb.\n   *   • Array-merge dedup in {@link deepSmartMerge} still uses reference equality\n   *     (`new Set`), so deep-equal *objects* in a merged array are not deduped.\n   *     Orthogonal to this change; tracked separately.\n   *\n   * Resets the buffer to empty state after commit.\n   */\n  commit(): {\n    overwrite: MemoryPatch;\n    updates: MemoryPatch;\n    redactedPaths: Set<string>;\n    trace: { path: string; verb: 'set' | 'merge' }[];\n  } {\n    const payload = this.toChangeOnlyPayload();\n\n    this.overwritePatch = {};\n    this.updatePatch = {};\n    this.opTrace.length = 0;\n    this.redactedPaths.clear();\n    this.workingCopy = {};\n\n    return payload;\n  }\n\n  /**\n   * Rebuild overwrite / updates / trace keeping ONLY paths whose final value\n   * differs from the base value — i.e. the stage's net change. See\n   * {@link TransactionBuffer.commit} for the rationale.\n   *\n   * Paths are compared at the exact granularity they were written (each trace\n   * entry's path), against `workingCopy` (final) vs `baseSnapshot` (start).\n   * Surviving `set` paths copy their final value from `overwritePatch`;\n   * surviving `merge` paths copy their accumulated delta from `updatePatch` —\n   * preserving the set-vs-merge verb so replay ({@link applySmartMerge}) is\n   * byte-for-byte identical to recording only the real changes.\n   */\n  private toChangeOnlyPayload(): {\n    overwrite: MemoryPatch;\n    updates: MemoryPatch;\n    redactedPaths: Set<string>;\n    trace: { path: string; verb: 'set' | 'merge' }[];\n  } {\n    const overwrite: MemoryPatch = {};\n    const updates: MemoryPatch = {};\n    const trace: { path: string; verb: 'set' | 'merge' }[] = [];\n    const survivingPaths = new Set<string>();\n\n    for (const op of this.opTrace) {\n      const segments = op.path.split(DELIM);\n      const before = _get(this.baseSnapshot, segments);\n      const after = _get(this.workingCopy, segments);\n      if (deepEqual(before, after)) continue; // no-op or write-then-revert → no net change\n\n      trace.push(op);\n      survivingPaths.add(op.path);\n      if (op.verb === 'set') {\n        _set(overwrite, segments, structuredClone(_get(this.overwritePatch, segments)));\n      } else {\n        _set(updates, segments, structuredClone(_get(this.updatePatch, segments)));\n      }\n    }\n\n    const redactedPaths = new Set([...this.redactedPaths].filter((path) => survivingPaths.has(path)));\n    return { overwrite, updates, redactedPaths, trace };\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TransactionBuffer.js","sourceRoot":"","sources":["../../../../src/lib/memory/TransactionBuffer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * TransactionBuffer — Per-stage STAGING buffer for state mutations\n *\n * What it IS: a staging buffer with read-your-writes and net-change commits.\n * - Changes are staged here during stage execution and flushed to\n *   SharedMemory in ONE batch per stage (`commit()`) — other stages and\n *   parallel siblings never observe a stage's half-finished writes.\n * - Read-after-write consistency within a stage — a stage sees its own\n *   staged writes immediately.\n * - `commit()` records the stage's NET change (see {@link commit}), plus an\n *   operation trace for deterministic replay.\n *\n * What it is NOT: a rollback mechanism. Despite the name, there is no\n * abort/rollback path — when a stage THROWS, the engine still commits\n * everything staged so far before re-throwing (commit-on-error in\n * `FlowchartTraverser`). That is deliberate: the audit trail must record\n * what the failing stage changed. Do not rely on \"stage failed → its\n * writes vanished\".\n */\n\nimport { nativeGet as _get, nativeSet as _set } from './pathOps.js';\nimport type { CommitValuesMode, MemoryPatch, TraceEntry } from './types.js';\nimport { deepEqual, deepSmartMerge, DELIM, normalisePath } from './utils.js';\n\n/** Op-level verbs staged into `opTrace`. `'delete'` is staged distinctly so\n *  delta-mode commits (#13c-B) can emit a real `delete` trace entry; under\n *  the default `'full'` mode it commits as `'set'` (of `undefined`) —\n *  byte-identical to the historical flattening. */\ntype OpVerb = 'set' | 'merge' | 'delete';\n\nexport class TransactionBuffer {\n  private readonly baseSnapshot: any;\n  private workingCopy: any;\n\n  private overwritePatch: MemoryPatch = {};\n  private updatePatch: MemoryPatch = {};\n  private opTrace: { path: string; verb: OpVerb }[] = [];\n  private redactedPaths = new Set<string>();\n  /** Commit-value encoding policy (#13c-B). `'full'` = historical bytes. */\n  private readonly commitValues: CommitValuesMode;\n\n  constructor(base: any, commitValues: CommitValuesMode = 'full') {\n    this.baseSnapshot = structuredClone(base);\n    this.workingCopy = structuredClone(base);\n    this.commitValues = commitValues;\n  }\n\n  /** Hard overwrite at the specified path. */\n  set(path: (string | number)[], value: any, shouldRedact = false): void {\n    _set(this.workingCopy, path, value);\n    _set(this.overwritePatch, path, structuredClone(value));\n    if (shouldRedact) {\n      this.redactedPaths.add(normalisePath(path));\n    }\n    this.opTrace.push({ path: normalisePath(path), verb: 'set' });\n  }\n\n  /**\n   * Explicit key deletion at the specified path (#13c-B; absorbs backlog B8).\n   *\n   * Stages EXACTLY the same buffer mutations as `set(path, undefined)` —\n   * `workingCopy`/`overwritePatch` get an own `undefined` at the path (the\n   * historical flattening, preserving read behavior and the dedup diff base\n   * across modes) — but records the op verb as `'delete'`. At commit:\n   * `'full'` mode maps it back to a `'set'` trace entry (byte-identical to\n   * today); `'delta'` mode emits a real `'delete'` entry whose replay\n   * REMOVES the key instead of leaving `key: undefined` behind.\n   */\n  delete(path: (string | number)[], shouldRedact = false): void {\n    _set(this.workingCopy, path, undefined);\n    _set(this.overwritePatch, path, undefined);\n    if (shouldRedact) {\n      this.redactedPaths.add(normalisePath(path));\n    }\n    this.opTrace.push({ path: normalisePath(path), verb: 'delete' });\n  }\n\n  /** Deep union merge at the specified path. */\n  merge(path: (string | number)[], value: any, shouldRedact = false): void {\n    const existing = _get(this.workingCopy, path) ?? {};\n    const merged = deepSmartMerge(existing, value);\n    _set(this.workingCopy, path, merged);\n    _set(this.updatePatch, path, deepSmartMerge(_get(this.updatePatch, path) ?? {}, value));\n    if (shouldRedact) {\n      this.redactedPaths.add(normalisePath(path));\n    }\n    this.opTrace.push({ path: normalisePath(path), verb: 'merge' });\n  }\n\n  /** Read current value at path (includes uncommitted changes). */\n  get(path: (string | number)[], defaultValue?: any) {\n    return _get(this.workingCopy, path, defaultValue);\n  }\n\n  /**\n   * Flush all staged mutations and return the commit bundle — recording the\n   * stage's NET CHANGE, not its raw write log.\n   *\n   * ── WHY (the defect this fixes) ─────────────────────────────────────────\n   * Previously every `set`/`merge` was recorded verbatim, so the commit bundle\n   * was a log of *operations* rather than *changes*. Two operations produce no\n   * net change yet were still committed as \"mutations\":\n   *\n   *   1. No-op write   — writing a key the value it already holds (e.g. an\n   *                      agent context slot re-emitting identical content every\n   *                      turn). base K=1, stage writes K=1.\n   *   2. Write-revert  — changing then restoring a key within one stage.\n   *                      base K=1, stage writes K=2 then K=1.\n   *\n   * Recording these as mutations (a) bloated causal slicing / backtracking with\n   * spurious dependencies on intermediate values that never reach final state,\n   * and (b) made downstream \"what changed here?\" consumers light up stages that\n   * changed nothing — most visibly the lens highlight flagging every slot.\n   *\n   * ── HOW ─────────────────────────────────────────────────────────────────\n   * At commit we hold BOTH `baseSnapshot` (state when the stage began) and\n   * `workingCopy` (state after all its writes). For each path the stage touched\n   * we keep it in the bundle ONLY if its final value differs from the base\n   * value ({@link deepEqual}). No-op AND write-revert paths drop out, because\n   * both compare equal to base. This is a single net-delta diff at commit time\n   * — one deep compare per touched path, O(changed state), paid once per stage\n   * (NOT per write). A naive per-write deep-equal skip would be more expensive\n   * and would still miss write-revert (the intermediate write differs from the\n   * value present at the moment of writing).\n   *\n   * ── TWO HONEST TIERS (by design — do not \"unify\" them) ──────────────────\n   *   • commit (here)   = CHANGE-level — truthful net delta. Feeds the commit\n   *                       log, causal chain, narrative, and the lens highlight.\n   *   • `onWrite` event = OP-level — fires on EVERY write attempt regardless of\n   *                       net change. Feeds metrics / behavioural observability\n   *                       (a debugger wants to see \"wrote 2, then reverted\").\n   * `onWrite` is unchanged by this method; only the COMMIT becomes change-only.\n   *\n   * ── EMPTY COMMITS ARE INTENTIONAL ───────────────────────────────────────\n   * A stage that nets no change commits an EMPTY patch — NOT nothing.\n   * {@link StageContext.commit} still records the bundle unconditionally, so\n   * every executed stage remains a time-travel cursor stop (its `runtimeStageId`\n   * marker is preserved); only its PATCH is empty. This is what keeps the\n   * commit-indexed slider stable while making the highlight truthful.\n   *\n   * ── KNOWN LIMITATIONS / FUTURE ──────────────────────────────────────────\n   *   • Explicit key DELETION under the default 'full' mode is still\n   *     flattened to set-of-`undefined` (a removed key cannot be expressed\n   *     in MemoryPatch alone). CLOSED under `commitValues: 'delta'` (#13c-B):\n   *     {@link delete} stages a distinct op and the bundle carries a real\n   *     `delete` trace verb whose replay removes the key.\n   *   • Array-merge dedup in {@link deepSmartMerge} still uses reference equality\n   *     (`new Set`), so deep-equal *objects* in a merged array are not deduped.\n   *     Orthogonal to this change; tracked separately.\n   *\n   * Resets the buffer to empty state after commit.\n   */\n  commit(): {\n    overwrite: MemoryPatch;\n    updates: MemoryPatch;\n    redactedPaths: Set<string>;\n    trace: TraceEntry[];\n  } {\n    const payload = this.commitValues === 'delta' ? this.toDeltaPayload() : this.toChangeOnlyPayload();\n\n    this.overwritePatch = {};\n    this.updatePatch = {};\n    this.opTrace.length = 0;\n    this.redactedPaths.clear();\n    this.workingCopy = {};\n\n    return payload;\n  }\n\n  /**\n   * Rebuild overwrite / updates / trace keeping ONLY paths whose final value\n   * differs from the base value — i.e. the stage's net change. See\n   * {@link TransactionBuffer.commit} for the rationale.\n   *\n   * Paths are compared at the exact granularity they were written (each trace\n   * entry's path), against `workingCopy` (final) vs `baseSnapshot` (start).\n   * Surviving `set` paths copy their final value from `overwritePatch`;\n   * surviving `merge` paths copy their accumulated delta from `updatePatch` —\n   * preserving the set-vs-merge verb so replay ({@link applySmartMerge}) is\n   * byte-for-byte identical to recording only the real changes.\n   *\n   * This is the DEFAULT (`commitValues: 'full'`) payload — byte-identical to\n   * the historical behavior, including flattening staged `delete` ops into\n   * `set`-of-`undefined` trace entries. The delta encoding lives in\n   * {@link toDeltaPayload}.\n   */\n  private toChangeOnlyPayload(): {\n    overwrite: MemoryPatch;\n    updates: MemoryPatch;\n    redactedPaths: Set<string>;\n    trace: TraceEntry[];\n  } {\n    const overwrite: MemoryPatch = {};\n    const updates: MemoryPatch = {};\n    const trace: TraceEntry[] = [];\n    const survivingPaths = new Set<string>();\n\n    for (const op of this.opTrace) {\n      const segments = op.path.split(DELIM);\n      const before = _get(this.baseSnapshot, segments);\n      const after = _get(this.workingCopy, segments);\n      if (deepEqual(before, after)) continue; // no-op or write-then-revert → no net change\n\n      // Historical flattening: an explicit delete commits as set-of-undefined.\n      trace.push(op.verb === 'delete' ? { path: op.path, verb: 'set' } : op);\n      survivingPaths.add(op.path);\n      if (op.verb === 'merge') {\n        _set(updates, segments, structuredClone(_get(this.updatePatch, segments)));\n      } else {\n        _set(overwrite, segments, structuredClone(_get(this.overwritePatch, segments)));\n      }\n    }\n\n    const redactedPaths = new Set([...this.redactedPaths].filter((path) => survivingPaths.has(path)));\n    return { overwrite, updates, redactedPaths, trace };\n  }\n\n  /**\n   * Delta-encoded payload (`commitValues: 'delta'`, #13c-B) — same net-change\n   * filter as {@link toChangeOnlyPayload}, two encoding differences:\n   *\n   * 1. **One trace entry per surviving path** (the §2.5 dedup rule — `append`\n   *    is NOT idempotent on replay, so duplicate entries would multiply\n   *    tails). The verb is resolved from the path's op mix + base→final\n   *    relationship; entries are ordered by each path's LAST touch,\n   *    preserving last-writer-wins for nested/overlapping paths.\n   * 2. **Verb resolution per path**:\n   *    - last op `'delete'` AND final value gone → `delete` (the path stays\n   *      enumerated in `overwrite` with `undefined` for key-set consumers);\n   *    - ONLY `'merge'` ops → `merge` with the accumulated `updatePatch`\n   *      delta (replaying the accumulated delta once ≡ the full mode's\n   *      k sequential replays — `deepSmartMerge` is reference-idempotent\n   *      within one replay pass);\n   *    - otherwise (`set`/mixed): the committed value is computed by\n   *      replaying the path's op sequence EXACTLY the way `applySmartMerge`\n   *      replays the full-mode bundle ({@link replayPathVerbs}) — for\n   *      pure-set paths that is simply the last set value; for mixed\n   *      set+merge interleavings it reproduces the full mode's quirk of\n   *      applying the ACCUMULATED merge delta at every merge position\n   *      (which can differ from the buffer's read-your-writes view; parity\n   *      with the `'full'` mode's committed state is the contract). If base\n   *      and that value are arrays and base is a STRICT PREFIX → `append`\n   *      storing only the tail; else `set` storing the full value.\n   *\n   * Losslessness never depends on detection succeeding — every fallback is\n   * today's full-value `set`.\n   */\n  private toDeltaPayload(): {\n    overwrite: MemoryPatch;\n    updates: MemoryPatch;\n    redactedPaths: Set<string>;\n    trace: TraceEntry[];\n  } {\n    const overwrite: MemoryPatch = {};\n    const updates: MemoryPatch = {};\n    const trace: TraceEntry[] = [];\n    const survivingPaths = new Set<string>();\n\n    // Path → its op-verb sequence, ordered by LAST touch (delete +\n    // re-insert moves a re-touched path to the end of the Map's insertion\n    // order — preserving last-writer-wins for nested/overlapping paths).\n    const byPath = new Map<string, OpVerb[]>();\n    for (const op of this.opTrace) {\n      const prev = byPath.get(op.path);\n      if (prev) {\n        prev.push(op.verb);\n        byPath.delete(op.path);\n        byPath.set(op.path, prev);\n      } else {\n        byPath.set(op.path, [op.verb]);\n      }\n    }\n\n    for (const [path, verbs] of byPath) {\n      const segments = path.split(DELIM);\n      const before = _get(this.baseSnapshot, segments);\n      const after = _get(this.workingCopy, segments);\n      if (deepEqual(before, after)) continue; // no-op or write-then-revert → no net change (same filter as 'full')\n\n      survivingPaths.add(path);\n      const lastVerb = verbs[verbs.length - 1];\n      if (lastVerb === 'delete' && after === undefined) {\n        // Real deletion — replay removes the key. Keep the path enumerated\n        // in `overwrite` (undefined) so Object.keys consumers see it.\n        trace.push({ path, verb: 'delete' });\n        _set(overwrite, segments, undefined);\n      } else if (verbs.every((v) => v === 'merge')) {\n        trace.push({ path, verb: 'merge' });\n        _set(updates, segments, structuredClone(_get(this.updatePatch, segments)));\n      } else {\n        // Committed-equivalent value: replay this path's op sequence the way\n        // applySmartMerge replays the FULL-mode bundle, so both modes commit\n        // byte-identical state (see the method JSDoc).\n        const committed = this.replayPathVerbs(before, segments, verbs);\n        if (isStrictArrayPrefix(before, committed)) {\n          trace.push({ path, verb: 'append' });\n          _set(overwrite, segments, structuredClone((committed as unknown[]).slice((before as unknown[]).length)));\n        } else {\n          trace.push({ path, verb: 'set' });\n          _set(overwrite, segments, structuredClone(committed));\n        }\n      }\n    }\n\n    const redactedPaths = new Set([...this.redactedPaths].filter((path) => survivingPaths.has(path)));\n    return { overwrite, updates, redactedPaths, trace };\n  }\n\n  /**\n   * Replay ONE path's op-verb sequence against its base value, exactly the\n   * way `applySmartMerge` replays the corresponding full-mode bundle: every\n   * `set`/`delete` position applies the LAST staged overwrite value (the\n   * bag holds one value per path — last writer wins), every `merge`\n   * position applies the ACCUMULATED `updatePatch` delta. This reproduces\n   * the full mode's committed value for any interleaving — including the\n   * mixed set+merge quirk where the accumulated delta re-applies pre-set\n   * merge keys (full-mode replay semantics, kept for byte-parity across\n   * modes; property-tested in delta-replay-equivalence).\n   */\n  private replayPathVerbs(before: unknown, segments: string[], verbs: OpVerb[]): unknown {\n    const setValue = _get(this.overwritePatch, segments);\n    const mergeDelta = _get(this.updatePatch, segments);\n    let value: unknown = before;\n    for (const verb of verbs) {\n      value = verb === 'merge' ? deepSmartMerge(value ?? {}, mergeDelta) : setValue;\n    }\n    return value;\n  }\n}\n\n/**\n * Append-detection predicate (#13c-B §2.2): both values are arrays, the\n * final is strictly longer, and the base is a structural prefix of the\n * final. Element compares short-circuit on reference identity (`deepEqual`'s\n * `===` fast path) before walking structure, and bail at the first mismatch\n * — worst case one structural compare of the base array, strictly cheaper\n * than the full-value `structuredClone` the fallback pays.\n *\n * `before === undefined` (first write) fails `Array.isArray` → `set`, which\n * keeps the first write as the causal anchor for \"who initialized this key\".\n */\nfunction isStrictArrayPrefix(before: unknown, after: unknown): before is unknown[] {\n  if (!Array.isArray(before) || !Array.isArray(after)) return false;\n  if (after.length <= before.length) return false;\n  for (let i = 0; i < before.length; i++) {\n    if (!deepEqual(before[i], after[i])) return false;\n  }\n  return true;\n}\n"]}

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

@@ -4,6 +4,8 @@
  * The commitLog is an ordered array of CommitBundle — one per stage commit.
  * These helpers provide type-safe queries without (b: any) casts.
  */
+import { nativeGet } from './pathOps.js';
+import { deepSmartMerge, DELIM } from './utils.js';
 /** Find the first commit by stageId, optionally filtering by a written key. */
 export function findCommit(commitLog, stageId, key) {
     return commitLog.find((b) => b.stageId === stageId && (!key || b.trace.some((t) => t.path === key)));
@@ -22,4 +24,72 @@ export function findLastWriter(commitLog, key, beforeIdx) {
     }
     return undefined;
 }
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Reconstruct the FULL value of `key` as of commit array index `idx`
+ * (inclusive) — the migration helper for the "read `bundle.overwrite[key]`
+ * as the full value written" pattern (#13c-B).
+ *
+ * Under `commitValues: 'delta'`, an `append` bundle's `overwrite[key]` holds
+ * only the TAIL of the array; this helper folds the verbs back together:
+ * it scans `commitLog[0..idx]` for trace entries on `key`, anchors at the
+ * latest full-value write (`set` — or `delete`, which resets to absent), and
+ * replays forward (`append` → concat, `merge` → `deepSmartMerge`) — exactly
+ * the per-key slice of `applySmartMerge`'s replay, O(key's commit span)
+ * instead of a full `materialise()`.
+ *
+ * Works on full-mode logs too (every `set` is its own anchor — equivalent to
+ * `findLastWriter(...).overwrite[key]`).
+ *
+ * @param key  Matched against `TraceEntry.path` exactly (same contract as
+ *   `findLastWriter`) — DELIM-joined for nested paths.
+ * @param idx  CommitBundle ARRAY index (the `bundle.idx` position),
+ *   inclusive. NOT the executionIndex from a runtimeStageId.
+ * @returns The reconstructed value (a detached clone), or `undefined` when
+ *   the key was never written in `commitLog[0..idx]` or its last write was a
+ *   delete. Caveat: values derived purely from the run's INITIAL state (no
+ *   `set` anchor in the log — e.g. merges onto a seeded key) fold from
+ *   absent; the commit log alone cannot see the pre-run base (the same blind
+ *   spot `findLastWriter` has).
+ */
+export function commitValueAt(commitLog, idx, key) {
+    const end = Math.min(idx, commitLog.length - 1);
+    const segs = key.split(DELIM);
+    // Collect every trace entry touching the key (in order) up to `end`.
+    const touches = [];
+    for (let i = 0; i <= end; i++) {
+        for (const t of commitLog[i].trace) {
+            if (t.path === key)
+                touches.push({ verb: t.verb, bundle: commitLog[i] });
+        }
+    }
+    if (touches.length === 0)
+        return undefined;
+    // Anchor at the latest entry that fully determines the value on its own.
+    let start = 0;
+    for (let i = touches.length - 1; i >= 0; i--) {
+        if (touches[i].verb === 'set' || touches[i].verb === 'delete') {
+            start = i;
+            break;
+        }
+    }
+    // Fold forward from the anchor — the per-key slice of applySmartMerge.
+    let value;
+    for (let i = start; i < touches.length; i++) {
+        const { verb, bundle } = touches[i];
+        if (verb === 'set') {
+            value = structuredClone(nativeGet(bundle.overwrite, segs));
+        }
+        else if (verb === 'delete') {
+            value = undefined;
+        }
+        else if (verb === 'append') {
+            const tail = structuredClone(nativeGet(bundle.overwrite, segs));
+            value = Array.isArray(value) && Array.isArray(tail) ? [...value, ...tail] : tail;
+        }
+        else {
+            value = deepSmartMerge(value, structuredClone(nativeGet(bundle.updates, segs)));
+        }
+    }
+    return value;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"commitLogUtils.js","sourceRoot":"","sources":["../../../../src/lib/memory/commitLogUtils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnD,+EAA+E;AAC/E,MAAM,UAAU,UAAU,CAAC,SAAyB,EAAE,OAAe,EAAE,GAAY;IACjF,OAAO,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,OAAO,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC;AACvG,CAAC;AAED,mCAAmC;AACnC,MAAM,UAAU,WAAW,CAAC,SAAyB,EAAE,OAAe;IACpE,OAAO,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,OAAO,CAAC,CAAC;AACxD,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,cAAc,CAAC,SAAyB,EAAE,GAAW,EAAE,SAAkB;IACvF,MAAM,GAAG,GAAG,SAAS,IAAI,SAAS,CAAC,MAAM,CAAC;IAC1C,KAAK,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAClC,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;YACnD,OAAO,SAAS,CAAC,CAAC,CAAC,CAAC;QACtB,CAAC;IACH,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,aAAa,CAAC,SAAyB,EAAE,GAAW,EAAE,GAAW;IAC/E,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAChD,MAAM,IAAI,GAAG,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAE9B,qEAAqE;IACrE,MAAM,OAAO,GAA6C,EAAE,CAAC;IAC7D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;QAC9B,KAAK,MAAM,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC;YACnC,IAAI,CAAC,CAAC,IAAI,KAAK,GAAG;gBAAE,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAC3E,CAAC;IACH,CAAC;IACD,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAE3C,yEAAyE;IACzE,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,IAAI,CAAC,GAAG,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC7C,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,KAAK,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC9D,KAAK,GAAG,CAAC,CAAC;YACV,MAAM;QACR,CAAC;IACH,CAAC;IAED,uEAAuE;IACvE,IAAI,KAAc,CAAC;IACnB,KAAK,IAAI,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC5C,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;QACpC,IAAI,IAAI,KAAK,KAAK,EAAE,CAAC;YACnB,KAAK,GAAG,eAAe,CAAC,SAAS,CAAC,MAAM,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,CAAC;QAC7D,CAAC;aAAM,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC7B,KAAK,GAAG,SAAS,CAAC;QACpB,CAAC;aAAM,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC7B,MAAM,IAAI,GAAG,eAAe,CAAC,SAAS,CAAC,MAAM,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,CAAC;YAChE,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QACnF,CAAC;aAAM,CAAC;YACN,KAAK,GAAG,cAAc,CAAC,KAAK,EAAE,eAAe,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;QAClF,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["/**\n * Typed utilities for querying the commit log.\n *\n * The commitLog is an ordered array of CommitBundle — one per stage commit.\n * These helpers provide type-safe queries without (b: any) casts.\n */\n\nimport { nativeGet } from './pathOps.js';\nimport type { CommitBundle } from './types.js';\nimport { deepSmartMerge, DELIM } from './utils.js';\n\n/** Find the first commit by stageId, optionally filtering by a written key. */\nexport function findCommit(commitLog: CommitBundle[], stageId: string, key?: string): CommitBundle | undefined {\n  return commitLog.find((b) => b.stageId === stageId && (!key || b.trace.some((t) => t.path === key)));\n}\n\n/** Find all commits by stageId. */\nexport function findCommits(commitLog: CommitBundle[], stageId: string): CommitBundle[] {\n  return commitLog.filter((b) => b.stageId === stageId);\n}\n\n/** Find the last commit that wrote a specific key (for backtracking). */\nexport function findLastWriter(commitLog: CommitBundle[], key: string, beforeIdx?: number): CommitBundle | undefined {\n  const end = beforeIdx ?? commitLog.length;\n  for (let i = end - 1; i >= 0; i--) {\n    if (commitLog[i].trace.some((t) => t.path === key)) {\n      return commitLog[i];\n    }\n  }\n  return undefined;\n}\n\n/**\n * Reconstruct the FULL value of `key` as of commit array index `idx`\n * (inclusive) — the migration helper for the \"read `bundle.overwrite[key]`\n * as the full value written\" pattern (#13c-B).\n *\n * Under `commitValues: 'delta'`, an `append` bundle's `overwrite[key]` holds\n * only the TAIL of the array; this helper folds the verbs back together:\n * it scans `commitLog[0..idx]` for trace entries on `key`, anchors at the\n * latest full-value write (`set` — or `delete`, which resets to absent), and\n * replays forward (`append` → concat, `merge` → `deepSmartMerge`) — exactly\n * the per-key slice of `applySmartMerge`'s replay, O(key's commit span)\n * instead of a full `materialise()`.\n *\n * Works on full-mode logs too (every `set` is its own anchor — equivalent to\n * `findLastWriter(...).overwrite[key]`).\n *\n * @param key  Matched against `TraceEntry.path` exactly (same contract as\n *   `findLastWriter`) — DELIM-joined for nested paths.\n * @param idx  CommitBundle ARRAY index (the `bundle.idx` position),\n *   inclusive. NOT the executionIndex from a runtimeStageId.\n * @returns The reconstructed value (a detached clone), or `undefined` when\n *   the key was never written in `commitLog[0..idx]` or its last write was a\n *   delete. Caveat: values derived purely from the run's INITIAL state (no\n *   `set` anchor in the log — e.g. merges onto a seeded key) fold from\n *   absent; the commit log alone cannot see the pre-run base (the same blind\n *   spot `findLastWriter` has).\n */\nexport function commitValueAt(commitLog: CommitBundle[], idx: number, key: string): unknown {\n  const end = Math.min(idx, commitLog.length - 1);\n  const segs = key.split(DELIM);\n\n  // Collect every trace entry touching the key (in order) up to `end`.\n  const touches: { verb: string; bundle: CommitBundle }[] = [];\n  for (let i = 0; i <= end; i++) {\n    for (const t of commitLog[i].trace) {\n      if (t.path === key) touches.push({ verb: t.verb, bundle: commitLog[i] });\n    }\n  }\n  if (touches.length === 0) return undefined;\n\n  // Anchor at the latest entry that fully determines the value on its own.\n  let start = 0;\n  for (let i = touches.length - 1; i >= 0; i--) {\n    if (touches[i].verb === 'set' || touches[i].verb === 'delete') {\n      start = i;\n      break;\n    }\n  }\n\n  // Fold forward from the anchor — the per-key slice of applySmartMerge.\n  let value: unknown;\n  for (let i = start; i < touches.length; i++) {\n    const { verb, bundle } = touches[i];\n    if (verb === 'set') {\n      value = structuredClone(nativeGet(bundle.overwrite, segs));\n    } else if (verb === 'delete') {\n      value = undefined;\n    } else if (verb === 'append') {\n      const tail = structuredClone(nativeGet(bundle.overwrite, segs));\n      value = Array.isArray(value) && Array.isArray(tail) ? [...value, ...tail] : tail;\n    } else {\n      value = deepSmartMerge(value, structuredClone(nativeGet(bundle.updates, segs)));\n    }\n  }\n  return value;\n}\n"]}

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

@@ -14,4 +14,4 @@ export { TransactionBuffer } from './TransactionBuffer.js';
 export { READ_PREVIEW_LENGTH, SUMMARY_PREVIEW_LENGTH } from './types.js';
 // Utilities
 export { applySmartMerge, deepSmartMerge, DELIM, getNestedValue, getRunAndGlobalPaths, normalisePath, redactPatch, setNestedValue, updateNestedValue, updateValue, } from './utils.js';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -66,6 +66,33 @@ export function nativeSet(obj, path, value) {
     curr[last] = value;
     return obj;
 }
+/**
+ * Remove the own property at `path` in `obj` (the replay primitive for the
+ * `delete` commit verb, #13c-B). No-op when any intermediate segment is
+ * missing — deleting an absent key has nothing to remove.
+ *
+ * Security: same DENIED + hasOwnProperty discipline as nativeGet — every
+ * segment is checked, so `nativeDelete(obj, '__proto__x')` and
+ * prototype-chain walks are inert.
+ */
+export function nativeDelete(obj, path) {
+    const segs = toSegments(path);
+    let curr = obj;
+    for (let i = 0; i < segs.length - 1; i++) {
+        const seg = segs[i];
+        if (DENIED.has(String(seg)))
+            return;
+        if (curr == null || typeof curr !== 'object' || !Object.prototype.hasOwnProperty.call(curr, seg))
+            return;
+        curr = curr[seg];
+    }
+    const last = segs[segs.length - 1];
+    if (DENIED.has(String(last)))
+        return;
+    if (curr != null && typeof curr === 'object') {
+        delete curr[last];
+    }
+}
 /** Returns true if `obj` has an own property at every segment of `path`. */
 export function nativeHas(obj, path) {
     const segs = toSegments(path);
@@ -112,4 +139,4 @@ export function mergeContextWins(dst, src) {
     }
     return out;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pathOps.js","sourceRoot":"","sources":["../../../../src/lib/memory/pathOps.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * pathOps.ts — Native nested-path helpers (replaces lodash.get/set/has/mergewith)\n *\n * Security contract: all functions guard against prototype-pollution and\n * prototype-chain-read attacks. The DENIED set blocks the three canonical\n * pollution vectors (__proto__, constructor, prototype) on every function.\n *\n * Intentional asymmetry:\n *   - nativeSet  — DENIED check only at each segment. No hasOwnProperty\n *     check is needed because writing always creates an OWN property on `curr`,\n *     which cannot pollute the prototype chain.\n *   - nativeGet / nativeHas — DENIED check + hasOwnProperty at every step.\n *     Reads follow the prototype chain by default (bracket notation), so the\n *     hasOwnProperty guard is required to prevent leaking inherited values\n *     (e.g. Object.prototype, Object constructor, toString).\n *   - mergeContextWins — DENIED check only; Object.keys() is own-enumerable-only\n *     by spec so prototype keys never appear in the iteration.\n *\n * Do NOT \"fix\" the nativeSet asymmetry by adding hasOwnProperty — it is\n * intentional and would break path creation for new intermediate nodes.\n *\n * Paths may be dot-notation strings or pre-split (string|number)[] arrays.\n */\n\nconst DENIED = new Set(['__proto__', 'constructor', 'prototype']);\n\nfunction toSegments(path: string | (string | number)[]): (string | number)[] {\n  return Array.isArray(path) ? path : path.split('.');\n}\n\n/**\n * Get the value at `path` in `obj`, returning `defaultValue` if absent.\n *\n * Security: each path segment is checked against the DENIED list and requires\n * an own property at every step, preventing prototype-chain reads.\n * e.g. nativeGet({}, '__proto__') and nativeGet({}, 'constructor') both return\n * `defaultValue` instead of leaking Object.prototype / the Object constructor.\n */\nexport function nativeGet(obj: any, path: string | (string | number)[], defaultValue?: any): any {\n  const segs = toSegments(path);\n  let curr = obj;\n  for (const seg of segs) {\n    if (curr == null) return defaultValue;\n    if (DENIED.has(String(seg))) return defaultValue;\n    if (!Object.prototype.hasOwnProperty.call(curr, seg)) return defaultValue;\n    curr = curr[seg];\n  }\n  return curr === undefined ? defaultValue : curr;\n}\n\n/** Mutate `obj`, setting `value` at `path` (creates intermediate objects). Returns `obj`. */\nexport function nativeSet(obj: any, path: string | (string | number)[], value: any): any {\n  const segs = toSegments(path);\n  let curr = obj;\n  for (let i = 0; i < segs.length - 1; i++) {\n    const k = segs[i];\n    if (DENIED.has(String(k))) return obj;\n    if (curr[k] == null || typeof curr[k] !== 'object') {\n      curr[k] = typeof segs[i + 1] === 'number' ? [] : {};\n    }\n    curr = curr[k];\n  }\n  const last = segs[segs.length - 1];\n  if (DENIED.has(String(last))) return obj;\n  curr[last] = value;\n  return obj;\n}\n\n/** Returns true if `obj` has an own property at every segment of `path`. */\nexport function nativeHas(obj: any, path: string | (string | number)[]): boolean {\n  const segs = toSegments(path);\n  let curr = obj;\n  for (let i = 0; i < segs.length; i++) {\n    if (curr == null || !Object.prototype.hasOwnProperty.call(curr, segs[i])) return false;\n    if (i < segs.length - 1) curr = curr[segs[i]];\n  }\n  return true;\n}\n\n/**\n * Deep merge where destination wins for any defined value.\n * Fills missing keys from `src`, but never overwrites defined keys in `dst`.\n * Arrays are not recursed — dst array always wins when present.\n *\n * Replaces: `mergeWith(dst, src, (objValue) => objValue !== undefined ? objValue : undefined)`\n */\nexport function mergeContextWins(dst: any, src: any): any {\n  if (!src || typeof src !== 'object' || Array.isArray(src)) {\n    return dst !== undefined ? dst : src;\n  }\n  const out: any = dst != null && typeof dst === 'object' ? { ...dst } : {};\n  for (const key of Object.keys(src)) {\n    if (DENIED.has(key)) continue;\n    const dstVal = out[key];\n    if (dstVal !== undefined) {\n      // dst wins; recurse only if both sides are plain objects\n      if (\n        dstVal !== null &&\n        typeof dstVal === 'object' &&\n        !Array.isArray(dstVal) &&\n        src[key] !== null &&\n        typeof src[key] === 'object' &&\n        !Array.isArray(src[key])\n      ) {\n        out[key] = mergeContextWins(dstVal, src[key]);\n      }\n      // else keep dstVal unchanged\n    } else {\n      out[key] = src[key];\n    }\n  }\n  return out;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pathOps.js","sourceRoot":"","sources":["../../../../src/lib/memory/pathOps.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * pathOps.ts — Native nested-path helpers (replaces lodash.get/set/has/mergewith)\n *\n * Security contract: all functions guard against prototype-pollution and\n * prototype-chain-read attacks. The DENIED set blocks the three canonical\n * pollution vectors (__proto__, constructor, prototype) on every function.\n *\n * Intentional asymmetry:\n *   - nativeSet  — DENIED check only at each segment. No hasOwnProperty\n *     check is needed because writing always creates an OWN property on `curr`,\n *     which cannot pollute the prototype chain.\n *   - nativeGet / nativeHas — DENIED check + hasOwnProperty at every step.\n *     Reads follow the prototype chain by default (bracket notation), so the\n *     hasOwnProperty guard is required to prevent leaking inherited values\n *     (e.g. Object.prototype, Object constructor, toString).\n *   - mergeContextWins — DENIED check only; Object.keys() is own-enumerable-only\n *     by spec so prototype keys never appear in the iteration.\n *\n * Do NOT \"fix\" the nativeSet asymmetry by adding hasOwnProperty — it is\n * intentional and would break path creation for new intermediate nodes.\n *\n * Paths may be dot-notation strings or pre-split (string|number)[] arrays.\n */\n\nconst DENIED = new Set(['__proto__', 'constructor', 'prototype']);\n\nfunction toSegments(path: string | (string | number)[]): (string | number)[] {\n  return Array.isArray(path) ? path : path.split('.');\n}\n\n/**\n * Get the value at `path` in `obj`, returning `defaultValue` if absent.\n *\n * Security: each path segment is checked against the DENIED list and requires\n * an own property at every step, preventing prototype-chain reads.\n * e.g. nativeGet({}, '__proto__') and nativeGet({}, 'constructor') both return\n * `defaultValue` instead of leaking Object.prototype / the Object constructor.\n */\nexport function nativeGet(obj: any, path: string | (string | number)[], defaultValue?: any): any {\n  const segs = toSegments(path);\n  let curr = obj;\n  for (const seg of segs) {\n    if (curr == null) return defaultValue;\n    if (DENIED.has(String(seg))) return defaultValue;\n    if (!Object.prototype.hasOwnProperty.call(curr, seg)) return defaultValue;\n    curr = curr[seg];\n  }\n  return curr === undefined ? defaultValue : curr;\n}\n\n/** Mutate `obj`, setting `value` at `path` (creates intermediate objects). Returns `obj`. */\nexport function nativeSet(obj: any, path: string | (string | number)[], value: any): any {\n  const segs = toSegments(path);\n  let curr = obj;\n  for (let i = 0; i < segs.length - 1; i++) {\n    const k = segs[i];\n    if (DENIED.has(String(k))) return obj;\n    if (curr[k] == null || typeof curr[k] !== 'object') {\n      curr[k] = typeof segs[i + 1] === 'number' ? [] : {};\n    }\n    curr = curr[k];\n  }\n  const last = segs[segs.length - 1];\n  if (DENIED.has(String(last))) return obj;\n  curr[last] = value;\n  return obj;\n}\n\n/**\n * Remove the own property at `path` in `obj` (the replay primitive for the\n * `delete` commit verb, #13c-B). No-op when any intermediate segment is\n * missing — deleting an absent key has nothing to remove.\n *\n * Security: same DENIED + hasOwnProperty discipline as nativeGet — every\n * segment is checked, so `nativeDelete(obj, '__proto__\u001fx')` and\n * prototype-chain walks are inert.\n */\nexport function nativeDelete(obj: any, path: string | (string | number)[]): void {\n  const segs = toSegments(path);\n  let curr = obj;\n  for (let i = 0; i < segs.length - 1; i++) {\n    const seg = segs[i];\n    if (DENIED.has(String(seg))) return;\n    if (curr == null || typeof curr !== 'object' || !Object.prototype.hasOwnProperty.call(curr, seg)) return;\n    curr = curr[seg];\n  }\n  const last = segs[segs.length - 1];\n  if (DENIED.has(String(last))) return;\n  if (curr != null && typeof curr === 'object') {\n    delete curr[last];\n  }\n}\n\n/** Returns true if `obj` has an own property at every segment of `path`. */\nexport function nativeHas(obj: any, path: string | (string | number)[]): boolean {\n  const segs = toSegments(path);\n  let curr = obj;\n  for (let i = 0; i < segs.length; i++) {\n    if (curr == null || !Object.prototype.hasOwnProperty.call(curr, segs[i])) return false;\n    if (i < segs.length - 1) curr = curr[segs[i]];\n  }\n  return true;\n}\n\n/**\n * Deep merge where destination wins for any defined value.\n * Fills missing keys from `src`, but never overwrites defined keys in `dst`.\n * Arrays are not recursed — dst array always wins when present.\n *\n * Replaces: `mergeWith(dst, src, (objValue) => objValue !== undefined ? objValue : undefined)`\n */\nexport function mergeContextWins(dst: any, src: any): any {\n  if (!src || typeof src !== 'object' || Array.isArray(src)) {\n    return dst !== undefined ? dst : src;\n  }\n  const out: any = dst != null && typeof dst === 'object' ? { ...dst } : {};\n  for (const key of Object.keys(src)) {\n    if (DENIED.has(key)) continue;\n    const dstVal = out[key];\n    if (dstVal !== undefined) {\n      // dst wins; recurse only if both sides are plain objects\n      if (\n        dstVal !== null &&\n        typeof dstVal === 'object' &&\n        !Array.isArray(dstVal) &&\n        src[key] !== null &&\n        typeof src[key] === 'object' &&\n        !Array.isArray(src[key])\n      ) {\n        out[key] = mergeContextWins(dstVal, src[key]);\n      }\n      // else keep dstVal unchanged\n    } else {\n      out[key] = src[key];\n    }\n  }\n  return out;\n}\n"]}

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

@@ -8,4 +8,4 @@
  * implementation).
  */
 export { READ_PREVIEW_LENGTH, SUMMARY_PREVIEW_LENGTH } from '../capture/summarize.js';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/lib/memory/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AA+DH,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC","sourcesContent":["/**\n * types.ts — Core type definitions for the memory library\n *\n * Zero dependencies on old code or other libraries in this package, with one\n * deliberate exception: `capture/` — the standalone leaf module holding the\n * shared retention-policy family and summary-marker builders (extracted from\n * here in #13c-A so the read and write dials, and later RFC-001, share one\n * implementation).\n */\n\nimport type { RetentionPolicy } from '../capture/policies.js';\n\n// ── Patch & Trace ──────────────────────────────────────────────────────────\n\n/** A flat key-value bag representing a state patch (overwrite or merge). */\nexport interface MemoryPatch {\n  [key: string]: any;\n}\n\n/** A single entry in the chronological operation trace. */\nexport interface TraceEntry {\n  /** Canonical path string (segments joined by DELIM). */\n  path: string;\n  /** 'set' = hard overwrite, 'merge' = deep union merge. */\n  verb: 'set' | 'merge';\n}\n\n/** The atomic bundle produced by TransactionBuffer.commit(). */\nexport interface CommitBundle {\n  /** Auto-assigned step index (set by EventLog.record). */\n  idx?: number;\n  /** Human-readable stage name. */\n  stage: string;\n  /** Stable stage identifier (matches spec node id). */\n  stageId: string;\n  /** Unique per-execution-step identifier. Format: [subflowPath/]stageId#executionIndex */\n  runtimeStageId: string;\n  /** Chronological write log for deterministic replay. */\n  trace: TraceEntry[];\n  /** Paths that should be redacted in UI (sensitive data). */\n  redactedPaths: string[];\n  /** Hard overwrite patches. */\n  overwrite: MemoryPatch;\n  /** Deep merge patches. */\n  updates: MemoryPatch;\n}\n\n// ── Flow Control Narrative ─────────────────────────────────────────────────\n\n/** Types of control flow decisions captured by the execution engine. */\nexport type FlowControlType = 'next' | 'branch' | 'children' | 'selected' | 'subflow' | 'loop';\n\n/** A single flow control narrative entry. */\nexport interface FlowMessage {\n  type: FlowControlType;\n  description: string;\n  targetStage?: string | string[];\n  rationale?: string;\n  count?: number;\n  iteration?: number;\n  timestamp?: number;\n}\n\n// ── Read / Write Tracking (#14, #13c-A) ────────────────────────────────────\n//\n// The policy family and marker shapes are owned by `capture/` (shared with\n// the write dial and, later, RFC-001's deferred-observer capture tier).\n// Re-exported here so every pre-extraction import path keeps working.\n\nexport type { RetentionPolicy } from '../capture/policies.js';\nexport type { ReadSummaryMarker, WriteSummaryMarker } from '../capture/summarize.js';\nexport { READ_PREVIEW_LENGTH, SUMMARY_PREVIEW_LENGTH } from '../capture/summarize.js';\n\n/**\n * Policy for how tracked reads are recorded into `StageSnapshot.stageReads`.\n *\n * - `'full'` (default) — every tracked read `structuredClone`s the value into\n *   the stage's read view. Byte-identical to the historical behavior; this is\n *   what snapshot consumers (lens, agentfootprint) see today.\n * - `'summary'` — reads record a cheap {@link ReadSummaryMarker} (type + size\n *   proxy + short preview) instead of the cloned value. O(1)-ish per read —\n *   no value clone, no serialization of large objects.\n * - `'off'` — reads are not recorded at all; `stageReads` is absent from the\n *   snapshot. Zero per-read cost. Values are still readable, and the\n *   `ScopeRecorder.onRead` event still fires (it passes the live reference and\n *   never cloned) — so narrative output is identical in every mode. The policy\n *   scopes ONLY the snapshot's `stageReads` payload.\n *\n * Set via `new FlowChartExecutor(chart, { readTracking })` or\n * `executor.setReadTracking(mode)` (before `run()`).\n *\n * Alias of the shared {@link RetentionPolicy} family (#13c-A) — kept as the\n * shipped public name for the read dial.\n */\nexport type ReadTrackingMode = RetentionPolicy;\n\n/**\n * Policy for how tracked writes are recorded into `StageSnapshot.stageWrites`\n * (#13c-A) — the sibling of {@link ReadTrackingMode}.\n *\n * - `'full'` (default) — every tracked write `structuredClone`s the value into\n *   the stage's write view. Byte-identical to the historical behavior.\n * - `'summary'` — writes record a cheap {@link WriteSummaryMarker} instead of\n *   the cloned value.\n * - `'off'` — writes are not recorded at all; `stageWrites` is absent from the\n *   snapshot. The writes themselves still commit to shared state and still\n *   appear in the commit log — only the per-stage snapshot bookkeeping (and\n *   therefore the commit observer's mutations payload) is affected.\n *\n * Set via `new FlowChartExecutor(chart, { writeTracking })` or\n * `executor.setWriteTracking(mode)` (before `run()`). See\n * `FlowChartExecutorOptions.writeTracking` for the full observable-consequence\n * contract (onCommit payload, redaction precedence, what is OUT of scope).\n */\nexport type WriteTrackingMode = RetentionPolicy;\n\n// ── Stage Snapshot ─────────────────────────────────────────────────────────\n\n/** Serialisable representation of a stage's state (for debugging / visualisation). */\nexport type StageSnapshot = {\n  id: string;\n  /** Unique per-execution-step identifier. Format: [subflowPath/]stageId#executionIndex */\n  runtimeStageId?: string;\n  name?: string;\n  /** Human-readable description of what this stage does (from builder). */\n  description?: string;\n  /** Subflow identifier — present when this stage is a subflow entry point. */\n  subflowId?: string;\n  isDecider?: boolean;\n  isFork?: boolean;\n  /** User-level writes made by this stage (pre-namespace keys → values).\n   *  Shape depends on {@link WriteTrackingMode}: cloned values under `'full'`\n   *  (default), {@link WriteSummaryMarker}s under `'summary'`, absent under\n   *  `'off'`. Redacted writes show `'[REDACTED]'` regardless of mode. */\n  stageWrites?: Record<string, unknown>;\n  /** User-level reads made by this stage (pre-namespace keys → values at read\n   *  time). Shape depends on {@link ReadTrackingMode}: cloned values under\n   *  `'full'` (default), {@link ReadSummaryMarker}s under `'summary'`, absent\n   *  under `'off'`. */\n  stageReads?: Record<string, unknown>;\n  logs: Record<string, unknown>;\n  errors: Record<string, unknown>;\n  metrics: Record<string, unknown>;\n  evals: Record<string, unknown>;\n  flowMessages?: FlowMessage[];\n  next?: StageSnapshot;\n  children?: StageSnapshot[];\n};\n\n// ── Scope Factory ──────────────────────────────────────────────────────────\n\n/** Forward-declared so StageContext can accept it without importing scope/. */\nexport type ScopeFactory<TScope> = (core: StageContext, stageName: string, readOnlyContext?: unknown) => TScope;\n\n// ── StageContext (forward reference for ScopeFactory) ──────────────────────\n\n// The actual class lives in StageContext.ts; we just need the type here for\n// the ScopeFactory generic. TypeScript's import-type handles this:\nimport type { StageContext } from './StageContext.js';\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/lib/memory/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAgFH,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC","sourcesContent":["/**\n * types.ts — Core type definitions for the memory library\n *\n * Zero dependencies on old code or other libraries in this package, with one\n * deliberate exception: `capture/` — the standalone leaf module holding the\n * shared retention-policy family and summary-marker builders (extracted from\n * here in #13c-A so the read and write dials, and later RFC-001, share one\n * implementation).\n */\n\nimport type { RetentionPolicy } from '../capture/policies.js';\n\n// ── Patch & Trace ──────────────────────────────────────────────────────────\n\n/** A flat key-value bag representing a state patch (overwrite or merge). */\nexport interface MemoryPatch {\n  [key: string]: any;\n}\n\n/** A single entry in the chronological operation trace. */\nexport interface TraceEntry {\n  /** Canonical path string (segments joined by DELIM). */\n  path: string;\n  /**\n   * - `'set'`    — hard overwrite; `overwrite[path]` holds the full final value.\n   * - `'merge'`  — deep union merge; `updates[path]` holds the accumulated delta.\n   * - `'append'` — (#13c-B, produced only under {@link CommitValuesMode}\n   *   `'delta'`) the path's final value is its base value plus a tail of new\n   *   trailing elements; `overwrite[path]` holds ONLY the tail. Replay\n   *   reconstructs by concatenation. NOT idempotent — delta-mode bundles\n   *   carry exactly one trace entry per surviving path.\n   * - `'delete'` — (#13c-B, produced only under `'delta'`; absorbs backlog\n   *   B8) the key was explicitly removed via `deleteValue()`. Replay removes\n   *   the key. `overwrite[path]` still ENUMERATES the path (value\n   *   `undefined`) so key-set consumers keep seeing the changed key.\n   *\n   * `overwrite` values are therefore VERB-QUALIFIED: consumers that read\n   * `bundle.overwrite[key]` as \"the full value written\" must use\n   * `commitValueAt(commitLog, idx, key)` (from `footprintjs/trace`) when the\n   * log may contain delta-mode bundles.\n   */\n  verb: 'set' | 'merge' | 'append' | 'delete';\n}\n\n/** The atomic bundle produced by TransactionBuffer.commit(). */\nexport interface CommitBundle {\n  /** Auto-assigned step index (set by EventLog.record). */\n  idx?: number;\n  /** Human-readable stage name. */\n  stage: string;\n  /** Stable stage identifier (matches spec node id). */\n  stageId: string;\n  /** Unique per-execution-step identifier. Format: [subflowPath/]stageId#executionIndex */\n  runtimeStageId: string;\n  /** Chronological write log for deterministic replay. */\n  trace: TraceEntry[];\n  /** Paths that should be redacted in UI (sensitive data). */\n  redactedPaths: string[];\n  /** Hard overwrite patches. */\n  overwrite: MemoryPatch;\n  /** Deep merge patches. */\n  updates: MemoryPatch;\n}\n\n// ── Flow Control Narrative ─────────────────────────────────────────────────\n\n/** Types of control flow decisions captured by the execution engine. */\nexport type FlowControlType = 'next' | 'branch' | 'children' | 'selected' | 'subflow' | 'loop';\n\n/** A single flow control narrative entry. */\nexport interface FlowMessage {\n  type: FlowControlType;\n  description: string;\n  targetStage?: string | string[];\n  rationale?: string;\n  count?: number;\n  iteration?: number;\n  timestamp?: number;\n}\n\n// ── Read / Write Tracking (#14, #13c-A) ────────────────────────────────────\n//\n// The policy family and marker shapes are owned by `capture/` (shared with\n// the write dial and, later, RFC-001's deferred-observer capture tier).\n// Re-exported here so every pre-extraction import path keeps working.\n\nexport type { RetentionPolicy } from '../capture/policies.js';\nexport type { ReadSummaryMarker, WriteSummaryMarker } from '../capture/summarize.js';\nexport { READ_PREVIEW_LENGTH, SUMMARY_PREVIEW_LENGTH } from '../capture/summarize.js';\n\n/**\n * Policy for how tracked reads are recorded into `StageSnapshot.stageReads`.\n *\n * - `'full'` (default) — every tracked read `structuredClone`s the value into\n *   the stage's read view. Byte-identical to the historical behavior; this is\n *   what snapshot consumers (lens, agentfootprint) see today.\n * - `'summary'` — reads record a cheap {@link ReadSummaryMarker} (type + size\n *   proxy + short preview) instead of the cloned value. O(1)-ish per read —\n *   no value clone, no serialization of large objects.\n * - `'off'` — reads are not recorded at all; `stageReads` is absent from the\n *   snapshot. Zero per-read cost. Values are still readable, and the\n *   `ScopeRecorder.onRead` event still fires (it passes the live reference and\n *   never cloned) — so narrative output is identical in every mode. The policy\n *   scopes ONLY the snapshot's `stageReads` payload.\n *\n * Set via `new FlowChartExecutor(chart, { readTracking })` or\n * `executor.setReadTracking(mode)` (before `run()`).\n *\n * Alias of the shared {@link RetentionPolicy} family (#13c-A) — kept as the\n * shipped public name for the read dial.\n */\nexport type ReadTrackingMode = RetentionPolicy;\n\n/**\n * Policy for how tracked writes are recorded into `StageSnapshot.stageWrites`\n * (#13c-A) — the sibling of {@link ReadTrackingMode}.\n *\n * - `'full'` (default) — every tracked write `structuredClone`s the value into\n *   the stage's write view. Byte-identical to the historical behavior.\n * - `'summary'` — writes record a cheap {@link WriteSummaryMarker} instead of\n *   the cloned value.\n * - `'off'` — writes are not recorded at all; `stageWrites` is absent from the\n *   snapshot. The writes themselves still commit to shared state and still\n *   appear in the commit log — only the per-stage snapshot bookkeeping (and\n *   therefore the commit observer's mutations payload) is affected. (The\n *   commit log's own value encoding has its own lossless dial —\n *   {@link CommitValuesMode}, #13c-B.)\n *\n * Set via `new FlowChartExecutor(chart, { writeTracking })` or\n * `executor.setWriteTracking(mode)` (before `run()`). See\n * `FlowChartExecutorOptions.writeTracking` for the full observable-consequence\n * contract (onCommit payload, redaction precedence, what is OUT of scope).\n */\nexport type WriteTrackingMode = RetentionPolicy;\n\n/**\n * Policy for how commit-bundle VALUES are encoded into the commit log\n * (#13c-B) — completes the `readTracking`/`writeTracking` dial family.\n * Unlike those two (which gate lossy snapshot bookkeeping), this dial is\n * **lossless in both modes** — it changes the commit log's *encoding*,\n * never its *information*; any step's full state stays exactly\n * reconstructable by replay.\n *\n * - `'full'` (default) — every surviving `set` path stores the full final\n *   value, one trace entry per operation. Byte-identical to the historical\n *   behavior.\n * - `'delta'` — two changes, both replay-covered by `applySmartMerge`:\n *   1. **`append` detection**: when a path's net change is \"the base array\n *      plus new trailing elements\" (strict prefix), the bundle records ONLY\n *      the tail under a `verb: 'append'` trace entry — the growing-history\n *      commit log becomes linear in tail size instead of O(N²) retained.\n *      A real `verb: 'delete'` entry replaces the `set: undefined` flattening\n *      for `deleteValue()` (closes the documented MemoryPatch limitation).\n *   2. **One trace entry per surviving path** (append is not idempotent on\n *      replay): the verb is resolved from the path's base→final relationship\n *      and op mix; entries are ordered by each path's LAST touch.\n *\n * Honest cost note: append detection is NEW wall work — an O(|base|)\n * structural prefix compare per array-set path per commit (today's\n * `deepEqual` fast-fails on length in O(1) for a grown array). On a hit the\n * commit gets cheaper in both wall and heap (the O(|final|) clone shrinks to\n * O(|tail|)); on a miss it pays compare + full clone. `'full'` pays zero —\n * the detection branch is mode-gated.\n *\n * Set via `new FlowChartExecutor(chart, { commitValues })` or\n * `executor.setCommitValues(mode)` (before `run()`). The active mode is\n * surfaced as the snapshot discriminant `RuntimeSnapshot.commitValues`.\n */\nexport type CommitValuesMode = 'full' | 'delta';\n\n// ── Stage Snapshot ─────────────────────────────────────────────────────────\n\n/** Serialisable representation of a stage's state (for debugging / visualisation). */\nexport type StageSnapshot = {\n  id: string;\n  /** Unique per-execution-step identifier. Format: [subflowPath/]stageId#executionIndex */\n  runtimeStageId?: string;\n  name?: string;\n  /** Human-readable description of what this stage does (from builder). */\n  description?: string;\n  /** Subflow identifier — present when this stage is a subflow entry point. */\n  subflowId?: string;\n  isDecider?: boolean;\n  isFork?: boolean;\n  /** User-level writes made by this stage (pre-namespace keys → values).\n   *  Shape depends on {@link WriteTrackingMode}: cloned values under `'full'`\n   *  (default), {@link WriteSummaryMarker}s under `'summary'`, absent under\n   *  `'off'`. Redacted writes show `'[REDACTED]'` regardless of mode. */\n  stageWrites?: Record<string, unknown>;\n  /** User-level reads made by this stage (pre-namespace keys → values at read\n   *  time). Shape depends on {@link ReadTrackingMode}: cloned values under\n   *  `'full'` (default), {@link ReadSummaryMarker}s under `'summary'`, absent\n   *  under `'off'`. */\n  stageReads?: Record<string, unknown>;\n  logs: Record<string, unknown>;\n  errors: Record<string, unknown>;\n  metrics: Record<string, unknown>;\n  evals: Record<string, unknown>;\n  flowMessages?: FlowMessage[];\n  next?: StageSnapshot;\n  children?: StageSnapshot[];\n};\n\n// ── Scope Factory ──────────────────────────────────────────────────────────\n\n/** Forward-declared so StageContext can accept it without importing scope/. */\nexport type ScopeFactory<TScope> = (core: StageContext, stageName: string, readOnlyContext?: unknown) => TScope;\n\n// ── StageContext (forward reference for ScopeFactory) ──────────────────────\n\n// The actual class lives in StageContext.ts; we just need the type here for\n// the ScopeFactory generic. TypeScript's import-type handles this:\nimport type { StageContext } from './StageContext.js';\n"]}