@bian-womp/spark-graph 0.2.29 → 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
@@ -984,7 +997,7 @@ class GraphRuntime {
         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 effectiveTypeId = e.typeId; // Start with original
             let srcDeclared;
             let dstDeclared;
             if (srcNode) {
@@ -993,6 +1006,7 @@ class GraphRuntime {
                     srcDeclared = resolved.outputs[e.source.handle];
             }
             if (!effectiveTypeId) {
+                // Infer if not explicitly set
                 effectiveTypeId = Array.isArray(srcDeclared)
                     ? srcDeclared[0]
                     : srcDeclared;
@@ -1007,7 +1021,8 @@ class GraphRuntime {
                 id: e.id,
                 source: { ...e.source },
                 target: { ...e.target },
-                typeId: effectiveTypeId ?? "untyped",
+                typeId: e.typeId, // Preserve original (may be undefined)
+                effectiveTypeId: effectiveTypeId ?? "untyped", // Always present
                 convert,
                 convertAsync,
                 srcUnionTypes: Array.isArray(srcDeclared)
@@ -1031,18 +1046,19 @@ 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) {
-            let srcDeclared = e.typeId;
+            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
                     ? resolved.outputs[e.source.handle]
                     : srcDeclared;
-                // If edge had no explicit typeId, infer from updated src
+                // Update effectiveTypeId if original wasn't explicit
                 if (!e.typeId) {
-                    e.typeId = Array.isArray(srcDeclared)
-                        ? srcDeclared?.[0]
-                        : srcDeclared;
+                    e.effectiveTypeId = Array.isArray(srcDeclared)
+                        ? srcDeclared?.[0] ?? "untyped"
+                        : srcDeclared ?? "untyped";
                 }
             }
             if (e.target.nodeId === nodeId) {
@@ -1055,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);
@@ -1165,10 +1194,23 @@ class GraphRuntime {
     getGraphDef() {
         const nodes = Array.from(this.nodes.values()).map((n) => {
             const resolved = this.resolvedByNode.get(n.nodeId);
+            // Collect user-provided inputs (inputs without inbound edges)
+            const initialInputs = {};
+            for (const [handle, value] of Object.entries(n.inputs)) {
+                const hasInbound = this.edges.some((e) => e.target.nodeId === n.nodeId && e.target.handle === handle);
+                if (!hasInbound && value !== undefined) {
+                    // Clone to avoid shared references
+                    initialInputs[handle] =
+                        typeof structuredClone === "function"
+                            ? structuredClone(value)
+                            : JSON.parse(JSON.stringify(value));
+                }
+            }
             return {
                 nodeId: n.nodeId,
                 typeId: n.typeId,
                 params: n.params ? { ...n.params } : undefined,
+                initialInputs: Object.keys(initialInputs).length > 0 ? initialInputs : undefined,
                 resolvedHandles: resolved ? { ...resolved } : undefined,
             };
         });
@@ -1176,7 +1218,7 @@ class GraphRuntime {
             id: e.id,
             source: { nodeId: e.source.nodeId, handle: e.source.handle },
             target: { nodeId: e.target.nodeId, handle: e.target.handle },
-            typeId: e.typeId && e.typeId !== "untyped" ? e.typeId : undefined,
+            typeId: e.typeId, // Only export original typeId (may be undefined)
         }));
         return { nodes, edges };
     }