@bian-womp/spark-graph 0.2.15 → 0.2.17

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) {
@@ -1405,35 +1440,56 @@ class GraphBuilder {
         const issues = [];
         const nodeIds = new Set();
         const edgeIds = new Set();
+        // Precompute effective handle maps (registry statics merged with per-node resolvedHandles)
+        const nodeById = new Map();
+        const effByNodeId = new Map();
+        const getEffectiveHandles = (n) => {
+            if (!n)
+                return { inputs: {}, outputs: {} };
+            const desc = this.registry.nodes.get(n.typeId);
+            const resolved = n.resolvedHandles || {};
+            const inputs = { ...desc?.inputs, ...resolved.inputs };
+            const outputs = { ...desc?.outputs, ...resolved.outputs };
+            return { inputs, outputs };
+        };
+        const normOut = (decl) => Array.isArray(decl) ? decl : decl ? [decl] : [];
+        const inferEdgeType = (srcDeclared, dstDeclared, explicit) => {
+            if (explicit)
+                return explicit;
+            if (Array.isArray(srcDeclared) && dstDeclared)
+                return dstDeclared;
+            if (srcDeclared)
+                return Array.isArray(srcDeclared) ? srcDeclared[0] : srcDeclared;
+            return undefined;
+        };
+        const canFlow = (from, to) => {
+            if (!to || !from)
+                return true;
+            const arr = Array.isArray(from) ? from : [from];
+            return arr.every((s) => s === to || !!this.registry.canCoerce(s, to));
+        };
+        const pushIssue = (level, code, message, data) => {
+            issues.push({ level, code, message, data });
+        };
         // nodes exist, ids unique, and categories registered
         for (const n of def.nodes) {
             if (nodeIds.has(n.nodeId)) {
-                issues.push({
-                    level: "error",
-                    code: "NODE_ID_DUP",
-                    message: `Duplicate nodeId ${n.nodeId}`,
-                    data: { nodeId: n.nodeId },
+                pushIssue("error", "NODE_ID_DUP", `Duplicate nodeId ${n.nodeId}`, {
+                    nodeId: n.nodeId,
                 });
             }
             else {
                 nodeIds.add(n.nodeId);
             }
+            nodeById.set(n.nodeId, n);
+            effByNodeId.set(n.nodeId, getEffectiveHandles(n));
             const nodeType = this.registry.nodes.get(n.typeId);
             if (!nodeType) {
-                issues.push({
-                    level: "error",
-                    code: "NODE_TYPE_MISSING",
-                    message: `Unknown node type ${n.typeId}`,
-                    data: { typeId: n.typeId, nodeId: n.nodeId },
-                });
+                pushIssue("error", "NODE_TYPE_MISSING", `Unknown node type ${n.typeId}`, { typeId: n.typeId, nodeId: n.nodeId });
                 continue;
             }
             if (!this.registry.categories.has(nodeType.categoryId)) {
-                issues.push({
-                    level: "error",
-                    code: "CATEGORY_MISSING",
-                    message: `Unknown category ${nodeType.categoryId} for node type ${n.typeId}`,
-                });
+                pushIssue("error", "CATEGORY_MISSING", `Unknown category ${nodeType.categoryId} for node type ${n.typeId}`);
             }
         }
         // edges validation: nodes exist, handles exist, type exists
@@ -1442,186 +1498,96 @@ class GraphBuilder {
         const inboundArrayOk = new Set();
         for (const e of def.edges) {
             if (edgeIds.has(e.id)) {
-                issues.push({
-                    level: "error",
-                    code: "EDGE_ID_DUP",
-                    message: `Duplicate edge id ${e.id}`,
-                    data: { edgeId: e.id },
+                pushIssue("error", "EDGE_ID_DUP", `Duplicate edge id ${e.id}`, {
+                    edgeId: e.id,
                 });
             }
             else {
                 edgeIds.add(e.id);
             }
-            const srcNode = def.nodes.find((nn) => nn.nodeId === e.source.nodeId);
-            const dstNode = def.nodes.find((nn) => nn.nodeId === e.target.nodeId);
+            const srcNode = nodeById.get(e.source.nodeId);
+            const dstNode = nodeById.get(e.target.nodeId);
             if (!srcNode)
-                issues.push({
-                    level: "error",
-                    code: "EDGE_SOURCE_MISSING",
-                    message: `Edge ${e.id} source node missing`,
-                    data: { edgeId: e.id },
+                pushIssue("error", "EDGE_SOURCE_MISSING", `Edge ${e.id} source node missing`, {
+                    edgeId: e.id,
                 });
             if (!dstNode)
-                issues.push({
-                    level: "error",
-                    code: "EDGE_TARGET_MISSING",
-                    message: `Edge ${e.id} target node missing`,
-                    data: { edgeId: e.id },
+                pushIssue("error", "EDGE_TARGET_MISSING", `Edge ${e.id} target node missing`, {
+                    edgeId: e.id,
                 });
-            // Infer edge type when missing. For union sources, prefer target input type if available.
-            let effectiveTypeId = e.typeId;
-            let _srcDeclared;
-            let _dstDeclared;
-            if (srcNode) {
-                const srcType = this.registry.nodes.get(srcNode.typeId);
-                if (srcType)
-                    _srcDeclared = srcType.outputs[e.source.handle];
-            }
-            if (dstNode) {
-                const dstType = this.registry.nodes.get(dstNode.typeId);
-                if (dstType)
-                    _dstDeclared = getInputTypeId(dstType.inputs, e.target.handle);
-            }
-            if (!effectiveTypeId) {
-                if (Array.isArray(_srcDeclared) && _dstDeclared) {
-                    // When source is a union and target input type is known, adopt the input type
-                    // so validation checks are performed against the target, not an arbitrary variant.
-                    effectiveTypeId = _dstDeclared;
-                }
-                else if (_srcDeclared) {
-                    effectiveTypeId = Array.isArray(_srcDeclared)
-                        ? _srcDeclared[0]
-                        : _srcDeclared;
-                }
-            }
+            // Effective handle declarations
+            const srcEff = effByNodeId.get(e.source.nodeId) || {
+                outputs: {},
+            };
+            const dstEff = effByNodeId.get(e.target.nodeId) || {
+                inputs: {}};
+            const _srcDeclared = srcNode
+                ? srcEff.outputs[e.source.handle]
+                : undefined;
+            const _dstDeclared = dstNode
+                ? getInputTypeId(dstEff.inputs, e.target.handle)
+                : undefined;
+            // Effective edge type
+            const effectiveTypeId = inferEdgeType(_srcDeclared, _dstDeclared, e.typeId);
             const type = effectiveTypeId
                 ? this.registry.types.get(effectiveTypeId)
                 : undefined;
             if (!type) {
-                issues.push({
-                    level: "error",
-                    code: "TYPE_MISSING",
-                    message: `Edge ${e.id} type missing or unknown`,
-                    data: { edgeId: e.id },
+                pushIssue("error", "TYPE_MISSING", `Edge ${e.id} type missing or unknown`, {
+                    edgeId: e.id,
                 });
             }
             if (srcNode) {
-                const srcType = this.registry.nodes.get(srcNode.typeId);
-                if (srcType && !(e.source.handle in srcType.outputs)) {
-                    issues.push({
-                        level: "error",
-                        code: "OUTPUT_MISSING",
-                        message: `Edge ${e.id} source output ${e.source.handle} missing on ${srcNode.typeId}`,
-                        data: {
-                            edgeId: e.id,
-                            nodeId: srcNode.nodeId,
-                            output: e.source.handle,
-                        },
-                    });
+                if (!(e.source.handle in srcEff.outputs)) {
+                    pushIssue("error", "OUTPUT_MISSING", `Edge ${e.id} source output ${e.source.handle} missing on ${srcNode.typeId}`, { edgeId: e.id, nodeId: srcNode.nodeId, output: e.source.handle });
                 }
-                if (srcType) {
-                    const declared = srcType.outputs[e.source.handle];
-                    const declaredArr = Array.isArray(declared)
-                        ? declared
-                        : declared
-                            ? [declared]
-                            : [];
-                    if (declaredArr.length > 0 && effectiveTypeId) {
-                        for (const s of declaredArr) {
-                            if (s !== effectiveTypeId &&
-                                !this.registry.canCoerce(s, effectiveTypeId)) {
-                                issues.push({
-                                    level: "error",
-                                    code: "TYPE_MISMATCH_OUTPUT",
-                                    message: `Edge ${e.id} type ${effectiveTypeId} mismatches source output ${srcNode.typeId}.${e.source.handle} (${s}) and no coercion exists`,
-                                    data: {
-                                        edgeId: e.id,
-                                        nodeId: srcNode.nodeId,
-                                        output: e.source.handle,
-                                        declared: s,
-                                        effectiveTypeId,
-                                    },
-                                });
-                            }
-                        }
-                    }
+                const declaredArr = normOut(srcEff.outputs[e.source.handle]);
+                if (declaredArr.length > 0 &&
+                    effectiveTypeId &&
+                    !canFlow(declaredArr, effectiveTypeId)) {
+                    pushIssue("error", "TYPE_MISMATCH_OUTPUT", `Edge ${e.id} type ${effectiveTypeId} mismatches source output ${srcNode.typeId}.${e.source.handle} (${declaredArr.join("|")}) and no coercion exists`, {
+                        edgeId: e.id,
+                        nodeId: srcNode.nodeId,
+                        output: e.source.handle,
+                        declared: declaredArr.join("|"),
+                        effectiveTypeId,
+                    });
                 }
             }
             if (dstNode) {
-                const dstType = this.registry.nodes.get(dstNode.typeId);
-                if (dstType && !(e.target.handle in dstType.inputs)) {
-                    issues.push({
-                        level: "error",
-                        code: "INPUT_MISSING",
-                        message: `Edge ${e.id} target input ${e.target.handle} missing on ${dstNode.typeId}`,
-                        data: {
-                            edgeId: e.id,
-                            nodeId: dstNode.nodeId,
-                            input: e.target.handle,
-                        },
-                    });
+                if (!(e.target.handle in dstEff.inputs)) {
+                    pushIssue("error", "INPUT_MISSING", `Edge ${e.id} target input ${e.target.handle} missing on ${dstNode.typeId}`, { edgeId: e.id, nodeId: dstNode.nodeId, input: e.target.handle });
                 }
-                if (dstType) {
-                    // Private inputs should not accept edges
-                    if (isInputPrivate(dstType.inputs, e.target.handle)) {
-                        issues.push({
-                            level: "error",
-                            code: "INPUT_PRIVATE",
-                            message: `Edge ${e.id} targets private input ${dstNode.typeId}.${e.target.handle}`,
-                            data: {
+                // Private inputs should not accept edges
+                if (isInputPrivate(dstEff.inputs, e.target.handle)) {
+                    pushIssue("error", "INPUT_PRIVATE", `Edge ${e.id} targets private input ${dstNode.typeId}.${e.target.handle}`, { edgeId: e.id, nodeId: dstNode.nodeId, input: e.target.handle });
+                }
+                const declaredIn = getInputTypeId(dstEff.inputs, e.target.handle);
+                if (declaredIn && effectiveTypeId) {
+                    if (srcNode) {
+                        const srcDeclared = srcEff.outputs[e.source.handle];
+                        const srcArr = normOut(srcDeclared).length
+                            ? normOut(srcDeclared)
+                            : [effectiveTypeId];
+                        if (!canFlow(srcArr, declaredIn)) {
+                            pushIssue("error", "TYPE_MISMATCH_INPUT", `Edge ${e.id} output type ${srcArr.join("|")} not convertible to target input ${dstNode.typeId}.${e.target.handle} (${declaredIn})`, {
                                 edgeId: e.id,
                                 nodeId: dstNode.nodeId,
                                 input: e.target.handle,
-                            },
-                        });
-                    }
-                    const declaredIn = getInputTypeId(dstType.inputs, e.target.handle);
-                    if (declaredIn && effectiveTypeId) {
-                        // If source is a union, ensure each variant can reach declaredIn
-                        if (srcNode) {
-                            const srcType = this.registry.nodes.get(srcNode.typeId);
-                            const srcDeclared = srcType?.outputs[e.source.handle];
-                            const srcArr = Array.isArray(srcDeclared)
-                                ? srcDeclared
-                                : srcDeclared
-                                    ? [srcDeclared]
-                                    : effectiveTypeId
-                                        ? [effectiveTypeId]
-                                        : [];
-                            for (const s of srcArr) {
-                                if (s !== declaredIn &&
-                                    !this.registry.canCoerce(s, declaredIn)) {
-                                    issues.push({
-                                        level: "error",
-                                        code: "TYPE_MISMATCH_INPUT",
-                                        message: `Edge ${e.id} output type ${s} not convertible to target input ${dstNode.typeId}.${e.target.handle} (${declaredIn})`,
-                                        data: {
-                                            edgeId: e.id,
-                                            nodeId: dstNode.nodeId,
-                                            input: e.target.handle,
-                                            declared: declaredIn,
-                                            effectiveTypeId: s,
-                                        },
-                                    });
-                                }
-                            }
-                        }
-                        else if (declaredIn !== effectiveTypeId &&
-                            !this.registry.canCoerce(effectiveTypeId, declaredIn)) {
-                            issues.push({
-                                level: "error",
-                                code: "TYPE_MISMATCH_INPUT",
-                                message: `Edge ${e.id} type ${effectiveTypeId} mismatches target input ${dstNode.typeId}.${e.target.handle} (${declaredIn}) and no coercion exists`,
-                                data: {
-                                    edgeId: e.id,
-                                    nodeId: dstNode.nodeId,
-                                    input: e.target.handle,
-                                    declared: declaredIn,
-                                    effectiveTypeId,
-                                },
+                                declared: declaredIn,
+                                effectiveTypeId: srcArr.join("|"),
                             });
                         }
                     }
+                    else if (!canFlow(effectiveTypeId, declaredIn)) {
+                        pushIssue("error", "TYPE_MISMATCH_INPUT", `Edge ${e.id} type ${effectiveTypeId} mismatches target input ${dstNode.typeId}.${e.target.handle} (${declaredIn}) and no coercion exists`, {
+                            edgeId: e.id,
+                            nodeId: dstNode.nodeId,
+                            input: e.target.handle,
+                            declared: declaredIn,
+                            effectiveTypeId,
+                        });
+                    }
                 }
             }
             // Track multiple inbound edges targeting the same input handle
@@ -1629,10 +1595,7 @@ class GraphBuilder {
             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;
+                const declaredIn = getInputTypeId((effByNodeId.get(dstNode.nodeId) || { inputs: {} }).inputs, e.target.handle);
                 if (typeof declaredIn === "string" && declaredIn.endsWith("[]")) {
                     inboundArrayOk.add(inboundKey);
                 }
@@ -2635,9 +2598,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: {} };