footprintjs 0.1.0

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

@@ -0,0 +1,326 @@
+"use strict";
+/**
+ * SubflowExecutor — Isolated recursive execution with I/O mapping.
+ *
+ * Responsibilities:
+ * - Execute subflows with isolated ExecutionRuntime contexts
+ * - Apply input/output mapping via SubflowInputMapper
+ * - Handle nested subflow detection and delegation
+ * - Track subflow results for debugging/visualization
+ *
+ * Each subflow gets its own GlobalStore for isolation.
+ * The subflow's `next` chain after children is NOT executed inside —
+ * the parent's executeNode continues with node.next after return.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubflowExecutor = void 0;
+const StageNode_1 = require("../graph/StageNode");
+const StageRunner_1 = require("./StageRunner");
+const SubflowInputMapper_1 = require("./SubflowInputMapper");
+class SubflowExecutor {
+    constructor(deps, nodeResolver, executeStage, callExtractor, getStageFn) {
+        this.deps = deps;
+        this.nodeResolver = nodeResolver;
+        this.executeStage = executeStage;
+        this.callExtractor = callExtractor;
+        this.getStageFn = getStageFn;
+    }
+    /**
+     * Execute a subflow with isolated context.
+     *
+     * 1. Creates a fresh ExecutionRuntime for the subflow
+     * 2. Applies input mapping to seed the subflow's GlobalStore
+     * 3. Executes the subflow's internal structure
+     * 4. Applies output mapping to write results back to parent scope
+     * 5. Stores execution data for debugging/visualization
+     */
+    async executeSubflow(node, parentContext, breakFlag, branchPath, subflowResultsMap) {
+        var _a, _b;
+        const subflowId = node.subflowId;
+        const subflowName = (_a = node.subflowName) !== null && _a !== void 0 ? _a : node.name;
+        parentContext.addFlowDebugMessage('subflow', `Entering ${subflowName} subflow`, {
+            targetStage: subflowId,
+        });
+        this.deps.narrativeGenerator.onSubflowEntry(subflowName);
+        parentContext.addLog('isSubflowContainer', true);
+        parentContext.addLog('subflowId', subflowId);
+        parentContext.addLog('subflowName', subflowName);
+        // ─── Input Mapping ───
+        const mountOptions = node.subflowMountOptions;
+        let mappedInput = {};
+        if (mountOptions) {
+            try {
+                const parentScope = parentContext.getScope();
+                mappedInput = (0, SubflowInputMapper_1.getInitialScopeValues)(parentScope, mountOptions);
+                if (Object.keys(mappedInput).length > 0) {
+                    parentContext.addLog('mappedInput', mappedInput);
+                }
+            }
+            catch (error) {
+                parentContext.addError('inputMapperError', error.toString());
+                this.deps.logger.error(`Error in inputMapper for subflow (${subflowId}):`, { error });
+                throw error;
+            }
+        }
+        // Create isolated runtime via dynamic construction (avoids circular import)
+        const ExecutionRuntimeClass = this.deps.executionRuntime.constructor;
+        const nestedRuntime = new ExecutionRuntimeClass(node.name);
+        let nestedRootContext = nestedRuntime.rootStageContext;
+        // Seed GlobalStore with input
+        if (Object.keys(mappedInput).length > 0) {
+            (0, SubflowInputMapper_1.seedSubflowGlobalStore)(nestedRuntime, mappedInput);
+            // Refresh rootStageContext so WriteBuffer sees committed data
+            const StageContextClass = nestedRootContext.constructor;
+            nestedRootContext = new StageContextClass('', nestedRootContext.stageName, nestedRuntime.globalStore, '', nestedRuntime.executionHistory);
+            nestedRuntime.rootStageContext = nestedRootContext;
+        }
+        // Create subflow HandlerDeps
+        const subflowDeps = (0, SubflowInputMapper_1.createSubflowHandlerDeps)(this.deps, nestedRuntime, mappedInput);
+        parentContext.addLog('subflowReadOnlyContext', mappedInput);
+        const subflowBreakFlag = { shouldBreak: false };
+        const hasChildren = Boolean(node.children && node.children.length > 0);
+        const subflowNode = {
+            ...node,
+            isSubflowRoot: false,
+            next: hasChildren ? undefined : node.next,
+        };
+        let subflowOutput;
+        let subflowError;
+        try {
+            this.subflowResultsMap = subflowResultsMap;
+            this.currentSubflowRoot = subflowNode;
+            this.currentSubflowDeps = subflowDeps;
+            subflowOutput = await this.executeSubflowInternal(subflowNode, nestedRootContext, subflowBreakFlag, subflowId);
+        }
+        catch (error) {
+            subflowError = error;
+            parentContext.addError('subflowError', error.toString());
+            this.deps.logger.error(`Error in subflow (${subflowId}):`, { error });
+        }
+        finally {
+            this.currentSubflowRoot = undefined;
+            this.currentSubflowDeps = undefined;
+        }
+        const subflowTreeContext = nestedRuntime.getSnapshot();
+        // ─── Output Mapping ───
+        if (!subflowError && (mountOptions === null || mountOptions === void 0 ? void 0 : mountOptions.outputMapper)) {
+            try {
+                let outputContext = parentContext;
+                if (parentContext.branchId && parentContext.branchId !== '' && parentContext.parent) {
+                    outputContext = parentContext.parent;
+                }
+                const parentScope = outputContext.getScope();
+                const mappedOutput = (0, SubflowInputMapper_1.applyOutputMapping)(subflowOutput, parentScope, outputContext, mountOptions);
+                if (mappedOutput && Object.keys(mappedOutput).length > 0) {
+                    parentContext.addLog('mappedOutput', mappedOutput);
+                    parentContext.addLog('outputMappingTarget', outputContext.branchId || '(root)');
+                }
+                outputContext.commit();
+            }
+            catch (error) {
+                parentContext.addError('outputMapperError', error.toString());
+                this.deps.logger.error(`Error in outputMapper for subflow (${subflowId}):`, { error });
+            }
+        }
+        const subflowResult = {
+            subflowId,
+            subflowName,
+            treeContext: {
+                globalContext: subflowTreeContext.sharedState,
+                stageContexts: subflowTreeContext.executionTree,
+                history: subflowTreeContext.commitLog,
+            },
+            parentStageId: parentContext.getStageId(),
+        };
+        const subflowDef = (_b = this.deps.subflows) === null || _b === void 0 ? void 0 : _b[subflowId];
+        if (subflowDef && subflowDef.buildTimeStructure) {
+            subflowResult.pipelineStructure = subflowDef.buildTimeStructure;
+        }
+        parentContext.addLog('subflowResult', subflowResult);
+        parentContext.addLog('hasSubflowData', true);
+        subflowResultsMap.set(subflowId, subflowResult);
+        parentContext.addFlowDebugMessage('subflow', `Exiting ${subflowName} subflow`, {
+            targetStage: subflowId,
+        });
+        this.deps.narrativeGenerator.onSubflowExit(subflowName);
+        parentContext.commit();
+        if (subflowError) {
+            throw subflowError;
+        }
+        return subflowOutput;
+    }
+    /**
+     * Internal execution within subflow context.
+     * Mirrors the traverser's executeNode but within the subflow's isolated runtime.
+     */
+    async executeSubflowInternal(node, context, breakFlag, branchPath) {
+        var _a;
+        // Detect nested subflows
+        if (node.isSubflowRoot && node.subflowId) {
+            const resolvedNode = this.nodeResolver.resolveSubflowReference(node);
+            return await this.executeSubflow(resolvedNode, context, breakFlag, branchPath, this.subflowResultsMap);
+        }
+        const stageFunc = this.getStageFn(node);
+        const breakFn = () => (breakFlag.shouldBreak = true);
+        let stageOutput;
+        if (stageFunc) {
+            try {
+                if (this.currentSubflowDeps) {
+                    const subflowStageRunner = new StageRunner_1.StageRunner(this.currentSubflowDeps);
+                    stageOutput = await subflowStageRunner.run(node, stageFunc, context, breakFn);
+                }
+                else {
+                    stageOutput = await this.executeStage(node, stageFunc, context, breakFn);
+                }
+            }
+            catch (error) {
+                context.commit();
+                this.callExtractor(node, context, this.getStagePath(node, branchPath, context.stageName), undefined, {
+                    type: 'stageExecutionError',
+                    message: error.toString(),
+                });
+                context.addError('stageExecutionError', error.toString());
+                throw error;
+            }
+            context.commit();
+            this.callExtractor(node, context, this.getStagePath(node, branchPath, context.stageName), stageOutput);
+            if (breakFlag.shouldBreak) {
+                return stageOutput;
+            }
+            // Handle dynamic StageNode return
+            if (stageOutput && typeof stageOutput === 'object' && (0, StageNode_1.isStageNodeReturn)(stageOutput)) {
+                const dynamicNode = stageOutput;
+                context.addLog('isDynamic', true);
+                context.addLog('dynamicPattern', 'StageNodeReturn');
+                if (dynamicNode.children && dynamicNode.children.length > 0) {
+                    node.children = dynamicNode.children;
+                    context.addLog('dynamicChildCount', dynamicNode.children.length);
+                    context.addLog('dynamicChildIds', dynamicNode.children.map((c) => c.id || c.name));
+                    if (typeof dynamicNode.nextNodeSelector === 'function') {
+                        node.nextNodeSelector = dynamicNode.nextNodeSelector;
+                        context.addLog('hasSelector', true);
+                    }
+                }
+                if (dynamicNode.next) {
+                    node.next = dynamicNode.next;
+                    context.addLog('hasDynamicNext', true);
+                    const loopTargetId = dynamicNode.next.id || dynamicNode.next.name;
+                    if (loopTargetId) {
+                        context.addLog('loopTarget', loopTargetId);
+                    }
+                }
+                stageOutput = undefined;
+            }
+        }
+        // ─── Children dispatch ───
+        const hasChildrenAfterStage = Boolean((_a = node.children) === null || _a === void 0 ? void 0 : _a.length);
+        const hasNextAfterStage = Boolean(node.next);
+        if (hasChildrenAfterStage) {
+            if (node.nextNodeSelector) {
+                const results = await this.executeSelectedChildrenInternal(node.nextNodeSelector, node.children, stageOutput, context, branchPath, breakFlag);
+                if (!hasNextAfterStage)
+                    return results;
+            }
+            else {
+                const results = await this.executeNodeChildrenInternal(node, context, branchPath, breakFlag);
+                if (!hasNextAfterStage)
+                    return results;
+            }
+        }
+        // ─── Linear next ───
+        if (hasNextAfterStage) {
+            let nextNode = node.next;
+            // Resolve reference nodes (has id but no fn)
+            if (nextNode.id && !nextNode.fn) {
+                let resolvedNode;
+                if (this.currentSubflowRoot) {
+                    resolvedNode = this.nodeResolver.findNodeById(nextNode.id, this.currentSubflowRoot);
+                    if (resolvedNode)
+                        context.addLog('dynamicNextResolvedFrom', 'subflow');
+                }
+                if (!resolvedNode) {
+                    resolvedNode = this.nodeResolver.findNodeById(nextNode.id);
+                    if (resolvedNode)
+                        context.addLog('dynamicNextResolvedFrom', 'mainPipeline');
+                }
+                if (resolvedNode) {
+                    nextNode = resolvedNode;
+                    context.addLog('dynamicNextResolved', true);
+                    context.addLog('dynamicNextTarget', nextNode.id);
+                }
+                else {
+                    this.deps.logger.info(`Dynamic next node '${nextNode.id}' not found in subflow or main pipeline`);
+                    context.addLog('dynamicNextResolved', false);
+                    context.addLog('dynamicNextNotFound', nextNode.id);
+                }
+            }
+            const nextCtx = context.createNext('', nextNode.name);
+            return await this.executeSubflowInternal(nextNode, nextCtx, breakFlag, branchPath);
+        }
+        return stageOutput;
+    }
+    getStagePath(node, branchPath, contextStageName) {
+        var _a;
+        const baseName = (_a = node.id) !== null && _a !== void 0 ? _a : node.name;
+        const nodeId = contextStageName && contextStageName !== node.name ? contextStageName : baseName;
+        if (!branchPath)
+            return nodeId;
+        return `${branchPath}.${nodeId}`;
+    }
+    async executeNodeChildrenInternal(node, context, branchPath, breakFlag) {
+        var _a;
+        const childPromises = ((_a = node.children) !== null && _a !== void 0 ? _a : []).map((child) => {
+            const childContext = context.createChild('', child.id, child.name);
+            const childBreakFlag = { shouldBreak: false };
+            return this.executeSubflowInternal(child, childContext, childBreakFlag, branchPath)
+                .then((result) => {
+                childContext.commit();
+                return { id: child.id, result, isError: false };
+            })
+                .catch((error) => {
+                childContext.commit();
+                this.deps.logger.info(`TREE PIPELINE: executeNodeChildrenInternal - Error for id: ${child === null || child === void 0 ? void 0 : child.id}`, { error });
+                return { id: child.id, result: error, isError: true };
+            });
+        });
+        const settled = await Promise.allSettled(childPromises);
+        const childrenResults = {};
+        settled.forEach((s) => {
+            if (s.status === 'fulfilled') {
+                const { id, result, isError } = s.value;
+                childrenResults[id] = { id, result, isError };
+            }
+            else {
+                this.deps.logger.error(`Execution failed: ${s.reason}`);
+            }
+        });
+        return childrenResults;
+    }
+    async executeSelectedChildrenInternal(selector, children, input, context, branchPath, breakFlag) {
+        const selectorResult = await selector(input);
+        const selectedIds = Array.isArray(selectorResult) ? selectorResult : [selectorResult];
+        context.addLog('selectedChildIds', selectedIds);
+        context.addLog('selectorPattern', 'multi-choice');
+        if (selectedIds.length === 0) {
+            context.addLog('skippedAllChildren', true);
+            return {};
+        }
+        const selectedChildren = children.filter((c) => selectedIds.includes(c.id));
+        if (selectedChildren.length !== selectedIds.length) {
+            const childIds = children.map((c) => c.id);
+            const missing = selectedIds.filter((id) => !childIds.includes(id));
+            const errorMessage = `Selector returned unknown child IDs: ${missing.join(', ')}. Available: ${childIds.join(', ')}`;
+            this.deps.logger.error(`Error in subflow (${branchPath}):`, { error: errorMessage });
+            context.addError('selectorError', errorMessage);
+            throw new Error(errorMessage);
+        }
+        const skippedIds = children.filter((c) => !selectedIds.includes(c.id)).map((c) => c.id);
+        if (skippedIds.length > 0) {
+            context.addLog('skippedChildIds', skippedIds);
+        }
+        const tempNode = { name: 'selector-temp', children: selectedChildren };
+        return await this.executeNodeChildrenInternal(tempNode, context, branchPath, breakFlag);
+    }
+}
+exports.SubflowExecutor = SubflowExecutor;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SubflowExecutor.js","sourceRoot":"","sources":["../../../../src/lib/engine/handlers/SubflowExecutor.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;;AAIH,kDAAuD;AAGvD,+CAA4C;AAC5C,6DAK8B;AAwB9B,MAAa,eAAe;IAK1B,YACU,IAA+B,EAC/B,YAAwC,EACxC,YAA0C,EAC1C,aAA4C,EAC5C,UAAsC;QAJtC,SAAI,GAAJ,IAAI,CAA2B;QAC/B,iBAAY,GAAZ,YAAY,CAA4B;QACxC,iBAAY,GAAZ,YAAY,CAA8B;QAC1C,kBAAa,GAAb,aAAa,CAA+B;QAC5C,eAAU,GAAV,UAAU,CAA4B;IAC7C,CAAC;IAEJ;;;;;;;;OAQG;IACH,KAAK,CAAC,cAAc,CAClB,IAA6B,EAC7B,aAA2B,EAC3B,SAAmC,EACnC,UAA8B,EAC9B,iBAA6C;;QAE7C,MAAM,SAAS,GAAG,IAAI,CAAC,SAAU,CAAC;QAClC,MAAM,WAAW,GAAG,MAAA,IAAI,CAAC,WAAW,mCAAI,IAAI,CAAC,IAAI,CAAC;QAElD,aAAa,CAAC,mBAAmB,CAAC,SAAS,EAAE,YAAY,WAAW,UAAU,EAAE;YAC9E,WAAW,EAAE,SAAS;SACvB,CAAC,CAAC;QACH,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;QAEzD,aAAa,CAAC,MAAM,CAAC,oBAAoB,EAAE,IAAI,CAAC,CAAC;QACjD,aAAa,CAAC,MAAM,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;QAC7C,aAAa,CAAC,MAAM,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC;QAEjD,wBAAwB;QACxB,MAAM,YAAY,GAAG,IAAI,CAAC,mBAAmB,CAAC;QAC9C,IAAI,WAAW,GAA4B,EAAE,CAAC;QAE9C,IAAI,YAAY,EAAE,CAAC;YACjB,IAAI,CAAC;gBACH,MAAM,WAAW,GAAG,aAAa,CAAC,QAAQ,EAAE,CAAC;gBAC7C,WAAW,GAAG,IAAA,0CAAqB,EAAC,WAAW,EAAE,YAAY,CAAC,CAAC;gBAC/D,IAAI,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACxC,aAAa,CAAC,MAAM,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC;gBACnD,CAAC;YACH,CAAC;YAAC,OAAO,KAAU,EAAE,CAAC;gBACpB,aAAa,CAAC,QAAQ,CAAC,kBAAkB,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;gBAC7D,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,qCAAqC,SAAS,IAAI,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;gBACtF,MAAM,KAAK,CAAC;YACd,CAAC;QACH,CAAC;QAED,4EAA4E;QAC5E,MAAM,qBAAqB,GAAG,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,WAAsD,CAAC;QAChH,MAAM,aAAa,GAAG,IAAI,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC3D,IAAI,iBAAiB,GAAG,aAAa,CAAC,gBAAgB,CAAC;QAEvD,8BAA8B;QAC9B,IAAI,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACxC,IAAA,2CAAsB,EAAC,aAAa,EAAE,WAAW,CAAC,CAAC;YACnD,8DAA8D;YAC9D,MAAM,iBAAiB,GAAG,iBAAiB,CAAC,WAAmD,CAAC;YAChG,iBAAiB,GAAG,IAAI,iBAAiB,CACvC,EAAE,EACF,iBAAiB,CAAC,SAAS,EAC3B,aAAa,CAAC,WAAW,EACzB,EAAE,EACF,aAAa,CAAC,gBAAgB,CAC/B,CAAC;YACF,aAAa,CAAC,gBAAgB,GAAG,iBAAiB,CAAC;QACrD,CAAC;QAED,6BAA6B;QAC7B,MAAM,WAAW,GAAG,IAAA,6CAAwB,EAAC,IAAI,CAAC,IAAI,EAAE,aAAa,EAAE,WAAW,CAAC,CAAC;QACpF,aAAa,CAAC,MAAM,CAAC,wBAAwB,EAAE,WAAW,CAAC,CAAC;QAE5D,MAAM,gBAAgB,GAAG,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC;QAEhD,MAAM,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QACvE,MAAM,WAAW,GAA4B;YAC3C,GAAG,IAAI;YACP,aAAa,EAAE,KAAK;YACpB,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI;SAC1C,CAAC;QAEF,IAAI,aAAkB,CAAC;QACvB,IAAI,YAA+B,CAAC;QAEpC,IAAI,CAAC;YACH,IAAI,CAAC,iBAAiB,GAAG,iBAAiB,CAAC;YAC3C,IAAI,CAAC,kBAAkB,GAAG,WAAW,CAAC;YACtC,IAAI,CAAC,kBAAkB,GAAG,WAAW,CAAC;YAEtC,aAAa,GAAG,MAAM,IAAI,CAAC,sBAAsB,CAAC,WAAW,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,SAAS,CAAC,CAAC;QACjH,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,YAAY,GAAG,KAAK,CAAC;YACrB,aAAa,CAAC,QAAQ,CAAC,cAAc,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;YACzD,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,qBAAqB,SAAS,IAAI,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;QACxE,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,kBAAkB,GAAG,SAAS,CAAC;YACpC,IAAI,CAAC,kBAAkB,GAAG,SAAS,CAAC;QACtC,CAAC;QAED,MAAM,kBAAkB,GAAG,aAAa,CAAC,WAAW,EAAE,CAAC;QAEvD,yBAAyB;QACzB,IAAI,CAAC,YAAY,KAAI,YAAY,aAAZ,YAAY,uBAAZ,YAAY,CAAE,YAAY,CAAA,EAAE,CAAC;YAChD,IAAI,CAAC;gBACH,IAAI,aAAa,GAAG,aAAa,CAAC;gBAClC,IAAI,aAAa,CAAC,QAAQ,IAAI,aAAa,CAAC,QAAQ,KAAK,EAAE,IAAI,aAAa,CAAC,MAAM,EAAE,CAAC;oBACpF,aAAa,GAAG,aAAa,CAAC,MAAM,CAAC;gBACvC,CAAC;gBAED,MAAM,WAAW,GAAG,aAAa,CAAC,QAAQ,EAAE,CAAC;gBAC7C,MAAM,YAAY,GAAG,IAAA,uCAAkB,EAAC,aAAa,EAAE,WAAW,EAAE,aAAa,EAAE,YAAY,CAAC,CAAC;gBAEjG,IAAI,YAAY,IAAI,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACzD,aAAa,CAAC,MAAM,CAAC,cAAc,EAAE,YAAY,CAAC,CAAC;oBACnD,aAAa,CAAC,MAAM,CAAC,qBAAqB,EAAE,aAAa,CAAC,QAAQ,IAAI,QAAQ,CAAC,CAAC;gBAClF,CAAC;gBAED,aAAa,CAAC,MAAM,EAAE,CAAC;YACzB,CAAC;YAAC,OAAO,KAAU,EAAE,CAAC;gBACpB,aAAa,CAAC,QAAQ,CAAC,mBAAmB,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;gBAC9D,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,sCAAsC,SAAS,IAAI,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;YACzF,CAAC;QACH,CAAC;QAED,MAAM,aAAa,GAAkB;YACnC,SAAS;YACT,WAAW;YACX,WAAW,EAAE;gBACX,aAAa,EAAE,kBAAkB,CAAC,WAAW;gBAC7C,aAAa,EAAE,kBAAkB,CAAC,aAAmD;gBACrF,OAAO,EAAE,kBAAkB,CAAC,SAAS;aACtC;YACD,aAAa,EAAE,aAAa,CAAC,UAAU,EAAE;SAC1C,CAAC;QAEF,MAAM,UAAU,GAAG,MAAA,IAAI,CAAC,IAAI,CAAC,QAAQ,0CAAG,SAAS,CAAC,CAAC;QACnD,IAAI,UAAU,IAAK,UAAkB,CAAC,kBAAkB,EAAE,CAAC;YACzD,aAAa,CAAC,iBAAiB,GAAI,UAAkB,CAAC,kBAAkB,CAAC;QAC3E,CAAC;QAED,aAAa,CAAC,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,CAAC;QACrD,aAAa,CAAC,MAAM,CAAC,gBAAgB,EAAE,IAAI,CAAC,CAAC;QAC7C,iBAAiB,CAAC,GAAG,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;QAEhD,aAAa,CAAC,mBAAmB,CAAC,SAAS,EAAE,WAAW,WAAW,UAAU,EAAE;YAC7E,WAAW,EAAE,SAAS;SACvB,CAAC,CAAC;QACH,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC;QAExD,aAAa,CAAC,MAAM,EAAE,CAAC;QAEvB,IAAI,YAAY,EAAE,CAAC;YACjB,MAAM,YAAY,CAAC;QACrB,CAAC;QAED,OAAO,aAAa,CAAC;IACvB,CAAC;IAED;;;OAGG;IACK,KAAK,CAAC,sBAAsB,CAClC,IAA6B,EAC7B,OAAqB,EACrB,SAAmC,EACnC,UAAkB;;QAElB,yBAAyB;QACzB,IAAI,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACzC,MAAM,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC,uBAAuB,CAAC,IAAI,CAAC,CAAC;YACrE,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,IAAI,CAAC,iBAAkB,CAAC,CAAC;QAC1G,CAAC;QAED,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QACxC,MAAM,OAAO,GAAG,GAAG,EAAE,CAAC,CAAC,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;QAErD,IAAI,WAA6B,CAAC;QAClC,IAAI,SAAS,EAAE,CAAC;YACd,IAAI,CAAC;gBACH,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;oBAC5B,MAAM,kBAAkB,GAAG,IAAI,yBAAW,CAAe,IAAI,CAAC,kBAAkB,CAAC,CAAC;oBAClF,WAAW,GAAG,MAAM,kBAAkB,CAAC,GAAG,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;gBAChF,CAAC;qBAAM,CAAC;oBACN,WAAW,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;gBAC3E,CAAC;YACH,CAAC;YAAC,OAAO,KAAU,EAAE,CAAC;gBACpB,OAAO,CAAC,MAAM,EAAE,CAAC;gBACjB,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,SAAS,CAAC,EAAE,SAAS,EAAE;oBACnG,IAAI,EAAE,qBAAqB;oBAC3B,OAAO,EAAE,KAAK,CAAC,QAAQ,EAAE;iBAC1B,CAAC,CAAC;gBACH,OAAO,CAAC,QAAQ,CAAC,qBAAqB,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;gBAC1D,MAAM,KAAK,CAAC;YACd,CAAC;YACD,OAAO,CAAC,MAAM,EAAE,CAAC;YACjB,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,SAAS,CAAC,EAAE,WAAW,CAAC,CAAC;YAEvG,IAAI,SAAS,CAAC,WAAW,EAAE,CAAC;gBAC1B,OAAO,WAAW,CAAC;YACrB,CAAC;YAED,kCAAkC;YAClC,IAAI,WAAW,IAAI,OAAO,WAAW,KAAK,QAAQ,IAAI,IAAA,6BAAiB,EAAC,WAAW,CAAC,EAAE,CAAC;gBACrF,MAAM,WAAW,GAAG,WAAsC,CAAC;gBAC3D,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;gBAClC,OAAO,CAAC,MAAM,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAAC;gBAEpD,IAAI,WAAW,CAAC,QAAQ,IAAI,WAAW,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBAC5D,IAAI,CAAC,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC;oBACrC,OAAO,CAAC,MAAM,CAAC,mBAAmB,EAAE,WAAW,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;oBACjE,OAAO,CAAC,MAAM,CACZ,iBAAiB,EACjB,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC,CAChD,CAAC;oBAEF,IAAI,OAAO,WAAW,CAAC,gBAAgB,KAAK,UAAU,EAAE,CAAC;wBACvD,IAAI,CAAC,gBAAgB,GAAG,WAAW,CAAC,gBAAgB,CAAC;wBACrD,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC;oBACtC,CAAC;gBACH,CAAC;gBAED,IAAI,WAAW,CAAC,IAAI,EAAE,CAAC;oBACrB,IAAI,CAAC,IAAI,GAAG,WAAW,CAAC,IAAI,CAAC;oBAC7B,OAAO,CAAC,MAAM,CAAC,gBAAgB,EAAE,IAAI,CAAC,CAAC;oBACvC,MAAM,YAAY,GAAG,WAAW,CAAC,IAAI,CAAC,EAAE,IAAI,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC;oBAClE,IAAI,YAAY,EAAE,CAAC;wBACjB,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;oBAC7C,CAAC;gBACH,CAAC;gBAED,WAAW,GAAG,SAAS,CAAC;YAC1B,CAAC;QACH,CAAC;QAED,4BAA4B;QAC5B,MAAM,qBAAqB,GAAG,OAAO,CAAC,MAAA,IAAI,CAAC,QAAQ,0CAAE,MAAM,CAAC,CAAC;QAC7D,MAAM,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAE7C,IAAI,qBAAqB,EAAE,CAAC;YAC1B,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;gBAC1B,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,+BAA+B,CACxD,IAAI,CAAC,gBAAgB,EACrB,IAAI,CAAC,QAAS,EACd,WAAW,EACX,OAAO,EACP,UAAU,EACV,SAAS,CACV,CAAC;gBACF,IAAI,CAAC,iBAAiB;oBAAE,OAAO,OAAO,CAAC;YACzC,CAAC;iBAAM,CAAC;gBACN,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,2BAA2B,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC;gBAC7F,IAAI,CAAC,iBAAiB;oBAAE,OAAO,OAAO,CAAC;YACzC,CAAC;QACH,CAAC;QAED,sBAAsB;QACtB,IAAI,iBAAiB,EAAE,CAAC;YACtB,IAAI,QAAQ,GAAG,IAAI,CAAC,IAAK,CAAC;YAE1B,6CAA6C;YAC7C,IAAI,QAAQ,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;gBAChC,IAAI,YAAiD,CAAC;gBACtD,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;oBAC5B,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC;oBACpF,IAAI,YAAY;wBAAE,OAAO,CAAC,MAAM,CAAC,yBAAyB,EAAE,SAAS,CAAC,CAAC;gBACzE,CAAC;gBACD,IAAI,CAAC,YAAY,EAAE,CAAC;oBAClB,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;oBAC3D,IAAI,YAAY;wBAAE,OAAO,CAAC,MAAM,CAAC,yBAAyB,EAAE,cAAc,CAAC,CAAC;gBAC9E,CAAC;gBACD,IAAI,YAAY,EAAE,CAAC;oBACjB,QAAQ,GAAG,YAAY,CAAC;oBACxB,OAAO,CAAC,MAAM,CAAC,qBAAqB,EAAE,IAAI,CAAC,CAAC;oBAC5C,OAAO,CAAC,MAAM,CAAC,mBAAmB,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;gBACnD,CAAC;qBAAM,CAAC;oBACN,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,sBAAsB,QAAQ,CAAC,EAAE,yCAAyC,CAAC,CAAC;oBAClG,OAAO,CAAC,MAAM,CAAC,qBAAqB,EAAE,KAAK,CAAC,CAAC;oBAC7C,OAAO,CAAC,MAAM,CAAC,qBAAqB,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;gBACrD,CAAC;YACH,CAAC;YAED,MAAM,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;YACtD,OAAO,MAAM,IAAI,CAAC,sBAAsB,CAAC,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;QACrF,CAAC;QAED,OAAO,WAAW,CAAC;IACrB,CAAC;IAEO,YAAY,CAAC,IAA6B,EAAE,UAAmB,EAAE,gBAAyB;;QAChG,MAAM,QAAQ,GAAG,MAAA,IAAI,CAAC,EAAE,mCAAI,IAAI,CAAC,IAAI,CAAC;QACtC,MAAM,MAAM,GAAG,gBAAgB,IAAI,gBAAgB,KAAK,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,QAAQ,CAAC;QAChG,IAAI,CAAC,UAAU;YAAE,OAAO,MAAM,CAAC;QAC/B,OAAO,GAAG,UAAU,IAAI,MAAM,EAAE,CAAC;IACnC,CAAC;IAEO,KAAK,CAAC,2BAA2B,CACvC,IAA6B,EAC7B,OAAqB,EACrB,UAAkB,EAClB,SAAmC;;QAEnC,MAAM,aAAa,GAA8B,CAAC,MAAA,IAAI,CAAC,QAAQ,mCAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;YACnF,MAAM,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,EAAE,EAAE,KAAK,CAAC,EAAY,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;YAC7E,MAAM,cAAc,GAAG,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC;YAE9C,OAAO,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,UAAU,CAAC;iBAChF,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;gBACf,YAAY,CAAC,MAAM,EAAE,CAAC;gBACtB,OAAO,EAAE,EAAE,EAAE,KAAK,CAAC,EAAG,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;YACnD,CAAC,CAAC;iBACD,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;gBACf,YAAY,CAAC,MAAM,EAAE,CAAC;gBACtB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,8DAA8D,KAAK,aAAL,KAAK,uBAAL,KAAK,CAAE,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;gBAC5G,OAAO,EAAE,EAAE,EAAE,KAAK,CAAC,EAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;YACzD,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;QAEH,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;QACxD,MAAM,eAAe,GAAmC,EAAE,CAAC;QAC3D,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE;YACpB,IAAI,CAAC,CAAC,MAAM,KAAK,WAAW,EAAE,CAAC;gBAC7B,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC;gBACxC,eAAe,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;YAChD,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;YAC1D,CAAC;QACH,CAAC,CAAC,CAAC;QACH,OAAO,eAAe,CAAC;IACzB,CAAC;IAEO,KAAK,CAAC,+BAA+B,CAC3C,QAAkB,EAClB,QAAmC,EACnC,KAAU,EACV,OAAqB,EACrB,UAAkB,EAClB,SAAmC;QAEnC,MAAM,cAAc,GAAG,MAAM,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC7C,MAAM,WAAW,GAAG,KAAK,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC;QAEtF,OAAO,CAAC,MAAM,CAAC,kBAAkB,EAAE,WAAW,CAAC,CAAC;QAChD,OAAO,CAAC,MAAM,CAAC,iBAAiB,EAAE,cAAc,CAAC,CAAC;QAElD,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC7B,OAAO,CAAC,MAAM,CAAC,oBAAoB,EAAE,IAAI,CAAC,CAAC;YAC3C,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,MAAM,gBAAgB,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAG,CAAC,CAAC,CAAC;QAC7E,IAAI,gBAAgB,CAAC,MAAM,KAAK,WAAW,CAAC,MAAM,EAAE,CAAC;YACnD,MAAM,QAAQ,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YAC3C,MAAM,OAAO,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;YACnE,MAAM,YAAY,GAAG,wCAAwC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAgB,QAAQ,CAAC,IAAI,CAC1G,IAAI,CACL,EAAE,CAAC;YACJ,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,qBAAqB,UAAU,IAAI,EAAE,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC,CAAC;YACrF,OAAO,CAAC,QAAQ,CAAC,eAAe,EAAE,YAAY,CAAC,CAAC;YAChD,MAAM,IAAI,KAAK,CAAC,YAAY,CAAC,CAAC;QAChC,CAAC;QAED,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QACzF,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC1B,OAAO,CAAC,MAAM,CAAC,iBAAiB,EAAE,UAAU,CAAC,CAAC;QAChD,CAAC;QAED,MAAM,QAAQ,GAA4B,EAAE,IAAI,EAAE,eAAe,EAAE,QAAQ,EAAE,gBAAgB,EAAE,CAAC;QAChG,OAAO,MAAM,IAAI,CAAC,2BAA2B,CAAC,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC;IAC1F,CAAC;CACF;AA7XD,0CA6XC","sourcesContent":["/**\n * SubflowExecutor — Isolated recursive execution with I/O mapping.\n *\n * Responsibilities:\n * - Execute subflows with isolated ExecutionRuntime contexts\n * - Apply input/output mapping via SubflowInputMapper\n * - Handle nested subflow detection and delegation\n * - Track subflow results for debugging/visualization\n *\n * Each subflow gets its own GlobalStore for isolation.\n * The subflow's `next` chain after children is NOT executed inside —\n * the parent's executeNode continues with node.next after return.\n */\n\nimport type { StageContext } from '../../memory/StageContext';\nimport type { Selector, StageNode } from '../graph/StageNode';\nimport { isStageNodeReturn } from '../graph/StageNode';\nimport type { HandlerDeps, IExecutionRuntime, NodeResultType, StageFunction, SubflowResult } from '../types';\nimport type { NodeResolver } from './NodeResolver';\nimport { StageRunner } from './StageRunner';\nimport {\n  applyOutputMapping,\n  createSubflowHandlerDeps,\n  getInitialScopeValues,\n  seedSubflowGlobalStore,\n} from './SubflowInputMapper';\n\n/** Callback for running a stage function. Avoids circular dep with traverser. */\nexport type ExecuteStageFn<TOut = any, TScope = any> = (\n  node: StageNode<TOut, TScope>,\n  stageFunc: StageFunction<TOut, TScope>,\n  context: StageContext,\n  breakFn: () => void,\n) => Promise<TOut>;\n\n/** Callback for calling the traversal extractor. */\nexport type CallExtractorFn<TOut = any, TScope = any> = (\n  node: StageNode<TOut, TScope>,\n  context: StageContext,\n  stagePath: string,\n  stageOutput?: unknown,\n  errorInfo?: { type: string; message: string },\n) => void;\n\n/** Callback for getting a stage function from the stage map. */\nexport type GetStageFnFn<TOut = any, TScope = any> = (\n  node: StageNode<TOut, TScope>,\n) => StageFunction<TOut, TScope> | undefined;\n\nexport class SubflowExecutor<TOut = any, TScope = any> {\n  private currentSubflowDeps?: HandlerDeps<TOut, TScope>;\n  private currentSubflowRoot?: StageNode<TOut, TScope>;\n  private subflowResultsMap?: Map<string, SubflowResult>;\n\n  constructor(\n    private deps: HandlerDeps<TOut, TScope>,\n    private nodeResolver: NodeResolver<TOut, TScope>,\n    private executeStage: ExecuteStageFn<TOut, TScope>,\n    private callExtractor: CallExtractorFn<TOut, TScope>,\n    private getStageFn: GetStageFnFn<TOut, TScope>,\n  ) {}\n\n  /**\n   * Execute a subflow with isolated context.\n   *\n   * 1. Creates a fresh ExecutionRuntime for the subflow\n   * 2. Applies input mapping to seed the subflow's GlobalStore\n   * 3. Executes the subflow's internal structure\n   * 4. Applies output mapping to write results back to parent scope\n   * 5. Stores execution data for debugging/visualization\n   */\n  async executeSubflow(\n    node: StageNode<TOut, TScope>,\n    parentContext: StageContext,\n    breakFlag: { shouldBreak: boolean },\n    branchPath: string | undefined,\n    subflowResultsMap: Map<string, SubflowResult>,\n  ): Promise<any> {\n    const subflowId = node.subflowId!;\n    const subflowName = node.subflowName ?? node.name;\n\n    parentContext.addFlowDebugMessage('subflow', `Entering ${subflowName} subflow`, {\n      targetStage: subflowId,\n    });\n    this.deps.narrativeGenerator.onSubflowEntry(subflowName);\n\n    parentContext.addLog('isSubflowContainer', true);\n    parentContext.addLog('subflowId', subflowId);\n    parentContext.addLog('subflowName', subflowName);\n\n    // ─── Input Mapping ───\n    const mountOptions = node.subflowMountOptions;\n    let mappedInput: Record<string, unknown> = {};\n\n    if (mountOptions) {\n      try {\n        const parentScope = parentContext.getScope();\n        mappedInput = getInitialScopeValues(parentScope, mountOptions);\n        if (Object.keys(mappedInput).length > 0) {\n          parentContext.addLog('mappedInput', mappedInput);\n        }\n      } catch (error: any) {\n        parentContext.addError('inputMapperError', error.toString());\n        this.deps.logger.error(`Error in inputMapper for subflow (${subflowId}):`, { error });\n        throw error;\n      }\n    }\n\n    // Create isolated runtime via dynamic construction (avoids circular import)\n    const ExecutionRuntimeClass = this.deps.executionRuntime.constructor as new (name: string) => IExecutionRuntime;\n    const nestedRuntime = new ExecutionRuntimeClass(node.name);\n    let nestedRootContext = nestedRuntime.rootStageContext;\n\n    // Seed GlobalStore with input\n    if (Object.keys(mappedInput).length > 0) {\n      seedSubflowGlobalStore(nestedRuntime, mappedInput);\n      // Refresh rootStageContext so WriteBuffer sees committed data\n      const StageContextClass = nestedRootContext.constructor as new (...args: any[]) => StageContext;\n      nestedRootContext = new StageContextClass(\n        '',\n        nestedRootContext.stageName,\n        nestedRuntime.globalStore,\n        '',\n        nestedRuntime.executionHistory,\n      );\n      nestedRuntime.rootStageContext = nestedRootContext;\n    }\n\n    // Create subflow HandlerDeps\n    const subflowDeps = createSubflowHandlerDeps(this.deps, nestedRuntime, mappedInput);\n    parentContext.addLog('subflowReadOnlyContext', mappedInput);\n\n    const subflowBreakFlag = { shouldBreak: false };\n\n    const hasChildren = Boolean(node.children && node.children.length > 0);\n    const subflowNode: StageNode<TOut, TScope> = {\n      ...node,\n      isSubflowRoot: false,\n      next: hasChildren ? undefined : node.next,\n    };\n\n    let subflowOutput: any;\n    let subflowError: Error | undefined;\n\n    try {\n      this.subflowResultsMap = subflowResultsMap;\n      this.currentSubflowRoot = subflowNode;\n      this.currentSubflowDeps = subflowDeps;\n\n      subflowOutput = await this.executeSubflowInternal(subflowNode, nestedRootContext, subflowBreakFlag, subflowId);\n    } catch (error: any) {\n      subflowError = error;\n      parentContext.addError('subflowError', error.toString());\n      this.deps.logger.error(`Error in subflow (${subflowId}):`, { error });\n    } finally {\n      this.currentSubflowRoot = undefined;\n      this.currentSubflowDeps = undefined;\n    }\n\n    const subflowTreeContext = nestedRuntime.getSnapshot();\n\n    // ─── Output Mapping ───\n    if (!subflowError && mountOptions?.outputMapper) {\n      try {\n        let outputContext = parentContext;\n        if (parentContext.branchId && parentContext.branchId !== '' && parentContext.parent) {\n          outputContext = parentContext.parent;\n        }\n\n        const parentScope = outputContext.getScope();\n        const mappedOutput = applyOutputMapping(subflowOutput, parentScope, outputContext, mountOptions);\n\n        if (mappedOutput && Object.keys(mappedOutput).length > 0) {\n          parentContext.addLog('mappedOutput', mappedOutput);\n          parentContext.addLog('outputMappingTarget', outputContext.branchId || '(root)');\n        }\n\n        outputContext.commit();\n      } catch (error: any) {\n        parentContext.addError('outputMapperError', error.toString());\n        this.deps.logger.error(`Error in outputMapper for subflow (${subflowId}):`, { error });\n      }\n    }\n\n    const subflowResult: SubflowResult = {\n      subflowId,\n      subflowName,\n      treeContext: {\n        globalContext: subflowTreeContext.sharedState,\n        stageContexts: subflowTreeContext.executionTree as unknown as Record<string, unknown>,\n        history: subflowTreeContext.commitLog,\n      },\n      parentStageId: parentContext.getStageId(),\n    };\n\n    const subflowDef = this.deps.subflows?.[subflowId];\n    if (subflowDef && (subflowDef as any).buildTimeStructure) {\n      subflowResult.pipelineStructure = (subflowDef as any).buildTimeStructure;\n    }\n\n    parentContext.addLog('subflowResult', subflowResult);\n    parentContext.addLog('hasSubflowData', true);\n    subflowResultsMap.set(subflowId, subflowResult);\n\n    parentContext.addFlowDebugMessage('subflow', `Exiting ${subflowName} subflow`, {\n      targetStage: subflowId,\n    });\n    this.deps.narrativeGenerator.onSubflowExit(subflowName);\n\n    parentContext.commit();\n\n    if (subflowError) {\n      throw subflowError;\n    }\n\n    return subflowOutput;\n  }\n\n  /**\n   * Internal execution within subflow context.\n   * Mirrors the traverser's executeNode but within the subflow's isolated runtime.\n   */\n  private async executeSubflowInternal(\n    node: StageNode<TOut, TScope>,\n    context: StageContext,\n    breakFlag: { shouldBreak: boolean },\n    branchPath: string,\n  ): Promise<any> {\n    // Detect nested subflows\n    if (node.isSubflowRoot && node.subflowId) {\n      const resolvedNode = this.nodeResolver.resolveSubflowReference(node);\n      return await this.executeSubflow(resolvedNode, context, breakFlag, branchPath, this.subflowResultsMap!);\n    }\n\n    const stageFunc = this.getStageFn(node);\n    const breakFn = () => (breakFlag.shouldBreak = true);\n\n    let stageOutput: TOut | undefined;\n    if (stageFunc) {\n      try {\n        if (this.currentSubflowDeps) {\n          const subflowStageRunner = new StageRunner<TOut, TScope>(this.currentSubflowDeps);\n          stageOutput = await subflowStageRunner.run(node, stageFunc, context, breakFn);\n        } else {\n          stageOutput = await this.executeStage(node, stageFunc, context, breakFn);\n        }\n      } catch (error: any) {\n        context.commit();\n        this.callExtractor(node, context, this.getStagePath(node, branchPath, context.stageName), undefined, {\n          type: 'stageExecutionError',\n          message: error.toString(),\n        });\n        context.addError('stageExecutionError', error.toString());\n        throw error;\n      }\n      context.commit();\n      this.callExtractor(node, context, this.getStagePath(node, branchPath, context.stageName), stageOutput);\n\n      if (breakFlag.shouldBreak) {\n        return stageOutput;\n      }\n\n      // Handle dynamic StageNode return\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        if (dynamicNode.children && dynamicNode.children.length > 0) {\n          node.children = dynamicNode.children;\n          context.addLog('dynamicChildCount', dynamicNode.children.length);\n          context.addLog(\n            'dynamicChildIds',\n            dynamicNode.children.map((c) => c.id || c.name),\n          );\n\n          if (typeof dynamicNode.nextNodeSelector === 'function') {\n            node.nextNodeSelector = dynamicNode.nextNodeSelector;\n            context.addLog('hasSelector', true);\n          }\n        }\n\n        if (dynamicNode.next) {\n          node.next = dynamicNode.next;\n          context.addLog('hasDynamicNext', true);\n          const loopTargetId = dynamicNode.next.id || dynamicNode.next.name;\n          if (loopTargetId) {\n            context.addLog('loopTarget', loopTargetId);\n          }\n        }\n\n        stageOutput = undefined;\n      }\n    }\n\n    // ─── Children dispatch ───\n    const hasChildrenAfterStage = Boolean(node.children?.length);\n    const hasNextAfterStage = Boolean(node.next);\n\n    if (hasChildrenAfterStage) {\n      if (node.nextNodeSelector) {\n        const results = await this.executeSelectedChildrenInternal(\n          node.nextNodeSelector,\n          node.children!,\n          stageOutput,\n          context,\n          branchPath,\n          breakFlag,\n        );\n        if (!hasNextAfterStage) return results;\n      } else {\n        const results = await this.executeNodeChildrenInternal(node, context, branchPath, breakFlag);\n        if (!hasNextAfterStage) return results;\n      }\n    }\n\n    // ─── Linear next ───\n    if (hasNextAfterStage) {\n      let nextNode = node.next!;\n\n      // Resolve reference nodes (has id but no fn)\n      if (nextNode.id && !nextNode.fn) {\n        let resolvedNode: StageNode<TOut, TScope> | undefined;\n        if (this.currentSubflowRoot) {\n          resolvedNode = this.nodeResolver.findNodeById(nextNode.id, this.currentSubflowRoot);\n          if (resolvedNode) context.addLog('dynamicNextResolvedFrom', 'subflow');\n        }\n        if (!resolvedNode) {\n          resolvedNode = this.nodeResolver.findNodeById(nextNode.id);\n          if (resolvedNode) context.addLog('dynamicNextResolvedFrom', 'mainPipeline');\n        }\n        if (resolvedNode) {\n          nextNode = resolvedNode;\n          context.addLog('dynamicNextResolved', true);\n          context.addLog('dynamicNextTarget', nextNode.id);\n        } else {\n          this.deps.logger.info(`Dynamic next node '${nextNode.id}' not found in subflow or main pipeline`);\n          context.addLog('dynamicNextResolved', false);\n          context.addLog('dynamicNextNotFound', nextNode.id);\n        }\n      }\n\n      const nextCtx = context.createNext('', nextNode.name);\n      return await this.executeSubflowInternal(nextNode, nextCtx, breakFlag, branchPath);\n    }\n\n    return stageOutput;\n  }\n\n  private getStagePath(node: StageNode<TOut, TScope>, branchPath?: string, contextStageName?: string): string {\n    const baseName = node.id ?? node.name;\n    const nodeId = contextStageName && contextStageName !== node.name ? contextStageName : baseName;\n    if (!branchPath) return nodeId;\n    return `${branchPath}.${nodeId}`;\n  }\n\n  private async executeNodeChildrenInternal(\n    node: StageNode<TOut, TScope>,\n    context: StageContext,\n    branchPath: string,\n    breakFlag: { shouldBreak: boolean },\n  ): Promise<Record<string, NodeResultType>> {\n    const childPromises: Promise<NodeResultType>[] = (node.children ?? []).map((child) => {\n      const childContext = context.createChild('', child.id as string, child.name);\n      const childBreakFlag = { shouldBreak: false };\n\n      return this.executeSubflowInternal(child, childContext, childBreakFlag, branchPath)\n        .then((result) => {\n          childContext.commit();\n          return { id: child.id!, result, isError: false };\n        })\n        .catch((error) => {\n          childContext.commit();\n          this.deps.logger.info(`TREE PIPELINE: executeNodeChildrenInternal - Error for id: ${child?.id}`, { error });\n          return { id: child.id!, result: error, isError: true };\n        });\n    });\n\n    const settled = await Promise.allSettled(childPromises);\n    const childrenResults: Record<string, NodeResultType> = {};\n    settled.forEach((s) => {\n      if (s.status === 'fulfilled') {\n        const { id, result, isError } = s.value;\n        childrenResults[id] = { id, result, isError };\n      } else {\n        this.deps.logger.error(`Execution failed: ${s.reason}`);\n      }\n    });\n    return childrenResults;\n  }\n\n  private async executeSelectedChildrenInternal(\n    selector: Selector,\n    children: StageNode<TOut, TScope>[],\n    input: any,\n    context: StageContext,\n    branchPath: string,\n    breakFlag: { shouldBreak: boolean },\n  ): Promise<Record<string, NodeResultType>> {\n    const selectorResult = await selector(input);\n    const selectedIds = Array.isArray(selectorResult) ? selectorResult : [selectorResult];\n\n    context.addLog('selectedChildIds', selectedIds);\n    context.addLog('selectorPattern', 'multi-choice');\n\n    if (selectedIds.length === 0) {\n      context.addLog('skippedAllChildren', true);\n      return {};\n    }\n\n    const selectedChildren = children.filter((c) => selectedIds.includes(c.id!));\n    if (selectedChildren.length !== selectedIds.length) {\n      const childIds = children.map((c) => c.id);\n      const missing = selectedIds.filter((id) => !childIds.includes(id));\n      const errorMessage = `Selector returned unknown child IDs: ${missing.join(', ')}. Available: ${childIds.join(\n        ', ',\n      )}`;\n      this.deps.logger.error(`Error in subflow (${branchPath}):`, { error: errorMessage });\n      context.addError('selectorError', errorMessage);\n      throw new Error(errorMessage);\n    }\n\n    const skippedIds = children.filter((c) => !selectedIds.includes(c.id!)).map((c) => c.id);\n    if (skippedIds.length > 0) {\n      context.addLog('skippedChildIds', skippedIds);\n    }\n\n    const tempNode: StageNode<TOut, TScope> = { name: 'selector-temp', children: selectedChildren };\n    return await this.executeNodeChildrenInternal(tempNode, context, branchPath, breakFlag);\n  }\n}\n"]}

package/dist/lib/engine/handlers/SubflowInputMapper.js

@@ -0,0 +1,121 @@
+"use strict";
+/**
+ * SubflowInputMapper — Pure functions for subflow data contracts.
+ *
+ * Mental model: Subflow = Pure Function
+ * - Isolated scope (own GlobalStore)
+ * - Explicit inputs via inputMapper
+ * - Explicit outputs via outputMapper
+ *
+ * | Scenario        | Behavior                                  |
+ * |-----------------|-------------------------------------------|
+ * | No inputMapper  | Subflow starts with empty scope           |
+ * | No outputMapper | Subflow scope changes discarded           |
+ * | Both present    | Full data contract (args in, results out) |
+ * | Neither present | Complete isolation (side effects only)    |
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyOutputMapping = exports.seedSubflowGlobalStore = exports.createSubflowHandlerDeps = exports.getInitialScopeValues = exports.extractParentScopeValues = void 0;
+/** Extract values from parent scope using inputMapper. */
+function extractParentScopeValues(parentScope, options) {
+    if (!(options === null || options === void 0 ? void 0 : options.inputMapper)) {
+        return {};
+    }
+    const result = options.inputMapper(parentScope);
+    if (result === null || result === undefined) {
+        return {};
+    }
+    return result;
+}
+exports.extractParentScopeValues = extractParentScopeValues;
+/**
+ * Get the initial scope values for a subflow.
+ * Always isolated — only inputMapper values are included.
+ */
+function getInitialScopeValues(parentScope, options) {
+    return extractParentScopeValues(parentScope, options);
+}
+exports.getInitialScopeValues = getInitialScopeValues;
+/**
+ * Create a new HandlerDeps for subflow execution.
+ * Key: sets readOnlyContext to mapped input so StageRunner passes it to ScopeFactory.
+ */
+function createSubflowHandlerDeps(parentDeps, subflowRuntime, mappedInput) {
+    return {
+        stageMap: parentDeps.stageMap,
+        root: parentDeps.root,
+        ScopeFactory: parentDeps.ScopeFactory,
+        subflows: parentDeps.subflows,
+        throttlingErrorChecker: parentDeps.throttlingErrorChecker,
+        streamHandlers: parentDeps.streamHandlers,
+        scopeProtectionMode: parentDeps.scopeProtectionMode,
+        executionRuntime: subflowRuntime,
+        readOnlyContext: mappedInput,
+        narrativeGenerator: parentDeps.narrativeGenerator,
+        logger: parentDeps.logger,
+    };
+}
+exports.createSubflowHandlerDeps = createSubflowHandlerDeps;
+/**
+ * Seed the subflow's GlobalStore with initial values.
+ * Called before subflow execution to make inputMapper values available.
+ */
+function seedSubflowGlobalStore(subflowRuntime, initialValues) {
+    const rootContext = subflowRuntime.rootStageContext;
+    for (const [key, value] of Object.entries(initialValues)) {
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            for (const [nestedKey, nestedValue] of Object.entries(value)) {
+                rootContext.setObject([key], nestedKey, nestedValue);
+            }
+        }
+        else {
+            rootContext.setGlobal(key, value);
+        }
+    }
+    rootContext.commit();
+}
+exports.seedSubflowGlobalStore = seedSubflowGlobalStore;
+/**
+ * Apply output mapping after subflow completion.
+ * Writes mapped values back to parent scope using merge semantics:
+ * arrays are appended, objects are shallow-merged, scalars are replaced.
+ */
+function applyOutputMapping(subflowOutput, parentScope, parentContext, options) {
+    if (!(options === null || options === void 0 ? void 0 : options.outputMapper)) {
+        return undefined;
+    }
+    const mappedOutput = options.outputMapper(subflowOutput, parentScope);
+    if (mappedOutput === null || mappedOutput === undefined) {
+        return undefined;
+    }
+    for (const [key, value] of Object.entries(mappedOutput)) {
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            for (const [nestedKey, nestedValue] of Object.entries(value)) {
+                if (Array.isArray(nestedValue)) {
+                    parentContext.appendToArray([key], nestedKey, nestedValue);
+                }
+                else if (typeof nestedValue === 'object' && nestedValue !== null) {
+                    parentContext.mergeObject([key], nestedKey, nestedValue);
+                }
+                else {
+                    parentContext.setObject([key], nestedKey, nestedValue);
+                }
+            }
+        }
+        else if (Array.isArray(value)) {
+            const existing = parentContext.getGlobal(key);
+            if (Array.isArray(existing)) {
+                parentContext.setGlobal(key, [...existing, ...value]);
+            }
+            else {
+                parentContext.setGlobal(key, value);
+            }
+        }
+        else {
+            parentContext.setGlobal(key, value);
+        }
+    }
+    return mappedOutput;
+}
+exports.applyOutputMapping = applyOutputMapping;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SubflowInputMapper.js","sourceRoot":"","sources":["../../../../src/lib/engine/handlers/SubflowInputMapper.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAKH,0DAA0D;AAC1D,SAAgB,wBAAwB,CACtC,WAAyB,EACzB,OAA0D;IAE1D,IAAI,CAAC,CAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,WAAW,CAAA,EAAE,CAAC;QAC1B,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;IAChD,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QAC5C,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAdD,4DAcC;AAED;;;GAGG;AACH,SAAgB,qBAAqB,CACnC,WAAyB,EACzB,OAA0D;IAE1D,OAAO,wBAAwB,CAAC,WAAW,EAAE,OAAO,CAA4B,CAAC;AACnF,CAAC;AALD,sDAKC;AAED;;;GAGG;AACH,SAAgB,wBAAwB,CACtC,UAAqC,EACrC,cAAiC,EACjC,WAAoC;IAEpC,OAAO;QACL,QAAQ,EAAE,UAAU,CAAC,QAAQ;QAC7B,IAAI,EAAE,UAAU,CAAC,IAAI;QACrB,YAAY,EAAE,UAAU,CAAC,YAAY;QACrC,QAAQ,EAAE,UAAU,CAAC,QAAQ;QAC7B,sBAAsB,EAAE,UAAU,CAAC,sBAAsB;QACzD,cAAc,EAAE,UAAU,CAAC,cAAc;QACzC,mBAAmB,EAAE,UAAU,CAAC,mBAAmB;QACnD,gBAAgB,EAAE,cAAc;QAChC,eAAe,EAAE,WAAW;QAC5B,kBAAkB,EAAE,UAAU,CAAC,kBAAkB;QACjD,MAAM,EAAE,UAAU,CAAC,MAAM;KAC1B,CAAC;AACJ,CAAC;AAlBD,4DAkBC;AAED;;;GAGG;AACH,SAAgB,sBAAsB,CACpC,cAAiC,EACjC,aAAsC;IAEtC,MAAM,WAAW,GAAG,cAAc,CAAC,gBAAgB,CAAC;IAEpD,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE,CAAC;QACzD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YACzE,KAAK,MAAM,CAAC,SAAS,EAAE,WAAW,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAgC,CAAC,EAAE,CAAC;gBACxF,WAAW,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC;YACvD,CAAC;QACH,CAAC;aAAM,CAAC;YACN,WAAW,CAAC,SAAS,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QACpC,CAAC;IACH,CAAC;IAED,WAAW,CAAC,MAAM,EAAE,CAAC;AACvB,CAAC;AAjBD,wDAiBC;AAED;;;;GAIG;AACH,SAAgB,kBAAkB,CAChC,aAA6B,EAC7B,WAAyB,EACzB,aAA2B,EAC3B,OAAgE;IAEhE,IAAI,CAAC,CAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,YAAY,CAAA,EAAE,CAAC;QAC3B,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,MAAM,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC;IAEtE,IAAI,YAAY,KAAK,IAAI,IAAI,YAAY,KAAK,SAAS,EAAE,CAAC;QACxD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,CAAC;QACxD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YACzE,KAAK,MAAM,CAAC,SAAS,EAAE,WAAW,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAgC,CAAC,EAAE,CAAC;gBACxF,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC;oBAC/B,aAAa,CAAC,aAAa,CAAC,CAAC,GAAG,CAAC,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC;gBAC7D,CAAC;qBAAM,IAAI,OAAO,WAAW,KAAK,QAAQ,IAAI,WAAW,KAAK,IAAI,EAAE,CAAC;oBACnE,aAAa,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,EAAE,SAAS,EAAE,WAAsC,CAAC,CAAC;gBACtF,CAAC;qBAAM,CAAC;oBACN,aAAa,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC;gBACzD,CAAC;YACH,CAAC;QACH,CAAC;aAAM,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YAChC,MAAM,QAAQ,GAAG,aAAa,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;YAC9C,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAC5B,aAAa,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,GAAG,QAAQ,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC;YACxD,CAAC;iBAAM,CAAC;gBACN,aAAa,CAAC,SAAS,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;YACtC,CAAC;QACH,CAAC;aAAM,CAAC;YACN,aAAa,CAAC,SAAS,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QACtC,CAAC;IACH,CAAC;IAED,OAAO,YAAY,CAAC;AACtB,CAAC;AAxCD,gDAwCC","sourcesContent":["/**\n * SubflowInputMapper — Pure functions for subflow data contracts.\n *\n * Mental model: Subflow = Pure Function\n * - Isolated scope (own GlobalStore)\n * - Explicit inputs via inputMapper\n * - Explicit outputs via outputMapper\n *\n * | Scenario        | Behavior                                  |\n * |-----------------|-------------------------------------------|\n * | No inputMapper  | Subflow starts with empty scope           |\n * | No outputMapper | Subflow scope changes discarded           |\n * | Both present    | Full data contract (args in, results out) |\n * | Neither present | Complete isolation (side effects only)    |\n */\n\nimport type { StageContext } from '../../memory/StageContext';\nimport type { HandlerDeps, IExecutionRuntime, SubflowMountOptions } from '../types';\n\n/** Extract values from parent scope using inputMapper. */\nexport function extractParentScopeValues<TParentScope, TSubflowInput>(\n  parentScope: TParentScope,\n  options?: SubflowMountOptions<TParentScope, TSubflowInput>,\n): TSubflowInput | Record<string, unknown> {\n  if (!options?.inputMapper) {\n    return {};\n  }\n\n  const result = options.inputMapper(parentScope);\n  if (result === null || result === undefined) {\n    return {};\n  }\n\n  return result;\n}\n\n/**\n * Get the initial scope values for a subflow.\n * Always isolated — only inputMapper values are included.\n */\nexport function getInitialScopeValues<TParentScope, TSubflowInput>(\n  parentScope: TParentScope,\n  options?: SubflowMountOptions<TParentScope, TSubflowInput>,\n): Record<string, unknown> {\n  return extractParentScopeValues(parentScope, options) as Record<string, unknown>;\n}\n\n/**\n * Create a new HandlerDeps for subflow execution.\n * Key: sets readOnlyContext to mapped input so StageRunner passes it to ScopeFactory.\n */\nexport function createSubflowHandlerDeps<TOut = any, TScope = any>(\n  parentDeps: HandlerDeps<TOut, TScope>,\n  subflowRuntime: IExecutionRuntime,\n  mappedInput: Record<string, unknown>,\n): HandlerDeps<TOut, TScope> {\n  return {\n    stageMap: parentDeps.stageMap,\n    root: parentDeps.root,\n    ScopeFactory: parentDeps.ScopeFactory,\n    subflows: parentDeps.subflows,\n    throttlingErrorChecker: parentDeps.throttlingErrorChecker,\n    streamHandlers: parentDeps.streamHandlers,\n    scopeProtectionMode: parentDeps.scopeProtectionMode,\n    executionRuntime: subflowRuntime,\n    readOnlyContext: mappedInput,\n    narrativeGenerator: parentDeps.narrativeGenerator,\n    logger: parentDeps.logger,\n  };\n}\n\n/**\n * Seed the subflow's GlobalStore with initial values.\n * Called before subflow execution to make inputMapper values available.\n */\nexport function seedSubflowGlobalStore(\n  subflowRuntime: IExecutionRuntime,\n  initialValues: Record<string, unknown>,\n): void {\n  const rootContext = subflowRuntime.rootStageContext;\n\n  for (const [key, value] of Object.entries(initialValues)) {\n    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {\n      for (const [nestedKey, nestedValue] of Object.entries(value as Record<string, unknown>)) {\n        rootContext.setObject([key], nestedKey, nestedValue);\n      }\n    } else {\n      rootContext.setGlobal(key, value);\n    }\n  }\n\n  rootContext.commit();\n}\n\n/**\n * Apply output mapping after subflow completion.\n * Writes mapped values back to parent scope using merge semantics:\n * arrays are appended, objects are shallow-merged, scalars are replaced.\n */\nexport function applyOutputMapping<TParentScope, TSubflowOutput>(\n  subflowOutput: TSubflowOutput,\n  parentScope: TParentScope,\n  parentContext: StageContext,\n  options?: SubflowMountOptions<TParentScope, any, TSubflowOutput>,\n): Record<string, unknown> | undefined {\n  if (!options?.outputMapper) {\n    return undefined;\n  }\n\n  const mappedOutput = options.outputMapper(subflowOutput, parentScope);\n\n  if (mappedOutput === null || mappedOutput === undefined) {\n    return undefined;\n  }\n\n  for (const [key, value] of Object.entries(mappedOutput)) {\n    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {\n      for (const [nestedKey, nestedValue] of Object.entries(value as Record<string, unknown>)) {\n        if (Array.isArray(nestedValue)) {\n          parentContext.appendToArray([key], nestedKey, nestedValue);\n        } else if (typeof nestedValue === 'object' && nestedValue !== null) {\n          parentContext.mergeObject([key], nestedKey, nestedValue as Record<string, unknown>);\n        } else {\n          parentContext.setObject([key], nestedKey, nestedValue);\n        }\n      }\n    } else if (Array.isArray(value)) {\n      const existing = parentContext.getGlobal(key);\n      if (Array.isArray(existing)) {\n        parentContext.setGlobal(key, [...existing, ...value]);\n      } else {\n        parentContext.setGlobal(key, value);\n      }\n    } else {\n      parentContext.setGlobal(key, value);\n    }\n  }\n\n  return mappedOutput;\n}\n"]}

