@bian-womp/spark-graph 0.3.43 → 0.3.45

package/lib/cjs/index.cjs

@@ -495,7 +495,8 @@ Registry.idCounter = 0;
  * This is the ONLY place where nodes, edges, and resolvedByNode are directly updated.
  */
 class Graph {
-    constructor(registry) {
+    constructor(eventEmitter, registry) {
+        this.eventEmitter = eventEmitter;
         this.registry = registry;
         this.nodes = new Map();
         this.edges = [];
@@ -552,7 +553,7 @@ class Graph {
     /**
      * Update node inputs
      */
-    updateNodeInput(nodeId, handle, value) {
+    updateNodeInput(nodeId, handle, value, calculated = true) {
         const node = this.getNodeMutable(nodeId);
         if (!node)
             return;
@@ -562,15 +563,16 @@ class Graph {
         else {
             node.inputs[handle] = value;
         }
-    }
-    /**
-     * Delete a node input handle
-     */
-    deleteNodeInput(nodeId, handle) {
-        const node = this.nodes.get(nodeId);
-        if (!node)
-            return;
-        delete node.inputs[handle];
+        if (calculated) {
+            this.updateNodeLastInputAt(nodeId, handle, Date.now());
+        }
+        this.eventEmitter.emit("value", {
+            nodeId,
+            handle,
+            value,
+            io: "input",
+            runtimeTypeId: unwrapTypeId(value),
+        });
     }
     /**
      * Update node outputs
@@ -579,7 +581,19 @@ class Graph {
         const node = this.nodes.get(nodeId);
         if (!node)
             return;
-        node.outputs[handle] = value;
+        if (value === undefined) {
+            delete node.outputs[handle];
+        }
+        else {
+            node.outputs[handle] = value;
+        }
+        this.eventEmitter.emit("value", {
+            nodeId,
+            handle,
+            value,
+            io: "output",
+            runtimeTypeId: unwrapTypeId(value),
+        });
     }
     /**
      * Update node state
@@ -652,9 +666,8 @@ class Graph {
         const node = this.nodes.get(nodeId);
         if (!node)
             return;
-        if (!node.lastInputAt) {
+        if (!node.lastInputAt)
             node.lastInputAt = {};
-        }
         node.lastInputAt[handle] = timestamp;
     }
     /**
@@ -1977,13 +1990,6 @@ class EdgePropagator {
             return false;
         }
         this.graph.updateNodeOutput(srcNodeId, srcHandle, value);
-        this.eventEmitter.emit("value", {
-            nodeId: srcNodeId,
-            handle: srcHandle,
-            value,
-            io: "output",
-            runtimeTypeId: unwrapTypeId(value),
-        });
         return true;
     }
     /**
@@ -2205,16 +2211,7 @@ class EdgePropagator {
      * Set target input value and emit event
      */
     setTargetInput(edge, dstNode, value) {
-        const now = Date.now();
         this.graph.updateNodeInput(edge.target.nodeId, edge.target.handle, value);
-        this.graph.updateNodeLastInputAt(edge.target.nodeId, edge.target.handle, now);
-        this.eventEmitter.emit("value", {
-            nodeId: edge.target.nodeId,
-            handle: edge.target.handle,
-            value,
-            io: "input",
-            runtimeTypeId: unwrapTypeId(value),
-        });
         this.handleResolver.scheduleRecomputeHandles(edge.target.nodeId);
     }
     /**
@@ -2430,7 +2427,7 @@ class NodeExecutor {
             return;
         const runMode = this.runtime.getRunMode();
         if (!runMode) {
-            console.warn("NodeExecutor.execute: no runMode, skipping execution");
+            console.trace("NodeExecutor.execute: no runMode, skipping execution");
             return;
         }
         // In manual mode, require runContextIds unless autoRun policy is set
@@ -2444,12 +2441,12 @@ class NodeExecutor {
                 ]);
             }
             else {
-                console.warn("NodeExecutor.execute: no runContextIds provided in manual mode, skipping execution");
+                console.trace("NodeExecutor.execute: no runContextIds provided in manual mode, skipping execution");
                 return;
             }
         }
         if (runMode === "auto" && runContextIds && runContextIds.size > 0) {
-            console.warn("NodeExecutor.execute: runContextIds provided in auto mode, ignoring");
+            console.trace("NodeExecutor.execute: runContextIds provided in auto mode, ignoring");
             runContextIds = undefined;
         }
         // Early validation for auto-mode paused state
@@ -3024,8 +3021,8 @@ class GraphRuntime {
         this.pauseRefCount = 0;
         this.persistentPauseToken = null;
         // Initialize components
-        this.graph = new Graph();
         this.eventEmitter = new EventEmitter();
+        this.graph = new Graph(this.eventEmitter);
         this.runContextManager = new RunContextManager(this.graph, "debug");
         this.handleResolver = new HandleResolver(this.graph, this.eventEmitter, this.runContextManager, this);
         this.edgePropagator = new EdgePropagator(this.graph, this.eventEmitter, this.runContextManager, this.handleResolver, this);
@@ -3135,7 +3132,7 @@ class GraphRuntime {
             if (hasInbound)
                 continue;
             // Validate input value against declared type
-            if (value !== undefined && registry) {
+            if (registry) {
                 const desc = registry.nodes.get(node.typeId);
                 const resolved = this.graph.getResolvedHandles(nodeId);
                 // Get declared types (may be union); prefer resolved handles over registry statics
@@ -3157,7 +3154,7 @@ class GraphRuntime {
                             return true;
                         return typeDesc.validate(value);
                     });
-                    if (!isValidForAny) {
+                    if (value !== undefined && !isValidForAny) {
                         const typeLabel = typeIds.join("|");
                         const errorMessage = `Invalid value for input ${nodeId}.${handle} (type ${typeLabel}): ${JSON.stringify(value)}`;
                         this.eventEmitter.emit("error", {
@@ -3186,11 +3183,7 @@ class GraphRuntime {
         // However, if autoRun policy is set, nodes run automatically even in manual mode.
         if (anyChanged) {
             this.handleResolver.scheduleRecomputeHandles(nodeId);
-            const node = this.graph.getNode(nodeId);
-            const shouldAutoRun = this.runMode === "auto" || node?.policy?.autoRun === true;
-            if (shouldAutoRun && this.graph.allInboundHaveValue(nodeId)) {
-                this.execute(nodeId);
-            }
+            this.executeNodeAutoRun(nodeId);
         }
     }
     getOutput(nodeId, output) {
@@ -3405,17 +3398,28 @@ class GraphRuntime {
             }
         }
     }
+    executeNodeAutoRun(nodeId) {
+        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, undefined, {
+                    propagate: false,
+                }),
+            ]);
+        }
+        if (shouldAutoRun && this.graph.allInboundHaveValue(nodeId)) {
+            this.execute(nodeId, runContextIdsToUse);
+        }
+    }
     copyOutputs(fromNodeId, toNodeId, options) {
         const fromNode = this.getNodeData(fromNodeId);
         if (!fromNode?.outputs)
             return;
         this.hydrate({ outputs: { [toNodeId]: { ...fromNode.outputs } } }, { invalidate: !options?.dry });
         this.handleResolver.scheduleRecomputeHandles(toNodeId);
-        const node = this.graph.getNode(toNodeId);
-        const shouldAutoRun = this.runMode === "auto" || node?.policy?.autoRun === true;
-        if (shouldAutoRun && this.graph.allInboundHaveValue(toNodeId)) {
-            this.execute(toNodeId);
-        }
+        this.executeNodeAutoRun(toNodeId);
     }
     hydrate(payload, opts) {
         const releasePause = this.requestPause();
@@ -3432,14 +3436,7 @@ class GraphRuntime {
                     const clonedValue = structuredClone(v);
                     const same = valuesEqual(prev, clonedValue);
                     if (!same) {
-                        this.graph.updateNodeInput(nodeId, h, clonedValue);
-                        this.eventEmitter.emit("value", {
-                            nodeId,
-                            handle: h,
-                            value: clonedValue,
-                            io: "input",
-                            runtimeTypeId: unwrapTypeId(clonedValue),
-                        });
+                        this.graph.updateNodeInput(nodeId, h, clonedValue, false);
                         nodeChanged = true;
                     }
                 }
@@ -3454,13 +3451,6 @@ class GraphRuntime {
                 for (const [h, v] of Object.entries(map || {})) {
                     const clonedValue = structuredClone(v);
                     this.graph.updateNodeOutput(nodeId, h, clonedValue);
-                    this.eventEmitter.emit("value", {
-                        nodeId,
-                        handle: h,
-                        value: clonedValue,
-                        io: "output",
-                        runtimeTypeId: unwrapTypeId(clonedValue),
-                    });
                 }
             }
             // Trigger handle resolution for nodes with changed inputs
@@ -3650,7 +3640,7 @@ class GraphRuntime {
                         if (!currSet.has(handle)) {
                             const node = this.graph.getNode(nodeId);
                             if (node && handle in node.inputs) {
-                                this.graph.deleteNodeInput(nodeId, handle);
+                                this.graph.updateNodeInput(nodeId, handle, undefined);
                                 changed = true;
                             }
                         }
@@ -3659,11 +3649,7 @@ class GraphRuntime {
                         this.edgePropagator.clearArrayBuckets(nodeId);
                         // Trigger handle resolution when inputs are removed
                         this.handleResolver.scheduleRecomputeHandles(nodeId);
-                        const node = this.graph.getNode(nodeId);
-                        const shouldAutoRun = this.runMode === "auto" || node?.policy?.autoRun === true;
-                        if (shouldAutoRun && this.graph.allInboundHaveValue(nodeId)) {
-                            this.execute(nodeId);
-                        }
+                        this.executeNodeAutoRun(nodeId);
                     }
                 }
                 // Propagate changes on edges added