@bian-womp/spark-graph 0.2.58 → 0.2.60

package/lib/cjs/index.cjs

@@ -582,7 +582,7 @@ class GraphRuntime {
         const node = this.nodes.get(nodeId);
         return node?.outputs[output];
     }
-    static buildEdgeConverters(srcDeclared, dstDeclared, registry) {
+    static buildEdgeConverters(srcDeclared, dstDeclared, registry, edgeLabel) {
         if (!dstDeclared || !srcDeclared) {
             return {};
         }
@@ -601,15 +601,15 @@ class GraphRuntime {
             const payload = getTypedOutputValue(v);
             if (isUnion) {
                 if (!typeId) {
-                    throw new Error(`Typed output required for union source; allowed: ${srcTypes.join("|")}`);
+                    throw new Error(`Typed output required for union source (${edgeLabel}); allowed: ${srcTypes.join("|")}`);
                 }
                 if (!srcTypes.includes(typeId)) {
-                    throw new Error(`Invalid typed output ${typeId}; allowed: ${srcTypes.join("|")}`);
+                    throw new Error(`Invalid typed output ${typeId} (${edgeLabel}); allowed: ${srcTypes.join("|")}`);
                 }
             }
             else if (typeId) {
                 // Warn if typed output is used for non-union source
-                console.warn(`Typed output ${typeId} is fed even though source is not union: ${srcDeclared} -> ${dstDeclared}`);
+                console.warn(`Typed output ${typeId} is fed even though source is not union (${edgeLabel}): ${srcDeclared} -> ${dstDeclared}`);
             }
             return { typeId: typeId || srcTypes[0], payload };
         };
@@ -639,7 +639,7 @@ class GraphRuntime {
                 if (!res)
                     return payload;
                 if (res.kind === "async") {
-                    throw new Error("Async coercion required but convert used");
+                    throw new Error(`Async coercion required but convert used (${edgeLabel})`);
                 }
                 return res.convert(payload);
             },
@@ -1138,7 +1138,7 @@ class GraphRuntime {
                 if (resolved)
                     dstDeclared = getInputTypeId(resolved.inputs, e.target.handle);
             }
-            const { convert, convertAsync } = GraphRuntime.buildEdgeConverters(srcDeclared, dstDeclared, registry);
+            const { convert, convertAsync } = GraphRuntime.buildEdgeConverters(srcDeclared, dstDeclared, registry, `buildEdges: ${srcNode?.typeId || ""}.${e.source.nodeId}.${e.source.handle} -> ${dstNode?.typeId || ""}.${e.target.nodeId}.${e.target.handle}`);
             return {
                 id: e.id,
                 source: { ...e.source },
@@ -1168,6 +1168,8 @@ class GraphRuntime {
         this.resolvedByNode.set(nodeId, handles);
         // Recompute edge converter/type for edges where this node is source or target
         for (const e of this.edges) {
+            const srcNode = this.nodes.get(e.source.nodeId);
+            const dstNode = this.nodes.get(e.target.nodeId);
             let srcDeclared = e.effectiveTypeId; // Use effectiveTypeId as fallback
             let dstDeclared = e.dstDeclared;
             const oldDstDeclared = dstDeclared; // Track old value to detect resolution
@@ -1190,7 +1192,7 @@ class GraphRuntime {
                     e.dstDeclared = dstDeclared;
                 }
             }
-            const conv = GraphRuntime.buildEdgeConverters(srcDeclared, dstDeclared, registry);
+            const conv = GraphRuntime.buildEdgeConverters(srcDeclared, dstDeclared, registry, `updateNodeHandles: ${srcNode?.typeId || ""}.${e.source.nodeId}.${e.source.handle} -> ${dstNode?.typeId || ""}.${e.target.nodeId}.${e.target.handle}`);
             e.convert = conv.convert;
             e.convertAsync = conv.convertAsync;
             // If target handle was just resolved (was undefined, now has a type), re-propagate values
@@ -3766,7 +3768,14 @@ function mergeGraphDefinitions(target, source, converter) {
                             ? transformedNode.resolvedHandles.inputs[handleId]
                             : transformedNode.resolvedHandles.inputs[handleId]?.typeId
                         : undefined;
-                    transformedInitialInputs[handleId] = converter(newId, handleId, value, "initialInput", nodeTypeId, handleDataType);
+                    transformedInitialInputs[handleId] = converter({
+                        nodeId: newId,
+                        handleId,
+                        value,
+                        type: "initialInput",
+                        nodeTypeId,
+                        handleDataType,
+                    });
                 }
                 transformedNode.initialInputs = transformedInitialInputs;
             }
@@ -3779,7 +3788,14 @@ function mergeGraphDefinitions(target, source, converter) {
                             ? transformedNode.resolvedHandles.inputs[handleId]
                             : transformedNode.resolvedHandles.inputs[handleId]?.typeId
                         : undefined;
-                    transformedInputDefaults[handleId] = converter(newId, handleId, value, "inputDefault", nodeTypeId, handleDataType);
+                    transformedInputDefaults[handleId] = converter({
+                        nodeId: newId,
+                        handleId,
+                        value,
+                        type: "inputDefault",
+                        nodeTypeId,
+                        handleDataType,
+                    });
                 }
                 transformedNode.resolvedHandles = {
                     ...transformedNode.resolvedHandles,
@@ -3877,7 +3893,14 @@ function mergeInputsOutputs(targetInputs, targetOutputs, sourceInputs, sourceOut
             for (const [handleId, value] of Object.entries(inputs)) {
                 const handleDataType = handleTypeMap?.get(oldId)?.get(handleId);
                 transformedInputs[handleId] = converter
-                    ? converter(newId, handleId, value, "input", nodeTypeId, handleDataType)
+                    ? converter({
+                        nodeId: newId,
+                        handleId,
+                        value,
+                        type: "input",
+                        nodeTypeId,
+                        handleDataType,
+                    })
                     : value;
             }
             mergedInputs[newId] = mergedInputs[newId]
@@ -3896,7 +3919,15 @@ function mergeInputsOutputs(targetInputs, targetOutputs, sourceInputs, sourceOut
                     ? getTypedOutputTypeId(value)
                     : undefined;
                 transformedOutputs[handleId] = converter
-                    ? converter(newId, handleId, value, "output", nodeTypeId, handleDataType, runtimeTypeId)
+                    ? converter({
+                        nodeId: newId,
+                        handleId,
+                        value,
+                        type: "output",
+                        nodeTypeId,
+                        handleDataType,
+                        runtimeTypeId,
+                    })
                     : value;
             }
             mergedOutputs[newId] = mergedOutputs[newId]
@@ -3969,7 +4000,8 @@ function matchesPattern(value, pattern) {
  * - value exists in valueMap
  */
 function buildValueConverter(config) {
-    return (nodeId, handleId, value, type, nodeTypeId, handleDataType, runtimeTypeId) => {
+    return (converterConfig) => {
+        const { nodeId, handleId, value, type, nodeTypeId, handleDataType, runtimeTypeId, } = converterConfig;
         const isTyped = isTypedOutput(value);
         for (const mapping of config.mappings) {
             if (!matchesPattern(handleId, mapping.handleId))