package/dist/lib/engine/handlers/index.js

@@ -0,0 +1,42 @@
+"use strict";
+/* istanbul ignore file */
+/**
+ * Barrel export for all engine handler modules.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeStructureManager = exports.computeNodeType = exports.ExtractorRunner = exports.seedSubflowGlobalStore = exports.getInitialScopeValues = exports.extractParentScopeValues = exports.createSubflowHandlerDeps = exports.applyOutputMapping = exports.SubflowExecutor = exports.DEFAULT_MAX_ITERATIONS = exports.ContinuationResolver = exports.SelectorHandler = exports.DeciderHandler = exports.ChildrenExecutor = exports.NodeResolver = exports.StageRunner = void 0;
+// Stage execution
+var StageRunner_1 = require("./StageRunner");
+Object.defineProperty(exports, "StageRunner", { enumerable: true, get: function () { return StageRunner_1.StageRunner; } });
+// Node resolution and subflow reference handling
+var NodeResolver_1 = require("./NodeResolver");
+Object.defineProperty(exports, "NodeResolver", { enumerable: true, get: function () { return NodeResolver_1.NodeResolver; } });
+var ChildrenExecutor_1 = require("./ChildrenExecutor");
+Object.defineProperty(exports, "ChildrenExecutor", { enumerable: true, get: function () { return ChildrenExecutor_1.ChildrenExecutor; } });
+var DeciderHandler_1 = require("./DeciderHandler");
+Object.defineProperty(exports, "DeciderHandler", { enumerable: true, get: function () { return DeciderHandler_1.DeciderHandler; } });
+// Multi-choice filtered fan-out
+var SelectorHandler_1 = require("./SelectorHandler");
+Object.defineProperty(exports, "SelectorHandler", { enumerable: true, get: function () { return SelectorHandler_1.SelectorHandler; } });
+// Back-edge resolution + iteration counting (was LoopHandler)
+var ContinuationResolver_1 = require("./ContinuationResolver");
+Object.defineProperty(exports, "ContinuationResolver", { enumerable: true, get: function () { return ContinuationResolver_1.ContinuationResolver; } });
+Object.defineProperty(exports, "DEFAULT_MAX_ITERATIONS", { enumerable: true, get: function () { return ContinuationResolver_1.DEFAULT_MAX_ITERATIONS; } });
+// Subflow execution with isolated contexts
+var SubflowExecutor_1 = require("./SubflowExecutor");
+Object.defineProperty(exports, "SubflowExecutor", { enumerable: true, get: function () { return SubflowExecutor_1.SubflowExecutor; } });
+// Subflow input/output mapping
+var SubflowInputMapper_1 = require("./SubflowInputMapper");
+Object.defineProperty(exports, "applyOutputMapping", { enumerable: true, get: function () { return SubflowInputMapper_1.applyOutputMapping; } });
+Object.defineProperty(exports, "createSubflowHandlerDeps", { enumerable: true, get: function () { return SubflowInputMapper_1.createSubflowHandlerDeps; } });
+Object.defineProperty(exports, "extractParentScopeValues", { enumerable: true, get: function () { return SubflowInputMapper_1.extractParentScopeValues; } });
+Object.defineProperty(exports, "getInitialScopeValues", { enumerable: true, get: function () { return SubflowInputMapper_1.getInitialScopeValues; } });
+Object.defineProperty(exports, "seedSubflowGlobalStore", { enumerable: true, get: function () { return SubflowInputMapper_1.seedSubflowGlobalStore; } });
+// Traversal extractor coordination
+var ExtractorRunner_1 = require("./ExtractorRunner");
+Object.defineProperty(exports, "ExtractorRunner", { enumerable: true, get: function () { return ExtractorRunner_1.ExtractorRunner; } });
+// Runtime structure management (dynamic pipeline structure tracking)
+var RuntimeStructureManager_1 = require("./RuntimeStructureManager");
+Object.defineProperty(exports, "computeNodeType", { enumerable: true, get: function () { return RuntimeStructureManager_1.computeNodeType; } });
+Object.defineProperty(exports, "RuntimeStructureManager", { enumerable: true, get: function () { return RuntimeStructureManager_1.RuntimeStructureManager; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL2VuZ2luZS9oYW5kbGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsMEJBQTBCO0FBQzFCOztHQUVHOzs7QUFFSCxrQkFBa0I7QUFDbEIsNkNBQTRDO0FBQW5DLDBHQUFBLFdBQVcsT0FBQTtBQUVwQixpREFBaUQ7QUFDakQsK0NBQThDO0FBQXJDLDRHQUFBLFlBQVksT0FBQTtBQUlyQix1REFBc0Q7QUFBN0Msb0hBQUEsZ0JBQWdCLE9BQUE7QUFJekIsbURBQWtEO0FBQXpDLGdIQUFBLGNBQWMsT0FBQTtBQUV2QixnQ0FBZ0M7QUFDaEMscURBQW9EO0FBQTNDLGtIQUFBLGVBQWUsT0FBQTtBQUV4Qiw4REFBOEQ7QUFDOUQsK0RBQXNGO0FBQTdFLDRIQUFBLG9CQUFvQixPQUFBO0FBQUUsOEhBQUEsc0JBQXNCLE9BQUE7QUFFckQsMkNBQTJDO0FBQzNDLHFEQUFvRDtBQUEzQyxrSEFBQSxlQUFlLE9BQUE7QUFFeEIsK0JBQStCO0FBQy9CLDJEQU04QjtBQUw1Qix3SEFBQSxrQkFBa0IsT0FBQTtBQUNsQiw4SEFBQSx3QkFBd0IsT0FBQTtBQUN4Qiw4SEFBQSx3QkFBd0IsT0FBQTtBQUN4QiwySEFBQSxxQkFBcUIsT0FBQTtBQUNyQiw0SEFBQSxzQkFBc0IsT0FBQTtBQUd4QixtQ0FBbUM7QUFDbkMscURBQW9EO0FBQTNDLGtIQUFBLGVBQWUsT0FBQTtBQUV4QixxRUFBcUU7QUFDckUscUVBQXFGO0FBQTVFLDBIQUFBLGVBQWUsT0FBQTtBQUFFLGtJQUFBLHVCQUF1QixPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyogaXN0YW5idWwgaWdub3JlIGZpbGUgKi9cbi8qKlxuICogQmFycmVsIGV4cG9ydCBmb3IgYWxsIGVuZ2luZSBoYW5kbGVyIG1vZHVsZXMuXG4gKi9cblxuLy8gU3RhZ2UgZXhlY3V0aW9uXG5leHBvcnQgeyBTdGFnZVJ1bm5lciB9IGZyb20gJy4vU3RhZ2VSdW5uZXInO1xuXG4vLyBOb2RlIHJlc29sdXRpb24gYW5kIHN1YmZsb3cgcmVmZXJlbmNlIGhhbmRsaW5nXG5leHBvcnQgeyBOb2RlUmVzb2x2ZXIgfSBmcm9tICcuL05vZGVSZXNvbHZlcic7XG5cbi8vIFBhcmFsbGVsIGNoaWxkcmVuIGV4ZWN1dGlvblxuZXhwb3J0IHR5cGUgeyBFeGVjdXRlTm9kZUZuIH0gZnJvbSAnLi9DaGlsZHJlbkV4ZWN1dG9yJztcbmV4cG9ydCB7IENoaWxkcmVuRXhlY3V0b3IgfSBmcm9tICcuL0NoaWxkcmVuRXhlY3V0b3InO1xuXG4vLyBTaW5nbGUtY2hvaWNlIGNvbmRpdGlvbmFsIGJyYW5jaGluZ1xuZXhwb3J0IHR5cGUgeyBDYWxsRXh0cmFjdG9yRm4sIEdldFN0YWdlUGF0aEZuLCBSdW5TdGFnZUZuIH0gZnJvbSAnLi9EZWNpZGVySGFuZGxlcic7XG5leHBvcnQgeyBEZWNpZGVySGFuZGxlciB9IGZyb20gJy4vRGVjaWRlckhhbmRsZXInO1xuXG4vLyBNdWx0aS1jaG9pY2UgZmlsdGVyZWQgZmFuLW91dFxuZXhwb3J0IHsgU2VsZWN0b3JIYW5kbGVyIH0gZnJvbSAnLi9TZWxlY3RvckhhbmRsZXInO1xuXG4vLyBCYWNrLWVkZ2UgcmVzb2x1dGlvbiArIGl0ZXJhdGlvbiBjb3VudGluZyAod2FzIExvb3BIYW5kbGVyKVxuZXhwb3J0IHsgQ29udGludWF0aW9uUmVzb2x2ZXIsIERFRkFVTFRfTUFYX0lURVJBVElPTlMgfSBmcm9tICcuL0NvbnRpbnVhdGlvblJlc29sdmVyJztcblxuLy8gU3ViZmxvdyBleGVjdXRpb24gd2l0aCBpc29sYXRlZCBjb250ZXh0c1xuZXhwb3J0IHsgU3ViZmxvd0V4ZWN1dG9yIH0gZnJvbSAnLi9TdWJmbG93RXhlY3V0b3InO1xuXG4vLyBTdWJmbG93IGlucHV0L291dHB1dCBtYXBwaW5nXG5leHBvcnQge1xuICBhcHBseU91dHB1dE1hcHBpbmcsXG4gIGNyZWF0ZVN1YmZsb3dIYW5kbGVyRGVwcyxcbiAgZXh0cmFjdFBhcmVudFNjb3BlVmFsdWVzLFxuICBnZXRJbml0aWFsU2NvcGVWYWx1ZXMsXG4gIHNlZWRTdWJmbG93R2xvYmFsU3RvcmUsXG59IGZyb20gJy4vU3ViZmxvd0lucHV0TWFwcGVyJztcblxuLy8gVHJhdmVyc2FsIGV4dHJhY3RvciBjb29yZGluYXRpb25cbmV4cG9ydCB7IEV4dHJhY3RvclJ1bm5lciB9IGZyb20gJy4vRXh0cmFjdG9yUnVubmVyJztcblxuLy8gUnVudGltZSBzdHJ1Y3R1cmUgbWFuYWdlbWVudCAoZHluYW1pYyBwaXBlbGluZSBzdHJ1Y3R1cmUgdHJhY2tpbmcpXG5leHBvcnQgeyBjb21wdXRlTm9kZVR5cGUsIFJ1bnRpbWVTdHJ1Y3R1cmVNYW5hZ2VyIH0gZnJvbSAnLi9SdW50aW1lU3RydWN0dXJlTWFuYWdlcic7XG4iXX0=

package/dist/lib/engine/index.js

@@ -0,0 +1,40 @@
+"use strict";
+/* istanbul ignore file */
+/**
+ * engine/ — Graph traversal engine library.
+ *
+ * Executes flowcharts built by FlowChartBuilder via pre-order DFS traversal.
+ * Handles linear, fork, decider, selector, loop, and subflow node shapes.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullControlFlowNarrativeGenerator = exports.ControlFlowNarrativeGenerator = exports.CombinedNarrativeBuilder = exports.isStageNodeReturn = exports.FlowchartTraverser = void 0;
+var FlowchartTraverser_1 = require("./traversal/FlowchartTraverser");
+Object.defineProperty(exports, "FlowchartTraverser", { enumerable: true, get: function () { return FlowchartTraverser_1.FlowchartTraverser; } });
+// Graph node types (Decider, Selector, StageNode re-exported via ./types)
+var StageNode_1 = require("./graph/StageNode");
+Object.defineProperty(exports, "isStageNodeReturn", { enumerable: true, get: function () { return StageNode_1.isStageNodeReturn; } });
+// Types
+__exportStar(require("./types"), exports);
+// Handlers (for advanced use cases and testing)
+__exportStar(require("./handlers"), exports);
+var CombinedNarrativeBuilder_1 = require("./narrative/CombinedNarrativeBuilder");
+Object.defineProperty(exports, "CombinedNarrativeBuilder", { enumerable: true, get: function () { return CombinedNarrativeBuilder_1.CombinedNarrativeBuilder; } });
+var ControlFlowNarrativeGenerator_1 = require("./narrative/ControlFlowNarrativeGenerator");
+Object.defineProperty(exports, "ControlFlowNarrativeGenerator", { enumerable: true, get: function () { return ControlFlowNarrativeGenerator_1.ControlFlowNarrativeGenerator; } });
+var NullControlFlowNarrativeGenerator_1 = require("./narrative/NullControlFlowNarrativeGenerator");
+Object.defineProperty(exports, "NullControlFlowNarrativeGenerator", { enumerable: true, get: function () { return NullControlFlowNarrativeGenerator_1.NullControlFlowNarrativeGenerator; } });
+//# sourceMappingURL=data:application/json;base64,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