footprintjs 0.1.0

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

@@ -0,0 +1,117 @@
+/**
+ * ExtractorRunner — Per-stage snapshot extraction.
+ *
+ * Coordinates traversal extractor invocations: step counting,
+ * snapshot enrichment, error collection, and result storage.
+ */
+import { computeNodeType } from './RuntimeStructureManager';
+export class ExtractorRunner {
+    constructor(extractor, enrichSnapshots, executionRuntime, logger) {
+        this.extractedResults = new Map();
+        this.extractorErrors = [];
+        this.stepCounter = 0;
+        this.extractor = extractor;
+        this.enrichSnapshots = enrichSnapshots;
+        this.executionRuntime = executionRuntime;
+        this.logger = logger;
+    }
+    /**
+     * Call the extractor for a stage and store the result.
+     * Increments stepCounter (1-based) before creating snapshot.
+     */
+    callExtractor(node, context, stagePath, stageOutput, errorInfo) {
+        var _a;
+        if (!this.extractor)
+            return;
+        this.stepCounter++;
+        try {
+            const snapshot = {
+                node,
+                context,
+                stepNumber: this.stepCounter,
+                structureMetadata: this.buildStructureMetadata(node),
+            };
+            if (this.enrichSnapshots) {
+                try {
+                    snapshot.scopeState = { ...this.executionRuntime.globalStore.getState() };
+                    snapshot.debugInfo = {
+                        logs: { ...context.debug.logContext },
+                        errors: { ...context.debug.errorContext },
+                        metrics: { ...context.debug.metricContext },
+                        evals: { ...context.debug.evalContext },
+                    };
+                    if (context.debug.flowMessages.length > 0) {
+                        snapshot.debugInfo.flowMessages = [...context.debug.flowMessages];
+                    }
+                    snapshot.stageOutput = stageOutput;
+                    if (errorInfo) {
+                        snapshot.errorInfo = errorInfo;
+                    }
+                    snapshot.historyIndex = this.executionRuntime.executionHistory.list().length;
+                }
+                catch (enrichError) {
+                    this.logger.warn(`Enrichment error at stage '${stagePath}':`, { error: enrichError });
+                }
+            }
+            const result = this.extractor(snapshot);
+            if (result !== undefined && result !== null) {
+                this.extractedResults.set(stagePath, result);
+            }
+        }
+        catch (error) {
+            this.logger.error(`Extractor error at stage '${stagePath}':`, { error });
+            this.extractorErrors.push({
+                stagePath,
+                message: (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : String(error),
+                error,
+            });
+        }
+    }
+    /**
+     * Generate the stage path for extractor results.
+     * Uses node.id (preferred) or node.name, combined with branchPath.
+     */
+    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}`;
+    }
+    buildStructureMetadata(node) {
+        var _a;
+        const metadata = {
+            type: computeNodeType(node),
+        };
+        if (node.isSubflowRoot) {
+            metadata.isSubflowRoot = true;
+            metadata.subflowId = node.subflowId;
+            metadata.subflowName = node.subflowName;
+        }
+        else if (this.currentSubflowId) {
+            metadata.subflowId = this.currentSubflowId;
+        }
+        if (this.currentForkId) {
+            metadata.isParallelChild = true;
+            metadata.parallelGroupId = this.currentForkId;
+        }
+        if (node.isStreaming) {
+            metadata.streamId = node.streamId;
+        }
+        const hasDynamicChildren = Boolean(((_a = node.children) === null || _a === void 0 ? void 0 : _a.length) && !node.nextNodeSelector && node.fn);
+        if (hasDynamicChildren) {
+            metadata.isDynamic = true;
+        }
+        return metadata;
+    }
+    /** Returns extracted results collected during execution. */
+    getExtractedResults() {
+        return this.extractedResults;
+    }
+    /** Returns errors encountered during extraction. */
+    getExtractorErrors() {
+        return this.extractorErrors;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ExtractorRunner.js","sourceRoot":"","sources":["../../../../../src/lib/engine/handlers/ExtractorRunner.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ExtractorRunner — Per-stage snapshot extraction.\n *\n * Coordinates traversal extractor invocations: step counting,\n * snapshot enrichment, error collection, and result storage.\n */\n\nimport type { StageContext } from '../../memory/StageContext';\nimport type { StageNode } from '../graph/StageNode';\nimport type {\n  ExtractorError,\n  IExecutionRuntime,\n  ILogger,\n  RuntimeStructureMetadata,\n  StageSnapshot,\n  TraversalExtractor,\n} from '../types';\nimport { computeNodeType } from './RuntimeStructureManager';\n\nexport class ExtractorRunner<TOut = any, TScope = any> {\n  private readonly extractor?: TraversalExtractor;\n  private readonly enrichSnapshots: boolean;\n  private readonly executionRuntime: IExecutionRuntime;\n  private readonly logger: ILogger;\n\n  private extractedResults: Map<string, unknown> = new Map();\n  private extractorErrors: ExtractorError[] = [];\n  private stepCounter = 0;\n\n  /** Current subflow context for metadata propagation. Set/cleared during subflow execution. */\n  currentSubflowId?: string;\n\n  /** Current fork context for metadata propagation. Set/cleared during parallel children execution. */\n  currentForkId?: string;\n\n  constructor(\n    extractor: TraversalExtractor | undefined,\n    enrichSnapshots: boolean,\n    executionRuntime: IExecutionRuntime,\n    logger: ILogger,\n  ) {\n    this.extractor = extractor;\n    this.enrichSnapshots = enrichSnapshots;\n    this.executionRuntime = executionRuntime;\n    this.logger = logger;\n  }\n\n  /**\n   * Call the extractor for a stage and store the result.\n   * Increments stepCounter (1-based) before creating snapshot.\n   */\n  callExtractor(\n    node: StageNode,\n    context: StageContext,\n    stagePath: string,\n    stageOutput?: unknown,\n    errorInfo?: { type: string; message: string },\n  ): void {\n    if (!this.extractor) return;\n\n    this.stepCounter++;\n\n    try {\n      const snapshot: StageSnapshot = {\n        node,\n        context,\n        stepNumber: this.stepCounter,\n        structureMetadata: this.buildStructureMetadata(node),\n      };\n\n      if (this.enrichSnapshots) {\n        try {\n          snapshot.scopeState = { ...this.executionRuntime.globalStore.getState() };\n\n          snapshot.debugInfo = {\n            logs: { ...context.debug.logContext },\n            errors: { ...context.debug.errorContext },\n            metrics: { ...context.debug.metricContext },\n            evals: { ...context.debug.evalContext },\n          };\n          if (context.debug.flowMessages.length > 0) {\n            snapshot.debugInfo.flowMessages = [...context.debug.flowMessages];\n          }\n\n          snapshot.stageOutput = stageOutput;\n\n          if (errorInfo) {\n            snapshot.errorInfo = errorInfo;\n          }\n\n          snapshot.historyIndex = this.executionRuntime.executionHistory.list().length;\n        } catch (enrichError: any) {\n          this.logger.warn(`Enrichment error at stage '${stagePath}':`, { error: enrichError });\n        }\n      }\n\n      const result = this.extractor(snapshot);\n\n      if (result !== undefined && result !== null) {\n        this.extractedResults.set(stagePath, result);\n      }\n    } catch (error: any) {\n      this.logger.error(`Extractor error at stage '${stagePath}':`, { error });\n      this.extractorErrors.push({\n        stagePath,\n        message: error?.message ?? String(error),\n        error,\n      });\n    }\n  }\n\n  /**\n   * Generate the stage path for extractor results.\n   * Uses node.id (preferred) or node.name, combined with branchPath.\n   */\n  getStagePath(node: StageNode, 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 buildStructureMetadata(node: StageNode): RuntimeStructureMetadata {\n    const metadata: RuntimeStructureMetadata = {\n      type: computeNodeType(node),\n    };\n\n    if (node.isSubflowRoot) {\n      metadata.isSubflowRoot = true;\n      metadata.subflowId = node.subflowId;\n      metadata.subflowName = node.subflowName;\n    } else if (this.currentSubflowId) {\n      metadata.subflowId = this.currentSubflowId;\n    }\n\n    if (this.currentForkId) {\n      metadata.isParallelChild = true;\n      metadata.parallelGroupId = this.currentForkId;\n    }\n\n    if (node.isStreaming) {\n      metadata.streamId = node.streamId;\n    }\n\n    const hasDynamicChildren = Boolean(node.children?.length && !node.nextNodeSelector && node.fn);\n    if (hasDynamicChildren) {\n      metadata.isDynamic = true;\n    }\n\n    return metadata;\n  }\n\n  /** Returns extracted results collected during execution. */\n  getExtractedResults<TResult = unknown>(): Map<string, TResult> {\n    return this.extractedResults as Map<string, TResult>;\n  }\n\n  /** Returns errors encountered during extraction. */\n  getExtractorErrors(): ExtractorError[] {\n    return this.extractorErrors;\n  }\n}\n"]}

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

@@ -0,0 +1,72 @@
+/**
+ * NodeResolver — DFS node lookup + subflow reference resolution.
+ *
+ * Responsibilities:
+ * - Find nodes by ID via recursive depth-first search (for back-edge/loop support)
+ * - Resolve subflow reference nodes to actual subflow structures
+ * - Evaluate deciders to determine next node in branching scenarios
+ */
+export class NodeResolver {
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /**
+     * DFS search for a node by ID.
+     * Checks: current → children (depth-first) → next (linear continuation).
+     */
+    findNodeById(nodeId, startNode) {
+        const node = startNode !== null && startNode !== void 0 ? startNode : this.deps.root;
+        if (node.id === nodeId)
+            return node;
+        if (node.children) {
+            for (const child of node.children) {
+                const found = this.findNodeById(nodeId, child);
+                if (found)
+                    return found;
+            }
+        }
+        if (node.next) {
+            const found = this.findNodeById(nodeId, node.next);
+            if (found)
+                return found;
+        }
+        return undefined;
+    }
+    /**
+     * Resolve a subflow reference node to its actual structure.
+     *
+     * Reference nodes are lightweight placeholders (isSubflowRoot but no fn/children).
+     * The actual structure lives in the subflows dictionary.
+     */
+    resolveSubflowReference(node) {
+        // Already has structure — not a reference
+        if (node.fn || (node.children && node.children.length > 0))
+            return node;
+        if (!this.deps.subflows)
+            return node;
+        // Try multiple keys in order of preference
+        const keysToTry = [node.subflowId, node.subflowName, node.name].filter(Boolean);
+        let subflowDef;
+        for (const key of keysToTry) {
+            if (this.deps.subflows[key]) {
+                subflowDef = this.deps.subflows[key];
+                break;
+            }
+        }
+        if (!subflowDef) {
+            this.deps.logger.info(`Subflow not found in dictionary for node '${node.name}' (tried keys: ${keysToTry.join(', ')})`);
+            return node;
+        }
+        // Merge reference metadata with actual structure
+        return {
+            ...subflowDef.root,
+            isSubflowRoot: node.isSubflowRoot,
+            subflowId: node.subflowId,
+            subflowName: node.subflowName,
+            displayName: node.displayName || subflowDef.root.displayName,
+            id: node.id || subflowDef.root.id,
+            subflowMountOptions: node.subflowMountOptions || subflowDef.root.subflowMountOptions,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTm9kZVJlc29sdmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2xpYi9lbmdpbmUvaGFuZGxlcnMvTm9kZVJlc29sdmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7O0dBT0c7QUFNSCxNQUFNLE9BQU8sWUFBWTtJQUN2QixZQUFvQixJQUErQjtRQUEvQixTQUFJLEdBQUosSUFBSSxDQUEyQjtJQUFHLENBQUM7SUFFdkQ7OztPQUdHO0lBQ0gsWUFBWSxDQUFDLE1BQWMsRUFBRSxTQUFtQztRQUM5RCxNQUFNLElBQUksR0FBRyxTQUFTLGFBQVQsU0FBUyxjQUFULFNBQVMsR0FBSSxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQztRQUV6QyxJQUFJLElBQUksQ0FBQyxFQUFFLEtBQUssTUFBTTtZQUFFLE9BQU8sSUFBSSxDQUFDO1FBRXBDLElBQUksSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO1lBQ2xCLEtBQUssTUFBTSxLQUFLLElBQUksSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO2dCQUNsQyxNQUFNLEtBQUssR0FBRyxJQUFJLENBQUMsWUFBWSxDQUFDLE1BQU0sRUFBRSxLQUFLLENBQUMsQ0FBQztnQkFDL0MsSUFBSSxLQUFLO29CQUFFLE9BQU8sS0FBSyxDQUFDO1lBQzFCLENBQUM7UUFDSCxDQUFDO1FBRUQsSUFBSSxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUM7WUFDZCxNQUFNLEtBQUssR0FBRyxJQUFJLENBQUMsWUFBWSxDQUFDLE1BQU0sRUFBRSxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDbkQsSUFBSSxLQUFLO2dCQUFFLE9BQU8sS0FBSyxDQUFDO1FBQzFCLENBQUM7UUFFRCxPQUFPLFNBQVMsQ0FBQztJQUNuQixDQUFDO0lBRUQ7Ozs7O09BS0c7SUFDSCx1QkFBdUIsQ0FBQyxJQUE2QjtRQUNuRCwwQ0FBMEM7UUFDMUMsSUFBSSxJQUFJLENBQUMsRUFBRSxJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUM7WUFBRSxPQUFPLElBQUksQ0FBQztRQUV4RSxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRO1lBQUUsT0FBTyxJQUFJLENBQUM7UUFFckMsMkNBQTJDO1FBQzNDLE1BQU0sU0FBUyxHQUFHLENBQUMsSUFBSSxDQUFDLFNBQVMsRUFBRSxJQUFJLENBQUMsV0FBVyxFQUFFLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFhLENBQUM7UUFDNUYsSUFBSSxVQUF5RCxDQUFDO1FBRTlELEtBQUssTUFBTSxHQUFHLElBQUksU0FBUyxFQUFFLENBQUM7WUFDNUIsSUFBSSxJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDO2dCQUM1QixVQUFVLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLENBQUM7Z0JBQ3JDLE1BQU07WUFDUixDQUFDO1FBQ0gsQ0FBQztRQUVELElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQztZQUNoQixJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQ25CLDZDQUE2QyxJQUFJLENBQUMsSUFBSSxrQkFBa0IsU0FBUyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUNoRyxDQUFDO1lBQ0YsT0FBTyxJQUFJLENBQUM7UUFDZCxDQUFDO1FBRUQsaURBQWlEO1FBQ2pELE9BQU87WUFDTCxHQUFHLFVBQVUsQ0FBQyxJQUFJO1lBQ2xCLGFBQWEsRUFBRSxJQUFJLENBQUMsYUFBYTtZQUNqQyxTQUFTLEVBQUUsSUFBSSxDQUFDLFNBQVM7WUFDekIsV0FBVyxFQUFFLElBQUksQ0FBQyxXQUFXO1lBQzdCLFdBQVcsRUFBRSxJQUFJLENBQUMsV0FBVyxJQUFJLFVBQVUsQ0FBQyxJQUFJLENBQUMsV0FBVztZQUM1RCxFQUFFLEVBQUUsSUFBSSxDQUFDLEVBQUUsSUFBSSxVQUFVLENBQUMsSUFBSSxDQUFDLEVBQUU7WUFDakMsbUJBQW1CLEVBQUUsSUFBSSxDQUFDLG1CQUFtQixJQUFJLFVBQVUsQ0FBQyxJQUFJLENBQUMsbUJBQW1CO1NBQ3JGLENBQUM7SUFDSixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIE5vZGVSZXNvbHZlciDigJQgREZTIG5vZGUgbG9va3VwICsgc3ViZmxvdyByZWZlcmVuY2UgcmVzb2x1dGlvbi5cbiAqXG4gKiBSZXNwb25zaWJpbGl0aWVzOlxuICogLSBGaW5kIG5vZGVzIGJ5IElEIHZpYSByZWN1cnNpdmUgZGVwdGgtZmlyc3Qgc2VhcmNoIChmb3IgYmFjay1lZGdlL2xvb3Agc3VwcG9ydClcbiAqIC0gUmVzb2x2ZSBzdWJmbG93IHJlZmVyZW5jZSBub2RlcyB0byBhY3R1YWwgc3ViZmxvdyBzdHJ1Y3R1cmVzXG4gKiAtIEV2YWx1YXRlIGRlY2lkZXJzIHRvIGRldGVybWluZSBuZXh0IG5vZGUgaW4gYnJhbmNoaW5nIHNjZW5hcmlvc1xuICovXG5cbmltcG9ydCB0eXBlIHsgU3RhZ2VDb250ZXh0IH0gZnJvbSAnLi4vLi4vbWVtb3J5L1N0YWdlQ29udGV4dCc7XG5pbXBvcnQgdHlwZSB7IFN0YWdlTm9kZSB9IGZyb20gJy4uL2dyYXBoL1N0YWdlTm9kZSc7XG5pbXBvcnQgdHlwZSB7IEhhbmRsZXJEZXBzIH0gZnJvbSAnLi4vdHlwZXMnO1xuXG5leHBvcnQgY2xhc3MgTm9kZVJlc29sdmVyPFRPdXQgPSBhbnksIFRTY29wZSA9IGFueT4ge1xuICBjb25zdHJ1Y3Rvcihwcml2YXRlIGRlcHM6IEhhbmRsZXJEZXBzPFRPdXQsIFRTY29wZT4pIHt9XG5cbiAgLyoqXG4gICAqIERGUyBzZWFyY2ggZm9yIGEgbm9kZSBieSBJRC5cbiAgICogQ2hlY2tzOiBjdXJyZW50IOKGkiBjaGlsZHJlbiAoZGVwdGgtZmlyc3QpIOKGkiBuZXh0IChsaW5lYXIgY29udGludWF0aW9uKS5cbiAgICovXG4gIGZpbmROb2RlQnlJZChub2RlSWQ6IHN0cmluZywgc3RhcnROb2RlPzogU3RhZ2VOb2RlPFRPdXQsIFRTY29wZT4pOiBTdGFnZU5vZGU8VE91dCwgVFNjb3BlPiB8IHVuZGVmaW5lZCB7XG4gICAgY29uc3Qgbm9kZSA9IHN0YXJ0Tm9kZSA/PyB0aGlzLmRlcHMucm9vdDtcblxuICAgIGlmIChub2RlLmlkID09PSBub2RlSWQpIHJldHVybiBub2RlO1xuXG4gICAgaWYgKG5vZGUuY2hpbGRyZW4pIHtcbiAgICAgIGZvciAoY29uc3QgY2hpbGQgb2Ygbm9kZS5jaGlsZHJlbikge1xuICAgICAgICBjb25zdCBmb3VuZCA9IHRoaXMuZmluZE5vZGVCeUlkKG5vZGVJZCwgY2hpbGQpO1xuICAgICAgICBpZiAoZm91bmQpIHJldHVybiBmb3VuZDtcbiAgICAgIH1cbiAgICB9XG5cbiAgICBpZiAobm9kZS5uZXh0KSB7XG4gICAgICBjb25zdCBmb3VuZCA9IHRoaXMuZmluZE5vZGVCeUlkKG5vZGVJZCwgbm9kZS5uZXh0KTtcbiAgICAgIGlmIChmb3VuZCkgcmV0dXJuIGZvdW5kO1xuICAgIH1cblxuICAgIHJldHVybiB1bmRlZmluZWQ7XG4gIH1cblxuICAvKipcbiAgICogUmVzb2x2ZSBhIHN1YmZsb3cgcmVmZXJlbmNlIG5vZGUgdG8gaXRzIGFjdHVhbCBzdHJ1Y3R1cmUuXG4gICAqXG4gICAqIFJlZmVyZW5jZSBub2RlcyBhcmUgbGlnaHR3ZWlnaHQgcGxhY2Vob2xkZXJzIChpc1N1YmZsb3dSb290IGJ1dCBubyBmbi9jaGlsZHJlbikuXG4gICAqIFRoZSBhY3R1YWwgc3RydWN0dXJlIGxpdmVzIGluIHRoZSBzdWJmbG93cyBkaWN0aW9uYXJ5LlxuICAgKi9cbiAgcmVzb2x2ZVN1YmZsb3dSZWZlcmVuY2Uobm9kZTogU3RhZ2VOb2RlPFRPdXQsIFRTY29wZT4pOiBTdGFnZU5vZGU8VE91dCwgVFNjb3BlPiB7XG4gICAgLy8gQWxyZWFkeSBoYXMgc3RydWN0dXJlIOKAlCBub3QgYSByZWZlcmVuY2VcbiAgICBpZiAobm9kZS5mbiB8fCAobm9kZS5jaGlsZHJlbiAmJiBub2RlLmNoaWxkcmVuLmxlbmd0aCA+IDApKSByZXR1cm4gbm9kZTtcblxuICAgIGlmICghdGhpcy5kZXBzLnN1YmZsb3dzKSByZXR1cm4gbm9kZTtcblxuICAgIC8vIFRyeSBtdWx0aXBsZSBrZXlzIGluIG9yZGVyIG9mIHByZWZlcmVuY2VcbiAgICBjb25zdCBrZXlzVG9UcnkgPSBbbm9kZS5zdWJmbG93SWQsIG5vZGUuc3ViZmxvd05hbWUsIG5vZGUubmFtZV0uZmlsdGVyKEJvb2xlYW4pIGFzIHN0cmluZ1tdO1xuICAgIGxldCBzdWJmbG93RGVmOiB7IHJvb3Q6IFN0YWdlTm9kZTxUT3V0LCBUU2NvcGU+IH0gfCB1bmRlZmluZWQ7XG5cbiAgICBmb3IgKGNvbnN0IGtleSBvZiBrZXlzVG9UcnkpIHtcbiAgICAgIGlmICh0aGlzLmRlcHMuc3ViZmxvd3Nba2V5XSkge1xuICAgICAgICBzdWJmbG93RGVmID0gdGhpcy5kZXBzLnN1YmZsb3dzW2tleV07XG4gICAgICAgIGJyZWFrO1xuICAgICAgfVxuICAgIH1cblxuICAgIGlmICghc3ViZmxvd0RlZikge1xuICAgICAgdGhpcy5kZXBzLmxvZ2dlci5pbmZvKFxuICAgICAgICBgU3ViZmxvdyBub3QgZm91bmQgaW4gZGljdGlvbmFyeSBmb3Igbm9kZSAnJHtub2RlLm5hbWV9JyAodHJpZWQga2V5czogJHtrZXlzVG9Ucnkuam9pbignLCAnKX0pYCxcbiAgICAgICk7XG4gICAgICByZXR1cm4gbm9kZTtcbiAgICB9XG5cbiAgICAvLyBNZXJnZSByZWZlcmVuY2UgbWV0YWRhdGEgd2l0aCBhY3R1YWwgc3RydWN0dXJlXG4gICAgcmV0dXJuIHtcbiAgICAgIC4uLnN1YmZsb3dEZWYucm9vdCxcbiAgICAgIGlzU3ViZmxvd1Jvb3Q6IG5vZGUuaXNTdWJmbG93Um9vdCxcbiAgICAgIHN1YmZsb3dJZDogbm9kZS5zdWJmbG93SWQsXG4gICAgICBzdWJmbG93TmFtZTogbm9kZS5zdWJmbG93TmFtZSxcbiAgICAgIGRpc3BsYXlOYW1lOiBub2RlLmRpc3BsYXlOYW1lIHx8IHN1YmZsb3dEZWYucm9vdC5kaXNwbGF5TmFtZSxcbiAgICAgIGlkOiBub2RlLmlkIHx8IHN1YmZsb3dEZWYucm9vdC5pZCxcbiAgICAgIHN1YmZsb3dNb3VudE9wdGlvbnM6IG5vZGUuc3ViZmxvd01vdW50T3B0aW9ucyB8fCBzdWJmbG93RGVmLnJvb3Quc3ViZmxvd01vdW50T3B0aW9ucyxcbiAgICB9O1xuICB9XG59XG4iXX0=

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

@@ -0,0 +1,154 @@
+/**
+ * RuntimeStructureManager — Mutable structure tracking for visualization.
+ *
+ * During execution, dynamic events (new children, subflows, next chains,
+ * loop iterations) modify the pipeline. This manager keeps a serialized
+ * structure in sync so consumers get the complete picture.
+ *
+ * Deep-clones build-time structure at init, then maintains O(1) lookup map.
+ */
+/**
+ * Compute the node type from node properties.
+ * Shared by RuntimeStructureManager (serialization) and ExtractorRunner (metadata).
+ */
+export function computeNodeType(node) {
+    var _a;
+    if (node.nextNodeSelector || node.deciderFn || node.selectorFn)
+        return 'decider';
+    if (node.isStreaming)
+        return 'streaming';
+    const hasDynamicChildren = Boolean(((_a = node.children) === null || _a === void 0 ? void 0 : _a.length) && !node.nextNodeSelector && node.fn);
+    if (node.children && node.children.length > 0 && !hasDynamicChildren)
+        return 'fork';
+    return 'stage';
+}
+export class RuntimeStructureManager {
+    constructor() {
+        this.structureNodeMap = new Map();
+    }
+    /** Initialize from build-time structure. Deep-clones via JSON round-trip. */
+    init(buildTimeStructure) {
+        if (!buildTimeStructure)
+            return;
+        this.runtimePipelineStructure = JSON.parse(JSON.stringify(buildTimeStructure));
+        this.buildNodeMap(this.runtimePipelineStructure);
+    }
+    /** Returns the current runtime structure (mutated during execution). */
+    getStructure() {
+        return this.runtimePipelineStructure;
+    }
+    /** Recursively registers all nodes in the O(1) lookup map. */
+    buildNodeMap(node) {
+        var _a;
+        const key = (_a = node.id) !== null && _a !== void 0 ? _a : node.name;
+        this.structureNodeMap.set(key, node);
+        if (node.children) {
+            for (const child of node.children) {
+                this.buildNodeMap(child);
+            }
+        }
+        if (node.next) {
+            this.buildNodeMap(node.next);
+        }
+        if (node.subflowStructure) {
+            this.buildNodeMap(node.subflowStructure);
+        }
+    }
+    /** Convert a runtime StageNode into a SerializedPipelineStructure node. */
+    stageNodeToStructure(node) {
+        var _a, _b, _c, _d;
+        const structure = {
+            name: node.name,
+            id: node.id,
+            type: computeNodeType(node),
+            displayName: node.displayName,
+            description: node.description,
+        };
+        if (node.isStreaming) {
+            structure.isStreaming = true;
+            structure.streamId = node.streamId;
+        }
+        if (node.isSubflowRoot) {
+            structure.isSubflowRoot = true;
+            structure.subflowId = node.subflowId;
+            structure.subflowName = node.subflowName;
+        }
+        if (node.deciderFn) {
+            structure.hasDecider = true;
+            structure.branchIds = (_a = node.children) === null || _a === void 0 ? void 0 : _a.map((c) => { var _a; return (_a = c.id) !== null && _a !== void 0 ? _a : c.name; });
+        }
+        if (node.nextNodeSelector) {
+            structure.hasSelector = true;
+            structure.branchIds = (_b = node.children) === null || _b === void 0 ? void 0 : _b.map((c) => { var _a; return (_a = c.id) !== null && _a !== void 0 ? _a : c.name; });
+        }
+        if ((_c = node.children) === null || _c === void 0 ? void 0 : _c.length) {
+            structure.children = node.children.map((c) => this.stageNodeToStructure(c));
+        }
+        if (node.next) {
+            structure.next = this.stageNodeToStructure(node.next);
+        }
+        if ((_d = node.subflowDef) === null || _d === void 0 ? void 0 : _d.buildTimeStructure) {
+            structure.subflowStructure = node.subflowDef.buildTimeStructure;
+        }
+        return structure;
+    }
+    /** Update structure when dynamic children are discovered at runtime. */
+    updateDynamicChildren(parentNodeId, dynamicChildren, hasSelector, hasDecider) {
+        if (!this.runtimePipelineStructure)
+            return;
+        const parentStructure = this.structureNodeMap.get(parentNodeId);
+        if (!parentStructure)
+            return;
+        const childStructures = dynamicChildren.map((child) => this.stageNodeToStructure(child));
+        parentStructure.children = childStructures;
+        for (const childStructure of childStructures) {
+            this.buildNodeMap(childStructure);
+        }
+        if (hasSelector) {
+            parentStructure.hasSelector = true;
+            parentStructure.branchIds = childStructures.map((c) => { var _a; return (_a = c.id) !== null && _a !== void 0 ? _a : c.name; });
+        }
+        if (hasDecider) {
+            parentStructure.hasDecider = true;
+            parentStructure.branchIds = childStructures.map((c) => { var _a; return (_a = c.id) !== null && _a !== void 0 ? _a : c.name; });
+        }
+    }
+    /** Update structure when a dynamic subflow is registered at runtime. */
+    updateDynamicSubflow(mountNodeId, subflowId, subflowName, subflowBuildTimeStructure) {
+        if (!this.runtimePipelineStructure)
+            return;
+        const mountStructure = this.structureNodeMap.get(mountNodeId);
+        if (!mountStructure)
+            return;
+        mountStructure.isSubflowRoot = true;
+        mountStructure.subflowId = subflowId;
+        if (subflowName !== undefined) {
+            mountStructure.subflowName = subflowName;
+        }
+        if (subflowBuildTimeStructure) {
+            mountStructure.subflowStructure = subflowBuildTimeStructure;
+            this.buildNodeMap(mountStructure.subflowStructure);
+        }
+    }
+    /** Update structure when a dynamic next chain is discovered at runtime. */
+    updateDynamicNext(currentNodeId, dynamicNext) {
+        if (!this.runtimePipelineStructure)
+            return;
+        const currentStructure = this.structureNodeMap.get(currentNodeId);
+        if (!currentStructure)
+            return;
+        const nextStructure = this.stageNodeToStructure(dynamicNext);
+        currentStructure.next = nextStructure;
+        this.buildNodeMap(nextStructure);
+    }
+    /** Update the iteration count for a node (loop support). */
+    updateIterationCount(nodeId, count) {
+        if (!this.runtimePipelineStructure)
+            return;
+        const nodeStructure = this.structureNodeMap.get(nodeId);
+        if (!nodeStructure)
+            return;
+        nodeStructure.iterationCount = count;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RuntimeStructureManager.js","sourceRoot":"","sources":["../../../../../src/lib/engine/handlers/RuntimeStructureManager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * RuntimeStructureManager — Mutable structure tracking for visualization.\n *\n * During execution, dynamic events (new children, subflows, next chains,\n * loop iterations) modify the pipeline. This manager keeps a serialized\n * structure in sync so consumers get the complete picture.\n *\n * Deep-clones build-time structure at init, then maintains O(1) lookup map.\n */\n\nimport type { StageNode } from '../graph/StageNode';\nimport type { SerializedPipelineStructure } from '../types';\n\n/**\n * Compute the node type from node properties.\n * Shared by RuntimeStructureManager (serialization) and ExtractorRunner (metadata).\n */\nexport function computeNodeType(node: StageNode): 'stage' | 'decider' | 'fork' | 'streaming' {\n  if (node.nextNodeSelector || node.deciderFn || node.selectorFn) return 'decider';\n  if (node.isStreaming) return 'streaming';\n\n  const hasDynamicChildren = Boolean(node.children?.length && !node.nextNodeSelector && node.fn);\n  if (node.children && node.children.length > 0 && !hasDynamicChildren) return 'fork';\n\n  return 'stage';\n}\n\nexport class RuntimeStructureManager {\n  private runtimePipelineStructure?: SerializedPipelineStructure;\n  private structureNodeMap: Map<string, SerializedPipelineStructure> = new Map();\n\n  /** Initialize from build-time structure. Deep-clones via JSON round-trip. */\n  init(buildTimeStructure?: SerializedPipelineStructure): void {\n    if (!buildTimeStructure) return;\n    this.runtimePipelineStructure = JSON.parse(JSON.stringify(buildTimeStructure));\n    this.buildNodeMap(this.runtimePipelineStructure!);\n  }\n\n  /** Returns the current runtime structure (mutated during execution). */\n  getStructure(): SerializedPipelineStructure | undefined {\n    return this.runtimePipelineStructure;\n  }\n\n  /** Recursively registers all nodes in the O(1) lookup map. */\n  private buildNodeMap(node: SerializedPipelineStructure): void {\n    const key = node.id ?? node.name;\n    this.structureNodeMap.set(key, node);\n\n    if (node.children) {\n      for (const child of node.children) {\n        this.buildNodeMap(child);\n      }\n    }\n    if (node.next) {\n      this.buildNodeMap(node.next);\n    }\n    if (node.subflowStructure) {\n      this.buildNodeMap(node.subflowStructure);\n    }\n  }\n\n  /** Convert a runtime StageNode into a SerializedPipelineStructure node. */\n  stageNodeToStructure(node: StageNode): SerializedPipelineStructure {\n    const structure: SerializedPipelineStructure = {\n      name: node.name,\n      id: node.id,\n      type: computeNodeType(node),\n      displayName: node.displayName,\n      description: node.description,\n    };\n\n    if (node.isStreaming) {\n      structure.isStreaming = true;\n      structure.streamId = node.streamId;\n    }\n\n    if (node.isSubflowRoot) {\n      structure.isSubflowRoot = true;\n      structure.subflowId = node.subflowId;\n      structure.subflowName = node.subflowName;\n    }\n\n    if (node.deciderFn) {\n      structure.hasDecider = true;\n      structure.branchIds = node.children?.map((c) => c.id ?? c.name);\n    }\n\n    if (node.nextNodeSelector) {\n      structure.hasSelector = true;\n      structure.branchIds = node.children?.map((c) => c.id ?? c.name);\n    }\n\n    if (node.children?.length) {\n      structure.children = node.children.map((c) => this.stageNodeToStructure(c));\n    }\n\n    if (node.next) {\n      structure.next = this.stageNodeToStructure(node.next);\n    }\n\n    if (node.subflowDef?.buildTimeStructure) {\n      structure.subflowStructure = node.subflowDef.buildTimeStructure as SerializedPipelineStructure;\n    }\n\n    return structure;\n  }\n\n  /** Update structure when dynamic children are discovered at runtime. */\n  updateDynamicChildren(\n    parentNodeId: string,\n    dynamicChildren: StageNode[],\n    hasSelector?: boolean,\n    hasDecider?: boolean,\n  ): void {\n    if (!this.runtimePipelineStructure) return;\n\n    const parentStructure = this.structureNodeMap.get(parentNodeId);\n    if (!parentStructure) return;\n\n    const childStructures = dynamicChildren.map((child) => this.stageNodeToStructure(child));\n    parentStructure.children = childStructures;\n\n    for (const childStructure of childStructures) {\n      this.buildNodeMap(childStructure);\n    }\n\n    if (hasSelector) {\n      parentStructure.hasSelector = true;\n      parentStructure.branchIds = childStructures.map((c) => c.id ?? c.name);\n    }\n\n    if (hasDecider) {\n      parentStructure.hasDecider = true;\n      parentStructure.branchIds = childStructures.map((c) => c.id ?? c.name);\n    }\n  }\n\n  /** Update structure when a dynamic subflow is registered at runtime. */\n  updateDynamicSubflow(\n    mountNodeId: string,\n    subflowId: string,\n    subflowName?: string,\n    subflowBuildTimeStructure?: unknown,\n  ): void {\n    if (!this.runtimePipelineStructure) return;\n\n    const mountStructure = this.structureNodeMap.get(mountNodeId);\n    if (!mountStructure) return;\n\n    mountStructure.isSubflowRoot = true;\n    mountStructure.subflowId = subflowId;\n\n    if (subflowName !== undefined) {\n      mountStructure.subflowName = subflowName;\n    }\n\n    if (subflowBuildTimeStructure) {\n      mountStructure.subflowStructure = subflowBuildTimeStructure as SerializedPipelineStructure;\n      this.buildNodeMap(mountStructure.subflowStructure);\n    }\n  }\n\n  /** Update structure when a dynamic next chain is discovered at runtime. */\n  updateDynamicNext(currentNodeId: string, dynamicNext: StageNode): void {\n    if (!this.runtimePipelineStructure) return;\n\n    const currentStructure = this.structureNodeMap.get(currentNodeId);\n    if (!currentStructure) return;\n\n    const nextStructure = this.stageNodeToStructure(dynamicNext);\n    currentStructure.next = nextStructure;\n    this.buildNodeMap(nextStructure);\n  }\n\n  /** Update the iteration count for a node (loop support). */\n  updateIterationCount(nodeId: string, count: number): void {\n    if (!this.runtimePipelineStructure) return;\n    const nodeStructure = this.structureNodeMap.get(nodeId);\n    if (!nodeStructure) return;\n    nodeStructure.iterationCount = count;\n  }\n}\n"]}

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

@@ -0,0 +1,79 @@
+/**
+ * SelectorHandler — Multi-choice filtered fan-out.
+ *
+ * Responsibilities:
+ * - Execute scope-based selector nodes (stage → commit → resolve children → parallel execution)
+ * - The selector function IS a stage: reads scope, returns string[] of branch IDs
+ * - Delegates parallel execution of selected children to ChildrenExecutor
+ */
+export class SelectorHandler {
+    constructor(deps, childrenExecutor) {
+        this.deps = deps;
+        this.childrenExecutor = childrenExecutor;
+    }
+    /**
+     * Handle a scope-based selector node (created via addSelectorFunction).
+     * The stage function IS the selector — its return value contains branch IDs.
+     * Execution order: runStage(fn) → commit → resolve children → parallel execute.
+     */
+    async handleScopeBased(node, stageFunc, context, breakFlag, branchPath, runStage, executeNode, callExtractor, getStagePath) {
+        var _a;
+        const breakFn = () => (breakFlag.shouldBreak = true);
+        let selectedIds;
+        try {
+            const stageOutput = await runStage(node, stageFunc, context, breakFn);
+            selectedIds = Array.isArray(stageOutput) ? stageOutput.map(String) : [String(stageOutput)];
+        }
+        catch (error) {
+            context.commit();
+            callExtractor(node, context, getStagePath(node, branchPath, context.stageName), undefined, {
+                type: 'stageExecutionError',
+                message: error.toString(),
+            });
+            this.deps.logger.error(`Error in pipeline (${branchPath}) stage [${node.name}]:`, { error });
+            context.addError('stageExecutionError', error.toString());
+            this.deps.narrativeGenerator.onError(node.name, error.toString(), node.displayName);
+            throw error;
+        }
+        context.commit();
+        callExtractor(node, context, getStagePath(node, branchPath, context.stageName), selectedIds);
+        if (breakFlag.shouldBreak) {
+            this.deps.logger.info(`Execution stopped in pipeline (${branchPath}) after ${node.name} due to break condition.`);
+            return {};
+        }
+        context.addLog('selectedChildIds', selectedIds);
+        context.addLog('selectorPattern', 'scope-based-multi-choice');
+        if (selectedIds.length === 0) {
+            context.addLog('skippedAllChildren', true);
+            context.addFlowDebugMessage('selected', 'No children selected — skipping all branches.', {
+                count: 0,
+                targetStage: [],
+            });
+            this.deps.narrativeGenerator.onSelected(node.displayName || node.name, [], ((_a = node.children) !== null && _a !== void 0 ? _a : []).length);
+            return {};
+        }
+        // Resolve children by matching selected IDs against node.children
+        const children = node.children;
+        const selectedChildren = children.filter((c) => selectedIds.includes(c.id));
+        // Validate all IDs exist (fail fast)
+        if (selectedChildren.length !== selectedIds.length) {
+            const childIds = children.map((c) => c.id);
+            const missing = selectedIds.filter((id) => !childIds.includes(id));
+            const errorMessage = `Scope-based selector '${node.name}' returned unknown child IDs: ${missing.join(', ')}. Available: ${childIds.join(', ')}`;
+            this.deps.logger.error(`Error in pipeline (${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 selectedNames = selectedChildren.map((c) => c.displayName || c.name).join(', ');
+        context.addFlowDebugMessage('selected', `Running ${selectedNames} (${selectedChildren.length} of ${children.length} matched)`, { count: selectedChildren.length, targetStage: selectedChildren.map((c) => c.name) });
+        const selectedDisplayNames = selectedChildren.map((c) => c.displayName || c.name);
+        this.deps.narrativeGenerator.onSelected(node.displayName || node.name, selectedDisplayNames, children.length);
+        const tempNode = { name: 'selector-temp', children: selectedChildren };
+        return await this.childrenExecutor.executeNodeChildren(tempNode, context, undefined, branchPath);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SelectorHandler.js","sourceRoot":"","sources":["../../../../../src/lib/engine/handlers/SelectorHandler.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * SelectorHandler — Multi-choice filtered fan-out.\n *\n * Responsibilities:\n * - Execute scope-based selector nodes (stage → commit → resolve children → parallel execution)\n * - The selector function IS a stage: reads scope, returns string[] of branch IDs\n * - Delegates parallel execution of selected children to ChildrenExecutor\n */\n\nimport type { StageContext } from '../../memory/StageContext';\nimport type { StageNode } from '../graph/StageNode';\nimport type { HandlerDeps, NodeResultType, StageFunction } from '../types';\nimport type { ChildrenExecutor } from './ChildrenExecutor';\nimport type { CallExtractorFn, ExecuteNodeFn, GetStagePathFn, RunStageFn } from './DeciderHandler';\n\nexport class SelectorHandler<TOut = any, TScope = any> {\n  constructor(\n    private readonly deps: HandlerDeps<TOut, TScope>,\n    private readonly childrenExecutor: ChildrenExecutor<TOut, TScope>,\n  ) {}\n\n  /**\n   * Handle a scope-based selector node (created via addSelectorFunction).\n   * The stage function IS the selector — its return value contains branch IDs.\n   * Execution order: runStage(fn) → commit → resolve children → parallel execute.\n   */\n  async handleScopeBased(\n    node: StageNode<TOut, TScope>,\n    stageFunc: StageFunction<TOut, TScope>,\n    context: StageContext,\n    breakFlag: { shouldBreak: boolean },\n    branchPath: string | undefined,\n    runStage: RunStageFn<TOut, TScope>,\n    executeNode: ExecuteNodeFn<TOut, TScope>,\n    callExtractor: CallExtractorFn<TOut, TScope>,\n    getStagePath: GetStagePathFn<TOut, TScope>,\n  ): Promise<Record<string, NodeResultType>> {\n    const breakFn = () => (breakFlag.shouldBreak = true);\n\n    let selectedIds: string[];\n    try {\n      const stageOutput = await runStage(node, stageFunc, context, breakFn);\n      selectedIds = Array.isArray(stageOutput) ? stageOutput.map(String) : [String(stageOutput)];\n    } catch (error: any) {\n      context.commit();\n      callExtractor(node, context, getStagePath(node, branchPath, context.stageName), undefined, {\n        type: 'stageExecutionError',\n        message: error.toString(),\n      });\n      this.deps.logger.error(`Error in pipeline (${branchPath}) stage [${node.name}]:`, { error });\n      context.addError('stageExecutionError', error.toString());\n      this.deps.narrativeGenerator.onError(node.name, error.toString(), node.displayName);\n      throw error;\n    }\n\n    context.commit();\n    callExtractor(node, context, getStagePath(node, branchPath, context.stageName), selectedIds);\n\n    if (breakFlag.shouldBreak) {\n      this.deps.logger.info(`Execution stopped in pipeline (${branchPath}) after ${node.name} due to break condition.`);\n      return {};\n    }\n\n    context.addLog('selectedChildIds', selectedIds);\n    context.addLog('selectorPattern', 'scope-based-multi-choice');\n\n    if (selectedIds.length === 0) {\n      context.addLog('skippedAllChildren', true);\n      context.addFlowDebugMessage('selected', 'No children selected — skipping all branches.', {\n        count: 0,\n        targetStage: [],\n      });\n      this.deps.narrativeGenerator.onSelected(node.displayName || node.name, [], (node.children ?? []).length);\n      return {};\n    }\n\n    // Resolve children by matching selected IDs against node.children\n    const children = node.children as StageNode<TOut, TScope>[];\n    const selectedChildren = children.filter((c) => selectedIds.includes(c.id!));\n\n    // Validate all IDs exist (fail fast)\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 = `Scope-based selector '${node.name}' returned unknown child IDs: ${missing.join(\n        ', ',\n      )}. Available: ${childIds.join(', ')}`;\n      this.deps.logger.error(`Error in pipeline (${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 selectedNames = selectedChildren.map((c) => c.displayName || c.name).join(', ');\n    context.addFlowDebugMessage(\n      'selected',\n      `Running ${selectedNames} (${selectedChildren.length} of ${children.length} matched)`,\n      { count: selectedChildren.length, targetStage: selectedChildren.map((c) => c.name) },\n    );\n\n    const selectedDisplayNames = selectedChildren.map((c) => c.displayName || c.name);\n    this.deps.narrativeGenerator.onSelected(node.displayName || node.name, selectedDisplayNames, children.length);\n\n    const tempNode: StageNode<TOut, TScope> = { name: 'selector-temp', children: selectedChildren };\n    return await this.childrenExecutor.executeNodeChildren(tempNode, context, undefined, branchPath);\n  }\n}\n"]}

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

@@ -0,0 +1,86 @@
+/**
+ * StageRunner — Executes individual stage functions.
+ *
+ * Responsibilities:
+ * - Create scope via ScopeFactory for each stage
+ * - Apply scope protection (createProtectedScope) to intercept direct assignments
+ * - Handle streaming stages (onStart, onToken, onEnd lifecycle)
+ * - Sync+async safety: only await real Promises (instanceof check)
+ */
+import { createProtectedScope } from '../../scope/protection/createProtectedScope';
+export class StageRunner {
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async run(node, stageFunc, context, breakFn) {
+        var _a, _b, _c, _d, _e, _f;
+        // Create scope via ScopeFactory — each stage gets its own scope instance
+        const rawScope = this.deps.ScopeFactory(context, node.name, this.deps.readOnlyContext);
+        // Wrap scope with protection to intercept direct property assignments
+        const scope = createProtectedScope(rawScope, {
+            mode: this.deps.scopeProtectionMode,
+            stageName: node.name,
+        });
+        // Set up streaming callback if this is a streaming stage
+        let streamCallback;
+        let accumulatedText = '';
+        if (node.isStreaming) {
+            const streamId = (_a = node.streamId) !== null && _a !== void 0 ? _a : node.name;
+            streamCallback = (token) => {
+                var _a, _b;
+                accumulatedText += token;
+                (_b = (_a = this.deps.streamHandlers) === null || _a === void 0 ? void 0 : _a.onToken) === null || _b === void 0 ? void 0 : _b.call(_a, streamId, token);
+            };
+            (_c = (_b = this.deps.streamHandlers) === null || _b === void 0 ? void 0 : _b.onStart) === null || _c === void 0 ? void 0 : _c.call(_b, streamId);
+        }
+        // Notify recorders of stage start (if scope supports it)
+        if (rawScope && typeof rawScope.notifyStageStart === 'function') {
+            rawScope.notifyStageStart();
+        }
+        // Execute the stage function
+        const output = stageFunc(scope, breakFn, streamCallback);
+        // Sync+async safety: only await real Promises to avoid thenable assimilation
+        let result;
+        if (output instanceof Promise) {
+            // Race against AbortSignal if provided
+            if (this.deps.signal) {
+                result = await raceAbort(output, this.deps.signal);
+            }
+            else {
+                result = await output;
+            }
+        }
+        else {
+            result = output;
+        }
+        // Notify recorders of stage end (if scope supports it)
+        if (rawScope && typeof rawScope.notifyStageEnd === 'function') {
+            rawScope.notifyStageEnd();
+        }
+        // Call onEnd lifecycle hook for streaming stages
+        if (node.isStreaming) {
+            const streamId = (_d = node.streamId) !== null && _d !== void 0 ? _d : node.name;
+            (_f = (_e = this.deps.streamHandlers) === null || _e === void 0 ? void 0 : _e.onEnd) === null || _f === void 0 ? void 0 : _f.call(_e, streamId, accumulatedText);
+        }
+        return result;
+    }
+}
+/** Race a promise against an AbortSignal. Rejects with the signal's reason on abort. */
+function raceAbort(promise, signal) {
+    var _a;
+    if (signal.aborted) {
+        return Promise.reject(signal.reason instanceof Error ? signal.reason : new Error((_a = signal.reason) !== null && _a !== void 0 ? _a : 'Aborted'));
+    }
+    return new Promise((resolve, reject) => {
+        const onAbort = () => { var _a; return reject(signal.reason instanceof Error ? signal.reason : new Error((_a = signal.reason) !== null && _a !== void 0 ? _a : 'Aborted')); };
+        signal.addEventListener('abort', onAbort, { once: true });
+        promise.then((val) => {
+            signal.removeEventListener('abort', onAbort);
+            resolve(val);
+        }, (err) => {
+            signal.removeEventListener('abort', onAbort);
+            reject(err);
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"StageRunner.js","sourceRoot":"","sources":["../../../../../src/lib/engine/handlers/StageRunner.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * StageRunner — Executes individual stage functions.\n *\n * Responsibilities:\n * - Create scope via ScopeFactory for each stage\n * - Apply scope protection (createProtectedScope) to intercept direct assignments\n * - Handle streaming stages (onStart, onToken, onEnd lifecycle)\n * - Sync+async safety: only await real Promises (instanceof check)\n */\n\nimport type { StageContext } from '../../memory/StageContext';\nimport { createProtectedScope } from '../../scope/protection/createProtectedScope';\nimport type { StageNode } from '../graph/StageNode';\nimport type { HandlerDeps, StageFunction, StreamCallback } from '../types';\n\nexport class StageRunner<TOut = any, TScope = any> {\n  constructor(private readonly deps: HandlerDeps<TOut, TScope>) {}\n\n  async run(\n    node: StageNode<TOut, TScope>,\n    stageFunc: StageFunction<TOut, TScope>,\n    context: StageContext,\n    breakFn: () => void,\n  ): Promise<TOut> {\n    // Create scope via ScopeFactory — each stage gets its own scope instance\n    const rawScope = this.deps.ScopeFactory(context, node.name, this.deps.readOnlyContext);\n\n    // Wrap scope with protection to intercept direct property assignments\n    const scope = createProtectedScope(rawScope as object, {\n      mode: this.deps.scopeProtectionMode,\n      stageName: node.name,\n    }) as TScope;\n\n    // Set up streaming callback if this is a streaming stage\n    let streamCallback: StreamCallback | undefined;\n    let accumulatedText = '';\n\n    if (node.isStreaming) {\n      const streamId = node.streamId ?? node.name;\n      streamCallback = (token: string) => {\n        accumulatedText += token;\n        this.deps.streamHandlers?.onToken?.(streamId, token);\n      };\n      this.deps.streamHandlers?.onStart?.(streamId);\n    }\n\n    // Notify recorders of stage start (if scope supports it)\n    if (rawScope && typeof (rawScope as any).notifyStageStart === 'function') {\n      (rawScope as any).notifyStageStart();\n    }\n\n    // Execute the stage function\n    const output = stageFunc(scope, breakFn, streamCallback);\n\n    // Sync+async safety: only await real Promises to avoid thenable assimilation\n    let result: TOut;\n    if (output instanceof Promise) {\n      // Race against AbortSignal if provided\n      if (this.deps.signal) {\n        result = await raceAbort(output, this.deps.signal);\n      } else {\n        result = await output;\n      }\n    } else {\n      result = output;\n    }\n\n    // Notify recorders of stage end (if scope supports it)\n    if (rawScope && typeof (rawScope as any).notifyStageEnd === 'function') {\n      (rawScope as any).notifyStageEnd();\n    }\n\n    // Call onEnd lifecycle hook for streaming stages\n    if (node.isStreaming) {\n      const streamId = node.streamId ?? node.name;\n      this.deps.streamHandlers?.onEnd?.(streamId, accumulatedText);\n    }\n\n    return result;\n  }\n}\n\n/** Race a promise against an AbortSignal. Rejects with the signal's reason on abort. */\nfunction raceAbort<T>(promise: Promise<T>, signal: AbortSignal): Promise<T> {\n  if (signal.aborted) {\n    return Promise.reject(signal.reason instanceof Error ? signal.reason : new Error(signal.reason ?? 'Aborted'));\n  }\n  return new Promise<T>((resolve, reject) => {\n    const onAbort = () =>\n      reject(signal.reason instanceof Error ? signal.reason : new Error(signal.reason ?? 'Aborted'));\n    signal.addEventListener('abort', onAbort, { once: true });\n    promise.then(\n      (val) => {\n        signal.removeEventListener('abort', onAbort);\n        resolve(val);\n      },\n      (err) => {\n        signal.removeEventListener('abort', onAbort);\n        reject(err);\n      },\n    );\n  });\n}\n"]}