@bian-womp/spark-graph 0.1.28 → 0.1.29

package/lib/cjs/index.cjs

@@ -409,6 +409,22 @@ class GraphRuntime {
         this.environment = {};
         this.paused = false;
     }
+    // Shallow/deep-ish equality to avoid unnecessary runs on identical values
+    valuesEqual(a, b) {
+        if (a === b)
+            return true;
+        if (typeof a !== typeof b)
+            return false;
+        if (a && b && typeof a === "object") {
+            try {
+                return JSON.stringify(a) === JSON.stringify(b);
+            }
+            catch {
+                return false;
+            }
+        }
+        return false;
+    }
     static create(def, registry, opts) {
         const gr = new GraphRuntime();
         gr.environment = opts?.environment ?? {};
@@ -545,17 +561,23 @@ class GraphRuntime {
         const node = this.nodes.get(nodeId);
         if (!node)
             throw new Error(`Node not found: ${nodeId}`);
+        let anyChanged = false;
         for (const [handle, value] of Object.entries(inputs)) {
             const hasInbound = this.edges.some((e) => e.target.nodeId === nodeId && e.target.handle === handle);
             if (hasInbound)
                 continue;
-            node.inputs[handle] = value;
-            // Emit value event for input updates
-            this.emit("value", { nodeId, handle, value, io: "input" });
+            const prev = node.inputs[handle];
+            const same = this.valuesEqual(prev, value);
+            if (!same) {
+                node.inputs[handle] = value;
+                // Emit value event for input updates
+                this.emit("value", { nodeId, handle, value, io: "input" });
+                anyChanged = true;
+            }
         }
         if (!this.paused) {
             // Only schedule if all inbound inputs are present (or there are none)
-            if (this.allInboundHaveValue(nodeId))
+            if (anyChanged && this.allInboundHaveValue(nodeId))
                 this.scheduleInputsChanged(nodeId);
         }
     }
@@ -812,17 +834,21 @@ class GraphRuntime {
                 const dstNode = this.nodes.get(e.target.nodeId);
                 if (!dstNode)
                     return;
-                dstNode.inputs[e.target.handle] = v;
-                // Emit value event for input updates
-                this.emit("value", {
-                    nodeId: e.target.nodeId,
-                    handle: e.target.handle,
-                    value: v,
-                    io: "input",
-                    runtimeTypeId: getTypedOutputTypeId(v),
-                });
-                if (!this.paused && this.allInboundHaveValue(e.target.nodeId))
-                    this.scheduleInputsChanged(e.target.nodeId);
+                const prev = dstNode.inputs[e.target.handle];
+                const same = this.valuesEqual(prev, v);
+                if (!same) {
+                    dstNode.inputs[e.target.handle] = v;
+                    // Emit value event for input updates
+                    this.emit("value", {
+                        nodeId: e.target.nodeId,
+                        handle: e.target.handle,
+                        value: v,
+                        io: "input",
+                        runtimeTypeId: getTypedOutputTypeId(v),
+                    });
+                    if (!this.paused && this.allInboundHaveValue(e.target.nodeId))
+                        this.scheduleInputsChanged(e.target.nodeId);
+                }
             };
             if (e.convertAsync) {
                 // emit edge-start before launching async conversion
@@ -1102,6 +1128,13 @@ class GraphRuntime {
             set.add(e.target.handle);
             prevInbound.set(e.target.nodeId, set);
         }
+        // Capture previous outgoing map before rebuilding edges
+        const prevOutgoing = new Map();
+        for (const e of this.edges) {
+            const set = prevOutgoing.get(e.source.nodeId) ?? new Set();
+            set.add(e.source.handle);
+            prevOutgoing.set(e.source.nodeId, set);
+        }
         // Rebuild edges mapping with coercions
         this.edges = def.edges.map((e) => {
             const srcNode = def.nodes.find((nn) => nn.nodeId === e.source.nodeId);
@@ -1191,9 +1224,34 @@ class GraphRuntime {
                 this.scheduleInputsChanged(nodeId);
             }
         }
-        // Re-emit existing outputs to populate new edges
-        for (const nodeId of this.nodes.keys()) {
-            this.reemitNodeOutputs(nodeId);
+        // Re-emit outputs only for sources whose outgoing edge set changed
+        const nextOutgoing = new Map();
+        for (const e of this.edges) {
+            const set = nextOutgoing.get(e.source.nodeId) ?? new Set();
+            set.add(e.source.handle);
+            nextOutgoing.set(e.source.nodeId, set);
+        }
+        const setsEqual = (a, b) => {
+            if (!a && !b)
+                return true;
+            if (!a || !b)
+                return false;
+            if (a.size !== b.size)
+                return false;
+            for (const v of a)
+                if (!b.has(v))
+                    return false;
+            return true;
+        };
+        const reemitCandidates = new Set([
+            ...Array.from(prevOutgoing.keys()),
+            ...Array.from(nextOutgoing.keys()),
+        ]);
+        for (const nodeId of reemitCandidates) {
+            const prev = prevOutgoing.get(nodeId);
+            const next = nextOutgoing.get(nodeId);
+            if (!setsEqual(prev, next))
+                this.reemitNodeOutputs(nodeId);
         }
     }
 }