@bian-womp/spark-graph 0.2.86 → 0.2.88

package/lib/cjs/index.cjs

@@ -760,6 +760,7 @@ class GraphRuntime {
                     this.emit("stats", {
                         kind: "node-progress",
                         nodeId,
+                        typeId: node.typeId,
                         runId,
                         progress: node.stats.progress,
                     });
@@ -776,15 +777,16 @@ class GraphRuntime {
                     await node.runtime.onInputsChanged?.(capturedInputs, ctx);
                 }
                 catch (err) {
-                    // Suppress errors caused by expected cancellations (switch, snapshot)
+                    // Suppress errors caused by expected cancellations
                     if (controller.signal.aborted) {
                         const reason = controller.signal.reason;
-                        if (reason === "switch" || reason === "snapshot") {
-                            return; // ignore switched/snapshot-cancelled runs
+                        if (reason === "switch" ||
+                            reason === "snapshot" ||
+                            reason === "node-deleted") {
+                            return; // Cancellation events are emitted separately, skip error handling
                         }
                     }
                     hadError = true;
-                    // Record last error for node
                     node.stats.lastError = err;
                     const retry = policy.retry;
                     if (retry && attempt < (retry.attempts ?? 0)) {
@@ -795,6 +797,10 @@ class GraphRuntime {
                     this.emit("error", { kind: "node-run", nodeId, runId, err });
                 }
                 finally {
+                    // Skip cleanup if node was deleted (cleanup already handled)
+                    if (!this.nodes.has(nodeId)) {
+                        return;
+                    }
                     if (timeoutId)
                         clearTimeout(timeoutId);
                     node.activeControllers.delete(controller);
@@ -805,15 +811,21 @@ class GraphRuntime {
                         node.stats.lastStartAt && node.stats.lastEndAt
                             ? node.stats.lastEndAt - node.stats.lastStartAt
                             : undefined;
-                    // Clear lastError upon successful completion
                     if (!hadError)
                         node.stats.lastError = undefined;
-                    this.emit("stats", {
-                        kind: "node-done",
-                        nodeId,
-                        runId,
-                        durationMs: node.stats.lastDurationMs,
-                    });
+                    // Only emit node-done if not cancelled (cancellation events emitted separately)
+                    const isCancelled = controller.signal.aborted &&
+                        (controller.signal.reason === "snapshot" ||
+                            controller.signal.reason === "node-deleted");
+                    if (!isCancelled) {
+                        this.emit("stats", {
+                            kind: "node-done",
+                            nodeId,
+                            typeId: node.typeId,
+                            runId,
+                            durationMs: node.stats.lastDurationMs,
+                        });
+                    }
                     ctx.log("debug", "node-done", {
                         durationMs: node.stats.lastDurationMs,
                         hadError,
@@ -823,7 +835,12 @@ class GraphRuntime {
                 }
             };
             // fire node-start event
-            this.emit("stats", { kind: "node-start", nodeId, runId });
+            this.emit("stats", {
+                kind: "node-start",
+                nodeId,
+                typeId: node.typeId,
+                runId,
+            });
             ctx.log("debug", "node-start");
             exec(0);
         };
@@ -1019,6 +1036,7 @@ class GraphRuntime {
                 this.emit("stats", {
                     kind: "edge-start",
                     edgeId: e.id,
+                    typeId: e.typeId,
                     source: { nodeId: e.source.nodeId, handle: e.source.handle },
                     target: { nodeId: e.target.nodeId, handle: e.target.handle },
                 });
@@ -1039,6 +1057,7 @@ class GraphRuntime {
                     this.emit("stats", {
                         kind: "edge-done",
                         edgeId: e.id,
+                        typeId: e.typeId,
                         source: { nodeId: e.source.nodeId, handle: e.source.handle },
                         target: { nodeId: e.target.nodeId, handle: e.target.handle },
                         durationMs: e.stats.lastDurationMs,
@@ -1352,12 +1371,50 @@ class GraphRuntime {
     scheduleInputsChanged(nodeId) {
         this.scheduleInputsChangedInternal(nodeId);
     }
+    /**
+     * Cancel all active runs for a node and emit cancellation events
+     * @param node - The node to cancel runs for
+     * @param reason - The cancellation reason ("snapshot" | "node-deleted")
+     */
+    cancelNodeActiveRuns(node, reason) {
+        for (const controller of Array.from(node.activeControllers)) {
+            const runId = node.controllerRunIds.get(controller);
+            if (runId) {
+                // Track cancelled runIds for snapshot operations
+                if (reason === "snapshot") {
+                    if (!node.snapshotCancelledRunIds) {
+                        node.snapshotCancelledRunIds = new Set();
+                    }
+                    node.snapshotCancelledRunIds.add(runId);
+                }
+                // Emit cancellation event
+                this.emit("stats", {
+                    kind: "node-done",
+                    nodeId: node.nodeId,
+                    typeId: node.typeId,
+                    runId,
+                    cancelled: true,
+                });
+            }
+            try {
+                controller.abort(reason);
+            }
+            catch {
+                // ignore abort errors
+            }
+        }
+        node.activeControllers.clear();
+        node.controllerRunIds.clear();
+        node.stats.active = 0;
+        node.queue = [];
+    }
     cancelNodeRuns(nodeIds) {
         if (nodeIds.length === 0)
             return;
         const toCancel = new Set(nodeIds);
         const visited = new Set();
         const queue = [...nodeIds];
+        // Collect all downstream nodes to cancel
         for (let i = 0; i < queue.length; i++) {
             const nodeId = queue[i];
             if (visited.has(nodeId))
@@ -1373,29 +1430,12 @@ class GraphRuntime {
                 }
             }
         }
+        // Cancel runs for all affected nodes
         for (const nodeId of toCancel) {
             const node = this.nodes.get(nodeId);
             if (!node)
                 continue;
-            if (!node.snapshotCancelledRunIds) {
-                node.snapshotCancelledRunIds = new Set();
-            }
-            for (const controller of Array.from(node.activeControllers)) {
-                const rid = node.controllerRunIds.get(controller);
-                if (rid) {
-                    node.snapshotCancelledRunIds.add(rid);
-                }
-                try {
-                    controller.abort("snapshot");
-                }
-                catch {
-                    // ignore
-                }
-            }
-            node.activeControllers.clear();
-            node.controllerRunIds.clear();
-            node.stats.active = 0;
-            node.queue = [];
+            this.cancelNodeActiveRuns(node, "snapshot");
             node.runSeq += 1;
             const now = Date.now();
             node.latestRunId = `${nodeId}:${node.runSeq}:${now}:snapshot`;
@@ -1458,6 +1498,9 @@ class GraphRuntime {
         for (const nodeId of Array.from(currentIds)) {
             if (!desiredIds.has(nodeId)) {
                 const node = this.nodes.get(nodeId);
+                // Cancel all active runs and emit cancellation events
+                this.cancelNodeActiveRuns(node, "node-deleted");
+                // Cleanup node resources
                 node.runtime.onDeactivated?.();
                 node.runtime.dispose?.();
                 node.lifecycle?.dispose?.({
@@ -1465,7 +1508,6 @@ class GraphRuntime {
                     setState: (next) => Object.assign(node.state, next),
                 });
                 this.nodes.delete(nodeId);
-                // Clear any array buckets for this node
                 this.arrayInputBuckets.delete(nodeId);
             }
         }