@ldsg/workflow 0.3.33 → 0.3.35

package/dist/__tests__/unit/multi-predecessor.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=multi-predecessor.test.d.ts.map

package/dist/__tests__/unit/multi-predecessor.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multi-predecessor.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/unit/multi-predecessor.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/unit/multi-predecessor.test.js

@@ -0,0 +1,450 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resource_1 = require("../../resource");
+describe("workflow BFS level scheduling with multiple predecessors", () => {
+    test("conditional branch with merge: only activated branch reaches merge (OR-join)", async () => {
+        const executionOrder = [];
+        let mergeInput = null;
+        const startNode = {
+            id: "start",
+            propertiesSchema: {
+                type: "object",
+                properties: {
+                    input: { type: "object", properties: {} },
+                    output: { type: "object", properties: {} },
+                },
+            },
+            execute: async () => {
+                executionOrder.push("start");
+                return { variables: {}, portId: "true" };
+            },
+        };
+        const branchTrue = {
+            id: "branchTrue",
+            propertiesSchema: {
+                type: "object",
+                properties: {
+                    input: { type: "object", properties: {} },
+                    output: {
+                        type: "object",
+                        properties: { value: { type: "string", const: "fromTrue" } },
+                    },
+                },
+            },
+            execute: async () => {
+                executionOrder.push("branchTrue");
+                return { variables: { value: "fromTrue" } };
+            },
+        };
+        const branchFalse = {
+            id: "branchFalse",
+            propertiesSchema: {
+                type: "object",
+                properties: {
+                    input: { type: "object", properties: {} },
+                    output: {
+                        type: "object",
+                        properties: { value: { type: "string", const: "fromFalse" } },
+                    },
+                },
+            },
+            execute: async () => {
+                executionOrder.push("branchFalse");
+                return { variables: { value: "fromFalse" } };
+            },
+        };
+        const mergeNode = {
+            id: "merge",
+            propertiesSchema: {
+                type: "object",
+                properties: {
+                    input: {
+                        type: "object",
+                        properties: {
+                            trueValue: {
+                                type: "string",
+                                "x-expression": '$."branchTrue".value',
+                            },
+                        },
+                    },
+                    output: { type: "object", properties: { result: { type: "string", const: "" } } },
+                },
+            },
+            execute: async (params) => {
+                executionOrder.push("merge");
+                mergeInput = params.variables;
+                return { variables: { result: params.variables.trueValue || "none" } };
+            },
+        };
+        const endNode = {
+            id: "end",
+            propertiesSchema: {
+                type: "object",
+                properties: {
+                    input: { type: "object", properties: {} },
+                    output: { type: "object", properties: {} },
+                },
+            },
+            execute: async (params) => {
+                executionOrder.push("end");
+                return { variables: params.variables };
+            },
+        };
+        const workflowData = {
+            nodes: [startNode, branchTrue, branchFalse, mergeNode, endNode],
+            edges: [
+                {
+                    sourceWorkflowNodeResourceId: "start",
+                    sourceWorkflowNodePortId: "true",
+                    targetWorkflowNodeResourceId: "branchTrue",
+                },
+                {
+                    sourceWorkflowNodeResourceId: "start",
+                    sourceWorkflowNodePortId: "false",
+                    targetWorkflowNodeResourceId: "branchFalse",
+                },
+                { sourceWorkflowNodeResourceId: "branchTrue", targetWorkflowNodeResourceId: "merge" },
+                { sourceWorkflowNodeResourceId: "branchFalse", targetWorkflowNodeResourceId: "merge" },
+                { sourceWorkflowNodeResourceId: "merge", targetWorkflowNodeResourceId: "end" },
+            ],
+        };
+        class TestWorkflowResource extends resource_1.WorkflowResource {
+            constructor() {
+                super(...arguments);
+                this.getWorkflowData = () => ({ workflowData });
+            }
+        }
+        const workflow = new TestWorkflowResource({
+            id: "test",
+            kind: "workflow",
+            parentId: "root",
+            settings: {
+                title: "",
+                description: "",
+                startWorkflowNodeResourceId: "start",
+                endWorkflowNodeResourceId: "end",
+            },
+        });
+        await workflow.execute({
+            context: {},
+            variables: {},
+        });
+        expect(executionOrder).toContain("start");
+        expect(executionOrder).toContain("branchTrue");
+        expect(executionOrder).not.toContain("branchFalse");
+        expect(executionOrder).toContain("merge");
+        expect(executionOrder).toContain("end");
+        const mergeIdx = executionOrder.indexOf("merge");
+        expect(executionOrder.indexOf("branchTrue")).toBeLessThan(mergeIdx);
+        expect(executionOrder.indexOf("end")).toBeGreaterThan(mergeIdx);
+        expect(mergeInput.trueValue).toBe("fromTrue");
+    });
+    test("diamond with extra direct edge: merge waits for longest path", async () => {
+        const executionOrder = [];
+        let mergeInput = null;
+        const makeNode = (id, value) => ({
+            id,
+            propertiesSchema: {
+                type: "object",
+                properties: {
+                    input: { type: "object", properties: {} },
+                    output: {
+                        type: "object",
+                        properties: { value: { type: "string", const: value } },
+                    },
+                },
+            },
+            execute: async () => {
+                executionOrder.push(id);
+                return { variables: { value } };
+            },
+        });
+        const start = makeNode("start", "S");
+        const middle = makeNode("middle", "M");
+        const mergeNode = {
+            id: "merge",
+            propertiesSchema: {
+                type: "object",
+                properties: {
+                    input: {
+                        type: "object",
+                        properties: {
+                            startVal: { type: "string", "x-expression": '$."start".value' },
+                            middleVal: { type: "string", "x-expression": '$."middle".value' },
+                        },
+                    },
+                    output: { type: "object", properties: { result: { type: "string", const: "" } } },
+                },
+            },
+            execute: async (params) => {
+                executionOrder.push("merge");
+                mergeInput = params.variables;
+                return {
+                    variables: { result: `${params.variables.startVal}-${params.variables.middleVal}` },
+                };
+            },
+        };
+        const end = makeNode("end", "E");
+        const workflowData = {
+            nodes: [start, middle, mergeNode, end],
+            edges: [
+                { sourceWorkflowNodeResourceId: "start", targetWorkflowNodeResourceId: "middle" },
+                { sourceWorkflowNodeResourceId: "start", targetWorkflowNodeResourceId: "merge" },
+                { sourceWorkflowNodeResourceId: "middle", targetWorkflowNodeResourceId: "merge" },
+                { sourceWorkflowNodeResourceId: "merge", targetWorkflowNodeResourceId: "end" },
+            ],
+        };
+        class TestWorkflowResource extends resource_1.WorkflowResource {
+            constructor() {
+                super(...arguments);
+                this.getWorkflowData = () => ({ workflowData });
+            }
+        }
+        const workflow = new TestWorkflowResource({
+            id: "test",
+            kind: "workflow",
+            parentId: "root",
+            settings: {
+                title: "",
+                description: "",
+                startWorkflowNodeResourceId: "start",
+                endWorkflowNodeResourceId: "end",
+            },
+        });
+        await workflow.execute({
+            context: {},
+            variables: {},
+        });
+        const startIdx = executionOrder.indexOf("start");
+        const middleIdx = executionOrder.indexOf("middle");
+        const mergeIdx = executionOrder.indexOf("merge");
+        const endIdx = executionOrder.indexOf("end");
+        expect(startIdx).toBe(0);
+        expect(middleIdx).toBeGreaterThan(startIdx);
+        expect(mergeIdx).toBeGreaterThan(middleIdx);
+        expect(endIdx).toBeGreaterThan(mergeIdx);
+        expect(mergeInput.startVal).toBe("S");
+        expect(mergeInput.middleVal).toBe("M");
+    });
+    test("merge node with two parallel predecessors runs after both complete (diamond pattern)", async () => {
+        const executionOrder = [];
+        let mergeInput = null;
+        const makeNode = (id, outputValue) => ({
+            id,
+            propertiesSchema: {
+                type: "object",
+                properties: {
+                    input: { type: "object", properties: {} },
+                    output: {
+                        type: "object",
+                        properties: {
+                            value: { type: "string", const: outputValue },
+                        },
+                    },
+                },
+            },
+            execute: async () => {
+                executionOrder.push(id);
+                return { variables: { value: outputValue } };
+            },
+        });
+        const start = makeNode("start", "start");
+        const branchA = makeNode("branchA", "A");
+        const branchB = makeNode("branchB", "B");
+        const mergeNode = {
+            id: "merge",
+            propertiesSchema: {
+                type: "object",
+                properties: {
+                    input: {
+                        type: "object",
+                        properties: {
+                            aValue: { type: "string", "x-expression": '$."branchA".value' },
+                            bValue: { type: "string", "x-expression": '$."branchB".value' },
+                        },
+                    },
+                    output: {
+                        type: "object",
+                        properties: {
+                            result: { type: "string", const: "" },
+                        },
+                    },
+                },
+            },
+            execute: async (params) => {
+                executionOrder.push("merge");
+                mergeInput = params.variables;
+                return { variables: { result: `${params.variables.aValue}+${params.variables.bValue}` } };
+            },
+        };
+        const endNode = {
+            id: "end",
+            propertiesSchema: {
+                type: "object",
+                properties: {
+                    input: { type: "object", properties: {} },
+                    output: { type: "object", properties: {} },
+                },
+            },
+            execute: async (params) => {
+                executionOrder.push("end");
+                return { variables: params.variables };
+            },
+        };
+        const workflowData = {
+            nodes: [start, branchA, branchB, mergeNode, endNode],
+            edges: [
+                { sourceWorkflowNodeResourceId: "start", targetWorkflowNodeResourceId: "branchA" },
+                { sourceWorkflowNodeResourceId: "start", targetWorkflowNodeResourceId: "branchB" },
+                { sourceWorkflowNodeResourceId: "branchA", targetWorkflowNodeResourceId: "merge" },
+                { sourceWorkflowNodeResourceId: "branchB", targetWorkflowNodeResourceId: "merge" },
+                { sourceWorkflowNodeResourceId: "merge", targetWorkflowNodeResourceId: "end" },
+            ],
+        };
+        class TestWorkflowResource extends resource_1.WorkflowResource {
+            constructor() {
+                super(...arguments);
+                this.getWorkflowData = () => ({ workflowData });
+            }
+        }
+        const workflow = new TestWorkflowResource({
+            id: "test",
+            kind: "workflow",
+            parentId: "root",
+            settings: {
+                title: "",
+                description: "",
+                startWorkflowNodeResourceId: "start",
+                endWorkflowNodeResourceId: "end",
+            },
+        });
+        await workflow.execute({
+            context: {},
+            variables: {},
+        });
+        const startIdx = executionOrder.indexOf("start");
+        const aIdx = executionOrder.indexOf("branchA");
+        const bIdx = executionOrder.indexOf("branchB");
+        const mergeIdx = executionOrder.indexOf("merge");
+        const endIdx = executionOrder.indexOf("end");
+        expect(startIdx).toBe(0);
+        expect(aIdx).toBeGreaterThan(startIdx);
+        expect(bIdx).toBeGreaterThan(startIdx);
+        expect(mergeIdx).toBeGreaterThan(aIdx);
+        expect(mergeIdx).toBeGreaterThan(bIdx);
+        expect(endIdx).toBeGreaterThan(mergeIdx);
+        expect(mergeInput.aValue).toBe("A");
+        expect(mergeInput.bValue).toBe("B");
+    });
+    test("merge node with three parallel predecessors runs after all three complete", async () => {
+        const executionOrder = [];
+        let mergeInput = null;
+        const makeNode = (id, outputValue) => ({
+            id,
+            propertiesSchema: {
+                type: "object",
+                properties: {
+                    input: { type: "object", properties: {} },
+                    output: {
+                        type: "object",
+                        properties: {
+                            value: { type: "number", const: outputValue },
+                        },
+                    },
+                },
+            },
+            execute: async () => {
+                executionOrder.push(id);
+                return { variables: { value: outputValue } };
+            },
+        });
+        const start = makeNode("start", 0);
+        const branchA = makeNode("branchA", 10);
+        const branchB = makeNode("branchB", 20);
+        const branchC = makeNode("branchC", 30);
+        const mergeNode = {
+            id: "merge",
+            propertiesSchema: {
+                type: "object",
+                properties: {
+                    input: {
+                        type: "object",
+                        properties: {
+                            a: { type: "number", "x-expression": '$."branchA".value' },
+                            b: { type: "number", "x-expression": '$."branchB".value' },
+                            c: { type: "number", "x-expression": '$."branchC".value' },
+                        },
+                    },
+                    output: {
+                        type: "object",
+                        properties: {
+                            total: { type: "number", const: 0 },
+                        },
+                    },
+                },
+            },
+            execute: async (params) => {
+                executionOrder.push("merge");
+                mergeInput = params.variables;
+                return {
+                    variables: { total: params.variables.a + params.variables.b + params.variables.c },
+                };
+            },
+        };
+        const endNode = {
+            id: "end",
+            propertiesSchema: {
+                type: "object",
+                properties: {
+                    input: { type: "object", properties: {} },
+                    output: { type: "object", properties: {} },
+                },
+            },
+            execute: async (params) => {
+                executionOrder.push("end");
+                return { variables: params.variables };
+            },
+        };
+        const workflowData = {
+            nodes: [start, branchA, branchB, branchC, mergeNode, endNode],
+            edges: [
+                { sourceWorkflowNodeResourceId: "start", targetWorkflowNodeResourceId: "branchA" },
+                { sourceWorkflowNodeResourceId: "start", targetWorkflowNodeResourceId: "branchB" },
+                { sourceWorkflowNodeResourceId: "start", targetWorkflowNodeResourceId: "branchC" },
+                { sourceWorkflowNodeResourceId: "branchA", targetWorkflowNodeResourceId: "merge" },
+                { sourceWorkflowNodeResourceId: "branchB", targetWorkflowNodeResourceId: "merge" },
+                { sourceWorkflowNodeResourceId: "branchC", targetWorkflowNodeResourceId: "merge" },
+                { sourceWorkflowNodeResourceId: "merge", targetWorkflowNodeResourceId: "end" },
+            ],
+        };
+        class TestWorkflowResource extends resource_1.WorkflowResource {
+            constructor() {
+                super(...arguments);
+                this.getWorkflowData = () => ({ workflowData });
+            }
+        }
+        const workflow = new TestWorkflowResource({
+            id: "test",
+            kind: "workflow",
+            parentId: "root",
+            settings: {
+                title: "",
+                description: "",
+                startWorkflowNodeResourceId: "start",
+                endWorkflowNodeResourceId: "end",
+            },
+        });
+        await workflow.execute({
+            context: {},
+            variables: {},
+        });
+        const mergeIdx = executionOrder.indexOf("merge");
+        expect(executionOrder.indexOf("branchA")).toBeLessThan(mergeIdx);
+        expect(executionOrder.indexOf("branchB")).toBeLessThan(mergeIdx);
+        expect(executionOrder.indexOf("branchC")).toBeLessThan(mergeIdx);
+        expect(executionOrder.indexOf("end")).toBeGreaterThan(mergeIdx);
+        expect(mergeInput.a).toBe(10);
+        expect(mergeInput.b).toBe(20);
+        expect(mergeInput.c).toBe(30);
+    });
+});

