footprintjs 9.6.0 → 9.7.0

package/dist/lib/memory/TransactionBuffer.js

@@ -29,9 +29,12 @@ 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) {
@@ -42,6 +45,25 @@ class TransactionBuffer {
         }
         this.opTrace.push({ path: (0, utils_js_1.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) {
+        (0, pathOps_js_1.nativeSet)(this.workingCopy, path, undefined);
+        (0, pathOps_js_1.nativeSet)(this.overwritePatch, path, undefined);
+        if (shouldRedact) {
+            this.redactedPaths.add((0, utils_js_1.normalisePath)(path));
+        }
+        this.opTrace.push({ path: (0, utils_js_1.normalisePath)(path), verb: 'delete' });
+    }
     /** Deep union merge at the specified path. */
     merge(path, value, shouldRedact = false) {
         const existing = (0, pathOps_js_1.nativeGet)(this.workingCopy, path) ?? {};
@@ -104,10 +126,11 @@ 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.
@@ -115,7 +138,7 @@ 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;
@@ -134,6 +157,11 @@ 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 = {};
@@ -146,18 +174,147 @@ class TransactionBuffer {
             const after = (0, pathOps_js_1.nativeGet)(this.workingCopy, segments);
             if ((0, utils_js_1.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') {
+                (0, pathOps_js_1.nativeSet)(updates, segments, structuredClone((0, pathOps_js_1.nativeGet)(this.updatePatch, segments)));
+            }
+            else {
                 (0, pathOps_js_1.nativeSet)(overwrite, segments, structuredClone((0, pathOps_js_1.nativeGet)(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(utils_js_1.DELIM);
+            const before = (0, pathOps_js_1.nativeGet)(this.baseSnapshot, segments);
+            const after = (0, pathOps_js_1.nativeGet)(this.workingCopy, segments);
+            if ((0, utils_js_1.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' });
+                (0, pathOps_js_1.nativeSet)(overwrite, segments, undefined);
+            }
+            else if (verbs.every((v) => v === 'merge')) {
+                trace.push({ path, verb: 'merge' });
                 (0, pathOps_js_1.nativeSet)(updates, segments, structuredClone((0, pathOps_js_1.nativeGet)(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' });
+                    (0, pathOps_js_1.nativeSet)(overwrite, segments, structuredClone(committed.slice(before.length)));
+                }
+                else {
+                    trace.push({ path, verb: 'set' });
+                    (0, pathOps_js_1.nativeSet)(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 = (0, pathOps_js_1.nativeGet)(this.overwritePatch, segments);
+        const mergeDelta = (0, pathOps_js_1.nativeGet)(this.updatePatch, segments);
+        let value = before;
+        for (const verb of verbs) {
+            value = verb === 'merge' ? (0, utils_js_1.deepSmartMerge)(value ?? {}, mergeDelta) : setValue;
+        }
+        return value;
+    }
 }
 exports.TransactionBuffer = TransactionBuffer;
-//# 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"]}
+/**
+ * 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 (!(0, utils_js_1.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 { 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/lib/memory/commitLogUtils.js

@@ -6,7 +6,9 @@
  * These helpers provide type-safe queries without (b: any) casts.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findLastWriter = exports.findCommits = exports.findCommit = void 0;
+exports.commitValueAt = exports.findLastWriter = exports.findCommits = exports.findCommit = void 0;
+const pathOps_js_1 = require("./pathOps.js");
+const utils_js_1 = require("./utils.js");
 /** Find the first commit by stageId, optionally filtering by a written key. */
 function findCommit(commitLog, stageId, key) {
     return commitLog.find((b) => b.stageId === stageId && (!key || b.trace.some((t) => t.path === key)));
@@ -28,4 +30,73 @@ function findLastWriter(commitLog, key, beforeIdx) {
     return undefined;
 }
 exports.findLastWriter = findLastWriter;
-//# 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).
+ */
+function commitValueAt(commitLog, idx, key) {
+    const end = Math.min(idx, commitLog.length - 1);
+    const segs = key.split(utils_js_1.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((0, pathOps_js_1.nativeGet)(bundle.overwrite, segs));
+        }
+        else if (verb === 'delete') {
+            value = undefined;
+        }
+        else if (verb === 'append') {
+            const tail = structuredClone((0, pathOps_js_1.nativeGet)(bundle.overwrite, segs));
+            value = Array.isArray(value) && Array.isArray(tail) ? [...value, ...tail] : tail;
+        }
+        else {
+            value = (0, utils_js_1.deepSmartMerge)(value, structuredClone((0, pathOps_js_1.nativeGet)(bundle.updates, segs)));
+        }
+    }
+    return value;
+}
+exports.commitValueAt = commitValueAt;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"commitLogUtils.js","sourceRoot":"","sources":["../../../src/lib/memory/commitLogUtils.ts"],"names":[],"mappings":"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","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/lib/memory/index.js

@@ -34,4 +34,4 @@ Object.defineProperty(exports, "redactPatch", { enumerable: true, get: function
 Object.defineProperty(exports, "setNestedValue", { enumerable: true, get: function () { return utils_js_1.setNestedValue; } });
 Object.defineProperty(exports, "updateNestedValue", { enumerable: true, get: function () { return utils_js_1.updateNestedValue; } });
 Object.defineProperty(exports, "updateValue", { enumerable: true, get: function () { return utils_js_1.updateValue; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/memory/pathOps.js

@@ -23,7 +23,7 @@
  * Paths may be dot-notation strings or pre-split (string|number)[] arrays.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeContextWins = exports.nativeHas = exports.nativeSet = exports.nativeGet = void 0;
+exports.mergeContextWins = exports.nativeHas = exports.nativeDelete = exports.nativeSet = exports.nativeGet = void 0;
 const DENIED = new Set(['__proto__', 'constructor', 'prototype']);
 function toSegments(path) {
     return Array.isArray(path) ? path : path.split('.');
@@ -71,6 +71,34 @@ function nativeSet(obj, path, value) {
     return obj;
 }
 exports.nativeSet = nativeSet;
+/**
+ * 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.
+ */
+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];
+    }
+}
+exports.nativeDelete = nativeDelete;
 /** Returns true if `obj` has an own property at every segment of `path`. */
 function nativeHas(obj, path) {
     const segs = toSegments(path);
@@ -119,4 +147,4 @@ function mergeContextWins(dst, src) {
     return out;
 }
 exports.mergeContextWins = mergeContextWins;
-//# 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"]}