@bian-womp/spark-graph 0.2.17 → 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) {
@@ -2617,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",