trigger.dev 3.0.0-beta.51 → 3.0.0-beta.53

package/dist/workers/dev/worker-setup.js

@@ -8,7 +8,7 @@ import { ZodMessageSender } from "@trigger.dev/core/v3/zodMessageHandler";
 import "source-map-support/register.js";
 
 // package.json
-var version = "3.0.0-beta.51";
+var version = "3.0.0-beta.53";
 
 // src/workers/dev/worker-setup.ts
 __SETUP_IMPORTED_PROJECT_CONFIG__;

package/dist/workers/prod/entry-point.js

@@ -1085,6 +1085,7 @@ import { randomUUID } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { createServer } from "node:http";
 import { setTimeout as timeout2 } from "node:timers/promises";
+import { Evt as Evt2 } from "evt";
 var HTTP_SERVER_PORT = Number(process.env.HTTP_SERVER_PORT || getRandomPortNumber());
 var COORDINATOR_HOST = process.env.COORDINATOR_HOST || "127.0.0.1";
 var COORDINATOR_PORT = Number(process.env.COORDINATOR_PORT || 50080);
@@ -1117,13 +1118,14 @@ var ProdWorker = class {
   completed = /* @__PURE__ */ new Set();
   paused = false;
   attemptFriendlyId;
+  attemptNumber;
   nextResumeAfter;
   waitForPostStart = false;
   connectionCount = 0;
+  restoreNotification = Evt2.create();
   waitForTaskReplay;
   waitForBatchReplay;
   readyForLazyAttemptReplay;
-  submitAttemptCompletionReplay;
   durationResumeFallback;
   #httpPort;
   #backgroundWorker;
@@ -1183,98 +1185,118 @@ var ProdWorker = class {
     }
   }
   // MARK: TASK WAIT
-  async #waitForTaskHandler(message, replayIdempotencyKey) {
-    const waitForTask = await defaultBackoff.execute(async ({ retry }) => {
-      logger.log("Wait for task with backoff", { retry });
-      if (!this.attemptFriendlyId) {
-        logger.error("Failed to send wait message, attempt friendly ID not set", { message });
-        throw new ExponentialBackoff.StopRetrying("No attempt ID");
+  #waitForTaskHandlerFactory(workerId) {
+    return async (message, replayIdempotencyKey) => {
+      logger.log("onWaitForTask", { workerId, message });
+      if (this.nextResumeAfter) {
+        logger.error("Already waiting for resume, skipping wait for task", {
+          nextResumeAfter: this.nextResumeAfter
+        });
+        return;
       }
-      return await this.#coordinatorSocket.socket.timeout(2e4).emitWithAck("WAIT_FOR_TASK", {
-        version: "v2",
-        friendlyId: message.friendlyId,
-        attemptFriendlyId: this.attemptFriendlyId
-      });
-    });
-    if (!waitForTask.success) {
-      logger.error("Failed to wait for task with backoff", {
-        cause: waitForTask.cause,
-        error: waitForTask.error
+      const waitForTask = await defaultBackoff.execute(async ({ retry }) => {
+        logger.log("Wait for task with backoff", { retry });
+        if (!this.attemptFriendlyId) {
+          logger.error("Failed to send wait message, attempt friendly ID not set", { message });
+          throw new ExponentialBackoff.StopRetrying("No attempt ID");
+        }
+        return await this.#coordinatorSocket.socket.timeout(2e4).emitWithAck("WAIT_FOR_TASK", {
+          version: "v2",
+          friendlyId: message.friendlyId,
+          attemptFriendlyId: this.attemptFriendlyId
+        });
       });
-      this.#emitUnrecoverableError(
-        "WaitForTaskFailed",
-        `${waitForTask.cause}: ${waitForTask.error}`
-      );
-      return;
-    }
-    const { willCheckpointAndRestore } = waitForTask.result;
-    await this.#prepareForWait("WAIT_FOR_TASK", willCheckpointAndRestore);
-    if (willCheckpointAndRestore) {
-      if (!this.waitForTaskReplay) {
-        this.waitForTaskReplay = {
-          message,
-          attempt: 1,
-          idempotencyKey: randomUUID()
-        };
-      } else {
-        if (replayIdempotencyKey && replayIdempotencyKey !== this.waitForTaskReplay.idempotencyKey) {
-          logger.error(
-            "wait for task handler called with mismatched idempotency key, won't overwrite replay request"
-          );
-          return;
+      if (!waitForTask.success) {
+        logger.error("Failed to wait for task with backoff", {
+          cause: waitForTask.cause,
+          error: waitForTask.error
+        });
+        this.#emitUnrecoverableError(
+          "WaitForTaskFailed",
+          `${waitForTask.cause}: ${waitForTask.error}`
+        );
+        return;
+      }
+      const { willCheckpointAndRestore } = waitForTask.result;
+      await this.#prepareForWait("WAIT_FOR_TASK", willCheckpointAndRestore);
+      if (willCheckpointAndRestore) {
+        if (!this.waitForTaskReplay) {
+          this.waitForTaskReplay = {
+            message,
+            attempt: 1,
+            idempotencyKey: randomUUID()
+          };
+        } else {
+          if (replayIdempotencyKey && replayIdempotencyKey !== this.waitForTaskReplay.idempotencyKey) {
+            logger.error(
+              "wait for task handler called with mismatched idempotency key, won't overwrite replay request"
+            );
+            return;
+          }
+          this.waitForTaskReplay.attempt++;
         }
-        this.waitForTaskReplay.attempt++;
       }
-    }
+    };
   }
   // MARK: BATCH WAIT
