@bian-womp/spark-graph 0.2.15 → 0.2.16

package/lib/cjs/index.cjs

@@ -406,6 +406,8 @@ class GraphRuntime {
     constructor() {
         this.nodes = new Map();
         this.edges = [];
+        // Current resolved handles per node (registry statics merged with per-node overrides)
+        this.resolvedByNode = new Map();
         this.listeners = new Map();
         this.environment = {};
         this.paused = false;
@@ -434,7 +436,7 @@ class GraphRuntime {
         const gr = new GraphRuntime();
         gr.environment = opts?.environment ?? {};
         // Precompute per-node resolved handles (use def-provided overrides; do not compute dynamically here)
-        const resolvedByNode = GraphRuntime.computeResolvedHandleMap(def, registry);
+        gr.resolvedByNode = GraphRuntime.computeResolvedHandleMap(def, registry);
         // Instantiate nodes
         for (const n of def.nodes) {
             const desc = registry.nodes.get(n.typeId);
@@ -474,7 +476,7 @@ class GraphRuntime {
             gr.nodes.set(n.nodeId, rn);
         }
         // Instantiate edges
-        gr.edges = GraphRuntime.buildEdges(def, registry, resolvedByNode);
+        gr.edges = GraphRuntime.buildEdges(def, registry, gr.resolvedByNode);
         // After nodes and edges exist, seed registry- and graph-level defaults
         for (const n of def.nodes) {
             const node = gr.nodes.get(n.nodeId);
@@ -967,6 +969,39 @@ class GraphRuntime {
             this.propagate(nodeId, handle, value);
         }
     }
+    // Update resolved handles for a single node and refresh edge converters/types that touch it
+    updateNodeHandles(nodeId, handles, registry) {
+        this.resolvedByNode.set(nodeId, handles);
+        // Recompute edge converter/type for edges where this node is source or target
+        for (const e of this.edges) {
+            let srcDeclared = e.typeId;
+            let dstDeclared = e.dstDeclared;
+            if (e.source.nodeId === nodeId) {
+                const resolved = this.resolvedByNode.get(nodeId);
+                srcDeclared = resolved
+                    ? resolved.outputs[e.source.handle]
+                    : srcDeclared;
+                // If edge had no explicit typeId, infer from updated src
+                if (!e.typeId) {
+                    e.typeId = Array.isArray(srcDeclared)
+                        ? srcDeclared?.[0]
+                        : srcDeclared;
+                }
+            }
+            if (e.target.nodeId === nodeId) {
+                const resolved = this.resolvedByNode.get(nodeId);
+                if (resolved) {
+                    dstDeclared = getInputTypeId(resolved.inputs, e.target.handle);
+                    e.dstDeclared = dstDeclared;
+                }
+            }
+            const conv = GraphRuntime.buildEdgeConverters(srcDeclared, dstDeclared, registry);
+            e.convert = conv.convert;
+            e.convertAsync = conv.convertAsync;
+        }
+        // Invalidate downstream for this node so UI refreshes
+        this.invalidateDownstream(nodeId);
+    }
     launch() {
         // call onActivated for nodes that implement it
         for (const node of this.nodes.values()) {
@@ -1260,9 +1295,9 @@ class GraphRuntime {
             prevOutTargets.set(e.source.nodeId, tmap);
         }
         // Precompute per-node resolved handles for updated graph
-        const resolvedByNode = GraphRuntime.computeResolvedHandleMap(def, registry);
+        this.resolvedByNode = GraphRuntime.computeResolvedHandleMap(def, registry);
         // Rebuild edges mapping with coercions
-        this.edges = GraphRuntime.buildEdges(def, registry, resolvedByNode);
+        this.edges = GraphRuntime.buildEdges(def, registry, this.resolvedByNode);
         // Build new inbound map
         const nextInbound = new Map();
         for (const e of this.edges) {
@@ -2635,9 +2670,9 @@ function setupBasicGraphRegistry() {
         categoryId: "compute",
         inputs: { Length: "base.float" },
         outputs: { Items: "base.object" },
-        resolveHandles: ({ params }) => {
+        resolveHandles: ({ inputs }) => {
             const maxLen = 64;
-            const raw = params?.Length;
+            const raw = inputs?.Length ?? 0;
             const n = Math.max(0, Math.min(maxLen, Math.trunc(Number(raw ?? 0))));
             if (!Number.isFinite(n))
                 return { inputs: {} };