@bian-womp/spark-graph 0.1.15 → 0.1.17

package/lib/cjs/index.cjs

@@ -372,6 +372,15 @@ class Registry {
     }
 }
 
+function typed(typeId, value) {
+    return { __spark_type: typeId, __spark_value: value };
+}
+function isTypedOutput(v) {
+    return (!!v &&
+        typeof v === "object" &&
+        Object.prototype.hasOwnProperty.call(v, "__spark_type"));
+}
+
 class GraphRuntime {
     constructor() {
         this.nodes = new Map();
@@ -435,25 +444,19 @@ class GraphRuntime {
                     srcDeclared = srcDesc.outputs[e.source.handle];
                 }
             }
-            if (!effectiveTypeId)
-                effectiveTypeId = srcDeclared;
+            if (!effectiveTypeId) {
+                effectiveTypeId = Array.isArray(srcDeclared)
+                    ? srcDeclared[0]
+                    : srcDeclared;
+            }
             if (dstNode) {
                 const dstDesc = registry.nodes.get(dstNode.typeId);
                 if (dstDesc) {
                     dstDeclared = dstDesc.inputs[e.target.handle];
                 }
             }
-            // Attach convert if source/target differ but coercible
-            let convert = undefined;
-            let convertAsync = undefined;
-            if (srcDeclared && dstDeclared && srcDeclared !== dstDeclared) {
-                const fn = registry.getCoercion(srcDeclared, dstDeclared);
-                if (fn)
-                    convert = convert ?? fn;
-                const afn = registry.getAsyncCoercion(srcDeclared, dstDeclared);
-                if (afn)
-                    convertAsync = convertAsync ?? afn;
-            }
+            // Attach dynamic convert/convertAsync aware of union sources and typed outputs
+            const { convert, convertAsync } = GraphRuntime.buildEdgeConverters(srcDeclared, dstDeclared, registry);
             return {
                 id: e.id,
                 source: { ...e.source },
@@ -461,6 +464,9 @@ class GraphRuntime {
                 typeId: effectiveTypeId ?? "untyped",
                 convert,
                 convertAsync,
+                srcUnionTypes: Array.isArray(srcDeclared)
+                    ? [...srcDeclared]
+                    : undefined,
                 stats: { runs: 0, inFlight: false, progress: 0 },
             };
         });
