footprintjs 8.3.0 → 9.0.0

package/dist/esm/lib/engine/traversal/FlowchartTraverser.js

@@ -1,12 +1,15 @@
 /**
  * FlowchartTraverser — Pre-order DFS traversal of StageNode graph.
  *
- * Unified traversal algorithm for all node shapes:
- *   const pre = await prep();
- *   const [x, y] = await Promise.all([fx(pre), fy(pre)]);
- *   return await next(x, y);
+ * Unified traversal algorithm for all node shapes. `executeNode` is a
+ * TRAMPOLINE driver: it runs `executeNodeStep` (one node, all 7 phases) in
+ * a flat loop, following tail continuations (linear `next`, loop edges,
+ * dynamic next, flat decider dispatch) iteratively — so chain length and
+ * loop iterations never grow the call stack. Only true tree nesting (fork
+ * children, with-continuation decider/selector branches, subflow mounts)
+ * recurses.
  *
- * For each node, executeNode follows 7 phases:
+ * For each node, executeNodeStep follows 7 phases:
  *   0. CLASSIFY  — subflow detection, early delegation
  *   1. VALIDATE  — node invariants, role markers
  *   2. EXECUTE   — run stage fn, commit, break check
@@ -33,6 +36,15 @@ import { FlowRecorderDispatcher } from '../narrative/FlowRecorderDispatcher.js';
 import { NarrativeFlowRecorder } from '../narrative/NarrativeFlowRecorder.js';
 import { NullControlFlowNarrativeGenerator } from '../narrative/NullControlFlowNarrativeGenerator.js';
 import { buildRuntimeStageId } from '../runtimeStageId.js';
+/**
+ * Trampoline brand — marks a continuation hop returned by `executeNodeStep`
+ * to the driver loop in `executeNode`. Module-private symbol so a stage's own
+ * return value (which can be any object) can never be mistaken for a hop.
+ */
+const CONTINUE_HOP = Symbol('footprintjs.executeNode.continue');
+function isContinuationHop(value) {
+    return typeof value === 'object' && value !== null && value[CONTINUE_HOP] === true;
+}
 export class FlowchartTraverser {
     root;
     stageMap;
@@ -84,11 +96,26 @@ export class FlowchartTraverser {
     dynamicPatches = new WeakMap();
     patchCount = 0;
     /**
-     * Recursion depth counter for executeNode.
-     * Each recursive executeNode call increments this; decrements on exit (try/finally).
-     * Prevents call-stack overflow on infinite loops or excessively deep stage chains.
+     * TREE-nesting depth counter for executeNode (the trampoline driver).
+     * Each driver invocation increments this; decrements on exit (try/finally).
+     *
+     * Linear `next` chains, loop edges, and dynamic continuations are followed
+     * ITERATIVELY inside one driver invocation, so they never grow this
+     * counter. Only true tree recursion does: fork children, decider/selector
+     * branch dispatch (when the decider has its own continuation), and
+     * unbounded dynamic recursion. Prevents call-stack overflow on runaway
+     * recursive composition.
      */
     _executeDepth = 0;
+    /**
+     * Memoized parent-chain depth per StageContext. The context tree deepens
+     * by one per executed stage along a chain, so the naive parent-walk in
+     * `computeContextDepth` is O(chain length) per stage — O(n²) per run once
+     * the trampoline allows chains of tens of thousands of stages. Contexts
+     * are visited parent-before-child, so the memo makes each lookup O(1)
+     * amortized. WeakMap — dies with the traverser.
+     */
+    contextDepthCache = new WeakMap();
     /**
      * Shared mutable execution counter — monotonic, incremented per stage execution.
      * Shared with child traversers (subflows) so indices are globally unique within a run.
@@ -99,18 +126,26 @@ export class FlowchartTraverser {
      */
     _maxDepth;
     /**
-     * Default maximum recursive executeNode depth before an error is thrown.
-     * 500 comfortably covers any realistic pipeline depth (including deeply nested
-     * subflows) while preventing call-stack overflow (~10 000 frames in V8).
+     * Per-instance loop-iteration limit forwarded to the ContinuationResolver
+     * and propagated to subflow traversers. Undefined → resolver default (1000).
+     */
+    _maxIterations;
+    /**
+     * Default maximum nested executeNode depth before an error is thrown.
      *
-     * **Note on counting:** the counter increments once per `executeNode` call, not once per
-     * logical user stage. Subflow root entry and subflow continuation after return each cost
-     * one tick. For pipelines with many nested subflows, budget roughly 2 × (avg stages per
-     * subflow) of headroom when computing a custom `maxDepth` via `RunOptions.maxDepth`.
+     * **What counts as depth (trampoline model):** `executeNode` is an iterative
+     * driver — linear `next` hops, loop edges (`loopTo`/dynamic next), and
+     * dynamic-subflow re-entry are followed in a flat loop and consume NO depth.
+     * Depth grows only with true tree nesting: one tick per fork child, one per
+     * decider/selector branch dispatch that must return to its invoker (decider
+     * with its own `next`), one per subflow mount frame in the parent (the
+     * subflow body itself runs on a FRESH traverser with its own budget).
      *
-     * **Note on loops:** for `loopTo()` pipelines, this depth guard and `ContinuationResolver`'s
-     * iteration limit are independent — the lower one fires first. The default depth guard (500)
-     * fires before the default iteration limit (1000) for loop-heavy pipelines.
+     * 500 therefore covers any realistic chart — it bounds recursive
+     * COMPOSITION, not chain length or loop count. Loops are bounded by
+     * `ContinuationResolver`'s independent iteration limit (default 1000,
+     * configurable via `RunOptions.maxIterations`), which is now the binding
+     * constraint for loop-heavy pipelines.
      *
      * @remarks Not safe for concurrent `.execute()` calls on the same instance — concurrent
      * executions race on `_executeDepth`. Use a separate `FlowchartTraverser` per concurrent
@@ -122,6 +157,10 @@ export class FlowchartTraverser {
         if (maxDepth < 1)
             throw new Error('FlowchartTraverser: maxDepth must be >= 1');
         this._maxDepth = maxDepth;
+        if (opts.maxIterations !== undefined && opts.maxIterations < 1) {
+            throw new Error('FlowchartTraverser: maxIterations must be >= 1');
+        }
+        this._maxIterations = opts.maxIterations;
         this._executionCounter = opts.executionCounter ?? { value: 0 };
         this.root = opts.root;
         // Shallow-copy stageMap and subflows so that lazy-resolution mutations
@@ -174,7 +213,7 @@ export class FlowchartTraverser {
         this.nodeResolver = new NodeResolver(deps, nodeIdMap, (n) => this.effChildren(n));
         this.childrenExecutor = new ChildrenExecutor(deps, this.executeNode.bind(this));
         this.stageRunner = new StageRunner(deps);
-        this.continuationResolver = new ContinuationResolver(deps, this.nodeResolver, (nodeId, count) => this.structureManager.updateIterationCount(nodeId, count));
+        this.continuationResolver = new ContinuationResolver(deps, this.nodeResolver, (nodeId, count) => this.structureManager.updateIterationCount(nodeId, count), this._maxIterations);
         this.deciderHandler = new DeciderHandler(deps);
         this.selectorHandler = new SelectorHandler(deps, this.childrenExecutor);
         this.subflowExecutor = new SubflowExecutor(deps, this.createSubflowTraverserFactory(opts));
@@ -207,6 +246,7 @@ export class FlowchartTraverser {
                 logger: parentOpts.logger,
                 signal: parentOpts.signal,
                 maxDepth: this._maxDepth,
+                ...(this._maxIterations !== undefined && { maxIterations: this._maxIterations }),
                 parentSubflowId: subflowOpts.subflowId,
                 executionCounter: this._executionCounter, // Share counter — subflow continues global numbering
                 runId: this.runId, // Subflow inherits parent's runId — same logical run
@@ -344,26 +384,30 @@ export class FlowchartTraverser {
     /**
      * Build an O(1) ID→node map from the root graph.
      * Used by NodeResolver to avoid repeated DFS on every loopTo() call.
-     * Depth-guarded at MAX_EXECUTE_DEPTH to prevent infinite recursion on cyclic graphs.
+     * Iterative worklist (no recursion) so arbitrarily long chains index fully;
+     * the `map.has` guard handles cyclic refs. First-visited node wins per ID —
+     * worklist order matches the old recursive pre-order (children, then next).
      * Dynamic subflows and lazy-resolved nodes are added to stageMap at runtime but not to this map —
      * those use the DFS fallback in NodeResolver.
      */
     buildNodeIdMap(root) {
         const map = new Map();
-        const visit = (node, depth) => {
-            if (depth > FlowchartTraverser.MAX_EXECUTE_DEPTH)
-                return;
+        const stack = [root];
+        while (stack.length > 0) {
+            const node = stack.pop();
             if (map.has(node.id))
-                return; // already visited (avoids infinite loops on cyclic refs)
+                continue; // already visited (avoids infinite loops on cyclic refs)
             map.set(node.id, node);
+            // Push in reverse visit order (LIFO stack): next first, then children
+            // reversed — so children are visited before next, first child first,
+            // matching the recursive pre-order exactly.
+            if (node.next)
+                stack.push(node.next);
             if (node.children) {
-                for (const child of node.children)
-                    visit(child, depth + 1);
+                for (let i = node.children.length - 1; i >= 0; i--)
+                    stack.push(node.children[i]);
             }
-            if (node.next)
-                visit(node.next, depth + 1);
-        };
-        visit(root, 0);
+        }
         return map;
     }
     getStageFn(node) {
@@ -443,327 +487,414 @@ export class FlowchartTraverser {
         return this.stageRunner.run(node, stageFunc, context, breakFn);
     }
     /**
-     * Pre-order DFS traversal — the core algorithm.
-     * Each call processes one node through all 7 phases.
+     * Trampoline driver — pre-order DFS traversal entry point.
+     *
+     * Runs `executeNodeStep` (one node, all 7 phases) in a flat loop: every
+     * TAIL continuation (linear `next`, loop edge, dynamic next / dynamic
+     * re-entry, no-continuation decider dispatch) comes back as a
+     * `ContinuationHop` and is followed ITERATIVELY — neither the call stack
+     * nor the retained promise chain grows with chain length or loop count.
+     *
+     * Recursion remains ONLY for true tree nesting (each gets a nested driver
+     * call): fork children (`ChildrenExecutor`), selector branches (parallel
+     * fan-out), decider branch dispatch when the decider has its own `next`
+     * (the branch must complete BEFORE the decider's continuation runs), and
+     * subflow mounts (fresh traverser; the mount frame stays in the parent).
+     * `_executeDepth` therefore counts chart COMPOSITION depth only, guarded
+     * by `_maxDepth` (default `MAX_EXECUTE_DEPTH` = 500).
+     *
+     * PauseSignal: a flat decider dispatch records an `InvokerStamp`; if the
+     * continued chain later pauses, the driver stamps the signal during
+     * unwind — same invoker context the recursive dispatch's catch used to
+     * stamp, innermost (most recent dispatch) first.
      */
     async executeNode(node, context, breakFlag, branchPath) {
-        // ─── Recursion depth guard ───
-        // Each `await executeNode(...)` keeps the calling frame on the stack.
-        // Without a cap, an infinite loop or an excessively deep stage chain will
-        // eventually overflow the V8 call stack (~10 000 frames) with a cryptic
-        // "Maximum call stack size exceeded" error.  We fail early with a clear
-        // message so users can diagnose the cause (infinite loop, missing break, etc.).
-        // The increment is inside `try` so `finally` always decrements — no fragile
-        // gap between check and try entry.
+        // Invoker stamps from flat decider dispatches in THIS driver — kept
+        // local so nested drivers (fork children, with-next decider branches)
+        // get their own windows, matching the old frame-on-stack stamping scope.
+        let pendingInvokers;
+        // ─── Tree-depth guard ───
+        // The increment is inside `try` so `finally` always decrements — no
+        // fragile gap between check and try entry.
         try {
             if (++this._executeDepth > this._maxDepth) {
                 throw new Error(`FlowchartTraverser: maximum traversal depth exceeded (${this._maxDepth}). ` +
-                    'Check for infinite loops or missing break conditions in your flowchart. ' +
+                    'Depth counts NESTED dispatch (fork children, decider/selector branches, recursive composition) — ' +
+                    'linear chains and loop iterations run flat and do not consume it. ' +
                     `Last stage: '${node.name}'. ` +
-                    'For loopTo() pipelines, consider adding a break condition or using RunOptions.maxDepth to raise the limit.');
+                    'Check for unbounded recursive chart composition, or raise the limit via RunOptions.maxDepth.');
             }
-            // Attach builder metadata to context for snapshot enrichment.
-            // Subflow meta reads go through the dynamic-patch overlay — a node
-            // patched by a dynamic-subflow return re-enters executeNode and must
-            // classify as a subflow without the shared node ever being mutated.
-            if (node.description)
-                context.description = node.description;
-            const effSubflowId = this.effSubflowId(node);
-            if (this.effIsSubflowRoot(node) && effSubflowId)
-                context.subflowId = effSubflowId;
-            // Assign runtimeStageId BEFORE traversalContext creation — ensures scope events
-            // (buffered by runtimeStageId) and flow events (flushed by traversalContext.runtimeStageId)
-            // use the same value. Must happen before executeStage AND before traversalContext.
-            const idx = this._executionCounter.value++;
-            context.runtimeStageId = buildRuntimeStageId(node.id, idx);
-            // Build traversal context for recorder events — created once per stage, shared by all events
-            const traversalContext = {
-                runId: this.runId,
-                stageId: node.id ?? context.stageId,
-                runtimeStageId: context.runtimeStageId,
-                stageName: node.name,
-                parentStageId: context.parent?.stageId,
-                subflowId: context.subflowId ?? this.parentSubflowId,
-                subflowPath: branchPath || undefined,
-                depth: this.computeContextDepth(context),
-            };
-            // ─── Phase 0a: LAZY RESOLVE — deferred subflow resolution ───
-            // Guard uses the per-traverser resolvedLazySubflows set (not the shared node) so
-            // concurrent traversers do not race on node.subflowResolver or clear it for each other.
-            if (node.isSubflowRoot && node.subflowResolver && !this.resolvedLazySubflows.has(node.subflowId)) {
-                const resolved = node.subflowResolver();
-                const prefixedRoot = this.prefixNodeTree(resolved.root, node.subflowId);
-                // Register the resolved subflow (same path as eager registration)
-                this.subflows[node.subflowId] = { root: prefixedRoot };
-                // Merge stageMap entries
-                for (const [key, fn] of resolved.stageMap) {
-                    const prefixedKey = `${node.subflowId}/${key}`;
-                    if (!this.stageMap.has(prefixedKey)) {
-                        this.stageMap.set(prefixedKey, fn);
-                    }
+            let current = { [CONTINUE_HOP]: true, node, context, branchPath };
+            for (;;) {
+                const result = await this.executeNodeStep(current.node, current.context, breakFlag, current.branchPath);
+                if (!isContinuationHop(result)) {
+                    return result;
                 }
-                // Merge nested subflows
-                if (resolved.subflows) {
-                    for (const [key, def] of Object.entries(resolved.subflows)) {
-                        const prefixedKey = `${node.subflowId}/${key}`;
-                        if (!this.subflows[prefixedKey]) {
-                            this.subflows[prefixedKey] = def;
-                        }
-                    }
-                }
-                // Update runtime structure with the now-resolved spec
-                this.structureManager.updateDynamicSubflow(node.id, node.subflowId, node.subflowName, resolved.buildTimeStructure);
-                // Mark as resolved for THIS traverser — per-traverser set prevents re-entry
-                // without mutating the shared StageNode graph (which would race concurrent traversers).
-                this.resolvedLazySubflows.add(node.subflowId);
+                if (result.invokerStamp)
+                    (pendingInvokers ??= []).push(result.invokerStamp);
+                current = result;
             }
-            // ─── Phase 0: CLASSIFY — subflow detection ───
-            if (this.effIsSubflowRoot(node) && effSubflowId) {
-                // Hand helpers the EFFECTIVE node view (built fields + dynamic patch)
-                // so SubflowExecutor/NodeResolver never read stale built fields.
-                const mountNode = this.effNode(node);
-                const resolvedNode = this.nodeResolver.resolveSubflowReference(mountNode);
-                const subflowOutput = await this.subflowExecutor.executeSubflow(resolvedNode, context, breakFlag, branchPath, this.subflowResults, traversalContext);
-                const isReferenceBasedSubflow = resolvedNode !== mountNode;
-                const hasChildren = Boolean(mountNode.children && mountNode.children.length > 0);
-                const shouldExecuteContinuation = isReferenceBasedSubflow || hasChildren;
-                // ─── Break-flag check AFTER subflow returns ───
-                // If the subflow was mounted with `propagateBreak: true` and broke
-                // internally, `SubflowExecutor` has already flipped our breakFlag.
-                // Stop the outer traversal here — do not run the next linear stage.
-                if (breakFlag.shouldBreak) {
-                    return subflowOutput;
+        }
+        catch (error) {
+            // Replay invoker stamps most-recent-first. `setInvoker` is
+            // first-write-wins, so the innermost dispatch's stamp lands — exactly
+            // the old bubble-up order through nested catch frames.
+            if (pendingInvokers !== undefined && isPauseSignal(error)) {
+                for (let i = pendingInvokers.length - 1; i >= 0; i--) {
+                    error.setInvoker(pendingInvokers[i].invokerStageId, pendingInvokers[i].continuationStageId);
                 }
-                if (node.next && shouldExecuteContinuation) {
-                    const nextCtx = context.createNext(branchPath, node.next.name, node.next.id);
-                    return await this.executeNode(node.next, nextCtx, breakFlag, branchPath);
+            }
+            throw error;
+        }
+        finally {
+            this._executeDepth--;
+        }
+    }
+    /** Build a flat continuation hop for the driver loop. */
+    hop(node, context, branchPath, invokerStamp) {
+        return { [CONTINUE_HOP]: true, node, context, branchPath, ...(invokerStamp && { invokerStamp }) };
+    }
+    /**
+     * Execute ONE node through all 7 phases — the old recursive `executeNode`
+     * body; only the tail calls became `ContinuationHop` returns. Returns the
+     * node's result, or a hop for the driver loop to follow.
+     */
+    async executeNodeStep(node, context, breakFlag, branchPath) {
+        // Attach builder metadata to context for snapshot enrichment.
+        // Subflow meta reads go through the dynamic-patch overlay — a node
+        // patched by a dynamic-subflow return re-enters executeNode and must
+        // classify as a subflow without the shared node ever being mutated.
+        if (node.description)
+            context.description = node.description;
+        const effSubflowId = this.effSubflowId(node);
+        if (this.effIsSubflowRoot(node) && effSubflowId)
+            context.subflowId = effSubflowId;
+        // Assign runtimeStageId BEFORE traversalContext creation — ensures scope events
+        // (buffered by runtimeStageId) and flow events (flushed by traversalContext.runtimeStageId)
+        // use the same value. Must happen before executeStage AND before traversalContext.
+        const idx = this._executionCounter.value++;
+        context.runtimeStageId = buildRuntimeStageId(node.id, idx);
+        // Build traversal context for recorder events — created once per stage, shared by all events
+        const traversalContext = {
+            runId: this.runId,
+            stageId: node.id ?? context.stageId,
+            runtimeStageId: context.runtimeStageId,
+            stageName: node.name,
+            parentStageId: context.parent?.stageId,
+            subflowId: context.subflowId ?? this.parentSubflowId,
+            subflowPath: branchPath || undefined,
+            depth: this.computeContextDepth(context),
+        };
+        // ─── Phase 0a: LAZY RESOLVE — deferred subflow resolution ───
+        // Guard uses the per-traverser resolvedLazySubflows set (not the shared node) so
+        // concurrent traversers do not race on node.subflowResolver or clear it for each other.
+        if (node.isSubflowRoot && node.subflowResolver && !this.resolvedLazySubflows.has(node.subflowId)) {
+            const resolved = node.subflowResolver();
+            const prefixedRoot = this.prefixNodeTree(resolved.root, node.subflowId);
+            // Register the resolved subflow (same path as eager registration)
+            this.subflows[node.subflowId] = { root: prefixedRoot };
+            // Merge stageMap entries
+            for (const [key, fn] of resolved.stageMap) {
+                const prefixedKey = `${node.subflowId}/${key}`;
+                if (!this.stageMap.has(prefixedKey)) {
+                    this.stageMap.set(prefixedKey, fn);
                 }
-                return subflowOutput;
             }
-            const stageFunc = this.getStageFn(node);
-            const hasStageFunction = Boolean(stageFunc);
-            const isScopeBasedDecider = Boolean(node.deciderFn);
-            const isScopeBasedSelector = Boolean(node.selectorFn);
-            const isDeciderNode = isScopeBasedDecider;
-            const hasChildren = Boolean(this.effChildren(node)?.length);
-            // `next` is never overlaid — a dynamic next applies only to the visit
-            // that produced it (handled via the `dynamicNext` local below), so the
-            // built chart's next is always the correct continuation here.
-            const hasNext = Boolean(node.next);
-            const originalNext = node.next;
-            // ─── Phase 1: VALIDATE — node invariants ───
-            if (!hasStageFunction && !isDeciderNode && !isScopeBasedSelector && !hasChildren) {
-                const errorMessage = `Node '${node.name}' must define: embedded fn OR a stageMap entry OR have children/decider`;
-                this.logger.error(`Error in pipeline (${branchPath}) stage [${node.name}]:`, { error: errorMessage });
-                throw new Error(errorMessage);
+            // Merge nested subflows
+            if (resolved.subflows) {
+                for (const [key, def] of Object.entries(resolved.subflows)) {
+                    const prefixedKey = `${node.subflowId}/${key}`;
+                    if (!this.subflows[prefixedKey]) {
+                        this.subflows[prefixedKey] = def;
+                    }
+                }
             }
-            if (isDeciderNode && !hasChildren) {
-                const errorMessage = 'Decider node needs to have children to execute';
-                this.logger.error(`Error in pipeline (${branchPath}) stage [${node.name}]:`, { error: errorMessage });
-                throw new Error(errorMessage);
+            // Update runtime structure with the now-resolved spec
+            this.structureManager.updateDynamicSubflow(node.id, node.subflowId, node.subflowName, resolved.buildTimeStructure);
+            // Mark as resolved for THIS traverser — per-traverser set prevents re-entry
+            // without mutating the shared StageNode graph (which would race concurrent traversers).
+            this.resolvedLazySubflows.add(node.subflowId);
+        }
+        // ─── Phase 0: CLASSIFY — subflow detection ───
+        if (this.effIsSubflowRoot(node) && effSubflowId) {
+            // Hand helpers the EFFECTIVE node view (built fields + dynamic patch)
+            // so SubflowExecutor/NodeResolver never read stale built fields.
+            const mountNode = this.effNode(node);
+            const resolvedNode = this.nodeResolver.resolveSubflowReference(mountNode);
+            const subflowOutput = await this.subflowExecutor.executeSubflow(resolvedNode, context, breakFlag, branchPath, this.subflowResults, traversalContext);
+            const isReferenceBasedSubflow = resolvedNode !== mountNode;
+            const hasChildren = Boolean(mountNode.children && mountNode.children.length > 0);
+            const shouldExecuteContinuation = isReferenceBasedSubflow || hasChildren;
+            // ─── Break-flag check AFTER subflow returns ───
+            // If the subflow was mounted with `propagateBreak: true` and broke
+            // internally, `SubflowExecutor` has already flipped our breakFlag.
+            // Stop the outer traversal here — do not run the next linear stage.
+            if (breakFlag.shouldBreak) {
+                return subflowOutput;
             }
-            if (isScopeBasedSelector && !hasChildren) {
-                const errorMessage = 'Selector node needs to have children to execute';
-                this.logger.error(`Error in pipeline (${branchPath}) stage [${node.name}]:`, { error: errorMessage });
-                throw new Error(errorMessage);
+            if (node.next && shouldExecuteContinuation) {
+                const nextCtx = context.createNext(branchPath, node.next.name, node.next.id);
+                return this.hop(node.next, nextCtx, branchPath);
             }
-            // Role markers for debug panels
-            if (!hasStageFunction) {
-                if (isDeciderNode)
-                    context.setAsDecider();
-                else if (hasChildren)
-                    context.setAsFork();
+            return subflowOutput;
+        }
+        const stageFunc = this.getStageFn(node);
+        const hasStageFunction = Boolean(stageFunc);
+        const isScopeBasedDecider = Boolean(node.deciderFn);
+        const isScopeBasedSelector = Boolean(node.selectorFn);
+        const isDeciderNode = isScopeBasedDecider;
+        const hasChildren = Boolean(this.effChildren(node)?.length);
+        // `next` is never overlaid — a dynamic next applies only to the visit
+        // that produced it (handled via the `dynamicNext` local below), so the
+        // built chart's next is always the correct continuation here.
+        const hasNext = Boolean(node.next);
+        const originalNext = node.next;
+        // ─── Phase 1: VALIDATE — node invariants ───
+        if (!hasStageFunction && !isDeciderNode && !isScopeBasedSelector && !hasChildren) {
+            const errorMessage = `Node '${node.name}' must define: embedded fn OR a stageMap entry OR have children/decider`;
+            this.logger.error(`Error in pipeline (${branchPath}) stage [${node.name}]:`, { error: errorMessage });
+            throw new Error(errorMessage);
+        }
+        if (isDeciderNode && !hasChildren) {
+            const errorMessage = 'Decider node needs to have children to execute';
+            this.logger.error(`Error in pipeline (${branchPath}) stage [${node.name}]:`, { error: errorMessage });
+            throw new Error(errorMessage);
+        }
+        if (isScopeBasedSelector && !hasChildren) {
+            const errorMessage = 'Selector node needs to have children to execute';
+            this.logger.error(`Error in pipeline (${branchPath}) stage [${node.name}]:`, { error: errorMessage });
+            throw new Error(errorMessage);
+        }
+        // Role markers for debug panels
+        if (!hasStageFunction) {
+            if (isDeciderNode)
+                context.setAsDecider();
+            else if (hasChildren)
+                context.setAsFork();
+        }
+        // Break handler wired to the scope. Captures the optional reason
+        // passed via `scope.$break(reason)` and parks it on the breakFlag so
+        // downstream code (FlowRecorder.onBreak, subflow propagation) can
+        // surface it. A second $break call in the same stage keeps the FIRST
+        // reason — first-break-wins — matching the "execution stopped" story.
+        const breakFn = (reason) => {
+            breakFlag.shouldBreak = true;
+            if (reason !== undefined && breakFlag.reason === undefined) {
+                breakFlag.reason = reason;
             }
-            // Break handler wired to the scope. Captures the optional reason
-            // passed via `scope.$break(reason)` and parks it on the breakFlag so
-            // downstream code (FlowRecorder.onBreak, subflow propagation) can
-            // surface it. A second $break call in the same stage keeps the FIRST
-            // reason — first-break-wins — matching the "execution stopped" story.
-            const breakFn = (reason) => {
-                breakFlag.shouldBreak = true;
-                if (reason !== undefined && breakFlag.reason === undefined) {
-                    breakFlag.reason = reason;
-                }
-            };
-            // ─── Phase 2a: SELECTOR — scope-based multi-choice ───
-            if (isScopeBasedSelector) {
-                const selectorResult = await this.selectorHandler.handleScopeBased(node, stageFunc, context, breakFlag, branchPath, this.executeStage.bind(this), this.executeNode.bind(this), traversalContext);
-                if (hasNext) {
-                    const nextCtx = context.createNext(branchPath, node.next.name, node.next.id);
-                    return await this.executeNode(node.next, nextCtx, breakFlag, branchPath);
-                }
-                return selectorResult;
+        };
+        // ─── Phase 2a: SELECTOR — scope-based multi-choice ───
+        if (isScopeBasedSelector) {
+            const selectorResult = await this.selectorHandler.handleScopeBased(node, stageFunc, context, breakFlag, branchPath, this.executeStage.bind(this), this.executeNode.bind(this), traversalContext);
+            if (hasNext) {
+                const nextCtx = context.createNext(branchPath, node.next.name, node.next.id);
+                return this.hop(node.next, nextCtx, branchPath);
             }
-            // ─── Phase 2b: DECIDER — scope-based single-choice conditional branch ───
-            if (isDeciderNode) {
-                const deciderResult = await this.deciderHandler.handleScopeBased(node, stageFunc, context, breakFlag, branchPath, this.executeStage.bind(this), this.executeNode.bind(this), traversalContext);
-                // After branch execution, follow decider's own next (e.g., loopTo target)
-                if (hasNext && !breakFlag.shouldBreak) {
-                    const nextNode = originalNext;
-                    // Use the isLoopRef flag set by loopTo() — do not rely on stageMap absence,
-                    // since id-keyed stageMaps would otherwise cause loop targets to be executed directly.
-                    const isLoopRef = nextNode.isLoopRef === true ||
-                        (!this.getStageFn(nextNode) &&
-                            !this.effChildren(nextNode)?.length &&
-                            !nextNode.deciderFn &&
-                            !nextNode.selectorFn &&
-                            !this.effIsSubflowRoot(nextNode));
-                    if (isLoopRef) {
-                        return this.continuationResolver.resolve(nextNode, node, context, breakFlag, branchPath, this.executeNode.bind(this));
-                    }
-                    this.narrativeGenerator.onNext(node.name, nextNode.name, nextNode.description, traversalContext);
-                    const nextCtx = context.createNext(branchPath, nextNode.name, nextNode.id);
-                    return await this.executeNode(nextNode, nextCtx, breakFlag, branchPath);
-                }
-                return deciderResult;
+            return selectorResult;
+        }
+        // ─── Phase 2b: DECIDER — scope-based single-choice conditional branch ───
+        if (isDeciderNode) {
+            const dispatch = await this.deciderHandler.prepareDispatch(node, stageFunc, context, breakFlag, branchPath, this.executeStage.bind(this), traversalContext);
+            // No decider-level continuation → the branch dispatch is a tail
+            // call. Hand it to the driver as a flat hop so loop-heavy decider
+            // charts (e.g. agent ReAct loops with branch-sourced `loopTo`) stay
+            // flat-stacked. The invoker stamp preserves PauseSignal semantics —
+            // the decider is the invoker of whatever pauses in the chain.
+            if (!hasNext && dispatch.kind === 'dispatch') {
+                return this.hop(dispatch.chosen, dispatch.branchContext, branchPath, {
+                    invokerStageId: node.id,
+                    continuationStageId: node.next?.id,
+                });
             }
-            // ─── Abort check — cooperative cancellation ───
-            if (this.signal?.aborted) {
-                const reason = this.signal.reason instanceof Error ? this.signal.reason : new Error(this.signal.reason ?? 'Aborted');
-                throw reason;
+            // Decider WITH its own next: the branch chain must complete BEFORE
+            // the decider's continuation runs — true tree nesting, kept
+            // recursive (a nested driver). Mirrors handleScopeBased exactly,
+            // including the PauseSignal invoker stamp on bubble-up.
+            let deciderResult;
+            if (dispatch.kind === 'break') {
+                deciderResult = dispatch.branchId;
             }
-            // ─── Phase 3: EXECUTE — run stage function ───
-            let stageOutput;
-            let dynamicNext;
-            if (stageFunc) {
+            else {
                 try {
-                    stageOutput = await this.executeStage(node, stageFunc, context, breakFn);
+                    deciderResult = await this.executeNode(dispatch.chosen, dispatch.branchContext, breakFlag, branchPath);
                 }
                 catch (error) {
-                    // PauseSignal is expected control flow, not an error — fire narrative, commit, re-throw.
                     if (isPauseSignal(error)) {
-                        context.commit();
-                        this.narrativeGenerator.onPause(node.name, node.id, error.pauseData, error.subflowPath, traversalContext);
-                        throw error;
+                        error.setInvoker(node.id, node.next?.id);
                     }
+                    throw error;
+                }
+            }
+            // After branch execution, follow decider's own next (e.g., loopTo target)
+            if (hasNext && !breakFlag.shouldBreak) {
+                const nextNode = originalNext;
+                // Use the isLoopRef flag set by loopTo() — do not rely on stageMap absence,
+                // since id-keyed stageMaps would otherwise cause loop targets to be executed directly.
+                const isLoopRef = nextNode.isLoopRef === true ||
+                    (!this.getStageFn(nextNode) &&
+                        !this.effChildren(nextNode)?.length &&
+                        !nextNode.deciderFn &&
+                        !nextNode.selectorFn &&
+                        !this.effIsSubflowRoot(nextNode));
+                if (isLoopRef) {
+                    const target = this.continuationResolver.resolveTarget(nextNode, node, context, branchPath);
+                    return this.hop(target.node, target.context, branchPath);
+                }
+                this.narrativeGenerator.onNext(node.name, nextNode.name, nextNode.description, traversalContext);
+                const nextCtx = context.createNext(branchPath, nextNode.name, nextNode.id);
+                return this.hop(nextNode, nextCtx, branchPath);
+            }
+            return deciderResult;
+        }
+        // ─── Abort check — cooperative cancellation ───
+        if (this.signal?.aborted) {
+            const reason = this.signal.reason instanceof Error ? this.signal.reason : new Error(this.signal.reason ?? 'Aborted');
+            throw reason;
+        }
+        // ─── Phase 3: EXECUTE — run stage function ───
+        let stageOutput;
+        let dynamicNext;
+        if (stageFunc) {
+            try {
+                stageOutput = await this.executeStage(node, stageFunc, context, breakFn);
+            }
+            catch (error) {
+                // PauseSignal is expected control flow, not an error — fire narrative, commit, re-throw.
+                if (isPauseSignal(error)) {
                     context.commit();
-                    this.narrativeGenerator.onError(node.name, error.toString(), error, traversalContext);
-                    this.logger.error(`Error in pipeline (${branchPath}) stage [${node.name}]:`, { error });
-                    context.addError('stageExecutionError', error.toString());
+                    this.narrativeGenerator.onPause(node.name, node.id, error.pauseData, error.subflowPath, traversalContext);
                     throw error;
                 }
                 context.commit();
-                this.narrativeGenerator.onStageExecuted(node.name, node.description, traversalContext, 'linear');
-                if (breakFlag.shouldBreak) {
-                    // Forward the optional reason captured on breakFlag — set by the
-                    // stage's $break(reason) call OR by a subflow's propagateBreak.
-                    this.narrativeGenerator.onBreak(node.name, traversalContext, breakFlag.reason);
-                    return stageOutput;
+                this.narrativeGenerator.onError(node.name, error.toString(), error, traversalContext);
+                this.logger.error(`Error in pipeline (${branchPath}) stage [${node.name}]:`, { error });
+                context.addError('stageExecutionError', error.toString());
+                throw error;
+            }
+            context.commit();
+            this.narrativeGenerator.onStageExecuted(node.name, node.description, traversalContext, 'linear');
+            if (breakFlag.shouldBreak) {
+                // Forward the optional reason captured on breakFlag — set by the
+                // stage's $break(reason) call OR by a subflow's propagateBreak.
+                this.narrativeGenerator.onBreak(node.name, traversalContext, breakFlag.reason);
+                return stageOutput;
+            }
+            // ─── Phase 4: DYNAMIC — StageNode return detection ───
+            if (stageOutput && typeof stageOutput === 'object' && isStageNodeReturn(stageOutput)) {
+                const dynamicNode = stageOutput;
+                context.addLog('isDynamic', true);
+                context.addLog('dynamicPattern', 'StageNodeReturn');
+                // Dynamic subflow auto-registration. The subflow meta lands in the
+                // traverser-local overlay (NOT on the shared node); the immediate
+                // executeNode re-entry sees it through the eff* accessors and
+                // classifies the node as a subflow mount in Phase 0.
+                if (dynamicNode.isSubflowRoot && dynamicNode.subflowDef && dynamicNode.subflowId) {
+                    context.addLog('dynamicPattern', 'dynamicSubflow');
+                    context.addLog('dynamicSubflowId', dynamicNode.subflowId);
+                    this.autoRegisterSubflowDef(dynamicNode.subflowId, dynamicNode.subflowDef, node.id);
+                    this.getOrCreatePatch(node).subflowMeta = {
+                        isSubflowRoot: true,
+                        subflowId: dynamicNode.subflowId,
+                        subflowName: dynamicNode.subflowName,
+                        subflowMountOptions: dynamicNode.subflowMountOptions,
+                    };
+                    this.structureManager.updateDynamicSubflow(node.id, dynamicNode.subflowId, dynamicNode.subflowName, dynamicNode.subflowDef?.buildTimeStructure);
+                    // Re-enter THIS node (same context): the overlay patch makes the
+                    // next step classify it as a subflow mount in Phase 0.
+                    return this.hop(node, context, branchPath);
                 }
-                // ─── Phase 4: DYNAMIC — StageNode return detection ───
-                if (stageOutput && typeof stageOutput === 'object' && isStageNodeReturn(stageOutput)) {
-                    const dynamicNode = stageOutput;
-                    context.addLog('isDynamic', true);
-                    context.addLog('dynamicPattern', 'StageNodeReturn');
-                    // Dynamic subflow auto-registration. The subflow meta lands in the
-                    // traverser-local overlay (NOT on the shared node); the immediate
-                    // executeNode re-entry sees it through the eff* accessors and
-                    // classifies the node as a subflow mount in Phase 0.
-                    if (dynamicNode.isSubflowRoot && dynamicNode.subflowDef && dynamicNode.subflowId) {
-                        context.addLog('dynamicPattern', 'dynamicSubflow');
-                        context.addLog('dynamicSubflowId', dynamicNode.subflowId);
-                        this.autoRegisterSubflowDef(dynamicNode.subflowId, dynamicNode.subflowDef, node.id);
-                        this.getOrCreatePatch(node).subflowMeta = {
-                            isSubflowRoot: true,
-                            subflowId: dynamicNode.subflowId,
-                            subflowName: dynamicNode.subflowName,
-                            subflowMountOptions: dynamicNode.subflowMountOptions,
-                        };
-                        this.structureManager.updateDynamicSubflow(node.id, dynamicNode.subflowId, dynamicNode.subflowName, dynamicNode.subflowDef?.buildTimeStructure);
-                        return await this.executeNode(node, context, breakFlag, branchPath);
-                    }
-                    // Check children for subflowDef
-                    if (dynamicNode.children) {
-                        for (const child of dynamicNode.children) {
-                            if (child.isSubflowRoot && child.subflowDef && child.subflowId) {
-                                this.autoRegisterSubflowDef(child.subflowId, child.subflowDef, child.id);
-                                this.structureManager.updateDynamicSubflow(child.id, child.subflowId, child.subflowName, child.subflowDef?.buildTimeStructure);
-                            }
+                // Check children for subflowDef
+                if (dynamicNode.children) {
+                    for (const child of dynamicNode.children) {
+                        if (child.isSubflowRoot && child.subflowDef && child.subflowId) {
+                            this.autoRegisterSubflowDef(child.subflowId, child.subflowDef, child.id);
+                            this.structureManager.updateDynamicSubflow(child.id, child.subflowId, child.subflowName, child.subflowDef?.buildTimeStructure);
                         }
                     }
-                    // Dynamic children (fork pattern) — patched into the overlay;
-                    // Phase 5 below reads them back through effChildren/effSelector.
-                    if (dynamicNode.children && dynamicNode.children.length > 0) {
-                        this.getOrCreatePatch(node).children = dynamicNode.children;
-                        context.addLog('dynamicChildCount', dynamicNode.children.length);
-                        context.addLog('dynamicChildIds', dynamicNode.children.map((c) => c.id));
-                        this.structureManager.updateDynamicChildren(node.id, dynamicNode.children, Boolean(dynamicNode.nextNodeSelector), Boolean(dynamicNode.deciderFn));
-                        if (typeof dynamicNode.nextNodeSelector === 'function') {
-                            this.getOrCreatePatch(node).nextNodeSelector = dynamicNode.nextNodeSelector;
-                            context.addLog('hasSelector', true);
-                        }
-                    }
-                    // Dynamic next (linear continuation) — stays a LOCAL: it applies
-                    // only to this visit (Phase 6 routes it through the
-                    // ContinuationResolver), so the shared node's next is never touched
-                    // and a loop revisit naturally sees the built continuation.
-                    if (dynamicNode.next) {
-                        dynamicNext = dynamicNode.next;
-                        this.structureManager.updateDynamicNext(node.id, dynamicNode.next);
-                        context.addLog('hasDynamicNext', true);
-                    }
-                    stageOutput = undefined;
                 }
-            }
-            // ─── Phase 5: CHILDREN — fork dispatch ───
-            // Re-read through the overlay: Phase 4 may have just patched dynamic
-            // children/selector for THIS visit (or an earlier visit in this run).
-            const childrenAfterStage = this.effChildren(node);
-            const hasChildrenAfterStage = Boolean(childrenAfterStage?.length);
-            if (hasChildrenAfterStage) {
-                context.addLog('totalChildren', childrenAfterStage?.length);
-                context.addLog('orderOfExecution', 'ChildrenAfterStage');
-                let nodeChildrenResults;
-                const effSelectorFn = this.effSelector(node);
-                if (effSelectorFn) {
-                    nodeChildrenResults = await this.childrenExecutor.executeSelectedChildren(effSelectorFn, childrenAfterStage, stageOutput, context, branchPath, traversalContext, node.failFast);
-                }
-                else {
-                    const childCount = childrenAfterStage?.length ?? 0;
-                    const childNames = childrenAfterStage?.map((c) => c.name).join(', ');
-                    context.addFlowDebugMessage('children', `Executing all ${childCount} children in parallel: ${childNames}`, {
-                        count: childCount,
-                        targetStage: childrenAfterStage?.map((c) => c.name),
-                    });
-                    // effNode: ChildrenExecutor reads node.children/node.failFast itself.
-                    nodeChildrenResults = await this.childrenExecutor.executeNodeChildren(this.effNode(node), context, undefined, branchPath, traversalContext);
-                }
-                // Fork-only: return bundle
-                if (!hasNext && !dynamicNext) {
-                    return nodeChildrenResults;
+                // Dynamic children (fork pattern) — patched into the overlay;
+                // Phase 5 below reads them back through effChildren/effSelector.
+                if (dynamicNode.children && dynamicNode.children.length > 0) {
+                    this.getOrCreatePatch(node).children = dynamicNode.children;
+                    context.addLog('dynamicChildCount', dynamicNode.children.length);
+                    context.addLog('dynamicChildIds', dynamicNode.children.map((c) => c.id));
+                    this.structureManager.updateDynamicChildren(node.id, dynamicNode.children, Boolean(dynamicNode.nextNodeSelector), Boolean(dynamicNode.deciderFn));
+                    if (typeof dynamicNode.nextNodeSelector === 'function') {
+                        this.getOrCreatePatch(node).nextNodeSelector = dynamicNode.nextNodeSelector;
+                        context.addLog('hasSelector', true);
+                    }
                 }
-                // Capture dynamic children as synthetic subflow result for UI
-                const isDynamic = context.debug?.logContext?.isDynamic;
-                if (isDynamic && childrenAfterStage && childrenAfterStage.length > 0) {
-                    this.captureDynamicChildrenResult(node, childrenAfterStage, context);
+                // Dynamic next (linear continuation) — stays a LOCAL: it applies
+                // only to this visit (Phase 6 routes it through the
+                // ContinuationResolver), so the shared node's next is never touched
+                // and a loop revisit naturally sees the built continuation.
+                if (dynamicNode.next) {
+                    dynamicNext = dynamicNode.next;
+                    this.structureManager.updateDynamicNext(node.id, dynamicNode.next);
+                    context.addLog('hasDynamicNext', true);
                 }
+                stageOutput = undefined;
             }
-            // ─── Phase 6: CONTINUE — dynamic next / linear next ───
-            if (dynamicNext) {
-                return this.continuationResolver.resolve(dynamicNext, node, context, breakFlag, branchPath, this.executeNode.bind(this));
+        }
+        // ─── Phase 5: CHILDREN — fork dispatch ───
+        // Re-read through the overlay: Phase 4 may have just patched dynamic
+        // children/selector for THIS visit (or an earlier visit in this run).
+        const childrenAfterStage = this.effChildren(node);
+        const hasChildrenAfterStage = Boolean(childrenAfterStage?.length);
+        if (hasChildrenAfterStage) {
+            context.addLog('totalChildren', childrenAfterStage?.length);
+            context.addLog('orderOfExecution', 'ChildrenAfterStage');
+            let nodeChildrenResults;
+            const effSelectorFn = this.effSelector(node);
+            if (effSelectorFn) {
+                nodeChildrenResults = await this.childrenExecutor.executeSelectedChildren(effSelectorFn, childrenAfterStage, stageOutput, context, branchPath, traversalContext, node.failFast);
             }
-            if (hasNext) {
-                const nextNode = originalNext;
-                // Detect loop reference nodes created by loopTo() — marked with isLoopRef flag.
-                // Route through ContinuationResolver for proper ID resolution, iteration
-                // tracking, and narrative generation.
-                const isLoopReference = nextNode.isLoopRef;
-                if (isLoopReference) {
-                    return this.continuationResolver.resolve(nextNode, node, context, breakFlag, branchPath, this.executeNode.bind(this), traversalContext);
-                }
-                this.narrativeGenerator.onNext(node.name, nextNode.name, nextNode.description, traversalContext);
-                context.addFlowDebugMessage('next', `Moving to ${nextNode.name} stage`, {
-                    targetStage: nextNode.name,
+            else {
+                const childCount = childrenAfterStage?.length ?? 0;
+                const childNames = childrenAfterStage?.map((c) => c.name).join(', ');
+                context.addFlowDebugMessage('children', `Executing all ${childCount} children in parallel: ${childNames}`, {
+                    count: childCount,
+                    targetStage: childrenAfterStage?.map((c) => c.name),
                 });
-                const nextCtx = context.createNext(branchPath, nextNode.name, nextNode.id);
-                return await this.executeNode(nextNode, nextCtx, breakFlag, branchPath);
+                // effNode: ChildrenExecutor reads node.children/node.failFast itself.
+                nodeChildrenResults = await this.childrenExecutor.executeNodeChildren(this.effNode(node), context, undefined, branchPath, traversalContext);
+            }
+            // Fork-only: return bundle
+            if (!hasNext && !dynamicNext) {
+                return nodeChildrenResults;
+            }
+            // Capture dynamic children as synthetic subflow result for UI
+            const isDynamic = context.debug?.logContext?.isDynamic;
+            if (isDynamic && childrenAfterStage && childrenAfterStage.length > 0) {
+                this.captureDynamicChildrenResult(node, childrenAfterStage, context);
             }
-            // ─── Phase 7: LEAF — no continuation ───
-            return stageOutput;
         }
-        finally {
-            this._executeDepth--;
+        // ─── Phase 6: CONTINUE — dynamic next / linear next ───
+        if (dynamicNext) {
+            const target = this.continuationResolver.resolveTarget(dynamicNext, node, context, branchPath);
+            return this.hop(target.node, target.context, branchPath);
+        }
+        if (hasNext) {
+            const nextNode = originalNext;
+            // Detect loop reference nodes created by loopTo() — marked with isLoopRef flag.
+            // Route through ContinuationResolver for proper ID resolution, iteration
+            // tracking, and narrative generation. The resolved target comes back
+            // as a hop — loop edges consume no stack, so the iteration limit
+            // (not call-stack depth) is what bounds a loop.
+            const isLoopReference = nextNode.isLoopRef;
+            if (isLoopReference) {
+                const target = this.continuationResolver.resolveTarget(nextNode, node, context, branchPath, traversalContext);
+                return this.hop(target.node, target.context, branchPath);
+            }
+            this.narrativeGenerator.onNext(node.name, nextNode.name, nextNode.description, traversalContext);
+            context.addFlowDebugMessage('next', `Moving to ${nextNode.name} stage`, {
+                targetStage: nextNode.name,
+            });
+            const nextCtx = context.createNext(branchPath, nextNode.name, nextNode.id);
+            return this.hop(nextNode, nextCtx, branchPath);
         }
+        // ─── Phase 7: LEAF — no continuation ───
+        return stageOutput;
     }
     // ─────────────────────── Private Helpers ───────────────────────
     captureDynamicChildrenResult(node, children, context) {
@@ -803,13 +934,35 @@ export class FlowchartTraverser {
             pipelineStructure: childStructure,
         });
     }
+    /**
+     * Parent-chain length of a StageContext — same value the pre-trampoline
+     * walk produced, memoized. The context tree deepens by one per executed
+     * stage along a chain, so the naive walk is O(chain length) per stage —
+     * O(n²) per run once chains reach trampoline scale. Contexts are visited
+     * parent-before-child, so the cached parent makes this O(1) amortized.
+     */
     computeContextDepth(context) {
-        let depth = 0;
-        let current = context.parent;
+        const cached = this.contextDepthCache.get(context);
+        if (cached !== undefined)
+            return cached;
+        // Walk up to the nearest cached ancestor (or the root), then fill the
+        // cache back down — iterative, so a cold deep chain can't overflow.
+        const uncached = [];
+        let depth = -1; // depth of the node ABOVE the first uncached entry
+        let current = context;
         while (current) {
-            depth++;
+            const hit = this.contextDepthCache.get(current);
+            if (hit !== undefined) {
+                depth = hit;
+                break;
+            }
+            uncached.push(current);
             current = current.parent;
         }
+        for (let i = uncached.length - 1; i >= 0; i--) {
+            depth++;
+            this.contextDepthCache.set(uncached[i], depth);
+        }
         return depth;
     }
     prefixNodeTree(node, prefix) {
@@ -864,4 +1017,4 @@ export class FlowchartTraverser {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FlowchartTraverser.js","sourceRoot":"","sources":["../../../../../src/lib/engine/traversal/FlowchartTraverser.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * FlowchartTraverser — Pre-order DFS traversal of StageNode graph.\n *\n * Unified traversal algorithm for all node shapes:\n *   const pre = await prep();\n *   const [x, y] = await Promise.all([fx(pre), fy(pre)]);\n *   return await next(x, y);\n *\n * For each node, executeNode follows 7 phases:\n *   0. CLASSIFY  — subflow detection, early delegation\n *   1. VALIDATE  — node invariants, role markers\n *   2. EXECUTE   — run stage fn, commit, break check\n *   3. DYNAMIC   — StageNode return detection, subflow auto-registration, structure updates\n *   4. CHILDREN  — fork/selector/decider dispatch\n *   5. CONTINUE  — dynamic next / linear next resolution\n *   6. LEAF      — no continuation, return output\n *\n * Break semantics: If a stage calls breakFn(), commit and STOP.\n * Patch model: Stage writes into local patch; commitPatch() after return or throw.\n */\n\nimport type { StageContext } from '../../memory/StageContext.js';\nimport { isPauseSignal } from '../../pause/types.js';\nimport type { ScopeProtectionMode } from '../../scope/protection/types.js';\nimport { extractErrorInfo } from '../errors/errorInfo.js';\nimport { isStageNodeReturn } from '../graph/StageNode.js';\nimport { ChildrenExecutor } from '../handlers/ChildrenExecutor.js';\nimport { ContinuationResolver } from '../handlers/ContinuationResolver.js';\nimport { DeciderHandler } from '../handlers/DeciderHandler.js';\nimport { NodeResolver } from '../handlers/NodeResolver.js';\nimport { RuntimeStructureManager } from '../handlers/RuntimeStructureManager.js';\nimport { SelectorHandler } from '../handlers/SelectorHandler.js';\nimport { StageRunner } from '../handlers/StageRunner.js';\nimport { SubflowExecutor } from '../handlers/SubflowExecutor.js';\nimport type { BreakFlag } from '../handlers/types.js';\nimport { FlowRecorderDispatcher } from '../narrative/FlowRecorderDispatcher.js';\nimport { NarrativeFlowRecorder } from '../narrative/NarrativeFlowRecorder.js';\nimport { NullControlFlowNarrativeGenerator } from '../narrative/NullControlFlowNarrativeGenerator.js';\nimport type { FlowRecorder, IControlFlowNarrative, TraversalContext } from '../narrative/types.js';\nimport { buildRuntimeStageId } from '../runtimeStageId.js';\nimport type {\n  HandlerDeps,\n  IExecutionRuntime,\n  ILogger,\n  NodeResultType,\n  ScopeFactory,\n  Selector,\n  SerializedPipelineStructure,\n  StageFunction,\n  StageNode,\n  StreamHandlers,\n  SubflowMountOptions,\n  SubflowResult,\n  SubflowTraverserFactory,\n  TraversalResult,\n} from '../types.js';\n\nexport interface TraverserOptions<TOut = any, TScope = any> {\n  root: StageNode<TOut, TScope>;\n  stageMap: Map<string, StageFunction<TOut, TScope>>;\n  scopeFactory: ScopeFactory<TScope>;\n  executionRuntime: IExecutionRuntime;\n  readOnlyContext?: unknown;\n  /** Execution environment — propagates to subflows automatically. */\n  executionEnv?: import('../../engine/types').ExecutionEnv;\n  throttlingErrorChecker?: (error: unknown) => boolean;\n  streamHandlers?: StreamHandlers;\n  scopeProtectionMode?: ScopeProtectionMode;\n  subflows?: Record<string, { root: StageNode<TOut, TScope> }>;\n  narrativeEnabled?: boolean;\n  buildTimeStructure?: SerializedPipelineStructure;\n  logger: ILogger;\n  signal?: AbortSignal;\n  /** Pre-configured FlowRecorders to attach when narrative is enabled. */\n  flowRecorders?: FlowRecorder[];\n  /**\n   * Pre-configured narrative generator. If provided, takes precedence over\n   * flowRecorders and narrativeEnabled. Used by the subflow traverser factory\n   * to share the parent's narrative generator with subflow traversers.\n   */\n  narrativeGenerator?: IControlFlowNarrative;\n  /**\n   * Maximum recursive executeNode depth. Defaults to FlowchartTraverser.MAX_EXECUTE_DEPTH (500).\n   * Override in tests or unusually deep pipelines.\n   */\n  maxDepth?: number;\n  /**\n   * When this traverser runs inside a subflow, set this to the subflow's ID.\n   * Propagated to TraversalContext so narrative entries carry the correct subflowId.\n   */\n  parentSubflowId?: string;\n  /** Shared execution counter from parent traverser. Subflows continue the parent's numbering. */\n  executionCounter?: { value: number };\n  /**\n   * Per-subflow scope captures from a checkpoint, on the resume path.\n   * Forwarded to `HandlerDeps.subflowStatesForResume` so SubflowExecutor\n   * can re-seed nested runtimes from pre-pause state instead of running\n   * the inputMapper. Undefined on normal `run()` paths.\n   */\n  subflowStatesForResume?: Record<string, Record<string, unknown>>;\n  /**\n   * Per-`executor.run()` identifier. Threaded into every TraversalContext\n   * this traverser produces so recorders can scope state to a single run.\n   * Subflow traversers inherit the parent's runId (the subflow is part of\n   * the same run from the consumer's POV). Required field — every event\n   * needs it. See `runner/runId.ts`.\n   */\n  runId: string;\n}\n\n/**\n * Traverser-local overlay entry for a node whose stage function returned a\n * StageNode (dynamic continuation). Holds the dynamic values that earlier\n * versions wrote DIRECTLY onto the shared built-chart node — which leaked the\n * dynamic shape into every later run of the same built chart and raced\n * concurrent executors. The overlay keeps the built graph immutable: patches\n * live in a per-traverser Map keyed by `node.id` and die with the run.\n *\n * `next` is intentionally ABSENT: a dynamic `next` only ever applies to the\n * visit that produced it (the old code wrote `node.next` and restored it\n * before anything could observe the write), so it stays a local variable in\n * `executeNode` and is routed through `ContinuationResolver` directly.\n */\nexport interface DynamicNodePatch<TOut = any, TScope = any> {\n  /**\n   * Subflow mount metadata from a dynamic-subflow return. Grouped so the\n   * merged view reproduces the old field-wise overwrite exactly — including\n   * `subflowName`/`subflowMountOptions` becoming undefined when the dynamic\n   * return omitted them.\n   */\n  subflowMeta?: {\n    isSubflowRoot: true;\n    subflowId: string;\n    subflowName: string | undefined;\n    subflowMountOptions: SubflowMountOptions | undefined;\n  };\n  /** Dynamic fork children (replaces the built node's children for this run). */\n  children?: StageNode<TOut, TScope>[];\n  /** Dynamic output-based selector accompanying dynamic children. */\n  nextNodeSelector?: Selector;\n}\n\nexport class FlowchartTraverser<TOut = any, TScope = any> {\n  private readonly root: StageNode<TOut, TScope>;\n  private stageMap: Map<string, StageFunction<TOut, TScope>>;\n  private readonly executionRuntime: IExecutionRuntime;\n  private subflows: Record<string, { root: StageNode<TOut, TScope> }>;\n  private readonly logger: ILogger;\n  private readonly signal?: AbortSignal;\n  private readonly parentSubflowId?: string;\n  /** Frozen value passed via `run({input})`. Surfaced on `onRunStart` at the\n   *  top-level traversal so consumers (e.g. `InOutRecorder`) can bracket\n   *  the run with the same payload shape that subflows already have. */\n  private readonly readOnlyContext?: unknown;\n  /** Per-`executor.run()` identifier. Stamped onto every TraversalContext.\n   *  Inherited by subflow traversers so all events of one run share one runId. */\n  private readonly runId: string;\n\n  // Handler modules\n  private readonly nodeResolver: NodeResolver<TOut, TScope>;\n  private readonly childrenExecutor: ChildrenExecutor<TOut, TScope>;\n  private readonly subflowExecutor: SubflowExecutor<TOut, TScope>;\n  private readonly stageRunner: StageRunner<TOut, TScope>;\n  private readonly continuationResolver: ContinuationResolver<TOut, TScope>;\n  private readonly deciderHandler: DeciderHandler<TOut, TScope>;\n  private readonly selectorHandler: SelectorHandler<TOut, TScope>;\n  private readonly structureManager: RuntimeStructureManager;\n  private readonly narrativeGenerator: IControlFlowNarrative;\n  private readonly flowRecorderDispatcher: FlowRecorderDispatcher | undefined;\n\n  // Execution state\n  private subflowResults: Map<string, SubflowResult> = new Map();\n\n  /**\n   * Per-traverser set of lazy subflow IDs that have been resolved by THIS run.\n   * Used instead of writing `node.subflowResolver = undefined` back to the shared\n   * StageNode graph — avoids a race where a concurrent traverser clears the shared\n   * resolver before another traverser has finished using it.\n   */\n  private readonly resolvedLazySubflows = new Set<string>();\n\n  /**\n   * Per-traverser overlay of dynamic StageNode returns, keyed by `node.id`.\n   * Phase 4 writes patches HERE instead of mutating the shared built-chart\n   * node objects (same isolation convention as `resolvedLazySubflows`).\n   * All engine reads of the patched fields go through the `eff*` accessors\n   * below. The map dies with the traverser — one run, one overlay — so a\n   * fresh executor over the same built chart always sees the original graph.\n   *\n   * Keyed by the node OBJECT (WeakMap), not `node.id`: a dynamic child that\n   * reuses a built node's id must NOT make the built node inherit the patch\n   * (id-keyed lookup caused phantom double-execution). `patchCount` is the\n   * fast-path check — WeakMap has no `size`.\n   */\n  private readonly dynamicPatches = new WeakMap<StageNode<TOut, TScope>, DynamicNodePatch<TOut, TScope>>();\n  private patchCount = 0;\n\n  /**\n   * Recursion depth counter for executeNode.\n   * Each recursive executeNode call increments this; decrements on exit (try/finally).\n   * Prevents call-stack overflow on infinite loops or excessively deep stage chains.\n   */\n  private _executeDepth = 0;\n\n  /**\n   * Shared mutable execution counter — monotonic, incremented per stage execution.\n   * Shared with child traversers (subflows) so indices are globally unique within a run.\n   */\n  private readonly _executionCounter: { value: number };\n\n  /**\n   * Per-instance maximum depth (set from TraverserOptions.maxDepth or the class default).\n   */\n  private readonly _maxDepth: number;\n\n  /**\n   * Default maximum recursive executeNode depth before an error is thrown.\n   * 500 comfortably covers any realistic pipeline depth (including deeply nested\n   * subflows) while preventing call-stack overflow (~10 000 frames in V8).\n   *\n   * **Note on counting:** the counter increments once per `executeNode` call, not once per\n   * logical user stage. Subflow root entry and subflow continuation after return each cost\n   * one tick. For pipelines with many nested subflows, budget roughly 2 × (avg stages per\n   * subflow) of headroom when computing a custom `maxDepth` via `RunOptions.maxDepth`.\n   *\n   * **Note on loops:** for `loopTo()` pipelines, this depth guard and `ContinuationResolver`'s\n   * iteration limit are independent — the lower one fires first. The default depth guard (500)\n   * fires before the default iteration limit (1000) for loop-heavy pipelines.\n   *\n   * @remarks Not safe for concurrent `.execute()` calls on the same instance — concurrent\n   * executions race on `_executeDepth`. Use a separate `FlowchartTraverser` per concurrent\n   * execution. `FlowChartExecutor.run()` always creates a fresh traverser per call.\n   */\n  static readonly MAX_EXECUTE_DEPTH = 500;\n\n  constructor(opts: TraverserOptions<TOut, TScope>) {\n    const maxDepth = opts.maxDepth ?? FlowchartTraverser.MAX_EXECUTE_DEPTH;\n    if (maxDepth < 1) throw new Error('FlowchartTraverser: maxDepth must be >= 1');\n    this._maxDepth = maxDepth;\n    this._executionCounter = opts.executionCounter ?? { value: 0 };\n    this.root = opts.root;\n    // Shallow-copy stageMap and subflows so that lazy-resolution mutations\n    // (prefixed entries added during execution) stay scoped to THIS traverser\n    // and do not escape to the shared FlowChart object. Without the copy,\n    // concurrent FlowChartExecutor runs sharing the same FlowChart would race\n    // on these two mutable dictionaries.\n    this.stageMap = new Map(opts.stageMap);\n    this.executionRuntime = opts.executionRuntime;\n    this.subflows = opts.subflows ? { ...opts.subflows } : {};\n    this.logger = opts.logger;\n    this.signal = opts.signal;\n    this.parentSubflowId = opts.parentSubflowId;\n    this.readOnlyContext = opts.readOnlyContext;\n    this.runId = opts.runId;\n\n    // Structure manager (deep-clones build-time structure)\n    this.structureManager = new RuntimeStructureManager();\n    this.structureManager.init(opts.buildTimeStructure);\n\n    // Narrative generator\n    // Priority: explicit narrativeGenerator > flowRecorders > default NarrativeFlowRecorder > null.\n    // Subflow traversers receive the parent's narrativeGenerator so all events flow to one place.\n    if (opts.narrativeGenerator) {\n      this.narrativeGenerator = opts.narrativeGenerator;\n    } else if (opts.narrativeEnabled) {\n      const dispatcher = new FlowRecorderDispatcher();\n      this.flowRecorderDispatcher = dispatcher;\n\n      // If custom FlowRecorders are provided, use them; otherwise attach default NarrativeFlowRecorder\n      if (opts.flowRecorders && opts.flowRecorders.length > 0) {\n        for (const recorder of opts.flowRecorders) {\n          dispatcher.attach(recorder);\n        }\n      } else {\n        dispatcher.attach(new NarrativeFlowRecorder());\n      }\n\n      this.narrativeGenerator = dispatcher;\n    } else {\n      this.narrativeGenerator = new NullControlFlowNarrativeGenerator();\n    }\n\n    // Build shared deps bag\n    const deps = this.createDeps(opts);\n\n    // Build O(1) node ID map from the root graph (avoids repeated DFS on every loopTo())\n    const nodeIdMap = this.buildNodeIdMap(opts.root);\n\n    // Initialize handler modules.\n    // NodeResolver's DFS fallback resolves loop targets against the LIVE\n    // runtime shape, so it reads children through the dynamic-patch overlay\n    // (a loop can target a node added by a dynamic StageNode return).\n    this.nodeResolver = new NodeResolver(deps, nodeIdMap, (n) => this.effChildren(n));\n    this.childrenExecutor = new ChildrenExecutor(deps, this.executeNode.bind(this));\n    this.stageRunner = new StageRunner(deps);\n    this.continuationResolver = new ContinuationResolver(deps, this.nodeResolver, (nodeId, count) =>\n      this.structureManager.updateIterationCount(nodeId, count),\n    );\n    this.deciderHandler = new DeciderHandler(deps);\n    this.selectorHandler = new SelectorHandler(deps, this.childrenExecutor);\n    this.subflowExecutor = new SubflowExecutor(deps, this.createSubflowTraverserFactory(opts));\n  }\n\n  /**\n   * Create a factory that produces FlowchartTraverser instances for subflow execution.\n   * Captures parent config in closure — SubflowExecutor provides subflow-specific overrides.\n   * Each subflow gets a full traverser with all 7 phases (deciders, selectors, loops, etc.).\n   */\n  private createSubflowTraverserFactory(\n    parentOpts: TraverserOptions<TOut, TScope>,\n  ): SubflowTraverserFactory<TOut, TScope> {\n    // Capture references to mutable state — factory reads the CURRENT state when called,\n    // not the state at factory creation time. This is correct because lazy subflow resolution\n    // may add entries to stageMap/subflows before a nested subflow is encountered.\n    const parentStageMap = this.stageMap;\n    const parentSubflows = this.subflows;\n    const narrativeGenerator = this.narrativeGenerator;\n\n    return (subflowOpts) => {\n      const traverser = new FlowchartTraverser<TOut, TScope>({\n        root: subflowOpts.root,\n        stageMap: parentStageMap, // Constructor shallow-copies this\n        scopeFactory: parentOpts.scopeFactory,\n        executionRuntime: subflowOpts.executionRuntime,\n        readOnlyContext: subflowOpts.readOnlyContext,\n        executionEnv: parentOpts.executionEnv,\n        throttlingErrorChecker: parentOpts.throttlingErrorChecker,\n        streamHandlers: parentOpts.streamHandlers,\n        scopeProtectionMode: parentOpts.scopeProtectionMode,\n        subflows: parentSubflows, // Constructor shallow-copies this\n        narrativeGenerator, // Share parent's — all events flow to one place\n        logger: parentOpts.logger,\n        signal: parentOpts.signal,\n        maxDepth: this._maxDepth,\n        parentSubflowId: subflowOpts.subflowId,\n        executionCounter: this._executionCounter, // Share counter — subflow continues global numbering\n        runId: this.runId, // Subflow inherits parent's runId — same logical run\n        // Forward the resume-only subflow scope captures so nested\n        // SubflowExecutors can re-seed deeper-nested runtimes (e.g.\n        // Sequence(Agent(...)) where the inner Agent subflow paused).\n        ...(parentOpts.subflowStatesForResume && {\n          subflowStatesForResume: parentOpts.subflowStatesForResume,\n        }),\n      });\n\n      return {\n        execute: () => traverser.execute(),\n        getSubflowResults: () => traverser.getSubflowResults(),\n        getBreakState: () => traverser.getBreakState(),\n      };\n    };\n  }\n\n  private createDeps(opts: TraverserOptions<TOut, TScope>): HandlerDeps<TOut, TScope> {\n    return {\n      stageMap: this.stageMap,\n      root: this.root,\n      executionRuntime: this.executionRuntime,\n      scopeFactory: opts.scopeFactory,\n      subflows: this.subflows,\n      throttlingErrorChecker: opts.throttlingErrorChecker,\n      streamHandlers: opts.streamHandlers,\n      scopeProtectionMode: opts.scopeProtectionMode ?? 'error',\n      readOnlyContext: opts.readOnlyContext,\n      executionEnv: opts.executionEnv,\n      narrativeGenerator: this.narrativeGenerator,\n      logger: this.logger,\n      signal: opts.signal,\n      ...(opts.subflowStatesForResume && {\n        subflowStatesForResume: opts.subflowStatesForResume,\n      }),\n    };\n  }\n\n  // ─────────────────────── Public API ───────────────────────\n\n  /**\n   * Holds the top-level break flag for the duration of `execute()`. Kept as\n   * a field (not a local) so `getBreakState()` can surface the final state\n   * for callers like `SubflowExecutor` that implement `propagateBreak`.\n   */\n  private _topBreakFlag: { shouldBreak: boolean; reason?: string } = { shouldBreak: false };\n\n  async execute(branchPath?: string): Promise<TraversalResult> {\n    const context = this.executionRuntime.rootStageContext;\n    this._topBreakFlag = { shouldBreak: false };\n\n    // Fire onRunStart ONLY at the top-level traversal — subflow traversers\n    // already produce onSubflowEntry/onSubflowExit pairs, so emitting run\n    // events for them would double-bracket the boundary stream. The\n    // top-level traverser is the one without a parentSubflowId.\n    const isTopLevel = this.parentSubflowId === undefined;\n    // Synthetic TraversalContext for run.entry / run.exit. Fields use\n    // root-stage defaults (stageId='__root__', runtimeStageId='__root__#0',\n    // depth 0) so the runId is reliably available on run events without\n    // forcing recorders to handle `traversalContext === undefined`.\n    const rootContext: TraversalContext = {\n      runId: this.runId,\n      stageId: '__root__',\n      runtimeStageId: '__root__#0',\n      stageName: '__root__',\n      depth: 0,\n    };\n    if (isTopLevel) {\n      // `readOnlyContext` is the engine's view of `run({input})` — passed\n      // through from `FlowChartExecutor.run()` as the validated input.\n      this.narrativeGenerator.onRunStart(this.readOnlyContext, rootContext);\n    }\n\n    // Top-level runs close their boundary SYMMETRICALLY: every onRunStart\n    // is followed by exactly one onRunEnd (clean) or onRunFailed (error).\n    // Without the catch, a thrown run fired onRunStart then nothing — a\n    // monitor couldn't tell \"still running\" from \"crashed.\" Pause is NOT\n    // an error (it's expected suspension), so it skips onRunFailed and\n    // re-throws untouched. The stage-level catch already recorded the\n    // failing stage (onError + commit); this adds the run-level terminal\n    // signal. The error still propagates — this is observation, not\n    // recovery. Subflow traversers don't fire run events; their errors\n    // bubble up and surface here at the top level.\n    if (!isTopLevel) {\n      return this.executeNode(this.root, context, this._topBreakFlag, branchPath ?? '');\n    }\n    let result: TraversalResult;\n    try {\n      result = await this.executeNode(this.root, context, this._topBreakFlag, branchPath ?? '');\n    } catch (error: unknown) {\n      if (!isPauseSignal(error)) {\n        this.narrativeGenerator.onRunFailed(extractErrorInfo(error), rootContext);\n      }\n      throw error;\n    }\n    this.narrativeGenerator.onRunEnd(result, rootContext);\n    return result;\n  }\n\n  /**\n   * Break state captured at the top-level of the most recent `execute()`.\n   * `shouldBreak` is true when a stage called `scope.$break(reason)`; the\n   * optional `reason` carries the string passed to `$break`.\n   *\n   * Used by `SubflowExecutor` to propagate an inner subflow's break up to\n   * the parent traverser when the mount sets `propagateBreak: true`.\n   */\n  getBreakState(): { shouldBreak: boolean; reason?: string } {\n    return { ...this._topBreakFlag };\n  }\n\n  getRuntimeStructure(): SerializedPipelineStructure | undefined {\n    return this.structureManager.getStructure();\n  }\n\n  getSnapshot(options?: { redact?: boolean }) {\n    return this.executionRuntime.getSnapshot(options);\n  }\n\n  getRuntime() {\n    return this.executionRuntime;\n  }\n\n  setRootObject(path: string[], key: string, value: unknown) {\n    this.executionRuntime.setRootObject(path, key, value);\n  }\n\n  getBranchIds() {\n    return this.executionRuntime.getPipelines();\n  }\n\n  getRuntimeRoot(): StageNode {\n    return this.root;\n  }\n\n  getSubflowResults(): Map<string, SubflowResult> {\n    return this.subflowResults;\n  }\n\n  getNarrative(): string[] {\n    return this.narrativeGenerator.getSentences();\n  }\n\n  /** Returns the FlowRecorderDispatcher, or undefined if narrative is disabled. */\n  getFlowRecorderDispatcher(): FlowRecorderDispatcher | undefined {\n    return this.flowRecorderDispatcher;\n  }\n\n  // ─────────────────────── Core Traversal ───────────────────────\n\n  /**\n   * Build an O(1) ID→node map from the root graph.\n   * Used by NodeResolver to avoid repeated DFS on every loopTo() call.\n   * Depth-guarded at MAX_EXECUTE_DEPTH to prevent infinite recursion on cyclic graphs.\n   * Dynamic subflows and lazy-resolved nodes are added to stageMap at runtime but not to this map —\n   * those use the DFS fallback in NodeResolver.\n   */\n  private buildNodeIdMap(root: StageNode<TOut, TScope>): Map<string, StageNode<TOut, TScope>> {\n    const map = new Map<string, StageNode<TOut, TScope>>();\n    const visit = (node: StageNode<TOut, TScope>, depth: number): void => {\n      if (depth > FlowchartTraverser.MAX_EXECUTE_DEPTH) return;\n      if (map.has(node.id)) return; // already visited (avoids infinite loops on cyclic refs)\n      map.set(node.id, node);\n      if (node.children) {\n        for (const child of node.children) visit(child, depth + 1);\n      }\n      if (node.next) visit(node.next, depth + 1);\n    };\n    visit(root, 0);\n    return map;\n  }\n\n  private getStageFn(node: StageNode<TOut, TScope>): StageFunction<TOut, TScope> | undefined {\n    if (typeof node.fn === 'function') return node.fn as StageFunction<TOut, TScope>;\n    // Primary: look up by id (stable identifier, keyed by FlowChartBuilder)\n    const byId = this.stageMap.get(node.id);\n    if (byId !== undefined) return byId;\n    // Fallback: look up by name (supports hand-crafted stageMaps in tests and advanced use)\n    return this.stageMap.get(node.name);\n  }\n\n  // ─────────────── Dynamic-patch overlay accessors ───────────────\n  //\n  // Every engine read of a field that Phase 4 can patch (children,\n  // nextNodeSelector, subflow meta) goes through these. Fast path: charts\n  // with no dynamic returns never allocate and pay one `size === 0` check.\n\n  private getPatch(node: StageNode<TOut, TScope>): DynamicNodePatch<TOut, TScope> | undefined {\n    if (this.patchCount === 0) return undefined;\n    return this.dynamicPatches.get(node);\n  }\n\n  private getOrCreatePatch(node: StageNode<TOut, TScope>): DynamicNodePatch<TOut, TScope> {\n    let patch = this.dynamicPatches.get(node);\n    if (!patch) {\n      patch = {};\n      this.dynamicPatches.set(node, patch);\n      this.patchCount++;\n    }\n    return patch;\n  }\n\n  /** Effective children: dynamic patch first, then the built node's children. */\n  private effChildren(node: StageNode<TOut, TScope>): StageNode<TOut, TScope>[] | undefined {\n    return this.getPatch(node)?.children ?? node.children;\n  }\n\n  /** Effective output-based selector: dynamic patch first, then the built node's. */\n  private effSelector(node: StageNode<TOut, TScope>): Selector | undefined {\n    return this.getPatch(node)?.nextNodeSelector ?? node.nextNodeSelector;\n  }\n\n  /** Effective subflow-root marker (true when a dynamic subflow was patched on). */\n  private effIsSubflowRoot(node: StageNode<TOut, TScope>): boolean | undefined {\n    const meta = this.getPatch(node)?.subflowMeta;\n    return meta ? true : node.isSubflowRoot;\n  }\n\n  /** Effective subflow id (patched verbatim by a dynamic subflow return). */\n  private effSubflowId(node: StageNode<TOut, TScope>): string | undefined {\n    const meta = this.getPatch(node)?.subflowMeta;\n    return meta ? meta.subflowId : node.subflowId;\n  }\n\n  /**\n   * Materialize the effective view of a node — field-identical to what the\n   * pre-overlay code produced by mutating the shared node. Used where a node\n   * is handed to a helper executor (NodeResolver / SubflowExecutor /\n   * ChildrenExecutor) so helpers never read stale built fields. Returns the\n   * node itself (no allocation) when it carries no patch.\n   */\n  private effNode(node: StageNode<TOut, TScope>): StageNode<TOut, TScope> {\n    const patch = this.getPatch(node);\n    if (!patch) return node;\n    const merged: StageNode<TOut, TScope> = { ...node };\n    if (patch.subflowMeta) {\n      merged.isSubflowRoot = true;\n      merged.subflowId = patch.subflowMeta.subflowId;\n      merged.subflowName = patch.subflowMeta.subflowName;\n      merged.subflowMountOptions = patch.subflowMeta.subflowMountOptions;\n    }\n    if (patch.children) merged.children = patch.children;\n    if (patch.nextNodeSelector) merged.nextNodeSelector = patch.nextNodeSelector;\n    return merged;\n  }\n\n  private async executeStage(\n    node: StageNode<TOut, TScope>,\n    stageFunc: StageFunction<TOut, TScope>,\n    context: StageContext,\n    breakFn: () => void,\n  ) {\n    // runtimeStageId is assigned in executeNode() before traversalContext creation,\n    // ensuring scope events and flow events use the same value.\n    return this.stageRunner.run(node, stageFunc, context, breakFn);\n  }\n\n  /**\n   * Pre-order DFS traversal — the core algorithm.\n   * Each call processes one node through all 7 phases.\n   */\n  private async executeNode(\n    node: StageNode<TOut, TScope>,\n    context: StageContext,\n    breakFlag: BreakFlag,\n    branchPath?: string,\n  ): Promise<any> {\n    // ─── Recursion depth guard ───\n    // Each `await executeNode(...)` keeps the calling frame on the stack.\n    // Without a cap, an infinite loop or an excessively deep stage chain will\n    // eventually overflow the V8 call stack (~10 000 frames) with a cryptic\n    // \"Maximum call stack size exceeded\" error.  We fail early with a clear\n    // message so users can diagnose the cause (infinite loop, missing break, etc.).\n    // The increment is inside `try` so `finally` always decrements — no fragile\n    // gap between check and try entry.\n    try {\n      if (++this._executeDepth > this._maxDepth) {\n        throw new Error(\n          `FlowchartTraverser: maximum traversal depth exceeded (${this._maxDepth}). ` +\n            'Check for infinite loops or missing break conditions in your flowchart. ' +\n            `Last stage: '${node.name}'. ` +\n            'For loopTo() pipelines, consider adding a break condition or using RunOptions.maxDepth to raise the limit.',\n        );\n      }\n\n      // Attach builder metadata to context for snapshot enrichment.\n      // Subflow meta reads go through the dynamic-patch overlay — a node\n      // patched by a dynamic-subflow return re-enters executeNode and must\n      // classify as a subflow without the shared node ever being mutated.\n      if (node.description) context.description = node.description;\n      const effSubflowId = this.effSubflowId(node);\n      if (this.effIsSubflowRoot(node) && effSubflowId) context.subflowId = effSubflowId;\n\n      // Assign runtimeStageId BEFORE traversalContext creation — ensures scope events\n      // (buffered by runtimeStageId) and flow events (flushed by traversalContext.runtimeStageId)\n      // use the same value. Must happen before executeStage AND before traversalContext.\n      const idx = this._executionCounter.value++;\n      context.runtimeStageId = buildRuntimeStageId(node.id, idx);\n\n      // Build traversal context for recorder events — created once per stage, shared by all events\n      const traversalContext: TraversalContext = {\n        runId: this.runId,\n        stageId: node.id ?? context.stageId,\n        runtimeStageId: context.runtimeStageId,\n        stageName: node.name,\n        parentStageId: context.parent?.stageId,\n        subflowId: context.subflowId ?? this.parentSubflowId,\n        subflowPath: branchPath || undefined,\n        depth: this.computeContextDepth(context),\n      };\n\n      // ─── Phase 0a: LAZY RESOLVE — deferred subflow resolution ───\n      // Guard uses the per-traverser resolvedLazySubflows set (not the shared node) so\n      // concurrent traversers do not race on node.subflowResolver or clear it for each other.\n      if (node.isSubflowRoot && node.subflowResolver && !this.resolvedLazySubflows.has(node.subflowId!)) {\n        const resolved = node.subflowResolver();\n        const prefixedRoot = this.prefixNodeTree(resolved.root as StageNode<TOut, TScope>, node.subflowId!);\n\n        // Register the resolved subflow (same path as eager registration)\n        this.subflows[node.subflowId!] = { root: prefixedRoot };\n\n        // Merge stageMap entries\n        for (const [key, fn] of resolved.stageMap) {\n          const prefixedKey = `${node.subflowId}/${key}`;\n          if (!this.stageMap.has(prefixedKey)) {\n            this.stageMap.set(prefixedKey, fn as StageFunction<TOut, TScope>);\n          }\n        }\n\n        // Merge nested subflows\n        if (resolved.subflows) {\n          for (const [key, def] of Object.entries(resolved.subflows)) {\n            const prefixedKey = `${node.subflowId}/${key}`;\n            if (!this.subflows[prefixedKey]) {\n              this.subflows[prefixedKey] = def as { root: StageNode<TOut, TScope> };\n            }\n          }\n        }\n\n        // Update runtime structure with the now-resolved spec\n        this.structureManager.updateDynamicSubflow(\n          node.id,\n          node.subflowId!,\n          node.subflowName,\n          resolved.buildTimeStructure,\n        );\n\n        // Mark as resolved for THIS traverser — per-traverser set prevents re-entry\n        // without mutating the shared StageNode graph (which would race concurrent traversers).\n        this.resolvedLazySubflows.add(node.subflowId!);\n      }\n\n      // ─── Phase 0: CLASSIFY — subflow detection ───\n      if (this.effIsSubflowRoot(node) && effSubflowId) {\n        // Hand helpers the EFFECTIVE node view (built fields + dynamic patch)\n        // so SubflowExecutor/NodeResolver never read stale built fields.\n        const mountNode = this.effNode(node);\n        const resolvedNode = this.nodeResolver.resolveSubflowReference(mountNode);\n\n        const subflowOutput = await this.subflowExecutor.executeSubflow(\n          resolvedNode,\n          context,\n          breakFlag,\n          branchPath,\n          this.subflowResults,\n          traversalContext,\n        );\n\n        const isReferenceBasedSubflow = resolvedNode !== mountNode;\n        const hasChildren = Boolean(mountNode.children && mountNode.children.length > 0);\n        const shouldExecuteContinuation = isReferenceBasedSubflow || hasChildren;\n\n        // ─── Break-flag check AFTER subflow returns ───\n        // If the subflow was mounted with `propagateBreak: true` and broke\n        // internally, `SubflowExecutor` has already flipped our breakFlag.\n        // Stop the outer traversal here — do not run the next linear stage.\n        if (breakFlag.shouldBreak) {\n          return subflowOutput;\n        }\n\n        if (node.next && shouldExecuteContinuation) {\n          const nextCtx = context.createNext(branchPath as string, node.next.name, node.next.id);\n          return await this.executeNode(node.next, nextCtx, breakFlag, branchPath);\n        }\n\n        return subflowOutput;\n      }\n\n      const stageFunc = this.getStageFn(node);\n      const hasStageFunction = Boolean(stageFunc);\n      const isScopeBasedDecider = Boolean(node.deciderFn);\n      const isScopeBasedSelector = Boolean(node.selectorFn);\n      const isDeciderNode = isScopeBasedDecider;\n      const hasChildren = Boolean(this.effChildren(node)?.length);\n      // `next` is never overlaid — a dynamic next applies only to the visit\n      // that produced it (handled via the `dynamicNext` local below), so the\n      // built chart's next is always the correct continuation here.\n      const hasNext = Boolean(node.next);\n      const originalNext = node.next;\n\n      // ─── Phase 1: VALIDATE — node invariants ───\n      if (!hasStageFunction && !isDeciderNode && !isScopeBasedSelector && !hasChildren) {\n        const errorMessage = `Node '${node.name}' must define: embedded fn OR a stageMap entry OR have children/decider`;\n        this.logger.error(`Error in pipeline (${branchPath}) stage [${node.name}]:`, { error: errorMessage });\n        throw new Error(errorMessage);\n      }\n      if (isDeciderNode && !hasChildren) {\n        const errorMessage = 'Decider node needs to have children to execute';\n        this.logger.error(`Error in pipeline (${branchPath}) stage [${node.name}]:`, { error: errorMessage });\n        throw new Error(errorMessage);\n      }\n      if (isScopeBasedSelector && !hasChildren) {\n        const errorMessage = 'Selector node needs to have children to execute';\n        this.logger.error(`Error in pipeline (${branchPath}) stage [${node.name}]:`, { error: errorMessage });\n        throw new Error(errorMessage);\n      }\n\n      // Role markers for debug panels\n      if (!hasStageFunction) {\n        if (isDeciderNode) context.setAsDecider();\n        else if (hasChildren) context.setAsFork();\n      }\n\n      // Break handler wired to the scope. Captures the optional reason\n      // passed via `scope.$break(reason)` and parks it on the breakFlag so\n      // downstream code (FlowRecorder.onBreak, subflow propagation) can\n      // surface it. A second $break call in the same stage keeps the FIRST\n      // reason — first-break-wins — matching the \"execution stopped\" story.\n      const breakFn = (reason?: string) => {\n        breakFlag.shouldBreak = true;\n        if (reason !== undefined && breakFlag.reason === undefined) {\n          breakFlag.reason = reason;\n        }\n      };\n\n      // ─── Phase 2a: SELECTOR — scope-based multi-choice ───\n      if (isScopeBasedSelector) {\n        const selectorResult = await this.selectorHandler.handleScopeBased(\n          node,\n          stageFunc!,\n          context,\n          breakFlag,\n          branchPath,\n          this.executeStage.bind(this),\n          this.executeNode.bind(this),\n          traversalContext,\n        );\n\n        if (hasNext) {\n          const nextCtx = context.createNext(branchPath as string, node.next!.name, node.next!.id);\n          return await this.executeNode(node.next!, nextCtx, breakFlag, branchPath);\n        }\n        return selectorResult;\n      }\n\n      // ─── Phase 2b: DECIDER — scope-based single-choice conditional branch ───\n      if (isDeciderNode) {\n        const deciderResult = await this.deciderHandler.handleScopeBased(\n          node,\n          stageFunc!,\n          context,\n          breakFlag,\n          branchPath,\n          this.executeStage.bind(this),\n          this.executeNode.bind(this),\n          traversalContext,\n        );\n\n        // After branch execution, follow decider's own next (e.g., loopTo target)\n        if (hasNext && !breakFlag.shouldBreak) {\n          const nextNode = originalNext!;\n          // Use the isLoopRef flag set by loopTo() — do not rely on stageMap absence,\n          // since id-keyed stageMaps would otherwise cause loop targets to be executed directly.\n          const isLoopRef =\n            nextNode.isLoopRef === true ||\n            (!this.getStageFn(nextNode) &&\n              !this.effChildren(nextNode)?.length &&\n              !nextNode.deciderFn &&\n              !nextNode.selectorFn &&\n              !this.effIsSubflowRoot(nextNode));\n\n          if (isLoopRef) {\n            return this.continuationResolver.resolve(\n              nextNode,\n              node,\n              context,\n              breakFlag,\n              branchPath,\n              this.executeNode.bind(this),\n            );\n          }\n\n          this.narrativeGenerator.onNext(node.name, nextNode.name, nextNode.description, traversalContext);\n          const nextCtx = context.createNext(branchPath as string, nextNode.name, nextNode.id);\n          return await this.executeNode(nextNode, nextCtx, breakFlag, branchPath);\n        }\n\n        return deciderResult;\n      }\n\n      // ─── Abort check — cooperative cancellation ───\n      if (this.signal?.aborted) {\n        const reason =\n          this.signal.reason instanceof Error ? this.signal.reason : new Error(this.signal.reason ?? 'Aborted');\n        throw reason;\n      }\n\n      // ─── Phase 3: EXECUTE — run stage function ───\n      let stageOutput: TOut | undefined;\n      let dynamicNext: StageNode<TOut, TScope> | undefined;\n\n      if (stageFunc) {\n        try {\n          stageOutput = await this.executeStage(node, stageFunc, context, breakFn);\n        } catch (error: any) {\n          // PauseSignal is expected control flow, not an error — fire narrative, commit, re-throw.\n          if (isPauseSignal(error)) {\n            context.commit();\n            this.narrativeGenerator.onPause(node.name, node.id, error.pauseData, error.subflowPath, traversalContext);\n            throw error;\n          }\n          context.commit();\n          this.narrativeGenerator.onError(node.name, error.toString(), error, traversalContext);\n          this.logger.error(`Error in pipeline (${branchPath}) stage [${node.name}]:`, { error });\n          context.addError('stageExecutionError', error.toString());\n          throw error;\n        }\n        context.commit();\n        this.narrativeGenerator.onStageExecuted(node.name, node.description, traversalContext, 'linear');\n\n        if (breakFlag.shouldBreak) {\n          // Forward the optional reason captured on breakFlag — set by the\n          // stage's $break(reason) call OR by a subflow's propagateBreak.\n          this.narrativeGenerator.onBreak(node.name, traversalContext, breakFlag.reason);\n          return stageOutput;\n        }\n\n        // ─── Phase 4: DYNAMIC — StageNode return detection ───\n        if (stageOutput && typeof stageOutput === 'object' && isStageNodeReturn(stageOutput)) {\n          const dynamicNode = stageOutput as StageNode<TOut, TScope>;\n          context.addLog('isDynamic', true);\n          context.addLog('dynamicPattern', 'StageNodeReturn');\n\n          // Dynamic subflow auto-registration. The subflow meta lands in the\n          // traverser-local overlay (NOT on the shared node); the immediate\n          // executeNode re-entry sees it through the eff* accessors and\n          // classifies the node as a subflow mount in Phase 0.\n          if (dynamicNode.isSubflowRoot && dynamicNode.subflowDef && dynamicNode.subflowId) {\n            context.addLog('dynamicPattern', 'dynamicSubflow');\n            context.addLog('dynamicSubflowId', dynamicNode.subflowId);\n\n            this.autoRegisterSubflowDef(dynamicNode.subflowId, dynamicNode.subflowDef, node.id);\n\n            this.getOrCreatePatch(node).subflowMeta = {\n              isSubflowRoot: true,\n              subflowId: dynamicNode.subflowId,\n              subflowName: dynamicNode.subflowName,\n              subflowMountOptions: dynamicNode.subflowMountOptions,\n            };\n\n            this.structureManager.updateDynamicSubflow(\n              node.id,\n              dynamicNode.subflowId!,\n              dynamicNode.subflowName,\n              dynamicNode.subflowDef?.buildTimeStructure,\n            );\n\n            return await this.executeNode(node, context, breakFlag, branchPath);\n          }\n\n          // Check children for subflowDef\n          if (dynamicNode.children) {\n            for (const child of dynamicNode.children) {\n              if (child.isSubflowRoot && child.subflowDef && child.subflowId) {\n                this.autoRegisterSubflowDef(child.subflowId, child.subflowDef, child.id);\n                this.structureManager.updateDynamicSubflow(\n                  child.id,\n                  child.subflowId!,\n                  child.subflowName,\n                  child.subflowDef?.buildTimeStructure,\n                );\n              }\n            }\n          }\n\n          // Dynamic children (fork pattern) — patched into the overlay;\n          // Phase 5 below reads them back through effChildren/effSelector.\n          if (dynamicNode.children && dynamicNode.children.length > 0) {\n            this.getOrCreatePatch(node).children = dynamicNode.children;\n            context.addLog('dynamicChildCount', dynamicNode.children.length);\n            context.addLog(\n              'dynamicChildIds',\n              dynamicNode.children.map((c) => c.id),\n            );\n\n            this.structureManager.updateDynamicChildren(\n              node.id,\n              dynamicNode.children,\n              Boolean(dynamicNode.nextNodeSelector),\n              Boolean(dynamicNode.deciderFn),\n            );\n\n            if (typeof dynamicNode.nextNodeSelector === 'function') {\n              this.getOrCreatePatch(node).nextNodeSelector = dynamicNode.nextNodeSelector;\n              context.addLog('hasSelector', true);\n            }\n          }\n\n          // Dynamic next (linear continuation) — stays a LOCAL: it applies\n          // only to this visit (Phase 6 routes it through the\n          // ContinuationResolver), so the shared node's next is never touched\n          // and a loop revisit naturally sees the built continuation.\n          if (dynamicNode.next) {\n            dynamicNext = dynamicNode.next;\n            this.structureManager.updateDynamicNext(node.id, dynamicNode.next);\n            context.addLog('hasDynamicNext', true);\n          }\n\n          stageOutput = undefined;\n        }\n      }\n\n      // ─── Phase 5: CHILDREN — fork dispatch ───\n      // Re-read through the overlay: Phase 4 may have just patched dynamic\n      // children/selector for THIS visit (or an earlier visit in this run).\n      const childrenAfterStage = this.effChildren(node);\n      const hasChildrenAfterStage = Boolean(childrenAfterStage?.length);\n\n      if (hasChildrenAfterStage) {\n        context.addLog('totalChildren', childrenAfterStage?.length);\n        context.addLog('orderOfExecution', 'ChildrenAfterStage');\n\n        let nodeChildrenResults: Record<string, NodeResultType>;\n\n        const effSelectorFn = this.effSelector(node);\n        if (effSelectorFn) {\n          nodeChildrenResults = await this.childrenExecutor.executeSelectedChildren(\n            effSelectorFn,\n            childrenAfterStage!,\n            stageOutput,\n            context,\n            branchPath as string,\n            traversalContext,\n            node.failFast,\n          );\n        } else {\n          const childCount = childrenAfterStage?.length ?? 0;\n          const childNames = childrenAfterStage?.map((c) => c.name).join(', ');\n          context.addFlowDebugMessage('children', `Executing all ${childCount} children in parallel: ${childNames}`, {\n            count: childCount,\n            targetStage: childrenAfterStage?.map((c) => c.name),\n          });\n\n          // effNode: ChildrenExecutor reads node.children/node.failFast itself.\n          nodeChildrenResults = await this.childrenExecutor.executeNodeChildren(\n            this.effNode(node),\n            context,\n            undefined,\n            branchPath,\n            traversalContext,\n          );\n        }\n\n        // Fork-only: return bundle\n        if (!hasNext && !dynamicNext) {\n          return nodeChildrenResults!;\n        }\n\n        // Capture dynamic children as synthetic subflow result for UI\n        const isDynamic = context.debug?.logContext?.isDynamic;\n        if (isDynamic && childrenAfterStage && childrenAfterStage.length > 0) {\n          this.captureDynamicChildrenResult(node, childrenAfterStage, context);\n        }\n      }\n\n      // ─── Phase 6: CONTINUE — dynamic next / linear next ───\n      if (dynamicNext) {\n        return this.continuationResolver.resolve(\n          dynamicNext,\n          node,\n          context,\n          breakFlag,\n          branchPath,\n          this.executeNode.bind(this),\n        );\n      }\n\n      if (hasNext) {\n        const nextNode = originalNext!;\n\n        // Detect loop reference nodes created by loopTo() — marked with isLoopRef flag.\n        // Route through ContinuationResolver for proper ID resolution, iteration\n        // tracking, and narrative generation.\n        const isLoopReference = nextNode.isLoopRef;\n\n        if (isLoopReference) {\n          return this.continuationResolver.resolve(\n            nextNode,\n            node,\n            context,\n            breakFlag,\n            branchPath,\n            this.executeNode.bind(this),\n            traversalContext,\n          );\n        }\n\n        this.narrativeGenerator.onNext(node.name, nextNode.name, nextNode.description, traversalContext);\n        context.addFlowDebugMessage('next', `Moving to ${nextNode.name} stage`, {\n          targetStage: nextNode.name,\n        });\n        const nextCtx = context.createNext(branchPath as string, nextNode.name, nextNode.id);\n        return await this.executeNode(nextNode, nextCtx, breakFlag, branchPath);\n      }\n\n      // ─── Phase 7: LEAF — no continuation ───\n      return stageOutput;\n    } finally {\n      this._executeDepth--;\n    }\n  }\n\n  // ─────────────────────── Private Helpers ───────────────────────\n\n  private captureDynamicChildrenResult(\n    node: StageNode<TOut, TScope>,\n    children: StageNode<TOut, TScope>[],\n    context: StageContext,\n  ): void {\n    const parentStageId = context.getStageId();\n\n    const childStructure: any = {\n      id: `${node.id}-children`,\n      name: 'Dynamic Children',\n      type: 'fork',\n      children: children.map((c) => ({\n        id: c.id,\n        name: c.name,\n        type: 'stage',\n      })),\n    };\n\n    const childStages: Record<string, unknown> = {};\n    if (context.children) {\n      for (const childCtx of context.children) {\n        const snapshot = childCtx.getSnapshot();\n        childStages[snapshot.name || snapshot.id] = {\n          name: snapshot.name,\n          output: snapshot.logs,\n          errors: snapshot.errors,\n          metrics: snapshot.metrics,\n          status: snapshot.errors && Object.keys(snapshot.errors).length > 0 ? 'error' : 'success',\n        };\n      }\n    }\n\n    this.subflowResults.set(node.id, {\n      subflowId: node.id,\n      subflowName: node.name,\n      treeContext: {\n        globalContext: {},\n        stageContexts: childStages as unknown as Record<string, unknown>,\n        history: [],\n      },\n      parentStageId,\n      pipelineStructure: childStructure,\n    });\n  }\n\n  private computeContextDepth(context: StageContext): number {\n    let depth = 0;\n    let current = context.parent;\n    while (current) {\n      depth++;\n      current = current.parent;\n    }\n    return depth;\n  }\n\n  private prefixNodeTree(node: StageNode<TOut, TScope>, prefix: string): StageNode<TOut, TScope> {\n    if (!node) return node;\n    const clone: StageNode<TOut, TScope> = { ...node };\n    clone.name = `${prefix}/${node.name}`;\n    clone.id = `${prefix}/${clone.id}`;\n    if (clone.subflowId) clone.subflowId = `${prefix}/${clone.subflowId}`;\n    if (clone.next) clone.next = this.prefixNodeTree(clone.next, prefix);\n    if (clone.children) {\n      clone.children = clone.children.map((c) => this.prefixNodeTree(c, prefix));\n    }\n    return clone;\n  }\n\n  private autoRegisterSubflowDef(\n    subflowId: string,\n    subflowDef: NonNullable<StageNode['subflowDef']>,\n    mountNodeId?: string,\n  ): void {\n    // this.subflows is always initialized in the constructor; the null guard below is unreachable.\n    const subflowsDict = this.subflows;\n\n    // First-write-wins\n    const isNewRegistration = !subflowsDict[subflowId];\n    if (isNewRegistration && subflowDef.root) {\n      subflowsDict[subflowId] = {\n        root: subflowDef.root as StageNode<TOut, TScope>,\n        ...(subflowDef.buildTimeStructure ? { buildTimeStructure: subflowDef.buildTimeStructure } : {}),\n      } as any;\n    }\n\n    // Merge stageMap entries (parent entries preserved)\n    if (subflowDef.stageMap) {\n      for (const [key, fn] of Array.from(subflowDef.stageMap.entries())) {\n        if (!this.stageMap.has(key)) {\n          this.stageMap.set(key, fn as StageFunction<TOut, TScope>);\n        }\n      }\n    }\n\n    // Merge nested subflows\n    if (subflowDef.subflows) {\n      for (const [key, def] of Object.entries(subflowDef.subflows)) {\n        if (!subflowsDict[key]) {\n          subflowsDict[key] = def as { root: StageNode<TOut, TScope> };\n        }\n      }\n    }\n\n    if (mountNodeId) {\n      this.structureManager.updateDynamicSubflow(\n        mountNodeId,\n        subflowId,\n        subflowDef.root?.subflowName || subflowDef.root?.name,\n        subflowDef.buildTimeStructure,\n      );\n    }\n\n    // Notify FlowRecorders only on first registration (matches first-write-wins)\n    if (isNewRegistration) {\n      const subflowName = subflowDef.root?.subflowName || subflowDef.root?.name || subflowId;\n      this.narrativeGenerator.onSubflowRegistered(\n        subflowId,\n        subflowName,\n        subflowDef.root?.description,\n        subflowDef.buildTimeStructure,\n      );\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FlowchartTraverser.js","sourceRoot":"","sources":["../../../../../src/lib/engine/traversal/FlowchartTraverser.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * FlowchartTraverser — Pre-order DFS traversal of StageNode graph.\n *\n * Unified traversal algorithm for all node shapes. `executeNode` is a\n * TRAMPOLINE driver: it runs `executeNodeStep` (one node, all 7 phases) in\n * a flat loop, following tail continuations (linear `next`, loop edges,\n * dynamic next, flat decider dispatch) iteratively — so chain length and\n * loop iterations never grow the call stack. Only true tree nesting (fork\n * children, with-continuation decider/selector branches, subflow mounts)\n * recurses.\n *\n * For each node, executeNodeStep follows 7 phases:\n *   0. CLASSIFY  — subflow detection, early delegation\n *   1. VALIDATE  — node invariants, role markers\n *   2. EXECUTE   — run stage fn, commit, break check\n *   3. DYNAMIC   — StageNode return detection, subflow auto-registration, structure updates\n *   4. CHILDREN  — fork/selector/decider dispatch\n *   5. CONTINUE  — dynamic next / linear next resolution\n *   6. LEAF      — no continuation, return output\n *\n * Break semantics: If a stage calls breakFn(), commit and STOP.\n * Patch model: Stage writes into local patch; commitPatch() after return or throw.\n */\n\nimport type { StageContext } from '../../memory/StageContext.js';\nimport { isPauseSignal } from '../../pause/types.js';\nimport type { ScopeProtectionMode } from '../../scope/protection/types.js';\nimport { extractErrorInfo } from '../errors/errorInfo.js';\nimport { isStageNodeReturn } from '../graph/StageNode.js';\nimport { ChildrenExecutor } from '../handlers/ChildrenExecutor.js';\nimport { ContinuationResolver } from '../handlers/ContinuationResolver.js';\nimport { DeciderHandler } from '../handlers/DeciderHandler.js';\nimport { NodeResolver } from '../handlers/NodeResolver.js';\nimport { RuntimeStructureManager } from '../handlers/RuntimeStructureManager.js';\nimport { SelectorHandler } from '../handlers/SelectorHandler.js';\nimport { StageRunner } from '../handlers/StageRunner.js';\nimport { SubflowExecutor } from '../handlers/SubflowExecutor.js';\nimport type { BreakFlag } from '../handlers/types.js';\nimport { FlowRecorderDispatcher } from '../narrative/FlowRecorderDispatcher.js';\nimport { NarrativeFlowRecorder } from '../narrative/NarrativeFlowRecorder.js';\nimport { NullControlFlowNarrativeGenerator } from '../narrative/NullControlFlowNarrativeGenerator.js';\nimport type { FlowRecorder, IControlFlowNarrative, TraversalContext } from '../narrative/types.js';\nimport { buildRuntimeStageId } from '../runtimeStageId.js';\nimport type {\n  HandlerDeps,\n  IExecutionRuntime,\n  ILogger,\n  NodeResultType,\n  ScopeFactory,\n  Selector,\n  SerializedPipelineStructure,\n  StageFunction,\n  StageNode,\n  StreamHandlers,\n  SubflowMountOptions,\n  SubflowResult,\n  SubflowTraverserFactory,\n  TraversalResult,\n} from '../types.js';\n\nexport interface TraverserOptions<TOut = any, TScope = any> {\n  root: StageNode<TOut, TScope>;\n  stageMap: Map<string, StageFunction<TOut, TScope>>;\n  scopeFactory: ScopeFactory<TScope>;\n  executionRuntime: IExecutionRuntime;\n  readOnlyContext?: unknown;\n  /** Execution environment — propagates to subflows automatically. */\n  executionEnv?: import('../../engine/types').ExecutionEnv;\n  throttlingErrorChecker?: (error: unknown) => boolean;\n  streamHandlers?: StreamHandlers;\n  scopeProtectionMode?: ScopeProtectionMode;\n  subflows?: Record<string, { root: StageNode<TOut, TScope> }>;\n  narrativeEnabled?: boolean;\n  buildTimeStructure?: SerializedPipelineStructure;\n  logger: ILogger;\n  signal?: AbortSignal;\n  /** Pre-configured FlowRecorders to attach when narrative is enabled. */\n  flowRecorders?: FlowRecorder[];\n  /**\n   * Pre-configured narrative generator. If provided, takes precedence over\n   * flowRecorders and narrativeEnabled. Used by the subflow traverser factory\n   * to share the parent's narrative generator with subflow traversers.\n   */\n  narrativeGenerator?: IControlFlowNarrative;\n  /**\n   * Maximum nested executeNode depth (tree nesting — branch/fork dispatch and\n   * dynamic recursion, NOT linear chains or loop iterations, which run flat).\n   * Defaults to FlowchartTraverser.MAX_EXECUTE_DEPTH (500).\n   */\n  maxDepth?: number;\n  /**\n   * Maximum loop iterations per node (the ContinuationResolver guard).\n   * Defaults to DEFAULT_MAX_ITERATIONS (1000). Propagated to subflow\n   * traversers. Must be >= 1.\n   */\n  maxIterations?: number;\n  /**\n   * When this traverser runs inside a subflow, set this to the subflow's ID.\n   * Propagated to TraversalContext so narrative entries carry the correct subflowId.\n   */\n  parentSubflowId?: string;\n  /** Shared execution counter from parent traverser. Subflows continue the parent's numbering. */\n  executionCounter?: { value: number };\n  /**\n   * Per-subflow scope captures from a checkpoint, on the resume path.\n   * Forwarded to `HandlerDeps.subflowStatesForResume` so SubflowExecutor\n   * can re-seed nested runtimes from pre-pause state instead of running\n   * the inputMapper. Undefined on normal `run()` paths.\n   */\n  subflowStatesForResume?: Record<string, Record<string, unknown>>;\n  /**\n   * Per-`executor.run()` identifier. Threaded into every TraversalContext\n   * this traverser produces so recorders can scope state to a single run.\n   * Subflow traversers inherit the parent's runId (the subflow is part of\n   * the same run from the consumer's POV). Required field — every event\n   * needs it. See `runner/runId.ts`.\n   */\n  runId: string;\n}\n\n/**\n * Traverser-local overlay entry for a node whose stage function returned a\n * StageNode (dynamic continuation). Holds the dynamic values that earlier\n * versions wrote DIRECTLY onto the shared built-chart node — which leaked the\n * dynamic shape into every later run of the same built chart and raced\n * concurrent executors. The overlay keeps the built graph immutable: patches\n * live in a per-traverser Map keyed by `node.id` and die with the run.\n *\n * `next` is intentionally ABSENT: a dynamic `next` only ever applies to the\n * visit that produced it (the old code wrote `node.next` and restored it\n * before anything could observe the write), so it stays a local variable in\n * `executeNode` and is routed through `ContinuationResolver` directly.\n */\nexport interface DynamicNodePatch<TOut = any, TScope = any> {\n  /**\n   * Subflow mount metadata from a dynamic-subflow return. Grouped so the\n   * merged view reproduces the old field-wise overwrite exactly — including\n   * `subflowName`/`subflowMountOptions` becoming undefined when the dynamic\n   * return omitted them.\n   */\n  subflowMeta?: {\n    isSubflowRoot: true;\n    subflowId: string;\n    subflowName: string | undefined;\n    subflowMountOptions: SubflowMountOptions | undefined;\n  };\n  /** Dynamic fork children (replaces the built node's children for this run). */\n  children?: StageNode<TOut, TScope>[];\n  /** Dynamic output-based selector accompanying dynamic children. */\n  nextNodeSelector?: Selector;\n}\n\n/**\n * Trampoline brand — marks a continuation hop returned by `executeNodeStep`\n * to the driver loop in `executeNode`. Module-private symbol so a stage's own\n * return value (which can be any object) can never be mistaken for a hop.\n */\nconst CONTINUE_HOP: unique symbol = Symbol('footprintjs.executeNode.continue');\n\n/**\n * A flat continuation — \"execute this node next, in this context\" — returned\n * by `executeNodeStep` for every TAIL continuation (linear `next`, loop\n * edges, dynamic next, dynamic-subflow re-entry, no-continuation decider\n * dispatch). The driver loop in `executeNode` consumes hops iteratively:\n * `current = hop; continue;` — so neither the call stack nor the retained\n * promise chain grows with chain length or loop iterations.\n */\ninterface ContinuationHop<TOut = any, TScope = any> {\n  readonly [CONTINUE_HOP]: true;\n  readonly node: StageNode<TOut, TScope>;\n  readonly context: StageContext;\n  readonly branchPath: string | undefined;\n  /**\n   * Present when the hop is a decider's branch dispatch (decider without its\n   * own `next`). The driver records it so a PauseSignal thrown anywhere in\n   * the continued chain still gets the decider stamped as its invoker —\n   * exactly what the recursive dispatch's catch used to do.\n   */\n  readonly invokerStamp?: InvokerStamp;\n}\n\n/** Pause-invoker context recorded by the driver for flat decider dispatches. */\ninterface InvokerStamp {\n  readonly invokerStageId: string;\n  readonly continuationStageId?: string;\n}\n\nfunction isContinuationHop<TOut, TScope>(value: unknown): value is ContinuationHop<TOut, TScope> {\n  return typeof value === 'object' && value !== null && (value as Record<symbol, unknown>)[CONTINUE_HOP] === true;\n}\n\nexport class FlowchartTraverser<TOut = any, TScope = any> {\n  private readonly root: StageNode<TOut, TScope>;\n  private stageMap: Map<string, StageFunction<TOut, TScope>>;\n  private readonly executionRuntime: IExecutionRuntime;\n  private subflows: Record<string, { root: StageNode<TOut, TScope> }>;\n  private readonly logger: ILogger;\n  private readonly signal?: AbortSignal;\n  private readonly parentSubflowId?: string;\n  /** Frozen value passed via `run({input})`. Surfaced on `onRunStart` at the\n   *  top-level traversal so consumers (e.g. `InOutRecorder`) can bracket\n   *  the run with the same payload shape that subflows already have. */\n  private readonly readOnlyContext?: unknown;\n  /** Per-`executor.run()` identifier. Stamped onto every TraversalContext.\n   *  Inherited by subflow traversers so all events of one run share one runId. */\n  private readonly runId: string;\n\n  // Handler modules\n  private readonly nodeResolver: NodeResolver<TOut, TScope>;\n  private readonly childrenExecutor: ChildrenExecutor<TOut, TScope>;\n  private readonly subflowExecutor: SubflowExecutor<TOut, TScope>;\n  private readonly stageRunner: StageRunner<TOut, TScope>;\n  private readonly continuationResolver: ContinuationResolver<TOut, TScope>;\n  private readonly deciderHandler: DeciderHandler<TOut, TScope>;\n  private readonly selectorHandler: SelectorHandler<TOut, TScope>;\n  private readonly structureManager: RuntimeStructureManager;\n  private readonly narrativeGenerator: IControlFlowNarrative;\n  private readonly flowRecorderDispatcher: FlowRecorderDispatcher | undefined;\n\n  // Execution state\n  private subflowResults: Map<string, SubflowResult> = new Map();\n\n  /**\n   * Per-traverser set of lazy subflow IDs that have been resolved by THIS run.\n   * Used instead of writing `node.subflowResolver = undefined` back to the shared\n   * StageNode graph — avoids a race where a concurrent traverser clears the shared\n   * resolver before another traverser has finished using it.\n   */\n  private readonly resolvedLazySubflows = new Set<string>();\n\n  /**\n   * Per-traverser overlay of dynamic StageNode returns, keyed by `node.id`.\n   * Phase 4 writes patches HERE instead of mutating the shared built-chart\n   * node objects (same isolation convention as `resolvedLazySubflows`).\n   * All engine reads of the patched fields go through the `eff*` accessors\n   * below. The map dies with the traverser — one run, one overlay — so a\n   * fresh executor over the same built chart always sees the original graph.\n   *\n   * Keyed by the node OBJECT (WeakMap), not `node.id`: a dynamic child that\n   * reuses a built node's id must NOT make the built node inherit the patch\n   * (id-keyed lookup caused phantom double-execution). `patchCount` is the\n   * fast-path check — WeakMap has no `size`.\n   */\n  private readonly dynamicPatches = new WeakMap<StageNode<TOut, TScope>, DynamicNodePatch<TOut, TScope>>();\n  private patchCount = 0;\n\n  /**\n   * TREE-nesting depth counter for executeNode (the trampoline driver).\n   * Each driver invocation increments this; decrements on exit (try/finally).\n   *\n   * Linear `next` chains, loop edges, and dynamic continuations are followed\n   * ITERATIVELY inside one driver invocation, so they never grow this\n   * counter. Only true tree recursion does: fork children, decider/selector\n   * branch dispatch (when the decider has its own continuation), and\n   * unbounded dynamic recursion. Prevents call-stack overflow on runaway\n   * recursive composition.\n   */\n  private _executeDepth = 0;\n\n  /**\n   * Memoized parent-chain depth per StageContext. The context tree deepens\n   * by one per executed stage along a chain, so the naive parent-walk in\n   * `computeContextDepth` is O(chain length) per stage — O(n²) per run once\n   * the trampoline allows chains of tens of thousands of stages. Contexts\n   * are visited parent-before-child, so the memo makes each lookup O(1)\n   * amortized. WeakMap — dies with the traverser.\n   */\n  private readonly contextDepthCache = new WeakMap<StageContext, number>();\n\n  /**\n   * Shared mutable execution counter — monotonic, incremented per stage execution.\n   * Shared with child traversers (subflows) so indices are globally unique within a run.\n   */\n  private readonly _executionCounter: { value: number };\n\n  /**\n   * Per-instance maximum depth (set from TraverserOptions.maxDepth or the class default).\n   */\n  private readonly _maxDepth: number;\n\n  /**\n   * Per-instance loop-iteration limit forwarded to the ContinuationResolver\n   * and propagated to subflow traversers. Undefined → resolver default (1000).\n   */\n  private readonly _maxIterations?: number;\n\n  /**\n   * Default maximum nested executeNode depth before an error is thrown.\n   *\n   * **What counts as depth (trampoline model):** `executeNode` is an iterative\n   * driver — linear `next` hops, loop edges (`loopTo`/dynamic next), and\n   * dynamic-subflow re-entry are followed in a flat loop and consume NO depth.\n   * Depth grows only with true tree nesting: one tick per fork child, one per\n   * decider/selector branch dispatch that must return to its invoker (decider\n   * with its own `next`), one per subflow mount frame in the parent (the\n   * subflow body itself runs on a FRESH traverser with its own budget).\n   *\n   * 500 therefore covers any realistic chart — it bounds recursive\n   * COMPOSITION, not chain length or loop count. Loops are bounded by\n   * `ContinuationResolver`'s independent iteration limit (default 1000,\n   * configurable via `RunOptions.maxIterations`), which is now the binding\n   * constraint for loop-heavy pipelines.\n   *\n   * @remarks Not safe for concurrent `.execute()` calls on the same instance — concurrent\n   * executions race on `_executeDepth`. Use a separate `FlowchartTraverser` per concurrent\n   * execution. `FlowChartExecutor.run()` always creates a fresh traverser per call.\n   */\n  static readonly MAX_EXECUTE_DEPTH = 500;\n\n  constructor(opts: TraverserOptions<TOut, TScope>) {\n    const maxDepth = opts.maxDepth ?? FlowchartTraverser.MAX_EXECUTE_DEPTH;\n    if (maxDepth < 1) throw new Error('FlowchartTraverser: maxDepth must be >= 1');\n    this._maxDepth = maxDepth;\n    if (opts.maxIterations !== undefined && opts.maxIterations < 1) {\n      throw new Error('FlowchartTraverser: maxIterations must be >= 1');\n    }\n    this._maxIterations = opts.maxIterations;\n    this._executionCounter = opts.executionCounter ?? { value: 0 };\n    this.root = opts.root;\n    // Shallow-copy stageMap and subflows so that lazy-resolution mutations\n    // (prefixed entries added during execution) stay scoped to THIS traverser\n    // and do not escape to the shared FlowChart object. Without the copy,\n    // concurrent FlowChartExecutor runs sharing the same FlowChart would race\n    // on these two mutable dictionaries.\n    this.stageMap = new Map(opts.stageMap);\n    this.executionRuntime = opts.executionRuntime;\n    this.subflows = opts.subflows ? { ...opts.subflows } : {};\n    this.logger = opts.logger;\n    this.signal = opts.signal;\n    this.parentSubflowId = opts.parentSubflowId;\n    this.readOnlyContext = opts.readOnlyContext;\n    this.runId = opts.runId;\n\n    // Structure manager (deep-clones build-time structure)\n    this.structureManager = new RuntimeStructureManager();\n    this.structureManager.init(opts.buildTimeStructure);\n\n    // Narrative generator\n    // Priority: explicit narrativeGenerator > flowRecorders > default NarrativeFlowRecorder > null.\n    // Subflow traversers receive the parent's narrativeGenerator so all events flow to one place.\n    if (opts.narrativeGenerator) {\n      this.narrativeGenerator = opts.narrativeGenerator;\n    } else if (opts.narrativeEnabled) {\n      const dispatcher = new FlowRecorderDispatcher();\n      this.flowRecorderDispatcher = dispatcher;\n\n      // If custom FlowRecorders are provided, use them; otherwise attach default NarrativeFlowRecorder\n      if (opts.flowRecorders && opts.flowRecorders.length > 0) {\n        for (const recorder of opts.flowRecorders) {\n          dispatcher.attach(recorder);\n        }\n      } else {\n        dispatcher.attach(new NarrativeFlowRecorder());\n      }\n\n      this.narrativeGenerator = dispatcher;\n    } else {\n      this.narrativeGenerator = new NullControlFlowNarrativeGenerator();\n    }\n\n    // Build shared deps bag\n    const deps = this.createDeps(opts);\n\n    // Build O(1) node ID map from the root graph (avoids repeated DFS on every loopTo())\n    const nodeIdMap = this.buildNodeIdMap(opts.root);\n\n    // Initialize handler modules.\n    // NodeResolver's DFS fallback resolves loop targets against the LIVE\n    // runtime shape, so it reads children through the dynamic-patch overlay\n    // (a loop can target a node added by a dynamic StageNode return).\n    this.nodeResolver = new NodeResolver(deps, nodeIdMap, (n) => this.effChildren(n));\n    this.childrenExecutor = new ChildrenExecutor(deps, this.executeNode.bind(this));\n    this.stageRunner = new StageRunner(deps);\n    this.continuationResolver = new ContinuationResolver(\n      deps,\n      this.nodeResolver,\n      (nodeId, count) => this.structureManager.updateIterationCount(nodeId, count),\n      this._maxIterations,\n    );\n    this.deciderHandler = new DeciderHandler(deps);\n    this.selectorHandler = new SelectorHandler(deps, this.childrenExecutor);\n    this.subflowExecutor = new SubflowExecutor(deps, this.createSubflowTraverserFactory(opts));\n  }\n\n  /**\n   * Create a factory that produces FlowchartTraverser instances for subflow execution.\n   * Captures parent config in closure — SubflowExecutor provides subflow-specific overrides.\n   * Each subflow gets a full traverser with all 7 phases (deciders, selectors, loops, etc.).\n   */\n  private createSubflowTraverserFactory(\n    parentOpts: TraverserOptions<TOut, TScope>,\n  ): SubflowTraverserFactory<TOut, TScope> {\n    // Capture references to mutable state — factory reads the CURRENT state when called,\n    // not the state at factory creation time. This is correct because lazy subflow resolution\n    // may add entries to stageMap/subflows before a nested subflow is encountered.\n    const parentStageMap = this.stageMap;\n    const parentSubflows = this.subflows;\n    const narrativeGenerator = this.narrativeGenerator;\n\n    return (subflowOpts) => {\n      const traverser = new FlowchartTraverser<TOut, TScope>({\n        root: subflowOpts.root,\n        stageMap: parentStageMap, // Constructor shallow-copies this\n        scopeFactory: parentOpts.scopeFactory,\n        executionRuntime: subflowOpts.executionRuntime,\n        readOnlyContext: subflowOpts.readOnlyContext,\n        executionEnv: parentOpts.executionEnv,\n        throttlingErrorChecker: parentOpts.throttlingErrorChecker,\n        streamHandlers: parentOpts.streamHandlers,\n        scopeProtectionMode: parentOpts.scopeProtectionMode,\n        subflows: parentSubflows, // Constructor shallow-copies this\n        narrativeGenerator, // Share parent's — all events flow to one place\n        logger: parentOpts.logger,\n        signal: parentOpts.signal,\n        maxDepth: this._maxDepth,\n        ...(this._maxIterations !== undefined && { maxIterations: this._maxIterations }),\n        parentSubflowId: subflowOpts.subflowId,\n        executionCounter: this._executionCounter, // Share counter — subflow continues global numbering\n        runId: this.runId, // Subflow inherits parent's runId — same logical run\n        // Forward the resume-only subflow scope captures so nested\n        // SubflowExecutors can re-seed deeper-nested runtimes (e.g.\n        // Sequence(Agent(...)) where the inner Agent subflow paused).\n        ...(parentOpts.subflowStatesForResume && {\n          subflowStatesForResume: parentOpts.subflowStatesForResume,\n        }),\n      });\n\n      return {\n        execute: () => traverser.execute(),\n        getSubflowResults: () => traverser.getSubflowResults(),\n        getBreakState: () => traverser.getBreakState(),\n      };\n    };\n  }\n\n  private createDeps(opts: TraverserOptions<TOut, TScope>): HandlerDeps<TOut, TScope> {\n    return {\n      stageMap: this.stageMap,\n      root: this.root,\n      executionRuntime: this.executionRuntime,\n      scopeFactory: opts.scopeFactory,\n      subflows: this.subflows,\n      throttlingErrorChecker: opts.throttlingErrorChecker,\n      streamHandlers: opts.streamHandlers,\n      scopeProtectionMode: opts.scopeProtectionMode ?? 'error',\n      readOnlyContext: opts.readOnlyContext,\n      executionEnv: opts.executionEnv,\n      narrativeGenerator: this.narrativeGenerator,\n      logger: this.logger,\n      signal: opts.signal,\n      ...(opts.subflowStatesForResume && {\n        subflowStatesForResume: opts.subflowStatesForResume,\n      }),\n    };\n  }\n\n  // ─────────────────────── Public API ───────────────────────\n\n  /**\n   * Holds the top-level break flag for the duration of `execute()`. Kept as\n   * a field (not a local) so `getBreakState()` can surface the final state\n   * for callers like `SubflowExecutor` that implement `propagateBreak`.\n   */\n  private _topBreakFlag: { shouldBreak: boolean; reason?: string } = { shouldBreak: false };\n\n  async execute(branchPath?: string): Promise<TraversalResult> {\n    const context = this.executionRuntime.rootStageContext;\n    this._topBreakFlag = { shouldBreak: false };\n\n    // Fire onRunStart ONLY at the top-level traversal — subflow traversers\n    // already produce onSubflowEntry/onSubflowExit pairs, so emitting run\n    // events for them would double-bracket the boundary stream. The\n    // top-level traverser is the one without a parentSubflowId.\n    const isTopLevel = this.parentSubflowId === undefined;\n    // Synthetic TraversalContext for run.entry / run.exit. Fields use\n    // root-stage defaults (stageId='__root__', runtimeStageId='__root__#0',\n    // depth 0) so the runId is reliably available on run events without\n    // forcing recorders to handle `traversalContext === undefined`.\n    const rootContext: TraversalContext = {\n      runId: this.runId,\n      stageId: '__root__',\n      runtimeStageId: '__root__#0',\n      stageName: '__root__',\n      depth: 0,\n    };\n    if (isTopLevel) {\n      // `readOnlyContext` is the engine's view of `run({input})` — passed\n      // through from `FlowChartExecutor.run()` as the validated input.\n      this.narrativeGenerator.onRunStart(this.readOnlyContext, rootContext);\n    }\n\n    // Top-level runs close their boundary SYMMETRICALLY: every onRunStart\n    // is followed by exactly one onRunEnd (clean) or onRunFailed (error).\n    // Without the catch, a thrown run fired onRunStart then nothing — a\n    // monitor couldn't tell \"still running\" from \"crashed.\" Pause is NOT\n    // an error (it's expected suspension), so it skips onRunFailed and\n    // re-throws untouched. The stage-level catch already recorded the\n    // failing stage (onError + commit); this adds the run-level terminal\n    // signal. The error still propagates — this is observation, not\n    // recovery. Subflow traversers don't fire run events; their errors\n    // bubble up and surface here at the top level.\n    if (!isTopLevel) {\n      return this.executeNode(this.root, context, this._topBreakFlag, branchPath ?? '');\n    }\n    let result: TraversalResult;\n    try {\n      result = await this.executeNode(this.root, context, this._topBreakFlag, branchPath ?? '');\n    } catch (error: unknown) {\n      if (!isPauseSignal(error)) {\n        this.narrativeGenerator.onRunFailed(extractErrorInfo(error), rootContext);\n      }\n      throw error;\n    }\n    this.narrativeGenerator.onRunEnd(result, rootContext);\n    return result;\n  }\n\n  /**\n   * Break state captured at the top-level of the most recent `execute()`.\n   * `shouldBreak` is true when a stage called `scope.$break(reason)`; the\n   * optional `reason` carries the string passed to `$break`.\n   *\n   * Used by `SubflowExecutor` to propagate an inner subflow's break up to\n   * the parent traverser when the mount sets `propagateBreak: true`.\n   */\n  getBreakState(): { shouldBreak: boolean; reason?: string } {\n    return { ...this._topBreakFlag };\n  }\n\n  getRuntimeStructure(): SerializedPipelineStructure | undefined {\n    return this.structureManager.getStructure();\n  }\n\n  getSnapshot(options?: { redact?: boolean }) {\n    return this.executionRuntime.getSnapshot(options);\n  }\n\n  getRuntime() {\n    return this.executionRuntime;\n  }\n\n  setRootObject(path: string[], key: string, value: unknown) {\n    this.executionRuntime.setRootObject(path, key, value);\n  }\n\n  getBranchIds() {\n    return this.executionRuntime.getPipelines();\n  }\n\n  getRuntimeRoot(): StageNode {\n    return this.root;\n  }\n\n  getSubflowResults(): Map<string, SubflowResult> {\n    return this.subflowResults;\n  }\n\n  getNarrative(): string[] {\n    return this.narrativeGenerator.getSentences();\n  }\n\n  /** Returns the FlowRecorderDispatcher, or undefined if narrative is disabled. */\n  getFlowRecorderDispatcher(): FlowRecorderDispatcher | undefined {\n    return this.flowRecorderDispatcher;\n  }\n\n  // ─────────────────────── Core Traversal ───────────────────────\n\n  /**\n   * Build an O(1) ID→node map from the root graph.\n   * Used by NodeResolver to avoid repeated DFS on every loopTo() call.\n   * Iterative worklist (no recursion) so arbitrarily long chains index fully;\n   * the `map.has` guard handles cyclic refs. First-visited node wins per ID —\n   * worklist order matches the old recursive pre-order (children, then next).\n   * Dynamic subflows and lazy-resolved nodes are added to stageMap at runtime but not to this map —\n   * those use the DFS fallback in NodeResolver.\n   */\n  private buildNodeIdMap(root: StageNode<TOut, TScope>): Map<string, StageNode<TOut, TScope>> {\n    const map = new Map<string, StageNode<TOut, TScope>>();\n    const stack: StageNode<TOut, TScope>[] = [root];\n    while (stack.length > 0) {\n      const node = stack.pop()!;\n      if (map.has(node.id)) continue; // already visited (avoids infinite loops on cyclic refs)\n      map.set(node.id, node);\n      // Push in reverse visit order (LIFO stack): next first, then children\n      // reversed — so children are visited before next, first child first,\n      // matching the recursive pre-order exactly.\n      if (node.next) stack.push(node.next);\n      if (node.children) {\n        for (let i = node.children.length - 1; i >= 0; i--) stack.push(node.children[i]);\n      }\n    }\n    return map;\n  }\n\n  private getStageFn(node: StageNode<TOut, TScope>): StageFunction<TOut, TScope> | undefined {\n    if (typeof node.fn === 'function') return node.fn as StageFunction<TOut, TScope>;\n    // Primary: look up by id (stable identifier, keyed by FlowChartBuilder)\n    const byId = this.stageMap.get(node.id);\n    if (byId !== undefined) return byId;\n    // Fallback: look up by name (supports hand-crafted stageMaps in tests and advanced use)\n    return this.stageMap.get(node.name);\n  }\n\n  // ─────────────── Dynamic-patch overlay accessors ───────────────\n  //\n  // Every engine read of a field that Phase 4 can patch (children,\n  // nextNodeSelector, subflow meta) goes through these. Fast path: charts\n  // with no dynamic returns never allocate and pay one `size === 0` check.\n\n  private getPatch(node: StageNode<TOut, TScope>): DynamicNodePatch<TOut, TScope> | undefined {\n    if (this.patchCount === 0) return undefined;\n    return this.dynamicPatches.get(node);\n  }\n\n  private getOrCreatePatch(node: StageNode<TOut, TScope>): DynamicNodePatch<TOut, TScope> {\n    let patch = this.dynamicPatches.get(node);\n    if (!patch) {\n      patch = {};\n      this.dynamicPatches.set(node, patch);\n      this.patchCount++;\n    }\n    return patch;\n  }\n\n  /** Effective children: dynamic patch first, then the built node's children. */\n  private effChildren(node: StageNode<TOut, TScope>): StageNode<TOut, TScope>[] | undefined {\n    return this.getPatch(node)?.children ?? node.children;\n  }\n\n  /** Effective output-based selector: dynamic patch first, then the built node's. */\n  private effSelector(node: StageNode<TOut, TScope>): Selector | undefined {\n    return this.getPatch(node)?.nextNodeSelector ?? node.nextNodeSelector;\n  }\n\n  /** Effective subflow-root marker (true when a dynamic subflow was patched on). */\n  private effIsSubflowRoot(node: StageNode<TOut, TScope>): boolean | undefined {\n    const meta = this.getPatch(node)?.subflowMeta;\n    return meta ? true : node.isSubflowRoot;\n  }\n\n  /** Effective subflow id (patched verbatim by a dynamic subflow return). */\n  private effSubflowId(node: StageNode<TOut, TScope>): string | undefined {\n    const meta = this.getPatch(node)?.subflowMeta;\n    return meta ? meta.subflowId : node.subflowId;\n  }\n\n  /**\n   * Materialize the effective view of a node — field-identical to what the\n   * pre-overlay code produced by mutating the shared node. Used where a node\n   * is handed to a helper executor (NodeResolver / SubflowExecutor /\n   * ChildrenExecutor) so helpers never read stale built fields. Returns the\n   * node itself (no allocation) when it carries no patch.\n   */\n  private effNode(node: StageNode<TOut, TScope>): StageNode<TOut, TScope> {\n    const patch = this.getPatch(node);\n    if (!patch) return node;\n    const merged: StageNode<TOut, TScope> = { ...node };\n    if (patch.subflowMeta) {\n      merged.isSubflowRoot = true;\n      merged.subflowId = patch.subflowMeta.subflowId;\n      merged.subflowName = patch.subflowMeta.subflowName;\n      merged.subflowMountOptions = patch.subflowMeta.subflowMountOptions;\n    }\n    if (patch.children) merged.children = patch.children;\n    if (patch.nextNodeSelector) merged.nextNodeSelector = patch.nextNodeSelector;\n    return merged;\n  }\n\n  private async executeStage(\n    node: StageNode<TOut, TScope>,\n    stageFunc: StageFunction<TOut, TScope>,\n    context: StageContext,\n    breakFn: () => void,\n  ) {\n    // runtimeStageId is assigned in executeNode() before traversalContext creation,\n    // ensuring scope events and flow events use the same value.\n    return this.stageRunner.run(node, stageFunc, context, breakFn);\n  }\n\n  /**\n   * Trampoline driver — pre-order DFS traversal entry point.\n   *\n   * Runs `executeNodeStep` (one node, all 7 phases) in a flat loop: every\n   * TAIL continuation (linear `next`, loop edge, dynamic next / dynamic\n   * re-entry, no-continuation decider dispatch) comes back as a\n   * `ContinuationHop` and is followed ITERATIVELY — neither the call stack\n   * nor the retained promise chain grows with chain length or loop count.\n   *\n   * Recursion remains ONLY for true tree nesting (each gets a nested driver\n   * call): fork children (`ChildrenExecutor`), selector branches (parallel\n   * fan-out), decider branch dispatch when the decider has its own `next`\n   * (the branch must complete BEFORE the decider's continuation runs), and\n   * subflow mounts (fresh traverser; the mount frame stays in the parent).\n   * `_executeDepth` therefore counts chart COMPOSITION depth only, guarded\n   * by `_maxDepth` (default `MAX_EXECUTE_DEPTH` = 500).\n   *\n   * PauseSignal: a flat decider dispatch records an `InvokerStamp`; if the\n   * continued chain later pauses, the driver stamps the signal during\n   * unwind — same invoker context the recursive dispatch's catch used to\n   * stamp, innermost (most recent dispatch) first.\n   */\n  private async executeNode(\n    node: StageNode<TOut, TScope>,\n    context: StageContext,\n    breakFlag: BreakFlag,\n    branchPath?: string,\n  ): Promise<any> {\n    // Invoker stamps from flat decider dispatches in THIS driver — kept\n    // local so nested drivers (fork children, with-next decider branches)\n    // get their own windows, matching the old frame-on-stack stamping scope.\n    let pendingInvokers: InvokerStamp[] | undefined;\n    // ─── Tree-depth guard ───\n    // The increment is inside `try` so `finally` always decrements — no\n    // fragile gap between check and try entry.\n    try {\n      if (++this._executeDepth > this._maxDepth) {\n        throw new Error(\n          `FlowchartTraverser: maximum traversal depth exceeded (${this._maxDepth}). ` +\n            'Depth counts NESTED dispatch (fork children, decider/selector branches, recursive composition) — ' +\n            'linear chains and loop iterations run flat and do not consume it. ' +\n            `Last stage: '${node.name}'. ` +\n            'Check for unbounded recursive chart composition, or raise the limit via RunOptions.maxDepth.',\n        );\n      }\n\n      let current: ContinuationHop<TOut, TScope> = { [CONTINUE_HOP]: true, node, context, branchPath };\n      for (;;) {\n        const result = await this.executeNodeStep(current.node, current.context, breakFlag, current.branchPath);\n        if (!isContinuationHop<TOut, TScope>(result)) {\n          return result;\n        }\n        if (result.invokerStamp) (pendingInvokers ??= []).push(result.invokerStamp);\n        current = result;\n      }\n    } catch (error: unknown) {\n      // Replay invoker stamps most-recent-first. `setInvoker` is\n      // first-write-wins, so the innermost dispatch's stamp lands — exactly\n      // the old bubble-up order through nested catch frames.\n      if (pendingInvokers !== undefined && isPauseSignal(error)) {\n        for (let i = pendingInvokers.length - 1; i >= 0; i--) {\n          error.setInvoker(pendingInvokers[i].invokerStageId, pendingInvokers[i].continuationStageId);\n        }\n      }\n      throw error;\n    } finally {\n      this._executeDepth--;\n    }\n  }\n\n  /** Build a flat continuation hop for the driver loop. */\n  private hop(\n    node: StageNode<TOut, TScope>,\n    context: StageContext,\n    branchPath: string | undefined,\n    invokerStamp?: InvokerStamp,\n  ): ContinuationHop<TOut, TScope> {\n    return { [CONTINUE_HOP]: true, node, context, branchPath, ...(invokerStamp && { invokerStamp }) };\n  }\n\n  /**\n   * Execute ONE node through all 7 phases — the old recursive `executeNode`\n   * body; only the tail calls became `ContinuationHop` returns. Returns the\n   * node's result, or a hop for the driver loop to follow.\n   */\n  private async executeNodeStep(\n    node: StageNode<TOut, TScope>,\n    context: StageContext,\n    breakFlag: BreakFlag,\n    branchPath?: string,\n  ): Promise<any> {\n    // Attach builder metadata to context for snapshot enrichment.\n    // Subflow meta reads go through the dynamic-patch overlay — a node\n    // patched by a dynamic-subflow return re-enters executeNode and must\n    // classify as a subflow without the shared node ever being mutated.\n    if (node.description) context.description = node.description;\n    const effSubflowId = this.effSubflowId(node);\n    if (this.effIsSubflowRoot(node) && effSubflowId) context.subflowId = effSubflowId;\n\n    // Assign runtimeStageId BEFORE traversalContext creation — ensures scope events\n    // (buffered by runtimeStageId) and flow events (flushed by traversalContext.runtimeStageId)\n    // use the same value. Must happen before executeStage AND before traversalContext.\n    const idx = this._executionCounter.value++;\n    context.runtimeStageId = buildRuntimeStageId(node.id, idx);\n\n    // Build traversal context for recorder events — created once per stage, shared by all events\n    const traversalContext: TraversalContext = {\n      runId: this.runId,\n      stageId: node.id ?? context.stageId,\n      runtimeStageId: context.runtimeStageId,\n      stageName: node.name,\n      parentStageId: context.parent?.stageId,\n      subflowId: context.subflowId ?? this.parentSubflowId,\n      subflowPath: branchPath || undefined,\n      depth: this.computeContextDepth(context),\n    };\n\n    // ─── Phase 0a: LAZY RESOLVE — deferred subflow resolution ───\n    // Guard uses the per-traverser resolvedLazySubflows set (not the shared node) so\n    // concurrent traversers do not race on node.subflowResolver or clear it for each other.\n    if (node.isSubflowRoot && node.subflowResolver && !this.resolvedLazySubflows.has(node.subflowId!)) {\n      const resolved = node.subflowResolver();\n      const prefixedRoot = this.prefixNodeTree(resolved.root as StageNode<TOut, TScope>, node.subflowId!);\n\n      // Register the resolved subflow (same path as eager registration)\n      this.subflows[node.subflowId!] = { root: prefixedRoot };\n\n      // Merge stageMap entries\n      for (const [key, fn] of resolved.stageMap) {\n        const prefixedKey = `${node.subflowId}/${key}`;\n        if (!this.stageMap.has(prefixedKey)) {\n          this.stageMap.set(prefixedKey, fn as StageFunction<TOut, TScope>);\n        }\n      }\n\n      // Merge nested subflows\n      if (resolved.subflows) {\n        for (const [key, def] of Object.entries(resolved.subflows)) {\n          const prefixedKey = `${node.subflowId}/${key}`;\n          if (!this.subflows[prefixedKey]) {\n            this.subflows[prefixedKey] = def as { root: StageNode<TOut, TScope> };\n          }\n        }\n      }\n\n      // Update runtime structure with the now-resolved spec\n      this.structureManager.updateDynamicSubflow(\n        node.id,\n        node.subflowId!,\n        node.subflowName,\n        resolved.buildTimeStructure,\n      );\n\n      // Mark as resolved for THIS traverser — per-traverser set prevents re-entry\n      // without mutating the shared StageNode graph (which would race concurrent traversers).\n      this.resolvedLazySubflows.add(node.subflowId!);\n    }\n\n    // ─── Phase 0: CLASSIFY — subflow detection ───\n    if (this.effIsSubflowRoot(node) && effSubflowId) {\n      // Hand helpers the EFFECTIVE node view (built fields + dynamic patch)\n      // so SubflowExecutor/NodeResolver never read stale built fields.\n      const mountNode = this.effNode(node);\n      const resolvedNode = this.nodeResolver.resolveSubflowReference(mountNode);\n\n      const subflowOutput = await this.subflowExecutor.executeSubflow(\n        resolvedNode,\n        context,\n        breakFlag,\n        branchPath,\n        this.subflowResults,\n        traversalContext,\n      );\n\n      const isReferenceBasedSubflow = resolvedNode !== mountNode;\n      const hasChildren = Boolean(mountNode.children && mountNode.children.length > 0);\n      const shouldExecuteContinuation = isReferenceBasedSubflow || hasChildren;\n\n      // ─── Break-flag check AFTER subflow returns ───\n      // If the subflow was mounted with `propagateBreak: true` and broke\n      // internally, `SubflowExecutor` has already flipped our breakFlag.\n      // Stop the outer traversal here — do not run the next linear stage.\n      if (breakFlag.shouldBreak) {\n        return subflowOutput;\n      }\n\n      if (node.next && shouldExecuteContinuation) {\n        const nextCtx = context.createNext(branchPath as string, node.next.name, node.next.id);\n        return this.hop(node.next, nextCtx, branchPath);\n      }\n\n      return subflowOutput;\n    }\n\n    const stageFunc = this.getStageFn(node);\n    const hasStageFunction = Boolean(stageFunc);\n    const isScopeBasedDecider = Boolean(node.deciderFn);\n    const isScopeBasedSelector = Boolean(node.selectorFn);\n    const isDeciderNode = isScopeBasedDecider;\n    const hasChildren = Boolean(this.effChildren(node)?.length);\n    // `next` is never overlaid — a dynamic next applies only to the visit\n    // that produced it (handled via the `dynamicNext` local below), so the\n    // built chart's next is always the correct continuation here.\n    const hasNext = Boolean(node.next);\n    const originalNext = node.next;\n\n    // ─── Phase 1: VALIDATE — node invariants ───\n    if (!hasStageFunction && !isDeciderNode && !isScopeBasedSelector && !hasChildren) {\n      const errorMessage = `Node '${node.name}' must define: embedded fn OR a stageMap entry OR have children/decider`;\n      this.logger.error(`Error in pipeline (${branchPath}) stage [${node.name}]:`, { error: errorMessage });\n      throw new Error(errorMessage);\n    }\n    if (isDeciderNode && !hasChildren) {\n      const errorMessage = 'Decider node needs to have children to execute';\n      this.logger.error(`Error in pipeline (${branchPath}) stage [${node.name}]:`, { error: errorMessage });\n      throw new Error(errorMessage);\n    }\n    if (isScopeBasedSelector && !hasChildren) {\n      const errorMessage = 'Selector node needs to have children to execute';\n      this.logger.error(`Error in pipeline (${branchPath}) stage [${node.name}]:`, { error: errorMessage });\n      throw new Error(errorMessage);\n    }\n\n    // Role markers for debug panels\n    if (!hasStageFunction) {\n      if (isDeciderNode) context.setAsDecider();\n      else if (hasChildren) context.setAsFork();\n    }\n\n    // Break handler wired to the scope. Captures the optional reason\n    // passed via `scope.$break(reason)` and parks it on the breakFlag so\n    // downstream code (FlowRecorder.onBreak, subflow propagation) can\n    // surface it. A second $break call in the same stage keeps the FIRST\n    // reason — first-break-wins — matching the \"execution stopped\" story.\n    const breakFn = (reason?: string) => {\n      breakFlag.shouldBreak = true;\n      if (reason !== undefined && breakFlag.reason === undefined) {\n        breakFlag.reason = reason;\n      }\n    };\n\n    // ─── Phase 2a: SELECTOR — scope-based multi-choice ───\n    if (isScopeBasedSelector) {\n      const selectorResult = await this.selectorHandler.handleScopeBased(\n        node,\n        stageFunc!,\n        context,\n        breakFlag,\n        branchPath,\n        this.executeStage.bind(this),\n        this.executeNode.bind(this),\n        traversalContext,\n      );\n\n      if (hasNext) {\n        const nextCtx = context.createNext(branchPath as string, node.next!.name, node.next!.id);\n        return this.hop(node.next!, nextCtx, branchPath);\n      }\n      return selectorResult;\n    }\n\n    // ─── Phase 2b: DECIDER — scope-based single-choice conditional branch ───\n    if (isDeciderNode) {\n      const dispatch = await this.deciderHandler.prepareDispatch(\n        node,\n        stageFunc!,\n        context,\n        breakFlag,\n        branchPath,\n        this.executeStage.bind(this),\n        traversalContext,\n      );\n\n      // No decider-level continuation → the branch dispatch is a tail\n      // call. Hand it to the driver as a flat hop so loop-heavy decider\n      // charts (e.g. agent ReAct loops with branch-sourced `loopTo`) stay\n      // flat-stacked. The invoker stamp preserves PauseSignal semantics —\n      // the decider is the invoker of whatever pauses in the chain.\n      if (!hasNext && dispatch.kind === 'dispatch') {\n        return this.hop(dispatch.chosen, dispatch.branchContext, branchPath, {\n          invokerStageId: node.id!,\n          continuationStageId: node.next?.id,\n        });\n      }\n\n      // Decider WITH its own next: the branch chain must complete BEFORE\n      // the decider's continuation runs — true tree nesting, kept\n      // recursive (a nested driver). Mirrors handleScopeBased exactly,\n      // including the PauseSignal invoker stamp on bubble-up.\n      let deciderResult: any;\n      if (dispatch.kind === 'break') {\n        deciderResult = dispatch.branchId;\n      } else {\n        try {\n          deciderResult = await this.executeNode(dispatch.chosen, dispatch.branchContext, breakFlag, branchPath);\n        } catch (error: unknown) {\n          if (isPauseSignal(error)) {\n            error.setInvoker(node.id!, node.next?.id);\n          }\n          throw error;\n        }\n      }\n\n      // After branch execution, follow decider's own next (e.g., loopTo target)\n      if (hasNext && !breakFlag.shouldBreak) {\n        const nextNode = originalNext!;\n        // Use the isLoopRef flag set by loopTo() — do not rely on stageMap absence,\n        // since id-keyed stageMaps would otherwise cause loop targets to be executed directly.\n        const isLoopRef =\n          nextNode.isLoopRef === true ||\n          (!this.getStageFn(nextNode) &&\n            !this.effChildren(nextNode)?.length &&\n            !nextNode.deciderFn &&\n            !nextNode.selectorFn &&\n            !this.effIsSubflowRoot(nextNode));\n\n        if (isLoopRef) {\n          const target = this.continuationResolver.resolveTarget(nextNode, node, context, branchPath);\n          return this.hop(target.node, target.context, branchPath);\n        }\n\n        this.narrativeGenerator.onNext(node.name, nextNode.name, nextNode.description, traversalContext);\n        const nextCtx = context.createNext(branchPath as string, nextNode.name, nextNode.id);\n        return this.hop(nextNode, nextCtx, branchPath);\n      }\n\n      return deciderResult;\n    }\n\n    // ─── Abort check — cooperative cancellation ───\n    if (this.signal?.aborted) {\n      const reason =\n        this.signal.reason instanceof Error ? this.signal.reason : new Error(this.signal.reason ?? 'Aborted');\n      throw reason;\n    }\n\n    // ─── Phase 3: EXECUTE — run stage function ───\n    let stageOutput: TOut | undefined;\n    let dynamicNext: StageNode<TOut, TScope> | undefined;\n\n    if (stageFunc) {\n      try {\n        stageOutput = await this.executeStage(node, stageFunc, context, breakFn);\n      } catch (error: any) {\n        // PauseSignal is expected control flow, not an error — fire narrative, commit, re-throw.\n        if (isPauseSignal(error)) {\n          context.commit();\n          this.narrativeGenerator.onPause(node.name, node.id, error.pauseData, error.subflowPath, traversalContext);\n          throw error;\n        }\n        context.commit();\n        this.narrativeGenerator.onError(node.name, error.toString(), error, traversalContext);\n        this.logger.error(`Error in pipeline (${branchPath}) stage [${node.name}]:`, { error });\n        context.addError('stageExecutionError', error.toString());\n        throw error;\n      }\n      context.commit();\n      this.narrativeGenerator.onStageExecuted(node.name, node.description, traversalContext, 'linear');\n\n      if (breakFlag.shouldBreak) {\n        // Forward the optional reason captured on breakFlag — set by the\n        // stage's $break(reason) call OR by a subflow's propagateBreak.\n        this.narrativeGenerator.onBreak(node.name, traversalContext, breakFlag.reason);\n        return stageOutput;\n      }\n\n      // ─── Phase 4: DYNAMIC — StageNode return detection ───\n      if (stageOutput && typeof stageOutput === 'object' && isStageNodeReturn(stageOutput)) {\n        const dynamicNode = stageOutput as StageNode<TOut, TScope>;\n        context.addLog('isDynamic', true);\n        context.addLog('dynamicPattern', 'StageNodeReturn');\n\n        // Dynamic subflow auto-registration. The subflow meta lands in the\n        // traverser-local overlay (NOT on the shared node); the immediate\n        // executeNode re-entry sees it through the eff* accessors and\n        // classifies the node as a subflow mount in Phase 0.\n        if (dynamicNode.isSubflowRoot && dynamicNode.subflowDef && dynamicNode.subflowId) {\n          context.addLog('dynamicPattern', 'dynamicSubflow');\n          context.addLog('dynamicSubflowId', dynamicNode.subflowId);\n\n          this.autoRegisterSubflowDef(dynamicNode.subflowId, dynamicNode.subflowDef, node.id);\n\n          this.getOrCreatePatch(node).subflowMeta = {\n            isSubflowRoot: true,\n            subflowId: dynamicNode.subflowId,\n            subflowName: dynamicNode.subflowName,\n            subflowMountOptions: dynamicNode.subflowMountOptions,\n          };\n\n          this.structureManager.updateDynamicSubflow(\n            node.id,\n            dynamicNode.subflowId!,\n            dynamicNode.subflowName,\n            dynamicNode.subflowDef?.buildTimeStructure,\n          );\n\n          // Re-enter THIS node (same context): the overlay patch makes the\n          // next step classify it as a subflow mount in Phase 0.\n          return this.hop(node, context, branchPath);\n        }\n\n        // Check children for subflowDef\n        if (dynamicNode.children) {\n          for (const child of dynamicNode.children) {\n            if (child.isSubflowRoot && child.subflowDef && child.subflowId) {\n              this.autoRegisterSubflowDef(child.subflowId, child.subflowDef, child.id);\n              this.structureManager.updateDynamicSubflow(\n                child.id,\n                child.subflowId!,\n                child.subflowName,\n                child.subflowDef?.buildTimeStructure,\n              );\n            }\n          }\n        }\n\n        // Dynamic children (fork pattern) — patched into the overlay;\n        // Phase 5 below reads them back through effChildren/effSelector.\n        if (dynamicNode.children && dynamicNode.children.length > 0) {\n          this.getOrCreatePatch(node).children = dynamicNode.children;\n          context.addLog('dynamicChildCount', dynamicNode.children.length);\n          context.addLog(\n            'dynamicChildIds',\n            dynamicNode.children.map((c) => c.id),\n          );\n\n          this.structureManager.updateDynamicChildren(\n            node.id,\n            dynamicNode.children,\n            Boolean(dynamicNode.nextNodeSelector),\n            Boolean(dynamicNode.deciderFn),\n          );\n\n          if (typeof dynamicNode.nextNodeSelector === 'function') {\n            this.getOrCreatePatch(node).nextNodeSelector = dynamicNode.nextNodeSelector;\n            context.addLog('hasSelector', true);\n          }\n        }\n\n        // Dynamic next (linear continuation) — stays a LOCAL: it applies\n        // only to this visit (Phase 6 routes it through the\n        // ContinuationResolver), so the shared node's next is never touched\n        // and a loop revisit naturally sees the built continuation.\n        if (dynamicNode.next) {\n          dynamicNext = dynamicNode.next;\n          this.structureManager.updateDynamicNext(node.id, dynamicNode.next);\n          context.addLog('hasDynamicNext', true);\n        }\n\n        stageOutput = undefined;\n      }\n    }\n\n    // ─── Phase 5: CHILDREN — fork dispatch ───\n    // Re-read through the overlay: Phase 4 may have just patched dynamic\n    // children/selector for THIS visit (or an earlier visit in this run).\n    const childrenAfterStage = this.effChildren(node);\n    const hasChildrenAfterStage = Boolean(childrenAfterStage?.length);\n\n    if (hasChildrenAfterStage) {\n      context.addLog('totalChildren', childrenAfterStage?.length);\n      context.addLog('orderOfExecution', 'ChildrenAfterStage');\n\n      let nodeChildrenResults: Record<string, NodeResultType>;\n\n      const effSelectorFn = this.effSelector(node);\n      if (effSelectorFn) {\n        nodeChildrenResults = await this.childrenExecutor.executeSelectedChildren(\n          effSelectorFn,\n          childrenAfterStage!,\n          stageOutput,\n          context,\n          branchPath as string,\n          traversalContext,\n          node.failFast,\n        );\n      } else {\n        const childCount = childrenAfterStage?.length ?? 0;\n        const childNames = childrenAfterStage?.map((c) => c.name).join(', ');\n        context.addFlowDebugMessage('children', `Executing all ${childCount} children in parallel: ${childNames}`, {\n          count: childCount,\n          targetStage: childrenAfterStage?.map((c) => c.name),\n        });\n\n        // effNode: ChildrenExecutor reads node.children/node.failFast itself.\n        nodeChildrenResults = await this.childrenExecutor.executeNodeChildren(\n          this.effNode(node),\n          context,\n          undefined,\n          branchPath,\n          traversalContext,\n        );\n      }\n\n      // Fork-only: return bundle\n      if (!hasNext && !dynamicNext) {\n        return nodeChildrenResults!;\n      }\n\n      // Capture dynamic children as synthetic subflow result for UI\n      const isDynamic = context.debug?.logContext?.isDynamic;\n      if (isDynamic && childrenAfterStage && childrenAfterStage.length > 0) {\n        this.captureDynamicChildrenResult(node, childrenAfterStage, context);\n      }\n    }\n\n    // ─── Phase 6: CONTINUE — dynamic next / linear next ───\n    if (dynamicNext) {\n      const target = this.continuationResolver.resolveTarget(dynamicNext, node, context, branchPath);\n      return this.hop(target.node, target.context, branchPath);\n    }\n\n    if (hasNext) {\n      const nextNode = originalNext!;\n\n      // Detect loop reference nodes created by loopTo() — marked with isLoopRef flag.\n      // Route through ContinuationResolver for proper ID resolution, iteration\n      // tracking, and narrative generation. The resolved target comes back\n      // as a hop — loop edges consume no stack, so the iteration limit\n      // (not call-stack depth) is what bounds a loop.\n      const isLoopReference = nextNode.isLoopRef;\n\n      if (isLoopReference) {\n        const target = this.continuationResolver.resolveTarget(nextNode, node, context, branchPath, traversalContext);\n        return this.hop(target.node, target.context, branchPath);\n      }\n\n      this.narrativeGenerator.onNext(node.name, nextNode.name, nextNode.description, traversalContext);\n      context.addFlowDebugMessage('next', `Moving to ${nextNode.name} stage`, {\n        targetStage: nextNode.name,\n      });\n      const nextCtx = context.createNext(branchPath as string, nextNode.name, nextNode.id);\n      return this.hop(nextNode, nextCtx, branchPath);\n    }\n\n    // ─── Phase 7: LEAF — no continuation ───\n    return stageOutput;\n  }\n\n  // ─────────────────────── Private Helpers ───────────────────────\n\n  private captureDynamicChildrenResult(\n    node: StageNode<TOut, TScope>,\n    children: StageNode<TOut, TScope>[],\n    context: StageContext,\n  ): void {\n    const parentStageId = context.getStageId();\n\n    const childStructure: any = {\n      id: `${node.id}-children`,\n      name: 'Dynamic Children',\n      type: 'fork',\n      children: children.map((c) => ({\n        id: c.id,\n        name: c.name,\n        type: 'stage',\n      })),\n    };\n\n    const childStages: Record<string, unknown> = {};\n    if (context.children) {\n      for (const childCtx of context.children) {\n        const snapshot = childCtx.getSnapshot();\n        childStages[snapshot.name || snapshot.id] = {\n          name: snapshot.name,\n          output: snapshot.logs,\n          errors: snapshot.errors,\n          metrics: snapshot.metrics,\n          status: snapshot.errors && Object.keys(snapshot.errors).length > 0 ? 'error' : 'success',\n        };\n      }\n    }\n\n    this.subflowResults.set(node.id, {\n      subflowId: node.id,\n      subflowName: node.name,\n      treeContext: {\n        globalContext: {},\n        stageContexts: childStages as unknown as Record<string, unknown>,\n        history: [],\n      },\n      parentStageId,\n      pipelineStructure: childStructure,\n    });\n  }\n\n  /**\n   * Parent-chain length of a StageContext — same value the pre-trampoline\n   * walk produced, memoized. The context tree deepens by one per executed\n   * stage along a chain, so the naive walk is O(chain length) per stage —\n   * O(n²) per run once chains reach trampoline scale. Contexts are visited\n   * parent-before-child, so the cached parent makes this O(1) amortized.\n   */\n  private computeContextDepth(context: StageContext): number {\n    const cached = this.contextDepthCache.get(context);\n    if (cached !== undefined) return cached;\n\n    // Walk up to the nearest cached ancestor (or the root), then fill the\n    // cache back down — iterative, so a cold deep chain can't overflow.\n    const uncached: StageContext[] = [];\n    let depth = -1; // depth of the node ABOVE the first uncached entry\n    let current: StageContext | undefined = context;\n    while (current) {\n      const hit = this.contextDepthCache.get(current);\n      if (hit !== undefined) {\n        depth = hit;\n        break;\n      }\n      uncached.push(current);\n      current = current.parent;\n    }\n    for (let i = uncached.length - 1; i >= 0; i--) {\n      depth++;\n      this.contextDepthCache.set(uncached[i], depth);\n    }\n    return depth;\n  }\n\n  private prefixNodeTree(node: StageNode<TOut, TScope>, prefix: string): StageNode<TOut, TScope> {\n    if (!node) return node;\n    const clone: StageNode<TOut, TScope> = { ...node };\n    clone.name = `${prefix}/${node.name}`;\n    clone.id = `${prefix}/${clone.id}`;\n    if (clone.subflowId) clone.subflowId = `${prefix}/${clone.subflowId}`;\n    if (clone.next) clone.next = this.prefixNodeTree(clone.next, prefix);\n    if (clone.children) {\n      clone.children = clone.children.map((c) => this.prefixNodeTree(c, prefix));\n    }\n    return clone;\n  }\n\n  private autoRegisterSubflowDef(\n    subflowId: string,\n    subflowDef: NonNullable<StageNode['subflowDef']>,\n    mountNodeId?: string,\n  ): void {\n    // this.subflows is always initialized in the constructor; the null guard below is unreachable.\n    const subflowsDict = this.subflows;\n\n    // First-write-wins\n    const isNewRegistration = !subflowsDict[subflowId];\n    if (isNewRegistration && subflowDef.root) {\n      subflowsDict[subflowId] = {\n        root: subflowDef.root as StageNode<TOut, TScope>,\n        ...(subflowDef.buildTimeStructure ? { buildTimeStructure: subflowDef.buildTimeStructure } : {}),\n      } as any;\n    }\n\n    // Merge stageMap entries (parent entries preserved)\n    if (subflowDef.stageMap) {\n      for (const [key, fn] of Array.from(subflowDef.stageMap.entries())) {\n        if (!this.stageMap.has(key)) {\n          this.stageMap.set(key, fn as StageFunction<TOut, TScope>);\n        }\n      }\n    }\n\n    // Merge nested subflows\n    if (subflowDef.subflows) {\n      for (const [key, def] of Object.entries(subflowDef.subflows)) {\n        if (!subflowsDict[key]) {\n          subflowsDict[key] = def as { root: StageNode<TOut, TScope> };\n        }\n      }\n    }\n\n    if (mountNodeId) {\n      this.structureManager.updateDynamicSubflow(\n        mountNodeId,\n        subflowId,\n        subflowDef.root?.subflowName || subflowDef.root?.name,\n        subflowDef.buildTimeStructure,\n      );\n    }\n\n    // Notify FlowRecorders only on first registration (matches first-write-wins)\n    if (isNewRegistration) {\n      const subflowName = subflowDef.root?.subflowName || subflowDef.root?.name || subflowId;\n      this.narrativeGenerator.onSubflowRegistered(\n        subflowId,\n        subflowName,\n        subflowDef.root?.description,\n        subflowDef.buildTimeStructure,\n      );\n    }\n  }\n}\n"]}