@bian-womp/spark-graph 0.3.6 → 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);
         }
@@ -2157,8 +2190,27 @@ class GraphRuntime {
         const node = this.graph.getNode(nodeId);
         if (!node)
             return;
+        // If event is an invalidate event, re-run the node with same inputs
+        if (this.isInvalidateEvent(event)) {
+            // Check if node has all inbound inputs (required for execution)
+            if (this.graph.allInboundHaveValue(nodeId)) {
+                this.execute(nodeId);
+            }
+            return;
+        }
+        // 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);
     }
@@ -2385,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);
@@ -2531,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);
+                            }
                         }
                     }
                 }