package/dist/utils/execute-workflow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"execute-workflow.d.ts","sourceRoot":"","sources":["../../src/utils/execute-workflow.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,YAAY,EACZ,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EAElB,MAAM,UAAU,CAAC;AAqBlB,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,GAAG,CAAC;IACb,yBAAyB,EAAE,MAAM,CAAC;IAClC,KAAK,EAAE,gBAAgB,EAAE,CAAC;IAC1B,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;IAC7B,uBAAuB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IAC5D,2BAA2B,EAAE,MAAM,CAAC;IACpC,SAAS,EAAE,GAAG,CAAC;IACf,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,CAAC,EAAE,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,GAAG,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAyND;;GAEG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CA6HhG"}
+{"version":3,"file":"execute-workflow.d.ts","sourceRoot":"","sources":["../../src/utils/execute-workflow.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,YAAY,EACZ,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EAElB,MAAM,UAAU,CAAC;AAqBlB,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,GAAG,CAAC;IACb,yBAAyB,EAAE,MAAM,CAAC;IAClC,KAAK,EAAE,gBAAgB,EAAE,CAAC;IAC1B,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;IAC7B,uBAAuB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IAC5D,2BAA2B,EAAE,MAAM,CAAC;IACpC,SAAS,EAAE,GAAG,CAAC;IACf,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,CAAC,EAAE,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,GAAG,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAgSD;;GAEG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAuJhG"}

package/dist/utils/execute-workflow.js

@@ -58,6 +58,8 @@ async function executeNode(node, context, workflowVariablesMap, isFirstLevel, wo
     }
     let consoleDirInfo = {
         nodeId: id,
+        inputSchema: workflowNodePropertiesInputSchema,
+        inputExpressionEvaluateInput: workflowNodeInputExpressionEvaluateInput,
         inputVariables: workflowNodeInputVariables,
         status: "processing",
     };
@@ -82,6 +84,8 @@ async function executeNode(node, context, workflowVariablesMap, isFirstLevel, wo
             ...consoleDirInfo,
             status: "success",
             portId,
+            outputSchema: workflowNodePropertiesOutputSchema,
+            outputExpressionEvaluateInput: workflowNodeOutputExpressionEvaluateInput,
             outputVariables: workflowNodeOutputVariables,
         };
         const res = {
@@ -101,80 +105,114 @@ async function executeNode(node, context, workflowVariablesMap, isFirstLevel, wo
     }
     finally {
         if (process.env.DEBUG) {
-            console.dir(consoleDirInfo);
+            console.dir(consoleDirInfo, {
+                depth: 5,
+            });
         }
     }
 }
-/**
- * 查找下一个需要执行的节点集合
- */
-function findNextNodeIds(levelResults, edges, visitedNodes, completedNodePredecessors, activatedEdges, endNodeId) {
+function findNextNodeIds(params) {
+    var _a;
+    const { levelResults, deadNodes, visitedNodes, completedNodePredecessors, pendingPredecessorCount, activatedEdges, requiredPredecessorCount, outgoingEdgesMap, incomingEdgesMap, endNodeId, } = params;
     const nextNodeIds = [];
     const nextLevelNodesSet = new Set();
     let workflowOutputVariables;
+    const newlyAffectedTargets = new Set();
     levelResults.forEach((result) => {
+        var _a;
         if (!result) {
             return;
         }
         const { nodeId, variables, portId } = result;
-        // 标记节点为已访问
         visitedNodes.add(nodeId);
-        // 保存变量
-        // workflowVariablesMap.set(nodeId, variables);
-        // 如果是结束节点，保存输出变量
         if (nodeId === endNodeId) {
             workflowOutputVariables = variables;
         }
-        // 查找从当前节点出发的连线
-        const outgoingEdges = edges.filter((edge) => edge.sourceWorkflowNodeResourceId === nodeId);
-        // 根据 portId 过滤连线
+        const allOutgoing = (_a = outgoingEdgesMap.get(nodeId)) !== null && _a !== void 0 ? _a : [];
+        allOutgoing.forEach((edge) => {
+            var _a;
+            const targetNodeId = edge.targetWorkflowNodeResourceId;
+            if (visitedNodes.has(targetNodeId) || deadNodes.has(targetNodeId)) {
+                return;
+            }
+            const pending = ((_a = pendingPredecessorCount.get(targetNodeId)) !== null && _a !== void 0 ? _a : 0) - 1;
+            pendingPredecessorCount.set(targetNodeId, pending);
+            newlyAffectedTargets.add(targetNodeId);
+        });
         const matchedEdges = portId
-            ? outgoingEdges.filter((edge) => edge.sourceWorkflowNodePortId === portId)
-            : outgoingEdges.filter((edge) => !edge.sourceWorkflowNodePortId);
-        // 处理匹配的连线的目标节点
+            ? allOutgoing.filter((edge) => edge.sourceWorkflowNodePortId === portId)
+            : allOutgoing.filter((edge) => !edge.sourceWorkflowNodePortId);
         matchedEdges.forEach((edge) => {
+            var _a;
             const targetNodeId = edge.targetWorkflowNodeResourceId;
-            // 如果目标节点已访问，跳过
-            if (visitedNodes.has(targetNodeId)) {
+            if (visitedNodes.has(targetNodeId) || deadNodes.has(targetNodeId)) {
                 return;
             }
-            // 记录该目标节点已完成的前驱节点
             if (!completedNodePredecessors.has(targetNodeId)) {
                 completedNodePredecessors.set(targetNodeId, new Set());
             }
             completedNodePredecessors.get(targetNodeId).add(nodeId);
-            // 记录激活的边（源节点 -> 目标节点）
             if (!activatedEdges.has(targetNodeId)) {
                 activatedEdges.set(targetNodeId, new Set());
             }
-            activatedEdges.get(targetNodeId).add(nodeId);
-            // 查找目标节点的所有可能的入边（用于计算需要等待多少个前驱节点）
-            const incomingEdges = edges.filter((edge) => edge.targetWorkflowNodeResourceId === targetNodeId);
-            // 计算实际需要等待的前驱节点数量
-            // 对于每个前驱节点，检查是否有至少一条激活的入边
-            const allPredecessorIds = new Set(incomingEdges.map((edge) => edge.sourceWorkflowNodeResourceId));
-            let requiredPredecessorCount = 0;
-            allPredecessorIds.forEach((predecessorId) => {
-                // 检查该前驱节点是否有激活的入边指向当前节点
-                const hasActivatedEdge = incomingEdges.some((e) => {
-                    var _a;
-                    return e.sourceWorkflowNodeResourceId === predecessorId &&
-                        ((_a = activatedEdges.get(targetNodeId)) === null || _a === void 0 ? void 0 : _a.has(predecessorId));
-                });
-                if (hasActivatedEdge) {
-                    requiredPredecessorCount++;
-                }
-            });
-            // 只有当所有需要等待的前驱节点都完成时，才加入下一轮执行
-            const completedPredecessors = completedNodePredecessors.get(targetNodeId);
-            if (completedPredecessors.size === requiredPredecessorCount) {
-                // 避免重复添加同一个节点到下一层
-                if (!nextLevelNodesSet.has(targetNodeId)) {
-                    nextLevelNodesSet.add(targetNodeId);
-                    nextNodeIds.push(targetNodeId);
+            const targetActivatedEdges = activatedEdges.get(targetNodeId);
+            if (!targetActivatedEdges.has(nodeId)) {
+                targetActivatedEdges.add(nodeId);
+                requiredPredecessorCount.set(targetNodeId, ((_a = requiredPredecessorCount.get(targetNodeId)) !== null && _a !== void 0 ? _a : 0) + 1);
+            }
+        });
+    });
+    const propagationQueue = [];
+    newlyAffectedTargets.forEach((targetId) => {
+        var _a;
+        const pending = (_a = pendingPredecessorCount.get(targetId)) !== null && _a !== void 0 ? _a : 0;
+        if (pending !== 0) {
+            return;
+        }
+        const targetActivated = activatedEdges.get(targetId);
+        if (targetActivated && targetActivated.size > 0) {
+            return;
+        }
+        deadNodes.add(targetId);
+        propagationQueue.push(targetId);
+    });
+    while (propagationQueue.length > 0) {
+        const deadNodeId = propagationQueue.shift();
+        const outgoing = (_a = outgoingEdgesMap.get(deadNodeId)) !== null && _a !== void 0 ? _a : [];
+        outgoing.forEach((edge) => {
+            var _a;
+            const targetId = edge.targetWorkflowNodeResourceId;
+            if (visitedNodes.has(targetId) || deadNodes.has(targetId)) {
+                return;
+            }
+            const pending = ((_a = pendingPredecessorCount.get(targetId)) !== null && _a !== void 0 ? _a : 0) - 1;
+            pendingPredecessorCount.set(targetId, pending);
+            if (pending === 0) {
+                const targetActivated = activatedEdges.get(targetId);
+                if (!targetActivated || targetActivated.size === 0) {
+                    deadNodes.add(targetId);
+                    propagationQueue.push(targetId);
                 }
             }
         });
+    }
+    newlyAffectedTargets.forEach((targetNodeId) => {
+        var _a, _b;
+        if (visitedNodes.has(targetNodeId) || deadNodes.has(targetNodeId)) {
+            return;
+        }
+        const pending = (_a = pendingPredecessorCount.get(targetNodeId)) !== null && _a !== void 0 ? _a : 0;
+        if (pending > 0) {
+            return;
+        }
+        const completed = completedNodePredecessors.get(targetNodeId).size;
+        const required = (_b = requiredPredecessorCount.get(targetNodeId)) !== null && _b !== void 0 ? _b : 0;
+        if (completed === required) {
+            if (!nextLevelNodesSet.has(targetNodeId)) {
+                nextLevelNodesSet.add(targetNodeId);
+                nextNodeIds.push(targetNodeId);
+            }
+        }
     });
     return { nextNodeIds, workflowOutputVariables };
 }
@@ -193,12 +231,30 @@ async function executeWorkflow(params) {
         throw new Error("invalid workflow nodes");
     }
     let workflowOutputVariables;
+    const outgoingEdgesMap = new Map();
+    const incomingEdgesMap = new Map();
+    edges.forEach((edge) => {
+        if (!outgoingEdgesMap.has(edge.sourceWorkflowNodeResourceId)) {
+            outgoingEdgesMap.set(edge.sourceWorkflowNodeResourceId, []);
+        }
+        outgoingEdgesMap.get(edge.sourceWorkflowNodeResourceId).push(edge);
+        if (!incomingEdgesMap.has(edge.targetWorkflowNodeResourceId)) {
+            incomingEdgesMap.set(edge.targetWorkflowNodeResourceId, []);
+        }
+        incomingEdgesMap.get(edge.targetWorkflowNodeResourceId).push(edge);
+    });
+    const pendingPredecessorCount = new Map();
+    incomingEdgesMap.forEach((incoming, nodeId) => {
+        pendingPredecessorCount.set(nodeId, incoming.length);
+    });
     // 使用动态执行，根据 portId 决定下一步执行哪些节点
     let currentNodeIds = [startNode.id];
     const visitedNodes = new Set();
+    const deadNodes = new Set();
     const completedNodePredecessors = new Map();
     // 记录每个节点被激活的入边（源节点ID -> 目标节点ID的集合）
     const activatedEdges = new Map();
+    const requiredPredecessorCount = new Map();
     let isFirstLevel = true;
     while (currentNodeIds.length > 0) {
         // 去重当前节点集合（避免重复执行）
@@ -240,7 +296,19 @@ async function executeWorkflow(params) {
             });
         }
         // 根据执行结果和 portId 查找下一个节点集合
-        const { nextNodeIds, workflowOutputVariables: tempOutputVariables } = findNextNodeIds(levelResults, edges, visitedNodes, completedNodePredecessors, activatedEdges, endNode.id);
+        const { nextNodeIds, workflowOutputVariables: tempOutputVariables } = findNextNodeIds({
+            levelResults,
+            edges,
+            visitedNodes,
+            deadNodes,
+            completedNodePredecessors,
+            pendingPredecessorCount,
+            activatedEdges,
+            requiredPredecessorCount,
+            outgoingEdgesMap,
+            incomingEdgesMap,
+            endNodeId: endNode.id,
+        });
         if (tempOutputVariables !== undefined) {
             workflowOutputVariables = tempOutputVariables;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ldsg/workflow",
-  "version": "0.3.33",
+  "version": "0.3.35",
   "description": "",
   "keywords": [],
   "license": "MIT",
@@ -20,10 +20,10 @@
     "jsonata": "2.2.2",
     "lodash": "^4.17.21",
     "zod": "^4.1.11",
-    "@ldsg/constants": "0.3.33",
-    "@ldsg/resource-definition": "0.3.33",
-    "@ldsg/handler": "0.3.33",
-    "@ldsg/resource": "0.3.33"
+    "@ldsg/constants": "0.3.35",
+    "@ldsg/handler": "0.3.35",
+    "@ldsg/resource": "0.3.35",
+    "@ldsg/resource-definition": "0.3.35"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
@@ -38,7 +38,7 @@
     "ts-jest": "^29.1.5",
     "ts-node": "^10.9.2",
     "typescript": "^5.8.3",
-    "@ldsg/types": "0.3.33"
+    "@ldsg/types": "0.3.35"
   },
   "scripts": {
     "build": "tsc --project tsconfig.build.json",