@bian-womp/spark-graph 0.2.10 → 0.2.12

package/lib/cjs/index.cjs

@@ -409,6 +409,10 @@ class GraphRuntime {
         this.listeners = new Map();
         this.environment = {};
         this.paused = false;
+        // For array-typed target inputs, keep per-edge contributions so successive runs
+        // from the same source replace their slice instead of accumulating forever.
+        // Structure: nodeId -> handle -> edgeId -> values[]
+        this.arrayInputBuckets = new Map();
     }
     // Shallow/deep-ish equality to avoid unnecessary runs on identical values
     valuesEqual(a, b) {
@@ -842,11 +846,31 @@ class GraphRuntime {
                     return;
                 const dstIsArray = typeof e.dstDeclared === "string" && e.dstDeclared.endsWith("[]");
                 let next = v;
-                // If target input is an array type, append incoming values instead of last-write wins
+                // If target input is an array type, merge per-edge contributions deterministically
                 if (dstIsArray) {
                     const toArray = (x) => Array.isArray(x) ? x : x === undefined ? [] : [x];
-                    const prev = dstNode.inputs[e.target.handle];
-                    const merged = [...toArray(prev), ...toArray(v)];
+                    // Update this edge's contribution
+                    let forNode = this.arrayInputBuckets.get(e.target.nodeId);
+                    if (!forNode) {
+                        forNode = new Map();
+                        this.arrayInputBuckets.set(e.target.nodeId, forNode);
+                    }
+                    let forHandle = forNode.get(e.target.handle);
+                    if (!forHandle) {
+                        forHandle = new Map();
+                        forNode.set(e.target.handle, forHandle);
+                    }
+                    forHandle.set(e.id, toArray(v));
+                    // Compute merged array in the order of current edges list
+                    const merged = [];
+                    for (const ed of this.edges) {
+                        if (ed.target.nodeId === e.target.nodeId &&
+                            ed.target.handle === e.target.handle) {
+                            const part = forHandle.get(ed.id);
+                            if (part && part.length)
+                                merged.push(...part);
+                        }
+                    }
                     next = merged;
                 }
                 const prev = dstNode.inputs[e.target.handle];
@@ -997,6 +1021,7 @@ class GraphRuntime {
         this.nodes.clear();
         this.edges = [];
         this.listeners.clear();
+        this.arrayInputBuckets.clear();
     }
     getNodeIds() {
         return Array.from(this.nodes.keys());
@@ -1054,6 +1079,60 @@ class GraphRuntime {
     __unsafe_scheduleInputsChanged(nodeId) {
         this.scheduleInputsChanged(nodeId);
     }
+    // Hydrate inputs/outputs without triggering computation; optionally re-emit outputs downstream
+    hydrate(payload, opts) {
+        const prevPaused = this.paused;
+        this.paused = true;
+        try {
+            const ins = payload?.inputs || {};
+            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 || {})) {
+                    node.inputs[h] =
+                        typeof structuredClone === "function"
+                            ? structuredClone(v)
+                            : JSON.parse(JSON.stringify(v));
+                    // emit input value event
+                    this.emit("value", {
+                        nodeId,
+                        handle: h,
+                        value: node.inputs[h],
+                        io: "input",
+                        runtimeTypeId: getTypedOutputTypeId(node.inputs[h]),
+                    });
+                }
+            }
+            const outs = payload?.outputs || {};
+            for (const [nodeId, map] of Object.entries(outs)) {
+                const node = this.nodes.get(nodeId);
+                if (!node)
+                    continue;
+                for (const [h, v] of Object.entries(map || {})) {
+                    node.outputs[h] =
+                        typeof structuredClone === "function"
+                            ? structuredClone(v)
+                            : JSON.parse(JSON.stringify(v));
+                    // emit output value event
+                    this.emit("value", {
+                        nodeId,
+                        handle: h,
+                        value: node.outputs[h],
+                        io: "output",
+                        runtimeTypeId: getTypedOutputTypeId(node.outputs[h]),
+                    });
+                }
+            }
+            if (opts?.reemit) {
+                for (const nodeId of this.nodes.keys())
+                    this.reemitNodeOutputs(nodeId);
+            }
+        }
+        finally {
+            this.paused = prevPaused;
+        }
+    }
     // Incrementally update nodes/edges to match new definition without full rebuild
     update(def, registry) {
         // Handle node additions and removals
@@ -1070,6 +1149,8 @@ class GraphRuntime {
                     setState: (next) => Object.assign(node.state, next),
                 });
                 this.nodes.delete(nodeId);
+                // Clear any array buckets for this node
+                this.arrayInputBuckets.delete(nodeId);
             }
         }
         // Add or update existing nodes
@@ -1247,6 +1328,16 @@ class GraphRuntime {
                         }
                     }
                 }
+                // Clear buckets for handles that lost inbound
+                const bucketsForNode = this.arrayInputBuckets.get(nodeId);
+                if (bucketsForNode) {
+                    for (const handle of Array.from(prevSet)) {
+                        if (!currSet.has(handle))
+                            bucketsForNode.delete(handle);
+                    }
+                    if (bucketsForNode.size === 0)
+                        this.arrayInputBuckets.delete(nodeId);
+                }
                 this.scheduleInputsChanged(nodeId);
             }
         }
@@ -1294,6 +1385,29 @@ class GraphRuntime {
                 }
             }
         }
+        // Prune array bucket contributions for edges that no longer exist
+        const validPerTarget = new Map();
+        for (const ed of this.edges) {
+            const m = validPerTarget.get(ed.target.nodeId) ?? new Map();
+            const s = m.get(ed.target.handle) ?? new Set();
+            s.add(ed.id);
+            m.set(ed.target.handle, s);
+            validPerTarget.set(ed.target.nodeId, m);
+        }
+        for (const [nodeId, byHandle] of Array.from(this.arrayInputBuckets)) {
+            const validHandles = validPerTarget.get(nodeId) ?? new Map();
+            for (const [handle, perEdge] of Array.from(byHandle)) {
+                const validEdgeIds = validHandles.get(handle) ?? new Set();
+                for (const edgeId of Array.from(perEdge.keys())) {
+                    if (!validEdgeIds.has(edgeId))
+                        perEdge.delete(edgeId);
+                }
+                if (perEdge.size === 0)
+                    byHandle.delete(handle);
+            }
+            if (byHandle.size === 0)
+                this.arrayInputBuckets.delete(nodeId);
+        }
     }
 }