@@ -537,6 +543,59 @@ class GraphRuntime {
         const node = this.nodes.get(nodeId);
         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) => {
+                        if (!isTypedOutput(v))
+                            throw new Error(`Typed output required for union source; allowed: ${srcTypes.join("|")}`);
+                        const typeId = String(v.__spark_type);
+                        if (!srcTypes.includes(typeId))
+                            throw new Error(`Invalid typed output ${typeId}; allowed: ${srcTypes.join("|")}`);
+                        const payload = v.__spark_value;
+                        const res = registry.resolveCoercion(typeId, dstDeclared);
+                        if (!res)
+                            return payload;
+                        if (res.kind === "async")
+                            return await res.convertAsync(payload, signal);
+                        return res.convert(payload);
+                    };
+                }
+                else {
+                    convert = (v) => {
+                        if (!isTypedOutput(v))
+                            throw new Error(`Typed output required for union source; allowed: ${srcTypes.join("|")}`);
+                        const typeId = String(v.__spark_type);
+                        if (!srcTypes.includes(typeId))
+                            throw new Error(`Invalid typed output ${typeId}; allowed: ${srcTypes.join("|")}`);
+                        const payload = v.__spark_value;
+                        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);
+                    };
+                }
+            }
+            else {
+                const res = registry.resolveCoercion(srcDeclared, dstDeclared);
+                if (res?.kind === "async")
+                    convertAsync = res.convertAsync;
+                else if (res?.kind === "sync")
+                    convert = res.convert;
+            }
+        }
+        return { convert, convertAsync };
+    }
     scheduleInputsChanged(nodeId) {
         const node = this.nodes.get(nodeId);
         if (!node)
@@ -708,10 +767,27 @@ class GraphRuntime {
             handle: srcHandle,
             value,
             io: "output",
+            runtimeTypeId: isTypedOutput(value)
+                ? String(value.__spark_type)
+                : undefined,
         });
         // fan-out along all edges from this output
         const outEdges = this.edges.filter((e) => e.source.nodeId === srcNodeId && e.source.handle === srcHandle);
         for (const e of outEdges) {
+            // If source declares a union for this handle, require typed output
+            const isUnion = Array.isArray(e.srcUnionTypes);
+            const isTyped = isTypedOutput(value);
+            if (isUnion && !isTyped) {
+                const err = new Error(`Output ${srcNodeId}.${srcHandle} requires typed value for union output (allowed: ${e.srcUnionTypes.join("|")})`);
+                this.emit("error", {
+                    kind: "edge-convert",
+                    edgeId: e.id,
+                    source: { nodeId: e.source.nodeId, handle: e.source.handle },
+                    target: { nodeId: e.target.nodeId, handle: e.target.handle },
+                    err,
+                });
+                continue;
+            }
             // Clone per edge to isolate conversions from mutating the shared source value
             let nextVal = structuredClone(value);
             const applyToTarget = (v) => {
@@ -725,6 +801,7 @@ class GraphRuntime {
                     handle: e.target.handle,
                     value: v,
                     io: "input",
+                    runtimeTypeId: isTypedOutput(v) ? String(v.__spark_type) : undefined,
                 });
                 if (!this.paused && this.allInboundHaveValue(e.target.nodeId))
                     this.scheduleInputsChanged(e.target.nodeId);
@@ -743,7 +820,7 @@ class GraphRuntime {
                 e.stats.inFlight = true;
                 e.stats.progress = 0;
                 const sig = controller.signal;
-                // Fire async conversion
+                // Fire async conversion using edge's convertAsync (dynamic union aware)
                 void e
                     .convertAsync(nextVal, sig)
                     .then((v) => {
@@ -1020,24 +1097,18 @@ class GraphRuntime {
                     srcDeclared = srcDesc.outputs[e.source.handle];
                 }
             }
-            if (!effectiveTypeId)
-                effectiveTypeId = srcDeclared;
+            if (!effectiveTypeId) {
+                effectiveTypeId = Array.isArray(srcDeclared)
+                    ? srcDeclared[0]
+                    : srcDeclared;
+            }
             if (dstNode) {
                 const dstDesc = registry.nodes.get(dstNode.typeId);
                 if (dstDesc) {
                     dstDeclared = dstDesc.inputs[e.target.handle];
                 }
             }
-            let convert = undefined;
-            let convertAsync = undefined;
-            if (srcDeclared && dstDeclared && srcDeclared !== dstDeclared) {
-                const fn = registry.getCoercion(srcDeclared, dstDeclared);
-                if (fn)
-                    convert = convert ?? fn;
-                const afn = registry.getAsyncCoercion(srcDeclared, dstDeclared);
-                if (afn)
-                    convertAsync = convertAsync ?? afn;
-            }
+            const { convert, convertAsync } = GraphRuntime.buildEdgeConverters(srcDeclared, dstDeclared, registry);
             return {
                 id: e.id,
                 source: { ...e.source },
@@ -1178,12 +1249,30 @@ class GraphBuilder {
                     message: `Edge ${e.id} target node missing`,
                     data: { edgeId: e.id },
                 });
-            // infer edge type from source output if missing
+            // Infer edge type when missing. For union sources, prefer target input type if available.
             let effectiveTypeId = e.typeId;
-            if (!effectiveTypeId && srcNode) {
+            let _srcDeclared;
+            let _dstDeclared;
+            if (srcNode) {
                 const srcType = this.registry.nodes.get(srcNode.typeId);
-                if (srcType) {
-                    effectiveTypeId = srcType.outputs[e.source.handle];
+                if (srcType)
+                    _srcDeclared = srcType.outputs[e.source.handle];
+            }
+            if (dstNode) {
+                const dstType = this.registry.nodes.get(dstNode.typeId);
+                if (dstType)
+                    _dstDeclared = dstType.inputs[e.target.handle];
+            }
+            if (!effectiveTypeId) {
+                if (Array.isArray(_srcDeclared) && _dstDeclared) {
+                    // When source is a union and target input type is known, adopt the input type
+                    // so validation checks are performed against the target, not an arbitrary variant.
+                    effectiveTypeId = _dstDeclared;
+                }
+                else if (_srcDeclared) {
+                    effectiveTypeId = Array.isArray(_srcDeclared)
+                        ? _srcDeclared[0]
+                        : _srcDeclared;
                 }
             }
             const type = effectiveTypeId
@@ -1213,22 +1302,29 @@ class GraphBuilder {
                 }
                 if (srcType) {
                     const declared = srcType.outputs[e.source.handle];
-                    if (declared &&
-                        effectiveTypeId &&
-                        declared !== effectiveTypeId &&
-                        !this.registry.canCoerce(declared, effectiveTypeId)) {
-                        issues.push({
-                            level: "error",
-                            code: "TYPE_MISMATCH_OUTPUT",
-                            message: `Edge ${e.id} type ${effectiveTypeId} mismatches source output ${srcNode.typeId}.${e.source.handle} (${declared}) and no coercion exists`,
-                            data: {
-                                edgeId: e.id,
-                                nodeId: srcNode.nodeId,
-                                output: e.source.handle,
-                                declared,
-                                effectiveTypeId,
-                            },
-                        });
+                    const declaredArr = Array.isArray(declared)
+                        ? declared
+                        : declared
+                            ? [declared]
+                            : [];
+                    if (declaredArr.length > 0 && effectiveTypeId) {
+                        for (const s of declaredArr) {
+                            if (s !== effectiveTypeId &&
+                                !this.registry.canCoerce(s, effectiveTypeId)) {
+                                issues.push({
+                                    level: "error",
+                                    code: "TYPE_MISMATCH_OUTPUT",
+                                    message: `Edge ${e.id} type ${effectiveTypeId} mismatches source output ${srcNode.typeId}.${e.source.handle} (${s}) and no coercion exists`,
+                                    data: {
+                                        edgeId: e.id,
+                                        nodeId: srcNode.nodeId,
+                                        output: e.source.handle,
+                                        declared: s,
+                                        effectiveTypeId,
+                                    },
+                                });
+                            }
+                        }
                     }
                 }
             }
@@ -1247,23 +1343,52 @@ class GraphBuilder {
                     });
                 }
                 if (dstType) {
-                    const declared = dstType.inputs[e.target.handle];
-                    if (declared &&
-                        effectiveTypeId &&
-                        declared !== effectiveTypeId &&
-                        !this.registry.canCoerce(effectiveTypeId, declared)) {
-                        issues.push({
-                            level: "error",
-                            code: "TYPE_MISMATCH_INPUT",
-                            message: `Edge ${e.id} type ${effectiveTypeId} mismatches target input ${dstNode.typeId}.${e.target.handle} (${declared}) and no coercion exists`,
-                            data: {
-                                edgeId: e.id,
-                                nodeId: dstNode.nodeId,
-                                input: e.target.handle,
-                                declared,
-                                effectiveTypeId,
-                            },
-                        });
+                    const declaredIn = dstType.inputs[e.target.handle];
+                    if (declaredIn && effectiveTypeId) {
+                        // If source is a union, ensure each variant can reach declaredIn
+                        if (srcNode) {
+                            const srcType = this.registry.nodes.get(srcNode.typeId);
+                            const srcDeclared = srcType?.outputs[e.source.handle];
+                            const srcArr = Array.isArray(srcDeclared)
+                                ? srcDeclared
+                                : srcDeclared
+                                    ? [srcDeclared]
+                                    : effectiveTypeId
+                                        ? [effectiveTypeId]
+                                        : [];
+                            for (const s of srcArr) {
+                                if (s !== declaredIn &&
+                                    !this.registry.canCoerce(s, declaredIn)) {
+                                    issues.push({
+                                        level: "error",
+                                        code: "TYPE_MISMATCH_INPUT",
+                                        message: `Edge ${e.id} output type ${s} not convertible to target input ${dstNode.typeId}.${e.target.handle} (${declaredIn})`,
+                                        data: {
+                                            edgeId: e.id,
+                                            nodeId: dstNode.nodeId,
+                                            input: e.target.handle,
+                                            declared: declaredIn,
+                                            effectiveTypeId: s,
+                                        },
+                                    });
+                                }
+                            }
+                        }
+                        else if (declaredIn !== effectiveTypeId &&
+                            !this.registry.canCoerce(effectiveTypeId, declaredIn)) {
+                            issues.push({
+                                level: "error",
+                                code: "TYPE_MISMATCH_INPUT",
+                                message: `Edge ${e.id} type ${effectiveTypeId} mismatches target input ${dstNode.typeId}.${e.target.handle} (${declaredIn}) and no coercion exists`,
+                                data: {
+                                    edgeId: e.id,
+                                    nodeId: dstNode.nodeId,
+                                    input: e.target.handle,
+                                    declared: declaredIn,
+                                    effectiveTypeId,
+                                },
+                            });
+                        }
                     }
                 }
             }
@@ -1304,7 +1429,8 @@ class GraphBuilder {
                 ? this.registry.nodes.get(innerNode.typeId)
                 : undefined;
             const typeId = innerDesc ? innerDesc.outputs[map.handle] : undefined;
-            outputTypes[outerOut] = typeId ?? "untyped";
+            const single = Array.isArray(typeId) ? typeId[0] : typeId;
+            outputTypes[outerOut] = single ?? "untyped";
         }
         return {
             id: nodeTypeId,
@@ -1576,10 +1702,16 @@ const CompositeCategory = (registry) => ({
             onInputsChanged: (inputs, ctx) => {
                 if (!inner)
                     return;
-                // map outer input => inner node input
+                // map outer inputs => batch per inner node to avoid extra runs
+                const grouped = {};
                 for (const [inHandle, map] of Object.entries(impl.exposure.inputs)) {
-                    if (inHandle in inputs)
-                        inner.setInput(map.nodeId, map.handle, inputs[inHandle]);
+                    if (inHandle in inputs) {
+                        const nodeMap = (grouped[map.nodeId] = grouped[map.nodeId] || {});
+                        nodeMap[map.handle] = inputs[inHandle];
+                    }
+                }
+                for (const [nodeId, map] of Object.entries(grouped)) {
+                    inner.setInputs(nodeId, map);
                 }
                 // pull inner exposed outputs and emit
                 for (const [outHandle, map] of Object.entries(impl.exposure.outputs)) {
@@ -1622,6 +1754,25 @@ const lcg = (seed) => {
     let s = seed >>> 0 || 1;
     return () => (s = (s * 1664525 + 1013904223) >>> 0) / 0xffffffff;
 };
+// JSON helpers
+const isPlainObject = (v) => {
+    if (v === null || typeof v !== "object")
+        return false;
+    const proto = Object.getPrototypeOf(v);
+    return proto === Object.prototype || proto === null;
+};
+const isJson = (v) => {
+    if (v === null)
+        return true;
+    const t = typeof v;
+    if (t === "string" || t === "number" || t === "boolean")
+        return true;
+    if (Array.isArray(v))
+        return v.every(isJson);
+    if (isPlainObject(v))
+        return Object.values(v).every(isJson);
+    return false;
+};
 function setupBasicGraphRegistry() {
     const registry = new Registry();
     registry.categories.register(ComputeCategory);
@@ -1637,6 +1788,11 @@ function setupBasicGraphRegistry() {
         id: "base.string",
         validate: (v) => typeof v === "string",
     }, { withArray: true, arrayPickFirstDefined: true });
+    // Generic object value (JSON-compatible; object/array/primitive/null)
+    registry.registerType({
+        id: "base.object",
+        validate: (v) => isJson(v),
+    }, { withArray: true, arrayPickFirstDefined: true });
     registry.registerType({
         id: "base.vec3",
         validate: (v) => Array.isArray(v) &&
@@ -1647,18 +1803,52 @@ function setupBasicGraphRegistry() {
     registry.registerCoercion("base.float", "base.vec3", (v) => {
         return [Number(v) || 0, 0, 0];
     });
-    // Async coercion variant for vec3 -> float (chunked + abortable)
-    registry.registerAsyncCoercion("base.vec3", "base.float", async (value, signal) => {
-        if (signal.aborted)
-            throw new DOMException("Aborted", "AbortError");
+    registry.registerCoercion("base.vec3", "base.float", (value) => {
         const v = value;
-        await new Promise((r) => setTimeout(r, 1000));
         return Math.hypot(Number(v[0] ?? 0), Number(v[1] ?? 0), Number(v[2] ?? 0));
     });
     registry.registerCoercion("base.bool", "base.float", (v) => (v ? 1 : 0));
     registry.registerCoercion("base.float", "base.bool", (v) => !!v);
     registry.registerCoercion("base.float", "base.string", (v) => String(v));
     registry.registerCoercion("base.string", "base.float", (v) => Number(v));
+    // Object <-> String
+    registry.registerCoercion("base.string", "base.object", (v) => {
+        try {
+            return JSON.parse(String(v));
+        }
+        catch {
+            return undefined;
+        }
+    });
+    registry.registerCoercion("base.object", "base.string", (v) => {
+        try {
+            return JSON.stringify(v);
+        }
+        catch {
+            return String(v);
+        }
+    });
+    registry.registerCoercion("base.vec3", "base.json", (v) => {
+        try {
+            return v ? JSON.stringify(v) : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    });
+    registry.registerCoercion("base.json", "base.vec3", (v) => {
+        try {
+            const result = JSON.parse(v);
+            if (result.length === 3 &&
+                result.every((x) => typeof x === "number")) {
+                return result;
+            }
+            return undefined;
+        }
+        catch {
+            return undefined;
+        }
+    });
     // Enums: Math Operation
     registry.registerEnum({
         id: "base.enum:math.operation",
@@ -2204,6 +2394,8 @@ exports.createSimpleGraphDef = createSimpleGraphDef;
 exports.createSimpleGraphRegistry = createSimpleGraphRegistry;
 exports.createValidationGraphDef = createValidationGraphDef;
 exports.createValidationGraphRegistry = createValidationGraphRegistry;
+exports.isTypedOutput = isTypedOutput;
 exports.registerDelayNode = registerDelayNode;
 exports.registerProgressNodes = registerProgressNodes;
+exports.typed = typed;
 //# sourceMappingURL=index.cjs.map