@bian-womp/spark-graph 0.2.33 → 0.2.35

package/lib/cjs/index.cjs

@@ -485,41 +485,12 @@ class GraphRuntime {
                     queued: 0,
                     progress: 0,
                 },
+                initialInputs: n.initialInputs ?? {},
             };
             gr.nodes.set(n.nodeId, rn);
         }
         // Instantiate edges
         gr.edges = GraphRuntime.buildEdges(def, registry, gr.resolvedByNode);
-        // 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 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 dynamic, which overrides registry-level
-            const merged = {
-                ...regDefaults,
-                ...dynDefaults,
-                ...graphDefaults,
-            };
-            for (const [handle, value] of Object.entries(merged)) {
-                // Only seed if input has no inbound wiring
-                const hasInbound = gr.edges.some((e) => e.target.nodeId === n.nodeId && e.target.handle === handle);
-                if (hasInbound)
-                    continue;
-                if (value === undefined)
-                    continue;
-                // Clone to avoid accidental shared references
-                node.inputs[handle] =
-                    typeof structuredClone === "function"
-                        ? structuredClone(value)
-                        : JSON.parse(JSON.stringify(value));
-            }
-        }
         // Schedule async recompute only for nodes that indicated Promise-based resolveHandles
         for (const nodeId of initial.pending)
             gr.scheduleRecomputeHandles(nodeId);