-  async #waitForBatchHandler(message, replayIdempotencyKey) {
-    const waitForBatch = await defaultBackoff.execute(async ({ retry }) => {
-      logger.log("Wait for batch with backoff", { retry });
-      if (!this.attemptFriendlyId) {
-        logger.error("Failed to send wait message, attempt friendly ID not set", { message });
-        throw new ExponentialBackoff.StopRetrying("No attempt ID");
+  #waitForBatchHandlerFactory(workerId) {
+    return async (message, replayIdempotencyKey) => {
+      logger.log("onWaitForBatch", { workerId, message });
+      if (this.nextResumeAfter) {
+        logger.error("Already waiting for resume, skipping wait for batch", {
+          nextResumeAfter: this.nextResumeAfter
+        });
+        return;
       }
-      return await this.#coordinatorSocket.socket.timeout(2e4).emitWithAck("WAIT_FOR_BATCH", {
-        version: "v2",
-        batchFriendlyId: message.batchFriendlyId,
-        runFriendlyIds: message.runFriendlyIds,
-        attemptFriendlyId: this.attemptFriendlyId
-      });
-    });
-    if (!waitForBatch.success) {
-      logger.error("Failed to wait for batch with backoff", {
-        cause: waitForBatch.cause,
-        error: waitForBatch.error
+      const waitForBatch = await defaultBackoff.execute(async ({ retry }) => {
+        logger.log("Wait for batch with backoff", { retry });
+        if (!this.attemptFriendlyId) {
+          logger.error("Failed to send wait message, attempt friendly ID not set", { message });
+          throw new ExponentialBackoff.StopRetrying("No attempt ID");
+        }
+        return await this.#coordinatorSocket.socket.timeout(2e4).emitWithAck("WAIT_FOR_BATCH", {
+          version: "v2",
+          batchFriendlyId: message.batchFriendlyId,
+          runFriendlyIds: message.runFriendlyIds,
+          attemptFriendlyId: this.attemptFriendlyId
+        });
       });
-      this.#emitUnrecoverableError(
-        "WaitForBatchFailed",
-        `${waitForBatch.cause}: ${waitForBatch.error}`
-      );
-      return;
-    }
-    const { willCheckpointAndRestore } = waitForBatch.result;
-    await this.#prepareForWait("WAIT_FOR_BATCH", willCheckpointAndRestore);
-    if (willCheckpointAndRestore) {
-      if (!this.waitForBatchReplay) {
-        this.waitForBatchReplay = {
-          message,
-          attempt: 1,
-          idempotencyKey: randomUUID()
-        };
-      } else {
-        if (replayIdempotencyKey && replayIdempotencyKey !== this.waitForBatchReplay.idempotencyKey) {
-          logger.error(
-            "wait for task handler called with mismatched idempotency key, won't overwrite replay request"
-          );
-          return;
+      if (!waitForBatch.success) {
+        logger.error("Failed to wait for batch with backoff", {
+          cause: waitForBatch.cause,
+          error: waitForBatch.error
+        });
+        this.#emitUnrecoverableError(
+          "WaitForBatchFailed",
+          `${waitForBatch.cause}: ${waitForBatch.error}`
+        );
+        return;
+      }
+      const { willCheckpointAndRestore } = waitForBatch.result;
+      await this.#prepareForWait("WAIT_FOR_BATCH", willCheckpointAndRestore);
+      if (willCheckpointAndRestore) {
+        if (!this.waitForBatchReplay) {
+          this.waitForBatchReplay = {
+            message,
+            attempt: 1,
+            idempotencyKey: randomUUID()
+          };
+        } else {
+          if (replayIdempotencyKey && replayIdempotencyKey !== this.waitForBatchReplay.idempotencyKey) {
+            logger.error(
+              "wait for task handler called with mismatched idempotency key, won't overwrite replay request"
+            );
+            return;
+          }
+          this.waitForBatchReplay.attempt++;
         }
-        this.waitForBatchReplay.attempt++;
       }
-    }
+    };
   }
   // MARK: WORKER CREATION
   #createBackgroundWorker() {
