@bian-womp/spark-graph 0.2.9 → 0.2.11

package/lib/cjs/index.cjs

@@ -504,6 +504,7 @@ class GraphRuntime {
                 srcUnionTypes: Array.isArray(srcDeclared)
                     ? [...srcDeclared]
                     : undefined,
+                dstDeclared,
                 stats: { runs: 0, inFlight: false, progress: 0 },
             };
         });
@@ -839,17 +840,26 @@ class GraphRuntime {
                 const dstNode = this.nodes.get(e.target.nodeId);
                 if (!dstNode)
                     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 (dstIsArray) {
+                    const toArray = (x) => Array.isArray(x) ? x : x === undefined ? [] : [x];
+                    const prev = dstNode.inputs[e.target.handle];
+                    const merged = [...toArray(prev), ...toArray(v)];
+                    next = merged;
+                }
                 const prev = dstNode.inputs[e.target.handle];
-                const same = this.valuesEqual(prev, v);
+                const same = this.valuesEqual(prev, next);
                 if (!same) {
-                    dstNode.inputs[e.target.handle] = v;
+                    dstNode.inputs[e.target.handle] = next;
                     // Emit value event for input updates
                     this.emit("value", {
                         nodeId: e.target.nodeId,
                         handle: e.target.handle,
-                        value: v,
+                        value: next,
                         io: "input",
-                        runtimeTypeId: getTypedOutputTypeId(v),
+                        runtimeTypeId: getTypedOutputTypeId(next),
                     });
                     if (!this.paused && this.allInboundHaveValue(e.target.nodeId))
                         this.scheduleInputsChanged(e.target.nodeId);
@@ -1044,6 +1054,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
@@ -1182,6 +1246,7 @@ class GraphRuntime {
                 typeId: effectiveTypeId ?? "untyped",
                 convert,
                 convertAsync,
+                dstDeclared,
                 stats: { runs: 0, inFlight: false, progress: 0 },
             };
         });
@@ -1327,6 +1392,8 @@ class GraphBuilder {
         }
         // edges validation: nodes exist, handles exist, type exists
         const inboundCounts = new Map();
+        // Track which inbound (nodeId::handle) are declared as array inputs, to allow multi-inbound without warning
+        const inboundArrayOk = new Set();
         for (const e of def.edges) {
             if (edgeIds.has(e.id)) {
                 issues.push({
@@ -1367,7 +1434,7 @@ class GraphBuilder {
             if (dstNode) {
                 const dstType = this.registry.nodes.get(dstNode.typeId);
                 if (dstType)
-                    _dstDeclared = dstType.inputs[e.target.handle];
+                    _dstDeclared = getInputTypeId(dstType.inputs, e.target.handle);
             }
             if (!effectiveTypeId) {
                 if (Array.isArray(_srcDeclared) && _dstDeclared) {
@@ -1514,9 +1581,19 @@ class GraphBuilder {
             // Track multiple inbound edges targeting the same input handle
             const inboundKey = `${e.target.nodeId}::${e.target.handle}`;
             inboundCounts.set(inboundKey, (inboundCounts.get(inboundKey) ?? 0) + 1);
+            // If the target input is declared as an array type, allow multi-inbound (runtime will append)
+            if (dstNode) {
+                const dstType = this.registry.nodes.get(dstNode.typeId);
+                const declaredIn = dstType
+                    ? getInputTypeId(dstType.inputs, e.target.handle)
+                    : undefined;
+                if (typeof declaredIn === "string" && declaredIn.endsWith("[]")) {
+                    inboundArrayOk.add(inboundKey);
+                }
+            }
         }
         for (const [key, count] of inboundCounts) {
-            if (count > 1) {
+            if (count > 1 && !inboundArrayOk.has(key)) {
                 issues.push({
                     level: "warning",
                     code: "MULTI_INBOUND",