@bian-womp/spark-graph 0.3.50 → 0.3.51

package/lib/cjs/index.cjs

@@ -2154,7 +2154,7 @@ class EdgePropagator {
         // Set input value (respecting skipPropagateValues)
         const shouldSetValue = this.shouldSetInputValue(effectiveRunContexts);
         if (shouldSetValue && valueChanged) {
-            this.setTargetInput(edge, dstNode, processedValue);
+            this.setTargetInput(edge, processedValue);
         }
         else if (shouldSetValue && !valueChanged) {
             // Even if value didn't change, update timestamp if we're forcing execution
@@ -2213,7 +2213,7 @@ class EdgePropagator {
     /**
      * Set target input value and emit event
      */
-    setTargetInput(edge, dstNode, value) {
+    setTargetInput(edge, value) {
         this.graph.updateNodeInput(edge.target.nodeId, edge.target.handle, value);
         this.handleResolver.scheduleRecomputeHandles(edge.target.nodeId);
     }
@@ -2224,7 +2224,10 @@ class EdgePropagator {
         // Determine if we should propagate
         const shouldPropagate = this.shouldPropagateExecution(effectiveRunContexts);
         if (shouldPropagate && this.graph.allInboundHaveValue(targetNodeId)) {
-            this.nodeExecutor.execute(targetNodeId, effectiveRunContexts);
+            this.nodeExecutor.execute(targetNodeId, {
+                runContextIds: effectiveRunContexts,
+                reason: "executeDownstream",
+            });
         }
     }
     /**
@@ -2354,7 +2357,7 @@ class NodeExecutor {
     /**
      * Create an execution context for a node
      */
-    createExecutionContext(nodeId, node, inputs, runId, abortSignal, runContextIds, options) {
+    createExecutionContext(nodeId, inputs, runId, abortSignal, runContextIds, options) {
         const emitHandler = options?.emitHandler ??
             ((handle, value) => {
                 this.edgePropagator.propagate(nodeId, handle, value, runContextIds);
@@ -2366,8 +2369,9 @@ class NodeExecutor {
                 });
             });
         // Create log function that respects node's logLevel using LevelLogger
-        const nodeLogLevel = node.logLevel ?? "info";
-        const logger = new LevelLogger(nodeLogLevel, `[node:${runId || nodeId}:${node.typeId}]`);
+        const node = this.graph.getNode(nodeId);
+        const nodeLogLevel = node?.logLevel ?? "info";
+        const logger = new LevelLogger(nodeLogLevel, `[node:${runId || nodeId}:${node?.typeId ?? ""}]`);
         const log = (level, message, context) => {
             switch (level) {
                 case "debug":
@@ -2386,7 +2390,7 @@ class NodeExecutor {
         };
         return {
             nodeId,
-            state: node.state,
+            state: node?.state,
             setState: (next) => this.graph.updateNodeState(nodeId, next),
             emit: emitHandler,
             invalidateDownstream: () => {
@@ -2401,7 +2405,10 @@ class NodeExecutor {
                             this.runContextManager.createRunContext(nodeId, opts),
                         ]);
                     }
-                    this.execute(nodeId, runContextIdsToUse);
+                    this.execute(nodeId, {
+                        runContextIds: runContextIdsToUse,
+                        reason: opts?.reason ?? "executeFromContext",
+                    });
                 }
             },
             getInput: (handle) => inputs[handle],
@@ -2413,7 +2420,7 @@ class NodeExecutor {
                 this.eventEmitter.emit("stats", {
                     kind: "node-custom-data",
                     nodeId,
-                    typeId: node.typeId,
+                    typeId: node?.typeId ?? "",
                     runId,
                     data,
                 });
@@ -2424,13 +2431,14 @@ class NodeExecutor {
     /**
      * Internal method for executing inputs changed (also used by GraphRuntime)
      */
-    execute(nodeId, runContextIds, canSkipHandleResolution) {
+    execute(nodeId, opts) {
+        let { runContextIds, canSkipHandleResolution, reason = "" } = opts ?? {};
         const node = this.graph.getNode(nodeId);
         if (!node)
             return;
         const runMode = this.runtime.getRunMode();
         if (!runMode) {
-            console.trace("NodeExecutor.execute: no runMode, skipping execution");
+            console.trace(`NodeExecutor.execute[${nodeId}:${reason}]: no runMode, skipping execution`);
             return;
         }
         // In manual mode, require runContextIds unless autoRun policy is set
@@ -2442,12 +2450,12 @@ class NodeExecutor {
                 ]);
             }
             else {
-                console.trace("NodeExecutor.execute: no runContextIds provided in manual mode, skipping execution");
+                console.trace(`NodeExecutor.execute[${nodeId}:${reason}]: no runContextIds provided in manual mode, skipping execution`);
                 return;
             }
         }
         if (runMode === "auto" && runContextIds && runContextIds.size > 0) {
-            console.trace("NodeExecutor.execute: runContextIds provided in auto mode, ignoring");
+            console.trace(`NodeExecutor.execute[${nodeId}:${reason}]: runContextIds provided in auto mode, ignoring`);
             runContextIds = undefined;
         }
         // Early validation for auto-mode paused state
@@ -2490,7 +2498,11 @@ class NodeExecutor {
                 // Re-check node still exists and conditions
                 const nodeAfter = this.graph.getNode(nodeId);
                 if (nodeAfter) {
-                    this.execute(nodeId, runContextIds, true);
+                    this.execute(nodeId, {
+                        runContextIds,
+                        canSkipHandleResolution: true,
+                        reason: opts?.reason,
+                    });
                 }
                 if (runContextIds && runContextIds.size > 0) {
                     for (const id of runContextIds) {
@@ -2502,19 +2514,22 @@ class NodeExecutor {
         }
         // Handle debouncing
         const now = Date.now();
-        if (this.shouldDebounce(node, now)) {
-            this.handleDebouncedSchedule(node, nodeId, now, runContextIds);
+        if (this.shouldDebounce(nodeId, now)) {
+            this.handleDebouncedSchedule(nodeId, now, runContextIds, reason);
             return;
         }
         // Prepare execution plan
-        const executionPlan = this.prepareExecutionPlan(node, nodeId, runContextIds, now);
+        const executionPlan = this.prepareExecutionPlan(nodeId, runContextIds, now, reason);
         // Route to appropriate concurrency handler
-        this.routeToConcurrencyHandler(node, nodeId, executionPlan);
+        this.routeToConcurrencyHandler(nodeId, executionPlan);
     }
     /**
      * Check if execution should be debounced
      */
-    shouldDebounce(node, now) {
+    shouldDebounce(nodeId, now) {
+        const node = this.graph.getNode(nodeId);
+        if (!node)
+            return false;
         const policy = node.policy ?? {};
         const lastScheduledAt = node.lastScheduledAt;
         return !!(policy.debounceMs &&
@@ -2524,80 +2539,78 @@ class NodeExecutor {
     /**
      * Handle debounced scheduling by replacing the latest queued item
      */
-    handleDebouncedSchedule(node, nodeId, now, runContextIds) {
+    handleDebouncedSchedule(nodeId, now, runContextIds, reason) {
+        const node = this.graph.getNode(nodeId);
+        if (!node)
+            return;
         // 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 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]);
+        const executionPlan = this.prepareExecutionPlan(nodeId, runContextIds, now, reason);
+        this.graph.replaceNodeQueue(nodeId, [executionPlan]);
     }
     /**
      * Prepare execution plan with all necessary information
      */
-    prepareExecutionPlan(node, nodeId, runContextIds, now) {
+    prepareExecutionPlan(nodeId, runContextIds, now, reason) {
+        const node = this.graph.getNode(nodeId);
         this.graph.setNodeLastScheduledAt(nodeId, now);
         const runSeq = this.graph.incrementNodeRunSeq(nodeId);
         const runId = `${nodeId}:${runSeq}:${now}`;
         this.graph.setNodeLatestRunId(nodeId, runId);
         const effectiveInputs = this.getEffectiveInputs(nodeId);
         // Take a shallow snapshot of the current policy for this run
-        const policySnapshot = node.policy ? { ...node.policy } : undefined;
+        const policySnapshot = node?.policy ? { ...node.policy } : undefined;
         return {
             runId,
             effectiveInputs,
             runContextIdsForRun: runContextIds,
             timestamp: now,
             policy: policySnapshot,
+            reason,
         };
     }
     /**
      * Route execution to appropriate concurrency handler
      */
-    routeToConcurrencyHandler(node, nodeId, plan) {
+    routeToConcurrencyHandler(nodeId, plan) {
         const mode = plan.policy?.asyncConcurrency ?? "switch";
         switch (mode) {
             case "drop":
-                this.handleDropMode(node, nodeId, plan);
+                this.handleDropMode(nodeId, plan);
                 break;
             case "queue":
-                this.handleQueueMode(node, nodeId, plan);
+                this.handleQueueMode(nodeId, plan);
                 break;
             case "switch":
             case "merge":
             default:
-                this.startRun(node, nodeId, plan);
+                this.startRun(nodeId, plan);
                 break;
         }
     }
     /**
      * Handle drop mode - drop execution if node is already running, otherwise start run
      */
-    handleDropMode(node, nodeId, plan) {
+    handleDropMode(nodeId, plan) {
+        const node = this.graph.getNode(nodeId);
+        if (!node)
+            return;
         // Drop if node is already running
         if (node.activeControllers.size > 0) {
             return; // Don't increment pendingCount if we're dropping this run
         }
         // Start run if node is not running
-        this.startRun(node, nodeId, plan);
+        this.startRun(nodeId, plan);
     }
     /**
      * Handle queue mode - add to queue and process sequentially
      */
-    handleQueueMode(node, nodeId, plan) {
+    handleQueueMode(nodeId, plan) {
         const maxQ = plan.policy?.maxQueue ?? 8;
-        const currentNode = this.graph.getNode(nodeId);
-        if (!currentNode)
+        const node = this.graph.getNode(nodeId);
+        if (!node)
             return;
         // Keep the originating run-context alive while work is queued by
         // incrementing queued counters for the plan's run-contexts.
@@ -2607,18 +2620,18 @@ class NodeExecutor {
             }
         }
         this.graph.addToNodeQueue(nodeId, plan);
-        if (currentNode.queue.length > maxQ) {
+        if (node.queue.length > maxQ) {
             const dropped = this.graph.shiftNodeQueue(nodeId);
             if (dropped) {
                 this.decrementQueuedForPlans(dropped, nodeId);
             }
         }
-        this.processQueue(node, nodeId);
+        this.processQueue(nodeId);
     }
     /**
      * Process queued executions sequentially
      */
-    processQueue(node, nodeId) {
+    processQueue(nodeId) {
         const processNext = () => {
             const node = this.graph.getNode(nodeId);
             if (!node)
@@ -2631,7 +2644,7 @@ class NodeExecutor {
             this.graph.setNodeLatestRunId(nodeId, next.runId);
             // Start the run first (which increments pendingNodes), then decrement
             // pendingQueued to ensure the run context stays alive.
-            this.startRun(node, nodeId, next, () => {
+            this.startRun(nodeId, next, () => {
                 setTimeout(processNext, 0);
             });
             this.decrementQueuedForPlans(next, nodeId);
@@ -2641,19 +2654,19 @@ class NodeExecutor {
     /**
      * Start a node execution run
      */
-    startRun(node, nodeId, plan, onDone) {
+    startRun(nodeId, plan, onDone) {
         // Track run-contexts
         this.trackRunContextStart(nodeId, plan.runContextIdsForRun);
         // Setup execution controller
-        const controller = this.createExecutionController(nodeId, node, plan.runId);
+        const controller = this.createExecutionController(nodeId, plan.runId);
         // Handle concurrency mode
-        this.applyConcurrencyMode(nodeId, node, controller, plan);
+        this.applyConcurrencyMode(nodeId, controller, plan);
         // Setup timeout if needed
-        const timeoutId = this.setupTimeout(node, controller, plan);
+        const timeoutId = this.setupTimeout(controller, plan);
         // Create execution context
-        const execCtx = this.createExecutionContext(nodeId, node, plan.effectiveInputs, plan.runId, controller.signal, plan.runContextIdsForRun, this.createEmitAndProgressHandlers(node, nodeId, plan));
+        const execCtx = this.createExecutionContext(nodeId, plan.effectiveInputs, plan.runId, controller.signal, plan.runContextIdsForRun, this.createEmitAndProgressHandlers(nodeId, plan));
         // Execute
-        this.executeNode(node, nodeId, execCtx, plan, controller, timeoutId, onDone);
+        this.executeNode(nodeId, execCtx, plan, controller, timeoutId, onDone);
     }
     /**
      * Track run-context start for pending nodes
@@ -2682,12 +2695,13 @@ class NodeExecutor {
     /**
      * Create execution controller and update node stats
      */
-    createExecutionController(nodeId, node, runId) {
+    createExecutionController(nodeId, runId) {
         const controller = new AbortController();
         const now = Date.now();
+        const node = this.graph.getNode(nodeId);
         this.graph.updateNodeStats(nodeId, {
-            runs: node.stats.runs + 1,
-            active: node.stats.active + 1,
+            runs: (node?.stats.runs ?? 0) + 1,
+            active: (node?.stats.active ?? 0) + 1,
             lastStartAt: now,
             progress: 0,
         });
@@ -2697,7 +2711,7 @@ class NodeExecutor {
     /**
      * Apply concurrency mode (switch mode aborts other controllers)
      */
-    applyConcurrencyMode(nodeId, node, controller, plan) {
+    applyConcurrencyMode(nodeId, controller, plan) {
         const mode = plan.policy?.asyncConcurrency ?? "switch";
         if (mode === "switch") {
             const controllers = this.graph.getNodeControllers(nodeId);
@@ -2710,7 +2724,7 @@ class NodeExecutor {
     /**
      * Setup timeout for execution if configured
      */
-    setupTimeout(node, controller, plan) {
+    setupTimeout(controller, plan) {
         const policy = plan.policy ?? {};
         if (policy.timeoutMs && policy.timeoutMs > 0) {
             return setTimeout(() => controller.abort("timeout"), policy.timeoutMs);
@@ -2720,7 +2734,7 @@ class NodeExecutor {
     /**
      * Create emit and progress handlers for execution context
      */
-    createEmitAndProgressHandlers(node, nodeId, plan) {
+    createEmitAndProgressHandlers(nodeId, plan) {
         const policy = plan.policy ?? {};
         return {
             emitHandler: (handle, value) => {
@@ -2755,7 +2769,10 @@ class NodeExecutor {
     /**
      * Execute the node with retry logic and cleanup
      */
-    executeNode(node, nodeId, ctx, plan, controller, timeoutId, onDone) {
+    executeNode(nodeId, ctx, plan, controller, timeoutId, onDone) {
+        const node = this.graph.getNode(nodeId);
+        if (!node)
+            return;
         // Fire node-start event
         this.eventEmitter.emit("stats", {
             kind: "node-start",
@@ -2763,7 +2780,11 @@ class NodeExecutor {
             typeId: node.typeId,
             runId: plan.runId,
         });
-        ctx.log("debug", "node-start");
+        ctx.log("debug", "node-start", {
+            inputs: node.inputs,
+            effectiveInputs: plan.effectiveInputs,
+            reason: plan.reason,
+        });
         const exec = async (attempt) => {
             let hadError = false;
             try {
@@ -2801,7 +2822,7 @@ class NodeExecutor {
                 });
             }
             finally {
-                this.cleanupExecution(node, nodeId, ctx, plan, controller, timeoutId, hadError, onDone);
+                this.cleanupExecution(nodeId, ctx, plan, controller, timeoutId, hadError, onDone);
             }
         };
         exec(0);
@@ -2809,7 +2830,7 @@ class NodeExecutor {
     /**
      * Cleanup after execution completes
      */
-    cleanupExecution(node, nodeId, ctx, plan, controller, timeoutId, hadError, onDone) {
+    cleanupExecution(nodeId, ctx, plan, controller, timeoutId, hadError, onDone) {
         // Decrement pendingNodes count for all relevant run-contexts
         if (plan.runContextIdsForRun && plan.runContextIdsForRun.size > 0) {
             for (const id of plan.runContextIdsForRun) {
@@ -2823,19 +2844,19 @@ class NodeExecutor {
         if (timeoutId)
             clearTimeout(timeoutId);
         this.graph.removeNodeController(nodeId, controller);
-        const currentNode = this.graph.getNode(nodeId);
-        if (!currentNode)
+        const node = this.graph.getNode(nodeId);
+        if (!node)
             return;
         const controllers = this.graph.getNodeControllers(nodeId);
         const lastEndAt = Date.now();
-        const lastDurationMs = currentNode.stats.lastStartAt && lastEndAt
-            ? lastEndAt - currentNode.stats.lastStartAt
+        const lastDurationMs = node.stats.lastStartAt && lastEndAt
+            ? lastEndAt - node.stats.lastStartAt
             : undefined;
         this.graph.updateNodeStats(nodeId, {
             active: Math.max(0, controllers.size),
             lastEndAt,
             lastDurationMs,
-            lastError: hadError ? currentNode.stats.lastError : undefined,
+            lastError: hadError ? node.stats.lastError : undefined,
         });
         // Track successful completion time (for detecting stale inputs)
         const isCancelled = controller.signal.aborted &&
@@ -2847,26 +2868,22 @@ class NodeExecutor {
         }
         // Only emit node-done if not cancelled (cancellation events emitted separately)
         if (!isCancelled) {
-            if (currentNode) {
+            if (node) {
                 this.eventEmitter.emit("stats", {
                     kind: "node-done",
                     nodeId,
-                    typeId: currentNode.typeId,
+                    typeId: node.typeId,
                     runId: plan.runId,
-                    durationMs: currentNode.stats.lastDurationMs,
+                    durationMs: node.stats.lastDurationMs,
                 });
             }
         }
-        if (currentNode) {
+        if (node) {
             ctx.log("debug", "node-done", {
-                durationMs: currentNode.stats.lastDurationMs,
+                durationMs: node.stats.lastDurationMs,
+                outputs: node.outputs,
                 hadError,
-                inputs: currentNode.inputs
-                    ? structuredClone(currentNode.inputs)
-                    : undefined,
-                outputs: currentNode.outputs
-                    ? structuredClone(currentNode.outputs)
-                    : undefined,
+                reason: plan.reason,
             });
         }
         if (onDone)
@@ -2875,14 +2892,13 @@ class NodeExecutor {
     /**
      * Cancel all active runs for a node
      */
-    cancelNodeActiveRuns(node, reason) {
-        const nodeId = node.nodeId;
+    cancelNodeActiveRuns(nodeId, reason) {
+        const node = this.graph.getNode(nodeId);
+        if (!node)
+            return;
         const controllers = this.graph.getNodeControllers(nodeId);
         for (const controller of controllers) {
-            const currentNode = this.graph.getNode(nodeId);
-            if (!currentNode)
-                continue;
-            const runId = currentNode.controllerRunIds.get(controller);
+            const runId = node.controllerRunIds.get(controller);
             if (runId) {
                 // Track cancelled runIds for snapshot and user-cancelled operations
                 // (to drop emits from cancelled runs)
@@ -2892,8 +2908,8 @@ class NodeExecutor {
                 // Emit cancellation event
                 this.eventEmitter.emit("stats", {
                     kind: "node-done",
-                    nodeId: currentNode.nodeId,
-                    typeId: currentNode.typeId,
+                    nodeId: nodeId,
+                    typeId: node.typeId,
                     runId,
                     cancelled: true,
                 });
@@ -2941,10 +2957,7 @@ class NodeExecutor {
         }
         // Cancel runs for all affected nodes
         for (const nodeId of toCancel) {
-            const node = this.graph.getNode(nodeId);
-            if (!node)
-                continue;
-            this.cancelNodeActiveRuns(node, reason);
+            this.cancelNodeActiveRuns(nodeId, reason);
             const runSeq = this.graph.incrementNodeRunSeq(nodeId);
             const now = Date.now();
             const suffix = reason === "snapshot" ? "snapshot" : "cancelled";
@@ -3184,7 +3197,7 @@ class GraphRuntime {
         // However, if autoRun policy is set, nodes run automatically even in manual mode.
         if (anyChanged) {
             this.handleResolver.scheduleRecomputeHandles(nodeId);
-            this.executeNodeAutoRun(nodeId);
+            this.executeNodeAutoRun(nodeId, { reason: "setInputs" });
         }
     }
     getOutput(nodeId, output) {
@@ -3195,7 +3208,7 @@ class GraphRuntime {
         this.graph.forEachNode((node) => {
             const effectiveInputs = this.nodeExecutor.getEffectiveInputs(node.nodeId);
             const ctrl = new AbortController();
-            const execCtx = this.nodeExecutor.createExecutionContext(node.nodeId, node, effectiveInputs, `${node.nodeId}:init`, ctrl.signal);
+            const execCtx = this.nodeExecutor.createExecutionContext(node.nodeId, effectiveInputs, `${node.nodeId}:init`, ctrl.signal);
             if (node.lifecycle?.prepare) {
                 execCtx.log("debug", "prepare-start");
                 node.lifecycle.prepare(node.params ?? {}, execCtx);
@@ -3206,7 +3219,7 @@ class GraphRuntime {
         if (this.runMode === "auto" && invalidate) {
             for (const nodeId of this.graph.getNodeIds()) {
                 if (this.graph.allInboundHaveValue(nodeId))
-                    this.execute(nodeId);
+                    this.execute(nodeId, { reason: "launch" });
             }
         }
         if (startPaused) {
@@ -3221,7 +3234,7 @@ class GraphRuntime {
         if (this.isInvalidateEvent(event)) {
             // Check if node has all inbound inputs (required for execution)
             if (this.graph.allInboundHaveValue(nodeId)) {
-                this.execute(nodeId);
+                this.execute(nodeId, { reason: "triggerExternal" });
             }
             return;
         }
@@ -3345,17 +3358,20 @@ class GraphRuntime {
             setTimeout(check, 10);
         });
     }
-    async runFromHereContext(startNodeId, options) {
+    async runFromHereContext(startNodeId, opts) {
         const node = this.graph.getNode(startNodeId);
         if (!node)
             return;
         return new Promise((resolve) => {
             const id = this.runContextManager.createRunContext(startNodeId, {
                 resolve,
-                ...options,
+                ...opts,
             });
             this.graph.addNodeRunContextId(startNodeId, id);
-            this.execute(startNodeId, new Set([id]));
+            this.execute(startNodeId, {
+                runContextIds: new Set([id]),
+                reason: opts?.reason ?? "runFromHereContext",
+            });
         });
     }
     setRunMode(runMode) {
@@ -3402,7 +3418,7 @@ class GraphRuntime {
             }
         }
     }
-    executeNodeAutoRun(nodeId) {
+    executeNodeAutoRun(nodeId, opts) {
         const node = this.graph.getNode(nodeId);
         const shouldAutoRun = this.runMode === "auto" || node?.policy?.autoRun === true;
         let runContextIdsToUse = undefined;
@@ -3412,7 +3428,10 @@ class GraphRuntime {
             ]);
         }
         if (shouldAutoRun && this.graph.allInboundHaveValue(nodeId)) {
-            this.execute(nodeId, runContextIdsToUse);
+            this.execute(nodeId, {
+                runContextIds: runContextIdsToUse,
+                reason: opts?.reason ?? "executeNodeAutoRun",
+            });
         }
     }
     copyOutputs(fromNodeId, toNodeId, options) {
@@ -3421,7 +3440,7 @@ class GraphRuntime {
             return;
         this.hydrate({ outputs: { [toNodeId]: { ...fromNode.outputs } } }, { invalidate: !options?.dry });
         this.handleResolver.scheduleRecomputeHandles(toNodeId);
-        this.executeNodeAutoRun(toNodeId);
+        this.executeNodeAutoRun(toNodeId, { reason: "copyOutputs" });
     }
     hydrate(payload, opts) {
         const releasePause = this.requestPause();
@@ -3479,7 +3498,7 @@ class GraphRuntime {
                     const node = this.graph.getNode(nodeId);
                     if (!node)
                         continue;
-                    this.nodeExecutor.cancelNodeActiveRuns(node, "node-deleted");
+                    this.nodeExecutor.cancelNodeActiveRuns(nodeId, "node-deleted");
                     this.runContextManager.cancelNodeInRunContexts(nodeId, true);
                     node.runtime.onDeactivated?.();
                     node.runtime.dispose?.();
@@ -3540,7 +3559,7 @@ class GraphRuntime {
                     this.graph.setNode(n.nodeId, newNode);
                     const effectiveInputs = this.nodeExecutor.getEffectiveInputs(newNode.nodeId);
                     const ctrl = new AbortController();
-                    const execCtx = this.nodeExecutor.createExecutionContext(newNode.nodeId, newNode, effectiveInputs, `${newNode.nodeId}:init`, ctrl.signal);
+                    const execCtx = this.nodeExecutor.createExecutionContext(newNode.nodeId, effectiveInputs, `${newNode.nodeId}:init`, ctrl.signal);
                     if (newNode.lifecycle?.prepare) {
                         execCtx.log("debug", "prepare-start");
                         newNode.lifecycle.prepare(newNode.params ?? {}, execCtx);
@@ -3651,7 +3670,7 @@ class GraphRuntime {
                         this.edgePropagator.clearArrayBuckets(nodeId);
                         // Trigger handle resolution when inputs are removed
                         this.handleResolver.scheduleRecomputeHandles(nodeId);
-                        this.executeNodeAutoRun(nodeId);
+                        this.executeNodeAutoRun(nodeId, { reason: "graphUpdate" });
                     }
                 }
                 // Propagate changes on edges added
@@ -3721,8 +3740,8 @@ class GraphRuntime {
         });
         this.graph.clear();
     }
-    execute(nodeId, runContextIds, canSkipHandleResolution) {
-        this.nodeExecutor.execute(nodeId, runContextIds, canSkipHandleResolution);
+    execute(nodeId, opts) {
+        this.nodeExecutor.execute(nodeId, opts);
     }
     propagate(srcNodeId, srcHandle, value, runContextIds) {
         this.edgePropagator.propagate(srcNodeId, srcHandle, value, runContextIds);
@@ -4085,6 +4104,7 @@ class LocalEngine {
         await this.graphRuntime.runFromHereContext(nodeId, {
             skipPropagateValues: options?.skipPropagateValues ?? false,
             propagate: false, // Don't schedule downstream nodes
+            reason: "computeNode",
         });
     }
     /**
@@ -4093,7 +4113,9 @@ class LocalEngine {
      * Uses run-context system for dynamic graph updates.
      */
     async runFromHere(nodeId) {
-        await this.graphRuntime.runFromHereContext(nodeId);
+        await this.graphRuntime.runFromHereContext(nodeId, {
+            reason: "runFromHere",
+        });
     }
     setRunMode(runMode) {
         this.graphRuntime.setRunMode(runMode);