footprintjs 9.11.0 → 9.12.0

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

@@ -139,16 +139,21 @@ export declare class TransactionBuffer {
     private toChangeOnlyPayload;
     /**
      * Delta-encoded payload (`commitValues: 'delta'`, #13c-B) — same net-change
-     * filter as {@link toChangeOnlyPayload}, two encoding differences:
+     * filter as {@link toChangeOnlyPayload}, three 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**:
+     * 2. **Verb resolution per path** — for a path with NO surviving relative
+     *    (see 3):
      *    - last op `'delete'` AND final value gone → `delete` (the path stays
-     *      enumerated in `overwrite` with `undefined` for key-set consumers);
+     *      enumerated in `overwrite` with `undefined` for key-set consumers).
+     *      Requires the parent to be a real container in the base — replay uses
+     *      `nativeDelete`, which is inert on a primitive/absent parent, whereas
+     *      the `'full'` flattening (`_set` of `undefined`) COERCES that parent
+     *      into an object; when they would disagree we keep the flattening;
      *    - 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
@@ -163,11 +168,66 @@ export declare class TransactionBuffer {
      *      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.
+     * 3. **OVERLAP FAMILIES take the full-value fallback.** `overwrite` /
+     *    `updates` are nested path TREES, so two surviving paths where one is
+     *    an ancestor of the other (`a` and `a.p`) share storage. The `'full'`
+     *    payload survives that because every entry stores the FULL value at its
+     *    path, drawn from one coherent tree — nested entries agree with their
+     *    ancestor by construction. Delta's per-path encodings do NOT: an
+     *    `append` ancestor stores only a TAIL (whose indices are shifted
+     *    relative to the whole array) and a `delete` ancestor stores
+     *    `undefined`, so whichever entry is written second silently destroys or
+     *    corrupts the other — the recorded write is LOST at replay. Therefore
+     *    every path that has a surviving ancestor/descendant is committed as a
+     *    plain `set` of the value it holds in the family's replayed value
+     *    ({@link replayFamilyVerbs}), and the family's shallowest path (whose
+     *    set covers the whole subtree) is emitted LAST. One coherent tree in,
+     *    one coherent tree out: entries can no longer clobber each other and
+     *    the replayed value is exact regardless of order.
      *
      * Losslessness never depends on detection succeeding — every fallback is
      * today's full-value `set`.
      */
     private toDeltaPayload;
+    /**
+     * Bucket the staged ops of every OVERLAPPING family by family root, in op
+     * order — the input {@link replayFamilyVerbs} folds. Ops on paths the
+     * net-change filter dropped are skipped (they are absent from `rootOf`),
+     * exactly as the `'full'` payload drops them from its trace. One pass over
+     * `opTrace`, and only when at least one family actually overlaps — commits
+     * that write no nested path pay nothing.
+     */
+    private opsByFamily;
+    /**
+     * Replay ONE overlapping family's staged ops onto the family root's base
+     * value — the multi-path generalisation of {@link replayPathVerbs}, and
+     * byte-for-byte what `applySmartMerge` produces for the corresponding
+     * `'full'`-mode entries: each `set`/`delete` position writes that path's
+     * `overwritePatch` value, each `merge` position deep-merges that path's
+     * accumulated `updatePatch` delta into the value replayed so far.
+     *
+     * (Both patches are single coherent trees, so a full-mode bundle's stored
+     * value at any recorded path always reads back as its `overwritePatch` /
+     * `updatePatch` value — which is why sourcing from them here reproduces the
+     * full-mode replay exactly, including its intermediate-coercion quirks.)
+     *
+     * The value is held in a `{ v }` box so the root itself (relative path `[]`)
+     * can be REPLACED by `_set` the same way `applySmartMerge` replaces it
+     * inside the state tree — including `nativeSet`'s coercion of primitive
+     * intermediates.
+     */
+    private replayFamilyVerbs;
+    /**
+     * May a staged `delete` at this path commit as the `'delete'` verb?
+     *
+     * Only when removing the key and the `'full'` mode's flattening (`_set` of
+     * `undefined`) land in the same place. They diverge when the parent is not
+     * a container: `nativeDelete` walks away untouched, while `nativeSet`
+     * COERCES the primitive parent into an object to hold the key. Committing
+     * `delete` there would silently drop a state change the stage really made,
+     * so those (pathological) deletes keep the historical flattening.
+     */
+    private deleteReplaysAsFlattening;
     /**
      * Replay ONE path's op-verb sequence against its base value, exactly the
      * way `applySmartMerge` replays the corresponding full-mode bundle: every

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

@@ -203,16 +203,21 @@ export class TransactionBuffer {
     }
     /**
      * Delta-encoded payload (`commitValues: 'delta'`, #13c-B) — same net-change
-     * filter as {@link toChangeOnlyPayload}, two encoding differences:
+     * filter as {@link toChangeOnlyPayload}, three 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**:
+     * 2. **Verb resolution per path** — for a path with NO surviving relative
+     *    (see 3):
      *    - last op `'delete'` AND final value gone → `delete` (the path stays
-     *      enumerated in `overwrite` with `undefined` for key-set consumers);
+     *      enumerated in `overwrite` with `undefined` for key-set consumers).
+     *      Requires the parent to be a real container in the base — replay uses
+     *      `nativeDelete`, which is inert on a primitive/absent parent, whereas
+     *      the `'full'` flattening (`_set` of `undefined`) COERCES that parent
+     *      into an object; when they would disagree we keep the flattening;
      *    - 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
@@ -227,6 +232,22 @@ export class TransactionBuffer {
      *      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.
+     * 3. **OVERLAP FAMILIES take the full-value fallback.** `overwrite` /
+     *    `updates` are nested path TREES, so two surviving paths where one is
+     *    an ancestor of the other (`a` and `a.p`) share storage. The `'full'`
+     *    payload survives that because every entry stores the FULL value at its
+     *    path, drawn from one coherent tree — nested entries agree with their
+     *    ancestor by construction. Delta's per-path encodings do NOT: an
+     *    `append` ancestor stores only a TAIL (whose indices are shifted
+     *    relative to the whole array) and a `delete` ancestor stores
+     *    `undefined`, so whichever entry is written second silently destroys or
+     *    corrupts the other — the recorded write is LOST at replay. Therefore
+     *    every path that has a surviving ancestor/descendant is committed as a
+     *    plain `set` of the value it holds in the family's replayed value
+     *    ({@link replayFamilyVerbs}), and the family's shallowest path (whose
+     *    set covers the whole subtree) is emitted LAST. One coherent tree in,
+     *    one coherent tree out: entries can no longer clobber each other and
+     *    the replayed value is exact regardless of order.
      *
      * Losslessness never depends on detection succeeding — every fallback is
      * today's full-value `set`.
@@ -235,7 +256,6 @@ export class TransactionBuffer {
         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).
@@ -255,16 +275,63 @@ export class TransactionBuffer {
                 byPath.set(op.path, { verbs: [op.verb], ...(op.readKeys !== undefined && { readKeys: op.readKeys }) });
             }
         }
+        // Net-change filter — identical to 'full'. Survivors keep last-touch order.
+        const survivors = [];
         for (const [path, { verbs, readKeys }] of byPath) {
-            const prov = readKeys !== undefined ? { readKeys } : undefined;
             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);
+            survivors.push({ path, segments, verbs, readKeys, before, after });
+        }
+        const survivingPaths = new Set(survivors.map((s) => s.path));
+        // Group survivors into OVERLAP FAMILIES (rule 3): each path's family is
+        // keyed by its SHALLOWEST surviving ancestor — walking prefixes shallow
+        // first means the first hit is that root, and a depth-1 path (the common
+        // case) never enters the loop at all. Any two paths sharing a root are
+        // exactly the paths whose patch storage overlaps.
+        const rootOf = new Map();
+        const byRoot = new Map();
+        for (const s of survivors) {
+            let root = s.path;
+            for (let i = 1; i < s.segments.length; i++) {
+                const ancestor = s.segments.slice(0, i).join(DELIM);
+                if (survivingPaths.has(ancestor)) {
+                    root = ancestor;
+                    break;
+                }
+            }
+            rootOf.set(s.path, root);
+            const family = byRoot.get(root);
+            if (family)
+                family.push(s);
+            else
+                byRoot.set(root, [s]);
+        }
+        // Replay each overlapping family ONCE (lazily — most commits have none).
+        const familyOps = this.opsByFamily(rootOf, byRoot);
+        const familyValues = new Map();
+        const familyValue = (root) => {
+            if (!familyValues.has(root)) {
+                familyValues.set(root, this.replayFamilyVerbs(root.split(DELIM), familyOps.get(root) ?? []));
+            }
+            return familyValues.get(root);
+        };
+        const emit = (s) => {
+            const { path, segments, verbs, before } = s;
+            const prov = s.readKeys !== undefined ? { readKeys: s.readKeys } : undefined;
+            const root = rootOf.get(path);
+            const family = byRoot.get(root);
+            if (family.length > 1) {
+                // Rule 3 — full-value fallback from ONE coherent family value.
+                const relative = ['v', ...segments.slice(root.split(DELIM).length)];
+                trace.push({ path, verb: 'set', ...prov });
+                _set(overwrite, segments, structuredClone(_get({ v: familyValue(root) }, relative)));
+                return;
+            }
             const lastVerb = verbs[verbs.length - 1];
-            if (lastVerb === 'delete' && after === undefined) {
+            if (lastVerb === 'delete' && s.after === undefined && this.deleteReplaysAsFlattening(segments)) {
                 // Real deletion — replay removes the key. Keep the path enumerated
                 // in `overwrite` (undefined) so Object.keys consumers see it.
                 trace.push({ path, verb: 'delete', ...prov });
@@ -288,10 +355,97 @@ export class TransactionBuffer {
                     _set(overwrite, segments, structuredClone(committed));
                 }
             }
+        };
+        for (const s of survivors) {
+            const root = rootOf.get(s.path);
+            const family = byRoot.get(root);
+            if (family.length === 1) {
+                emit(s);
+                continue;
+            }
+            // Overlapping family: members in last-touch order, the ROOT emitted
+            // LAST — its whole-subtree set is what makes the replayed subtree
+            // exactly the family value (a descendant applied afterwards could only
+            // re-state a value already inside it, but would also leave behind the
+            // `key: undefined` shells 'full' mode never has).
+            if (s.path !== root)
+                emit(s);
+            if (family[family.length - 1] === s)
+                emit(family.find((m) => m.path === root));
         }
         const redactedPaths = new Set([...this.redactedPaths].filter((path) => survivingPaths.has(path)));
         return { overwrite, updates, redactedPaths, trace };
     }
+    /**
+     * Bucket the staged ops of every OVERLAPPING family by family root, in op
+     * order — the input {@link replayFamilyVerbs} folds. Ops on paths the
+     * net-change filter dropped are skipped (they are absent from `rootOf`),
+     * exactly as the `'full'` payload drops them from its trace. One pass over
+     * `opTrace`, and only when at least one family actually overlaps — commits
+     * that write no nested path pay nothing.
+     */
+    opsByFamily(rootOf, byRoot) {
+        const buckets = new Map();
+        for (const [root, family] of byRoot)
+            if (family.length > 1)
+                buckets.set(root, []);
+        if (buckets.size === 0)
+            return buckets;
+        for (const op of this.opTrace) {
+            const bucket = buckets.get(rootOf.get(op.path));
+            if (bucket)
+                bucket.push(op);
+        }
+        return buckets;
+    }
+    /**
+     * Replay ONE overlapping family's staged ops onto the family root's base
+     * value — the multi-path generalisation of {@link replayPathVerbs}, and
+     * byte-for-byte what `applySmartMerge` produces for the corresponding
+     * `'full'`-mode entries: each `set`/`delete` position writes that path's
+     * `overwritePatch` value, each `merge` position deep-merges that path's
+     * accumulated `updatePatch` delta into the value replayed so far.
+     *
+     * (Both patches are single coherent trees, so a full-mode bundle's stored
+     * value at any recorded path always reads back as its `overwritePatch` /
+     * `updatePatch` value — which is why sourcing from them here reproduces the
+     * full-mode replay exactly, including its intermediate-coercion quirks.)
+     *
+     * The value is held in a `{ v }` box so the root itself (relative path `[]`)
+     * can be REPLACED by `_set` the same way `applySmartMerge` replaces it
+     * inside the state tree — including `nativeSet`'s coercion of primitive
+     * intermediates.
+     */
+    replayFamilyVerbs(rootSegments, ops) {
+        const box = { v: structuredClone(_get(this.baseSnapshot, rootSegments)) };
+        for (const op of ops) {
+            const segments = op.path.split(DELIM);
+            const at = ['v', ...segments.slice(rootSegments.length)];
+            if (op.verb === 'merge') {
+                _set(box, at, deepSmartMerge(_get(box, at) ?? {}, structuredClone(_get(this.updatePatch, segments))));
+            }
+            else {
+                _set(box, at, structuredClone(_get(this.overwritePatch, segments)));
+            }
+        }
+        return box.v;
+    }
+    /**
+     * May a staged `delete` at this path commit as the `'delete'` verb?
+     *
+     * Only when removing the key and the `'full'` mode's flattening (`_set` of
+     * `undefined`) land in the same place. They diverge when the parent is not
+     * a container: `nativeDelete` walks away untouched, while `nativeSet`
+     * COERCES the primitive parent into an object to hold the key. Committing
+     * `delete` there would silently drop a state change the stage really made,
+     * so those (pathological) deletes keep the historical flattening.
+     */
+    deleteReplaysAsFlattening(segments) {
+        if (segments.length === 1)
+            return true; // parent is the state root — always a container
+        const parent = _get(this.baseSnapshot, segments.slice(0, -1));
+        return parent !== null && typeof parent === 'object';
+    }
     /**
      * Replay ONE path's op-verb sequence against its base value, exactly the
      * way `applySmartMerge` replays the corresponding full-mode bundle: every
@@ -323,6 +477,13 @@ export class TransactionBuffer {
  *
  * `before === undefined` (first write) fails `Array.isArray` → `set`, which
  * keeps the first write as the causal anchor for "who initialized this key".
+ *
+ * BOTH arrays must also be plain and dense ({@link isIndexOnly}): replay
+ * reconstructs an append as `[...current, ...tail]`, and that spread carries
+ * ONLY indexed elements — a named property parked on an array (a nested write
+ * like `set(['history','note'], …)`, which `nativeSet` happily hangs off the
+ * array object) or a hole would be silently dropped, where `'full'` mode
+ * stores the value whole and keeps it.
  */
 function isStrictArrayPrefix(before, after) {
     if (!Array.isArray(before) || !Array.isArray(after))
@@ -333,6 +494,13 @@ function isStrictArrayPrefix(before, after) {
         if (!deepEqual(before[i], after[i]))
             return false;
     }
-    return true;
+    return isIndexOnly(before) && isIndexOnly(after);
+}
+/** True when an array's own enumerable keys are exactly its indices — no
+ *  extra named properties and no holes, i.e. the array survives a spread
+ *  intact. One `Object.keys` pass, same order as the prefix compare above
+ *  and paid only after it succeeds. */
+function isIndexOnly(arr) {
+    return Object.keys(arr).length === arr.length;
 }
-//# 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; readKeys?: string[] }[] = [];\n  private redactedPaths = new Set<string>();\n  /** Commit-value encoding policy (#13c-B). `'full'` = historical bytes. */\n  private readonly commitValues: CommitValuesMode;\n\n  /** Per-write read-provenance source (#P1). When set (the\n   *  `writeProvenance: 'reads-prefix'` dial), every staged op snapshots the\n   *  keys tracked-read so far — the temporal-prefix attribution consumed by\n   *  causal slicing. Undefined (default) = zero cost, byte-identical ops. */\n  private readonly readKeysProvider?: () => string[];\n\n  constructor(base: any, commitValues: CommitValuesMode = 'full', readKeysProvider?: () => string[]) {\n    this.baseSnapshot = structuredClone(base);\n    this.workingCopy = structuredClone(base);\n    this.commitValues = commitValues;\n    this.readKeysProvider = readKeysProvider;\n  }\n\n  /** Stamp the current read prefix onto a staged op — only when the\n   *  provenance dial is on (provider present), so the default path allocates\n   *  nothing and commit bundles stay byte-identical. */\n  private stampReadKeys(op: { path: string; verb: OpVerb; readKeys?: string[] }): typeof op {\n    if (this.readKeysProvider) op.readKeys = this.readKeysProvider();\n    return op;\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(this.stampReadKeys({ 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(this.stampReadKeys({ 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(this.stampReadKeys({ 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      // Per-write provenance (#P1) rides each surviving entry untouched.\n      trace.push(\n        op.verb === 'delete'\n          ? { path: op.path, verb: 'set' as const, ...(op.readKeys !== undefined && { readKeys: op.readKeys }) }\n          : op,\n      );\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    // Per-write provenance (#P1): the LAST op's readKeys is kept — read\n    // prefixes only grow within a stage, so last == union across the path.\n    const byPath = new Map<string, { verbs: OpVerb[]; readKeys?: string[] }>();\n    for (const op of this.opTrace) {\n      const prev = byPath.get(op.path);\n      if (prev) {\n        prev.verbs.push(op.verb);\n        if (op.readKeys !== undefined) prev.readKeys = op.readKeys;\n        byPath.delete(op.path);\n        byPath.set(op.path, prev);\n      } else {\n        byPath.set(op.path, { verbs: [op.verb], ...(op.readKeys !== undefined && { readKeys: op.readKeys }) });\n      }\n    }\n\n    for (const [path, { verbs, readKeys }] of byPath) {\n      const prov = readKeys !== undefined ? { readKeys } : undefined;\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', ...prov });\n        _set(overwrite, segments, undefined);\n      } else if (verbs.every((v) => v === 'merge')) {\n        trace.push({ path, verb: 'merge', ...prov });\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', ...prov });\n          _set(overwrite, segments, structuredClone((committed as unknown[]).slice((before as unknown[]).length)));\n        } else {\n          trace.push({ path, verb: 'set', ...prov });\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"]}
+//# 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\n/** A path that passed the net-change filter, with everything the delta\n *  encoder needs to decide its verb — resolved once, then reused by the\n *  overlap-family grouping (`toDeltaPayload` rule 3). */\ntype Survivor = {\n  path: string;\n  segments: string[];\n  verbs: OpVerb[];\n  readKeys?: string[];\n  /** Value at this path when the stage began (the append/diff base). */\n  before: unknown;\n  /** Value at this path after every staged op (read-your-writes view). */\n  after: unknown;\n};\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; readKeys?: string[] }[] = [];\n  private redactedPaths = new Set<string>();\n  /** Commit-value encoding policy (#13c-B). `'full'` = historical bytes. */\n  private readonly commitValues: CommitValuesMode;\n\n  /** Per-write read-provenance source (#P1). When set (the\n   *  `writeProvenance: 'reads-prefix'` dial), every staged op snapshots the\n   *  keys tracked-read so far — the temporal-prefix attribution consumed by\n   *  causal slicing. Undefined (default) = zero cost, byte-identical ops. */\n  private readonly readKeysProvider?: () => string[];\n\n  constructor(base: any, commitValues: CommitValuesMode = 'full', readKeysProvider?: () => string[]) {\n    this.baseSnapshot = structuredClone(base);\n    this.workingCopy = structuredClone(base);\n    this.commitValues = commitValues;\n    this.readKeysProvider = readKeysProvider;\n  }\n\n  /** Stamp the current read prefix onto a staged op — only when the\n   *  provenance dial is on (provider present), so the default path allocates\n   *  nothing and commit bundles stay byte-identical. */\n  private stampReadKeys(op: { path: string; verb: OpVerb; readKeys?: string[] }): typeof op {\n    if (this.readKeysProvider) op.readKeys = this.readKeysProvider();\n    return op;\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(this.stampReadKeys({ 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(this.stampReadKeys({ 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(this.stampReadKeys({ 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      // Per-write provenance (#P1) rides each surviving entry untouched.\n      trace.push(\n        op.verb === 'delete'\n          ? { path: op.path, verb: 'set' as const, ...(op.readKeys !== undefined && { readKeys: op.readKeys }) }\n          : op,\n      );\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}, three 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** — for a path with NO surviving relative\n   *    (see 3):\n   *    - last op `'delete'` AND final value gone → `delete` (the path stays\n   *      enumerated in `overwrite` with `undefined` for key-set consumers).\n   *      Requires the parent to be a real container in the base — replay uses\n   *      `nativeDelete`, which is inert on a primitive/absent parent, whereas\n   *      the `'full'` flattening (`_set` of `undefined`) COERCES that parent\n   *      into an object; when they would disagree we keep the flattening;\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   * 3. **OVERLAP FAMILIES take the full-value fallback.** `overwrite` /\n   *    `updates` are nested path TREES, so two surviving paths where one is\n   *    an ancestor of the other (`a` and `a.p`) share storage. The `'full'`\n   *    payload survives that because every entry stores the FULL value at its\n   *    path, drawn from one coherent tree — nested entries agree with their\n   *    ancestor by construction. Delta's per-path encodings do NOT: an\n   *    `append` ancestor stores only a TAIL (whose indices are shifted\n   *    relative to the whole array) and a `delete` ancestor stores\n   *    `undefined`, so whichever entry is written second silently destroys or\n   *    corrupts the other — the recorded write is LOST at replay. Therefore\n   *    every path that has a surviving ancestor/descendant is committed as a\n   *    plain `set` of the value it holds in the family's replayed value\n   *    ({@link replayFamilyVerbs}), and the family's shallowest path (whose\n   *    set covers the whole subtree) is emitted LAST. One coherent tree in,\n   *    one coherent tree out: entries can no longer clobber each other and\n   *    the replayed value is exact regardless of order.\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\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    // Per-write provenance (#P1): the LAST op's readKeys is kept — read\n    // prefixes only grow within a stage, so last == union across the path.\n    const byPath = new Map<string, { verbs: OpVerb[]; readKeys?: string[] }>();\n    for (const op of this.opTrace) {\n      const prev = byPath.get(op.path);\n      if (prev) {\n        prev.verbs.push(op.verb);\n        if (op.readKeys !== undefined) prev.readKeys = op.readKeys;\n        byPath.delete(op.path);\n        byPath.set(op.path, prev);\n      } else {\n        byPath.set(op.path, { verbs: [op.verb], ...(op.readKeys !== undefined && { readKeys: op.readKeys }) });\n      }\n    }\n\n    // Net-change filter — identical to 'full'. Survivors keep last-touch order.\n    const survivors: Survivor[] = [];\n    for (const [path, { verbs, readKeys }] 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      survivors.push({ path, segments, verbs, readKeys, before, after });\n    }\n    const survivingPaths = new Set(survivors.map((s) => s.path));\n\n    // Group survivors into OVERLAP FAMILIES (rule 3): each path's family is\n    // keyed by its SHALLOWEST surviving ancestor — walking prefixes shallow\n    // first means the first hit is that root, and a depth-1 path (the common\n    // case) never enters the loop at all. Any two paths sharing a root are\n    // exactly the paths whose patch storage overlaps.\n    const rootOf = new Map<string, string>();\n    const byRoot = new Map<string, Survivor[]>();\n    for (const s of survivors) {\n      let root = s.path;\n      for (let i = 1; i < s.segments.length; i++) {\n        const ancestor = s.segments.slice(0, i).join(DELIM);\n        if (survivingPaths.has(ancestor)) {\n          root = ancestor;\n          break;\n        }\n      }\n      rootOf.set(s.path, root);\n      const family = byRoot.get(root);\n      if (family) family.push(s);\n      else byRoot.set(root, [s]);\n    }\n\n    // Replay each overlapping family ONCE (lazily — most commits have none).\n    const familyOps = this.opsByFamily(rootOf, byRoot);\n    const familyValues = new Map<string, unknown>();\n    const familyValue = (root: string): unknown => {\n      if (!familyValues.has(root)) {\n        familyValues.set(root, this.replayFamilyVerbs(root.split(DELIM), familyOps.get(root) ?? []));\n      }\n      return familyValues.get(root);\n    };\n\n    const emit = (s: Survivor): void => {\n      const { path, segments, verbs, before } = s;\n      const prov = s.readKeys !== undefined ? { readKeys: s.readKeys } : undefined;\n      const root = rootOf.get(path) as string;\n      const family = byRoot.get(root) as Survivor[];\n\n      if (family.length > 1) {\n        // Rule 3 — full-value fallback from ONE coherent family value.\n        const relative = ['v', ...segments.slice(root.split(DELIM).length)];\n        trace.push({ path, verb: 'set', ...prov });\n        _set(overwrite, segments, structuredClone(_get({ v: familyValue(root) }, relative)));\n        return;\n      }\n\n      const lastVerb = verbs[verbs.length - 1];\n      if (lastVerb === 'delete' && s.after === undefined && this.deleteReplaysAsFlattening(segments)) {\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', ...prov });\n        _set(overwrite, segments, undefined);\n      } else if (verbs.every((v) => v === 'merge')) {\n        trace.push({ path, verb: 'merge', ...prov });\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', ...prov });\n          _set(overwrite, segments, structuredClone((committed as unknown[]).slice((before as unknown[]).length)));\n        } else {\n          trace.push({ path, verb: 'set', ...prov });\n          _set(overwrite, segments, structuredClone(committed));\n        }\n      }\n    };\n\n    for (const s of survivors) {\n      const root = rootOf.get(s.path) as string;\n      const family = byRoot.get(root) as Survivor[];\n      if (family.length === 1) {\n        emit(s);\n        continue;\n      }\n      // Overlapping family: members in last-touch order, the ROOT emitted\n      // LAST — its whole-subtree set is what makes the replayed subtree\n      // exactly the family value (a descendant applied afterwards could only\n      // re-state a value already inside it, but would also leave behind the\n      // `key: undefined` shells 'full' mode never has).\n      if (s.path !== root) emit(s);\n      if (family[family.length - 1] === s) emit(family.find((m) => m.path === root) as Survivor);\n    }\n\n    const redactedPaths = new Set([...this.redactedPaths].filter((path) => survivingPaths.has(path)));\n    return { overwrite, updates, redactedPaths, trace };\n  }\n\n  /**\n   * Bucket the staged ops of every OVERLAPPING family by family root, in op\n   * order — the input {@link replayFamilyVerbs} folds. Ops on paths the\n   * net-change filter dropped are skipped (they are absent from `rootOf`),\n   * exactly as the `'full'` payload drops them from its trace. One pass over\n   * `opTrace`, and only when at least one family actually overlaps — commits\n   * that write no nested path pay nothing.\n   */\n  private opsByFamily(\n    rootOf: Map<string, string>,\n    byRoot: Map<string, Survivor[]>,\n  ): Map<string, { path: string; verb: OpVerb }[]> {\n    const buckets = new Map<string, { path: string; verb: OpVerb }[]>();\n    for (const [root, family] of byRoot) if (family.length > 1) buckets.set(root, []);\n    if (buckets.size === 0) return buckets;\n    for (const op of this.opTrace) {\n      const bucket = buckets.get(rootOf.get(op.path) as string);\n      if (bucket) bucket.push(op);\n    }\n    return buckets;\n  }\n\n  /**\n   * Replay ONE overlapping family's staged ops onto the family root's base\n   * value — the multi-path generalisation of {@link replayPathVerbs}, and\n   * byte-for-byte what `applySmartMerge` produces for the corresponding\n   * `'full'`-mode entries: each `set`/`delete` position writes that path's\n   * `overwritePatch` value, each `merge` position deep-merges that path's\n   * accumulated `updatePatch` delta into the value replayed so far.\n   *\n   * (Both patches are single coherent trees, so a full-mode bundle's stored\n   * value at any recorded path always reads back as its `overwritePatch` /\n   * `updatePatch` value — which is why sourcing from them here reproduces the\n   * full-mode replay exactly, including its intermediate-coercion quirks.)\n   *\n   * The value is held in a `{ v }` box so the root itself (relative path `[]`)\n   * can be REPLACED by `_set` the same way `applySmartMerge` replaces it\n   * inside the state tree — including `nativeSet`'s coercion of primitive\n   * intermediates.\n   */\n  private replayFamilyVerbs(rootSegments: string[], ops: { path: string; verb: OpVerb }[]): unknown {\n    const box: { v: unknown } = { v: structuredClone(_get(this.baseSnapshot, rootSegments)) };\n    for (const op of ops) {\n      const segments = op.path.split(DELIM);\n      const at = ['v', ...segments.slice(rootSegments.length)];\n      if (op.verb === 'merge') {\n        _set(box, at, deepSmartMerge(_get(box, at) ?? {}, structuredClone(_get(this.updatePatch, segments))));\n      } else {\n        _set(box, at, structuredClone(_get(this.overwritePatch, segments)));\n      }\n    }\n    return box.v;\n  }\n\n  /**\n   * May a staged `delete` at this path commit as the `'delete'` verb?\n   *\n   * Only when removing the key and the `'full'` mode's flattening (`_set` of\n   * `undefined`) land in the same place. They diverge when the parent is not\n   * a container: `nativeDelete` walks away untouched, while `nativeSet`\n   * COERCES the primitive parent into an object to hold the key. Committing\n   * `delete` there would silently drop a state change the stage really made,\n   * so those (pathological) deletes keep the historical flattening.\n   */\n  private deleteReplaysAsFlattening(segments: string[]): boolean {\n    if (segments.length === 1) return true; // parent is the state root — always a container\n    const parent = _get(this.baseSnapshot, segments.slice(0, -1));\n    return parent !== null && typeof parent === 'object';\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 *\n * BOTH arrays must also be plain and dense ({@link isIndexOnly}): replay\n * reconstructs an append as `[...current, ...tail]`, and that spread carries\n * ONLY indexed elements — a named property parked on an array (a nested write\n * like `set(['history','note'], …)`, which `nativeSet` happily hangs off the\n * array object) or a hole would be silently dropped, where `'full'` mode\n * stores the value whole and keeps it.\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 isIndexOnly(before) && isIndexOnly(after);\n}\n\n/** True when an array's own enumerable keys are exactly its indices — no\n *  extra named properties and no holes, i.e. the array survives a spread\n *  intact. One `Object.keys` pass, same order as the prefix compare above\n *  and paid only after it succeeds. */\nfunction isIndexOnly(arr: unknown[]): boolean {\n  return Object.keys(arr).length === arr.length;\n}\n"]}

package/dist/esm/lib/recorder/CombinedRecorder.d.ts

@@ -111,6 +111,9 @@ export type CombinedRecorder = Partial<Omit<ScopeRecorder, SharedLifecycleOverla
         description?: string;
         preferredOperation?: 'translate' | 'accumulate' | 'aggregate';
         data: unknown;
+        /** Machine-readable facts about the bundle itself — see
+         *  {@link import('../runner/ExecutionRuntime.js').RecorderSnapshot.meta}. */
+        meta?: Readonly<Record<string, unknown>>;
     };
     onError?(event: ErrorEvent | FlowErrorEvent): void;
     onPause?(event: PauseEvent | FlowPauseEvent): void;