footprintjs 9.28.0 → 9.29.0

package/CLAUDE.md

@@ -25,7 +25,7 @@ Entry points: `footprintjs` (public API) · `/recorders` (factories) · `/trace`
 | contract/, detach/ | I/O schema + OpenAPI; fire-and-forget child charts (drivers passed explicitly) |
 
 ## Core state & flow
-- `SharedMemory` (memory/SharedMemory.ts:14) — run-namespaced heap; committed state is **immutable-after-swap** (applySmartMerge clones+swaps).
+- `SharedMemory` (memory/SharedMemory.ts) — run-namespaced heap; committed state is **immutable-after-swap**, COPY-ON-WRITE since 9.29.0: every write (`applyPatch` → `utils · nextGeneration`, `setValue`/`updateValue`) copies the root + the containers on each written path and SHARES every other subtree with the previous generation, then swaps. A generation is never edited; the seed is detached once at construction. Design: docs/design/2026-10-copy-on-write-commit.md.
 - `StageContext` (memory/StageContext.ts:29) — per-stage frame: lazy TransactionBuffer + first-touch view; `commit()` (:531) applies patch → redacted mirror → EventLog.record → onCommit.
 - `CommitBundle`/`EventLog` — one bundle per executed stage, `bundle.idx` == array position; encoding governed by `commitValues: 'full'|'delta'`.
 - `TraversalContext` (engine/narrative/types.ts:172) — THE per-event context (runId, runtimeStageId, parentRuntimeStageId, subflowPath, loopIteration); stamped on every FlowRecorder event.
@@ -51,11 +51,12 @@ Entry points: `footprintjs` (public API) · `/recorders` (factories) · `/trace`
 - **Closed seams that look open**: ExecutionEnv (fixed type); decide() operators (evaluator.ts:19 module-private); METHOD_ROUTES; the executeNodeStep phase chain; emit dispatcher (rides scope channel).
 
 ## Change-impact map
-- **Trace verbs** (`set|merge|append|delete`, memory/types.ts:42) → FOUR verb-switch replicas in lockstep: applySmartMerge (utils.ts:254 — live commit AND EventLog.materialise), commitValueAt (commitLogUtils.ts:82), TransactionBuffer.toDeltaPayload/replayPathVerbs (:248-328); plus causalChain/findLastWriter readers. NOT a fifth replica (9.22.1): `utils.ts · supersededByNextSet` — the ONE repeated-path skip (CONSECUTIVE same-path `set` rows: only the last is applied), asked by `applySmartMerge` before its switch and by `replayFamilyVerbs`; its commit-side twin is the last-materialised-path memo in `toChangeOnlyPayload`. Rows are never dropped from the log; a non-consecutive skip is WRONG (a descendant op in between coerces/shells the container) — pinned by test/lib/memory/scenario/repeated-path-byte-identity.test.ts. Since 9.23.0 the clone in that memo loop (and every `structuredClone` in `toDeltaPayload`) is THE clone — the patch trees hold references until commit; still not a fifth replica, no verb switch was touched.
+- **Trace verbs** (`set|merge|append|delete`, memory/types.ts:42) → FOUR verb-switch replicas in lockstep: the replay, `utils · replayRows` (behind the engine's `nextGeneration` — live commit + redacted mirror; the folds' `applySmartMergeInto` — `stateAt`, `EventLog.materialise`; and the PUBLIC `applySmartMerge`, which keeps its 9.28.0 contract: base deep-cloned, fully detached result — 9.29.0), commitValueAt (commitLogUtils.ts:82), TransactionBuffer.toDeltaPayload/replayPathVerbs (:248-328); plus causalChain/findLastWriter readers. NOT a fifth replica (9.22.1): `utils.ts · supersededByNextSet` — the ONE repeated-path skip (CONSECUTIVE same-path `set` rows: only the last is applied), asked by `replayRows` before its switch and by `replayFamilyVerbs`; its commit-side twin is the last-materialised-path memo in `toChangeOnlyPayload`. Rows are never dropped from the log; a non-consecutive skip is WRONG (a descendant op in between coerces/shells the container) — pinned by test/lib/memory/scenario/repeated-path-byte-identity.test.ts. Since 9.23.0 the clone in that memo loop (and every `structuredClone` in `toDeltaPayload`) is THE clone — the patch trees hold references until commit; still not a fifth replica, no verb switch was touched.
 - **StageContext.commit / dials** → dial propagation is TRIPLICATED: ExecutionRuntime.use* (:131-161), createNext/createChild inheritance (StageContext.ts:619/640), SubflowExecutor duck-push (:151-173) — miss one and subflows silently run the default. Applies to all FOUR dials incl. writeProvenance (#P1). `commit()`'s FIRST act (9.23.0) is `materialiseWrites` — the `writeTracking` retained form is taken there, once per key, from `_pendingWrites` (bare references + the write-time verdict); anything that reads `_stageWrites` goes through `retainedWrites()` (a non-consuming fold, so a mid-run snapshot is honest), and `discardStaged` drops the pending map with the rest.
 - **runtimeStageId format** (`#`/`/` delimiters) → string parsers everywhere: parseRuntimeStageId, ScopeFacade._getSubflowPath, subflowResults dual-keying, checkpoint lean-filter, narrative buffering, store keys. All are last-delimiter based, which is why a GENERATED branch segment (`<stageId>~<index>`, 9.14.0) needed ZERO parser changes — the marker is opaque to every one of them. Only 3 places may ever know `~`: branchSegment.ts, the builder's 9 refusals, the fan-out handler. A parser that special-cases it is a design smell.
 - **Subflow id prefixing** → DUPLICATED prefixer: builder _prefixNodeTree and traverser prefixNodeTree are byte-twins; change both + stageMap key composition + resume drilling. PINNED since 9.14.0 by test/lib/engine/branch-segment-prefixer-equivalence.test.ts (fails on drift, including drift that keeps the twins equal to each other).
 - **Checkpoint shape** → `FlowChartExecutor · buildPauseCheckpoint` ↔ `FlowChartExecutor · resume` (validation) ↔ `checkpointSanitize.ts` ↔ `ResumeEntry.plan` (the path's mounts + captures + dispatcher continuations, the `pendingPauses` queue; refused up front when unwalkable, ambiguous, or a pending record is not a sibling) ↔ `SubflowExecutor · executeSubflow` resume hop (seed from the capture in place of the mapper's values — the mapper still runs, for the args — FIRST entry only) ↔ `ChildrenExecutor · raisePauses` (fills `pendingPauses`). 9.28.0 adds ONE optional field, `pendingPauses` (present only when parallel siblings wait); `continuationStageId` is a record, no longer read. Pinned: a 9.27.0 checkpoint resumes, test/lib/pause/resume-real-chart-9.27.0-checkpoints.test.ts.
+- **Committed-state writers** (copy-on-write, 9.29.0) → anything that writes into `SharedMemory`'s state, a fold's working copy or the buffer's working copy must copy before it writes: `pathOps · ownSpine` for the containers on the path, `ownedRootOf` for the root, `own`/`adopt` for what it created. An in-place edit of a container it did not create edits every generation sharing it — the counted guard stays green while the generations property fails. A new READ path through `TransactionBuffer` goes through `get` (private after the first write) unless it only compares (`peek`); a read the working copy cannot answer is served from LIVE state (`StageContext · readState`, as on 9.28.0) after `TransactionBuffer · detachBase` gives the diff base a private copy at that path — a private copy of the value handed out instead would change live state wherever 9.28.0 let an in-place edit in (a fork child's read of a parent key). `TransactionBuffer · merge` privatises its base first: `deepSmartMerge` dedups arrays BY REFERENCE, so the identity of the base is part of the bytes.
 - **Redaction** (9.19.0) has ONE owner: `memory/redaction.ts` `RedactionRule` (verdict per user-level path: `clear | whole | fields`), installed on the root StageContext by `ExecutionRuntime.useRedaction` and propagated like the four dials (createNext/createChild + SubflowExecutor push — the same triplication). `StageContext.stageWrite` is the ONE write funnel (facade writes, subflow seed, outputMapper merge-back, resume re-seed) and `getValue` retention asks the same rule; the facade asks it for recorder payloads; `SubflowExecutor` for the narrated seed (`retainRecord`). The LAW: a policy covers everything retained or served (log both encodings, mirror, stageReads/stageWrites, narrative, subflow seed + merge-back) and NEVER the live heap or the resume checkpoint. `emitPatterns` is the one separate scrub (emit channel). Two placeholders, historical: log/mirror `'REDACTED'`, scope-tier `'[REDACTED]'`.
 - **Traverser phases** → node-shape reads must use eff* overlay accessors (:646-703) or dynamic StageNode returns break; tail continuations must return ContinuationHops or stacks regrow; decider flat-dispatch must keep InvokerStamp or pause loses its invoker.
 
