@bian-womp/spark-graph 0.2.30 → 0.2.31

package/lib/cjs/index.cjs

@@ -573,57 +573,67 @@ class GraphRuntime {
         return node?.outputs[output];
     }
     static buildEdgeConverters(srcDeclared, dstDeclared, registry) {
-        let convert;
-        let convertAsync;
-        if (dstDeclared && srcDeclared) {
-            if (Array.isArray(srcDeclared)) {
-                const srcTypes = srcDeclared;
-                const anyAsync = srcTypes.some((s) => {
-                    const res = registry.resolveCoercion(s, dstDeclared);
-                    return res?.kind === "async";
-                });
-                if (anyAsync) {
-                    convertAsync = async (v, signal) => {
-                        const typeId = getTypedOutputTypeId(v);
-                        if (!typeId)
-                            throw new Error(`Typed output required for union source; allowed: ${srcTypes.join("|")}`);
-                        if (!srcTypes.includes(typeId))
-                            throw new Error(`Invalid typed output ${typeId}; allowed: ${srcTypes.join("|")}`);
-                        const payload = getTypedOutputValue(v);
-                        const res = registry.resolveCoercion(typeId, dstDeclared);
-                        if (!res)
-                            return payload;
-                        if (res.kind === "async")
-                            return await res.convertAsync(payload, signal);
-                        return res.convert(payload);
-                    };
+        if (!dstDeclared || !srcDeclared) {
+            return {};
+        }
+        const isUnion = Array.isArray(srcDeclared);
+        const srcTypes = isUnion ? srcDeclared : [srcDeclared];
+        // Helper to get the coercion for a specific type
+        const getCoercion = (typeId) => {
+            return registry.resolveCoercion(typeId, dstDeclared);
+        };
+        // Resolve coercions for all source types
+        const coercions = srcTypes.map(getCoercion);
+        const hasAsync = coercions.some((r) => r?.kind === "async");
+        // Helper to extract and validate typed output for unions
+        const extractPayload = (v) => {
+            const typeId = getTypedOutputTypeId(v);
+            const payload = getTypedOutputValue(v);
+            if (isUnion) {
+                if (!typeId) {
+                    throw new Error(`Typed output required for union source; allowed: ${srcTypes.join("|")}`);
                 }
-                else {
-                    convert = (v) => {
-                        const typeId = getTypedOutputTypeId(v);
-                        if (!typeId)
-                            throw new Error(`Typed output required for union source; allowed: ${srcTypes.join("|")}`);
-                        if (!srcTypes.includes(typeId))
-                            throw new Error(`Invalid typed output ${typeId}; allowed: ${srcTypes.join("|")}`);
-                        const payload = getTypedOutputValue(v);
-                        const res = registry.resolveCoercion(typeId, dstDeclared);
-                        if (!res)
-                            return payload;
-                        if (res.kind === "async")
-                            throw new Error("Async coercion required but convert used");
-                        return res.convert(payload);
-                    };
+                if (!srcTypes.includes(typeId)) {
+                    throw new Error(`Invalid typed output ${typeId}; allowed: ${srcTypes.join("|")}`);
                 }
             }
-            else {
-                const res = registry.resolveCoercion(srcDeclared, dstDeclared);
-                if (res?.kind === "async")
-                    convertAsync = res.convertAsync;
-                else if (res?.kind === "sync")
-                    convert = res.convert;
+            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}`);
             }
+            return { typeId: typeId || srcTypes[0], payload };
+        };
+        if (hasAsync) {
+            return {
+                convertAsync: async (v, signal) => {
+                    const { typeId, payload } = extractPayload(v);
+                    const res = getCoercion(typeId);
+                    if (!res)
+                        return payload;
+                    if (res.kind === "async") {
+                        return await res.convertAsync(payload, signal);
+                    }
+                    return res.convert(payload);
+                },
+            };
+        }
+        // Sync path
+        const firstCoercion = coercions.find((r) => r?.kind === "sync");
+        if (!firstCoercion) {
+            return {};
         }
-        return { convert, convertAsync };
+        return {
+            convert: (v) => {
+                const { typeId, payload } = extractPayload(v);
+                const res = getCoercion(typeId);
+                if (!res)
+                    return payload;
+                if (res.kind === "async") {
+                    throw new Error("Async coercion required but convert used");
+                }
+                return res.convert(payload);
+            },
+        };
     }
     scheduleInputsChanged(nodeId) {
         const node = this.nodes.get(nodeId);
@@ -827,6 +837,9 @@ class GraphRuntime {
                 const dstNode = this.nodes.get(e.target.nodeId);
                 if (!dstNode)
                     return;
+                // Skip writing to unresolved handles - wait for handle resolution
+                if (e.dstDeclared === undefined)
+                    return;
                 const dstIsArray = typeof e.dstDeclared === "string" && e.dstDeclared.endsWith("[]");
                 let next = v;
                 // If target input is an array type, merge per-edge contributions deterministically
@@ -1035,6 +1048,7 @@ class GraphRuntime {
         for (const e of this.edges) {
             let srcDeclared = e.effectiveTypeId; // Use effectiveTypeId as fallback
             let dstDeclared = e.dstDeclared;
+            const oldDstDeclared = dstDeclared; // Track old value to detect resolution
             if (e.source.nodeId === nodeId) {
                 const resolved = this.resolvedByNode.get(nodeId);
                 srcDeclared = resolved
@@ -1057,6 +1071,19 @@ class GraphRuntime {
             const conv = GraphRuntime.buildEdgeConverters(srcDeclared, dstDeclared, registry);
             e.convert = conv.convert;
             e.convertAsync = conv.convertAsync;
+            // If target handle was just resolved (was undefined, now has a type), re-propagate values
+            if (e.target.nodeId === nodeId &&
+                oldDstDeclared === undefined &&
+                dstDeclared !== undefined) {
+                const srcNode = this.nodes.get(e.source.nodeId);
+                if (srcNode) {
+                    const srcValue = srcNode.outputs[e.source.handle];
+                    if (srcValue !== undefined) {
+                        // Re-propagate through the now-resolved edge converter
+                        this.propagate(e.source.nodeId, e.source.handle, srcValue);
+                    }
+                }
+            }
         }
         // Invalidate downstream for this node so UI refreshes
         this.invalidateDownstream(nodeId);