@bian-womp/spark-graph 0.2.14 → 0.2.15

package/lib/cjs/index.cjs

@@ -433,6 +433,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)
+        const resolvedByNode = GraphRuntime.computeResolvedHandleMap(def, registry);
         // Instantiate nodes
         for (const n of def.nodes) {
             const desc = registry.nodes.get(n.typeId);
@@ -472,46 +474,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, 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 +904,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)
@@ -1241,42 +1259,10 @@ class GraphRuntime {
             tmap.set(e.source.handle, tset);
             prevOutTargets.set(e.source.nodeId, tmap);
         }
+        // Precompute per-node resolved handles for updated graph
+        const 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, resolvedByNode);
         // Build new inbound map
         const nextInbound = new Map();
         for (const e of this.edges) {
@@ -2643,6 +2629,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: ({ params }) => {
+            const maxLen = 64;
+            const raw = params?.Length;
+            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",