@bian-womp/spark-graph 0.3.17 → 0.3.19

package/lib/cjs/index.cjs

@@ -1532,7 +1532,7 @@ class HandleResolver {
         this.recomputeTokenByNode = new Map();
         this.environment = {};
         this.pendingResolutions = new Map();
-        this.pendingResolutionRunContexts = new Map();
+        this.isRecomputing = new Map();
         this.environment = environment ?? {};
     }
     setRegistry(registry) {
@@ -1541,33 +1541,12 @@ class HandleResolver {
     setEnvironment(environment) {
         this.environment = environment;
     }
-    /**
-     * Check if handle resolution is pending for a node
-     */
-    isResolvingHandles(nodeId) {
-        return this.pendingResolutions.has(nodeId);
-    }
     /**
      * Get the promise for pending handle resolution, or null if none
      */
     getPendingResolution(nodeId) {
         return this.pendingResolutions.get(nodeId) || null;
     }
-    /**
-     * Track additional run contexts for a pending resolution
-     */
-    trackRunContextsForPendingResolution(nodeId, runContextIds) {
-        if (!this.pendingResolutions.has(nodeId))
-            return;
-        const tracked = this.pendingResolutionRunContexts.get(nodeId) ?? new Set();
-        for (const runContextId of runContextIds) {
-            if (!tracked.has(runContextId)) {
-                this.runContextManager.startHandleResolution(runContextId, nodeId);
-                tracked.add(runContextId);
-            }
-        }
-        this.pendingResolutionRunContexts.set(nodeId, tracked);
-    }
     /**
      * Schedule async recomputation of handles for a node
      */
@@ -1578,27 +1557,43 @@ class HandleResolver {
         const node = this.graph.getNode(nodeId);
         if (!node)
             return;
+        // If already recomputing, increment token to mark that a new recompute is needed
+        // but don't schedule another concurrent execution
+        if (this.isRecomputing.get(nodeId)) {
+            const currentToken = this.recomputeTokenByNode.get(nodeId) ?? 0;
+            this.recomputeTokenByNode.set(nodeId, currentToken + 1);
+            return;
+        }
         // Track resolver start for all active run-contexts
         const activeRunContextIds = this.graph.getNodeRunContextIds(nodeId);
-        const trackedRunContextIds = new Set(activeRunContextIds);
         if (activeRunContextIds.size > 0) {
             for (const runContextId of activeRunContextIds) {
                 this.runContextManager.startHandleResolution(runContextId, nodeId);
             }
         }
+        // Mark as recomputing
+        this.isRecomputing.set(nodeId, true);
+        // Capture initial token before starting (will be incremented in recomputeHandlesForNode)
+        const initialToken = this.recomputeTokenByNode.get(nodeId) ?? 0;
         // Create and track the resolution promise
         const resolutionPromise = new Promise((resolve) => {
             setTimeout(async () => {
-                // Get all tracked run contexts (including any added during pending state)
-                const allTracked = this.pendingResolutionRunContexts.get(nodeId) ?? trackedRunContextIds;
-                await this.recomputeHandlesForNode(nodeId, allTracked.size > 0 ? allTracked : undefined);
+                await this.recomputeHandlesForNode(nodeId, activeRunContextIds);
                 this.pendingResolutions.delete(nodeId);
-                this.pendingResolutionRunContexts.delete(nodeId);
+                this.isRecomputing.delete(nodeId);
+                // Check if a new recompute was requested while we were running
+                // (token was incremented by another scheduleRecomputeHandles call)
+                const finalToken = this.recomputeTokenByNode.get(nodeId) ?? 0;
+                // After recomputeHandlesForNode, token should be initialToken + 1
+                // If finalToken > initialToken + 1, a new recompute was requested
+                if (finalToken > initialToken + 1) {
+                    // A new recompute was requested, schedule it now
+                    this.scheduleRecomputeHandles(nodeId);
+                }
                 resolve();
             }, 0);
         });
         this.pendingResolutions.set(nodeId, resolutionPromise);
-        this.pendingResolutionRunContexts.set(nodeId, trackedRunContextIds);
     }
     // Update resolved handles for a single node and refresh edge converters/types that touch it
     updateNodeHandles(nodeId, handles) {
@@ -2260,6 +2255,15 @@ class NodeExecutor {
             runId,
             abortSignal,
             reportProgress,
+            setCustomData: (data) => {
+                this.eventEmitter.emit("stats", {
+                    kind: "node-custom-data",
+                    nodeId,
+                    typeId: node.typeId,
+                    runId,
+                    data,
+                });
+            },
             log,
         };
     }
@@ -2304,23 +2308,27 @@ class NodeExecutor {
         }
         // Check if handles are being resolved - wait for resolution before executing
         // Do this AFTER setting up run contexts so handle resolution can track them
-        if (this.handleResolver && this.handleResolver.isResolvingHandles(nodeId)) {
-            // Track run contexts for the pending resolution
+        const pendingResolution = this.handleResolver.getPendingResolution(nodeId);
+        if (pendingResolution) {
             if (runContextIds && runContextIds.size > 0) {
-                this.handleResolver.trackRunContextsForPendingResolution(nodeId, runContextIds);
+                for (const id of runContextIds) {
+                    this.runContextManager.startHandleResolution(id, nodeId);
+                }
             }
-            const pendingResolution = this.handleResolver.getPendingResolution(nodeId);
-            if (pendingResolution) {
-                // Wait for resolution to complete, then re-execute
-                pendingResolution.then(() => {
-                    // Re-check node still exists and conditions
-                    const nodeAfter = this.graph.getNode(nodeId);
-                    if (nodeAfter) {
-                        this.execute(nodeId, runContextIds);
+            // Wait for resolution to complete, then re-execute
+            pendingResolution.then(() => {
+                // Re-check node still exists and conditions
+                const nodeAfter = this.graph.getNode(nodeId);
+                if (nodeAfter) {
+                    this.execute(nodeId, runContextIds);
+                }
+                if (runContextIds && runContextIds.size > 0) {
+                    for (const id of runContextIds) {
+                        this.runContextManager.finishHandleResolution(id, nodeId);
                     }
-                });
-                return;
-            }
+                }
+            });
+            return;
         }
         // Handle debouncing
         const now = Date.now();