@@ -71,7 +72,7 @@ end: onRunEnd (throw → onRunFailed; pause → neither) → deferred terminalFl
 Seven mechanisms, no state rollback anywhere: **M1** TransactionBuffer staging + net-change commit — commit-on-error by design, explicitly NOT rollback (TransactionBuffer.ts:13-18; error path commits then rethrows). **M2** Pause/Resume checkpointing — the only resume-from-prior-point; TWO raise shapes, ONE checkpoint: `addPausableFunction` (resume runs `resumeFn`) and `interrupt(scope, payload)` (resume RE-RUNS THE STAGE FUNCTION FROM ITS TOP — stages are atomic; the answer returns out of the `interrupt()` call via a WeakMap keyed by the scope), discriminated by `checkpoint.pausedBy`; checkpoint is one detached structuredClone; resume rebuilds the cursor from pausedStageId+subflowPath and re-enters ONCE (9.28.0, `ResumeEntry`): the paused stage's stand-in (its own node, fn swapped — so a dispatcher that interrupted still dispatches) is only where the resumed traversal STARTS — never in a node map — and each subflow on the path takes its capture + entry point on its FIRST entry (a 2+-deep pause re-enters each outer subflow AT the next mount; no pre-mount stage re-runs); every level's entry carries its DISPATCHER's continuation, read from the chart (a branch/fork-child mount hands back to its parent's `next`/join at the parent's level); parallel siblings that paused together wait in `checkpoint.pendingPauses` and are asked in turn, the join after the last; the rest of the run walks the REAL chart (a loop back to the paused stage reaches it and it pauses again; later entries run the inputMapper). Not rebuilt (pinned in test/lib/pause/resume-known-limitations.test.ts): lazy-subflow / parallelForEach-branch pauses (refused), a parallel-branch STAGE's namespace on resume, fan-out error containment for the resumed child. **M3** commit-log replay (EventLog.materialise, commitValueAt — required under delta mode). **M4** loopTo re-entry — forward execution over accumulated state, bounded by maxIterations + dynamicNextHops. **M5** causalChain backward slicing (read-only analysis; honesty flags for untracked reads; `edgeAttribution: 'per-write'` refines edges via `TraceEntry.readKeys` when the writeProvenance dial recorded them — worklist, subset-of-ceiling safe). **M6 (query layer)** slice/ — variable-first triage: sliceForKey + append-fold element provenance + the ONLY safe serializations (sliceToJSON/formatSlice — never JSON.stringify a slice root). **M7 (read-time cursor)** time-travel/ — `timeTravel(snapshot)` walks stops over the finished log with `stateAt()` folding M3's replay at each one (base = `RuntimeSnapshot.initialState`, which now travels with the log); it is a READER, never a second live cursor, and `drill(mount)` opens a separate cursor over a subflow's own isolated log. 9.18.0: `timeTravel([paused, resumed])` chains a cross-executor M2 resume into ONE axis — the resumed leg's `initialState` (= the state at the pause) restarts the fold, commit indices stay run-local (`Stop.sourceIdx` names the leg), and the chain is refused unless the never-reset execution counter is monotonic across legs. Deep dive + step tables: [.claude/rules/backtracking.md](.claude/rules/backtracking.md).
 
 ## Invariants (assumed, not stated)
-- Committed state immutable-after-swap; first-touch views hold bare references on that guarantee — in-place mutation of SharedMemory.context corrupts every in-flight stage.
+- Committed state immutable-after-swap — a generation is NEVER edited, and since 9.29.0 generations SHARE every untouched subtree (copy-on-write). First-touch views AND the transaction buffer's net-change diff base hold bare references on that guarantee — an in-place mutation of a committed container corrupts every generation that shares it and blinds the diff. Every writer copies before it writes (`pathOps · ownSpine` / `ownedRootOf`); pinned by the generations property in test/lib/memory/scenario/copy-on-write-commit.test.ts and the counted guard in test/lib/memory/boundary/commit-cost-independent-of-state.test.ts.
 - Reads are borrowed live references (recorders get them un-cloned) — never mutate.
 - executionIndex globally monotonic per run; continues across resume. One CommitBundle per executed stage; empty commits are deliberate cursor stops.
 - runtimeStageId stamped BEFORE the stage runs — the entire event-correlation model rests on scope+flow events sharing it.
@@ -86,7 +87,7 @@ Seven mechanisms, no state rollback anywhere: **M1** TransactionBuffer staging +
 ## Landmines
 1. **NOT a landmine any more (9.24.0), recorded because it was one for eight releases:** TypedScope's set trap used to JSON-round-trip the ASSIGNED VALUE of every object write (Date→string, Map→{}, own undefined dropped) while `$setValue` did not — two write paths, two byte shapes. The round-trip existed only to keep the scope's own Proxies out of the buffer; `reactive/handles.ts` recognises them now (O(1)), so `writeTraps.ts · sinkSetTrap`, `arrayTraps.ts` (index set, `MUTATING_METHODS` arguments, element-proxy leaf) and `createTypedScope · assignStateKey` hand the value to the sink AS ASSIGNED and the buffer's `structuredClone` at commit is the one detaching step — both doors store the same bytes (pinned: test/lib/reactive/scenario/assigned-value-only.test.ts, a fast-check property over `fc.jsonValue()`). Consequences to keep in mind: (a) a value nothing can clone — a function, a foreign Proxy such as a framework's reactive object — now fails the stage at COMMIT through the trap too (it always did through `$setValue`; the trap used to JSON-copy it silently, dropping the function); (b) `s.k = o; o.x = 1` commits `x: 1` — what the stage reads back — the same law 9.23.0 gave `$setValue`; (c) the shape work the round-trip did for free stays explicit: `delete arr[i]`, a write past the end and `length` growth spell holes as `null` (`arrayTraps` · `fillHoles`). The surrounding state reaches the buffer by reference and is detached with `structuredClone` at commit (9.22.0 / 9.23.0).
 2. Fork "parent breaks when ALL children broke" is implemented (ChildrenExecutor.ts:53) but **unwired** — every live call site passes parentBreakFlag=undefined; fork breaks do NOT propagate in real runs.
