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

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.53";
+var version = "3.0.0-beta.54";
 
 // src/workers/dev/worker-setup.ts
 __SETUP_IMPORTED_PROJECT_CONFIG__;

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

@@ -1085,7 +1085,6 @@ 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);
@@ -1118,14 +1117,13 @@ 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;
@@ -1185,118 +1183,98 @@ var ProdWorker = class {
     }
   }
   // MARK: TASK WAIT
-  #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;
+  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");
       }
-      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
-        });
+      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
-        });
-        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++;
+    });
+    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++;
       }
-    };
+    }
   }
   // MARK: BATCH WAIT
-  #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;
+  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");
       }
-      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
-        });
+      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
-        });
-        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++;
+    });
+    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++;
       }
-    };
+    }
   }
   // MARK: WORKER CREATION
   #createBackgroundWorker() {
-    const workerId = randomUUID();
-    logger.log("Creating background worker", { workerId });
     const backgroundWorker = new ProdBackgroundWorker("worker.js", {
       projectConfig: __PROJECT_CONFIG__,
       env: {
@@ -1308,27 +1286,18 @@ var ProdWorker = class {
       contentHash: this.contentHash
     });
     backgroundWorker.onTaskHeartbeat.attach((attemptFriendlyId) => {
-      logger.log("onTaskHeartbeat", {
-        workerId,
-        attemptFriendlyId
-      });
+      logger.log("onTaskHeartbeat", { attemptFriendlyId });
       this.#coordinatorSocket.socket.volatile.emit("TASK_HEARTBEAT", {
         version: "v1",
         attemptFriendlyId
       });
     });
     backgroundWorker.onTaskRunHeartbeat.attach((runId) => {
-      logger.log("onTaskRunHeartbeat", {
-        workerId,
-        runId
-      });
+      logger.log("onTaskRunHeartbeat", { runId });
       this.#coordinatorSocket.socket.volatile.emit("TASK_RUN_HEARTBEAT", { version: "v1", runId });
     });
     backgroundWorker.onCreateTaskRunAttempt.attach(async (message) => {
-      logger.log("onCreateTaskRunAttempt()", {
-        workerId,
-        message
-      });
+      logger.log("onCreateTaskRunAttempt()", { 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", {
@@ -1357,7 +1326,6 @@ var ProdWorker = class {
     });
     backgroundWorker.attemptCreatedNotification.attach((message) => {
       logger.log("attemptCreatedNotification", {
-        workerId,
         success: message.success,
         ...message.success ? {
           attempt: message.execution.attempt,
@@ -1372,20 +1340,9 @@ var ProdWorker = class {
         return;
       }
       this.attemptFriendlyId = message.execution.attempt.id;
-      this.attemptNumber = message.execution.attempt.number;
     });
     backgroundWorker.onWaitForDuration.attach(async (message) => {
-      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;
-      }
+      logger.log("onWaitForDuration", { ...message, drift: Date.now() - message.now });
       noResume: {
         const { ms, waitThresholdInMs } = message;
         const internalTimeout = unboundedTimeout(ms, "internal");
@@ -1423,15 +1380,6 @@ 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",
@@ -1442,6 +1390,8 @@ 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");
@@ -1455,32 +1405,19 @@ var ProdWorker = class {
             this.#resumeAfterDuration();
           }, 15e3);
         } catch (error) {
-          logger.debug("Checkpoint cancellation timed out", {
-            workerId,
-            message,
-            error
-          });
+          logger.debug("Checkpoint cancellation timed out", { error });
+          break noResume;
         }
         return;
       }
       this.#resumeAfterDuration();
     });
-    backgroundWorker.onWaitForTask.attach(this.#waitForTaskHandlerFactory(workerId).bind(this));
-    backgroundWorker.onWaitForBatch.attach(this.#waitForBatchHandlerFactory(workerId).bind(this));
+    backgroundWorker.onWaitForTask.attach(this.#waitForTaskHandler.bind(this));
+    backgroundWorker.onWaitForBatch.attach(this.#waitForBatchHandler.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;
     }
@@ -1490,9 +1427,12 @@ var ProdWorker = class {
     await this.#prepareForCheckpoint();
   }
   // MARK: RETRY PREP
-  async #prepareForRetry(shouldExit, exitCode) {
-    logger.log("prepare for retry", { shouldExit, exitCode });
+  async #prepareForRetry(willCheckpointAndRestore, shouldExit, exitCode) {
+    logger.log("prepare for retry", { willCheckpointAndRestore, 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;
     }
@@ -1500,7 +1440,11 @@ var ProdWorker = class {
     this.waitForPostStart = false;
     this.executing = false;
     this.attemptFriendlyId = void 0;
-    this.attemptNumber = void 0;
+    if (!willCheckpointAndRestore) {
+      return;
+    }
+    this.waitForPostStart = true;
+    await this.#prepareForCheckpoint(false);
   }
   // MARK: CHECKPOINT PREP
   async #prepareForCheckpoint(flush = true) {
@@ -1528,7 +1472,6 @@ var ProdWorker = class {
     this.paused = false;
     this.nextResumeAfter = void 0;
     this.waitForPostStart = false;
-    this.durationResumeFallback = void 0;
     this.#backgroundWorker.waitCompletedNotification();
   }
   async #readyForLazyAttempt() {
@@ -1593,7 +1536,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: "v2",
+        version: "v1",
         execution,
         completion
       });
@@ -1609,9 +1552,26 @@ 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(shouldExit, exitCode);
+    await this.#prepareForRetry(willCheckpointAndRestore, shouldExit, exitCode);
     if (willCheckpointAndRestore) {
-      logger.error("This worker should never be checkpointed between attempts. This is a bug.");
+      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++;
+      }
     }
   }
   #returnValidatedExtraHeaders(headers) {
@@ -1637,9 +1597,6 @@ 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({
@@ -1711,13 +1668,31 @@ var ProdWorker = class {
             });
             return;
           }
+          this.durationResumeFallback = void 0;
           this.#resumeAfterDuration();
         },
-        EXECUTE_TASK_RUN: async () => {
-          this.#failRun(
-            this.runId,
-            "Received deprecated EXECUTE_TASK_RUN message. Please contact us if you see this error."
-          );
+        // 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_LAZY_ATTEMPT: async (message) => {
           this.readyForLazyAttemptReplay = void 0;
@@ -1765,6 +1740,7 @@ 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();
         }
       },