@@ -643,6 +614,8 @@ class GraphRuntime {
             return;
         const now = Date.now();
         const policy = node.policy ?? {};
+        // Compute effective inputs (real inputs + defaults) for this execution
+        const effectiveInputs = this.getEffectiveInputs(nodeId);
         if (policy.debounceMs &&
             node.lastScheduledAt &&
             now - node.lastScheduledAt < policy.debounceMs) {
@@ -650,7 +623,7 @@ class GraphRuntime {
             node.queue.splice(0, node.queue.length);
             node.runSeq += 1;
             const rid = `${nodeId}:${node.runSeq}:${now}`;
-            node.queue.push({ runId: rid, inputs: { ...node.inputs } });
+            node.queue.push({ runId: rid, inputs: effectiveInputs });
             return;
         }
         node.lastScheduledAt = now;
@@ -756,7 +729,7 @@ class GraphRuntime {
             return;
         if (mode === "queue") {
             const maxQ = policy.maxQueue ?? 8;
-            node.queue.push({ runId: rid, inputs: { ...node.inputs } });
+            node.queue.push({ runId: rid, inputs: effectiveInputs });
             if (node.queue.length > maxQ)
                 node.queue.shift();
             const processNext = () => {
@@ -775,7 +748,7 @@ class GraphRuntime {
             return;
         }
         // switch or merge
-        startRun(rid, { ...node.inputs });
+        startRun(rid, effectiveInputs);
     }
     // Returns true if all inbound handles for the node currently have a value
     allInboundHaveValue(nodeId) {
@@ -791,6 +764,62 @@ class GraphRuntime {
         }
         return true;
     }
+    // Computes effective inputs for a node by merging real inputs with defaults
+    // Defaults are applied only for unbound handles that have no explicit value
+    // This method does NOT mutate node.inputs - defaults remain virtual
+    // Dynamic handles (from resolveHandles) do NOT get defaults applied - they are metadata-only
+    getEffectiveInputs(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return {};
+        const registry = this.registry;
+        if (!registry)
+            return {};
+        const desc = registry.nodes.get(node.typeId);
+        if (!desc)
+            return {};
+        const resolved = this.resolvedByNode.get(nodeId);
+        const regDefaults = desc.inputDefaults ?? {};
+        const dynDefaults = resolved?.inputDefaults ?? {};
+        const graphDefaults = node.initialInputs ?? {};
+        // Identify which handles are dynamically resolved (not in registry statics)
+        // Dynamic handles are metadata-only and should not receive defaults in execution
+        const staticHandles = new Set(Object.keys(desc.inputs ?? {}));
+        const dynamicHandles = new Set(Object.keys(resolved?.inputs ?? {}).filter((h) => !staticHandles.has(h)));
+        // Precedence: graph > dynamic > registry
+        const mergedDefaults = {
+            ...regDefaults,
+            ...dynDefaults,
+            ...graphDefaults,
+        };
+        // Start with real inputs only (no defaults)
+        const effective = { ...node.inputs };
+        // Build set of inbound handles (wired inputs)
+        const inbound = new Set(this.edges
+            .filter((e) => e.target.nodeId === nodeId)
+            .map((e) => e.target.handle));
+        // Apply defaults only for:
+        // 1. Unbound handles that have no explicit value
+        // 2. Static handles (not dynamically resolved)
+        // This prevents dynamic handles (like geo:*) from getting defaults in execution
+        // Dynamic handles are metadata-only for UI display, not execution values
+        for (const [handle, defaultValue] of Object.entries(mergedDefaults)) {
+            if (defaultValue === undefined)
+                continue;
+            if (inbound.has(handle))
+                continue; // Don't override wired inputs
+            if (effective[handle] !== undefined)
+                continue; // Already has value
+            if (dynamicHandles.has(handle))
+                continue; // Skip defaults for dynamic handles
+            // Clone to avoid shared references
+            effective[handle] =
+                typeof structuredClone === "function"
+                    ? structuredClone(defaultValue)
+                    : JSON.parse(JSON.stringify(defaultValue));
+        }
+        return effective;
+    }
     invalidateDownstream(nodeId) {
         // Notifies dependents; for now we propagate current outputs
         for (const e of this.edges.filter((e) => e.source.nodeId === nodeId)) {
@@ -1092,12 +1121,13 @@ class GraphRuntime {
         // call onActivated for nodes that implement it
         for (const node of this.nodes.values()) {
             const ctrl = new AbortController();
+            const effectiveInputs = this.getEffectiveInputs(node.nodeId);
             const ctx = {
                 state: node.state,
                 setState: (next) => Object.assign(node.state, next),
                 emit: (handle, value) => this.propagate(node.nodeId, handle, value),
                 invalidateDownstream: () => this.invalidateDownstream(node.nodeId),
-                getInput: (handle) => node.inputs[handle],
+                getInput: (handle) => effectiveInputs[handle],
                 environment: this.environment,
                 runId: `${node.nodeId}:activation`,
                 abortSignal: ctrl.signal,
@@ -1125,12 +1155,13 @@ class GraphRuntime {
         if (!node)
             return;
         const ctrl = new AbortController();
+        const effectiveInputs = this.getEffectiveInputs(nodeId);
         const ctx = {
             state: node.state,
             setState: (next) => Object.assign(node.state, next),
             emit: (handle, value) => this.propagate(nodeId, handle, value),
             invalidateDownstream: () => this.invalidateDownstream(nodeId),
-            getInput: (handle) => node.inputs[handle],
+            getInput: (handle) => effectiveInputs[handle],
             environment: this.environment,
             runId: `${nodeId}:external`,
             abortSignal: ctrl.signal,
@@ -1387,16 +1418,18 @@ class GraphRuntime {
                         queued: 0,
                         progress: 0,
                     },
+                    initialInputs: n.initialInputs ?? {},
                 };
                 this.nodes.set(n.nodeId, rn);
                 // Activate new node
                 const ctrl = new AbortController();
+                const effectiveInputs = this.getEffectiveInputs(rn.nodeId);
                 const ctx = {
                     state: rn.state,
                     setState: (next) => Object.assign(rn.state, next),
                     emit: (handle, value) => this.propagate(rn.nodeId, handle, value),
                     invalidateDownstream: () => this.invalidateDownstream(rn.nodeId),
-                    getInput: (handle) => rn.inputs[handle],
+                    getInput: (handle) => effectiveInputs[handle],
                     environment: this.environment,
                     runId: `${rn.nodeId}:activation`,
                     abortSignal: ctrl.signal,
@@ -1409,8 +1442,9 @@ class GraphRuntime {
                 rn.runtime.onActivated?.(ctx);
             }
             else {
-                // update params/policy
+                // update params/policy and initialInputs
                 existing.params = n.params;
+                existing.initialInputs = n.initialInputs ?? {};
                 if (!existing.stats) {
                     existing.stats = {
                         runs: 0,
@@ -1464,32 +1498,7 @@ class GraphRuntime {
                     }
                 }
             }
-            // If input lost inbound, try to re-seed from defaults
             if (changed) {
-                const defNode = def.nodes.find((n) => n.nodeId === nodeId);
-                if (defNode) {
-                    const desc = registry.nodes.get(defNode.typeId);
-                    if (desc) {
-                        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)) {
-                            if (!currSet.has(h) && node.inputs[h] === undefined) {
-                                const v = merged[h];
-                                if (v !== undefined)
-                                    node.inputs[h] =
-                                        typeof structuredClone === "function"
-                                            ? structuredClone(v)
-                                            : JSON.parse(JSON.stringify(v));
-                            }
-                        }
-                    }
-                }
                 // Clear buckets for handles that lost inbound
                 const bucketsForNode = this.arrayInputBuckets.get(nodeId);
                 if (bucketsForNode) {
@@ -1547,34 +1556,6 @@ 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) {
@@ -1653,30 +1634,6 @@ class GraphRuntime {
             return;
         this.resolvedByNode.set(nodeId, next);
         this.updateNodeHandles(nodeId, next, registry);
-        // Seed defaults for newly introduced inputs that are not inbound
-        const inbound = this.edges
-            .filter((e) => e.target.nodeId === nodeId)
-            .map((e) => e.target.handle);
-        for (const [handle, value] of Object.entries(inputDefaults)) {
-            if (value === undefined)
-                continue;
-            if (inbound.includes(handle))
-                continue;
-            if (node.inputs[handle] === undefined) {
-                node.inputs[handle] =
-                    typeof structuredClone === "function"
-                        ? structuredClone(value)
-                        : JSON.parse(JSON.stringify(value));
-                // Emit input value event for seeded defaults
-                this.emit("value", {
-                    nodeId,
-                    handle,
-                    value: node.inputs[handle],
-                    io: "input",
-                    runtimeTypeId: getTypedOutputTypeId(node.inputs[handle]),
-                });
-            }
-        }
         // Notify graph updated for UI parity
         this.emit("invalidate", { reason: "graph-updated" });
     }