@bian-womp/spark-graph 0.2.16 → 0.2.18

package/lib/cjs/index.cjs

@@ -477,23 +477,20 @@ class GraphRuntime {
         }
         // Instantiate edges
         gr.edges = GraphRuntime.buildEdges(def, registry, gr.resolvedByNode);
-        // After nodes and edges exist, seed registry- and graph-level defaults
+        // After nodes and edges exist, seed registry-, dynamic- and graph-level defaults
         for (const n of def.nodes) {
             const node = gr.nodes.get(n.nodeId);
             const desc = registry.nodes.get(n.typeId);
             if (!node || !desc)
                 continue;
-            // Resolve registry-level defaults (object or function)
-            const regDefaults = typeof desc.inputDefaults === "function"
-                ? desc.inputDefaults({
-                    params: n.params,
-                    environment: gr.environment,
-                })
-                : desc.inputDefaults ?? {};
+            // Resolve registry-level defaults and dynamic (resolved) defaults
+            const regDefaults = desc.inputDefaults ?? {};
+            const dynDefaults = gr.resolvedByNode.get(n.nodeId)?.inputDefaults ?? {};
             const graphDefaults = n.initialInputs ?? {};
-            // Apply precedence: graph-level overrides registry-level
+            // Apply precedence: graph-level overrides dynamic, which overrides registry-level
             const merged = {
                 ...regDefaults,
+                ...dynDefaults,
                 ...graphDefaults,
             };
             for (const [handle, value] of Object.entries(merged)) {
@@ -915,10 +912,12 @@ class GraphRuntime {
                 continue;
             const overrideInputs = n.resolvedHandles?.inputs;
             const overrideOutputs = n.resolvedHandles?.outputs;
+            const overrideDefaults = n.resolvedHandles?.inputDefaults;
             // Merge base with overrides (allow partial resolvedHandles)
             const inputs = { ...desc.inputs, ...overrideInputs };
             const outputs = { ...desc.outputs, ...overrideOutputs };
-            out.set(n.nodeId, { inputs, outputs });
+            const inputDefaults = { ...desc.inputDefaults, ...overrideDefaults };
+            out.set(n.nodeId, { inputs, outputs, inputDefaults });
         }
         return out;
     }
@@ -1326,15 +1325,12 @@ class GraphRuntime {
                 if (defNode) {
                     const desc = registry.nodes.get(defNode.typeId);
                     if (desc) {
-                        const regDefaults = typeof desc.inputDefaults === "function"
-                            ? desc.inputDefaults({
-                                params: defNode.params,
-                                environment: this.environment,
-                            })
-                            : desc.inputDefaults ?? {};
+                        const regDefaults = desc.inputDefaults ?? {};
+                        const dynDefaults = this.resolvedByNode.get(defNode.nodeId)?.inputDefaults ?? {};
                         const graphDefaults = defNode.initialInputs ?? {};
                         const merged = {
                             ...regDefaults,
+                            ...dynDefaults,
                             ...graphDefaults,
                         };
                         for (const h of Array.from(prevSet)) {
@@ -1406,6 +1402,34 @@ class GraphRuntime {
                 }
             }
         }
+        // Seed defaults for nodes (new or existing) where inputs are still undefined and not inbound
+        for (const n of def.nodes) {
+            const node = this.nodes.get(n.nodeId);
+            const desc = registry.nodes.get(n.typeId);
+            if (!node || !desc)
+                continue;
+            const regDefaults = desc.inputDefaults ?? {};
+            const dynDefaults = this.resolvedByNode.get(n.nodeId)?.inputDefaults ?? {};
+            const graphDefaults = n.initialInputs ?? {};
+            const merged = {
+                ...regDefaults,
+                ...dynDefaults,
+                ...graphDefaults,
+            };
+            const inboundSet = nextInbound.get(n.nodeId) ?? new Set();
+            for (const [handle, value] of Object.entries(merged)) {
+                if (value === undefined)
+                    continue;
+                if (inboundSet.has(handle))
+                    continue;
+                if (node.inputs[handle] !== undefined)
+                    continue;
+                node.inputs[handle] =
+                    typeof structuredClone === "function"
+                        ? structuredClone(value)
+                        : JSON.parse(JSON.stringify(value));
+            }
+        }
         // Prune array bucket contributions for edges that no longer exist
         const validPerTarget = new Map();
         for (const ed of this.edges) {
@@ -1440,35 +1464,56 @@ class GraphBuilder {
         const issues = [];
         const nodeIds = new Set();
         const edgeIds = new Set();
+        // Precompute effective handle maps (registry statics merged with per-node resolvedHandles)
+        const nodeById = new Map();
+        const effByNodeId = new Map();
+        const getEffectiveHandles = (n) => {
+            if (!n)
+                return { inputs: {}, outputs: {} };
+            const desc = this.registry.nodes.get(n.typeId);
+            const resolved = n.resolvedHandles || {};
+            const inputs = { ...desc?.inputs, ...resolved.inputs };
+            const outputs = { ...desc?.outputs, ...resolved.outputs };
+            return { inputs, outputs };
+        };
+        const normOut = (decl) => Array.isArray(decl) ? decl : decl ? [decl] : [];
+        const inferEdgeType = (srcDeclared, dstDeclared, explicit) => {
+            if (explicit)
+                return explicit;
+            if (Array.isArray(srcDeclared) && dstDeclared)
+                return dstDeclared;
+            if (srcDeclared)
+                return Array.isArray(srcDeclared) ? srcDeclared[0] : srcDeclared;
+            return undefined;
+        };
+        const canFlow = (from, to) => {
+            if (!to || !from)
+                return true;
+            const arr = Array.isArray(from) ? from : [from];
+            return arr.every((s) => s === to || !!this.registry.canCoerce(s, to));
+        };
+        const pushIssue = (level, code, message, data) => {
+            issues.push({ level, code, message, data });
+        };
         // nodes exist, ids unique, and categories registered
         for (const n of def.nodes) {
             if (nodeIds.has(n.nodeId)) {
-                issues.push({
-                    level: "error",
-                    code: "NODE_ID_DUP",
-                    message: `Duplicate nodeId ${n.nodeId}`,
-                    data: { nodeId: n.nodeId },
+                pushIssue("error", "NODE_ID_DUP", `Duplicate nodeId ${n.nodeId}`, {
+                    nodeId: n.nodeId,
                 });
             }
             else {
                 nodeIds.add(n.nodeId);
             }
+            nodeById.set(n.nodeId, n);
+            effByNodeId.set(n.nodeId, getEffectiveHandles(n));
             const nodeType = this.registry.nodes.get(n.typeId);
             if (!nodeType) {
-                issues.push({
-                    level: "error",
-                    code: "NODE_TYPE_MISSING",
-                    message: `Unknown node type ${n.typeId}`,
-                    data: { typeId: n.typeId, nodeId: n.nodeId },
-                });
+                pushIssue("error", "NODE_TYPE_MISSING", `Unknown node type ${n.typeId}`, { typeId: n.typeId, nodeId: n.nodeId });
                 continue;
             }
             if (!this.registry.categories.has(nodeType.categoryId)) {
-                issues.push({
-                    level: "error",
-                    code: "CATEGORY_MISSING",
-                    message: `Unknown category ${nodeType.categoryId} for node type ${n.typeId}`,
-                });
+                pushIssue("error", "CATEGORY_MISSING", `Unknown category ${nodeType.categoryId} for node type ${n.typeId}`);
             }
         }
         // edges validation: nodes exist, handles exist, type exists
@@ -1477,186 +1522,96 @@ class GraphBuilder {
         const inboundArrayOk = new Set();
         for (const e of def.edges) {
             if (edgeIds.has(e.id)) {
-                issues.push({
-                    level: "error",
-                    code: "EDGE_ID_DUP",
-                    message: `Duplicate edge id ${e.id}`,
-                    data: { edgeId: e.id },
+                pushIssue("error", "EDGE_ID_DUP", `Duplicate edge id ${e.id}`, {
+                    edgeId: e.id,
                 });
             }
             else {
                 edgeIds.add(e.id);
             }
-            const srcNode = def.nodes.find((nn) => nn.nodeId === e.source.nodeId);
-            const dstNode = def.nodes.find((nn) => nn.nodeId === e.target.nodeId);
+            const srcNode = nodeById.get(e.source.nodeId);
+            const dstNode = nodeById.get(e.target.nodeId);
             if (!srcNode)
-                issues.push({
-                    level: "error",
-                    code: "EDGE_SOURCE_MISSING",
-                    message: `Edge ${e.id} source node missing`,
-                    data: { edgeId: e.id },
+                pushIssue("error", "EDGE_SOURCE_MISSING", `Edge ${e.id} source node missing`, {
+                    edgeId: e.id,
                 });
             if (!dstNode)
-                issues.push({
-                    level: "error",
-                    code: "EDGE_TARGET_MISSING",
-                    message: `Edge ${e.id} target node missing`,
-                    data: { edgeId: e.id },
+                pushIssue("error", "EDGE_TARGET_MISSING", `Edge ${e.id} target node missing`, {
+                    edgeId: e.id,
                 });
-            // Infer edge type when missing. For union sources, prefer target input type if available.
-            let effectiveTypeId = e.typeId;
-            let _srcDeclared;
-            let _dstDeclared;
-            if (srcNode) {
-                const srcType = this.registry.nodes.get(srcNode.typeId);
-                if (srcType)
-                    _srcDeclared = srcType.outputs[e.source.handle];
-            }
-            if (dstNode) {
-                const dstType = this.registry.nodes.get(dstNode.typeId);
-                if (dstType)
-                    _dstDeclared = getInputTypeId(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;
-                }
-            }
+            // Effective handle declarations
+            const srcEff = effByNodeId.get(e.source.nodeId) || {
+                outputs: {},
+            };
+            const dstEff = effByNodeId.get(e.target.nodeId) || {
+                inputs: {}};
+            const _srcDeclared = srcNode
+                ? srcEff.outputs[e.source.handle]
+                : undefined;
+            const _dstDeclared = dstNode
+                ? getInputTypeId(dstEff.inputs, e.target.handle)
+                : undefined;
+            // Effective edge type
+            const effectiveTypeId = inferEdgeType(_srcDeclared, _dstDeclared, e.typeId);
             const type = effectiveTypeId
                 ? this.registry.types.get(effectiveTypeId)
                 : undefined;
             if (!type) {
-                issues.push({
-                    level: "error",
-                    code: "TYPE_MISSING",
-                    message: `Edge ${e.id} type missing or unknown`,
-                    data: { edgeId: e.id },
+                pushIssue("error", "TYPE_MISSING", `Edge ${e.id} type missing or unknown`, {
+                    edgeId: e.id,
                 });
             }
             if (srcNode) {
-                const srcType = this.registry.nodes.get(srcNode.typeId);
-                if (srcType && !(e.source.handle in srcType.outputs)) {
-                    issues.push({
-                        level: "error",
-                        code: "OUTPUT_MISSING",
-                        message: `Edge ${e.id} source output ${e.source.handle} missing on ${srcNode.typeId}`,
-                        data: {
-                            edgeId: e.id,
-                            nodeId: srcNode.nodeId,
-                            output: e.source.handle,
-                        },
-                    });
+                if (!(e.source.handle in srcEff.outputs)) {
+                    pushIssue("error", "OUTPUT_MISSING", `Edge ${e.id} source output ${e.source.handle} missing on ${srcNode.typeId}`, { edgeId: e.id, nodeId: srcNode.nodeId, output: e.source.handle });
                 }
-                if (srcType) {
-                    const declared = srcType.outputs[e.source.handle];
-                    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,
-                                    },
-                                });
-                            }
-                        }
-                    }
+                const declaredArr = normOut(srcEff.outputs[e.source.handle]);
+                if (declaredArr.length > 0 &&
+                    effectiveTypeId &&
+                    !canFlow(declaredArr, effectiveTypeId)) {
+                    pushIssue("error", "TYPE_MISMATCH_OUTPUT", `Edge ${e.id} type ${effectiveTypeId} mismatches source output ${srcNode.typeId}.${e.source.handle} (${declaredArr.join("|")}) and no coercion exists`, {
+                        edgeId: e.id,
+                        nodeId: srcNode.nodeId,
+                        output: e.source.handle,
+                        declared: declaredArr.join("|"),
+                        effectiveTypeId,
+                    });
                 }
             }
             if (dstNode) {
-                const dstType = this.registry.nodes.get(dstNode.typeId);
-                if (dstType && !(e.target.handle in dstType.inputs)) {
-                    issues.push({
-                        level: "error",
-                        code: "INPUT_MISSING",
-                        message: `Edge ${e.id} target input ${e.target.handle} missing on ${dstNode.typeId}`,
-                        data: {
-                            edgeId: e.id,
-                            nodeId: dstNode.nodeId,
-                            input: e.target.handle,
-                        },
-                    });
+                if (!(e.target.handle in dstEff.inputs)) {
+                    pushIssue("error", "INPUT_MISSING", `Edge ${e.id} target input ${e.target.handle} missing on ${dstNode.typeId}`, { edgeId: e.id, nodeId: dstNode.nodeId, input: e.target.handle });
+                }
+                // Private inputs should not accept edges
+                if (isInputPrivate(dstEff.inputs, e.target.handle)) {
+                    pushIssue("error", "INPUT_PRIVATE", `Edge ${e.id} targets private input ${dstNode.typeId}.${e.target.handle}`, { edgeId: e.id, nodeId: dstNode.nodeId, input: e.target.handle });
                 }
-                if (dstType) {
-                    // Private inputs should not accept edges
-                    if (isInputPrivate(dstType.inputs, e.target.handle)) {
-                        issues.push({
-                            level: "error",
-                            code: "INPUT_PRIVATE",
-                            message: `Edge ${e.id} targets private input ${dstNode.typeId}.${e.target.handle}`,
-                            data: {
+                const declaredIn = getInputTypeId(dstEff.inputs, e.target.handle);
+                if (declaredIn && effectiveTypeId) {
+                    if (srcNode) {
+                        const srcDeclared = srcEff.outputs[e.source.handle];
+                        const srcArr = normOut(srcDeclared).length
+                            ? normOut(srcDeclared)
+                            : [effectiveTypeId];
+                        if (!canFlow(srcArr, declaredIn)) {
+                            pushIssue("error", "TYPE_MISMATCH_INPUT", `Edge ${e.id} output type ${srcArr.join("|")} not convertible to target input ${dstNode.typeId}.${e.target.handle} (${declaredIn})`, {
                                 edgeId: e.id,
                                 nodeId: dstNode.nodeId,
                                 input: e.target.handle,
-                            },
-                        });
-                    }
-                    const declaredIn = getInputTypeId(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,
-                                },
+                                declared: declaredIn,
+                                effectiveTypeId: srcArr.join("|"),
                             });
                         }
                     }
+                    else if (!canFlow(effectiveTypeId, declaredIn)) {
+                        pushIssue("error", "TYPE_MISMATCH_INPUT", `Edge ${e.id} type ${effectiveTypeId} mismatches target input ${dstNode.typeId}.${e.target.handle} (${declaredIn}) and no coercion exists`, {
+                            edgeId: e.id,
+                            nodeId: dstNode.nodeId,
+                            input: e.target.handle,
+                            declared: declaredIn,
+                            effectiveTypeId,
+                        });
+                    }
                 }
             }
             // Track multiple inbound edges targeting the same input handle
@@ -1664,10 +1619,7 @@ 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 dstType = this.registry.nodes.get(dstNode.typeId);
-                const declaredIn = dstType
-                    ? getInputTypeId(dstType.inputs, e.target.handle)
-                    : undefined;
+                const declaredIn = getInputTypeId((effByNodeId.get(dstNode.nodeId) || { inputs: {} }).inputs, e.target.handle);
                 if (typeof declaredIn === "string" && declaredIn.endsWith("[]")) {
                     inboundArrayOk.add(inboundKey);
                 }
@@ -2689,6 +2641,30 @@ function setupBasicGraphRegistry() {
             return { Items: Array.from({ length }, (_, i) => ins[`Item${i}`]) };
         },
     });
+    // Decompose array into dynamic item outputs
+    registry.registerNode({
+        id: "base.array.decompose",
+        categoryId: "compute",
+        inputs: { Items: "base.object" },
+        outputs: {},
+        resolveHandles: ({ inputs }) => {
+            const maxLen = 64;
+            const arr = Array.isArray(inputs?.Items) ? inputs?.Items : [];
+            const n = Math.max(0, Math.min(maxLen, arr.length));
+            const dyn = {};
+            for (let i = 0; i < n; i++)
+                dyn[`Item${i}`] = "base.object";
+            return { outputs: dyn };
+        },
+        impl: (ins) => {
+            const arr = Array.isArray(ins.Items) ? ins.Items : [];
+            const out = {};
+            const n = Math.max(0, Math.min(64, arr.length));
+            for (let i = 0; i < n; i++)
+                out[`Item${i}`] = arr[i];
+            return out;
+        },
+    });
     // Select
     registry.registerNode({
         id: "base.select",