-3. **First bite CLOSED (9.23.0 — clone once at commit):** `TransactionBuffer` · `set` now stores the REFERENCE in `overwritePatch` too (it always did in `workingCopy`) and the record's copy is taken ONCE per surviving path when the payload leaves the buffer (`toChangeOnlyPayload` / `toDeltaPayload`); `StageContext` · `trackWrite` holds the reference + verdict in `_pendingWrites` and `materialiseWrites` takes the retained form once per key at `commit()`. So `$setValue(k, o); o.x = 1` commits `x: 1` — what the stage read back — instead of a stale write-time snapshot (pinned: test/lib/memory/scenario/clone-once-at-commit.test.ts). The law "the record never aliases a caller's object" holds at the commit boundary; a mutation AFTER commit reaches nothing. Two things to keep in mind: (a) the engine's OWN nested ops (`set a` then `merge a.b` — the buffer driven directly; the proxy writes root keys) must not edit through a shared container, because only `workingCopy` receives a nested merge's result — `detachHeldAncestors` clones the held ancestor in `overwritePatch` first (the design page missed this; the `set-merge-interleaved` 9.22.0 reference pins it); (b) an UNCLONEABLE value (function, foreign Proxy) now fails at COMMIT, not at the write — the run still fails loudly with the `DataCloneError`, the stage cannot catch it, and none of that stage's writes land. The scope's OWN proxies are not uncloneable values at the boundaries the library owns (9.23.3, `reactive/handles.ts`): a handle handed to the fan-out selector, a subflow mapper or `$setValue` is swapped for the value behind it first — a handle buried inside a hand-built value elsewhere (an `interrupt` payload, a `$emit` payload) still fails at the clone. The element-write loop's other O(N)-per-write cost, the array commit callbacks' whole-array JSON round-trip, went in the same release (landmine 1, second moved behaviour); what remains per element write is the array proxy's own shallow copy-on-write (`arrayTraps` · `replaceInElement` / the traps' `[...getCurrent()]`, ~9 µs at N = 10k) — bench 1k 5.7 ms, 10k 104 ms. **Second bite — a raw element held past its stage:** a value obtained through `find`/`filter`/`for…of`/`$getValue`/`$read`/`$toRaw` in stage A and mutated in stage B is the committed object itself, so the mutation edits committed state with no row, and the dev-mode guard (`StageContext` · `warnOnBorrowedMutation`) sees it only if B also READS that key. Cannot be trapped; documented in src/lib/reactive/README.md ("A handle is bound to its stage"). A PROXY held that long is refused at the write (`ScopeFacade` · `assertLive`, sealed by the commit observer — the refusal lives on the facade, not `stageWrite`, because the frame's post-commit re-use is what the engine's double-commit paths need).
+3. **First bite CLOSED (9.23.0 — clone once at commit):** `TransactionBuffer` · `set` now stores the REFERENCE in `overwritePatch` too (it always did in `workingCopy`) and the record's copy is taken ONCE per surviving path when the payload leaves the buffer (`toChangeOnlyPayload` / `toDeltaPayload`); `StageContext` · `trackWrite` holds the reference + verdict in `_pendingWrites` and `materialiseWrites` takes the retained form once per key at `commit()`. So `$setValue(k, o); o.x = 1` commits `x: 1` — what the stage read back — instead of a stale write-time snapshot (pinned: test/lib/memory/scenario/clone-once-at-commit.test.ts). The law "the record never aliases a caller's object" holds at the commit boundary; a mutation AFTER commit reaches nothing. Two things to keep in mind: (a) the engine's OWN nested ops (`set a` then `merge a.b` — the buffer driven directly; the proxy writes root keys) must not edit through a shared container, because only `workingCopy` receives a nested merge's result — `detachHeldAncestors` clones the held ancestor in `overwritePatch` first (the design page missed this; the `set-merge-interleaved` 9.22.0 reference pins it); (b) an UNCLONEABLE value (function, foreign Proxy) now fails at COMMIT, not at the write — the run still fails loudly with the `DataCloneError`, the stage cannot catch it, and none of that stage's writes land. The scope's OWN proxies are not uncloneable values at the boundaries the library owns (9.23.3, `reactive/handles.ts`): a handle handed to the fan-out selector, a subflow mapper or `$setValue` is swapped for the value behind it first — a handle buried inside a hand-built value elsewhere (an `interrupt` payload, a `$emit` payload) still fails at the clone. The element-write loop's other O(N)-per-write cost, the array commit callbacks' whole-array JSON round-trip, went in the same release (landmine 1, second moved behaviour); what remains per element write is the array proxy's own shallow copy-on-write (`arrayTraps` · `replaceInElement` / the traps' `[...getCurrent()]`, ~9 µs at N = 10k) — bench 1k 5.7 ms, 10k 104 ms. **Second bite — a raw element held past its stage:** (within ONE stage, 9.29.0: a raw read BEFORE the stage's first write is the committed object itself — edited in place and written back it records NO change, because the diff base is that object (M7; dev mode warns, `StageContext · warnOnCommittedMutation`); a raw read AFTER the first write is the stage's private copy, `TransactionBuffer · privatise` — option D, 9.28.0's behaviour; one the working copy cannot answer (a key the stage deleted) is LIVE state, as on 9.28.0, with the diff base detached there first, `TransactionBuffer · detachBase`, so a write-back is recorded as it was.) A value obtained through `find`/`filter`/`for…of`/`$getValue`/`$read`/`$toRaw` in stage A and mutated in stage B is the committed object itself, so the mutation edits committed state with no row, and the dev-mode guard (`StageContext` · `warnOnBorrowedMutation`) sees it only if B also READS that key. Cannot be trapped; documented in src/lib/reactive/README.md ("A handle is bound to its stage"). A PROXY held that long is refused at the write (`ScopeFacade` · `assertLive`, sealed by the commit observer — the refusal lives on the facade, not `stageWrite`, because the frame's post-commit re-use is what the engine's double-commit paths need).
 4. **NOT a landmine any more (9.22.0), recorded because it was one:** an indexed array read (`arr[i]`) used to hand back the RAW element, and a nested array write committed with the `merge` verb whose array arm is a set UNION. Both are fixed at the root — `reactive/arrayTraps.ts` wraps elements, and a nested array commits as a `set` of its ROOT KEY (`createTypedScope` · nested array commit callback). Consequences to keep in mind: an array ASSIGNMENT now REPLACES at every depth (`$update` is still the append), and a nested array write appears in `bundle.overwrite`/verb `set`, not `bundle.updates`/verb `merge`. What the proxy still cannot see — an element reached via `find`/`filter`/`for…of`/`forEach` — is REPORTED loudly instead: `StageContext` · `warnOnBorrowedMutation` (a dev-mode WARNING at the frame's first commit, under `readTracking: 'full'` only — a report after the fact, not a refusal). `memory/utils.ts` · `equalPairs` has typed arms (Date by instant, Map/Set by members) so a `$setValue` of a new Date/Set is a change, not a no-op. Every proxy (nested/terminal/element) READS LIVE through `reactive/liveView.ts` — a held handle sees its own writes; it answers from the captured object only when the path is gone. See src/lib/reactive/README.md. **Named, not fixed (out of contract):** a cyclic self-reference reached through a terminal proxy commits array/element writes to the WRONG place (row recorded, fold agrees, value lands beside the cycle edge); a top-level key containing U+001F (the path separator) throws at the seed; an expando on an array (`arr.foo = 1`) is dropped by the array proxy's set trap (indices and `length` only).
 
 ## Pointers

package/dist/esm/lib/engine/handlers/SubflowExecutor.js

@@ -16,6 +16,45 @@ import { isPauseSignal } from '../../pause/types.js';
 import { ResumeEntry } from './ResumeEntry.js';
 import { rememberRedactedSubflowState } from './servedSubflowResults.js';
 import { applyOutputMapping, getInitialScopeValues, seedSubflowGlobalStore } from './SubflowInputMapper.js';
+/**
+ * The mapped input, detached from the parent's state ONCE per mount (D1,
+ * 9.29.0 — docs/design/2026-10-copy-on-write-commit.md).
+ *
+ * The inputMapper reads the parent's LIVE state (`getScope()`), so a value it
+ * passes through (`(p) => ({ cfg: p.cfg })`) is the parent's committed
+ * object — and the subflow's args are deep-FROZEN in place
+ * (`readonlyInput · createFrozenArgs`). The typed scope does not proxy a
+ * frozen value (`allowlist · shouldWrapWithProxy`), so a later
+ * `scope.cfg.x = 1` in the parent met the raw frozen object: a TypeError in
+ * strict code. Before 9.29.0 the parent's next whole-state clone replaced the
+ * frozen object (a mount that committed nothing left it in place — the bug
+ * existed, it was only short-lived); under copy-on-write nothing re-clones,
+ * so the freeze would last until the key is rewritten. A mount must never
+ * edit — or freeze — the parent's committed objects: every plain object,
+ * array, `Date`, `Map` and `Set` the mapper returns is cloned here, before it
+ * becomes the args. A class instance passes by reference, as before (it
+ * cannot come from committed state, and a clone would drop its prototype).
+ * The seed is cloned again at its commit, so the subflow's state is
+ * unchanged.
+ */
+function detachMappedInput(input) {
+    let out;
+    for (const [key, value] of Object.entries(input)) {
+        if (!isDetachable(value))
+            continue;
+        (out ??= { ...input })[key] = structuredClone(value);
+    }
+    return out ?? input;
+}
+/** A value `structuredClone` reproduces with its own type: plain object, array, `Date`, `Map`, `Set`. */
+function isDetachable(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    if (Array.isArray(value) || value instanceof Date || value instanceof Map || value instanceof Set)
+        return true;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
 export class SubflowExecutor {
     deps;
     traverserFactory;
@@ -74,7 +113,7 @@ export class SubflowExecutor {
         if (mountOptions) {
             try {
                 const parentScope = parentContext.getScope();
-                mappedInput = getInitialScopeValues(parentScope, mountOptions);
+                mappedInput = detachMappedInput(getInitialScopeValues(parentScope, mountOptions));
                 if (Object.keys(mappedInput).length > 0) {
                     // mappedInput is captured in SubflowResult.treeContext for debugging
                 }
@@ -393,4 +432,4 @@ export class SubflowExecutor {
             root.useRedactedMirror(runtime.redactedStore);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SubflowExecutor.js","sourceRoot":"","sources":["../../../../../src/lib/engine/handlers/SubflowExecutor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * SubflowExecutor — Isolation boundary for subflow execution.\n *\n * Responsibilities:\n * - Create isolated ExecutionRuntime for each subflow\n * - Apply input/output mapping via SubflowInputMapper\n * - Delegate traversal to a factory-created FlowchartTraverser\n * - Track subflow results for debugging/visualization\n *\n * Each subflow gets its own GlobalStore for isolation.\n * Traversal uses the SAME 7-phase algorithm as the top-level traverser\n * (via SubflowTraverserFactory), so deciders, selectors, loops, lazy subflows,\n * and abort signals all work inside subflows automatically.\n */\n\nimport type { RedactionRule } from '../../memory/redaction.js';\nimport type { StageContext } from '../../memory/StageContext.js';\nimport { isPauseSignal } from '../../pause/types.js';\nimport type { StageNode } from '../graph/StageNode.js';\nimport type { TraversalContext } from '../narrative/types.js';\nimport type {\n  HandlerDeps,\n  IExecutionRuntime,\n  SubflowResult,\n  SubflowTraverserFactory,\n  SubflowTraverserHandle,\n} from '../types.js';\nimport { ResumeEntry } from './ResumeEntry.js';\nimport { rememberRedactedSubflowState } from './servedSubflowResults.js';\nimport { applyOutputMapping, getInitialScopeValues, seedSubflowGlobalStore } from './SubflowInputMapper.js';\nimport type { BreakFlag } from './types.js';\n\nexport class SubflowExecutor<TOut = any, TScope = any> {\n  /**\n   * The resume's one-shot re-entry (`deps.resume`), or a seed-only one built\n   * from the deprecated `deps.subflowStatesForResume`. Undefined on a normal\n   * run. Asked once per subflow entry — see {@link ResumeEntry}.\n   */\n  private readonly resume: ResumeEntry<TOut, TScope> | undefined;\n\n  constructor(\n    private deps: HandlerDeps<TOut, TScope>,\n    private traverserFactory: SubflowTraverserFactory<TOut, TScope>,\n  ) {\n    this.resume =\n      deps.resume ??\n      (deps.subflowStatesForResume ? ResumeEntry.fromCaptures<TOut, TScope>(deps.subflowStatesForResume) : undefined);\n  }\n\n  /**\n   * Execute a subflow with isolated context.\n   *\n   * 1. Creates a fresh ExecutionRuntime for the subflow\n   * 2. Applies input mapping to seed the subflow's GlobalStore\n   * 3. Delegates traversal to a factory-created FlowchartTraverser\n   * 4. Applies output mapping to write results back to parent scope\n   * 5. Stores execution data for debugging/visualization\n   */\n  async executeSubflow(\n    node: StageNode<TOut, TScope>,\n    parentContext: StageContext,\n    breakFlag: BreakFlag,\n    branchPath: string | undefined,\n    subflowResultsMap: Map<string, SubflowResult>,\n    parentTraversalContext?: TraversalContext,\n  ): Promise<any> {\n    const subflowId = node.subflowId!;\n    const subflowName = node.subflowName ?? node.name;\n\n    parentContext.addFlowDebugMessage('subflow', `Entering ${subflowName} subflow`, {\n      targetStage: subflowId,\n    });\n\n    // ─── Resume re-entry (one-shot) ───\n    //\n    // When this entry is the resume's way back into a paused subflow, the\n    // hop names where the subflow's traversal starts (the next mount on the\n    // pause path, or the paused stage's stand-in), carries the subflow's\n    // captured pre-pause state, and any sibling pauses waiting in it. Taken\n    // ONCE: any later entry into this subflow — a loop passing its mount\n    // again — gets `undefined` and runs the real subflow from its real root,\n    // inputMapper and all.\n    const resumeHop = this.resume?.enterSubflow(subflowId);\n\n    // ─── Input Mapping ───\n    //\n    // The mapper runs on EVERY entry: its result is the stages' read-only\n    // args (`$getArgs()`), and a re-entered subflow's stages read the same\n    // args they read before the pause (the parent's view is the same one —\n    // it was blocked in this mount). What a resume changes is only the SEED:\n    // when the hop carries a capture, the nested memory is seeded from the\n    // capture, not from the mapper — the capture is the post-input pre-pause\n    // memory, and seeding the mapper's values would clobber post-input\n    // writes (history, pausedToolCallId, etc.) with the start-of-subflow view.\n    const mountOptions = node.subflowMountOptions;\n    let mappedInput: Record<string, unknown> = {};\n    const resumeCapture = resumeHop?.seed;\n    const isResumeForThisSubflow = resumeCapture !== undefined;\n\n    if (mountOptions) {\n      try {\n        const parentScope = parentContext.getScope();\n        mappedInput = getInitialScopeValues(parentScope, mountOptions);\n        if (Object.keys(mappedInput).length > 0) {\n          // mappedInput is captured in SubflowResult.treeContext for debugging\n        }\n      } catch (error: any) {\n        parentContext.addError('inputMapperError', error.toString());\n        this.deps.logger.error(`Error in inputMapper for subflow (${subflowId}):`, { error });\n        throw error;\n      }\n    }\n\n    // The run's redaction rule (9.19.0), read off the parent-mount context\n    // the way the dials are (duck-typed: this section constructs its runtime\n    // dynamically to avoid the circular import). The seed narrated below and\n    // the seed COMMITTED below both retain under it; the subflow's stages\n    // still compute on the real `mappedInput` (their frozen args).\n    const redactionRule = parentContext.getRedactionRule?.();\n    // The run's redacted mirror (9.20.0): the parent-mount context carries it\n    // exactly when the root enabled one (`ExecutionRuntime.enableRedactedMirror`\n    // under a policy, inherited by createNext/createChild) — read the way the\n    // dials are. When it does, the nested runtime keeps a mirror of its own,\n    // so the subflow's SERVED state is a mirror too — the fold of its own\n    // scrubbed log — and never a second scrub. No policy: no mirror, no\n    // allocation, and the served state is the raw heap it always was.\n    const keepsMirror = parentContext.getRedactedSharedMemory?.() !== undefined;\n    // Narrative receives the RETAINED form of the mapped input — an\n    // inputMapper may inject values from anywhere, so the seed is scrubbed\n    // under the policy before any recorder sees it. Same object when nothing\n    // in it is redacted (the no-policy path allocates nothing).\n    const narrativeInput = redactionRule ? redactionRule.retainRecord(mappedInput) : mappedInput;\n    // `FlowSubflowEvent.description` is semantically \"what this subflow does\" — sourced from\n    // the subflow's own root stage, not the parent mount point. The mount node never carries\n    // a description (builders don't copy it), so reading `node.description` here returns\n    // `undefined` and taxonomy markers set on the subflow root (e.g. agentfootprint's\n    // `'Agent: ReAct loop'` / `'LLMCall: one-shot'`) never reach downstream consumers.\n    const rootDescription = this.deps.subflows?.[subflowId]?.root?.description;\n    this.deps.narrativeGenerator.onSubflowEntry(\n      subflowName,\n      subflowId,\n      rootDescription ?? node.description,\n      parentTraversalContext,\n      narrativeInput,\n    );\n    // Proposal #003: fire onStageExecuted for the mount node AFTER\n    // onSubflowEntry so consumers tracking \"did this stage run\" work\n    // uniformly across linear / decider / fork / selector / subflow-mount.\n    // Fires on ENTRY (not exit) — entry = \"this mount ran\"; the\n    // subflow's children execute after as separate stages.\n    this.deps.narrativeGenerator.onStageExecuted(\n      node.name,\n      rootDescription ?? node.description,\n      parentTraversalContext,\n      'subflow-mount',\n    );\n\n    // Create isolated runtime via dynamic construction (avoids circular import).\n    // Its root context is the first stage the subflow traversal runs — the\n    // resume hop's entry on a re-entry, the subflow's root otherwise.\n    const ExecutionRuntimeClass = this.deps.executionRuntime.constructor as new (\n      name: string,\n      id: string,\n    ) => IExecutionRuntime;\n    const firstNode = resumeHop?.entry ?? node;\n    const nestedRuntime = new ExecutionRuntimeClass(firstNode.name, firstNode.id);\n    let nestedRootContext = nestedRuntime.rootStageContext;\n\n    // Seed GlobalStore with the right shape for the path:\n    //   • Resume into THIS subflow → seed from the captured pre-pause\n    //     scope so resume handlers see history, pausedToolCallId, etc.\n    //     (`mappedInput` still reaches the stages, as their read-only args.)\n    //   • Normal entry → seed from the inputMapper's mappedInput.\n    const seedValues: Record<string, unknown> = isResumeForThisSubflow ? resumeCapture! : mappedInput;\n    if (Object.keys(seedValues).length > 0) {\n      // The seed is committed as the subflow's `history[0]` by its root\n      // context, not by a facade — install the rule (and the mirror) on THAT\n      // context first so the seed commit retains under the policy like every\n      // other write, and lands in the mirror as the placeholder.\n      this.inheritRedaction(nestedRuntime, nestedRootContext, redactionRule, keepsMirror);\n      seedSubflowGlobalStore(nestedRuntime, seedValues);\n      // Refresh rootStageContext so WriteBuffer sees committed data\n      const StageContextClass = nestedRootContext.constructor as new (...args: any[]) => StageContext;\n      nestedRootContext = new StageContextClass(\n        '',\n        nestedRootContext.stageName,\n        nestedRootContext.stageId,\n        nestedRuntime.globalStore,\n        '',\n        nestedRuntime.executionHistory,\n      );\n      nestedRuntime.rootStageContext = nestedRootContext;\n    }\n\n    // Read-tracking policy (#14): subflows get an ISOLATED runtime, so the\n    // executor-level policy doesn't reach them via the root context chain.\n    // Inherit it from the parent-mount context (which inherited it from ITS\n    // root via createNext/createChild) — applied to the FINAL nested root,\n    // after the seeding block above may have replaced it. Nested subflows\n    // chain the same way, one hop per mount. Optional-chained because this\n    // section is duck-typed by design (dynamic construction to avoid the\n    // circular import) — and skipped at the default 'full', where the fresh\n    // nested context is already correct, so the default path does zero work.\n    const parentReadTracking = parentContext.getReadTracking?.();\n    if (parentReadTracking !== undefined && parentReadTracking !== 'full') {\n      nestedRootContext.useReadTracking(parentReadTracking);\n    }\n\n    // Redaction rule (9.19.0) and mirror (9.20.0): same hop as the dials,\n    // applied to the FINAL nested root (the seeding block above may have\n    // replaced it) so every stage context the subflow creates inherits both.\n    this.inheritRedaction(nestedRuntime, nestedRootContext, redactionRule, keepsMirror);\n\n    // Write-tracking policy (#13c-A): same inheritance hop as readTracking\n    // above — subflow runtimes are isolated, so the parent-mount context's\n    // mode is pushed into the FINAL nested root with the same duck-type\n    // guard and the same skip-at-default fast path.\n    const parentWriteTracking = parentContext.getWriteTracking?.();\n    if (parentWriteTracking !== undefined && parentWriteTracking !== 'full') {\n      nestedRootContext.useWriteTracking(parentWriteTracking);\n    }\n\n    // Commit-values encoding (#13c-B): same inheritance hop as the two\n    // tracking dials above — subflow runtimes are isolated, so the\n    // parent-mount context's mode is pushed into the FINAL nested root with\n    // the same duck-type guard and the same skip-at-default fast path, so\n    // nested charts commit in the same encoding as the parent.\n    const parentCommitValues = parentContext.getCommitValues?.();\n    if (parentCommitValues !== undefined && parentCommitValues !== 'full') {\n      nestedRootContext.useCommitValues(parentCommitValues);\n    }\n\n    // Per-write read provenance (#P1): fourth dial, same inheritance hop —\n    // duck-type guard, skip-at-default ('off') fast path, so nested charts\n    // stamp TraceEntry.readKeys exactly when the parent does.\n    const parentWriteProvenance = parentContext.getWriteProvenance?.();\n    if (parentWriteProvenance !== undefined && parentWriteProvenance !== 'off') {\n      nestedRootContext.useWriteProvenance(parentWriteProvenance);\n    }\n\n    // Prepare subflow root node — strip isSubflowRoot to prevent re-delegation.\n    //\n    // PRESERVE `next`. Earlier revisions stripped `next` whenever the\n    // subflow root had children, on the assumption that `next` was\n    // always the OUTER mount's continuation leaking into the inner\n    // tree. That assumption was wrong: the resolved subflow root's\n    // `next` is the INNER join stage (e.g., Parallel's Merge after a\n    // fan-out, ToT's Pruner). Stripping it broke composite subflows —\n    // the join stage never ran, so the subflow returned partial state.\n    //\n    // The outer mount's post-subflow continuation is handled separately\n    // by the parent traverser via `parentContext.nextNode` and is never\n    // conflated with the inner subflow's `next` chain.\n    const subflowNode: StageNode<TOut, TScope> = {\n      ...node,\n      isSubflowRoot: false,\n    };\n\n    // ─── Execute via factory traverser ───\n    // The factory creates a full FlowchartTraverser with the same 7-phase algorithm,\n    // sharing the parent's stageMap, subflows dict, and narrative generator.\n    let subflowOutput: any;\n    let subflowError: Error | undefined;\n    let traverserHandle: SubflowTraverserHandle<TOut, TScope> | undefined;\n\n    try {\n      traverserHandle = this.traverserFactory({\n        // The REAL subflow graph — every id inside the subflow (loop targets,\n        // a re-visit of the paused stage) resolves against it, re-entry or not.\n        root: subflowNode,\n        // Where this traversal starts on a resume re-entry; visited once —\n        // and the sibling pauses it raises once that entry's chain ends.\n        ...(resumeHop?.entry && { entry: resumeHop.entry }),\n        ...(resumeHop?.pendingPauses && { pendingPauses: resumeHop.pendingPauses }),\n        executionRuntime: nestedRuntime,\n        readOnlyContext: mappedInput,\n        subflowId,\n        // RFC-003 D1: the mount stage's runtimeStageId — the subflow root\n        // stage's `parentRuntimeStageId` so ancestor chains cross the mount.\n        parentMountRuntimeStageId: parentTraversalContext?.runtimeStageId,\n      });\n\n      subflowOutput = await traverserHandle.execute();\n    } catch (error: any) {\n      // PauseSignal is not an error — prepend subflow ID and re-throw\n      // immediately. No error logging, no subflowResult recording —\n      // the pause is control flow.\n      //\n      // BEFORE re-throw, snapshot the nested runtime's `sharedState`\n      // onto the signal. This is the only chance — once we re-throw,\n      // the outer traverser unwinds and the nested runtime is GC'd. On\n      // resume, we'll re-seed a fresh nested runtime from this capture\n      // so resume handlers can read the pre-pause subflow scope.\n      //\n      // Capture is keyed by the SAME path-prefixed `subflowId` used in\n      // `subflowPath`, so resume can look up \"scope for sf-foo\" by id.\n      if (isPauseSignal(error)) {\n        try {\n          const snap = nestedRuntime.getSnapshot();\n          // `sharedState` is the subflow's working memory at pause\n          // time (after every committed write up to the pause). Cast\n          // is safe — SharedMemory snapshot returns a plain object.\n          error.captureSubflowScope(subflowId, snap.sharedState as Record<string, unknown>);\n        } catch {\n          // Snapshot failure shouldn't mask the pause — let the pause\n          // bubble up; resume will fall back to checkpoint.sharedState\n          // (the parent scope) for this subflow's keys.\n        }\n        error.prependSubflow(subflowId);\n        throw error;\n      }\n      subflowError = error;\n      parentContext.addError('subflowError', error.toString());\n      this.deps.logger.error(`Error in subflow (${subflowId}):`, { error });\n    }\n\n    // Always merge nested subflow results (even on error — partial results aid debugging)\n    if (traverserHandle) {\n      for (const [key, value] of traverserHandle.getSubflowResults()) {\n        subflowResultsMap.set(key, value);\n      }\n    }\n\n    // ─── Break propagation (opt-in via SubflowMountOptions.propagateBreak) ──\n    //\n    // If the subflow's inner traversal broke (because a stage called\n    // `scope.$break(reason)`) AND the mount declared `propagateBreak: true`,\n    // forward the break state to the PARENT's breakFlag. The parent\n    // traverser will see `shouldBreak` on its next step and stop.\n    //\n    // Without this, inner breaks are locally scoped to the subflow — the\n    // parent continues as if the subflow returned normally.\n    //\n    // IMPORTANT: this runs BEFORE `outputMapping` below, intentionally. The\n    // outputMapper still executes, so the subflow's partial result still\n    // lands in the parent scope. Consumers who need to suppress output on\n    // break check the break state inside their outputMapper and early-return.\n    // See `SubflowMountOptions.propagateBreak` JSDoc for rationale.\n    if (traverserHandle && mountOptions?.propagateBreak === true) {\n      const innerBreak = traverserHandle.getBreakState();\n      if (innerBreak.shouldBreak) {\n        breakFlag.shouldBreak = true;\n        if (innerBreak.reason !== undefined && breakFlag.reason === undefined) {\n          breakFlag.reason = innerBreak.reason;\n        }\n        // Raise a parent-level onBreak event so recorders can distinguish\n        // the inner originating break (fired inside the subflow) from this\n        // propagated one (fired at the mount level on the parent).\n        this.deps.narrativeGenerator.onBreak(subflowName, parentTraversalContext, innerBreak.reason, subflowId);\n      }\n    }\n\n    const subflowTreeContext = nestedRuntime.getSnapshot();\n\n    // ─── Output Mapping ───\n    if (!subflowError && mountOptions?.outputMapper) {\n      try {\n        let outputContext = parentContext;\n        if (parentContext.branchId && parentContext.branchId !== '' && parentContext.parent) {\n          outputContext = parentContext.parent;\n        }\n\n        const parentScope = outputContext.getScope();\n        // For TypedScope subflows, stage functions return void — fall back to a shallow clone\n        // of the subflow's shared state so outputMapper can access all scope values written\n        // during the subflow. We shallow-clone to avoid aliasing the live SharedMemory context.\n        // NOTE: the full scope is passed (not just declared outputs) — outputMapper must\n        // explicitly select what to propagate to the parent.\n        // Redaction: `applyOutputMapping` writes through `outputContext` (a\n        // StageContext, not a facade). The context's write funnel asks the\n        // run's redaction rule — shared with the subflow's contexts, so a key\n        // the policy names OR a key marked per-call inside the subflow is\n        // scrubbed in the PARENT's log and mirror too (9.19.0; before, this\n        // merge-back retained plaintext).\n        const effectiveOutput = subflowOutput ?? { ...subflowTreeContext.sharedState };\n        const mappedOutput = applyOutputMapping(effectiveOutput, parentScope, outputContext, mountOptions);\n\n        outputContext.commit();\n      } catch (error: any) {\n        parentContext.addError('outputMapperError', error.toString());\n        this.deps.logger.error(`Error in outputMapper for subflow (${subflowId}):`, { error });\n      }\n    }\n\n    const subflowResult: SubflowResult = {\n      subflowId,\n      subflowName,\n      treeContext: {\n        globalContext: subflowTreeContext.sharedState,\n        stageContexts: subflowTreeContext.executionTree as unknown as Record<string, unknown>,\n        history: subflowTreeContext.commitLog,\n        // The subflow's own fold base travels with its own log — same\n        // contract as the run-level `RuntimeSnapshot.initialState`.\n        initialState: subflowTreeContext.initialState,\n      },\n      parentStageId: parentContext.getStageId(),\n    };\n\n    const subflowDef = this.deps.subflows?.[subflowId];\n    if (subflowDef && (subflowDef as any).buildTimeStructure) {\n      subflowResult.pipelineStructure = (subflowDef as any).buildTimeStructure;\n    }\n\n    // The served state (9.20.0): the nested mirror's final state, remembered\n    // BESIDE the result — `treeContext.globalContext` stays the live heap for\n    // the plain snapshot and the checkpoint; `getSnapshot({ redact: true })`\n    // substitutes the mirror through `servedSubflowResults`. Absent without\n    // a policy. The exit event below carries the same served view; without a\n    // mirror it carries the heap retained under the rule (per-call marks\n    // alone keep no mirror) — the same object when nothing is redacted.\n    const rawState = subflowResult.treeContext.globalContext;\n    const mirrorState = nestedRuntime.redactedStore?.getState();\n    if (mirrorState !== undefined) rememberRedactedSubflowState(subflowResult, mirrorState);\n    const exitState = mirrorState ?? (redactionRule ? redactionRule.retainRecord(rawState) : rawState);\n\n    subflowResultsMap.set(subflowId, subflowResult);\n    // Additive per-execution key (design: docs/design/subflow-commit-visibility.md). A LOOPING\n    // subflow re-enters with the SAME subflowId, so the path key above is OVERWRITTEN each\n    // iteration (back-compat: it holds the LAST iteration — what getSubtreeSnapshot/listSubflowPaths\n    // and the eui fallback see, unchanged). ALSO key by the mount's UNIQUE runtimeStageId so EVERY\n    // iteration's result is retained and addressable (eui per-loop drill-down, per-scope localization).\n    // runtimeStageId always contains '#'; subflowId never does — so they never collide, and\n    // listSubflowPaths filters '#' keys to keep its path-only contract. The pause checkpoint filters\n    // these out (buildPauseCheckpoint) so it stays lean.\n    const mountRuntimeStageId = parentTraversalContext?.runtimeStageId;\n    if (mountRuntimeStageId && mountRuntimeStageId !== subflowId) {\n      subflowResultsMap.set(mountRuntimeStageId, subflowResult);\n    }\n\n    parentContext.addFlowDebugMessage('subflow', `Exiting ${subflowName} subflow`, {\n      targetStage: subflowId,\n    });\n    this.deps.narrativeGenerator.onSubflowExit(subflowName, subflowId, parentTraversalContext, exitState);\n\n    parentContext.commit();\n\n    if (subflowError) {\n      throw subflowError;\n    }\n\n    return subflowOutput;\n  }\n\n  /**\n   * Push the run's redaction into a nested root the way the dials are pushed\n   * — the triplicated propagation (root install · createNext/createChild ·\n   * this hop). Called TWICE on purpose: on the runtime's first root, so the\n   * SEED commit (`history[0]`) retains and mirrors under the policy, and on\n   * the FINAL root after the seeding block replaces it. Rule before mirror,\n   * as the executor orders them (the mirror's seed is scrubbed with the rule;\n   * for a nested runtime that seed is empty — its input arrives as a commit).\n   * `enableRedactedMirror` is idempotent, so the second call only re-installs\n   * the ONE mirror on the fresh root.\n   */\n  private inheritRedaction(\n    runtime: IExecutionRuntime,\n    root: StageContext,\n    rule: RedactionRule | undefined,\n    keepsMirror: boolean,\n  ): void {\n    if (rule) root.useRedactionRule(rule);\n    if (!keepsMirror) return;\n    runtime.enableRedactedMirror?.();\n    if (runtime.redactedStore) root.useRedactedMirror(runtime.redactedStore);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SubflowExecutor.js","sourceRoot":"","sources":["../../../../../src/lib/engine/handlers/SubflowExecutor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * SubflowExecutor — Isolation boundary for subflow execution.\n *\n * Responsibilities:\n * - Create isolated ExecutionRuntime for each subflow\n * - Apply input/output mapping via SubflowInputMapper\n * - Delegate traversal to a factory-created FlowchartTraverser\n * - Track subflow results for debugging/visualization\n *\n * Each subflow gets its own GlobalStore for isolation.\n * Traversal uses the SAME 7-phase algorithm as the top-level traverser\n * (via SubflowTraverserFactory), so deciders, selectors, loops, lazy subflows,\n * and abort signals all work inside subflows automatically.\n */\n\nimport type { RedactionRule } from '../../memory/redaction.js';\nimport type { StageContext } from '../../memory/StageContext.js';\nimport { isPauseSignal } from '../../pause/types.js';\nimport type { StageNode } from '../graph/StageNode.js';\nimport type { TraversalContext } from '../narrative/types.js';\nimport type {\n  HandlerDeps,\n  IExecutionRuntime,\n  SubflowResult,\n  SubflowTraverserFactory,\n  SubflowTraverserHandle,\n} from '../types.js';\nimport { ResumeEntry } from './ResumeEntry.js';\nimport { rememberRedactedSubflowState } from './servedSubflowResults.js';\nimport { applyOutputMapping, getInitialScopeValues, seedSubflowGlobalStore } from './SubflowInputMapper.js';\nimport type { BreakFlag } from './types.js';\n\n/**\n * The mapped input, detached from the parent's state ONCE per mount (D1,\n * 9.29.0 — docs/design/2026-10-copy-on-write-commit.md).\n *\n * The inputMapper reads the parent's LIVE state (`getScope()`), so a value it\n * passes through (`(p) => ({ cfg: p.cfg })`) is the parent's committed\n * object — and the subflow's args are deep-FROZEN in place\n * (`readonlyInput · createFrozenArgs`). The typed scope does not proxy a\n * frozen value (`allowlist · shouldWrapWithProxy`), so a later\n * `scope.cfg.x = 1` in the parent met the raw frozen object: a TypeError in\n * strict code. Before 9.29.0 the parent's next whole-state clone replaced the\n * frozen object (a mount that committed nothing left it in place — the bug\n * existed, it was only short-lived); under copy-on-write nothing re-clones,\n * so the freeze would last until the key is rewritten. A mount must never\n * edit — or freeze — the parent's committed objects: every plain object,\n * array, `Date`, `Map` and `Set` the mapper returns is cloned here, before it\n * becomes the args. A class instance passes by reference, as before (it\n * cannot come from committed state, and a clone would drop its prototype).\n * The seed is cloned again at its commit, so the subflow's state is\n * unchanged.\n */\nfunction detachMappedInput(input: Record<string, unknown>): Record<string, unknown> {\n  let out: Record<string, unknown> | undefined;\n  for (const [key, value] of Object.entries(input)) {\n    if (!isDetachable(value)) continue;\n    (out ??= { ...input })[key] = structuredClone(value);\n  }\n  return out ?? input;\n}\n\n/** A value `structuredClone` reproduces with its own type: plain object, array, `Date`, `Map`, `Set`. */\nfunction isDetachable(value: unknown): boolean {\n  if (value === null || typeof value !== 'object') return false;\n  if (Array.isArray(value) || value instanceof Date || value instanceof Map || value instanceof Set) return true;\n  const proto = Object.getPrototypeOf(value);\n  return proto === Object.prototype || proto === null;\n}\n\nexport class SubflowExecutor<TOut = any, TScope = any> {\n  /**\n   * The resume's one-shot re-entry (`deps.resume`), or a seed-only one built\n   * from the deprecated `deps.subflowStatesForResume`. Undefined on a normal\n   * run. Asked once per subflow entry — see {@link ResumeEntry}.\n   */\n  private readonly resume: ResumeEntry<TOut, TScope> | undefined;\n\n  constructor(\n    private deps: HandlerDeps<TOut, TScope>,\n    private traverserFactory: SubflowTraverserFactory<TOut, TScope>,\n  ) {\n    this.resume =\n      deps.resume ??\n      (deps.subflowStatesForResume ? ResumeEntry.fromCaptures<TOut, TScope>(deps.subflowStatesForResume) : undefined);\n  }\n\n  /**\n   * Execute a subflow with isolated context.\n   *\n   * 1. Creates a fresh ExecutionRuntime for the subflow\n   * 2. Applies input mapping to seed the subflow's GlobalStore\n   * 3. Delegates traversal to a factory-created FlowchartTraverser\n   * 4. Applies output mapping to write results back to parent scope\n   * 5. Stores execution data for debugging/visualization\n   */\n  async executeSubflow(\n    node: StageNode<TOut, TScope>,\n    parentContext: StageContext,\n    breakFlag: BreakFlag,\n    branchPath: string | undefined,\n    subflowResultsMap: Map<string, SubflowResult>,\n    parentTraversalContext?: TraversalContext,\n  ): Promise<any> {\n    const subflowId = node.subflowId!;\n    const subflowName = node.subflowName ?? node.name;\n\n    parentContext.addFlowDebugMessage('subflow', `Entering ${subflowName} subflow`, {\n      targetStage: subflowId,\n    });\n\n    // ─── Resume re-entry (one-shot) ───\n    //\n    // When this entry is the resume's way back into a paused subflow, the\n    // hop names where the subflow's traversal starts (the next mount on the\n    // pause path, or the paused stage's stand-in), carries the subflow's\n    // captured pre-pause state, and any sibling pauses waiting in it. Taken\n    // ONCE: any later entry into this subflow — a loop passing its mount\n    // again — gets `undefined` and runs the real subflow from its real root,\n    // inputMapper and all.\n    const resumeHop = this.resume?.enterSubflow(subflowId);\n\n    // ─── Input Mapping ───\n    //\n    // The mapper runs on EVERY entry: its result is the stages' read-only\n    // args (`$getArgs()`), and a re-entered subflow's stages read the same\n    // args they read before the pause (the parent's view is the same one —\n    // it was blocked in this mount). What a resume changes is only the SEED:\n    // when the hop carries a capture, the nested memory is seeded from the\n    // capture, not from the mapper — the capture is the post-input pre-pause\n    // memory, and seeding the mapper's values would clobber post-input\n    // writes (history, pausedToolCallId, etc.) with the start-of-subflow view.\n    const mountOptions = node.subflowMountOptions;\n    let mappedInput: Record<string, unknown> = {};\n    const resumeCapture = resumeHop?.seed;\n    const isResumeForThisSubflow = resumeCapture !== undefined;\n\n    if (mountOptions) {\n      try {\n        const parentScope = parentContext.getScope();\n        mappedInput = detachMappedInput(getInitialScopeValues(parentScope, mountOptions));\n        if (Object.keys(mappedInput).length > 0) {\n          // mappedInput is captured in SubflowResult.treeContext for debugging\n        }\n      } catch (error: any) {\n        parentContext.addError('inputMapperError', error.toString());\n        this.deps.logger.error(`Error in inputMapper for subflow (${subflowId}):`, { error });\n        throw error;\n      }\n    }\n\n    // The run's redaction rule (9.19.0), read off the parent-mount context\n    // the way the dials are (duck-typed: this section constructs its runtime\n    // dynamically to avoid the circular import). The seed narrated below and\n    // the seed COMMITTED below both retain under it; the subflow's stages\n    // still compute on the real `mappedInput` (their frozen args).\n    const redactionRule = parentContext.getRedactionRule?.();\n    // The run's redacted mirror (9.20.0): the parent-mount context carries it\n    // exactly when the root enabled one (`ExecutionRuntime.enableRedactedMirror`\n    // under a policy, inherited by createNext/createChild) — read the way the\n    // dials are. When it does, the nested runtime keeps a mirror of its own,\n    // so the subflow's SERVED state is a mirror too — the fold of its own\n    // scrubbed log — and never a second scrub. No policy: no mirror, no\n    // allocation, and the served state is the raw heap it always was.\n    const keepsMirror = parentContext.getRedactedSharedMemory?.() !== undefined;\n    // Narrative receives the RETAINED form of the mapped input — an\n    // inputMapper may inject values from anywhere, so the seed is scrubbed\n    // under the policy before any recorder sees it. Same object when nothing\n    // in it is redacted (the no-policy path allocates nothing).\n    const narrativeInput = redactionRule ? redactionRule.retainRecord(mappedInput) : mappedInput;\n    // `FlowSubflowEvent.description` is semantically \"what this subflow does\" — sourced from\n    // the subflow's own root stage, not the parent mount point. The mount node never carries\n    // a description (builders don't copy it), so reading `node.description` here returns\n    // `undefined` and taxonomy markers set on the subflow root (e.g. agentfootprint's\n    // `'Agent: ReAct loop'` / `'LLMCall: one-shot'`) never reach downstream consumers.\n    const rootDescription = this.deps.subflows?.[subflowId]?.root?.description;\n    this.deps.narrativeGenerator.onSubflowEntry(\n      subflowName,\n      subflowId,\n      rootDescription ?? node.description,\n      parentTraversalContext,\n      narrativeInput,\n    );\n    // Proposal #003: fire onStageExecuted for the mount node AFTER\n    // onSubflowEntry so consumers tracking \"did this stage run\" work\n    // uniformly across linear / decider / fork / selector / subflow-mount.\n    // Fires on ENTRY (not exit) — entry = \"this mount ran\"; the\n    // subflow's children execute after as separate stages.\n    this.deps.narrativeGenerator.onStageExecuted(\n      node.name,\n      rootDescription ?? node.description,\n      parentTraversalContext,\n      'subflow-mount',\n    );\n\n    // Create isolated runtime via dynamic construction (avoids circular import).\n    // Its root context is the first stage the subflow traversal runs — the\n    // resume hop's entry on a re-entry, the subflow's root otherwise.\n    const ExecutionRuntimeClass = this.deps.executionRuntime.constructor as new (\n      name: string,\n      id: string,\n    ) => IExecutionRuntime;\n    const firstNode = resumeHop?.entry ?? node;\n    const nestedRuntime = new ExecutionRuntimeClass(firstNode.name, firstNode.id);\n    let nestedRootContext = nestedRuntime.rootStageContext;\n\n    // Seed GlobalStore with the right shape for the path:\n    //   • Resume into THIS subflow → seed from the captured pre-pause\n    //     scope so resume handlers see history, pausedToolCallId, etc.\n    //     (`mappedInput` still reaches the stages, as their read-only args.)\n    //   • Normal entry → seed from the inputMapper's mappedInput.\n    const seedValues: Record<string, unknown> = isResumeForThisSubflow ? resumeCapture! : mappedInput;\n    if (Object.keys(seedValues).length > 0) {\n      // The seed is committed as the subflow's `history[0]` by its root\n      // context, not by a facade — install the rule (and the mirror) on THAT\n      // context first so the seed commit retains under the policy like every\n      // other write, and lands in the mirror as the placeholder.\n      this.inheritRedaction(nestedRuntime, nestedRootContext, redactionRule, keepsMirror);\n      seedSubflowGlobalStore(nestedRuntime, seedValues);\n      // Refresh rootStageContext so WriteBuffer sees committed data\n      const StageContextClass = nestedRootContext.constructor as new (...args: any[]) => StageContext;\n      nestedRootContext = new StageContextClass(\n        '',\n        nestedRootContext.stageName,\n        nestedRootContext.stageId,\n        nestedRuntime.globalStore,\n        '',\n        nestedRuntime.executionHistory,\n      );\n      nestedRuntime.rootStageContext = nestedRootContext;\n    }\n\n    // Read-tracking policy (#14): subflows get an ISOLATED runtime, so the\n    // executor-level policy doesn't reach them via the root context chain.\n    // Inherit it from the parent-mount context (which inherited it from ITS\n    // root via createNext/createChild) — applied to the FINAL nested root,\n    // after the seeding block above may have replaced it. Nested subflows\n    // chain the same way, one hop per mount. Optional-chained because this\n    // section is duck-typed by design (dynamic construction to avoid the\n    // circular import) — and skipped at the default 'full', where the fresh\n    // nested context is already correct, so the default path does zero work.\n    const parentReadTracking = parentContext.getReadTracking?.();\n    if (parentReadTracking !== undefined && parentReadTracking !== 'full') {\n      nestedRootContext.useReadTracking(parentReadTracking);\n    }\n\n    // Redaction rule (9.19.0) and mirror (9.20.0): same hop as the dials,\n    // applied to the FINAL nested root (the seeding block above may have\n    // replaced it) so every stage context the subflow creates inherits both.\n    this.inheritRedaction(nestedRuntime, nestedRootContext, redactionRule, keepsMirror);\n\n    // Write-tracking policy (#13c-A): same inheritance hop as readTracking\n    // above — subflow runtimes are isolated, so the parent-mount context's\n    // mode is pushed into the FINAL nested root with the same duck-type\n    // guard and the same skip-at-default fast path.\n    const parentWriteTracking = parentContext.getWriteTracking?.();\n    if (parentWriteTracking !== undefined && parentWriteTracking !== 'full') {\n      nestedRootContext.useWriteTracking(parentWriteTracking);\n    }\n\n    // Commit-values encoding (#13c-B): same inheritance hop as the two\n    // tracking dials above — subflow runtimes are isolated, so the\n    // parent-mount context's mode is pushed into the FINAL nested root with\n    // the same duck-type guard and the same skip-at-default fast path, so\n    // nested charts commit in the same encoding as the parent.\n    const parentCommitValues = parentContext.getCommitValues?.();\n    if (parentCommitValues !== undefined && parentCommitValues !== 'full') {\n      nestedRootContext.useCommitValues(parentCommitValues);\n    }\n\n    // Per-write read provenance (#P1): fourth dial, same inheritance hop —\n    // duck-type guard, skip-at-default ('off') fast path, so nested charts\n    // stamp TraceEntry.readKeys exactly when the parent does.\n    const parentWriteProvenance = parentContext.getWriteProvenance?.();\n    if (parentWriteProvenance !== undefined && parentWriteProvenance !== 'off') {\n      nestedRootContext.useWriteProvenance(parentWriteProvenance);\n    }\n\n    // Prepare subflow root node — strip isSubflowRoot to prevent re-delegation.\n    //\n    // PRESERVE `next`. Earlier revisions stripped `next` whenever the\n    // subflow root had children, on the assumption that `next` was\n    // always the OUTER mount's continuation leaking into the inner\n    // tree. That assumption was wrong: the resolved subflow root's\n    // `next` is the INNER join stage (e.g., Parallel's Merge after a\n    // fan-out, ToT's Pruner). Stripping it broke composite subflows —\n    // the join stage never ran, so the subflow returned partial state.\n    //\n    // The outer mount's post-subflow continuation is handled separately\n    // by the parent traverser via `parentContext.nextNode` and is never\n    // conflated with the inner subflow's `next` chain.\n    const subflowNode: StageNode<TOut, TScope> = {\n      ...node,\n      isSubflowRoot: false,\n    };\n\n    // ─── Execute via factory traverser ───\n    // The factory creates a full FlowchartTraverser with the same 7-phase algorithm,\n    // sharing the parent's stageMap, subflows dict, and narrative generator.\n    let subflowOutput: any;\n    let subflowError: Error | undefined;\n    let traverserHandle: SubflowTraverserHandle<TOut, TScope> | undefined;\n\n    try {\n      traverserHandle = this.traverserFactory({\n        // The REAL subflow graph — every id inside the subflow (loop targets,\n        // a re-visit of the paused stage) resolves against it, re-entry or not.\n        root: subflowNode,\n        // Where this traversal starts on a resume re-entry; visited once —\n        // and the sibling pauses it raises once that entry's chain ends.\n        ...(resumeHop?.entry && { entry: resumeHop.entry }),\n        ...(resumeHop?.pendingPauses && { pendingPauses: resumeHop.pendingPauses }),\n        executionRuntime: nestedRuntime,\n        readOnlyContext: mappedInput,\n        subflowId,\n        // RFC-003 D1: the mount stage's runtimeStageId — the subflow root\n        // stage's `parentRuntimeStageId` so ancestor chains cross the mount.\n        parentMountRuntimeStageId: parentTraversalContext?.runtimeStageId,\n      });\n\n      subflowOutput = await traverserHandle.execute();\n    } catch (error: any) {\n      // PauseSignal is not an error — prepend subflow ID and re-throw\n      // immediately. No error logging, no subflowResult recording —\n      // the pause is control flow.\n      //\n      // BEFORE re-throw, snapshot the nested runtime's `sharedState`\n      // onto the signal. This is the only chance — once we re-throw,\n      // the outer traverser unwinds and the nested runtime is GC'd. On\n      // resume, we'll re-seed a fresh nested runtime from this capture\n      // so resume handlers can read the pre-pause subflow scope.\n      //\n      // Capture is keyed by the SAME path-prefixed `subflowId` used in\n      // `subflowPath`, so resume can look up \"scope for sf-foo\" by id.\n      if (isPauseSignal(error)) {\n        try {\n          const snap = nestedRuntime.getSnapshot();\n          // `sharedState` is the subflow's working memory at pause\n          // time (after every committed write up to the pause). Cast\n          // is safe — SharedMemory snapshot returns a plain object.\n          error.captureSubflowScope(subflowId, snap.sharedState as Record<string, unknown>);\n        } catch {\n          // Snapshot failure shouldn't mask the pause — let the pause\n          // bubble up; resume will fall back to checkpoint.sharedState\n          // (the parent scope) for this subflow's keys.\n        }\n        error.prependSubflow(subflowId);\n        throw error;\n      }\n      subflowError = error;\n      parentContext.addError('subflowError', error.toString());\n      this.deps.logger.error(`Error in subflow (${subflowId}):`, { error });\n    }\n\n    // Always merge nested subflow results (even on error — partial results aid debugging)\n    if (traverserHandle) {\n      for (const [key, value] of traverserHandle.getSubflowResults()) {\n        subflowResultsMap.set(key, value);\n      }\n    }\n\n    // ─── Break propagation (opt-in via SubflowMountOptions.propagateBreak) ──\n    //\n    // If the subflow's inner traversal broke (because a stage called\n    // `scope.$break(reason)`) AND the mount declared `propagateBreak: true`,\n    // forward the break state to the PARENT's breakFlag. The parent\n    // traverser will see `shouldBreak` on its next step and stop.\n    //\n    // Without this, inner breaks are locally scoped to the subflow — the\n    // parent continues as if the subflow returned normally.\n    //\n    // IMPORTANT: this runs BEFORE `outputMapping` below, intentionally. The\n    // outputMapper still executes, so the subflow's partial result still\n    // lands in the parent scope. Consumers who need to suppress output on\n    // break check the break state inside their outputMapper and early-return.\n    // See `SubflowMountOptions.propagateBreak` JSDoc for rationale.\n    if (traverserHandle && mountOptions?.propagateBreak === true) {\n      const innerBreak = traverserHandle.getBreakState();\n      if (innerBreak.shouldBreak) {\n        breakFlag.shouldBreak = true;\n        if (innerBreak.reason !== undefined && breakFlag.reason === undefined) {\n          breakFlag.reason = innerBreak.reason;\n        }\n        // Raise a parent-level onBreak event so recorders can distinguish\n        // the inner originating break (fired inside the subflow) from this\n        // propagated one (fired at the mount level on the parent).\n        this.deps.narrativeGenerator.onBreak(subflowName, parentTraversalContext, innerBreak.reason, subflowId);\n      }\n    }\n\n    const subflowTreeContext = nestedRuntime.getSnapshot();\n\n    // ─── Output Mapping ───\n    if (!subflowError && mountOptions?.outputMapper) {\n      try {\n        let outputContext = parentContext;\n        if (parentContext.branchId && parentContext.branchId !== '' && parentContext.parent) {\n          outputContext = parentContext.parent;\n        }\n\n        const parentScope = outputContext.getScope();\n        // For TypedScope subflows, stage functions return void — fall back to a shallow clone\n        // of the subflow's shared state so outputMapper can access all scope values written\n        // during the subflow. We shallow-clone to avoid aliasing the live SharedMemory context.\n        // NOTE: the full scope is passed (not just declared outputs) — outputMapper must\n        // explicitly select what to propagate to the parent.\n        // Redaction: `applyOutputMapping` writes through `outputContext` (a\n        // StageContext, not a facade). The context's write funnel asks the\n        // run's redaction rule — shared with the subflow's contexts, so a key\n        // the policy names OR a key marked per-call inside the subflow is\n        // scrubbed in the PARENT's log and mirror too (9.19.0; before, this\n        // merge-back retained plaintext).\n        const effectiveOutput = subflowOutput ?? { ...subflowTreeContext.sharedState };\n        const mappedOutput = applyOutputMapping(effectiveOutput, parentScope, outputContext, mountOptions);\n\n        outputContext.commit();\n      } catch (error: any) {\n        parentContext.addError('outputMapperError', error.toString());\n        this.deps.logger.error(`Error in outputMapper for subflow (${subflowId}):`, { error });\n      }\n    }\n\n    const subflowResult: SubflowResult = {\n      subflowId,\n      subflowName,\n      treeContext: {\n        globalContext: subflowTreeContext.sharedState,\n        stageContexts: subflowTreeContext.executionTree as unknown as Record<string, unknown>,\n        history: subflowTreeContext.commitLog,\n        // The subflow's own fold base travels with its own log — same\n        // contract as the run-level `RuntimeSnapshot.initialState`.\n        initialState: subflowTreeContext.initialState,\n      },\n      parentStageId: parentContext.getStageId(),\n    };\n\n    const subflowDef = this.deps.subflows?.[subflowId];\n    if (subflowDef && (subflowDef as any).buildTimeStructure) {\n      subflowResult.pipelineStructure = (subflowDef as any).buildTimeStructure;\n    }\n\n    // The served state (9.20.0): the nested mirror's final state, remembered\n    // BESIDE the result — `treeContext.globalContext` stays the live heap for\n    // the plain snapshot and the checkpoint; `getSnapshot({ redact: true })`\n    // substitutes the mirror through `servedSubflowResults`. Absent without\n    // a policy. The exit event below carries the same served view; without a\n    // mirror it carries the heap retained under the rule (per-call marks\n    // alone keep no mirror) — the same object when nothing is redacted.\n    const rawState = subflowResult.treeContext.globalContext;\n    const mirrorState = nestedRuntime.redactedStore?.getState();\n    if (mirrorState !== undefined) rememberRedactedSubflowState(subflowResult, mirrorState);\n    const exitState = mirrorState ?? (redactionRule ? redactionRule.retainRecord(rawState) : rawState);\n\n    subflowResultsMap.set(subflowId, subflowResult);\n    // Additive per-execution key (design: docs/design/subflow-commit-visibility.md). A LOOPING\n    // subflow re-enters with the SAME subflowId, so the path key above is OVERWRITTEN each\n    // iteration (back-compat: it holds the LAST iteration — what getSubtreeSnapshot/listSubflowPaths\n    // and the eui fallback see, unchanged). ALSO key by the mount's UNIQUE runtimeStageId so EVERY\n    // iteration's result is retained and addressable (eui per-loop drill-down, per-scope localization).\n    // runtimeStageId always contains '#'; subflowId never does — so they never collide, and\n    // listSubflowPaths filters '#' keys to keep its path-only contract. The pause checkpoint filters\n    // these out (buildPauseCheckpoint) so it stays lean.\n    const mountRuntimeStageId = parentTraversalContext?.runtimeStageId;\n    if (mountRuntimeStageId && mountRuntimeStageId !== subflowId) {\n      subflowResultsMap.set(mountRuntimeStageId, subflowResult);\n    }\n\n    parentContext.addFlowDebugMessage('subflow', `Exiting ${subflowName} subflow`, {\n      targetStage: subflowId,\n    });\n    this.deps.narrativeGenerator.onSubflowExit(subflowName, subflowId, parentTraversalContext, exitState);\n\n    parentContext.commit();\n\n    if (subflowError) {\n      throw subflowError;\n    }\n\n    return subflowOutput;\n  }\n\n  /**\n   * Push the run's redaction into a nested root the way the dials are pushed\n   * — the triplicated propagation (root install · createNext/createChild ·\n   * this hop). Called TWICE on purpose: on the runtime's first root, so the\n   * SEED commit (`history[0]`) retains and mirrors under the policy, and on\n   * the FINAL root after the seeding block replaces it. Rule before mirror,\n   * as the executor orders them (the mirror's seed is scrubbed with the rule;\n   * for a nested runtime that seed is empty — its input arrives as a commit).\n   * `enableRedactedMirror` is idempotent, so the second call only re-installs\n   * the ONE mirror on the fresh root.\n   */\n  private inheritRedaction(\n    runtime: IExecutionRuntime,\n    root: StageContext,\n    rule: RedactionRule | undefined,\n    keepsMirror: boolean,\n  ): void {\n    if (rule) root.useRedactionRule(rule);\n    if (!keepsMirror) return;\n    runtime.enableRedactedMirror?.();\n    if (runtime.redactedStore) root.useRedactedMirror(runtime.redactedStore);\n  }\n}\n"]}

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

@@ -34,6 +34,12 @@ export declare class EventLog {
      * same log but its `commitIdx` is INCLUSIVE, because a reader's cursor asks
      * "the state AT this stop", which must include that stop's own commit. Two
      * folds over one log with opposite conventions: check which one you hold.
+     *
+     * One clone of the base per call, then every bundle replayed INTO that
+     * private copy (`applySmartMergeInto` — the live commit's copy-on-write law
+     * below the root, 9.29.0, so the fold and the live state agree at every
+     * path). The result is the caller's: it shares nothing with the base or
+     * the log.
      */
     materialise(stepIdx?: number): any;
     /** Persists a commit bundle for a finished stage. */

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

@@ -4,7 +4,7 @@
  * Like git history: stores commit bundles (diffs), not full snapshots.
  * materialise(stepIdx) reconstructs state at any point by replaying commits.
  */
-import { applySmartMerge } from './utils.js';
+import { applySmartMergeInto } from './utils.js';
 export class EventLog {
     /** Base snapshot BEFORE the first stage mutates anything. */
     base;
@@ -42,12 +42,18 @@ export class EventLog {
      * same log but its `commitIdx` is INCLUSIVE, because a reader's cursor asks
      * "the state AT this stop", which must include that stop's own commit. Two
      * folds over one log with opposite conventions: check which one you hold.
+     *
+     * One clone of the base per call, then every bundle replayed INTO that
+     * private copy (`applySmartMergeInto` — the live commit's copy-on-write law
+     * below the root, 9.29.0, so the fold and the live state agree at every
+     * path). The result is the caller's: it shares nothing with the base or
+     * the log.
      */
     materialise(stepIdx = this.steps.length) {
-        let out = structuredClone(this.base);
+        const out = structuredClone(this.base);
         for (let i = 0; i < stepIdx; i++) {
             const { overwrite, updates, trace } = this.steps[i];
-            out = applySmartMerge(out, updates, overwrite, trace);
+            applySmartMergeInto(out, updates, overwrite, trace);
         }
         return out;
     }
@@ -69,4 +75,4 @@ export class EventLog {
         this.steps = [];
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -5,6 +5,15 @@
  * - Each run gets its own namespace (runs/{id}/)
  * - Default values can be initialised and preserved
  * - Accepts commit bundles from TransactionBuffer
+ *
+ * COPY-ON-WRITE (9.29.0 — docs/design/2026-10-copy-on-write-commit.md):
+ * `context` is a GENERATION, and a generation is never edited. Every write —
+ * `applyPatch` (a stage commit), `setValue`, `updateValue` — builds the next
+ * generation by copying the root and the containers on each written path,
+ * shares every other subtree with the generation before it, and swaps. So a
+ * generation a stage captured (its first-touch view, its transaction
+ * buffer's diff base) stays exactly what it was, and a write costs O(what it
+ * wrote), not O(state).
  */
 import type { MemoryPatch, TraceEntry } from './types.js';
 export declare class SharedMemory {
@@ -15,17 +24,22 @@ export declare class SharedMemory {
     getDefaultValues(): {} | undefined;
     /** Gets all run namespaces. */
     getRuns(): any;
-    /** Updates a value using merge semantics. */
+    /** 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. */
+    /** Sets a value using overwrite semantics, as a new generation (path copy + swap). */
     setValue(runId: 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.
+     */
+    private ownedPathTo;
     /**
      * Reads a value from the store.
      * Looks up in run namespace first, falls back to global.
      */
     getValue(runId?: string, path?: string[], key?: string): any;
-    /** Gets the entire state as a JSON object. */
+    /** 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. */
+    /** Applies a commit bundle from TransactionBuffer: builds the next generation and swaps it in. */
     applyPatch(overwrite: MemoryPatch, updates: MemoryPatch, trace: TraceEntry[]): void;
 }

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

@@ -5,15 +5,31 @@
  * - Each run gets its own namespace (runs/{id}/)
  * - Default values can be initialised and preserved
  * - Accepts commit bundles from TransactionBuffer
+ *
+ * COPY-ON-WRITE (9.29.0 — docs/design/2026-10-copy-on-write-commit.md):
+ * `context` is a GENERATION, and a generation is never edited. Every write —
+ * `applyPatch` (a stage commit), `setValue`, `updateValue` — builds the next
+ * generation by copying the root and the containers on each written path,
+ * shares every other subtree with the generation before it, and swaps. So a
+ * generation a stage captured (its first-touch view, its transaction
+ * buffer's diff base) stays exactly what it was, and a write costs O(what it
+ * wrote), not O(state).
  */
-import { mergeContextWins } from './pathOps.js';
-import { applySmartMerge, getNestedValue, getRunAndGlobalPaths, setNestedValue, updateNestedValue } from './utils.js';
+import { mergeContextWins, ownedRootOf, ownSpine } from './pathOps.js';
+import { getNestedValue, getRunAndGlobalPaths, nextGeneration, setNestedValue, updateNestedValue } from './utils.js';
 export class SharedMemory {
     context = {};
     _defaultValues;
     constructor(defaultValues, initialContext) {
         this._defaultValues = defaultValues;
-        this.context = mergeContextWins(initialContext || {}, defaultValues || {});
+        const seed = mergeContextWins(initialContext || {}, defaultValues || {});
+        // Detached ONCE, here: `mergeContextWins` copies only the top level, so
+        // the seed's nested values are the caller's own objects. Before 9.29.0
+        // the first commit's whole-state clone detached them (and until then a
+        // caller mutating its `initialContext` changed live state with no row);
+        // nothing re-clones the state any more, so the seed is detached at
+        // construction — one clone per runtime, not one per commit.
+        this.context = Object.keys(seed).length > 0 ? structuredClone(seed) : seed;
     }
     /** Gets a clone of the default values. */
     getDefaultValues() {
@@ -23,13 +39,28 @@ export class SharedMemory {
     getRuns() {
         return this.context.runs;
     }
-    /** Updates a value using merge semantics. */
+    /** Updates a value using merge semantics, as a new generation (path copy + swap). */
     updateValue(runId, path, key, value) {
-        updateNestedValue(this.context, runId, path, key, value, this.getDefaultValues());
+        const next = this.ownedPathTo(runId, path, key);
+        updateNestedValue(next, runId, path, key, value, this.getDefaultValues());
+        this.context = next;
     }
-    /** Sets a value using overwrite semantics. */
+    /** Sets a value using overwrite semantics, as a new generation (path copy + swap). */
     setValue(runId, path, key, value) {
-        setNestedValue(this.context, runId, path, key, value, this.getDefaultValues());
+        const next = this.ownedPathTo(runId, path, key);
+        setNestedValue(next, runId, 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) {
+        const owned = new WeakSet();
+        const root = ownedRootOf(this.context, owned);
+        const { runPath, globalPath } = getRunAndGlobalPaths(runId, path);
+        ownSpine(root, [...(runPath || globalPath), key], owned);
+        return root;
     }
     /**
      * Reads a value from the store.
@@ -40,13 +71,13 @@ export class SharedMemory {
         const value = runPath ? getNestedValue(this.context, runPath, key) : undefined;
         return typeof value !== 'undefined' ? value : getNestedValue(this.context, globalPath, key);
     }
-    /** Gets the entire state as a JSON object. */
+    /** Gets the entire state as a JSON object — the current generation, by reference. Never mutate it. */
     getState() {
         return this.context;
     }
-    /** Applies a commit bundle from TransactionBuffer. */
+    /** Applies a commit bundle from TransactionBuffer: builds the next generation and swaps it in. */
     applyPatch(overwrite, updates, trace) {
-        this.context = applySmartMerge(this.context, updates, overwrite, trace);
+        this.context = nextGeneration(this.context, updates, overwrite, trace);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# 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 * - 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"]}