@bian-womp/spark-graph 0.3.7 → 0.3.8

package/lib/cjs/index.cjs

@@ -1238,14 +1238,35 @@ class EdgePropagator {
         const processedValue = this.processArrayInput(edge, value);
         // Check if value changed
         const prev = dstNode.inputs[edge.target.handle];
-        if (valuesEqual(prev, processedValue)) {
-            return; // No change
+        const valueChanged = !valuesEqual(prev, processedValue);
+        // Check if we should execute even if value is same:
+        // 1. If node has rerunOnSameInput policy (from node params or registry)
+        // 2. If input was set after last successful run (stale input detection)
+        const registry = this.graph.getRegistry();
+        const desc = registry?.nodes.get(dstNode.typeId);
+        const nodeRerunPolicy = dstNode.policy?.rerunOnSameInput === true;
+        const descRerunPolicy = desc?.policy?.rerunOnSameInput === true;
+        const shouldRerunOnSameInput = nodeRerunPolicy || descRerunPolicy;
+        const inputWasSetAfterLastRun = dstNode.lastInputAt?.[edge.target.handle] &&
+            dstNode.lastSuccessAt &&
+            dstNode.lastInputAt[edge.target.handle] > dstNode.lastSuccessAt;
+        const shouldExecute = valueChanged || shouldRerunOnSameInput || inputWasSetAfterLastRun;
+        if (!shouldExecute) {
+            return; // No change and no reason to rerun
         }
         // Set input value (respecting skipPropagateValues)
         const shouldSetValue = this.shouldSetInputValue(effectiveRunContexts);
-        if (shouldSetValue) {
+        if (shouldSetValue && valueChanged) {
             this.setTargetInput(edge, dstNode, processedValue);
         }
+        else if (shouldSetValue && !valueChanged) {
+            // Even if value didn't change, update timestamp if we're forcing execution
+            const now = Date.now();
+            if (!dstNode.lastInputAt) {
+                dstNode.lastInputAt = {};
+            }
+            dstNode.lastInputAt[edge.target.handle] = now;
+        }
         // Schedule downstream execution
         this.executeDownstream(edge.target.nodeId, effectiveRunContexts);
     }
@@ -1302,7 +1323,13 @@ class EdgePropagator {
      * Set target input value and emit event
      */
     setTargetInput(edge, dstNode, value) {
+        const now = Date.now();
         dstNode.inputs[edge.target.handle] = value;
+        // Track when this input was set
+        if (!dstNode.lastInputAt) {
+            dstNode.lastInputAt = {};
+        }
+        dstNode.lastInputAt[edge.target.handle] = now;
         this.eventEmitter.emit("value", {
             nodeId: edge.target.nodeId,
             handle: edge.target.handle,
@@ -1879,11 +1906,15 @@ class NodeExecutor {
                 : undefined;
         if (!hadError)
             node.stats.lastError = undefined;
-        // Only emit node-done if not cancelled (cancellation events emitted separately)
+        // Track successful completion time (for detecting stale inputs)
         const isCancelled = controller.signal.aborted &&
             (controller.signal.reason === "snapshot" ||
                 controller.signal.reason === "node-deleted" ||
                 controller.signal.reason === "user-cancelled");
+        if (!hadError && !isCancelled) {
+            node.lastSuccessAt = Date.now();
+        }
+        // Only emit node-done if not cancelled (cancellation events emitted separately)
         if (!isCancelled) {
             this.eventEmitter.emit("stats", {
                 kind: "node-done",
@@ -2051,6 +2082,8 @@ class GraphRuntime {
                     progress: 0,
                 },
                 activeRunContextIds: new Set(),
+                lastInputAt: {},
+                lastSuccessAt: undefined,
             };
             gr.graph.setNode(n.nodeId, rn);
         }
@@ -2404,6 +2437,8 @@ class GraphRuntime {
                             progress: 0,
                         },
                         activeRunContextIds: new Set(),
+                        lastInputAt: {},
+                        lastSuccessAt: undefined,
                     };
                     this.graph.setNode(n.nodeId, newNode);
                     const effectiveInputs = this.nodeExecutor.getEffectiveInputs(newNode.nodeId);
@@ -2550,8 +2585,17 @@ class GraphRuntime {
                         const afterTargetSet = afterMap.get(handle) ?? new Set();
                         if (!setsEqual(beforeTargetSet, afterTargetSet)) {
                             const val = this.getOutput(nodeId, handle);
-                            if (val !== undefined)
-                                this.propagate(nodeId, handle, val);
+                            if (val !== undefined) {
+                                let runContextIdsToUse = undefined;
+                                if (this.runMode === "manual") {
+                                    runContextIdsToUse = new Set([
+                                        this.runContextManager.createRunContext(nodeId, undefined, {
+                                            propagate: false,
+                                        }),
+                                    ]);
+                                }
+                                this.propagate(nodeId, handle, val, runContextIdsToUse);
+                            }
                         }
                     }
                 }