trigger.dev 0.0.0-re2-20250502115816 → 0.0.0-re2-20250503165707

package/dist/esm/entryPoints/managed/execution.js

@@ -5,7 +5,6 @@ import { RunExecutionSnapshotPoller } from "./poller.js";
 import { assertExhaustive, tryCatch } from "@trigger.dev/core/utils";
 import { MetadataClient } from "./overrides.js";
 import { randomBytes } from "node:crypto";
-import { SnapshotManager } from "./snapshot.js";
 class ExecutionAbortError extends Error {
     constructor(message) {
         super(message);
@@ -16,9 +15,9 @@ export class RunExecution {
     id;
     executionAbortController;
     _runFriendlyId;
+    currentSnapshotId;
     currentAttemptNumber;
     currentTaskRunEnv;
-    snapshotManager;
     dequeuedAt;
     podScheduledAt;
     workerManifest;
@@ -30,7 +29,6 @@ export class RunExecution {
     snapshotPoller;
     lastHeartbeat;
     isShuttingDown = false;
-    shutdownReason;
     constructor(opts) {
         this.id = randomBytes(4).toString("hex");
         this.workerManifest = opts.workerManifest;
@@ -40,33 +38,11 @@ export class RunExecution {
         this.restoreCount = 0;
         this.executionAbortController = new AbortController();
     }
-    /**
-     * Cancels the current execution.
-     */
-    async cancel() {
-        if (this.isShuttingDown) {
-            throw new Error("cancel called after execution shut down");
-        }
-        this.sendDebugLog("cancelling attempt", { runId: this.runFriendlyId });
-        await this.taskRunProcess?.cancel();
-    }
-    /**
-     * Kills the current execution.
-     */
-    async kill({ exitExecution = true } = {}) {
-        await this.taskRunProcess?.kill("SIGKILL");
-        if (exitExecution) {
-            this.shutdown("kill");
-        }
-    }
     /**
      * Prepares the execution with task run environment variables.
      * This should be called before executing, typically after a successful run to prepare for the next one.
      */
     prepareForExecution(opts) {
-        if (this.isShuttingDown) {
-            throw new Error("prepareForExecution called after execution shut down");
-        }
         if (this.taskRunProcess) {
             throw new Error("prepareForExecution called after process was already created");
         }
@@ -113,12 +89,6 @@ export class RunExecution {
                 this.sendDebugLog("onTaskRunHeartbeat: failed", { error: error.message });
             }
         });
-        taskRunProcess.onSendDebugLog.attach(async (debugLog) => {
-            this.sendRuntimeDebugLog(debugLog.message, debugLog.properties);
-        });
-        taskRunProcess.onSetSuspendable.attach(async ({ suspendable }) => {
-            this.suspendable = suspendable;
-        });
         return taskRunProcess;
     }
     /**
@@ -133,20 +103,52 @@ export class RunExecution {
     }
     /**
      * Called by the RunController when it receives a websocket notification
-     * or when the snapshot poller detects a change.
-     *
-     * This is the main entry point for snapshot changes, but processing is deferred to the snapshot manager.
+     * or when the snapshot poller detects a change
      */
-    async enqueueSnapshotChangeAndWait(runData) {
+    async handleSnapshotChange(runData) {
         if (this.isShuttingDown) {
-            this.sendDebugLog("enqueueSnapshotChangeAndWait: shutting down, skipping");
+            this.sendDebugLog("handleSnapshotChange: shutting down, skipping");
+            return;
+        }
+        const { run, snapshot, completedWaitpoints } = runData;
+        const snapshotMetadata = {
+            incomingRunId: run.friendlyId,
+            incomingSnapshotId: snapshot.friendlyId,
+            completedWaitpoints: completedWaitpoints.length,
+        };
+        // Ensure we have run details
+        if (!this.runFriendlyId || !this.currentSnapshotId) {
+            this.sendDebugLog("handleSnapshotChange: missing run or snapshot ID", snapshotMetadata, run.friendlyId);
             return;
         }
-        if (!this.snapshotManager) {
-            this.sendDebugLog("enqueueSnapshotChangeAndWait: missing snapshot manager");
+        // Ensure the run ID matches
+        if (run.friendlyId !== this.runFriendlyId) {
+            // Send debug log to both runs
+            this.sendDebugLog("handleSnapshotChange: mismatched run IDs", snapshotMetadata);
+            this.sendDebugLog("handleSnapshotChange: mismatched run IDs", snapshotMetadata, run.friendlyId);
             return;
         }
-        await this.snapshotManager.handleSnapshotChange(runData);
+        this.snapshotChangeQueue.push(runData);
+        await this.processSnapshotChangeQueue();
+    }
+    snapshotChangeQueue = [];
+    snapshotChangeQueueLock = false;
+    async processSnapshotChangeQueue() {
+        if (this.snapshotChangeQueueLock) {
+            return;
+        }
+        this.snapshotChangeQueueLock = true;
+        while (this.snapshotChangeQueue.length > 0) {
+            const runData = this.snapshotChangeQueue.shift();
+            if (!runData) {
+                continue;
+            }
+            const [error] = await tryCatch(this.processSnapshotChange(runData));
+            if (error) {
+                this.sendDebugLog("Failed to process snapshot change", { error: error.message });
+            }
+        }
+        this.snapshotChangeQueueLock = false;
     }
     async processSnapshotChange(runData) {
         const { run, snapshot, completedWaitpoints } = runData;
@@ -154,25 +156,28 @@ export class RunExecution {
             incomingSnapshotId: snapshot.friendlyId,
             completedWaitpoints: completedWaitpoints.length,
         };
-        if (!this.snapshotManager) {
-            this.sendDebugLog("handleSnapshotChange: missing snapshot manager", snapshotMetadata);
+        // Check if the incoming snapshot is newer than the current one
+        if (!this.currentSnapshotId || snapshot.friendlyId < this.currentSnapshotId) {
+            this.sendDebugLog("handleSnapshotChange: received older snapshot, skipping", snapshotMetadata);
+            return;
+        }
+        if (snapshot.friendlyId === this.currentSnapshotId) {
             return;
         }
         if (this.currentAttemptNumber && this.currentAttemptNumber !== run.attemptNumber) {
-            this.sendDebugLog("error: attempt number mismatch", snapshotMetadata);
-            // This is a rogue execution, a new one will already have been created elsewhere
-            await this.exitTaskRunProcessWithoutFailingRun({ flush: false });
+            this.sendDebugLog("ERROR: attempt number mismatch", snapshotMetadata);
+            await this.taskRunProcess?.suspend();
             return;
         }
-        // DO NOT REMOVE (very noisy, but helpful for debugging)
-        // this.sendDebugLog(`processing snapshot change: ${snapshot.executionStatus}`, snapshotMetadata);
+        this.sendDebugLog(`snapshot has changed to: ${snapshot.executionStatus}`, snapshotMetadata);
         // Reset the snapshot poll interval so we don't do unnecessary work
-        this.snapshotPoller?.updateSnapshotId(snapshot.friendlyId);
         this.snapshotPoller?.resetCurrentInterval();
-        await this.processEnvOverrides("snapshot change");
+        // Update internal state
+        this.currentSnapshotId = snapshot.friendlyId;
+        // Update services
+        this.snapshotPoller?.updateSnapshotId(snapshot.friendlyId);
         switch (snapshot.executionStatus) {
             case "PENDING_CANCEL": {
-                this.sendDebugLog("run was cancelled", snapshotMetadata);
                 const [error] = await tryCatch(this.cancel());
                 if (error) {
                     this.sendDebugLog("snapshot change: failed to cancel attempt", {
@@ -184,39 +189,83 @@ export class RunExecution {
                 return;
             }
             case "QUEUED": {
-                this.sendDebugLog("run was re-queued", snapshotMetadata);
+                this.sendDebugLog("Run was re-queued", snapshotMetadata);
                 // Pretend we've just suspended the run. This will kill the process without failing the run.
-                await this.exitTaskRunProcessWithoutFailingRun({ flush: true });
+                await this.taskRunProcess?.suspend();
                 return;
             }
             case "FINISHED": {
-                this.sendDebugLog("run is finished", snapshotMetadata);
+                this.sendDebugLog("Run is finished", snapshotMetadata);
                 // Pretend we've just suspended the run. This will kill the process without failing the run.
-                await this.exitTaskRunProcessWithoutFailingRun({ flush: true });
+                await this.taskRunProcess?.suspend();
                 return;
             }
             case "QUEUED_EXECUTING":
             case "EXECUTING_WITH_WAITPOINTS": {
-                this.sendDebugLog("run is executing with waitpoints", snapshotMetadata);
-                // Wait for next status change - suspension is handled by the snapshot manager
+                this.sendDebugLog("Run is executing with waitpoints", snapshotMetadata);
+                const [error] = await tryCatch(this.taskRunProcess?.cleanup(false));
+                if (error) {
+                    this.sendDebugLog("Failed to cleanup task run process, carrying on", {
+                        ...snapshotMetadata,
+                        error: error.message,
+                    });
+                }
+                if (snapshot.friendlyId !== this.currentSnapshotId) {
+                    this.sendDebugLog("Snapshot changed after cleanup, abort", snapshotMetadata);
+                    this.abortExecution();
+                    return;
+                }
+                await sleep(this.env.TRIGGER_PRE_SUSPEND_WAIT_MS);
+                if (snapshot.friendlyId !== this.currentSnapshotId) {
+                    this.sendDebugLog("Snapshot changed after suspend threshold, abort", snapshotMetadata);
+                    this.abortExecution();
+                    return;
+                }
+                if (!this.runFriendlyId || !this.currentSnapshotId) {
+                    this.sendDebugLog("handleSnapshotChange: Missing run ID or snapshot ID after suspension, abort", snapshotMetadata);
+                    this.abortExecution();
+                    return;
+                }
+                const suspendResult = await this.httpClient.suspendRun(this.runFriendlyId, this.currentSnapshotId);
+                if (!suspendResult.success) {
+                    this.sendDebugLog("Failed to suspend run, staying alive 🎶", {
+                        ...snapshotMetadata,
+                        error: suspendResult.error,
+                    });
+                    this.sendDebugLog("checkpoint: suspend request failed", {
+                        ...snapshotMetadata,
+                        error: suspendResult.error,
+                    });
+                    // This is fine, we'll wait for the next status change
+                    return;
+                }
+                if (!suspendResult.data.ok) {
+                    this.sendDebugLog("checkpoint: failed to suspend run", {
+                        snapshotId: this.currentSnapshotId,
+                        error: suspendResult.data.error,
+                    });
+                    // This is fine, we'll wait for the next status change
+                    return;
+                }
+                this.sendDebugLog("Suspending, any day now 🚬", snapshotMetadata);
+                // Wait for next status change
                 return;
             }
             case "SUSPENDED": {
-                this.sendDebugLog("run was suspended", snapshotMetadata);
+                this.sendDebugLog("Run was suspended, kill the process", snapshotMetadata);
                 // This will kill the process and fail the execution with a SuspendedProcessError
-                // We don't flush because we already did before suspending
-                await this.exitTaskRunProcessWithoutFailingRun({ flush: false });
+                await this.taskRunProcess?.suspend();
                 return;
             }
             case "PENDING_EXECUTING": {
-                this.sendDebugLog("run is pending execution", snapshotMetadata);
+                this.sendDebugLog("Run is pending execution", snapshotMetadata);
                 if (completedWaitpoints.length === 0) {
-                    this.sendDebugLog("no waitpoints to complete, nothing to do", snapshotMetadata);
+                    this.sendDebugLog("No waitpoints to complete, nothing to do", snapshotMetadata);
                     return;
                 }
                 const [error] = await tryCatch(this.restore());
                 if (error) {
-                    this.sendDebugLog("failed to restore execution", {
+                    this.sendDebugLog("Failed to restore execution", {
                         ...snapshotMetadata,
                         error: error.message,
                     });
@@ -226,13 +275,13 @@ export class RunExecution {
                 return;
             }
             case "EXECUTING": {
+                this.sendDebugLog("Run is now executing", snapshotMetadata);
                 if (completedWaitpoints.length === 0) {
-                    this.sendDebugLog("run is executing without completed waitpoints", snapshotMetadata);
                     return;
                 }
-                this.sendDebugLog("run is executing with completed waitpoints", snapshotMetadata);
+                this.sendDebugLog("Processing completed waitpoints", snapshotMetadata);
                 if (!this.taskRunProcess) {
-                    this.sendDebugLog("no task run process, ignoring completed waitpoints", snapshotMetadata);
+                    this.sendDebugLog("No task run process, ignoring completed waitpoints", snapshotMetadata);
                     this.abortExecution();
                     return;
                 }
@@ -242,7 +291,7 @@ export class RunExecution {
                 return;
             }
             case "RUN_CREATED": {
-                this.sendDebugLog("aborting execution: invalid status change: RUN_CREATED", snapshotMetadata);
+                this.sendDebugLog("Invalid status change", snapshotMetadata);
                 this.abortExecution();
                 return;
             }
@@ -252,16 +301,16 @@ export class RunExecution {
         }
     }
     async startAttempt({ isWarmStart, }) {
-        if (!this.runFriendlyId || !this.snapshotManager) {
-            throw new Error("Cannot start attempt: missing run or snapshot manager");
+        if (!this.runFriendlyId || !this.currentSnapshotId) {
+            throw new Error("Cannot start attempt: missing run or snapshot ID");
         }
-        this.sendDebugLog("starting attempt");
+        this.sendDebugLog("Starting attempt");
         const attemptStartedAt = Date.now();
         // Check for abort before each major async operation
         if (this.executionAbortController.signal.aborted) {
             throw new ExecutionAbortError("Execution aborted before start");
         }
-        const start = await this.httpClient.startRunAttempt(this.runFriendlyId, this.snapshotManager.snapshotId, { isWarmStart });
+        const start = await this.httpClient.startRunAttempt(this.runFriendlyId, this.currentSnapshotId, { isWarmStart });
         if (this.executionAbortController.signal.aborted) {
             throw new ExecutionAbortError("Execution aborted after start");
         }
@@ -269,14 +318,14 @@ export class RunExecution {
             throw new Error(`Start API call failed: ${start.error}`);
         }
         // A snapshot was just created, so update the snapshot ID
-        this.snapshotManager.updateSnapshot(start.data.snapshot.friendlyId, start.data.snapshot.executionStatus);
+        this.currentSnapshotId = start.data.snapshot.friendlyId;
         // Also set or update the attempt number - we do this to detect illegal attempt number changes, e.g. from stalled runners coming back online
         const attemptNumber = start.data.run.attemptNumber;
         if (attemptNumber && attemptNumber > 0) {
             this.currentAttemptNumber = attemptNumber;
         }
         else {
-            this.sendDebugLog("error: invalid attempt number returned from start attempt", {
+            this.sendDebugLog("ERROR: invalid attempt number returned from start attempt", {
                 attemptNumber: String(attemptNumber),
             });
         }
@@ -285,7 +334,7 @@ export class RunExecution {
             dequeuedAt: this.dequeuedAt?.getTime(),
             podScheduledAt: this.podScheduledAt?.getTime(),
         });
-        this.sendDebugLog("started attempt");
+        this.sendDebugLog("Started attempt");
         return { ...start.data, metrics };
     }
     /**
@@ -293,47 +342,34 @@ export class RunExecution {
      * When this returns, the child process will have been cleaned up.
      */
     async execute(runOpts) {
-        if (this.isShuttingDown) {
-            throw new Error("execute called after execution shut down");
-        }
         // Setup initial state
         this.runFriendlyId = runOpts.runFriendlyId;
-        // Create snapshot manager
-        this.snapshotManager = new SnapshotManager({
-            runFriendlyId: runOpts.runFriendlyId,
-            initialSnapshotId: runOpts.snapshotFriendlyId,
-            // We're just guessing here, but "PENDING_EXECUTING" is probably fine
-            initialStatus: "PENDING_EXECUTING",
-            logger: this.logger,
-            onSnapshotChange: this.processSnapshotChange.bind(this),
-            onSuspendable: this.handleSuspendable.bind(this),
-        });
+        this.currentSnapshotId = runOpts.snapshotFriendlyId;
         this.dequeuedAt = runOpts.dequeuedAt;
         this.podScheduledAt = runOpts.podScheduledAt;
         // Create and start services
         this.snapshotPoller = new RunExecutionSnapshotPoller({
             runFriendlyId: this.runFriendlyId,
-            snapshotFriendlyId: this.snapshotManager.snapshotId,
+            snapshotFriendlyId: this.currentSnapshotId,
             httpClient: this.httpClient,
             logger: this.logger,
             snapshotPollIntervalSeconds: this.env.TRIGGER_SNAPSHOT_POLL_INTERVAL_SECONDS,
-            handleSnapshotChange: this.enqueueSnapshotChangeAndWait.bind(this),
+            handleSnapshotChange: this.handleSnapshotChange.bind(this),
         });
         this.snapshotPoller.start();
         const [startError, start] = await tryCatch(this.startAttempt({ isWarmStart: runOpts.isWarmStart }));
         if (startError) {
-            this.sendDebugLog("failed to start attempt", { error: startError.message });
-            this.shutdown("failed to start attempt");
+            this.sendDebugLog("Failed to start attempt", { error: startError.message });
+            this.stopServices();
             return;
         }
         const [executeError] = await tryCatch(this.executeRunWrapper(start));
         if (executeError) {
-            this.sendDebugLog("failed to execute run", { error: executeError.message });
-            this.shutdown("failed to execute run");
+            this.sendDebugLog("Failed to execute run", { error: executeError.message });
+            this.stopServices();
             return;
         }
-        // This is here for safety, but it
-        this.shutdown("execute call finished");
+        this.stopServices();
     }
     async executeRunWrapper({ run, snapshot, envVars, execution, metrics, isWarmStart, }) {
         this.currentTaskRunEnv = envVars;
@@ -345,11 +381,13 @@ export class RunExecution {
             metrics,
             isWarmStart,
         }));
+        this.sendDebugLog("Run execution completed", { error: executeError?.message });
         if (!executeError) {
+            this.stopServices();
             return;
         }
         if (executeError instanceof SuspendedProcessError) {
-            this.sendDebugLog("run was suspended", {
+            this.sendDebugLog("Run was suspended", {
                 run: run.friendlyId,
                 snapshot: snapshot.friendlyId,
                 error: executeError.message,
@@ -357,14 +395,14 @@ export class RunExecution {
             return;
         }
         if (executeError instanceof ExecutionAbortError) {
-            this.sendDebugLog("run was interrupted", {
+            this.sendDebugLog("Run was interrupted", {
                 run: run.friendlyId,
                 snapshot: snapshot.friendlyId,
                 error: executeError.message,
             });
             return;
         }
-        this.sendDebugLog("error while executing attempt", {
+        this.sendDebugLog("Error while executing attempt", {
             error: executeError.message,
             runId: run.friendlyId,
             snapshotId: snapshot.friendlyId,
@@ -377,8 +415,9 @@ export class RunExecution {
         };
         const [completeError] = await tryCatch(this.complete({ completion }));
         if (completeError) {
-            this.sendDebugLog("failed to complete run", { error: completeError.message });
+            this.sendDebugLog("Failed to complete run", { error: completeError.message });
         }
+        this.stopServices();
     }
     async executeRun({ run, snapshot, envVars, execution, metrics, isWarmStart, }) {
         // For immediate retries, we need to ensure the task run process is prepared for the next attempt
@@ -386,7 +425,7 @@ export class RunExecution {
             this.taskRunProcess &&
             !this.taskRunProcess.isPreparedForNextAttempt) {
             this.sendDebugLog("killing existing task run process before executing next attempt");
-            await this.kill({ exitExecution: false }).catch(() => { });
+            await this.kill().catch(() => { });
         }
         // To skip this step and eagerly create the task run process, run prepareForExecution first
         if (!this.taskRunProcess || !this.taskRunProcess.isPreparedForNextRun) {
@@ -395,7 +434,7 @@ export class RunExecution {
         this.sendDebugLog("executing task run process", { runId: execution.run.id });
         // Set up an abort handler that will cleanup the task run process
         this.executionAbortController.signal.addEventListener("abort", async () => {
-            this.sendDebugLog("execution aborted during task run, cleaning up process", {
+            this.sendDebugLog("Execution aborted during task run, cleaning up process", {
                 runId: execution.run.id,
             });
             await this.taskRunProcess?.cleanup(true);
@@ -410,24 +449,39 @@ export class RunExecution {
             env: envVars,
         }, isWarmStart);
         // If we get here, the task completed normally
-        this.sendDebugLog("completed run attempt", { attemptSuccess: completion.ok });
+        this.sendDebugLog("Completed run attempt", { attemptSuccess: completion.ok });
         // The execution has finished, so we can cleanup the task run process. Killing it should be safe.
         const [error] = await tryCatch(this.taskRunProcess.cleanup(true));
         if (error) {
-            this.sendDebugLog("failed to cleanup task run process, submitting completion anyway", {
+            this.sendDebugLog("Failed to cleanup task run process, submitting completion anyway", {
                 error: error.message,
             });
         }
         const [completionError] = await tryCatch(this.complete({ completion }));
         if (completionError) {
-            this.sendDebugLog("failed to complete run", { error: completionError.message });
+            this.sendDebugLog("Failed to complete run", { error: completionError.message });
+        }
+    }
+    /**
+     * Cancels the current execution.
+     */
+    async cancel() {
+        this.sendDebugLog("cancelling attempt", { runId: this.runFriendlyId });
+        await this.taskRunProcess?.cancel();
+    }
+    exit() {
+        if (this.taskRunProcess?.isPreparedForNextRun) {
+            this.taskRunProcess?.forceExit();
         }
     }
+    async kill() {
+        await this.taskRunProcess?.kill("SIGKILL");
+    }
     async complete({ completion }) {
-        if (!this.runFriendlyId || !this.snapshotManager) {
-            throw new Error("cannot complete run: missing run or snapshot manager");
+        if (!this.runFriendlyId || !this.currentSnapshotId) {
+            throw new Error("Cannot complete run: missing run or snapshot ID");
         }
-        const completionResult = await this.httpClient.completeRunAttempt(this.runFriendlyId, this.snapshotManager.snapshotId, { completion });
+        const completionResult = await this.httpClient.completeRunAttempt(this.runFriendlyId, this.currentSnapshotId, { completion });
         if (!completionResult.success) {
             throw new Error(`failed to submit completion: ${completionResult.error}`);
         }
@@ -437,57 +491,39 @@ export class RunExecution {
         });
     }
     async handleCompletionResult({ completion, result, }) {
-        this.sendDebugLog(`completion result: ${result.attemptStatus}`, {
+        this.sendDebugLog("Handling completion result", {
             attemptSuccess: completion.ok,
             attemptStatus: result.attemptStatus,
             snapshotId: result.snapshot.friendlyId,
             runId: result.run.friendlyId,
         });
-        const snapshotStatus = this.convertAttemptStatusToSnapshotStatus(result.attemptStatus);
-        // Update our snapshot ID to match the completion result to ensure any subsequent API calls use the correct snapshot
-        this.updateSnapshotAfterCompletion(result.snapshot.friendlyId, snapshotStatus);
+        // Update our snapshot ID to match the completion result
+        // This ensures any subsequent API calls use the correct snapshot
+        this.currentSnapshotId = result.snapshot.friendlyId;
         const { attemptStatus } = result;
-        switch (attemptStatus) {
-            case "RUN_FINISHED":
-            case "RUN_PENDING_CANCEL":
-            case "RETRY_QUEUED": {
-                return;
-            }
-            case "RETRY_IMMEDIATELY": {
-                if (attemptStatus !== "RETRY_IMMEDIATELY") {
-                    return;
-                }
-                if (completion.ok) {
-                    throw new Error("Should retry but completion OK.");
-                }
-                if (!completion.retry) {
-                    throw new Error("Should retry but missing retry params.");
-                }
-                await this.retryImmediately({ retryOpts: completion.retry });
-                return;
+        if (attemptStatus === "RUN_FINISHED") {
+            this.sendDebugLog("Run finished");
+            return;
+        }
+        if (attemptStatus === "RUN_PENDING_CANCEL") {
+            this.sendDebugLog("Run pending cancel");
+            return;
+        }
+        if (attemptStatus === "RETRY_QUEUED") {
+            this.sendDebugLog("Retry queued");
+            return;
+        }
+        if (attemptStatus === "RETRY_IMMEDIATELY") {
+            if (completion.ok) {
+                throw new Error("Should retry but completion OK.");
             }
-            default: {
-                assertExhaustive(attemptStatus);
+            if (!completion.retry) {
+                throw new Error("Should retry but missing retry params.");
             }
+            await this.retryImmediately({ retryOpts: completion.retry });
+            return;
         }
-    }
-    updateSnapshotAfterCompletion(snapshotId, status) {
-        this.snapshotManager?.updateSnapshot(snapshotId, status);
-        this.snapshotPoller?.updateSnapshotId(snapshotId);
-    }
-    convertAttemptStatusToSnapshotStatus(attemptStatus) {
-        switch (attemptStatus) {
-            case "RUN_FINISHED":
-                return "FINISHED";
-            case "RUN_PENDING_CANCEL":
-                return "PENDING_CANCEL";
-            case "RETRY_QUEUED":
-                return "QUEUED";
-            case "RETRY_IMMEDIATELY":
-                return "EXECUTING";
-            default:
-                assertExhaustive(attemptStatus);
-        }
+        assertExhaustive(attemptStatus);
     }
     measureExecutionMetrics({ attemptCreatedAt, dequeuedAt, podScheduledAt, }) {
         const metrics = [
@@ -517,7 +553,7 @@ export class RunExecution {
         return metrics;
     }
     async retryImmediately({ retryOpts }) {
-        this.sendDebugLog("retrying run immediately", {
+        this.sendDebugLog("Retrying run immediately", {
             timestamp: retryOpts.timestamp,
             delay: retryOpts.delay,
         });
@@ -529,65 +565,52 @@ export class RunExecution {
         // Start and execute next attempt
         const [startError, start] = await tryCatch(this.startAttempt({ isWarmStart: true }));
         if (startError) {
-            this.sendDebugLog("failed to start attempt for retry", { error: startError.message });
-            this.shutdown("retryImmediately: failed to start attempt");
+            this.sendDebugLog("Failed to start attempt for retry", { error: startError.message });
+            this.stopServices();
             return;
         }
         const [executeError] = await tryCatch(this.executeRunWrapper({ ...start, isWarmStart: true }));
         if (executeError) {
-            this.sendDebugLog("failed to execute run for retry", { error: executeError.message });
-            this.shutdown("retryImmediately: failed to execute run");
+            this.sendDebugLog("Failed to execute run for retry", { error: executeError.message });
+            this.stopServices();
             return;
         }
+        this.stopServices();
     }
     /**
      * Restores a suspended execution from PENDING_EXECUTING
      */
     async restore() {
-        this.sendDebugLog("restoring execution");
-        if (!this.runFriendlyId || !this.snapshotManager) {
-            throw new Error("Cannot restore: missing run or snapshot manager");
+        this.sendDebugLog("Restoring execution");
+        if (!this.runFriendlyId || !this.currentSnapshotId) {
+            throw new Error("Cannot restore: missing run or snapshot ID");
         }
         // Short delay to give websocket time to reconnect
         await sleep(100);
         // Process any env overrides
-        await this.processEnvOverrides("restore");
-        const continuationResult = await this.httpClient.continueRunExecution(this.runFriendlyId, this.snapshotManager.snapshotId);
+        await this.processEnvOverrides();
+        const continuationResult = await this.httpClient.continueRunExecution(this.runFriendlyId, this.currentSnapshotId);
         if (!continuationResult.success) {
             throw new Error(continuationResult.error);
         }
         // Track restore count
         this.restoreCount++;
     }
-    async exitTaskRunProcessWithoutFailingRun({ flush }) {
-        await this.taskRunProcess?.suspend({ flush });
-        // No services should be left running after this line - let's make sure of it
-        this.shutdown("exitTaskRunProcessWithoutFailingRun");
-    }
     /**
      * Processes env overrides from the metadata service. Generally called when we're resuming from a suspended state.
      */
-    async processEnvOverrides(reason) {
+    async processEnvOverrides() {
         if (!this.env.TRIGGER_METADATA_URL) {
-            this.sendDebugLog("no metadata url, skipping env overrides", { reason });
+            this.sendDebugLog("No metadata URL, skipping env overrides");
             return;
         }
         const metadataClient = new MetadataClient(this.env.TRIGGER_METADATA_URL);
         const overrides = await metadataClient.getEnvOverrides();
         if (!overrides) {
-            this.sendDebugLog("no env overrides, skipping", { reason });
+            this.sendDebugLog("No env overrides, skipping");
             return;
         }
-        this.sendDebugLog(`processing env overrides: ${reason}`, {
-            overrides,
-            currentEnv: this.env.raw,
-        });
-        if (this.env.TRIGGER_RUNNER_ID !== overrides.TRIGGER_RUNNER_ID) {
-            this.sendDebugLog("runner ID changed -> run was restored from a checkpoint", {
-                currentRunnerId: this.env.TRIGGER_RUNNER_ID,
-                newRunnerId: overrides.TRIGGER_RUNNER_ID,
-            });
-        }
+        this.sendDebugLog("Processing env overrides", overrides);
         // Override the env with the new values
         this.env.override(overrides);
         // Update services with new values
@@ -605,17 +628,17 @@ export class RunExecution {
     }
     async onHeartbeat() {
         if (!this.runFriendlyId) {
-            this.sendDebugLog("heartbeat: missing run ID");
+            this.sendDebugLog("Heartbeat: missing run ID");
             return;
         }
-        if (!this.snapshotManager) {
-            this.sendDebugLog("heartbeat: missing snapshot manager");
+        if (!this.currentSnapshotId) {
+            this.sendDebugLog("Heartbeat: missing snapshot ID");
             return;
         }
-        this.sendDebugLog("heartbeat");
-        const response = await this.httpClient.heartbeatRun(this.runFriendlyId, this.snapshotManager.snapshotId);
+        this.sendDebugLog("Heartbeat: started");
+        const response = await this.httpClient.heartbeatRun(this.runFriendlyId, this.currentSnapshotId);
         if (!response.success) {
-            this.sendDebugLog("heartbeat: failed", { error: response.error });
+            this.sendDebugLog("Heartbeat: failed", { error: response.error });
         }
         this.lastHeartbeat = new Date();
     }
@@ -626,33 +649,13 @@ export class RunExecution {
             properties: {
                 ...properties,
                 runId: this.runFriendlyId,
-                snapshotId: this.currentSnapshotFriendlyId,
-                executionId: this.id,
-                executionRestoreCount: this.restoreCount,
-                lastHeartbeat: this.lastHeartbeat?.toISOString(),
-            },
-        });
-    }
-    sendRuntimeDebugLog(message, properties, runIdOverride) {
-        this.logger.sendDebugLog({
-            runId: runIdOverride ?? this.runFriendlyId,
-            message: `[runtime] ${message}`,
-            print: false,
-            properties: {
-                ...properties,
-                runId: this.runFriendlyId,
-                snapshotId: this.currentSnapshotFriendlyId,
+                snapshotId: this.currentSnapshotId,
                 executionId: this.id,
                 executionRestoreCount: this.restoreCount,
                 lastHeartbeat: this.lastHeartbeat?.toISOString(),
             },
         });
     }
-    set suspendable(suspendable) {
-        this.snapshotManager?.setSuspendable(suspendable).catch((error) => {
-            this.sendDebugLog("failed to set suspendable", { error: error.message });
-        });
-    }
     // Ensure we can only set this once
     set runFriendlyId(id) {
         if (this._runFriendlyId) {
@@ -664,7 +667,7 @@ export class RunExecution {
         return this._runFriendlyId;
     }
     get currentSnapshotFriendlyId() {
-        return this.snapshotManager?.snapshotId;
+        return this.currentSnapshotId;
     }
     get taskRunEnv() {
         return this.currentTaskRunEnv;
@@ -679,82 +682,19 @@ export class RunExecution {
     }
     abortExecution() {
         if (this.isAborted) {
-            this.sendDebugLog("execution already aborted");
+            this.sendDebugLog("Execution already aborted");
             return;
         }
         this.executionAbortController.abort();
-        this.shutdown("abortExecution");
+        this.stopServices();
     }
-    shutdown(reason) {
+    stopServices() {
         if (this.isShuttingDown) {
-            this.sendDebugLog(`[shutdown] ${reason} (already shutting down)`, {
-                firstShutdownReason: this.shutdownReason,
-            });
             return;
         }
-        this.sendDebugLog(`[shutdown] ${reason}`);
         this.isShuttingDown = true;
-        this.shutdownReason = reason;
         this.snapshotPoller?.stop();
-        this.snapshotManager?.cleanup();
-        this.taskRunProcess?.unsafeDetachEvtHandlers();
-    }
-    async handleSuspendable(suspendableSnapshot) {
-        this.sendDebugLog("handleSuspendable", { suspendableSnapshot });
-        if (!this.snapshotManager) {
-            this.sendDebugLog("handleSuspendable: missing snapshot manager");
-            return;
-        }
-        // Ensure this is the current snapshot
-        if (suspendableSnapshot.id !== this.currentSnapshotFriendlyId) {
-            this.sendDebugLog("snapshot changed before cleanup, abort", {
-                suspendableSnapshot,
-                currentSnapshotId: this.currentSnapshotFriendlyId,
-            });
-            this.abortExecution();
-            return;
-        }
-        // First cleanup the task run process
-        const [error] = await tryCatch(this.taskRunProcess?.cleanup(false));
-        if (error) {
-            this.sendDebugLog("failed to cleanup task run process, carrying on", {
-                suspendableSnapshot,
-                error: error.message,
-            });
-        }
-        // Double check snapshot hasn't changed after cleanup
-        if (suspendableSnapshot.id !== this.currentSnapshotFriendlyId) {
-            this.sendDebugLog("snapshot changed after cleanup, abort", {
-                suspendableSnapshot,
-                currentSnapshotId: this.currentSnapshotFriendlyId,
-            });
-            this.abortExecution();
-            return;
-        }
-        if (!this.runFriendlyId) {
-            this.sendDebugLog("missing run ID for suspension, abort", { suspendableSnapshot });
-            this.abortExecution();
-            return;
-        }
-        // Call the suspend API with the current snapshot ID
-        const suspendResult = await this.httpClient.suspendRun(this.runFriendlyId, suspendableSnapshot.id);
-        if (!suspendResult.success) {
-            this.sendDebugLog("suspension request failed, staying alive 🎶", {
-                suspendableSnapshot,
-                error: suspendResult.error,
-            });
-            // This is fine, we'll wait for the next status change
-            return;
-        }
-        if (!suspendResult.data.ok) {
-            this.sendDebugLog("suspension request returned error, staying alive 🎶", {
-                suspendableSnapshot,
-                error: suspendResult.data.error,
-            });
-            // This is fine, we'll wait for the next status change
-            return;
-        }
-        this.sendDebugLog("suspending, any day now 🚬", { suspendableSnapshot });
+        this.taskRunProcess?.onTaskRunHeartbeat.detach();
     }
 }
 //# sourceMappingURL=execution.js.map