@bian-womp/spark-graph 0.3.35 → 0.3.37

package/lib/cjs/index.cjs

@@ -1148,6 +1148,7 @@ class RunContextManager {
             pendingNodes: 0,
             pendingEdges: 0,
             pendingResolvers: 0,
+            pendingQueued: 0,
             skipPropagateValues: options?.skipPropagateValues ?? false,
             propagate: options?.propagate ?? true,
             resolve,
@@ -1179,6 +1180,47 @@ class RunContextManager {
     hasActiveRunContexts() {
         return this.runContexts.size > 0;
     }
+    /**
+     * Increment queued work count for a run-context.
+     * Used by asyncConcurrency: "queue" to keep contexts alive while work is queued.
+     */
+    incrementQueued(id, nodeId) {
+        const ctx = this.runContexts.get(id);
+        if (!ctx) {
+            this.logger.debug("increment-queued-context-not-found", {
+                runContextId: id,
+                nodeId,
+            });
+            return;
+        }
+        ctx.pendingQueued++;
+        this.logger.debug("increment-queued", {
+            runContextId: id,
+            nodeId,
+            pendingQueued: ctx.pendingQueued,
+        });
+    }
+    /**
+     * Decrement queued work count for a run-context.
+     * Called when queued work is either started or dropped.
+     */
+    decrementQueued(id, nodeId) {
+        const ctx = this.runContexts.get(id);
+        if (!ctx) {
+            this.logger.debug("decrement-queued-context-not-found", {
+                runContextId: id,
+                nodeId,
+            });
+            return;
+        }
+        ctx.pendingQueued--;
+        this.logger.debug("decrement-queued", {
+            runContextId: id,
+            nodeId,
+            pendingQueued: ctx.pendingQueued,
+        });
+        this.finishRunContextIfPossible(id);
+    }
     startNodeRun(id, nodeId) {
         const ctx = this.runContexts.get(id);
         if (!ctx) {
@@ -1291,7 +1333,8 @@ class RunContextManager {
         }
         if (ctx.pendingNodes > 0 ||
             ctx.pendingEdges > 0 ||
-            ctx.pendingResolvers > 0) {
+            ctx.pendingResolvers > 0 ||
+            ctx.pendingQueued > 0) {
             return; // Still has pending work
         }
         this.logger.info("finish-run-context", {
@@ -1842,8 +1885,6 @@ class HandleResolver {
             if ((this.recomputeTokenByNode.get(nodeId) ?? 0) !== token)
                 return;
             const before = this.graph.getResolvedHandles(nodeId);
-            if (!before)
-                return;
             // Re-fetch desc to ensure we have the latest (node might have been updated)
             const nodeDesc = this.registry.nodes.get(node.typeId);
             if (!nodeDesc)
@@ -1872,8 +1913,9 @@ class HandleResolver {
                 ...resolved?.inputDefaults,
             };
             const after = { inputs, outputs, inputDefaults };
-            // Compare shallow-structurally via JSON
-            if (JSON.stringify(before) === JSON.stringify(after))
+            // If we have prior handles, skip update when unchanged; for new nodes (no before),
+            // always write the resolved handles.
+            if (before && JSON.stringify(before) === JSON.stringify(after))
                 return;
             // Call GraphRuntime's updateNodeHandles to update edges and re-propagate values
             // Note: updateNodeHandles will set the resolved handles internally
@@ -2460,8 +2502,8 @@ class NodeExecutor {
         }
         // Handle debouncing
         const now = Date.now();
-        if (this.shouldDebounce(nodeId, node, now)) {
-            this.handleDebouncedSchedule(node, nodeId, now);
+        if (this.shouldDebounce(node, now)) {
+            this.handleDebouncedSchedule(node, nodeId, now, runContextIds);
             return;
         }
         // Prepare execution plan
@@ -2472,7 +2514,7 @@ class NodeExecutor {
     /**
      * Check if execution should be debounced
      */
-    shouldDebounce(nodeId, node, now) {
+    shouldDebounce(node, now) {
         const policy = node.policy ?? {};
         const lastScheduledAt = node.lastScheduledAt;
         return !!(policy.debounceMs &&
@@ -2482,13 +2524,23 @@ class NodeExecutor {
     /**
      * Handle debounced scheduling by replacing the latest queued item
      */
-    handleDebouncedSchedule(node, nodeId, now) {
+    handleDebouncedSchedule(node, nodeId, now, runContextIds) {
+        // Decrement pendingQueued for any existing queued items before replacing
+        if (node.queue.length > 0) {
+            this.decrementQueuedForPlans(node.queue, nodeId);
+        }
         const effectiveInputs = this.getEffectiveInputs(nodeId);
         const runSeq = this.graph.incrementNodeRunSeq(nodeId);
-        const rid = `${nodeId}:${runSeq}:${now}`;
-        this.graph.replaceNodeQueue(nodeId, [
-            { runId: rid, inputs: effectiveInputs },
-        ]);
+        const runId = `${nodeId}:${runSeq}:${now}`;
+        const policySnapshot = node.policy ? { ...node.policy } : undefined;
+        const plan = {
+            runId,
+            effectiveInputs,
+            runContextIdsForRun: runContextIds,
+            timestamp: now,
+            policy: policySnapshot,
+        };
+        this.graph.replaceNodeQueue(nodeId, [plan]);
     }
     /**
      * Prepare execution plan with all necessary information
@@ -2547,12 +2599,19 @@ class NodeExecutor {
         const currentNode = this.graph.getNode(nodeId);
         if (!currentNode)
             return;
-        this.graph.addToNodeQueue(nodeId, {
-            runId: plan.runId,
-            inputs: plan.effectiveInputs,
-        });
+        // Keep the originating run-context alive while work is queued by
+        // incrementing queued counters for the plan's run-contexts.
+        if (plan.runContextIdsForRun) {
+            for (const rcId of plan.runContextIdsForRun) {
+                this.runContextManager.incrementQueued(rcId, nodeId);
+            }
+        }
+        this.graph.addToNodeQueue(nodeId, plan);
         if (currentNode.queue.length > maxQ) {
-            this.graph.shiftNodeQueue(nodeId);
+            const dropped = this.graph.shiftNodeQueue(nodeId);
+            if (dropped) {
+                this.decrementQueuedForPlans(dropped, nodeId);
+            }
         }
         this.processQueue(node, nodeId);
     }
@@ -2570,18 +2629,12 @@ class NodeExecutor {
             if (!next)
                 return;
             this.graph.setNodeLatestRunId(nodeId, next.runId);
-            const policySnapshot = node.policy ? { ...node.policy } : undefined;
-            const activeRunContextIds = this.graph.getNodeRunContextIds(nodeId);
-            const plan = {
-                runId: next.runId,
-                effectiveInputs: next.inputs,
-                runContextIdsForRun: activeRunContextIds.size > 0 ? activeRunContextIds : undefined,
-                timestamp: Date.now(),
-                policy: policySnapshot,
-            };
-            this.startRun(node, nodeId, plan, () => {
+            // Start the run first (which increments pendingNodes), then decrement
+            // pendingQueued to ensure the run context stays alive.
+            this.startRun(node, nodeId, next, () => {
                 setTimeout(processNext, 0);
             });
+            this.decrementQueuedForPlans(next, nodeId);
         };
         processNext();
     }
@@ -2612,6 +2665,20 @@ class NodeExecutor {
             }
         }
     }
+    /**
+     * Decrement pendingQueued counters for plans' run-contexts.
+     * Used when queued work is being started, dropped, or cancelled.
+     */
+    decrementQueuedForPlans(plans, nodeId) {
+        const plansArray = Array.isArray(plans) ? plans : [plans];
+        for (const plan of plansArray) {
+            if (plan.runContextIdsForRun) {
+                for (const rcId of plan.runContextIdsForRun) {
+                    this.runContextManager.decrementQueued(rcId, nodeId);
+                }
+            }
+        }
+    }
     /**
      * Create execution controller and update node stats
      */
@@ -2840,6 +2907,10 @@ class NodeExecutor {
         }
         this.graph.clearNodeControllers(nodeId);
         this.graph.updateNodeStats(nodeId, { active: 0 });
+        // Decrement pendingQueued for any queued items before clearing the queue
+        if (node.queue.length > 0) {
+            this.decrementQueuedForPlans(node.queue, nodeId);
+        }
         this.graph.clearNodeQueue(nodeId);
     }
     /**