@bian-womp/spark-graph 0.2.30 → 0.2.32

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);
+                },
+            };
         }
-        return { convert, convertAsync };
+        // Sync path
+        const firstCoercion = coercions.find((r) => r?.kind === "sync");
+        if (!firstCoercion) {
+            return {};
+        }
+        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,11 +1071,24 @@ 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);
     }
-    launch() {
+    launch(invalidate = false) {
         // call onActivated for nodes that implement it
         for (const node of this.nodes.values()) {
             const ctrl = new AbortController();
@@ -1085,10 +1112,12 @@ class GraphRuntime {
             });
             node.runtime.onActivated?.(ctx);
         }
-        // After activation, schedule nodes that have all inbound inputs present
-        for (const nodeId of this.nodes.keys()) {
-            if (this.allInboundHaveValue(nodeId))
-                this.scheduleInputsChanged(nodeId);
+        if (invalidate) {
+            // After activation, schedule nodes that have all inbound inputs present
+            for (const nodeId of this.nodes.keys()) {
+                if (this.allInboundHaveValue(nodeId))
+                    this.scheduleInputsChanged(nodeId);
+            }
         }
     }
     triggerExternal(nodeId, event) {
@@ -1874,11 +1903,11 @@ class AbstractEngine {
     constructor(graphRuntime) {
         this.graphRuntime = graphRuntime;
     }
-    launch() {
-        this.graphRuntime.launch();
+    launch(invalidate = false) {
+        this.graphRuntime.launch(invalidate);
     }
     setInput(nodeId, handle, value) {
-        this.setInputs(nodeId, { [handle]: value });
+        this.graphRuntime.setInputs(nodeId, { [handle]: value });
     }
     setInputs(nodeId, inputs) {
         this.graphRuntime.setInputs(nodeId, inputs);