+    const workerId = randomUUID();
+    logger.log("Creating background worker", { workerId });
     const backgroundWorker = new ProdBackgroundWorker("worker.js", {
       projectConfig: __PROJECT_CONFIG__,
       env: {
@@ -1286,18 +1308,27 @@ var ProdWorker = class {
       contentHash: this.contentHash
     });
     backgroundWorker.onTaskHeartbeat.attach((attemptFriendlyId) => {
-      logger.log("onTaskHeartbeat", { attemptFriendlyId });
+      logger.log("onTaskHeartbeat", {
+        workerId,
+        attemptFriendlyId
+      });
       this.#coordinatorSocket.socket.volatile.emit("TASK_HEARTBEAT", {
         version: "v1",
         attemptFriendlyId
       });
     });
     backgroundWorker.onTaskRunHeartbeat.attach((runId) => {
-      logger.log("onTaskRunHeartbeat", { runId });
+      logger.log("onTaskRunHeartbeat", {
+        workerId,
+        runId
+      });
       this.#coordinatorSocket.socket.volatile.emit("TASK_RUN_HEARTBEAT", { version: "v1", runId });
     });
     backgroundWorker.onCreateTaskRunAttempt.attach(async (message) => {
-      logger.log("onCreateTaskRunAttempt()", { message });
+      logger.log("onCreateTaskRunAttempt()", {
+        workerId,
+        message
+      });
       const createAttempt = await defaultBackoff.execute(async ({ retry }) => {
         logger.log("Create task run attempt with backoff", { retry });
         return await this.#coordinatorSocket.socket.timeout(15e3).emitWithAck("CREATE_TASK_RUN_ATTEMPT", {
@@ -1326,6 +1357,7 @@ var ProdWorker = class {
     });
     backgroundWorker.attemptCreatedNotification.attach((message) => {
       logger.log("attemptCreatedNotification", {
+        workerId,
         success: message.success,
         ...message.success ? {
           attempt: message.execution.attempt,
@@ -1340,9 +1372,20 @@ var ProdWorker = class {
         return;
       }
       this.attemptFriendlyId = message.execution.attempt.id;
+      this.attemptNumber = message.execution.attempt.number;
     });
     backgroundWorker.onWaitForDuration.attach(async (message) => {
-      logger.log("onWaitForDuration", { ...message, drift: Date.now() - message.now });
+      logger.log("onWaitForDuration", {
+        workerId,
+        ...message,
+        drift: Date.now() - message.now
+      });
+      if (this.nextResumeAfter) {
+        logger.error("Already waiting for resume, skipping wait for duration", {
+          nextResumeAfter: this.nextResumeAfter
+        });
+        return;
+      }
       noResume: {
         const { ms, waitThresholdInMs } = message;
         const internalTimeout = unboundedTimeout(ms, "internal");
@@ -1380,6 +1423,15 @@ var ProdWorker = class {
         }
         await this.#prepareForWait("WAIT_FOR_DURATION", willCheckpointAndRestore);
         await Promise.race([internalTimeout, checkpointSafeInternalTimeout]);
+        const idempotencyKey = randomUUID();
+        this.durationResumeFallback = { idempotencyKey };
+        try {
+          await this.restoreNotification.waitFor(5e3);
+        } catch (error) {
+          logger.error("Did not receive restore notification in time", {
+            error
+          });
+        }
         try {
           const { checkpointCanceled } = await this.#coordinatorSocket.socket.timeout(15e3).emitWithAck("CANCEL_CHECKPOINT", {
             version: "v2",
@@ -1390,8 +1442,6 @@ var ProdWorker = class {
             break noResume;
           }
           logger.log("Waiting for external duration resume as we may have been restored");
-          const idempotencyKey = randomUUID();
-          this.durationResumeFallback = { idempotencyKey };
           setTimeout(() => {
             if (!this.durationResumeFallback) {
               logger.error("Already resumed after duration, skipping fallback");
@@ -1405,19 +1455,32 @@ var ProdWorker = class {
             this.#resumeAfterDuration();
           }, 15e3);
         } catch (error) {
-          logger.debug("Checkpoint cancellation timed out", { error });
-          break noResume;
+          logger.debug("Checkpoint cancellation timed out", {
+            workerId,
+            message,
+            error
+          });
         }
         return;
       }
       this.#resumeAfterDuration();
     });
-    backgroundWorker.onWaitForTask.attach(this.#waitForTaskHandler.bind(this));
-    backgroundWorker.onWaitForBatch.attach(this.#waitForBatchHandler.bind(this));
+    backgroundWorker.onWaitForTask.attach(this.#waitForTaskHandlerFactory(workerId).bind(this));
+    backgroundWorker.onWaitForBatch.attach(this.#waitForBatchHandlerFactory(workerId).bind(this));
     return backgroundWorker;
   }
   async #prepareForWait(reason, willCheckpointAndRestore) {
     logger.log(`prepare for ${reason}`, { willCheckpointAndRestore });
+    if (this.nextResumeAfter) {
+      logger.error("Already waiting for resume, skipping prepare for wait", {
+        nextResumeAfter: this.nextResumeAfter,
+        params: {
+          reason,
+          willCheckpointAndRestore
+        }
+      });
+      return;
+    }
     if (!willCheckpointAndRestore) {
       return;
     }
@@ -1427,12 +1490,9 @@ var ProdWorker = class {
     await this.#prepareForCheckpoint();
   }
   // MARK: RETRY PREP
-  async #prepareForRetry(willCheckpointAndRestore, shouldExit, exitCode) {
-    logger.log("prepare for retry", { willCheckpointAndRestore, shouldExit, exitCode });
+  async #prepareForRetry(shouldExit, exitCode) {
+    logger.log("prepare for retry", { shouldExit, exitCode });
     if (shouldExit) {
-      if (willCheckpointAndRestore) {
-        logger.error("WARNING: Will checkpoint but also requested exit. This won't end well.");
-      }
       await this.#exitGracefully(false, exitCode);
       return;
     }
@@ -1440,11 +1500,7 @@ var ProdWorker = class {
     this.waitForPostStart = false;
     this.executing = false;
     this.attemptFriendlyId = void 0;
-    if (!willCheckpointAndRestore) {
-      return;
-    }
-    this.waitForPostStart = true;
-    await this.#prepareForCheckpoint(false);
+    this.attemptNumber = void 0;
   }
   // MARK: CHECKPOINT PREP
   async #prepareForCheckpoint(flush = true) {
@@ -1472,6 +1528,7 @@ var ProdWorker = class {
     this.paused = false;
     this.nextResumeAfter = void 0;
     this.waitForPostStart = false;
+    this.durationResumeFallback = void 0;
     this.#backgroundWorker.waitCompletedNotification();
   }
   async #readyForLazyAttempt() {
@@ -1536,7 +1593,7 @@ var ProdWorker = class {
     const taskRunCompleted = await defaultBackoff.execute(async ({ retry }) => {
       logger.log("Submit attempt completion with backoff", { retry });
       return await this.#coordinatorSocket.socket.timeout(2e4).emitWithAck("TASK_RUN_COMPLETED", {
-        version: "v1",
+        version: "v2",
         execution,
         completion
       });
@@ -1552,26 +1609,9 @@ var ProdWorker = class {
     const { willCheckpointAndRestore, shouldExit } = taskRunCompleted.result;
     logger.log("completion acknowledged", { willCheckpointAndRestore, shouldExit });
     const exitCode = !completion.ok && completion.error.type === "INTERNAL_ERROR" && completion.error.code === TaskRunErrorCodes2.TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE ? EXIT_CODE_CHILD_NONZERO : 0;
-    await this.#prepareForRetry(willCheckpointAndRestore, shouldExit, exitCode);
+    await this.#prepareForRetry(shouldExit, exitCode);
     if (willCheckpointAndRestore) {
-      if (!this.submitAttemptCompletionReplay) {
-        this.submitAttemptCompletionReplay = {
-          message: {
-            execution,
-            completion
-          },
-          attempt: 1,
-          idempotencyKey: randomUUID()
-        };
-      } else {
-        if (replayIdempotencyKey && replayIdempotencyKey !== this.submitAttemptCompletionReplay.idempotencyKey) {
-          logger.error(
-            "attempt completion handler called with mismatched idempotency key, won't overwrite replay request"
-          );
-          return;
-        }
-        this.submitAttemptCompletionReplay.attempt++;
-      }
+      logger.error("This worker should never be checkpointed between attempts. This is a bug.");
     }
   }
   #returnValidatedExtraHeaders(headers) {
@@ -1597,6 +1637,9 @@ var ProdWorker = class {
     if (this.attemptFriendlyId) {
       extraHeaders["x-trigger-attempt-friendly-id"] = this.attemptFriendlyId;
     }
+    if (this.attemptNumber !== void 0) {
+      extraHeaders["x-trigger-attempt-number"] = String(this.attemptNumber);
+    }
     logger.log(`connecting to coordinator: ${host}:${COORDINATOR_PORT}`);
     logger.debug(`connecting with extra headers`, { extraHeaders });
     const coordinatorConnection = new ZodSocketConnection({
@@ -1668,31 +1711,13 @@ var ProdWorker = class {
             });
             return;
           }
-          this.durationResumeFallback = void 0;
           this.#resumeAfterDuration();
         },
-        // Deprecated: This will never get called as this worker supports lazy attempts. It's only here for a quick view of the flow old workers use.
-        EXECUTE_TASK_RUN: async ({ executionPayload }) => {
-          if (this.executing) {
-            logger.error("dropping execute request, already executing");
-            return;
-          }
-          if (this.completed.has(executionPayload.execution.attempt.id)) {
-            logger.error("dropping execute request, already completed");
-            return;
-          }
-          this.executing = true;
-          this.attemptFriendlyId = executionPayload.execution.attempt.id;
-          const completion = await this.#backgroundWorker.executeTaskRun(executionPayload);
-          logger.log("completed", completion);
-          this.completed.add(executionPayload.execution.attempt.id);
-          const { willCheckpointAndRestore, shouldExit } = await this.#coordinatorSocket.socket.emitWithAck("TASK_RUN_COMPLETED", {
-            version: "v1",
-            execution: executionPayload.execution,
-            completion
-          });
-          logger.log("completion acknowledged", { willCheckpointAndRestore, shouldExit });
-          await this.#prepareForRetry(willCheckpointAndRestore, shouldExit);
+        EXECUTE_TASK_RUN: async () => {
+          this.#failRun(
+            this.runId,
+            "Received deprecated EXECUTE_TASK_RUN message. Please contact us if you see this error."
+          );
         },
         EXECUTE_TASK_RUN_LAZY_ATTEMPT: async (message) => {
           this.readyForLazyAttemptReplay = void 0;
@@ -1740,7 +1765,6 @@ var ProdWorker = class {
             logger.error("Received READY_FOR_RETRY but no completions yet. This is a bug.");
             return;
           }
-          this.submitAttemptCompletionReplay = void 0;
           await this.#readyForLazyAttempt();
         }
       },
@@ -1750,7 +1774,11 @@ var ProdWorker = class {
           status: this.#status,
           connectionCount: ++this.connectionCount
         });
-        socket.emit("SET_STATE", { version: "v1", attemptFriendlyId: this.attemptFriendlyId });
+        socket.emit("SET_STATE", {
+          version: "v1",
+          attemptFriendlyId: this.attemptFriendlyId,
+          attemptNumber: this.attemptNumber ? String(this.attemptNumber) : void 0
+        });
         try {
           if (this.waitForPostStart) {
             logger2.log("skip connection handler, waiting for post start hook");
@@ -1766,16 +1794,25 @@ var ProdWorker = class {
               return;
             }
             if (!this.attemptFriendlyId) {
-              logger2.error("Missing friendly ID", { status: this.#status });
+              logger2.error("Missing attempt friendly ID", { status: this.#status });
               this.#emitUnrecoverableError(
                 "NoAttemptId",
                 "Attempt ID not set while resuming from paused state"
               );
               return;
             }
+            if (!this.attemptNumber) {
+              logger2.error("Missing attempt number", { status: this.#status });
+              this.#emitUnrecoverableError(
+                "NoAttemptNumber",
+                "Attempt number not set while resuming from paused state"
+              );
+              return;
+            }
             socket.emit("READY_FOR_RESUME", {
-              version: "v1",
+              version: "v2",
               attemptFriendlyId: this.attemptFriendlyId,
+              attemptNumber: this.attemptNumber,
               type: this.nextResumeAfter
             });
             return;
@@ -1912,7 +1949,7 @@ var ProdWorker = class {
       }
       try {
         await backoff.wait(attempt + 1);
-        await this.#waitForTaskHandler(message);
+        await this.#waitForTaskHandlerFactory("replay")(message, idempotencyKey);
       } catch (error) {
         if (error instanceof ExponentialBackoff.RetryLimitExceeded) {
           logger.error("wait for task replay retry limit exceeded", { error });
@@ -1944,7 +1981,7 @@ var ProdWorker = class {
       }
       try {
         await backoff.wait(attempt + 1);
-        await this.#waitForBatchHandler(message);
+        await this.#waitForBatchHandlerFactory("replay")(message, idempotencyKey);
       } catch (error) {
         if (error instanceof ExponentialBackoff.RetryLimitExceeded) {
           logger.error("wait for batch replay retry limit exceeded", { error });
@@ -1954,38 +1991,6 @@ var ProdWorker = class {
       }
       return;
     }
-    if (this.submitAttemptCompletionReplay) {
-      logger.log("replaying attempt completion", {
-        ...this.submitAttemptCompletionReplay,
-        cancellationDelay: replayCancellationDelay
-      });
-      const { idempotencyKey, message, attempt } = this.submitAttemptCompletionReplay;
-      await timeout2(replayCancellationDelay);
-      if (!this.submitAttemptCompletionReplay) {
-        logger.error("attempt completion replay cancelled, discarding", {
-          originalMessage: { idempotencyKey, message, attempt }
-        });
-        return;
-      }
-      if (idempotencyKey !== this.submitAttemptCompletionReplay.idempotencyKey) {
-        logger.error("attempt completion replay idempotency key mismatch, discarding", {
-          originalMessage: { idempotencyKey, message, attempt },
-          newMessage: this.submitAttemptCompletionReplay
-        });
-        return;
-      }
-      try {
-        await backoff.wait(attempt + 1);
-        await this.#submitAttemptCompletion(message.execution, message.completion, idempotencyKey);
-      } catch (error) {
-        if (error instanceof ExponentialBackoff.RetryLimitExceeded) {
-          logger.error("attempt completion replay retry limit exceeded", { error });
-        } else {
-          logger.error("attempt completion replay error", { error });
-        }
-      }
-      return;
-    }
   }
   // MARK: HTTP SERVER
   #createHttpServer() {
@@ -2048,6 +2053,7 @@ var ProdWorker = class {
               }
               case "restore": {
                 await this.#reconnectAfterPostStart();
+                this.restoreNotification.post();
                 break;
               }
               default: {
@@ -2128,6 +2134,7 @@ var ProdWorker = class {
       nextResumeAfter: this.nextResumeAfter,
       waitForPostStart: this.waitForPostStart,
       attemptFriendlyId: this.attemptFriendlyId,
+      attemptNumber: this.attemptNumber,
       waitForTaskReplay: this.waitForTaskReplay,
       waitForBatchReplay: this.waitForBatchReplay
     };

package/dist/workers/prod/worker-setup.js

@@ -1,5 +1,5 @@
 // package.json
-var version = "3.0.0-beta.51";
+var version = "3.0.0-beta.53";
 
 // src/workers/prod/worker-setup.ts
 import { taskCatalog } from "@trigger.dev/core/v3";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trigger.dev",
-  "version": "3.0.0-beta.51",
+  "version": "3.0.0-beta.53",
   "description": "A Command-Line Interface for Trigger.dev (v3) projects",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -53,7 +53,7 @@
     "typescript": "^5.3.3",
     "vitest": "^1.6.0",
     "xdg-app-paths": "^8.3.0",
-    "@trigger.dev/core-apps": "3.0.0-beta.51",
+    "@trigger.dev/core-apps": "3.0.0-beta.53",
     "@trigger.dev/tsconfig": "0.0.0"
   },
   "dependencies": {
@@ -72,7 +72,7 @@
     "@opentelemetry/sdk-trace-base": "^1.22.0",
     "@opentelemetry/sdk-trace-node": "^1.22.0",
     "@opentelemetry/semantic-conventions": "^1.22.0",
-    "@trigger.dev/core": "3.0.0-beta.51",
+    "@trigger.dev/core": "3.0.0-beta.53",
     "@types/degit": "^2.8.3",
     "chalk": "^5.2.0",
     "chokidar": "^3.5.3",