@bian-womp/spark-graph 0.3.37 → 0.3.38

package/lib/cjs/index.cjs

@@ -3136,22 +3136,33 @@ class GraphRuntime {
             if (value !== undefined && registry) {
                 const desc = registry.nodes.get(node.typeId);
                 const resolved = this.graph.getResolvedHandles(nodeId);
-                // Get typeId from resolved handles first, then registry statics
-                const typeId = resolved
-                    ? getInputTypeId(resolved.inputs, handle)
+                // Get declared types (may be union); prefer resolved handles over registry statics
+                const declaredTypes = resolved
+                    ? getInputDeclaredTypes(resolved.inputs, handle)
                     : desc
-                        ? getInputTypeId(desc.inputs, handle)
+                        ? getInputDeclaredTypes(desc.inputs, handle)
                         : undefined;
-                if (typeId) {
-                    const typeDesc = registry.types.get(typeId);
-                    if (typeDesc?.validate && !typeDesc.validate(value)) {
-                        // Emit error event for invalid input value and reject it
-                        const errorMessage = `Invalid value for input ${nodeId}.${handle} (type ${typeId}): ${JSON.stringify(value)}`;
+                const typeIds = Array.isArray(declaredTypes)
+                    ? declaredTypes
+                    : declaredTypes
+                        ? [declaredTypes]
+                        : [];
+                if (typeIds.length > 0) {
+                    const isValidForAny = typeIds.some((tId) => {
+                        const typeDesc = registry.types.get(tId);
+                        // If no validate function, consider it valid
+                        if (!typeDesc?.validate)
+                            return true;
+                        return typeDesc.validate(value);
+                    });
+                    if (!isValidForAny) {
+                        const typeLabel = typeIds.join("|");
+                        const errorMessage = `Invalid value for input ${nodeId}.${handle} (type ${typeLabel}): ${JSON.stringify(value)}`;
                         this.eventEmitter.emit("error", {
                             kind: "input-validation",
                             nodeId,
                             handle,
-                            typeId,
+                            typeId: typeLabel,
                             value,
                             message: errorMessage,
                         });
@@ -3741,11 +3752,30 @@ class GraphBuilder {
                 return { inputs: {}, outputs: {} };
             const desc = this.registry.nodes.get(n.typeId);
             const resolved = n.resolvedHandles || {};
-            const inputs = { ...desc?.inputs, ...resolved.inputs };
+            // Merge inputs properly, handling union types and metadata
+            const inputs = {};
+            // First, add all static handles
+            if (desc?.inputs) {
+                for (const [handle, staticDesc] of Object.entries(desc.inputs)) {
+                    inputs[handle] = staticDesc;
+                }
+            }
+            // Then, merge resolved handles (which may override/extend static handles)
+            if (resolved.inputs) {
+                for (const [handle, resolvedDesc] of Object.entries(resolved.inputs)) {
+                    const staticDesc = desc?.inputs?.[handle];
+                    const merged = mergeInputHandleDescriptors(staticDesc, resolvedDesc);
+                    if (merged) {
+                        inputs[handle] = merged;
+                    }
+                }
+            }
             const outputs = { ...desc?.outputs, ...resolved.outputs };
             return { inputs, outputs };
         };
         const normOut = (decl) => Array.isArray(decl) ? decl : decl ? [decl] : [];
+        const getEnumTypes = (decl) => normOut(decl).filter((t) => t.startsWith("enum:"));
+        const hasArrayType = (decl) => normOut(decl).some((t) => t.endsWith("[]"));
         const canFlow = (from, to) => {
             if (!to || !from)
                 return true;
@@ -3795,19 +3825,20 @@ class GraphBuilder {
                     if (paramKey === "policy")
                         continue;
                     // Check if this param corresponds to an input handle
-                    const inputTypeId = getInputTypeId(effectiveHandles.inputs, paramKey);
-                    if (inputTypeId && inputTypeId.startsWith("enum:")) {
-                        if (!validateEnumValue(inputTypeId, paramValue, n.nodeId)) {
-                            const enumDef = this.registry.enums.get(inputTypeId);
-                            const validValues = enumDef
-                                ? Array.from(enumDef.valueToLabel.keys()).join(", ")
-                                : "unknown";
-                            pushIssue("error", "ENUM_VALUE_INVALID", `Node ${n.nodeId} param ${paramKey} has invalid enum value ${paramValue}. Valid values: ${validValues}`, {
-                                nodeId: n.nodeId,
-                                input: paramKey,
-                                typeId: inputTypeId,
-                            });
-                        }
+                    const declaredTypes = getInputDeclaredTypes(effectiveHandles.inputs, paramKey);
+                    const enumTypes = getEnumTypes(declaredTypes);
+                    if (enumTypes.length > 0 &&
+                        typeof paramValue === "number" &&
+                        !enumTypes.some((et) => validateEnumValue(et, paramValue, n.nodeId))) {
+                        const enumDef = this.registry.enums.get(enumTypes[0]);
+                        const validValues = enumDef
+                            ? Array.from(enumDef.valueToLabel.keys()).join(", ")
+                            : "unknown";
+                        pushIssue("error", "ENUM_VALUE_INVALID", `Node ${n.nodeId} param ${paramKey} has invalid enum value ${paramValue}. Valid values: ${validValues}`, {
+                            nodeId: n.nodeId,
+                            input: paramKey,
+                            typeId: enumTypes.join("|"),
+                        });
                     }
                 }
             }
@@ -3816,19 +3847,20 @@ class GraphBuilder {
             if (resolved?.inputDefaults) {
                 const effectiveHandles = getEffectiveHandles(n);
                 for (const [handle, defaultValue] of Object.entries(resolved.inputDefaults)) {
-                    const inputTypeId = getInputTypeId(effectiveHandles.inputs, handle);
-                    if (inputTypeId && inputTypeId.startsWith("enum:")) {
-                        if (!validateEnumValue(inputTypeId, defaultValue, n.nodeId)) {
-                            const enumDef = this.registry.enums.get(inputTypeId);
-                            const validValues = enumDef
-                                ? Array.from(enumDef.valueToLabel.keys()).join(", ")
-                                : "unknown";
-                            pushIssue("warning", "ENUM_DEFAULT_INVALID", `Node ${n.nodeId} input default ${handle} has invalid enum value ${defaultValue}. Valid values: ${validValues}`, {
-                                nodeId: n.nodeId,
-                                input: handle,
-                                typeId: inputTypeId,
-                            });
-                        }
+                    const declaredTypes = getInputDeclaredTypes(effectiveHandles.inputs, handle);
+                    const enumTypes = getEnumTypes(declaredTypes);
+                    if (enumTypes.length > 0 &&
+                        typeof defaultValue === "number" &&
+                        !enumTypes.some((et) => validateEnumValue(et, defaultValue, n.nodeId))) {
+                        const enumDef = this.registry.enums.get(enumTypes[0]);
+                        const validValues = enumDef
+                            ? Array.from(enumDef.valueToLabel.keys()).join(", ")
+                            : "unknown";
+                        pushIssue("warning", "ENUM_DEFAULT_INVALID", `Node ${n.nodeId} input default ${handle} has invalid enum value ${defaultValue}. Valid values: ${validValues}`, {
+                            nodeId: n.nodeId,
+                            input: handle,
+                            typeId: enumTypes.join("|"),
+                        });
                     }
                 }
             }
@@ -3928,8 +3960,8 @@ 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 declaredIn = getInputTypeId((effByNodeId.get(dstNode.nodeId) || { inputs: {} }).inputs, e.target.handle);
-                if (typeof declaredIn === "string" && declaredIn.endsWith("[]")) {
+                const declaredIn = getInputDeclaredTypes((effByNodeId.get(dstNode.nodeId) || { inputs: {} }).inputs, e.target.handle);
+                if (hasArrayType(declaredIn)) {
                     inboundArrayOk.add(inboundKey);
                 }
             }
@@ -3958,10 +3990,10 @@ class GraphBuilder {
             const innerDesc = innerNode
                 ? this.registry.nodes.get(innerNode.typeId)
                 : undefined;
-            const typeId = innerDesc
-                ? getInputTypeId(innerDesc.inputs, map.handle)
+            const typeIds = innerDesc
+                ? getInputDeclaredTypes(innerDesc.inputs, map.handle)
                 : undefined;
-            inputTypes[outerIn] = typeId ?? "untyped";
+            inputTypes[outerIn] = typeIds ?? "unknown";
         }
         for (const [outerOut, map] of Object.entries(exposure.outputs)) {
             const innerNode = def.nodes.find((n) => n.nodeId === map.nodeId);
@@ -3970,7 +4002,7 @@ class GraphBuilder {
                 : undefined;
             const typeId = innerDesc ? innerDesc.outputs[map.handle] : undefined;
             const single = Array.isArray(typeId) ? typeId[0] : typeId;
-            outputTypes[outerOut] = single ?? "untyped";
+            outputTypes[outerOut] = single ?? "unknown";
         }
         return {
             id: nodeTypeId,