@bian-womp/spark-graph 0.2.43 → 0.2.45

package/lib/cjs/index.cjs

@@ -846,10 +846,7 @@ class GraphRuntime {
             if (dynamicHandles.has(handle))
                 continue; // Skip defaults for dynamic handles
             // Clone to avoid shared references
-            effective[handle] =
-                typeof structuredClone === "function"
-                    ? structuredClone(defaultValue)
-                    : JSON.parse(JSON.stringify(defaultValue));
+            effective[handle] = structuredClone(defaultValue);
         }
         return effective;
     }
@@ -1266,10 +1263,7 @@ class GraphRuntime {
                 const hasInbound = this.edges.some((e) => e.target.nodeId === n.nodeId && e.target.handle === handle);
                 if (!hasInbound && value !== undefined) {
                     // Clone to avoid shared references
-                    initialInputs[handle] =
-                        typeof structuredClone === "function"
-                            ? structuredClone(value)
-                            : JSON.parse(JSON.stringify(value));
+                    initialInputs[handle] = structuredClone(value);
                 }
             }
             return {
@@ -1328,30 +1322,12 @@ class GraphRuntime {
         this.paused = true;
         try {
             const ins = payload?.inputs || {};
-            const outsPayload = payload?.outputs || {};
             for (const [nodeId, map] of Object.entries(ins)) {
                 const node = this.nodes.get(nodeId);
                 if (!node)
                     continue;
                 for (const [h, v] of Object.entries(map || {})) {
-                    // If this handle has inbound wiring, prefer upstream outputs from snapshot to populate it.
-                    // Fallback: if not all upstream output values are present in the snapshot, hydrate the saved input
-                    // so the initial view matches last saved state (important for array inputs with multiple edges).
-                    const inboundEdges = this.edges.filter((e) => e.target.nodeId === nodeId && e.target.handle === h);
-                    if (inboundEdges.length > 0) {
-                        // Check if ALL upstream outputs exist in snapshot (required for correct array input restoration)
-                        const allUpstreamOutputsExist = inboundEdges.every((e) => {
-                            const srcMap = outsPayload[e.source.nodeId] || {};
-                            return Object.prototype.hasOwnProperty.call(srcMap, e.source.handle);
-                        });
-                        // Only skip input hydration if all upstream outputs are present (re-emit will populate correctly)
-                        if (allUpstreamOutputsExist)
-                            continue;
-                    }
-                    node.inputs[h] =
-                        typeof structuredClone === "function"
-                            ? structuredClone(v)
-                            : JSON.parse(JSON.stringify(v));
+                    node.inputs[h] = structuredClone(v);
                     // emit input value event
                     this.emit("value", {
                         nodeId,
@@ -1368,10 +1344,7 @@ class GraphRuntime {
                 if (!node)
                     continue;
                 for (const [h, v] of Object.entries(map || {})) {
-                    node.outputs[h] =
-                        typeof structuredClone === "function"
-                            ? structuredClone(v)
-                            : JSON.parse(JSON.stringify(v));
+                    node.outputs[h] = structuredClone(v);
                     // emit output value event
                     this.emit("value", {
                         nodeId,
@@ -1506,6 +1479,15 @@ class GraphRuntime {
         }
         // Precompute per-node resolved handles for updated graph (include dynamic)
         const resolved = GraphRuntime.computeResolvedHandleMap(def, registry, this.environment);
+        // Check which handles changed and emit events for those
+        const changedHandles = {};
+        for (const [nodeId, newHandles] of resolved.map) {
+            const oldHandles = this.resolvedByNode.get(nodeId);
+            if (!oldHandles ||
+                JSON.stringify(oldHandles) !== JSON.stringify(newHandles)) {
+                changedHandles[nodeId] = newHandles;
+            }
+        }
         this.resolvedByNode = resolved.map;
         // Rebuild edges mapping with coercions
         this.edges = GraphRuntime.buildEdges(def, registry, this.resolvedByNode);
@@ -1613,8 +1595,16 @@ class GraphRuntime {
                 this.arrayInputBuckets.delete(nodeId);
         }
         // Schedule async recompute for nodes that indicated Promise-based resolveHandles in this update
-        for (const nodeId of resolved.pending)
+        // Emit event for changed handles (if any)
+        if (Object.keys(changedHandles).length > 0) {
+            this.emit("invalidate", {
+                reason: "graph-updated",
+                resolvedHandles: changedHandles,
+            });
+        }
+        for (const nodeId of resolved.pending) {
             this.scheduleRecomputeHandles(nodeId);
+        }
     }
     // Schedule a recomputation of dynamic handles for a node (async to avoid mutating during propagation)
     scheduleRecomputeHandles(nodeId) {
@@ -1667,8 +1657,11 @@ class GraphRuntime {
             return;
         this.resolvedByNode.set(nodeId, next);
         this.updateNodeHandles(nodeId, next, registry);
-        // Notify graph updated for UI parity
-        this.emit("invalidate", { reason: "graph-updated" });
+        // Notify graph updated with the changed handles
+        this.emit("invalidate", {
+            reason: "graph-updated",
+            resolvedHandles: { [nodeId]: next },
+        });
     }
 }