footprintjs 9.44.3 → 9.46.0

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

@@ -0,0 +1,265 @@
+/**
+ * RecordFrame — the record half of one stage's frame (C3, L3).
+ *
+ * What a stage's frame needs to READ and WRITE the record, and nothing about the stage inside a run:
+ * where it writes (its address), what it read first (the first-touch base), what it staged (the lazy
+ * transaction buffer), which keys it read (the readKeys list), and where a commit lands (live state,
+ * the redacted mirror, the log — through `recordCommit`). The engine's frame (`StageContext`, L4)
+ * composes one and keeps the rest: retention, diagnostics, the dev-mode warnings, the commit observer
+ * and the redaction verdict.
+ *
+ * THE LAW:
+ *   1. ADDRESS. The frame reads and writes at its address, a path prefix the engine computed and hands
+ *      over as data (C2: `['runs', <id>]` or `[]`, the root). It moves only before the first write:
+ *      the buffer keeps the address it was built at (the engine refuses a later move).
+ *   2. FIRST TOUCH. The committed generation the frame first touched — its first read OR first write —
+ *      is held by reference, never cloned: the read view before the first write and the buffer's
+ *      net-change diff base after it.
+ *   3. TWO TIERS. A read is served from the stage's own view (the buffer's working copy once the stage
+ *      wrote, else the first-touch base); a key absent there is served from LIVE state (at the
+ *      address, then the root). After the first write the buffer's diff base is first given a private
+ *      copy at that path (`TransactionBuffer · detachBase`).
+ *   4. LAZY BUFFER. The buffer is built at the first write — on the first-touch base, at the address,
+ *      under the encoding. A frame that never writes builds none, and its commit is the empty bundle.
+ *   5. READ KEYS. Under `writeProvenance: 'reads-prefix'` every noted read puts its user-level key
+ *      (dotted for a nested path) on the frame's list, once, in order; each staged row carries a copy
+ *      of the list as it stands when the row is staged.
+ *   6. COMMIT, RELEASE, DISCARD. `commit` takes the buffer's payload (none = the empty commit), then
+ *      the names, and hands both to `recordCommit`. `release` drops the buffer and the base; a frame
+ *      touched again re-anchors on the state as it stands then. The readKeys list survives a release,
+ *      and goes with `discard` (a failed attempt never happened).
+ */
+import { nativeGet } from './pathOps.js';
+import { recordCommit } from './recordCommit.js';
+import { TransactionBuffer } from './TransactionBuffer.js';
+export class RecordFrame {
+    /** Live committed state — the heap every frame of the run shares. */
+    state;
+    /** The log the frame's commits land on, when the run keeps one. */
+    log;
+    /** The redacted mirror the frame's commits land on, when the run keeps one ({@link useMirror}). */
+    _mirror;
+    /** Where the frame reads and writes (law 1). */
+    _address;
+    /** The two dials (law 4, 5); absent → the record's defaults. */
+    encoding;
+    /**
+     * The committed generation at the frame's FIRST touch (law 2) — held by REFERENCE, never cloned.
+     * See {@link firstTouch} for the algorithm and the immutability invariant that makes a bare
+     * reference safe.
+     */
+    base;
+    /** The stage's staged writes — built at its first write (law 4), released at commit. */
+    buffer;
+    /**
+     * Keys tracked-read so far, in order (law 5) — the source of each staged row's `readKeys`. Only
+     * allocated under `'reads-prefix'`; insertion-ordered (a Set) and monotonic, which is what makes
+     * "last write's prefix == union" hold in delta mode.
+     */
+    readKeys;
+    constructor(state, log, address = []) {
+        this.state = state;
+        this.log = log;
+        this._address = address;
+    }
+    /** Where the frame reads and writes (law 1). */
+    get address() {
+        return this._address;
+    }
+    /**
+     * Read and write at `address` from now on — before the frame's first write (law 1): the buffer keeps
+     * the address it was built at. The engine's one caller, `StageContext · useAddressOf`, refuses a move
+     * once the frame has staged.
+     */
+    useAddress(address) {
+        this._address = address;
+    }
+    /** The two dials the frame encodes under from its next buffer and its next read on (law 4, 5). */
+    useEncoding(encoding) {
+        this.encoding = encoding;
+    }
+    /** The redacted mirror, if the run keeps one. */
+    get mirror() {
+        return this._mirror;
+    }
+    /** Land every commit from now on on `mirror` too, with the scrubbed rows the log takes (`recordCommit`). */
+    useMirror(mirror) {
+        this._mirror = mirror;
+    }
+    /** The absolute path of `key` under `path`: the frame's address, then the path, then the key. */
+    at(path, key) {
+        // Every read and write builds one. The root's is the path and the key; under an address, an
+        // index loop — the double spread `[...address, ...path, key]` costs a third more per call
+        // (as `utils · pathUnder` found for the address and the path).
+        const address = this._address;
+        if (address.length === 0)
+            return [...path, key];
+        const out = new Array(address.length + path.length + 1);
+        for (let i = 0; i < address.length; i++)
+            out[i] = address[i];
+        for (let i = 0; i < path.length; i++)
+            out[address.length + i] = path[i];
+        out[out.length - 1] = key;
+        return out;
+    }
+    /**
+     * ── The first-touch base (#13) ───────────────────────────────────────────
+     *
+     * WHAT: returns the committed shared state as it was at this frame's FIRST touch (first read or
+     * first write), capturing the reference on first call. Serves two consumers: reads before the first
+     * write ({@link read}) and the transaction buffer's diff base ({@link getTransactionBuffer}).
+     *
+     * WHY A BARE REFERENCE IS SAFE — the invariant this rests on: committed state is
+     * immutable-after-swap. Every write to `SharedMemory` builds the NEXT generation and swaps it in
+     * (copy-on-write, 9.29.0: `applyPatch` via `nextGeneration`, and `setValue`/`updateValue` too) — it
+     * copies the root and the containers on each written path, shares the rest, and never edits a
+     * container of the generation a stage captured here. Holding the reference therefore gives this
+     * stage a stable snapshot at zero cost — no clone, which is the entire point of #13. The transaction
+     * buffer's net-change diff base rests on the same guarantee: it IS this view.
+     *
+     * WHY FIRST TOUCH, not first write: the pre-#13 eager engine cloned the state into the buffer at
+     * the stage's first ACCESS, anchoring both its snapshot reads and its commit baseline (the
+     * net-change diff base) there. #13's first cut anchored the lazy buffer at first WRITE — observably
+     * different when something else commits in the gap between this stage's first read and its first
+     * write. That gap is REACHABLE: fork siblings are namespace-isolated for run-scoped keys (each child
+     * writes under `runs/<childId>/`), but ROOT-level keys are shared — written via `setGlobal` from
+     * consumer scope code and, critically, by `SubflowInputMapper`'s output mapping
+     * (`parentContext.setGlobal`), which is exactly what runs when a subflow is a fork branch. A
+     * sibling's root-key commit landing in the gap would shift this stage's diff base, making its
+     * CommitBundle record a phantom change (or swallow a real one) relative to the eager engine.
+     * Anchoring the view at first touch restores the EXACT eager semantics — sequential AND parallel —
+     * at zero clone cost.
+     *
+     * Read visibility is two-tier, matching eager byte-for-byte: keys present in the view at first
+     * touch read repeatably from it; keys ABSENT from it fall back to LIVE state (the eager engine's
+     * exact fallback — a mid-flight sibling root-key write was always visible to reads, and stays
+     * visible; only the DIFF BASE is pinned).
+     */
+    firstTouch() {
+        if (!this.base) {
+            this.base = this.state.getState();
+        }
+        return this.base;
+    }
+    /**
+     * The transaction buffer, created lazily on the frame's FIRST WRITE (#13).
+     *
+     * Reads NEVER construct it: read-your-writes only matters once a staged write exists, so before that
+     * {@link read} serves from the first-touch base and {@link commit} records an empty bundle — all with
+     * ZERO `structuredClone`s of the shared state.
+     *
+     * The buffer's base is the FIRST-TOUCH view, NOT the live state at write time: under parallel forks
+     * a sibling may have committed between this frame's first read and this write, and the net-change
+     * diff base must stay anchored at first touch to match the eager engine — see {@link firstTouch}.
+     */
+    getTransactionBuffer() {
+        if (!this.buffer) {
+            // Per-write provenance (#P1): hand the buffer a live view of this frame's read prefix —
+            // evaluated AT EACH WRITE, so each staged op captures exactly the reads that preceded it.
+            const readKeysProvider = this.encoding?.writeProvenance === 'reads-prefix' ? () => [...(this.readKeys ?? [])] : undefined;
+            // The frame's address (9.30.0: the admitted record reads the containers there as where the
+            // stage writes, never as a value it read).
+            this.buffer = new TransactionBuffer(this.firstTouch(), this.encoding?.commitValues, readKeysProvider, this._address);
+        }
+        return this.buffer;
+    }
+    /** Has the frame staged a write since its last release — does its buffer exist? */
+    get hasStaged() {
+        return this.buffer !== undefined;
+    }
+    /**
+     * The frame's read, mirroring the eager engine's read order byte-for-byte (law 3):
+     *
+     *    1. staged writes + first-touch snapshot — `buffer.get` over its workingCopy when the buffer
+     *       exists, else `nativeGet` over the zero-clone first-touch base (the buffer's base IS that
+     *       view, so the two tiers agree on content);
+     *    2. LIVE state via `SharedMemory · getValue` for keys absent from the snapshot — including its
+     *       address→root fallback. The eager engine had this exact live fallback for snapshot-missing
+     *       keys; byte-identity over purity. After the frame's first write such a value can be the very
+     *       container the buffer's diff base holds at the path (the stage deleted or unset it, or
+     *       replaced a container above it), so the base is detached there first
+     *       (`TransactionBuffer · detachBase`): an in-place edit of the value (out of contract) written
+     *       back is recorded, as on 9.28.0, whose base was a clone taken at the first write.
+     *
+     * Reads never construct the buffer (#13): a frame that never writes performs zero clones of the
+     * shared state.
+     */
+    read(path, key) {
+        const at = this.at(path, key);
+        const fromSnapshot = this.buffer ? this.buffer.get(at) : nativeGet(this.firstTouch(), at);
+        if (typeof fromSnapshot !== 'undefined')
+            return fromSnapshot;
+        const live = this.state.getValue(this._address, path, key);
+        // Tier 2 after the first write: keep the diff base exact (see above).
+        if (this.buffer && live !== null && typeof live === 'object')
+            this.buffer.detachBase(at);
+        return live;
+    }
+    /** Put a tracked read's user-level key on the readKeys list (law 5) — a no-op unless the frame keeps one. */
+    noteRead(path, key) {
+        if (this.encoding?.writeProvenance === 'reads-prefix') {
+            (this.readKeys ??= new Set()).add(path.length > 0 ? [...path, key].join('.') : key);
+        }
+    }
+    /**
+     * Live committed state at `key`: at the frame's address, else at the root — never the stage's own
+     * view. Typed as `SharedMemory · getValue` types it, which `StageContext · getRoot` hands on.
+     */
+    readLive(key) {
+        return this.state.getValue(this._address, [], key);
+    }
+    /** Live committed state at `key` at the root — typed as `SharedMemory · getValue` (`StageContext · getGlobal`). */
+    readGlobal(key) {
+        return this.state.getValue([], [], key);
+    }
+    /** Did a staged op touch `path` — on it, above it or below it? (A report's question; never the hot path.) */
+    wasStaged(path) {
+        return this.buffer !== undefined && this.buffer.wasStaged(path);
+    }
+    /**
+     * The value at `path` in what the stage has seen — its working copy once it wrote, else its
+     * first-touch base — WITHOUT taking a private copy: for a report that only compares.
+     */
+    peek(path) {
+        return this.buffer ? this.buffer.peek(path) : nativeGet(this.firstTouch(), path);
+    }
+    /** The value at `path` in the first-touch base — committed state as the frame first touched it. */
+    baseAt(path) {
+        return nativeGet(this.firstTouch(), path);
+    }
+    /**
+     * Record what the frame staged (law 6): the buffer's payload first — none, the empty commit, when
+     * it staged nothing (#13: zero clones) — then the names (`stampOf()`), read once the payload is
+     * built, and both to `recordCommit`. User code can run while the payload is built (a getter on a
+     * staged value, which the net-change compare and the clone invoke); what it adds to the names —
+     * an untracked read, say — is on the bundle.
+     */
+    commit(stampOf) {
+        const payload = this.buffer?.commit();
+        recordCommit(payload, stampOf(), { state: this.state, mirror: this._mirror, log: this.log });
+    }
+    /**
+     * End the frame's hold on state (#13b, law 6): drop the buffer (its working copy and whatever private
+     * copies its reads took) and the first-touch base (a reference that pins one committed-state
+     * GENERATION). Both re-create lazily: a later read re-anchors on the CURRENT committed state, and a
+     * later write builds a fresh buffer on it — so a second commit diffs against the state after the
+     * first. Without the release, the execution tree — which retains every frame for the lifetime of
+     * the run — retains one state generation per executed stage (measured O(N²) before copy-on-write;
+     * a 500-iteration agent OOMed a default Node heap, backlog #18).
+     */
+    release() {
+        this.buffer = undefined;
+        this.base = undefined;
+    }
+    /**
+     * Throw away everything the frame staged and read (law 6): the buffer, the first-touch base (the next
+     * attempt re-anchors on committed state as it stands NOW) and the readKeys list — a discarded
+     * attempt's reads must never reach the next attempt's `TraceEntry.readKeys`, or a backward slice
+     * would follow an edge that no committed write ever had. Nothing is recorded.
+     */
+    discard() {
+        this.release();
+        this.readKeys = undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RecordFrame.js","sourceRoot":"","sources":["../../../../src/lib/memory/RecordFrame.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * RecordFrame — the record half of one stage's frame (C3, L3).\n *\n * What a stage's frame needs to READ and WRITE the record, and nothing about the stage inside a run:\n * where it writes (its address), what it read first (the first-touch base), what it staged (the lazy\n * transaction buffer), which keys it read (the readKeys list), and where a commit lands (live state,\n * the redacted mirror, the log — through `recordCommit`). The engine's frame (`StageContext`, L4)\n * composes one and keeps the rest: retention, diagnostics, the dev-mode warnings, the commit observer\n * and the redaction verdict.\n *\n * THE LAW:\n *   1. ADDRESS. The frame reads and writes at its address, a path prefix the engine computed and hands\n *      over as data (C2: `['runs', <id>]` or `[]`, the root). It moves only before the first write:\n *      the buffer keeps the address it was built at (the engine refuses a later move).\n *   2. FIRST TOUCH. The committed generation the frame first touched — its first read OR first write —\n *      is held by reference, never cloned: the read view before the first write and the buffer's\n *      net-change diff base after it.\n *   3. TWO TIERS. A read is served from the stage's own view (the buffer's working copy once the stage\n *      wrote, else the first-touch base); a key absent there is served from LIVE state (at the\n *      address, then the root). After the first write the buffer's diff base is first given a private\n *      copy at that path (`TransactionBuffer · detachBase`).\n *   4. LAZY BUFFER. The buffer is built at the first write — on the first-touch base, at the address,\n *      under the encoding. A frame that never writes builds none, and its commit is the empty bundle.\n *   5. READ KEYS. Under `writeProvenance: 'reads-prefix'` every noted read puts its user-level key\n *      (dotted for a nested path) on the frame's list, once, in order; each staged row carries a copy\n *      of the list as it stands when the row is staged.\n *   6. COMMIT, RELEASE, DISCARD. `commit` takes the buffer's payload (none = the empty commit), then\n *      the names, and hands both to `recordCommit`. `release` drops the buffer and the base; a frame\n *      touched again re-anchors on the state as it stands then. The readKeys list survives a release,\n *      and goes with `discard` (a failed attempt never happened).\n */\n\nimport type { EventLog } from './EventLog.js';\nimport { nativeGet } from './pathOps.js';\nimport { type CommitStamp, recordCommit } from './recordCommit.js';\nimport type { SharedMemory } from './SharedMemory.js';\nimport { TransactionBuffer } from './TransactionBuffer.js';\nimport type { CommitValuesMode, WriteProvenanceMode } from './types.js';\n\n/**\n * The two dials that shape a frame's bytes: the log's value encoding and the per-row read prefix.\n * Held by reference and swapped whole (`useEncoding`), never edited — the engine hands the run's\n * frozen policy itself. Absent: `'full'` values and no read prefix.\n */\nexport interface RecordEncoding {\n  readonly commitValues: CommitValuesMode;\n  readonly writeProvenance: WriteProvenanceMode;\n}\n\nexport class RecordFrame {\n  /** Live committed state — the heap every frame of the run shares. */\n  readonly state: SharedMemory;\n  /** The log the frame's commits land on, when the run keeps one. */\n  readonly log?: EventLog;\n  /** The redacted mirror the frame's commits land on, when the run keeps one ({@link useMirror}). */\n  private _mirror?: SharedMemory;\n  /** Where the frame reads and writes (law 1). */\n  private _address: readonly string[];\n  /** The two dials (law 4, 5); absent → the record's defaults. */\n  private encoding?: RecordEncoding;\n  /**\n   * The committed generation at the frame's FIRST touch (law 2) — held by REFERENCE, never cloned.\n   * See {@link firstTouch} for the algorithm and the immutability invariant that makes a bare\n   * reference safe.\n   */\n  private base?: Record<string, unknown>;\n  /** The stage's staged writes — built at its first write (law 4), released at commit. */\n  private buffer?: TransactionBuffer;\n  /**\n   * Keys tracked-read so far, in order (law 5) — the source of each staged row's `readKeys`. Only\n   * allocated under `'reads-prefix'`; insertion-ordered (a Set) and monotonic, which is what makes\n   * \"last write's prefix == union\" hold in delta mode.\n   */\n  private readKeys?: Set<string>;\n\n  constructor(state: SharedMemory, log?: EventLog, address: readonly string[] = []) {\n    this.state = state;\n    this.log = log;\n    this._address = address;\n  }\n\n  /** Where the frame reads and writes (law 1). */\n  get address(): readonly string[] {\n    return this._address;\n  }\n\n  /**\n   * Read and write at `address` from now on — before the frame's first write (law 1): the buffer keeps\n   * the address it was built at. The engine's one caller, `StageContext · useAddressOf`, refuses a move\n   * once the frame has staged.\n   */\n  useAddress(address: readonly string[]): void {\n    this._address = address;\n  }\n\n  /** The two dials the frame encodes under from its next buffer and its next read on (law 4, 5). */\n  useEncoding(encoding: RecordEncoding): void {\n    this.encoding = encoding;\n  }\n\n  /** The redacted mirror, if the run keeps one. */\n  get mirror(): SharedMemory | undefined {\n    return this._mirror;\n  }\n\n  /** Land every commit from now on on `mirror` too, with the scrubbed rows the log takes (`recordCommit`). */\n  useMirror(mirror: SharedMemory | undefined): void {\n    this._mirror = mirror;\n  }\n\n  /** The absolute path of `key` under `path`: the frame's address, then the path, then the key. */\n  at(path: readonly string[], key: string): string[] {\n    // Every read and write builds one. The root's is the path and the key; under an address, an\n    // index loop — the double spread `[...address, ...path, key]` costs a third more per call\n    // (as `utils · pathUnder` found for the address and the path).\n    const address = this._address;\n    if (address.length === 0) return [...path, key];\n    const out = new Array<string>(address.length + path.length + 1);\n    for (let i = 0; i < address.length; i++) out[i] = address[i];\n    for (let i = 0; i < path.length; i++) out[address.length + i] = path[i];\n    out[out.length - 1] = key;\n    return out;\n  }\n\n  /**\n   * ── The first-touch base (#13) ───────────────────────────────────────────\n   *\n   * WHAT: returns the committed shared state as it was at this frame's FIRST touch (first read or\n   * first write), capturing the reference on first call. Serves two consumers: reads before the first\n   * write ({@link read}) and the transaction buffer's diff base ({@link getTransactionBuffer}).\n   *\n   * WHY A BARE REFERENCE IS SAFE — the invariant this rests on: committed state is\n   * immutable-after-swap. Every write to `SharedMemory` builds the NEXT generation and swaps it in\n   * (copy-on-write, 9.29.0: `applyPatch` via `nextGeneration`, and `setValue`/`updateValue` too) — it\n   * copies the root and the containers on each written path, shares the rest, and never edits a\n   * container of the generation a stage captured here. Holding the reference therefore gives this\n   * stage a stable snapshot at zero cost — no clone, which is the entire point of #13. The transaction\n   * buffer's net-change diff base rests on the same guarantee: it IS this view.\n   *\n   * WHY FIRST TOUCH, not first write: the pre-#13 eager engine cloned the state into the buffer at\n   * the stage's first ACCESS, anchoring both its snapshot reads and its commit baseline (the\n   * net-change diff base) there. #13's first cut anchored the lazy buffer at first WRITE — observably\n   * different when something else commits in the gap between this stage's first read and its first\n   * write. That gap is REACHABLE: fork siblings are namespace-isolated for run-scoped keys (each child\n   * writes under `runs/<childId>/`), but ROOT-level keys are shared — written via `setGlobal` from\n   * consumer scope code and, critically, by `SubflowInputMapper`'s output mapping\n   * (`parentContext.setGlobal`), which is exactly what runs when a subflow is a fork branch. A\n   * sibling's root-key commit landing in the gap would shift this stage's diff base, making its\n   * CommitBundle record a phantom change (or swallow a real one) relative to the eager engine.\n   * Anchoring the view at first touch restores the EXACT eager semantics — sequential AND parallel —\n   * at zero clone cost.\n   *\n   * Read visibility is two-tier, matching eager byte-for-byte: keys present in the view at first\n   * touch read repeatably from it; keys ABSENT from it fall back to LIVE state (the eager engine's\n   * exact fallback — a mid-flight sibling root-key write was always visible to reads, and stays\n   * visible; only the DIFF BASE is pinned).\n   */\n  private firstTouch(): Record<string, unknown> {\n    if (!this.base) {\n      this.base = this.state.getState();\n    }\n    return this.base;\n  }\n\n  /**\n   * The transaction buffer, created lazily on the frame's FIRST WRITE (#13).\n   *\n   * Reads NEVER construct it: read-your-writes only matters once a staged write exists, so before that\n   * {@link read} serves from the first-touch base and {@link commit} records an empty bundle — all with\n   * ZERO `structuredClone`s of the shared state.\n   *\n   * The buffer's base is the FIRST-TOUCH view, NOT the live state at write time: under parallel forks\n   * a sibling may have committed between this frame's first read and this write, and the net-change\n   * diff base must stay anchored at first touch to match the eager engine — see {@link firstTouch}.\n   */\n  getTransactionBuffer(): TransactionBuffer {\n    if (!this.buffer) {\n      // Per-write provenance (#P1): hand the buffer a live view of this frame's read prefix —\n      // evaluated AT EACH WRITE, so each staged op captures exactly the reads that preceded it.\n      const readKeysProvider =\n        this.encoding?.writeProvenance === 'reads-prefix' ? () => [...(this.readKeys ?? [])] : undefined;\n      // The frame's address (9.30.0: the admitted record reads the containers there as where the\n      // stage writes, never as a value it read).\n      this.buffer = new TransactionBuffer(\n        this.firstTouch(),\n        this.encoding?.commitValues,\n        readKeysProvider,\n        this._address,\n      );\n    }\n    return this.buffer;\n  }\n\n  /** Has the frame staged a write since its last release — does its buffer exist? */\n  get hasStaged(): boolean {\n    return this.buffer !== undefined;\n  }\n\n  /**\n   * The frame's read, mirroring the eager engine's read order byte-for-byte (law 3):\n   *\n   *    1. staged writes + first-touch snapshot — `buffer.get` over its workingCopy when the buffer\n   *       exists, else `nativeGet` over the zero-clone first-touch base (the buffer's base IS that\n   *       view, so the two tiers agree on content);\n   *    2. LIVE state via `SharedMemory · getValue` for keys absent from the snapshot — including its\n   *       address→root fallback. The eager engine had this exact live fallback for snapshot-missing\n   *       keys; byte-identity over purity. After the frame's first write such a value can be the very\n   *       container the buffer's diff base holds at the path (the stage deleted or unset it, or\n   *       replaced a container above it), so the base is detached there first\n   *       (`TransactionBuffer · detachBase`): an in-place edit of the value (out of contract) written\n   *       back is recorded, as on 9.28.0, whose base was a clone taken at the first write.\n   *\n   * Reads never construct the buffer (#13): a frame that never writes performs zero clones of the\n   * shared state.\n   */\n  read(path: string[], key?: string): unknown {\n    const at = this.at(path, key as string);\n    const fromSnapshot = this.buffer ? this.buffer.get(at) : nativeGet(this.firstTouch(), at);\n    if (typeof fromSnapshot !== 'undefined') return fromSnapshot;\n    const live = this.state.getValue(this._address, path, key);\n    // Tier 2 after the first write: keep the diff base exact (see above).\n    if (this.buffer && live !== null && typeof live === 'object') this.buffer.detachBase(at);\n    return live;\n  }\n\n  /** Put a tracked read's user-level key on the readKeys list (law 5) — a no-op unless the frame keeps one. */\n  noteRead(path: readonly string[], key: string): void {\n    if (this.encoding?.writeProvenance === 'reads-prefix') {\n      (this.readKeys ??= new Set()).add(path.length > 0 ? [...path, key].join('.') : key);\n    }\n  }\n\n  /**\n   * Live committed state at `key`: at the frame's address, else at the root — never the stage's own\n   * view. Typed as `SharedMemory · getValue` types it, which `StageContext · getRoot` hands on.\n   */\n  readLive(key: string) {\n    return this.state.getValue(this._address, [], key);\n  }\n\n  /** Live committed state at `key` at the root — typed as `SharedMemory · getValue` (`StageContext · getGlobal`). */\n  readGlobal(key: string) {\n    return this.state.getValue([], [], key);\n  }\n\n  /** Did a staged op touch `path` — on it, above it or below it? (A report's question; never the hot path.) */\n  wasStaged(path: (string | number)[]): boolean {\n    return this.buffer !== undefined && this.buffer.wasStaged(path);\n  }\n\n  /**\n   * The value at `path` in what the stage has seen — its working copy once it wrote, else its\n   * first-touch base — WITHOUT taking a private copy: for a report that only compares.\n   */\n  peek(path: (string | number)[]): unknown {\n    return this.buffer ? this.buffer.peek(path) : nativeGet(this.firstTouch(), path);\n  }\n\n  /** The value at `path` in the first-touch base — committed state as the frame first touched it. */\n  baseAt(path: (string | number)[]): unknown {\n    return nativeGet(this.firstTouch(), path);\n  }\n\n  /**\n   * Record what the frame staged (law 6): the buffer's payload first — none, the empty commit, when\n   * it staged nothing (#13: zero clones) — then the names (`stampOf()`), read once the payload is\n   * built, and both to `recordCommit`. User code can run while the payload is built (a getter on a\n   * staged value, which the net-change compare and the clone invoke); what it adds to the names —\n   * an untracked read, say — is on the bundle.\n   */\n  commit(stampOf: () => CommitStamp): void {\n    const payload = this.buffer?.commit();\n    recordCommit(payload, stampOf(), { state: this.state, mirror: this._mirror, log: this.log });\n  }\n\n  /**\n   * End the frame's hold on state (#13b, law 6): drop the buffer (its working copy and whatever private\n   * copies its reads took) and the first-touch base (a reference that pins one committed-state\n   * GENERATION). Both re-create lazily: a later read re-anchors on the CURRENT committed state, and a\n   * later write builds a fresh buffer on it — so a second commit diffs against the state after the\n   * first. Without the release, the execution tree — which retains every frame for the lifetime of\n   * the run — retains one state generation per executed stage (measured O(N²) before copy-on-write;\n   * a 500-iteration agent OOMed a default Node heap, backlog #18).\n   */\n  release(): void {\n    this.buffer = undefined;\n    this.base = undefined;\n  }\n\n  /**\n   * Throw away everything the frame staged and read (law 6): the buffer, the first-touch base (the next\n   * attempt re-anchors on committed state as it stands NOW) and the readKeys list — a discarded\n   * attempt's reads must never reach the next attempt's `TraceEntry.readKeys`, or a backward slice\n   * would follow an edge that no committed write ever had. Nothing is recorded.\n   */\n  discard(): void {\n    this.release();\n    this.readKeys = undefined;\n  }\n}\n"]}

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

@@ -2,8 +2,11 @@
  * SharedMemory — The shared state container for all flowchart execution
  *
  * Like a runtime heap with namespace isolation:
- * - Each run gets its own namespace (runs/{id}/)
- * - Default values can be initialised and preserved
+ * - A value is written at an ADDRESS — a path prefix the caller computed
+ *   (C2: the engine's frame decides it, `StageContext.ts · runAddress`) — and read
+ *   there first, then at the root
+ * - Default values seed the root, and the container at an address when a
+ *   write creates it
  * - Accepts commit bundles from TransactionBuffer
  *
  * COPY-ON-WRITE (9.29.0 — docs/design/2026-10-copy-on-write-commit.md):
@@ -22,12 +25,10 @@ export declare class SharedMemory {
     constructor(defaultValues?: unknown, initialContext?: unknown);
     /** Gets a clone of the default values. */
     getDefaultValues(): {} | undefined;
-    /** Gets all run namespaces. */
-    getRuns(): any;
-    /** Updates a value using merge semantics, as a new generation (path copy + swap). */
-    updateValue(runId: string, path: string[], key: string, value: unknown): void;
-    /** Sets a value using overwrite semantics, as a new generation (path copy + swap). */
-    setValue(runId: string, path: string[], key: string, value: unknown): void;
+    /** Updates a value at `address` + `path` using merge semantics, as a new generation (path copy + swap). */
+    updateValue(address: readonly string[], path: string[], key: string, value: unknown): void;
+    /** Sets a value at `address` + `path` using overwrite semantics, as a new generation (path copy + swap). */
+    setValue(address: readonly string[], path: string[], key: string, value: unknown): void;
     /**
      * A copy of the current generation's root whose containers on the way to
      * `key` are owned — the in-place helpers above then edit only copies.
@@ -35,9 +36,9 @@ export declare class SharedMemory {
     private ownedPathTo;
     /**
      * Reads a value from the store.
-     * Looks up in run namespace first, falls back to global.
+     * Looks up at `address` first, falls back to the root.
      */
-    getValue(runId?: string, path?: string[], key?: string): any;
+    getValue(address?: readonly string[], path?: string[], key?: string): any;
     /** Gets the entire state as a JSON object — the current generation, by reference. Never mutate it. */
     getState(): Record<string, unknown>;
     /** Applies a commit bundle from TransactionBuffer: builds the next generation and swaps it in. */

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

@@ -2,8 +2,11 @@
  * SharedMemory — The shared state container for all flowchart execution
  *
  * Like a runtime heap with namespace isolation:
- * - Each run gets its own namespace (runs/{id}/)
- * - Default values can be initialised and preserved
+ * - A value is written at an ADDRESS — a path prefix the caller computed
+ *   (C2: the engine's frame decides it, `StageContext.ts · runAddress`) — and read
+ *   there first, then at the root
+ * - Default values seed the root, and the container at an address when a
+ *   write creates it
  * - Accepts commit bundles from TransactionBuffer
  *
  * COPY-ON-WRITE (9.29.0 — docs/design/2026-10-copy-on-write-commit.md):
@@ -35,39 +38,35 @@ export class SharedMemory {
     getDefaultValues() {
         return this._defaultValues ? structuredClone(this._defaultValues) : undefined;
     }
-    /** Gets all run namespaces. */
-    getRuns() {
-        return this.context.runs;
-    }
-    /** Updates a value using merge semantics, as a new generation (path copy + swap). */
-    updateValue(runId, path, key, value) {
-        const next = this.ownedPathTo(runId, path, key);
-        updateNestedValue(next, runId, path, key, value, this.getDefaultValues());
+    /** Updates a value at `address` + `path` using merge semantics, as a new generation (path copy + swap). */
+    updateValue(address, path, key, value) {
+        const next = this.ownedPathTo(address, path, key);
+        updateNestedValue(next, address, path, key, value, this.getDefaultValues());
         this.context = next;
     }
-    /** Sets a value using overwrite semantics, as a new generation (path copy + swap). */
-    setValue(runId, path, key, value) {
-        const next = this.ownedPathTo(runId, path, key);
-        setNestedValue(next, runId, path, key, value, this.getDefaultValues());
+    /** Sets a value at `address` + `path` using overwrite semantics, as a new generation (path copy + swap). */
+    setValue(address, path, key, value) {
+        const next = this.ownedPathTo(address, path, key);
+        setNestedValue(next, address, path, key, value, this.getDefaultValues());
         this.context = next;
     }
     /**
      * A copy of the current generation's root whose containers on the way to
      * `key` are owned — the in-place helpers above then edit only copies.
      */
-    ownedPathTo(runId, path, key) {
+    ownedPathTo(address, path, key) {
         const owned = new WeakSet();
         const root = ownedRootOf(this.context, owned);
-        const { runPath, globalPath } = getRunAndGlobalPaths(runId, path);
+        const { runPath, globalPath } = getRunAndGlobalPaths(address, path);
         ownSpine(root, [...(runPath || globalPath), key], owned);
         return root;
     }
     /**
      * Reads a value from the store.
-     * Looks up in run namespace first, falls back to global.
+     * Looks up at `address` first, falls back to the root.
      */
-    getValue(runId, path, key) {
-        const { globalPath, runPath } = getRunAndGlobalPaths(runId, path);
+    getValue(address, path, key) {
+        const { globalPath, runPath } = getRunAndGlobalPaths(address, path);
         const value = runPath ? getNestedValue(this.context, runPath, key) : undefined;
         return typeof value !== 'undefined' ? value : getNestedValue(this.context, globalPath, key);
     }
@@ -80,4 +79,4 @@ export class SharedMemory {
         this.context = nextGeneration(this.context, updates, overwrite, trace);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SharedMemory.js","sourceRoot":"","sources":["../../../../src/lib/memory/SharedMemory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAEvE,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,cAAc,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAErH,MAAM,OAAO,YAAY;IACf,OAAO,GAA2B,EAAE,CAAC;IACrC,cAAc,CAAW;IAEjC,YAAY,aAAuB,EAAE,cAAwB;QAC3D,IAAI,CAAC,cAAc,GAAG,aAAa,CAAC;QACpC,MAAM,IAAI,GAAG,gBAAgB,CAAC,cAAc,IAAI,EAAE,EAAE,aAAa,IAAI,EAAE,CAAC,CAAC;QACzE,wEAAwE;QACxE,uEAAuE;QACvE,uEAAuE;QACvE,wEAAwE;QACxE,mEAAmE;QACnE,4DAA4D;QAC5D,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC7E,CAAC;IAED,0CAA0C;IAC1C,gBAAgB;QACd,OAAO,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAChF,CAAC;IAED,+BAA+B;IAC/B,OAAO;QACL,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;IAC3B,CAAC;IAED,qFAAqF;IACrF,WAAW,CAAC,KAAa,EAAE,IAAc,EAAE,GAAW,EAAE,KAAc;QACpE,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC;QAChD,iBAAiB,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC;QAC1E,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;IACtB,CAAC;IAED,sFAAsF;IACtF,QAAQ,CAAC,KAAa,EAAE,IAAc,EAAE,GAAW,EAAE,KAAc;QACjE,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC;QAChD,cAAc,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC;QACvE,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;IACtB,CAAC;IAED;;;OAGG;IACK,WAAW,CAAC,KAAa,EAAE,IAAc,EAAE,GAAW;QAC5D,MAAM,KAAK,GAAG,IAAI,OAAO,EAAU,CAAC;QACpC,MAAM,IAAI,GAAG,WAAW,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAC9C,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,oBAAoB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAClE,QAAQ,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,OAAO,IAAI,UAAU,CAAC,EAAE,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC;QACzD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACH,QAAQ,CAAC,KAAc,EAAE,IAAe,EAAE,GAAY;QACpD,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,GAAG,oBAAoB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAClE,MAAM,KAAK,GAAG,OAAO,CAAC,CAAC,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC/E,OAAO,OAAO,KAAK,KAAK,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC;IAC9F,CAAC;IAED,sGAAsG;IACtG,QAAQ;QACN,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,kGAAkG;IAClG,UAAU,CAAC,SAAsB,EAAE,OAAoB,EAAE,KAAmB;QAC1E,IAAI,CAAC,OAAO,GAAG,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;IACzE,CAAC;CACF","sourcesContent":["/**\n * SharedMemory — The shared state container for all flowchart execution\n *\n * Like a runtime heap with namespace isolation:\n * - Each run gets its own namespace (runs/{id}/)\n * - Default values can be initialised and preserved\n * - Accepts commit bundles from TransactionBuffer\n *\n * COPY-ON-WRITE (9.29.0 — docs/design/2026-10-copy-on-write-commit.md):\n * `context` is a GENERATION, and a generation is never edited. Every write —\n * `applyPatch` (a stage commit), `setValue`, `updateValue` — builds the next\n * generation by copying the root and the containers on each written path,\n * shares every other subtree with the generation before it, and swaps. So a\n * generation a stage captured (its first-touch view, its transaction\n * buffer's diff base) stays exactly what it was, and a write costs O(what it\n * wrote), not O(state).\n */\n\nimport { mergeContextWins, ownedRootOf, ownSpine } from './pathOps.js';\nimport type { MemoryPatch, TraceEntry } from './types.js';\nimport { getNestedValue, getRunAndGlobalPaths, nextGeneration, setNestedValue, updateNestedValue } from './utils.js';\n\nexport class SharedMemory {\n  private context: { [key: string]: any } = {};\n  private _defaultValues?: unknown;\n\n  constructor(defaultValues?: unknown, initialContext?: unknown) {\n    this._defaultValues = defaultValues;\n    const seed = mergeContextWins(initialContext || {}, defaultValues || {});\n    // Detached ONCE, here: `mergeContextWins` copies only the top level, so\n    // the seed's nested values are the caller's own objects. Before 9.29.0\n    // the first commit's whole-state clone detached them (and until then a\n    // caller mutating its `initialContext` changed live state with no row);\n    // nothing re-clones the state any more, so the seed is detached at\n    // construction — one clone per runtime, not one per commit.\n    this.context = Object.keys(seed).length > 0 ? structuredClone(seed) : seed;\n  }\n\n  /** Gets a clone of the default values. */\n  getDefaultValues() {\n    return this._defaultValues ? structuredClone(this._defaultValues) : undefined;\n  }\n\n  /** Gets all run namespaces. */\n  getRuns() {\n    return this.context.runs;\n  }\n\n  /** Updates a value using merge semantics, as a new generation (path copy + swap). */\n  updateValue(runId: string, path: string[], key: string, value: unknown) {\n    const next = this.ownedPathTo(runId, path, key);\n    updateNestedValue(next, runId, path, key, value, this.getDefaultValues());\n    this.context = next;\n  }\n\n  /** Sets a value using overwrite semantics, as a new generation (path copy + swap). */\n  setValue(runId: string, path: string[], key: string, value: unknown) {\n    const next = this.ownedPathTo(runId, path, key);\n    setNestedValue(next, runId, path, key, value, this.getDefaultValues());\n    this.context = next;\n  }\n\n  /**\n   * A copy of the current generation's root whose containers on the way to\n   * `key` are owned — the in-place helpers above then edit only copies.\n   */\n  private ownedPathTo(runId: string, path: string[], key: string): { [key: string]: any } {\n    const owned = new WeakSet<object>();\n    const root = ownedRootOf(this.context, owned);\n    const { runPath, globalPath } = getRunAndGlobalPaths(runId, path);\n    ownSpine(root, [...(runPath || globalPath), key], owned);\n    return root;\n  }\n\n  /**\n   * Reads a value from the store.\n   * Looks up in run namespace first, falls back to global.\n   */\n  getValue(runId?: string, path?: string[], key?: string): any {\n    const { globalPath, runPath } = getRunAndGlobalPaths(runId, path);\n    const value = runPath ? getNestedValue(this.context, runPath, key) : undefined;\n    return typeof value !== 'undefined' ? value : getNestedValue(this.context, globalPath, key);\n  }\n\n  /** Gets the entire state as a JSON object — the current generation, by reference. Never mutate it. */\n  getState(): Record<string, unknown> {\n    return this.context;\n  }\n\n  /** Applies a commit bundle from TransactionBuffer: builds the next generation and swaps it in. */\n  applyPatch(overwrite: MemoryPatch, updates: MemoryPatch, trace: TraceEntry[]): void {\n    this.context = nextGeneration(this.context, updates, overwrite, trace);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SharedMemory.js","sourceRoot":"","sources":["../../../../src/lib/memory/SharedMemory.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * SharedMemory — The shared state container for all flowchart execution\n *\n * Like a runtime heap with namespace isolation:\n * - A value is written at an ADDRESS — a path prefix the caller computed\n *   (C2: the engine's frame decides it, `StageContext.ts · runAddress`) — and read\n *   there first, then at the root\n * - Default values seed the root, and the container at an address when a\n *   write creates it\n * - Accepts commit bundles from TransactionBuffer\n *\n * COPY-ON-WRITE (9.29.0 — docs/design/2026-10-copy-on-write-commit.md):\n * `context` is a GENERATION, and a generation is never edited. Every write —\n * `applyPatch` (a stage commit), `setValue`, `updateValue` — builds the next\n * generation by copying the root and the containers on each written path,\n * shares every other subtree with the generation before it, and swaps. So a\n * generation a stage captured (its first-touch view, its transaction\n * buffer's diff base) stays exactly what it was, and a write costs O(what it\n * wrote), not O(state).\n */\n\nimport { mergeContextWins, ownedRootOf, ownSpine } from './pathOps.js';\nimport type { MemoryPatch, TraceEntry } from './types.js';\nimport { getNestedValue, getRunAndGlobalPaths, nextGeneration, setNestedValue, updateNestedValue } from './utils.js';\n\nexport class SharedMemory {\n  private context: { [key: string]: any } = {};\n  private _defaultValues?: unknown;\n\n  constructor(defaultValues?: unknown, initialContext?: unknown) {\n    this._defaultValues = defaultValues;\n    const seed = mergeContextWins(initialContext || {}, defaultValues || {});\n    // Detached ONCE, here: `mergeContextWins` copies only the top level, so\n    // the seed's nested values are the caller's own objects. Before 9.29.0\n    // the first commit's whole-state clone detached them (and until then a\n    // caller mutating its `initialContext` changed live state with no row);\n    // nothing re-clones the state any more, so the seed is detached at\n    // construction — one clone per runtime, not one per commit.\n    this.context = Object.keys(seed).length > 0 ? structuredClone(seed) : seed;\n  }\n\n  /** Gets a clone of the default values. */\n  getDefaultValues() {\n    return this._defaultValues ? structuredClone(this._defaultValues) : undefined;\n  }\n\n  /** Updates a value at `address` + `path` using merge semantics, as a new generation (path copy + swap). */\n  updateValue(address: readonly string[], path: string[], key: string, value: unknown) {\n    const next = this.ownedPathTo(address, path, key);\n    updateNestedValue(next, address, path, key, value, this.getDefaultValues());\n    this.context = next;\n  }\n\n  /** Sets a value at `address` + `path` using overwrite semantics, as a new generation (path copy + swap). */\n  setValue(address: readonly string[], path: string[], key: string, value: unknown) {\n    const next = this.ownedPathTo(address, path, key);\n    setNestedValue(next, address, path, key, value, this.getDefaultValues());\n    this.context = next;\n  }\n\n  /**\n   * A copy of the current generation's root whose containers on the way to\n   * `key` are owned — the in-place helpers above then edit only copies.\n   */\n  private ownedPathTo(address: readonly string[], path: string[], key: string): { [key: string]: any } {\n    const owned = new WeakSet<object>();\n    const root = ownedRootOf(this.context, owned);\n    const { runPath, globalPath } = getRunAndGlobalPaths(address, path);\n    ownSpine(root, [...(runPath || globalPath), key], owned);\n    return root;\n  }\n\n  /**\n   * Reads a value from the store.\n   * Looks up at `address` first, falls back to the root.\n   */\n  getValue(address?: readonly string[], path?: string[], key?: string): any {\n    const { globalPath, runPath } = getRunAndGlobalPaths(address, path);\n    const value = runPath ? getNestedValue(this.context, runPath, key) : undefined;\n    return typeof value !== 'undefined' ? value : getNestedValue(this.context, globalPath, key);\n  }\n\n  /** Gets the entire state as a JSON object — the current generation, by reference. Never mutate it. */\n  getState(): Record<string, unknown> {\n    return this.context;\n  }\n\n  /** Applies a commit bundle from TransactionBuffer: builds the next generation and swaps it in. */\n  applyPatch(overwrite: MemoryPatch, updates: MemoryPatch, trace: TraceEntry[]): void {\n    this.context = nextGeneration(this.context, updates, overwrite, trace);\n  }\n}\n"]}