@bian-womp/spark-graph 0.3.7 → 0.3.9

package/lib/cjs/index.cjs

@@ -28,6 +28,46 @@ function isInputPrivate(inputs, handle) {
     const v = inputs ? inputs[handle] : undefined;
     return !!(v && typeof v === "object" && v.private);
 }
+/**
+ * Merge two InputHandleDescriptor values, with dynamic taking precedence.
+ * If both have metadata, merge the metadata objects (dynamic overrides static).
+ */
+function mergeInputHandleDescriptors(staticDesc, dynamicDesc) {
+    // If only one exists, return it
+    if (!staticDesc)
+        return dynamicDesc;
+    if (!dynamicDesc)
+        return staticDesc;
+    // If both are strings, dynamic wins
+    if (typeof staticDesc === "string" && typeof dynamicDesc === "string") {
+        return dynamicDesc;
+    }
+    const staticObj = typeof staticDesc === "string" ? { typeId: staticDesc } : staticDesc;
+    const dynamicObj = typeof dynamicDesc === "string" ? { typeId: dynamicDesc } : dynamicDesc;
+    // Merge: dynamic takes precedence, but merge metadata objects
+    const merged = {
+        typeId: dynamicObj.typeId ?? staticObj.typeId,
+        private: dynamicObj.private ?? staticObj.private,
+    };
+    // Merge metadata if either has it
+    if (staticObj.metadata || dynamicObj.metadata) {
+        merged.metadata = {
+            ...staticObj.metadata,
+            ...dynamicObj.metadata, // Dynamic metadata overrides static
+        };
+    }
+    // Return as InputHandleDescriptor (which accepts object form)
+    return merged;
+}
+/**
+ * Extract metadata from an InputHandleDescriptor
+ */
+function getInputHandleMetadata(inputs, handle) {
+    const v = inputs ? inputs[handle] : undefined;
+    if (!v || typeof v === "string")
+        return undefined;
+    return v.metadata;
+}
 
 class CategoryRegistry {
     constructor() {
@@ -752,11 +792,34 @@ function tryHandleResolving(def, registry, environment) {
             // ignore dynamic resolution errors at this stage
         }
         // Merge base with dynamic and overrides (allow partial resolvedHandles)
-        const inputs = {
-            ...desc.inputs,
-            ...dyn.inputs,
-            ...overrideInputs,
-        };
+        // Merge inputs properly, handling metadata
+        const inputs = {};
+        // First, add all static handles
+        if (desc.inputs) {
+            for (const [handle, staticDesc] of Object.entries(desc.inputs)) {
+                inputs[handle] = staticDesc;
+            }
+        }
+        // Then, merge dynamic handles
+        if (dyn.inputs) {
+            for (const [handle, dynamicDesc] of Object.entries(dyn.inputs)) {
+                const staticDesc = desc.inputs?.[handle];
+                const merged = mergeInputHandleDescriptors(staticDesc, dynamicDesc);
+                if (merged) {
+                    inputs[handle] = merged;
+                }
+            }
+        }
+        // Finally, merge overrides
+        if (overrideInputs) {
+            for (const [handle, overrideDesc] of Object.entries(overrideInputs)) {
+                const existingDesc = inputs[handle];
+                const merged = mergeInputHandleDescriptors(existingDesc, overrideDesc);
+                if (merged) {
+                    inputs[handle] = merged;
+                }
+            }
+        }
         const outputs = {
             ...desc.outputs,
             ...dyn.outputs,
@@ -1022,7 +1085,24 @@ class HandleResolver {
             const nodeDesc = this.registry.nodes.get(node.typeId);
             if (!nodeDesc)
                 return;
-            const inputs = { ...nodeDesc.inputs, ...resolved?.inputs };
+            // Merge inputs properly, handling metadata
+            const inputs = {};
+            // First, add all static handles
+            if (nodeDesc.inputs) {
+                for (const [handle, staticDesc] of Object.entries(nodeDesc.inputs)) {
+                    inputs[handle] = staticDesc;
+                }
+            }
+            // Then, merge dynamic handles
+            if (resolved?.inputs) {
+                for (const [handle, dynamicDesc] of Object.entries(resolved.inputs)) {
+                    const staticDesc = nodeDesc.inputs?.[handle];
+                    const merged = mergeInputHandleDescriptors(staticDesc, dynamicDesc);
+                    if (merged) {
+                        inputs[handle] = merged;
+                    }
+                }
+            }
             const outputs = { ...nodeDesc.outputs, ...resolved?.outputs };
             const inputDefaults = {
                 ...nodeDesc.inputDefaults,
@@ -1238,14 +1318,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 +1403,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 +1986,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 +2162,8 @@ class GraphRuntime {
                     progress: 0,
                 },
                 activeRunContextIds: new Set(),
+                lastInputAt: {},
+                lastSuccessAt: undefined,
             };
             gr.graph.setNode(n.nodeId, rn);
         }
@@ -2404,6 +2517,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 +2665,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);
+                            }
                         }
                     }
                 }
@@ -5043,6 +5167,7 @@ exports.createValidationGraphDef = createValidationGraphDef;
 exports.createValidationGraphRegistry = createValidationGraphRegistry;
 exports.findMatchingPaths = findMatchingPaths;
 exports.generateId = generateId;
+exports.getInputHandleMetadata = getInputHandleMetadata;
 exports.getInputTypeId = getInputTypeId;
 exports.getTypedOutputTypeId = getTypedOutputTypeId;
 exports.getTypedOutputValue = getTypedOutputValue;
@@ -5051,6 +5176,7 @@ exports.installLogging = installLogging;
 exports.isInputPrivate = isInputPrivate;
 exports.isTypedOutput = isTypedOutput;
 exports.mergeGraphDefinitions = mergeGraphDefinitions;
+exports.mergeInputHandleDescriptors = mergeInputHandleDescriptors;
 exports.mergeInputsOutputs = mergeInputsOutputs;
 exports.mergeRuntimeState = mergeRuntimeState;
 exports.mergeSnapshotData = mergeSnapshotData;