@bian-womp/spark-graph 0.2.14 → 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;
@@ -433,6 +435,8 @@ class GraphRuntime {
     static create(def, registry, opts) {
         const gr = new GraphRuntime();
         gr.environment = opts?.environment ?? {};
+        // Precompute per-node resolved handles (use def-provided overrides; do not compute dynamically here)
+        gr.resolvedByNode = GraphRuntime.computeResolvedHandleMap(def, registry);
         // Instantiate nodes
         for (const n of def.nodes) {
             const desc = registry.nodes.get(n.typeId);
@@ -472,46 +476,7 @@ class GraphRuntime {
             gr.nodes.set(n.nodeId, rn);
         }
         // Instantiate edges
-        gr.edges = def.edges.map((e) => {
-            // infer type from source output if missing
-            const srcNode = def.nodes.find((n) => n.nodeId === e.source.nodeId);
-            const dstNode = def.nodes.find((n) => n.nodeId === e.target.nodeId);
-            let effectiveTypeId = e.typeId;
-            let srcDeclared;
-            let dstDeclared;
-            if (srcNode) {
-                const srcDesc = registry.nodes.get(srcNode.typeId);
-                if (srcDesc) {
-                    srcDeclared = srcDesc.outputs[e.source.handle];
-                }
-            }
-            if (!effectiveTypeId) {
-                effectiveTypeId = Array.isArray(srcDeclared)
-                    ? srcDeclared[0]
-                    : srcDeclared;
-            }
-            if (dstNode) {
-                const dstDesc = registry.nodes.get(dstNode.typeId);
-                if (dstDesc) {
-                    dstDeclared = getInputTypeId(dstDesc.inputs, e.target.handle);
-                }
-            }
-            // Attach dynamic convert/convertAsync aware of union sources and typed outputs
-            const { convert, convertAsync } = GraphRuntime.buildEdgeConverters(srcDeclared, dstDeclared, registry);
-            return {
-                id: e.id,
-                source: { ...e.source },
-                target: { ...e.target },
-                typeId: effectiveTypeId ?? "untyped",
-                convert,
-                convertAsync,
-                srcUnionTypes: Array.isArray(srcDeclared)
-                    ? [...srcDeclared]
-                    : undefined,
-                dstDeclared,
-                stats: { runs: 0, inFlight: false, progress: 0 },
-            };
-        });
+        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);
@@ -941,6 +906,61 @@ class GraphRuntime {
             }
         }
     }
