veryfront 0.1.699 → 0.1.701

package/esm/deno.js

@@ -1,6 +1,6 @@
 export default {
     "name": "veryfront",
-    "version": "0.1.699",
+    "version": "0.1.701",
     "license": "Apache-2.0",
     "nodeModulesDir": "auto",
     "minimumDependencyAge": "P2D",

package/esm/src/utils/version-constant.d.ts

@@ -1,3 +1,3 @@
 /** Shared version value. */
-export declare const VERSION = "0.1.699";
+export declare const VERSION = "0.1.701";
 //# sourceMappingURL=version-constant.d.ts.map

package/esm/src/utils/version-constant.js

@@ -1,4 +1,4 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
 /** Shared version value. */
-export const VERSION = "0.1.699";
+export const VERSION = "0.1.701";

package/esm/src/workflow/executor/dag/index.d.ts

@@ -15,11 +15,10 @@ export declare class DAGExecutor {
     private executeNode;
     private executeStepNode;
     private executeParallelNode;
-    private executeMapNode;
     private executeBranchNode;
     private executeWaitNode;
     private executeSubWorkflowNode;
-    private executeLoopNode;
     private checkpoint;
+    private executeChildGraph;
 }
 //# sourceMappingURL=index.d.ts.map

package/esm/src/workflow/executor/dag/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/src/workflow/executor/dag/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAYV,YAAY,EAEZ,WAAW,EACZ,MAAM,gBAAgB,CAAC;AAIxB,YAAY,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAE7F,OAAO,KAAK,EACV,kBAAkB,EAClB,iBAAiB,EAGlB,MAAM,YAAY,CAAC;AAIpB,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAA4B;gBAE9B,MAAM,EAAE,iBAAiB;IAQ/B,OAAO,CACX,KAAK,EAAE,YAAY,EAAE,EACrB,GAAG,EAAE,WAAW,EAChB,aAAa,CAAC,EAAE,MAAM,GACrB,OAAO,CAAC,kBAAkB,CAAC;YAsGhB,WAAW;YA8CX,eAAe;YA0Bf,mBAAmB;YA4CnB,cAAc;YAqGd,iBAAiB;YA+DjB,eAAe;YA8Bf,sBAAsB;YA+DtB,eAAe;YAsKf,UAAU;CAoBzB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/src/workflow/executor/dag/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAQV,YAAY,EAEZ,WAAW,EACZ,MAAM,gBAAgB,CAAC;AAIxB,YAAY,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAE7F,OAAO,KAAK,EACV,kBAAkB,EAClB,iBAAiB,EAGlB,MAAM,YAAY,CAAC;AAOpB,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAA4B;gBAE9B,MAAM,EAAE,iBAAiB;IAQ/B,OAAO,CACX,KAAK,EAAE,YAAY,EAAE,EACrB,GAAG,EAAE,WAAW,EAChB,aAAa,CAAC,EAAE,MAAM,GACrB,OAAO,CAAC,kBAAkB,CAAC;YAsGhB,WAAW;YAgEX,eAAe;YA0Bf,mBAAmB;YA4CnB,iBAAiB;YA+DjB,eAAe;YA8Bf,sBAAsB;YA+DtB,UAAU;YAqBV,iBAAiB;CAiBhC"}

package/esm/src/workflow/executor/dag/index.js

@@ -5,10 +5,12 @@
  *
  * @module ai/workflow/executor/dag
  */
-import { generateId, parseDuration } from "../../types.js";
+import { generateId } from "../../types.js";
 import { INVALID_ARGUMENT, NOT_SUPPORTED } from "../../../errors/index.js";
-import { deriveNodeStatus, shouldCheckpoint, sleep } from "./utils.js";
+import { deriveNodeStatus, shouldCheckpoint } from "./utils.js";
 import { buildGraph, getReadyNodes, hasCycle, updateInDegreesForCompletedNodes } from "./graph.js";
+import { executeLoopNodeStrategy } from "./loop-node-strategy.js";
+import { executeMapNodeStrategy } from "./map-node-strategy.js";
 export class DAGExecutor {
     config;
     constructor(config) {
@@ -118,7 +120,16 @@ export class DAGExecutor {
             case "parallel":
                 return this.executeParallelNode(node, config, context, nodeStates);
             case "map":
-                return this.executeMapNode(node, config, context, nodeStates);
+                return executeMapNodeStrategy({
+                    node,
+                    config,
+                    context,
+                    nodeStates,
+                    runtime: {
+                        executeChildGraph: (nodes, run, options) => this.executeChildGraph(nodes, run, options),
+                        onNodeComplete: this.config.onNodeComplete,
+                    },
+                });
             case "branch":
                 return this.executeBranchNode(node, config, context, nodeStates);
             case "wait":
@@ -126,7 +137,16 @@ export class DAGExecutor {
             case "subWorkflow":
                 return this.executeSubWorkflowNode(node, config, context);
             case "loop":
-                return this.executeLoopNode(node, config, context, nodeStates);
+                return executeLoopNodeStrategy({
+                    node,
+                    config,
+                    context,
+                    nodeStates,
+                    runtime: {
+                        executeChildGraph: (nodes, run) => this.executeChildGraph(nodes, run),
+                        onNodeComplete: this.config.onNodeComplete,
+                    },
+                });
             default:
                 throw INVALID_ARGUMENT.create({
                     detail: `Unknown node type "${config.type}" for node "${node.id}". ` +
@@ -186,85 +206,6 @@ export class DAGExecutor {
             waiting: result.waiting,
         };
     }
-    async executeMapNode(node, config, context, nodeStates) {
-        const startTime = Date.now();
-        const items = typeof config.items === "function" ? await config.items(context) : config.items;
-        if (!Array.isArray(items)) {
-            throw INVALID_ARGUMENT.create({ detail: `Map node "${node.id}" items must be an array` });
-        }
-        if (items.length === 0) {
-            const state = {
-                nodeId: node.id,
-                status: "completed",
-                output: [],
-                attempt: 1,
-                startedAt: new Date(startTime),
-                completedAt: new Date(),
-            };
-            return { state, contextUpdates: { [node.id]: [] }, waiting: false };
-        }
-        const isWorkflowDef = (p) => typeof p === "object" && p !== null && "steps" in p;
-        const childNodes = items.map((item, i) => {
-            const childId = `${node.id}_${i}`;
-            if (isWorkflowDef(config.processor)) {
-                return {
-                    id: childId,
-                    config: {
-                        type: "subWorkflow",
-                        workflow: config.processor,
-                        input: item,
-                        retry: config.retry,
-                        checkpoint: false,
-                    },
-                };
-            }
-            const processorConfig = { ...config.processor.config };
-            if (processorConfig.type === "step") {
-                processorConfig.input = item;
-            }
-            return { id: childId, config: processorConfig };
-        });
-        const originalConcurrency = this.config.maxConcurrency;
-        if (config.concurrency) {
-            this.config.maxConcurrency = config.concurrency;
-        }
-        try {
-            const result = await this.execute(childNodes, {
-                id: `${node.id}_map`,
-                workflowId: "",
-                status: "running",
-                input: context.input,
-                // Carry already-accumulated child states so completed children are
-                // skipped on resume instead of re-executing (H8).
-                nodeStates,
-                currentNodes: [],
-                context: { ...context },
-                checkpoints: [],
-                pendingApprovals: [],
-                createdAt: new Date(),
-            });
-            Object.assign(nodeStates, result.nodeStates);
-            const outputs = childNodes.map((child) => result.nodeStates[child.id]?.output);
-            const state = {
-                nodeId: node.id,
-                status: deriveNodeStatus(result.completed, result.waiting),
-                output: outputs,
-                error: result.error,
-                attempt: 1,
-                startedAt: new Date(startTime),
-                completedAt: result.completed ? new Date() : undefined,
-            };
-            this.config.onNodeComplete?.(node.id, state);
-            return {
-                state,
-                contextUpdates: result.completed ? { [node.id]: outputs } : {},
-                waiting: result.waiting,
-            };
-        }
-        finally {
-            this.config.maxConcurrency = originalConcurrency;
-        }
-    }
     async executeBranchNode(node, config, context, nodeStates) {
         const startTime = Date.now();
         const conditionResult = await config.condition(context);
@@ -383,139 +324,6 @@ export class DAGExecutor {
             waiting: result.waiting,
         };
     }
-    async executeLoopNode(node, config, context, nodeStates) {
-        const startTime = Date.now();
-        const previousResults = [];
-        let iteration = 0;
-        let exitReason = "condition";
-        let lastError;
-        const existingLoopState = context[`${node.id}_loop_state`];
-        // Child node states for the in-flight (resumed) iteration, so its already
-        // completed steps are not re-executed on resume (H9).
-        let resumeIterationNodeStates;
-        let resumeIteration;
-        if (existingLoopState) {
-            iteration = existingLoopState.iteration;
-            previousResults.push(...existingLoopState.previousResults);
-            resumeIterationNodeStates = existingLoopState.iterationNodeStates;
-            resumeIteration = existingLoopState.iteration;
-        }
-        while (iteration < config.maxIterations) {
-            const loopContext = {
-                iteration,
-                totalIterations: iteration,
-                previousResults: [...previousResults],
-                isFirstIteration: iteration === 0,
-                isLastAllowedIteration: iteration === config.maxIterations - 1,
-            };
-            if (!(await config.while(context, loopContext))) {
-                exitReason = "condition";
-                break;
-            }
-            const steps = typeof config.steps === "function"
-                ? config.steps(context, loopContext)
-                : config.steps;
-            // On resume, rehydrate the in-flight iteration's child node states so its
-            // already-completed steps are skipped instead of re-executed (H9).
-            const iterationNodeStates = resumeIteration === iteration && resumeIterationNodeStates
-                ? { ...resumeIterationNodeStates }
-                : {};
-            // Only rehydrate once; subsequent iterations start fresh.
-            resumeIterationNodeStates = undefined;
-            const result = await this.execute(steps, {
-                id: `${node.id}_iter_${iteration}`,
-                workflowId: "",
-                status: "running",
-                input: context.input,
-                nodeStates: iterationNodeStates,
-                currentNodes: [],
-                context: { ...context, _loop: loopContext },
-                checkpoints: [],
-                pendingApprovals: [],
-                createdAt: new Date(),
-            });
-            if (result.waiting) {
-                Object.assign(nodeStates, result.nodeStates);
-                const state = {
-                    nodeId: node.id,
-                    status: "running",
-                    output: { iteration, waiting: true, previousResults },
-                    attempt: 1,
-                    startedAt: new Date(startTime),
-                };
-                return {
-                    state,
-                    contextUpdates: {
-                        ...result.context,
-                        [`${node.id}_loop_state`]: {
-                            iteration,
-                            previousResults,
-                            // Persist the in-flight iteration's child states so completed
-                            // steps are not re-executed when this iteration resumes (H9).
-                            iterationNodeStates: result.nodeStates,
-                        },
-                    },
-                    waiting: true,
-                };
-            }
-            if (result.error) {
-                lastError = result.error;
-                exitReason = "error";
-                break;
-            }
-            previousResults.push(result.context);
-            Object.assign(context, result.context);
-            Object.assign(nodeStates, result.nodeStates);
-            if (config.delay && iteration < config.maxIterations - 1) {
-                const delayMs = typeof config.delay === "number"
-                    ? config.delay
-                    : parseDuration(config.delay);
-                await sleep(delayMs);
-            }
-            iteration++;
-        }
-        if (iteration >= config.maxIterations && exitReason !== "condition") {
-            exitReason = "maxIterations";
-        }
-        const finalLoopContext = {
-            iteration,
-            totalIterations: iteration,
-            previousResults,
-            isFirstIteration: false,
-            isLastAllowedIteration: true,
-        };
-        let completionUpdates = {};
-        if (exitReason === "maxIterations" && config.onMaxIterations) {
-            completionUpdates = await config.onMaxIterations(context, finalLoopContext);
-        }
-        else if (exitReason === "condition" && config.onComplete) {
-            completionUpdates = await config.onComplete(context, finalLoopContext);
-        }
-        const output = {
-            exitReason,
-            iterations: iteration,
-            previousResults,
-            ...completionUpdates,
-        };
-        const state = {
-            nodeId: node.id,
-            status: exitReason === "error" ? "failed" : "completed",
-            output,
-            error: lastError,
-            attempt: 1,
-            startedAt: new Date(startTime),
-            completedAt: new Date(),
-        };
-        this.config.onNodeComplete?.(node.id, state);
-        return {
-            state,
-            contextUpdates: {
-                [node.id]: output,
-                ...completionUpdates,
-            },
-            waiting: false,
-        };
-    }
     async checkpoint(runId, nodeId, context, nodeStates) {
         if (!this.config.checkpointManager) {
             return;
@@ -529,4 +337,17 @@ export class DAGExecutor {
         };
         await this.config.checkpointManager.save(runId, checkpoint);
     }
+    async executeChildGraph(nodes, run, options) {
+        if (!options?.maxConcurrency) {
+            return await this.execute(nodes, run);
+        }
+        const originalConcurrency = this.config.maxConcurrency;
+        this.config.maxConcurrency = options.maxConcurrency;
+        try {
+            return await this.execute(nodes, run);
+        }
+        finally {
+            this.config.maxConcurrency = originalConcurrency;
+        }
+    }
 }

package/esm/src/workflow/executor/dag/loop-node-strategy.d.ts

@@ -0,0 +1,13 @@
+import type { LoopNodeConfig, NodeState, WorkflowContext, WorkflowNode } from "../../types.js";
+import type { NodeExecutionResult } from "./types.js";
+import type { NodeStrategyRuntime } from "./node-strategy-types.js";
+interface ExecuteLoopNodeStrategyInput {
+    node: WorkflowNode;
+    config: LoopNodeConfig;
+    context: WorkflowContext;
+    nodeStates: Record<string, NodeState>;
+    runtime: NodeStrategyRuntime;
+}
+export declare function executeLoopNodeStrategy(input: ExecuteLoopNodeStrategyInput): Promise<NodeExecutionResult>;
+export {};
+//# sourceMappingURL=loop-node-strategy.d.ts.map

package/esm/src/workflow/executor/dag/loop-node-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop-node-strategy.d.ts","sourceRoot":"","sources":["../../../../../src/src/workflow/executor/dag/loop-node-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,cAAc,EACd,SAAS,EACT,eAAe,EACf,YAAY,EACb,MAAM,gBAAgB,CAAC;AAExB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAEpE,UAAU,4BAA4B;IACpC,IAAI,EAAE,YAAY,CAAC;IACnB,MAAM,EAAE,cAAc,CAAC;IACvB,OAAO,EAAE,eAAe,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACtC,OAAO,EAAE,mBAAmB,CAAC;CAC9B;AAQD,wBAAsB,uBAAuB,CAC3C,KAAK,EAAE,4BAA4B,GAClC,OAAO,CAAC,mBAAmB,CAAC,CAwJ9B"}

package/esm/src/workflow/executor/dag/loop-node-strategy.js

@@ -0,0 +1,134 @@
+import { parseDuration } from "../../types.js";
+import { sleep } from "./utils.js";
+export async function executeLoopNodeStrategy(input) {
+    const { node, config, context, nodeStates, runtime } = input;
+    const startTime = Date.now();
+    const previousResults = [];
+    let iteration = 0;
+    let exitReason = "condition";
+    let lastError;
+    const existingLoopState = context[`${node.id}_loop_state`];
+    // Child node states for the in-flight (resumed) iteration, so its already
+    // completed steps are not re-executed on resume (H9).
+    let resumeIterationNodeStates;
+    let resumeIteration;
+    if (existingLoopState) {
+        iteration = existingLoopState.iteration;
+        previousResults.push(...existingLoopState.previousResults);
+        resumeIterationNodeStates = existingLoopState.iterationNodeStates;
+        resumeIteration = existingLoopState.iteration;
+    }
+    while (iteration < config.maxIterations) {
+        const loopContext = {
+            iteration,
+            totalIterations: iteration,
+            previousResults: [...previousResults],
+            isFirstIteration: iteration === 0,
+            isLastAllowedIteration: iteration === config.maxIterations - 1,
+        };
+        if (!(await config.while(context, loopContext))) {
+            exitReason = "condition";
+            break;
+        }
+        const steps = typeof config.steps === "function"
+            ? config.steps(context, loopContext)
+            : config.steps;
+        // On resume, rehydrate the in-flight iteration's child node states so its
+        // already-completed steps are skipped instead of re-executed (H9).
+        const iterationNodeStates = resumeIteration === iteration && resumeIterationNodeStates
+            ? { ...resumeIterationNodeStates }
+            : {};
+        // Only rehydrate once; subsequent iterations start fresh.
+        resumeIterationNodeStates = undefined;
+        const result = await runtime.executeChildGraph(steps, {
+            id: `${node.id}_iter_${iteration}`,
+            workflowId: "",
+            status: "running",
+            input: context.input,
+            nodeStates: iterationNodeStates,
+            currentNodes: [],
+            context: { ...context, _loop: loopContext },
+            checkpoints: [],
+            pendingApprovals: [],
+            createdAt: new Date(),
+        });
+        if (result.waiting) {
+            Object.assign(nodeStates, result.nodeStates);
+            const state = {
+                nodeId: node.id,
+                status: "running",
+                output: { iteration, waiting: true, previousResults },
+                attempt: 1,
+                startedAt: new Date(startTime),
+            };
+            return {
+                state,
+                contextUpdates: {
+                    ...result.context,
+                    [`${node.id}_loop_state`]: {
+                        iteration,
+                        previousResults,
+                        // Persist the in-flight iteration's child states so completed
+                        // steps are not re-executed when this iteration resumes (H9).
+                        iterationNodeStates: result.nodeStates,
+                    },
+                },
+                waiting: true,
+            };
+        }
+        if (result.error) {
+            lastError = result.error;
+            exitReason = "error";
+            break;
+        }
+        previousResults.push(result.context);
+        Object.assign(context, result.context);
+        Object.assign(nodeStates, result.nodeStates);
+        if (config.delay && iteration < config.maxIterations - 1) {
+            const delayMs = typeof config.delay === "number" ? config.delay : parseDuration(config.delay);
+            await sleep(delayMs);
+        }
+        iteration++;
+    }
+    if (iteration >= config.maxIterations && exitReason !== "condition") {
+        exitReason = "maxIterations";
+    }
+    const finalLoopContext = {
+        iteration,
+        totalIterations: iteration,
+        previousResults,
+        isFirstIteration: false,
+        isLastAllowedIteration: true,
+    };
+    let completionUpdates = {};
+    if (exitReason === "maxIterations" && config.onMaxIterations) {
+        completionUpdates = await config.onMaxIterations(context, finalLoopContext);
+    }
+    else if (exitReason === "condition" && config.onComplete) {
+        completionUpdates = await config.onComplete(context, finalLoopContext);
+    }
+    const output = {
+        exitReason,
+        iterations: iteration,
+        previousResults,
+        ...completionUpdates,
+    };
+    const state = {
+        nodeId: node.id,
+        status: exitReason === "error" ? "failed" : "completed",
+        output,
+        error: lastError,
+        attempt: 1,
+        startedAt: new Date(startTime),
+        completedAt: new Date(),
+    };
+    runtime.onNodeComplete?.(node.id, state);
+    return {
+        state,
+        contextUpdates: {
+            [node.id]: output,
+            ...completionUpdates,
+        },
+        waiting: false,
+    };
+}

package/esm/src/workflow/executor/dag/map-node-strategy.d.ts

@@ -0,0 +1,13 @@
+import type { MapNodeConfig, NodeState, WorkflowContext, WorkflowNode } from "../../types.js";
+import type { NodeExecutionResult } from "./types.js";
+import type { NodeStrategyRuntime } from "./node-strategy-types.js";
+interface ExecuteMapNodeStrategyInput {
+    node: WorkflowNode;
+    config: MapNodeConfig;
+    context: WorkflowContext;
+    nodeStates: Record<string, NodeState>;
+    runtime: NodeStrategyRuntime;
+}
+export declare function executeMapNodeStrategy(input: ExecuteMapNodeStrategyInput): Promise<NodeExecutionResult>;
+export {};
+//# sourceMappingURL=map-node-strategy.d.ts.map

package/esm/src/workflow/executor/dag/map-node-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-node-strategy.d.ts","sourceRoot":"","sources":["../../../../../src/src/workflow/executor/dag/map-node-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,SAAS,EACT,eAAe,EAEf,YAAY,EAEb,MAAM,gBAAgB,CAAC;AAExB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAEpE,UAAU,2BAA2B;IACnC,IAAI,EAAE,YAAY,CAAC;IACnB,MAAM,EAAE,aAAa,CAAC;IACtB,OAAO,EAAE,eAAe,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACtC,OAAO,EAAE,mBAAmB,CAAC;CAC9B;AAqCD,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,2BAA2B,GACjC,OAAO,CAAC,mBAAmB,CAAC,CAgE9B"}

package/esm/src/workflow/executor/dag/map-node-strategy.js

@@ -0,0 +1,78 @@
+import { INVALID_ARGUMENT } from "../../../errors/index.js";
+import { deriveNodeStatus } from "./utils.js";
+function isWorkflowDefinition(processor) {
+    return typeof processor === "object" && processor !== null && "steps" in processor;
+}
+function createMapChildNodes(node, config, items) {
+    return items.map((item, i) => {
+        const childId = `${node.id}_${i}`;
+        if (isWorkflowDefinition(config.processor)) {
+            return {
+                id: childId,
+                config: {
+                    type: "subWorkflow",
+                    workflow: config.processor,
+                    input: item,
+                    retry: config.retry,
+                    checkpoint: false,
+                },
+            };
+        }
+        const processorConfig = { ...config.processor.config };
+        if (processorConfig.type === "step") {
+            processorConfig.input = item;
+        }
+        return { id: childId, config: processorConfig };
+    });
+}
+export async function executeMapNodeStrategy(input) {
+    const { node, config, context, nodeStates, runtime } = input;
+    const startTime = Date.now();
+    const items = typeof config.items === "function" ? await config.items(context) : config.items;
+    if (!Array.isArray(items)) {
+        throw INVALID_ARGUMENT.create({ detail: `Map node "${node.id}" items must be an array` });
+    }
+    if (items.length === 0) {
+        const state = {
+            nodeId: node.id,
+            status: "completed",
+            output: [],
+            attempt: 1,
+            startedAt: new Date(startTime),
+            completedAt: new Date(),
+        };
+        return { state, contextUpdates: { [node.id]: [] }, waiting: false };
+    }
+    const childNodes = createMapChildNodes(node, config, items);
+    const result = await runtime.executeChildGraph(childNodes, {
+        id: `${node.id}_map`,
+        workflowId: "",
+        status: "running",
+        input: context.input,
+        // Carry already-accumulated child states so completed children are
+        // skipped on resume instead of re-executing (H8).
+        nodeStates,
+        currentNodes: [],
+        context: { ...context },
+        checkpoints: [],
+        pendingApprovals: [],
+        createdAt: new Date(),
+    }, config.concurrency ? { maxConcurrency: config.concurrency } : undefined);
+    Object.assign(nodeStates, result.nodeStates);
+    const outputs = childNodes.map((child) => result.nodeStates[child.id]?.output);
+    const state = {
+        nodeId: node.id,
+        status: deriveNodeStatus(result.completed, result.waiting),
+        output: outputs,
+        error: result.error,
+        attempt: 1,
+        startedAt: new Date(startTime),
+        completedAt: result.completed ? new Date() : undefined,
+    };
+    runtime.onNodeComplete?.(node.id, state);
+    return {
+        state,
+        contextUpdates: result.completed ? { [node.id]: outputs } : {},
+        waiting: result.waiting,
+    };
+}

package/esm/src/workflow/executor/dag/node-strategy-types.d.ts

@@ -0,0 +1,11 @@
+import type { NodeState, WorkflowNode, WorkflowRun } from "../../types.js";
+import type { DAGExecutionResult } from "./types.js";
+export interface ChildGraphExecutionOptions {
+    maxConcurrency?: number;
+}
+export type ExecuteChildGraph = (nodes: WorkflowNode[], run: WorkflowRun, options?: ChildGraphExecutionOptions) => Promise<DAGExecutionResult>;
+export interface NodeStrategyRuntime {
+    executeChildGraph: ExecuteChildGraph;
+    onNodeComplete?: (nodeId: string, state: NodeState) => void;
+}
+//# sourceMappingURL=node-strategy-types.d.ts.map

package/esm/src/workflow/executor/dag/node-strategy-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-strategy-types.d.ts","sourceRoot":"","sources":["../../../../../src/src/workflow/executor/dag/node-strategy-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC3E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAErD,MAAM,WAAW,0BAA0B;IACzC,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,MAAM,iBAAiB,GAAG,CAC9B,KAAK,EAAE,YAAY,EAAE,EACrB,GAAG,EAAE,WAAW,EAChB,OAAO,CAAC,EAAE,0BAA0B,KACjC,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAEjC,MAAM,WAAW,mBAAmB;IAClC,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;CAC7D"}

package/esm/src/workflow/executor/dag/node-strategy-types.js

@@ -0,0 +1 @@
+export {};

package/esm/src/workflow/worker/run-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run-manager.d.ts","sourceRoot":"","sources":["../../../../src/src/workflow/worker/run-manager.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAoC,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG9F,OAAO,KAAK,EAAsB,kBAAkB,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAehG,YAAY,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAE9F;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,uCAAuC;IACvC,OAAO,EAAE,eAAe,CAAC;IAEzB,6DAA6D;IAC7D,QAAQ,EAAE,WAAW,CAAC;IAEtB,0DAA0D;IAC1D,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE7B,wDAAwD;IACxD,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,wCAAwC;IACxC,uBAAuB,CAAC,EAAE,MAAM,CAAC;IAEjC,4DAA4D;IAC5D,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B,6EAA6E;IAC7E,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,CAAC;AAExE;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,aAAa,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,gBAAgB,EAAE,MAAM,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,IAAI,CAAC;IAClB,WAAW,CAAC,EAAE,IAAI,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,UAAU,gBAAgB;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,kBAAkB,CAAC;IAC3B,SAAS,EAAE,IAAI,CAAC;CACjB;AAOD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,MAAM,CAAyB;IACvC,OAAO,CAAC,WAAW,CAAC,CAAwC;IAC5D,OAAO,CAAC,gBAAgB,CAAuC;IAC/D,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,SAAS,CAAS;gBAEd,MAAM,EAAE,wBAAwB;IAuB5C;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAsB5B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IA+B3B;;OAEG;IACH,QAAQ,IAAI,YAAY;IAIxB;;OAEG;IACH,mBAAmB,IAAI,gBAAgB,EAAE;IAIzC;;OAEG;IACH,YAAY,IAAI,MAAM;IAItB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAWxB;;OAEG;YACW,IAAI;IAyGlB;;OAEG;YACW,wBAAwB;IAuCtC;;OAEG;YACW,0BAA0B;IAoDxC;;OAEG;IACH,OAAO,CAAC,WAAW;CAIpB;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,wBAAwB,GAC/B,kBAAkB,CAEpB"}
+{"version":3,"file":"run-manager.d.ts","sourceRoot":"","sources":["../../../../src/src/workflow/worker/run-manager.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAoC,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG9F,OAAO,KAAK,EAAsB,kBAAkB,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAehG,YAAY,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAE9F;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,uCAAuC;IACvC,OAAO,EAAE,eAAe,CAAC;IAEzB,6DAA6D;IAC7D,QAAQ,EAAE,WAAW,CAAC;IAEtB,0DAA0D;IAC1D,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE7B,wDAAwD;IACxD,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,wCAAwC;IACxC,uBAAuB,CAAC,EAAE,MAAM,CAAC;IAEjC,4DAA4D;IAC5D,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B,6EAA6E;IAC7E,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,CAAC;AAExE;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,aAAa,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,gBAAgB,EAAE,MAAM,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,IAAI,CAAC;IAClB,WAAW,CAAC,EAAE,IAAI,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,UAAU,gBAAgB;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,kBAAkB,CAAC;IAC3B,SAAS,EAAE,IAAI,CAAC;CACjB;AAOD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,MAAM,CAAyB;IACvC,OAAO,CAAC,WAAW,CAAC,CAAwC;IAC5D,OAAO,CAAC,gBAAgB,CAAuC;IAC/D,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,SAAS,CAAS;gBAEd,MAAM,EAAE,wBAAwB;IAuB5C;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAsB5B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IA+B3B;;OAEG;IACH,QAAQ,IAAI,YAAY;IAIxB;;OAEG;IACH,mBAAmB,IAAI,gBAAgB,EAAE;IAIzC;;OAEG;IACH,YAAY,IAAI,MAAM;IAItB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAWxB;;OAEG;YACW,IAAI;IAyGlB;;OAEG;YACW,wBAAwB;IAuCtC;;OAEG;YACW,0BAA0B;IAqDxC;;OAEG;IACH,OAAO,CAAC,WAAW;CAIpB;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,wBAAwB,GAC/B,kBAAkB,CAEpB"}

package/esm/src/workflow/worker/run-manager.js

@@ -303,6 +303,7 @@ export class WorkflowRunManager {
         }
         catch (error) {
             logger.error(`Failed to create run execution for ${run.id}:`, error);
+            this.stats.executionsFailed++;
             // Mark workflow as failed
             await this.config.backend.updateRun(run.id, {
                 status: "failed",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "veryfront",
-  "version": "0.1.699",
+  "version": "0.1.701",
   "description": "The simplest way to build AI-powered apps",
   "keywords": [
     "react",