@bian-womp/spark-graph 0.3.86 → 0.3.88

package/lib/cjs/index.cjs

@@ -1884,7 +1884,6 @@ class RunContextManager {
             pendingEdges: 0,
             pendingResolvers: 0,
             pendingQueued: 0,
-            skipPropagateValues: options?.skipPropagateValues ?? false,
             propagate: options?.propagate ?? true,
             resolve: options?.resolve,
         };
@@ -1892,7 +1891,6 @@ class RunContextManager {
         this.logger.info("create-run-context", {
             id,
             startNodeId,
-            skipPropagateValues: ctx.skipPropagateValues,
             propagate: ctx.propagate,
         });
         return id;
@@ -2943,12 +2941,11 @@ class EdgePropagator {
         if (!shouldExecute) {
             return; // No change and no reason to rerun
         }
-        // Set input value (respecting skipPropagateValues)
-        const shouldSetValue = this.shouldSetInputValue(effectiveRunContexts);
-        if (shouldSetValue && valueChanged) {
+        // Set input value
+        if (valueChanged) {
             this.runtime.setTargetInput(edge, processedValue, "applyToTarget");
         }
-        else if (shouldSetValue && !valueChanged) {
+        else {
             // Even if value didn't change, update timestamp if we're forcing execution
             const now = Date.now();
             this.graph.updateNodeLastInputAt(edge.target.nodeId, edge.target.handle, now);
@@ -2986,22 +2983,6 @@ class EdgePropagator {
         }
         return merged;
     }
-    /**
-     * Check if input value should be set (respecting skipPropagateValues)
-     */
-    shouldSetInputValue(effectiveRunContexts) {
-        if (!effectiveRunContexts) {
-            return true; // Auto mode always sets values
-        }
-        // Check skipPropagateValues (only in run-context mode)
-        for (const id of effectiveRunContexts) {
-            const ctx = this.runContextManager.getRunContext(id);
-            if (ctx && ctx.skipPropagateValues) {
-                return false;
-            }
-        }
-        return true;
-    }
     /**
      * Execute downstream if conditions are met
      */
@@ -3090,8 +3071,6 @@ class EdgePropagator {
      *                        If undefined or empty, behaves like auto mode (always propagates values and execution).
      */
     propagate(srcNodeId, srcHandle, value, runContextIds) {
-        if (this.runtime.isPaused())
-            return;
         // Set source output
         if (!this.setSourceOutput(srcNodeId, srcHandle, value)) {
             return; // Node was removed
@@ -3108,8 +3087,6 @@ class EdgePropagator {
      * Only re-emits outputs that are valid according to resolved handles
      */
     invalidateDownstream(nodeId) {
-        if (this.runtime.isPaused())
-            return;
         const node = this.graph.getNode(nodeId);
         if (!node)
             return;
@@ -3848,6 +3825,7 @@ class GraphRuntime {
         this.runMode = "manual";
         this.pauseRefCount = 0;
         this.persistentPauseToken = null;
+        this.deferredAutoRunNodeIds = new Set();
         // Initialize components
         this.eventEmitter = new EventEmitter();
         this.graph = new Graph(this.eventEmitter);
@@ -3952,28 +3930,48 @@ class GraphRuntime {
         const e = event;
         return e.action === "invalidate";
     }
+    withRunContext(nodeId, options, run) {
+        const runContextId = this.runContextManager.createRunContext(nodeId, options);
+        try {
+            return run(new Set([runContextId]));
+        }
+        finally {
+            this.runContextManager.releaseScheduling(runContextId);
+        }
+    }
+    withManualNoPropagateContext(nodeId, run) {
+        if (this.runMode !== "manual") {
+            run(undefined);
+            return;
+        }
+        this.withRunContext(nodeId, { propagate: false }, (runContextIds) => {
+            run(runContextIds);
+        });
+    }
     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]);
+        if (this.isPaused()) {
+            this.deferredAutoRunNodeIds.add(nodeId);
+            return;
         }
-        try {
+        this.withManualNoPropagateContext(nodeId, (runContextIds) => {
             this.execute(nodeId, {
-                runContextIds: runContextIdsToUse,
+                runContextIds,
                 reason: opts?.reason ?? "executeNodeAutoRun",
             });
-        }
-        finally {
-            if (runContextIdToRelease) {
-                this.runContextManager.releaseScheduling(runContextIdToRelease);
-            }
+        });
+    }
+    flushDeferredAutoRunNodes() {
+        if (this.isPaused() || this.deferredAutoRunNodeIds.size === 0)
+            return;
+        const queuedNodeIds = Array.from(this.deferredAutoRunNodeIds);
+        this.deferredAutoRunNodeIds.clear();
+        for (const nodeId of queuedNodeIds) {
+            this.executeNodeAutoRun(nodeId, { reason: "deferred-auto-run" });
         }
     }
     setInputs(nodeId, inputs) {
@@ -4203,20 +4201,19 @@ class GraphRuntime {
         if (!node)
             return;
         return new Promise((resolve) => {
-            const id = this.runContextManager.createRunContext(startNodeId, {
-                resolve,
+            this.withRunContext(startNodeId, {
                 ...opts,
-            });
-            this.graph.addNodeRunContextId(startNodeId, id);
-            try {
+                resolve,
+            }, (runContextIds) => {
+                const [runContextId] = runContextIds;
+                if (runContextId) {
+                    this.graph.addNodeRunContextId(startNodeId, runContextId);
+                }
                 this.execute(startNodeId, {
-                    runContextIds: new Set([id]),
+                    runContextIds,
                     reason: opts?.reason ?? "runFromHereContext",
                 });
-            }
-            finally {
-                this.runContextManager.releaseScheduling(id);
-            }
+            });
         });
     }
     setRunMode(runMode) {
@@ -4233,6 +4230,10 @@ class GraphRuntime {
                 return;
             released = true;
             this.pauseRefCount--;
+            if (this.pauseRefCount <= 0) {
+                this.pauseRefCount = 0;
+                this.flushDeferredAutoRunNodes();
+            }
         };
     }
     isPaused() {
@@ -4276,18 +4277,13 @@ class GraphRuntime {
         this.handleResolver.scheduleRecomputeHandles(toNodeId);
         if (options?.dry) {
             // Dry copy should propagate values only, never schedule node execution.
-            const runContextId = this.runContextManager.createRunContext(toNodeId, { propagate: false });
-            const runContextIds = new Set([runContextId]);
-            try {
+            this.withRunContext(toNodeId, { propagate: false }, (runContextIds) => {
                 for (const [handle, value] of Object.entries(fromNode.outputs || {})) {
                     if (value !== undefined) {
                         this.propagate(toNodeId, handle, value, runContextIds);
                     }
                 }
-            }
-            finally {
-                this.runContextManager.releaseScheduling(runContextId);
-            }
+            });
             return;
         }
         this.executeNodeAutoRun(toNodeId, { reason: "copyOutputs" });
@@ -4553,22 +4549,9 @@ class GraphRuntime {
                         if (!setsEqual(beforeTargetSet, afterTargetSet)) {
                             const val = this.getOutput(nodeId, handle);
                             if (val !== undefined) {
-                                let runContextIdsToUse = undefined;
-                                let runContextIdToRelease;
-                                if (this.runMode === "manual") {
-                                    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.withManualNoPropagateContext(nodeId, (runContextIds) => {
+                                    this.propagate(nodeId, handle, val, runContextIds);
+                                });
                             }
                         }
                     }
@@ -4941,12 +4924,9 @@ class LocalEngine {
      * Run only this node, no downstream propagation.
      * Works in both modes, but typically only used in manual mode.
      * @param nodeId - The node to run
-     * @param options - Execution options
-     * @param options.skipPropagateValues - If true, don't set inputs of linked nodes (default: false)
      */
-    async computeNode(nodeId, options) {
+    async computeNode(nodeId) {
         await this.graphRuntime.runFromHereContext(nodeId, {
-            skipPropagateValues: options?.skipPropagateValues ?? false,
             propagate: false, // Don't schedule downstream nodes
             reason: "computeNode",
         });