+    // Helper: build map of resolved handles per node from def (prefer def.resolvedHandles, otherwise registry statics)
+    static computeResolvedHandleMap(def, registry) {
+        const out = new Map();
+        for (const n of def.nodes) {
+            const desc = registry.nodes.get(n.typeId);
+            if (!desc)
+                continue;
+            const overrideInputs = n.resolvedHandles?.inputs;
+            const overrideOutputs = n.resolvedHandles?.outputs;
+            // Merge base with overrides (allow partial resolvedHandles)
+            const inputs = { ...desc.inputs, ...overrideInputs };
+            const outputs = { ...desc.outputs, ...overrideOutputs };
+            out.set(n.nodeId, { inputs, outputs });
+        }
+        return out;
+    }
+    // Helper: build runtime edges with coercions using resolved handles
+    static buildEdges(def, registry, resolvedByNode) {
+        return def.edges.map((e) => {
+            const srcNode = def.nodes.find((n) => n.nodeId === e.source.nodeId);
+            const dstNode = def.nodes.find((n) => n.nodeId === e.target.nodeId);
+            let effectiveTypeId = e.typeId;
+            let srcDeclared;
+            let dstDeclared;
+            if (srcNode) {
+                const resolved = resolvedByNode.get(srcNode.nodeId);
+                if (resolved)
+                    srcDeclared = resolved.outputs[e.source.handle];
+            }
+            if (!effectiveTypeId) {
+                effectiveTypeId = Array.isArray(srcDeclared)
+                    ? srcDeclared[0]
+                    : srcDeclared;
+            }
+            if (dstNode) {
+                const resolved = resolvedByNode.get(dstNode.nodeId);
+                if (resolved)
+                    dstDeclared = getInputTypeId(resolved.inputs, e.target.handle);
+            }
+            const { convert, convertAsync } = GraphRuntime.buildEdgeConverters(srcDeclared, dstDeclared, registry);
+            return {
+                id: e.id,
+                source: { ...e.source },
+                target: { ...e.target },
+                typeId: effectiveTypeId ?? "untyped",
+                convert,
+                convertAsync,
+                srcUnionTypes: Array.isArray(srcDeclared)
+                    ? [...srcDeclared]
+                    : undefined,
+                dstDeclared,
+                stats: { runs: 0, inFlight: false, progress: 0 },
+            };
+        });
+    }
     reemitNodeOutputs(nodeId) {
         const node = this.nodes.get(nodeId);
         if (!node)
@@ -949,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()) {
@@ -1241,42 +1294,10 @@ class GraphRuntime {
             tmap.set(e.source.handle, tset);
             prevOutTargets.set(e.source.nodeId, tmap);
         }
+        // Precompute per-node resolved handles for updated graph
+        this.resolvedByNode = GraphRuntime.computeResolvedHandleMap(def, registry);
         // Rebuild edges mapping with coercions
-        this.edges = def.edges.map((e) => {
-            const srcNode = def.nodes.find((nn) => nn.nodeId === e.source.nodeId);
-            const dstNode = def.nodes.find((nn) => nn.nodeId === e.target.nodeId);
-            let effectiveTypeId = e.typeId;
-            let srcDeclared;
-            let dstDeclared;
-            if (srcNode) {
-                const srcDesc = registry.nodes.get(srcNode.typeId);
-                if (srcDesc) {
-                    srcDeclared = srcDesc.outputs[e.source.handle];
-                }
-            }
-            if (!effectiveTypeId) {
-                effectiveTypeId = Array.isArray(srcDeclared)
-                    ? srcDeclared[0]
-                    : srcDeclared;
-            }
-            if (dstNode) {
-                const dstDesc = registry.nodes.get(dstNode.typeId);
-                if (dstDesc) {
-                    dstDeclared = getInputTypeId(dstDesc.inputs, e.target.handle);
-                }
-            }
-            const { convert, convertAsync } = GraphRuntime.buildEdgeConverters(srcDeclared, dstDeclared, registry);
-            return {
-                id: e.id,
-                source: { ...e.source },
-                target: { ...e.target },
-                typeId: effectiveTypeId ?? "untyped",
-                convert,
-                convertAsync,
-                dstDeclared,
-                stats: { runs: 0, inFlight: false, progress: 0 },
-            };
-        });
+        this.edges = GraphRuntime.buildEdges(def, registry, this.resolvedByNode);
         // Build new inbound map
         const nextInbound = new Map();
         for (const e of this.edges) {
@@ -2643,6 +2664,31 @@ function setupBasicGraphRegistry() {
             return { Result: arr.slice(s, e) };
         },
     });
+    // Compose array from dynamic item inputs
+    registry.registerNode({
+        id: "base.array.compose",
+        categoryId: "compute",
+        inputs: { Length: "base.float" },
+        outputs: { Items: "base.object" },
+        resolveHandles: ({ inputs }) => {
+            const maxLen = 64;
+            const raw = inputs?.Length ?? 0;
+            const n = Math.max(0, Math.min(maxLen, Math.trunc(Number(raw ?? 0))));
+            if (!Number.isFinite(n))
+                return { inputs: {} };
+            const dyn = {};
+            for (let i = 0; i < n; i++)
+                dyn[`Item${i}`] = { typeId: "base.object" };
+            return { inputs: dyn };
+        },
+        inputDefaults: { Length: 0 },
+        impl: (ins) => {
+            const length = Math.max(0, Math.trunc(Number(ins.Length ?? 0)));
+            if (!Number.isFinite(length))
+                return { Items: [] };
+            return { Items: Array.from({ length }, (_, i) => ins[`Item${i}`]) };
+        },
+    });
     // Select
     registry.registerNode({
         id: "base.select",