@bian-womp/spark-graph 0.3.72 → 0.3.74

package/lib/cjs/index.cjs

@@ -1684,6 +1684,7 @@ class RunContextManager {
             id,
             startNodes: new Set([startNodeId]),
             cancelledNodes: new Set(),
+            pendingScheduling: 1,
             pendingNodes: 0,
             pendingEdges: 0,
             pendingResolvers: 0,
@@ -1719,6 +1720,33 @@ class RunContextManager {
     hasActiveRunContexts() {
         return this.runContexts.size > 0;
     }
+    /**
+     * Release one scheduling hold from a run-context.
+     * Must be called once by the creator when scheduling decisions are complete.
+     */
+    releaseScheduling(id) {
+        const ctx = this.runContexts.get(id);
+        if (!ctx) {
+            this.logger.debug("release-scheduling-context-not-found", {
+                runContextId: id,
+            });
+            return;
+        }
+        if (ctx.pendingScheduling > 0) {
+            ctx.pendingScheduling--;
+        }
+        else {
+            this.logger.warn("release-scheduling-underflow", {
+                runContextId: id,
+                pendingScheduling: ctx.pendingScheduling,
+            });
+        }
+        this.logger.debug("release-scheduling", {
+            runContextId: id,
+            pendingScheduling: ctx.pendingScheduling,
+        });
+        this.finishRunContextIfPossible(id);
+    }
     /**
      * Increment queued work count for a run-context.
      * Used by asyncConcurrency: "queue" to keep contexts alive while work is queued.
@@ -1870,7 +1898,11 @@ class RunContextManager {
             });
             return;
         }
-        if (ctx.pendingNodes > 0 || ctx.pendingEdges > 0 || ctx.pendingResolvers > 0 || ctx.pendingQueued > 0) {
+        if (ctx.pendingScheduling > 0 ||
+            ctx.pendingNodes > 0 ||
+            ctx.pendingEdges > 0 ||
+            ctx.pendingResolvers > 0 ||
+            ctx.pendingQueued > 0) {
             return; // Still has pending work
         }
         this.logger.info("finish-run-context", {
@@ -2523,11 +2555,10 @@ class HandleResolver {
  * EdgePropagator component - handles value propagation through edges
  */
 class EdgePropagator {
-    constructor(graph, eventEmitter, runContextManager, handleResolver, nodeExecutor, runtime) {
+    constructor(graph, eventEmitter, runContextManager, nodeExecutor, runtime) {
         this.graph = graph;
         this.eventEmitter = eventEmitter;
         this.runContextManager = runContextManager;
-        this.handleResolver = handleResolver;
         this.nodeExecutor = nodeExecutor;
         this.runtime = runtime;
         this.arrayInputBuckets = new Map();
@@ -2716,7 +2747,7 @@ class EdgePropagator {
         // Set input value (respecting skipPropagateValues)
         const shouldSetValue = this.shouldSetInputValue(effectiveRunContexts);
         if (shouldSetValue && valueChanged) {
-            this.setTargetInput(edge, processedValue);
+            this.runtime.setTargetInput(edge, processedValue, "applyToTarget");
         }
         else if (shouldSetValue && !valueChanged) {
             // Even if value didn't change, update timestamp if we're forcing execution
@@ -2772,13 +2803,6 @@ class EdgePropagator {
         }
         return true;
     }
-    /**
-     * Set target input value and emit event
-     */
-    setTargetInput(edge, value) {
-        this.graph.updateNodeInput(edge.target.nodeId, edge.target.handle, value);
-        this.handleResolver.scheduleRecomputeHandles(edge.target.nodeId);
-    }
     /**
      * Execute downstream if conditions are met
      */
@@ -2988,13 +3012,22 @@ class NodeExecutor {
             execute: (opts) => {
                 if (this.graph.allInboundHaveValue(nodeId)) {
                     let runContextIdsToUse = this.runtime.getRunMode() === "auto" ? undefined : runContextIds;
+                    let runContextIdToRelease;
                     if (this.runtime.getRunMode() === "manual" && (!runContextIds || runContextIds.size === 0)) {
-                        runContextIdsToUse = new Set([this.runContextManager.createRunContext(nodeId, opts)]);
+                        runContextIdToRelease = this.runContextManager.createRunContext(nodeId, opts);
+                        runContextIdsToUse = new Set([runContextIdToRelease]);
+                    }
+                    try {
+                        this.execute(nodeId, {
+                            runContextIds: runContextIdsToUse,
+                            reason: opts?.reason ?? "executeFromContext",
+                        });
+                    }
+                    finally {
+                        if (runContextIdToRelease) {
+                            this.runContextManager.releaseScheduling(runContextIdToRelease);
+                        }
                     }
-                    this.execute(nodeId, {
-                        runContextIds: runContextIdsToUse,
-                        reason: opts?.reason ?? "executeFromContext",
-                    });
                 }
             },
             getInput: (handle) => inputs[handle],
@@ -3020,6 +3053,7 @@ class NodeExecutor {
      */
     execute(nodeId, opts) {
         let { runContextIds, canSkipHandleResolution, reason = "" } = opts ?? {};
+        let autoCreatedRunContextId;
         const node = this.graph.getNode(nodeId);
         if (!node)
             return;
@@ -3032,81 +3066,89 @@ class NodeExecutor {
         if (runMode === "manual" && (!runContextIds || runContextIds.size === 0)) {
             // If autoRun is true, auto-generate a run context (similar to createExecutionContext pattern)
             if (node.policy?.autoRun === true) {
-                runContextIds = new Set([this.runContextManager.createRunContext(nodeId, { propagate: false })]);
+                autoCreatedRunContextId = this.runContextManager.createRunContext(nodeId, { propagate: false });
+                runContextIds = new Set([autoCreatedRunContextId]);
             }
             else {
                 console.trace(`NodeExecutor.execute[${formatNodeRef(this.graph, nodeId)}:${reason}]: no runContextIds provided in manual mode, skipping execution`);
                 return;
             }
         }
-        if (runMode === "auto" && runContextIds && runContextIds.size > 0) {
-            console.trace(`NodeExecutor.execute[${formatNodeRef(this.graph, nodeId)}:${reason}]: runContextIds provided in auto mode, ignoring`);
-            runContextIds = undefined;
-        }
-        // Early validation for auto-mode paused state
-        if (this.runtime.isPaused())
-            return;
-        // Check runtime validators (check current state, not just graph definition)
-        const runtimeValidationError = this.runtime.hasRuntimeValidationBlock(nodeId);
-        if (runtimeValidationError) {
-            this.eventEmitter.emit("error", {
-                kind: "system",
-                message: runtimeValidationError.message,
-                code: runtimeValidationError.code || "RUNTIME_VALIDATION_BLOCKED",
-                details: {
-                    nodeId,
-                    nodeTypeId: node?.typeId,
-                    ...runtimeValidationError.details,
-                },
-            });
-            return;
-        }
-        // Attach run-context IDs if provided - do this BEFORE checking for pending resolution
-        // so that handle resolution can track these run contexts
-        if (runContextIds) {
-            this.graph.addNodeRunContextIds(nodeId, runContextIds);
-        }
-        if (!canSkipHandleResolution && !this.handleResolver.getPendingResolution(nodeId)) {
-            this.handleResolver.scheduleRecomputeHandles(nodeId);
-        }
-        // Check if handles are being resolved - wait for resolution before executing
-        // Do this AFTER setting up run contexts so handle resolution can track them
-        const pendingResolution = this.handleResolver.getPendingResolution(nodeId);
-        if (pendingResolution) {
-            if (runContextIds && runContextIds.size > 0) {
-                for (const id of runContextIds) {
-                    this.runContextManager.startHandleResolution(id, nodeId);
-                }
+        try {
+            if (runMode === "auto" && runContextIds && runContextIds.size > 0) {
+                console.trace(`NodeExecutor.execute[${formatNodeRef(this.graph, nodeId)}:${reason}]: runContextIds provided in auto mode, ignoring`);
+                runContextIds = undefined;
             }
-            // Wait for resolution to complete, then re-execute
-            pendingResolution.then(() => {
-                // Re-check node still exists and conditions
-                const nodeAfter = this.graph.getNode(nodeId);
-                if (nodeAfter) {
-                    this.execute(nodeId, {
-                        runContextIds,
-                        canSkipHandleResolution: true,
-                        reason: opts?.reason,
-                    });
-                }
+            // Early validation for auto-mode paused state
+            if (this.runtime.isPaused())
+                return;
+            // Check runtime validators (check current state, not just graph definition)
+            const runtimeValidationError = this.runtime.hasRuntimeValidationBlock(nodeId);
+            if (runtimeValidationError) {
+                this.eventEmitter.emit("error", {
+                    kind: "system",
+                    message: runtimeValidationError.message,
+                    code: runtimeValidationError.code || "RUNTIME_VALIDATION_BLOCKED",
+                    details: {
+                        nodeId,
+                        nodeTypeId: node?.typeId,
+                        ...runtimeValidationError.details,
+                    },
+                });
+                return;
+            }
+            // Attach run-context IDs if provided - do this BEFORE checking for pending resolution
+            // so that handle resolution can track these run contexts
+            if (runContextIds) {
+                this.graph.addNodeRunContextIds(nodeId, runContextIds);
+            }
+            if (!canSkipHandleResolution && !this.handleResolver.getPendingResolution(nodeId)) {
+                this.handleResolver.scheduleRecomputeHandles(nodeId);
+            }
+            // Check if handles are being resolved - wait for resolution before executing
+            // Do this AFTER setting up run contexts so handle resolution can track them
+            const pendingResolution = this.handleResolver.getPendingResolution(nodeId);
+            if (pendingResolution) {
                 if (runContextIds && runContextIds.size > 0) {
                     for (const id of runContextIds) {
-                        this.runContextManager.finishHandleResolution(id, nodeId);
+                        this.runContextManager.startHandleResolution(id, nodeId);
                     }
                 }
-            });
-            return;
+                // Wait for resolution to complete, then re-execute
+                pendingResolution.then(() => {
+                    // Re-check node still exists and conditions
+                    const nodeAfter = this.graph.getNode(nodeId);
+                    if (nodeAfter) {
+                        this.execute(nodeId, {
+                            runContextIds,
+                            canSkipHandleResolution: true,
+                            reason: opts?.reason,
+                        });
+                    }
+                    if (runContextIds && runContextIds.size > 0) {
+                        for (const id of runContextIds) {
+                            this.runContextManager.finishHandleResolution(id, nodeId);
+                        }
+                    }
+                });
+                return;
+            }
+            // Handle debouncing
+            const now = Date.now();
+            if (this.shouldDebounce(nodeId, now)) {
+                this.handleDebouncedSchedule(nodeId, now, runContextIds, reason);
+                return;
+            }
+            // Prepare execution plan
+            const executionPlan = this.prepareExecutionPlan(nodeId, runContextIds, now, reason);
+            // Route to appropriate concurrency handler
+            this.routeToConcurrencyHandler(nodeId, executionPlan);
         }
-        // Handle debouncing
-        const now = Date.now();
-        if (this.shouldDebounce(nodeId, now)) {
-            this.handleDebouncedSchedule(nodeId, now, runContextIds, reason);
-            return;
+        finally {
+            if (autoCreatedRunContextId) {
+                this.runContextManager.releaseScheduling(autoCreatedRunContextId);
+            }
         }
-        // Prepare execution plan
-        const executionPlan = this.prepareExecutionPlan(nodeId, runContextIds, now, reason);
-        // Route to appropriate concurrency handler
-        this.routeToConcurrencyHandler(nodeId, executionPlan);
     }
     /**
      * Check if execution should be debounced
@@ -3622,7 +3664,7 @@ class GraphRuntime {
         this.graph = new Graph(this.eventEmitter);
         this.runContextManager = new RunContextManager(this.graph, "warn");
         this.handleResolver = new HandleResolver(this.graph, this.eventEmitter, this.runContextManager, this);
-        this.edgePropagator = new EdgePropagator(this.graph, this.eventEmitter, this.runContextManager, this.handleResolver, this, this);
+        this.edgePropagator = new EdgePropagator(this.graph, this.eventEmitter, this.runContextManager, this, this);
         // Create NodeExecutor with EdgePropagator and HandleResolver
         this.nodeExecutor = new NodeExecutor(this.graph, this.eventEmitter, this.runContextManager, this.handleResolver, this, this);
         // Create RuntimeValidatorManager
@@ -3711,6 +3753,40 @@ class GraphRuntime {
     on(event, handler) {
         return this.eventEmitter.on(event, handler);
     }
+    /**
+     * Check if an event is an invalidate event that should trigger re-execution
+     */
+    isInvalidateEvent(event) {
+        if (!event || typeof event !== "object")
+            return false;
+        // Check if event has action === "invalidate"
+        const e = event;
+        return e.action === "invalidate";
+    }
+    executeNodeAutoRun(nodeId, opts) {
+        const node = this.graph.getNode(nodeId);
+        const shouldAutoRun = this.runMode === "auto" || node?.policy?.autoRun === true;
+        const canExecute = this.graph.allInboundHaveValue(nodeId);
+        if (!shouldAutoRun || !canExecute)
+            return;
+        let runContextIdsToUse = undefined;
+        let runContextIdToRelease;
+        if (this.runMode === "manual") {
+            runContextIdToRelease = this.runContextManager.createRunContext(nodeId, { propagate: false });
+            runContextIdsToUse = new Set([runContextIdToRelease]);
+        }
+        try {
+            this.execute(nodeId, {
+                runContextIds: runContextIdsToUse,
+                reason: opts?.reason ?? "executeNodeAutoRun",
+            });
+        }
+        finally {
+            if (runContextIdToRelease) {
+                this.runContextManager.releaseScheduling(runContextIdToRelease);
+            }
+        }
+    }
     setInputs(nodeId, inputs) {
         const node = this.graph.getNode(nodeId);
         if (!node)
@@ -3766,8 +3842,6 @@ class GraphRuntime {
             const same = valuesEqual(prev, value);
             if (!same) {
                 this.graph.updateNodeInput(nodeId, handle, value);
-                // Emit value event for input updates
-                this.eventEmitter.emit("value", { nodeId, handle, value, io: "input" });
                 anyChanged = true;
             }
         }
@@ -3796,8 +3870,9 @@ class GraphRuntime {
         });
         if (this.runMode === "auto" && invalidate) {
             for (const nodeId of this.graph.getNodeIds()) {
-                if (this.graph.allInboundHaveValue(nodeId))
+                if (this.graph.allInboundHaveValue(nodeId)) {
                     this.execute(nodeId, { reason: "launch" });
+                }
             }
         }
         if (startPaused) {
@@ -3819,16 +3894,6 @@ class GraphRuntime {
         // Forward event to node's onExternalEvent handler for custom actions
         node.runtime.onExternalEvent?.(event, node.state);
     }
-    /**
-     * Check if an event is an invalidate event that should trigger re-execution
-     */
-    isInvalidateEvent(event) {
-        if (!event || typeof event !== "object")
-            return false;
-        // Check if event has action === "invalidate"
-        const e = event;
-        return e.action === "invalidate";
-    }
     cancelNodeRuns(nodeIds) {
         this.nodeExecutor.cancelNodeRuns(nodeIds);
     }
@@ -3856,6 +3921,7 @@ class GraphRuntime {
         this.nodeExecutor.setEnvironment(this.environment);
         for (const nodeId of this.graph.getNodeIds()) {
             this.handleResolver.scheduleRecomputeHandles(nodeId);
+            this.executeNodeAutoRun(nodeId, { reason: "setEnvironment" });
         }
     }
     setCustomNodeData(customNodeData) {
@@ -3953,10 +4019,15 @@ class GraphRuntime {
                 ...opts,
             });
             this.graph.addNodeRunContextId(startNodeId, id);
-            this.execute(startNodeId, {
-                runContextIds: new Set([id]),
-                reason: opts?.reason ?? "runFromHereContext",
-            });
+            try {
+                this.execute(startNodeId, {
+                    runContextIds: new Set([id]),
+                    reason: opts?.reason ?? "runFromHereContext",
+                });
+            }
+            finally {
+                this.runContextManager.releaseScheduling(id);
+            }
         });
     }
     setRunMode(runMode) {
@@ -4003,19 +4074,10 @@ class GraphRuntime {
             }
         }
     }
-    executeNodeAutoRun(nodeId, opts) {
-        const node = this.graph.getNode(nodeId);
-        const shouldAutoRun = this.runMode === "auto" || node?.policy?.autoRun === true;
-        let runContextIdsToUse = undefined;
-        if (this.runMode === "manual") {
-            runContextIdsToUse = new Set([this.runContextManager.createRunContext(nodeId, { propagate: false })]);
-        }
-        if (shouldAutoRun && this.graph.allInboundHaveValue(nodeId)) {
-            this.execute(nodeId, {
-                runContextIds: runContextIdsToUse,
-                reason: opts?.reason ?? "executeNodeAutoRun",
-            });
-        }
+    setTargetInput(edge, value, reason) {
+        this.graph.updateNodeInput(edge.target.nodeId, edge.target.handle, value);
+        this.handleResolver.scheduleRecomputeHandles(edge.target.nodeId);
+        this.executeNodeAutoRun(edge.target.nodeId, { reason });
     }
     copyOutputs(fromNodeId, toNodeId, options) {
         const fromNode = this.getNodeData(fromNodeId);
@@ -4286,14 +4348,21 @@ class GraphRuntime {
                             const val = this.getOutput(nodeId, handle);
                             if (val !== undefined) {
                                 let runContextIdsToUse = undefined;
+                                let runContextIdToRelease;
                                 if (this.runMode === "manual") {
-                                    runContextIdsToUse = new Set([
-                                        this.runContextManager.createRunContext(nodeId, {
-                                            propagate: false,
-                                        }),
-                                    ]);
+                                    runContextIdToRelease = this.runContextManager.createRunContext(nodeId, {
+                                        propagate: false,
+                                    });
+                                    runContextIdsToUse = new Set([runContextIdToRelease]);
+                                }
+                                try {
+                                    this.propagate(nodeId, handle, val, runContextIdsToUse);
+                                }
+                                finally {
+                                    if (runContextIdToRelease) {
+                                        this.runContextManager.releaseScheduling(runContextIdToRelease);
+                                    }
                                 }
-                                this.propagate(nodeId, handle, val, runContextIdsToUse);
                             }
                         }
                     }