@bian-womp/spark-graph 0.3.65 → 0.3.67

package/lib/cjs/index.cjs

@@ -76,6 +76,7 @@ function mergeInputHandleDescriptors(staticDesc, dynamicDesc) {
     const merged = {
         typeId: dynamicObj.typeId ?? staticObj.typeId,
         private: dynamicObj.private ?? staticObj.private,
+        defaultPolicy: dynamicObj.defaultPolicy ?? staticObj.defaultPolicy,
     };
     // Merge metadata if either has it
     if (staticObj.metadata || dynamicObj.metadata) {
@@ -2313,18 +2314,31 @@ function getEffectiveInputs(nodeId, graph, registry) {
     // Build set of inbound handles (wired inputs)
     const inboundEdges = graph.getInboundEdges(nodeId);
     const inbound = new Set(inboundEdges.map((e) => e.target.handle));
+    const getDefaultPolicy = (handle) => {
+        const resolvedDesc = resolved?.inputs?.[handle];
+        const staticDesc = desc.inputs?.[handle];
+        const pick = (d) => d && typeof d === "object" && "typeId" in d ? d.defaultPolicy : undefined;
+        return pick(resolvedDesc) ?? pick(staticDesc);
+    };
     // Apply defaults only for:
     // 1. Unbound handles that have no explicit value
     // 2. Static handles (not dynamically resolved)
     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
+        const policy = getDefaultPolicy(handle);
+        if (policy === "bound") {
+            if (!inbound.has(handle))
+                continue;
+        }
+        else {
+            if (inbound.has(handle))
+                continue;
+        }
         // Clone to avoid shared references
         effective[handle] = structuredClone(defaultValue);
     }
@@ -2947,11 +2961,15 @@ class NodeExecutor {
         this.edgePropagator = edgePropagator;
         this.runtime = runtime;
         this.environment = {};
+        this.customNodeData = {};
         this.environment = environment ?? {};
     }
     setEnvironment(environment) {
         this.environment = environment;
     }
+    setCustomNodeData(customNodeData) {
+        this.customNodeData = customNodeData;
+    }
     /**
      * Compute effective inputs for a node by merging real inputs with defaults
      */
@@ -3020,6 +3038,7 @@ class NodeExecutor {
             },
             getInput: (handle) => inputs[handle],
             environment: this.environment,
+            customNodeData: this.customNodeData[nodeId],
             runId,
             abortSignal,
             reportProgress,
@@ -3638,6 +3657,7 @@ class GraphRuntime {
     constructor() {
         // State
         this.environment = {};
+        this.customNodeData = {};
         this.runMode = null;
         this.pauseRefCount = 0;
         this.persistentPauseToken = null;
@@ -3657,11 +3677,13 @@ class GraphRuntime {
         if (opts?.startPaused)
             gr.pause();
         gr.environment = opts?.environment ?? {};
+        gr.customNodeData = {};
         // Set registry and environment on components
         gr.graph.setRegistry(registry);
         gr.handleResolver.setRegistry(registry);
         gr.handleResolver.setEnvironment(gr.environment);
         gr.nodeExecutor.setEnvironment(gr.environment);
+        gr.nodeExecutor.setCustomNodeData(gr.customNodeData);
         gr.runtimeValidatorManager.setRegistry(registry);
         // Precompute per-node resolved handles (use def-provided overrides; do not compute dynamically here)
         const initial = gr.isPaused()
@@ -3883,6 +3905,13 @@ class GraphRuntime {
             this.handleResolver.scheduleRecomputeHandles(nodeId);
         }
     }
+    setCustomNodeData(customNodeData) {
+        this.customNodeData = { ...customNodeData };
+        this.nodeExecutor.setCustomNodeData(this.customNodeData);
+    }
+    getCustomNodeData() {
+        return { ...this.customNodeData };
+    }
     /**
      * Register a runtime validator that will be called before node execution.
      * Validators are called in registration order - if any returns true, execution is blocked.