@bian-womp/spark-graph 0.3.23 → 0.3.25

package/lib/cjs/index.cjs

@@ -2778,6 +2778,8 @@ class GraphRuntime {
     }
     static create(def, registry, opts) {
         const gr = new GraphRuntime();
+        if (opts?.startPaused)
+            gr.pause();
         gr.environment = opts?.environment ?? {};
         // Set registry and environment on components
         gr.graph.setRegistry(registry);
@@ -2785,7 +2787,15 @@ class GraphRuntime {
         gr.handleResolver.setEnvironment(gr.environment);
         gr.nodeExecutor.setEnvironment(gr.environment);
         // Precompute per-node resolved handles (use def-provided overrides; do not compute dynamically here)
-        const initial = tryHandleResolving(def, registry, gr.environment);
+        const initial = gr.pauseRefCount
+            ? {
+                resolved: new Map(),
+                pending: new Set(),
+            }
+            : tryHandleResolving(def, registry, gr.environment);
+        if (gr.pauseRefCount) {
+            gr.handleResolvingSkippedRef = def;
+        }
         for (const [nodeId, handles] of initial.resolved) {
             gr.graph.setResolvedHandles(nodeId, handles);
         }
@@ -3089,6 +3099,20 @@ class GraphRuntime {
         if (this.persistentPauseToken) {
             this.persistentPauseToken();
             this.persistentPauseToken = null;
+            // If handle resolving was skipped, trigger it now
+            if (this.handleResolvingSkippedRef) {
+                const registry = this.graph.getRegistry();
+                if (registry) {
+                    const result = tryHandleResolving(this.handleResolvingSkippedRef, registry, this.environment);
+                    for (const [nodeId, handles] of result.resolved) {
+                        this.graph.setResolvedHandles(nodeId, handles);
+                    }
+                    for (const nodeId of result.pending) {
+                        this.handleResolver.scheduleRecomputeHandles(nodeId);
+                    }
+                }
+                this.handleResolvingSkippedRef = undefined;
+            }
         }
     }
     copyOutputs(fromNodeId, toNodeId, options) {
@@ -3276,7 +3300,15 @@ class GraphRuntime {
             });
             {
                 // Update handles and edges
-                const result = tryHandleResolving(def, registry, this.environment);
+                const result = this.pauseRefCount
+                    ? {
+                        resolved: new Map(),
+                        pending: new Set(),
+                    }
+                    : tryHandleResolving(def, registry, this.environment);
+                if (this.pauseRefCount) {
+                    this.handleResolvingSkippedRef = def;
+                }
                 const changedHandles = {};
                 for (const [nodeId, newHandles] of result.resolved) {
                     const oldHandles = this.graph.getResolvedHandles(nodeId);
@@ -5552,17 +5584,19 @@ function offsetImportedPositions(targetPositions, sourcePositions, sourceDef, no
 }
 function buildTypeMaps(def) {
     const nodeTypeMap = new Map();
-    const handleTypeMap = new Map();
+    const inputHandleTypeMap = new Map();
+    const outputHandleTypeMap = new Map();
     for (const node of def.nodes) {
         nodeTypeMap.set(node.nodeId, node.typeId);
-        const nodeHandleTypes = new Map();
+        const nodeInputTypes = new Map();
+        const nodeOutputTypes = new Map();
         if (node.resolvedHandles?.inputs) {
             for (const [handleId, handleDesc] of Object.entries(node.resolvedHandles.inputs)) {
                 const typeId = typeof handleDesc === "string"
                     ? handleDesc
                     : handleDesc?.typeId;
                 if (typeId)
-                    nodeHandleTypes.set(handleId, typeId);
+                    nodeInputTypes.set(handleId, typeId);
             }
         }
         if (node.resolvedHandles?.outputs) {
@@ -5573,14 +5607,33 @@ function buildTypeMaps(def) {
                         ? handleDesc[0]
                         : undefined;
                 if (typeId)
-                    nodeHandleTypes.set(handleId, typeId);
+                    nodeOutputTypes.set(handleId, typeId);
             }
         }
-        if (nodeHandleTypes.size > 0) {
-            handleTypeMap.set(node.nodeId, nodeHandleTypes);
+        // Also include handles from inputDefaults - they share handle IDs with inputs
+        if (node.resolvedHandles?.inputDefaults) {
+            for (const handleId of Object.keys(node.resolvedHandles.inputDefaults)) {
+                // If not already in map, try to get type from input handles
+                if (!nodeInputTypes.has(handleId) && node.resolvedHandles?.inputs) {
+                    const inputDesc = node.resolvedHandles.inputs[handleId];
+                    if (inputDesc) {
+                        const typeId = typeof inputDesc === "string"
+                            ? inputDesc
+                            : inputDesc?.typeId;
+                        if (typeId)
+                            nodeInputTypes.set(handleId, typeId);
+                    }
+                }
+            }
+        }
+        if (nodeInputTypes.size > 0) {
+            inputHandleTypeMap.set(node.nodeId, nodeInputTypes);
+        }
+        if (nodeOutputTypes.size > 0) {
+            outputHandleTypeMap.set(node.nodeId, nodeOutputTypes);
         }
     }
-    return { nodeTypeMap, handleTypeMap };
+    return { nodeTypeMap, inputHandleTypeMap, outputHandleTypeMap };
 }
 function applyConversion(items, values, converter, type) {
     for (const item of items) {
@@ -5608,21 +5661,21 @@ function applyConversion(items, values, converter, type) {
         }
     }
 }
-function collectValuesToConvert(values, nodeTypeMap, handleTypeMap, originalNodeIdMap) {
+function collectValuesToConvert(values, nodeTypeMap, inputHandleTypeMap, outputHandleTypeMap, type) {
     const converted = {};
     const toConvert = [];
+    const handleTypeMap = type === "output" ? outputHandleTypeMap : inputHandleTypeMap;
     for (const [nodeId, nodeValues] of Object.entries(values)) {
         converted[nodeId] = { ...nodeValues };
-        const originalNodeId = nodeId;
-        const nodeTypeId = nodeTypeMap.get(originalNodeId);
+        const nodeTypeId = nodeTypeMap.get(nodeId);
         for (const [handleId, value] of Object.entries(nodeValues)) {
-            const handleDataType = handleTypeMap.get(originalNodeId)?.get(handleId);
+            const handleDataType = handleTypeMap.get(nodeId)?.get(handleId);
             const runtimeTypeId = isTypedOutput(value)
                 ? getTypedOutputTypeId(value)
                 : undefined;
             toConvert.push({
                 nodeId,
-                originalNodeId,
+                originalNodeId: nodeId,
                 handleId,
                 value,
                 nodeTypeId,
@@ -5635,16 +5688,16 @@ function collectValuesToConvert(values, nodeTypeMap, handleTypeMap, originalNode
 }
 function convertSnapshot(snapshot, converter) {
     const def = snapshot.def ?? { nodes: [], edges: [] };
-    const { nodeTypeMap, handleTypeMap } = buildTypeMaps(def);
+    const { nodeTypeMap, inputHandleTypeMap, outputHandleTypeMap } = buildTypeMaps(def);
     const inputDefaults = {};
     for (const node of def.nodes) {
         if (node.resolvedHandles?.inputDefaults) {
             inputDefaults[node.nodeId] = { ...node.resolvedHandles.inputDefaults };
         }
     }
-    const { converted: convertedInputs, toConvert: inputsToConvert } = collectValuesToConvert(snapshot.inputs ?? {}, nodeTypeMap, handleTypeMap);
-    const { converted: convertedOutputs, toConvert: outputsToConvert } = collectValuesToConvert(snapshot.outputs ?? {}, nodeTypeMap, handleTypeMap);
-    const { converted: convertedInputDefaults, toConvert: inputDefaultsToConvert, } = collectValuesToConvert(inputDefaults, nodeTypeMap, handleTypeMap);
+    const { converted: convertedInputs, toConvert: inputsToConvert } = collectValuesToConvert(snapshot.inputs ?? {}, nodeTypeMap, inputHandleTypeMap, outputHandleTypeMap, "input");
+    const { converted: convertedOutputs, toConvert: outputsToConvert } = collectValuesToConvert(snapshot.outputs ?? {}, nodeTypeMap, inputHandleTypeMap, outputHandleTypeMap, "output");
+    const { converted: convertedInputDefaults, toConvert: inputDefaultsToConvert, } = collectValuesToConvert(inputDefaults, nodeTypeMap, inputHandleTypeMap, outputHandleTypeMap, "inputDefault");
     applyConversion(inputsToConvert, convertedInputs, converter, "input");
     applyConversion(outputsToConvert, convertedOutputs, converter, "output");
     applyConversion(inputDefaultsToConvert, convertedInputDefaults, converter, "inputDefault");
@@ -5675,7 +5728,7 @@ function convertSnapshot(snapshot, converter) {
         outputs: convertedOutputs,
     };
 }
-function mergeInputsOutputs(targetInputs, targetOutputs, sourceInputs, sourceOutputs, targetInputDefaults, sourceInputDefaults, nodeIdMap, nodeTypeMap, handleTypeMap) {
+function mergeInputsOutputs(targetInputs, targetOutputs, sourceInputs, sourceOutputs, targetInputDefaults, sourceInputDefaults, nodeIdMap, nodeTypeMap, inputHandleTypeMap, outputHandleTypeMap) {
     const mergedInputs = { ...targetInputs };
     const mergedOutputs = { ...targetOutputs };
     const mergedInputDefaults = { ...targetInputDefaults };
@@ -5690,7 +5743,7 @@ function mergeInputsOutputs(targetInputs, targetOutputs, sourceInputs, sourceOut
             }
             const nodeTypeId = nodeTypeMap?.get(oldId);
             for (const [handleId, value] of Object.entries(inputs)) {
-                const handleDataType = handleTypeMap?.get(oldId)?.get(handleId);
+                const handleDataType = inputHandleTypeMap?.get(oldId)?.get(handleId);
                 inputsToConvert.push({
                     nodeId: newId,
                     originalNodeId: oldId,
@@ -5711,7 +5764,7 @@ function mergeInputsOutputs(targetInputs, targetOutputs, sourceInputs, sourceOut
             }
             const nodeTypeId = nodeTypeMap?.get(oldId);
             for (const [handleId, value] of Object.entries(outputs)) {
-                const handleDataType = handleTypeMap?.get(oldId)?.get(handleId);
+                const handleDataType = outputHandleTypeMap?.get(oldId)?.get(handleId);
                 const runtimeTypeId = isTypedOutput(value)
                     ? getTypedOutputTypeId(value)
                     : undefined;
@@ -5736,7 +5789,7 @@ function mergeInputsOutputs(targetInputs, targetOutputs, sourceInputs, sourceOut
             }
             const nodeTypeId = nodeTypeMap?.get(oldId);
             for (const [handleId, value] of Object.entries(defaults)) {
-                const handleDataType = handleTypeMap?.get(oldId)?.get(handleId);
+                const handleDataType = inputHandleTypeMap?.get(oldId)?.get(handleId);
                 inputDefaultsToConvert.push({
                     nodeId: newId,
                     originalNodeId: oldId,
@@ -5760,8 +5813,8 @@ function mergeInputsOutputs(targetInputs, targetOutputs, sourceInputs, sourceOut
 }
 function mergeSnapshotData(targetSnapshot, sourceSnapshot, targetInputDefaults, sourceInputDefaults, nodeIdMap) {
     const sourceDef = sourceSnapshot.def ?? { nodes: []};
-    const { nodeTypeMap, handleTypeMap } = buildTypeMaps(sourceDef);
-    return mergeInputsOutputs(targetSnapshot.inputs ?? {}, targetSnapshot.outputs ?? {}, sourceSnapshot.inputs ?? {}, sourceSnapshot.outputs ?? {}, targetInputDefaults, sourceInputDefaults, nodeIdMap, nodeTypeMap, handleTypeMap);
+    const { nodeTypeMap, inputHandleTypeMap, outputHandleTypeMap } = buildTypeMaps(sourceDef);
+    return mergeInputsOutputs(targetSnapshot.inputs ?? {}, targetSnapshot.outputs ?? {}, sourceSnapshot.inputs ?? {}, sourceSnapshot.outputs ?? {}, targetInputDefaults, sourceInputDefaults, nodeIdMap, nodeTypeMap, inputHandleTypeMap, outputHandleTypeMap);
 }
 function mergeSnapshots(targetSnapshot, sourceSnapshot, converter) {
     const targetDef = targetSnapshot.def ?? { nodes: [], edges: [] };