@bian-womp/spark-graph 0.3.58 → 0.3.60

package/lib/cjs/index.cjs

@@ -919,14 +919,6 @@ class Graph {
     setResolvedHandles(nodeId, handles) {
         this.resolvedByNode.set(nodeId, handles);
     }
-    /**
-     * Iterate over resolved handles safely
-     */
-    forEachResolvedHandles(callback) {
-        for (const [nodeId, handles] of this.resolvedByNode.entries()) {
-            callback(handles, nodeId);
-        }
-    }
     // ==================== Utility Methods ====================
     /**
      * Check if all inbound edges for a node have values
@@ -2128,11 +2120,11 @@ function tryHandleResolving(def, registry, environment) {
     }
     return { resolved: out, pending };
 }
-function buildEdges(def, registry, resolvedByNode) {
+function buildEdges(def, registry, graph) {
     return def.edges.map((e) => {
         const srcNode = def.nodes.find((n) => n.nodeId === e.source.nodeId);
         const dstNode = def.nodes.find((n) => n.nodeId === e.target.nodeId);
-        const { srcDeclared, dstDeclared } = extractEdgeTypes(e.source.nodeId, e.source.handle, e.target.nodeId, e.target.handle, resolvedByNode);
+        const { srcDeclared, dstDeclared } = extractEdgeTypes(e.source.nodeId, e.source.handle, e.target.nodeId, e.target.handle, registry, graph);
         const { convert, convertAsync } = buildEdgeConverters(srcDeclared, dstDeclared, registry, `buildEdges: ${srcNode?.typeId || ""}.${e.source.nodeId}.${e.source.handle} -> ${dstNode?.typeId || ""}.${e.target.nodeId}.${e.target.handle}`);
         return {
             id: e.id,
@@ -2152,15 +2144,13 @@ function buildEdges(def, registry, resolvedByNode) {
  * Used by both buildEdges and updateNodeHandles to avoid duplication
  * Now supports union types on both source (output) and destination (input) handles
  */
-function extractEdgeTypes(sourceNodeId, sourceHandle, targetNodeId, targetHandle, resolvedByNode) {
-    const srcResolved = resolvedByNode.get(sourceNodeId);
-    const dstResolved = resolvedByNode.get(targetNodeId);
+function extractEdgeTypes(sourceNodeId, sourceHandle, targetNodeId, targetHandle, registry, graph) {
+    const srcResolved = graph.getResolvedHandles(sourceNodeId);
+    const dstResolved = graph.getResolvedHandles(targetNodeId);
     const srcDeclared = srcResolved
         ? srcResolved.outputs[sourceHandle]
-        : undefined;
-    const dstDeclared = dstResolved
-        ? getInputDeclaredTypes(dstResolved.inputs, targetHandle)
-        : undefined;
+        : registry.nodes.get(sourceNodeId)?.outputs[sourceHandle];
+    const dstDeclared = getInputDeclaredTypes(dstResolved ? dstResolved.inputs : registry.nodes.get(targetNodeId)?.inputs, targetHandle);
     return {
         srcDeclared,
         dstDeclared,
@@ -2426,10 +2416,6 @@ class HandleResolver {
         if (!node)
             return;
         this.graph.setResolvedHandles(nodeId, handles);
-        const resolvedByNode = new Map();
-        this.graph.forEachResolvedHandles((handles, nodeId) => {
-            resolvedByNode.set(nodeId, handles);
-        });
         const registry = this.registry; // Store for use in callback
         this.graph.forEachEdge((e, _index) => {
             // Only update edges that touch the changed node
@@ -2440,7 +2426,7 @@ class HandleResolver {
             const dstNode = this.graph.getNode(e.target.nodeId);
             const oldDstDeclared = e.dstDeclared;
             // Extract edge types using shared helper (handles both source and target updates)
-            const { srcDeclared, dstDeclared } = extractEdgeTypes(e.source.nodeId, e.source.handle, e.target.nodeId, e.target.handle, resolvedByNode);
+            const { srcDeclared, dstDeclared } = extractEdgeTypes(e.source.nodeId, e.source.handle, e.target.nodeId, e.target.handle, registry, this.graph);
             // Update converters
             const conv = buildEdgeConverters(srcDeclared, dstDeclared, registry, `updateNodeHandles: ${srcNode?.typeId || ""}.${e.source.nodeId}.${e.source.handle} -> ${dstNode?.typeId || ""}.${e.target.nodeId}.${e.target.handle}`);
             // Update edge properties via Graph
@@ -2573,31 +2559,15 @@ class HandleResolver {
  * EdgePropagator component - handles value propagation through edges
  */
 class EdgePropagator {
-    constructor(graph, eventEmitter, runContextManager, handleResolver, nodeExecutor) {
+    constructor(graph, eventEmitter, runContextManager, handleResolver, nodeExecutor, runtime) {
         this.graph = graph;
         this.eventEmitter = eventEmitter;
         this.runContextManager = runContextManager;
         this.handleResolver = handleResolver;
         this.nodeExecutor = nodeExecutor;
+        this.runtime = runtime;
         this.arrayInputBuckets = new Map();
     }
-    /**
-     * Propagate value through edges
-     * @param runContextIds - Optional set of run-context IDs. If provided, propagation is run-context aware.
-     *                        If undefined or empty, behaves like auto mode (always propagates values and execution).
-     */
-    propagate(srcNodeId, srcHandle, value, runContextIds) {
-        // Set source output
-        if (!this.setSourceOutput(srcNodeId, srcHandle, value)) {
-            return; // Node was removed
-        }
-        // Find outgoing edges
-        const outEdges = this.findOutgoingEdges(srcNodeId, srcHandle);
-        // Process each edge
-        for (const edge of outEdges) {
-            this.propagateToEdge(edge, value, srcNodeId, runContextIds);
-        }
-    }
     /**
      * Set source output value and emit event
      */
@@ -2686,6 +2656,9 @@ class EdgePropagator {
         if (edge.convert) {
             convertedValue = edge.convert(value);
         }
+        else {
+            console.warn(`No convert function for edge ${edge.id} of type ${edge.source.nodeId}.${edge.source.handle} -> ${edge.target.nodeId}.${edge.target.handle}`);
+        }
         this.applyToTarget(edge, convertedValue, effectiveRunContexts);
     }
     /**
@@ -2906,11 +2879,32 @@ class EdgePropagator {
             this.runContextManager.finishEdgeConversion(id, edgeId);
         }
     }
+    /**
+     * Propagate value through edges
+     * @param runContextIds - Optional set of run-context IDs. If provided, propagation is run-context aware.
+     *                        If undefined or empty, behaves like auto mode (always propagates values and execution).
+     */
+    propagate(srcNodeId, srcHandle, value, runContextIds) {
+        if (this.runtime.isPaused())
+            return;
+        // Set source output
+        if (!this.setSourceOutput(srcNodeId, srcHandle, value)) {
+            return; // Node was removed
+        }
+        // Find outgoing edges
+        const outEdges = this.findOutgoingEdges(srcNodeId, srcHandle);
+        // Process each edge
+        for (const edge of outEdges) {
+            this.propagateToEdge(edge, value, srcNodeId, runContextIds);
+        }
+    }
     /**
      * Re-emit all outputs from a node (used when graph updates)
      * Only re-emits outputs that are valid according to resolved handles
      */
     invalidateDownstream(nodeId) {
+        if (this.runtime.isPaused())
+            return;
         const node = this.graph.getNode(nodeId);
         if (!node)
             return;
@@ -3653,7 +3647,7 @@ class GraphRuntime {
         this.graph = new Graph(this.eventEmitter);
         this.runContextManager = new RunContextManager(this.graph, "warn");
         this.handleResolver = new HandleResolver(this.graph, this.eventEmitter, this.runContextManager, this);
-        this.edgePropagator = new EdgePropagator(this.graph, this.eventEmitter, this.runContextManager, this.handleResolver, this);
+        this.edgePropagator = new EdgePropagator(this.graph, this.eventEmitter, this.runContextManager, this.handleResolver, this, this);
         // Create NodeExecutor with EdgePropagator and HandleResolver
         this.nodeExecutor = new NodeExecutor(this.graph, this.eventEmitter, this.runContextManager, this.handleResolver, this, this);
         // Create RuntimeValidatorManager
@@ -3729,11 +3723,7 @@ class GraphRuntime {
             gr.graph.setNode(n.nodeId, rn);
         }
         // Instantiate edges
-        const resolvedByNode = new Map();
-        gr.graph.forEachResolvedHandles((handles, nodeId) => {
-            resolvedByNode.set(nodeId, handles);
-        });
-        const edges = buildEdges(def, registry, resolvedByNode);
+        const edges = buildEdges(def, registry, gr.graph);
         gr.graph.setEdges(edges);
         // Schedule async recompute only for nodes that indicated Promise-based resolveHandles
         for (const nodeId of initial.pending) {
@@ -4241,11 +4231,7 @@ class GraphRuntime {
                 for (const [nodeId, handles] of result.resolved) {
                     this.graph.setResolvedHandles(nodeId, handles);
                 }
-                const resolvedByNode = new Map();
-                this.graph.forEachResolvedHandles((handles, nodeId) => {
-                    resolvedByNode.set(nodeId, handles);
-                });
-                const afterEdges = buildEdges(def, registry, resolvedByNode);
+                const afterEdges = buildEdges(def, registry, this.graph);
                 this.graph.setEdges(afterEdges);
                 for (const nodeId of result.pending) {
                     this.handleResolver.scheduleRecomputeHandles(nodeId);