@@ -1774,11 +1750,7 @@ var ProdWorker = class {
           status: this.#status,
           connectionCount: ++this.connectionCount
         });
-        socket.emit("SET_STATE", {
-          version: "v1",
-          attemptFriendlyId: this.attemptFriendlyId,
-          attemptNumber: this.attemptNumber ? String(this.attemptNumber) : void 0
-        });
+        socket.emit("SET_STATE", { version: "v1", attemptFriendlyId: this.attemptFriendlyId });
         try {
           if (this.waitForPostStart) {
             logger2.log("skip connection handler, waiting for post start hook");
@@ -1794,25 +1766,16 @@ var ProdWorker = class {
               return;
             }
             if (!this.attemptFriendlyId) {
-              logger2.error("Missing attempt friendly ID", { status: this.#status });
+              logger2.error("Missing 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: "v2",
+              version: "v1",
               attemptFriendlyId: this.attemptFriendlyId,
-              attemptNumber: this.attemptNumber,
               type: this.nextResumeAfter
             });
             return;
@@ -1949,7 +1912,7 @@ var ProdWorker = class {
       }
       try {
         await backoff.wait(attempt + 1);
-        await this.#waitForTaskHandlerFactory("replay")(message, idempotencyKey);
+        await this.#waitForTaskHandler(message);
       } catch (error) {
         if (error instanceof ExponentialBackoff.RetryLimitExceeded) {
           logger.error("wait for task replay retry limit exceeded", { error });
@@ -1981,7 +1944,7 @@ var ProdWorker = class {
       }
       try {
         await backoff.wait(attempt + 1);
-        await this.#waitForBatchHandlerFactory("replay")(message, idempotencyKey);
+        await this.#waitForBatchHandler(message);
       } catch (error) {
         if (error instanceof ExponentialBackoff.RetryLimitExceeded) {
           logger.error("wait for batch replay retry limit exceeded", { error });
@@ -1991,6 +1954,38 @@ 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() {
@@ -2053,7 +2048,6 @@ var ProdWorker = class {
               }
               case "restore": {
                 await this.#reconnectAfterPostStart();
-                this.restoreNotification.post();
                 break;
               }
               default: {
@@ -2134,7 +2128,6 @@ 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.53";
+var version = "3.0.0-beta.54";
 
 // 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.53",
+  "version": "3.0.0-beta.54",
   "description": "A Command-Line Interface for Trigger.dev (v3) projects",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -53,8 +53,8 @@
     "typescript": "^5.3.3",
     "vitest": "^1.6.0",
     "xdg-app-paths": "^8.3.0",
-    "@trigger.dev/core-apps": "3.0.0-beta.53",
-    "@trigger.dev/tsconfig": "0.0.0"
+    "@trigger.dev/tsconfig": "0.0.0",
+    "@trigger.dev/core-apps": "3.0.0-beta.54"
   },
   "dependencies": {
     "@anatine/esbuild-decorators": "^0.2.19",
@@ -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.53",
+    "@trigger.dev/core": "3.0.0-beta.54",
     "@types/degit": "^2.8.3",
     "chalk": "^5.2.0",
     "chokidar": "^3.5.3",