maxComputeSeconds

.changeset/deprecate-max-duration.md

@@ -0,0 +1,7 @@
+---
+"@trigger.dev/core": patch
+"@trigger.dev/sdk": patch
+"trigger.dev": patch
+---
+
+Deprecate `maxDuration` in favor of `maxComputeSeconds` because it's clearer. The new `maxComputeSeconds` property better reflects that the limit is based on compute time (CPU time) rather than wall-clock time. The old `maxDuration` property is still supported for backwards compatibility but will show deprecation warnings.

.claude/skills/trigger-dev-tasks/advanced-tasks.md

@@ -166,7 +166,7 @@ In trailing mode, these options update with each trigger:
 - `metadata` — run metadata
 - `tags` — run tags (replaces existing)
 - `maxAttempts` — retry attempts
-- `maxDuration` — maximum compute time
+- `maxComputeSeconds` — maximum compute time in seconds
 - `machine` — machine preset
 
 ### Important Notes
@@ -274,7 +274,7 @@ export const resilientTask = task({
 export const heavyTask = task({
   id: "heavy-computation",
   machine: { preset: "large-2x" }, // 8 vCPU, 16 GB RAM
-  maxDuration: 1800, // 30 minutes timeout
+  maxComputeSeconds: 1800, // 30 minutes timeout
   run: async (payload, { ctx }) => {
     // Resource-intensive computation
     if (ctx.machine.preset === "large-2x") {

.claude/skills/trigger-dev-tasks/config.md

@@ -295,7 +295,7 @@ export default defineConfig({
 export default defineConfig({
   // ... other config
   defaultMachine: "large-1x", // Default machine for all tasks
-  maxDuration: 300, // Default max duration (seconds)
+  maxComputeSeconds: 300, // Default max compute time (seconds)
   enableConsoleLogging: true, // Console logging in development
 });
 ```

apps/webapp/app/components/runs/v3/ReplayRunDialog.tsx

@@ -479,7 +479,7 @@ function ReplayForm({
                 <FormError id={maxAttempts.errorId}>{maxAttempts.error}</FormError>
               </InputGroup>
               <InputGroup>
-                <Label variant="small">Max duration</Label>
+                <Label variant="small">Max compute time</Label>
                 <DurationPicker
                   name={maxDurationSeconds.name}
                   id={maxDurationSeconds.id}

apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.test.tasks.$taskParam/route.tsx

@@ -742,7 +742,7 @@ function StandardTaskForm({
                 <FormError id={maxAttempts.errorId}>{maxAttempts.error}</FormError>
               </InputGroup>
               <InputGroup>
-                <Label variant="small">Max duration</Label>
+                <Label variant="small">Max compute time</Label>
                 <DurationPicker
                   name={maxDurationSeconds.name}
                   id={maxDurationSeconds.id}
@@ -1318,7 +1318,7 @@ function ScheduledTaskForm({
           </InputGroup>
           <InputGroup>
             <Label htmlFor={maxDurationSeconds.id} variant="small">
-              Max duration
+              Max compute time
             </Label>
             <DurationPicker
               name={maxDurationSeconds.name}

apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam.spans.$spanParam/route.tsx

@@ -869,7 +869,7 @@ function RunBody({
                   </Property.Value>
                 </Property.Item>
                 <Property.Item>
-                  <Property.Label>Max duration</Property.Label>
+                  <Property.Label>Max compute time</Property.Label>
                   <Property.Value>
                     {run.maxDurationInSeconds
                       ? `${run.maxDurationInSeconds}s (${formatDurationMilliseconds(

docs/config/config-file.mdx

@@ -334,21 +334,21 @@ export default defineConfig({
 });
 ```
 
-## Max duration
+## Max compute time
 
-You can set the default `maxDuration` for all tasks in your project:
+You can set the default `maxComputeSeconds` for all tasks in your project:
 
 ```ts trigger.config.ts
 import { defineConfig } from "@trigger.dev/sdk";
 
 export default defineConfig({
   project: "<project ref>",
   // Your other config settings...
-  maxDuration: 60, // 60 seconds
+  maxComputeSeconds: 60, // 60 seconds
 });
 ```
 
-See our [maxDuration guide](/runs/max-duration) for more information.
+See our [maxComputeSeconds guide](/runs/max-duration) for more information.
 
 ## Process keep alive
 

docs/runs/max-duration.mdx

@@ -1,35 +1,39 @@
 ---
-title: "Max duration"
-sidebarTitle: "Max duration"
-description: "Set a maximum duration for a task to run."
+title: "Max compute time"
+sidebarTitle: "Max compute time"
+description: "Set a maximum compute time limit for a task to run."
 ---
 
-The `maxDuration` parameter sets a maximum compute time limit for tasks. When a task exceeds this duration, it will be automatically stopped. This helps prevent runaway tasks and manage compute resources effectively.
+The `maxComputeSeconds` parameter sets a maximum compute time limit for tasks. When a task exceeds this duration, it will be automatically stopped. This helps prevent runaway tasks and manage compute resources effectively.
 
-You must set a default maxDuration in your `trigger.config.ts` file, which will apply to all tasks unless overridden:
+<Note>
+  `maxDuration` replaces the deprecated `maxComputeSeconds` parameter. Both work the same way, but we recommend using `maxDuration` for clarity.
+</Note>
+
+You must set a default maxComputeSeconds in your `trigger.config.ts` file, which will apply to all tasks unless overridden:
 
 ```ts /config/trigger.config.ts
 import { defineConfig } from "@trigger.dev/sdk";
 
 export default defineConfig({
   project: "proj_gtcwttqhhtlasxgfuhxs",
-  maxDuration: 60, // 60 seconds or 1 minute
+  maxComputeSeconds: 60, // 60 seconds or 1 minute
 });
 ```
 
 <Note>
-  The minimum maxDuration is 5 seconds. If you want to avoid timeouts, set this value to a very large number of seconds.
+  The minimum maxComputeSeconds is 5 seconds. If you want to avoid timeouts, set this value to a very large number of seconds.
 </Note>
 
-You can set the `maxDuration` for a run in the following ways:
+You can set the `maxComputeSeconds` for a run in the following ways:
 
-- Across all your tasks in the [config](/config/config-file#max-duration)
+- Across all your tasks in the [config](/config/config-file#max-compute-time)
 - On a specific task
-- On a specific run when you [trigger a task](/triggering#maxduration)
+- On a specific run when you [trigger a task](/triggering#maxcomputeseconds)
 
 ## How it works
 
-The `maxDuration` is set in seconds, and is compared to the CPU time elapsed since the start of a single execution (which we call [attempts](/runs#attempts)) of the task. The CPU time is the time that the task has been actively running on the CPU, and does not include time spent waiting during the following:
+The `maxComputeSeconds` is set in seconds, and is compared to the CPU time elapsed since the start of a single execution (which we call [attempts](/runs#attempts)) of the task. The CPU time is the time that the task has been actively running on the CPU, and does not include time spent waiting during the following:
 
 - `wait.for` calls
 - `triggerAndWait` calls
@@ -40,9 +44,9 @@ You can inspect the CPU time of a task inside the run function with our `usage`
 ```ts /trigger/max-duration.ts
 import { task, usage } from "@trigger.dev/sdk";
 
-export const maxDurationTask = task({
+export const maxComputeSecondsTask = task({
   id: "max-duration-task",
-  maxDuration: 300, // 300 seconds or 5 minutes
+  maxComputeSeconds: 300, // 300 seconds or 5 minutes
   run: async (payload: any, { ctx }) => {
     let currentUsage = usage.getCurrent();
 
@@ -51,36 +55,36 @@ export const maxDurationTask = task({
 });
 ```
 
-The above value will be compared to the `maxDuration` you set. If the task exceeds the `maxDuration`, it will be stopped with the following error:
+The above value will be compared to the `maxComputeSeconds` you set. If the task exceeds the `maxComputeSeconds`, it will be stopped with the following error:
 
 ![Max duration error](/runs/max-duration-error.png)
 
 ## Configuring for a task
 
-You can set a `maxDuration` on a specific task:
+You can set a `maxComputeSeconds` on a specific task:
 
 ```ts /trigger/max-duration-task.ts
 import { task } from "@trigger.dev/sdk";
 
-export const maxDurationTask = task({
+export const maxComputeSecondsTask = task({
   id: "max-duration-task",
-  maxDuration: 300, // 300 seconds or 5 minutes
+  maxComputeSeconds: 300, // 300 seconds or 5 minutes
   run: async (payload: any, { ctx }) => {
     //...
   },
 });
 ```
 
-This will override the default `maxDuration` set in the config file. If you have a config file with a default `maxDuration` of 60 seconds, and you set a `maxDuration` of 300 seconds on a task, the task will run for 300 seconds.
+This will override the default `maxComputeSeconds` set in the config file. If you have a config file with a default `maxComputeSeconds` of 60 seconds, and you set a `maxComputeSeconds` of 300 seconds on a task, the task will run for 300 seconds.
 
 You can "turn off" the Max duration set in your config file for a specific task like so:
 
 ```ts /trigger/max-duration-task.ts
 import { task, timeout } from "@trigger.dev/sdk";
 
-export const maxDurationTask = task({
+export const maxComputeSecondsTask = task({
   id: "max-duration-task",
-  maxDuration: timeout.None, // No max duration
+  maxComputeSeconds: timeout.None, // No max duration
   run: async (payload: any, { ctx }) => {
     //...
   },
@@ -89,51 +93,51 @@ export const maxDurationTask = task({
 
 ## Configuring for a run
 
-You can set a `maxDuration` on a specific run when you trigger a task:
+You can set a `maxComputeSeconds` on a specific run when you trigger a task:
 
 ```ts /trigger/max-duration.ts
-import { maxDurationTask } from "./trigger/max-duration-task";
+import { maxComputeSecondsTask } from "./trigger/max-duration-task";
 
-// Trigger the task with a maxDuration of 300 seconds
-const run = await maxDurationTask.trigger(
+// Trigger the task with a maxComputeSeconds of 300 seconds
+const run = await maxComputeSecondsTask.trigger(
   { foo: "bar" },
   {
-    maxDuration: 300, // 300 seconds or 5 minutes
+    maxComputeSeconds: 300, // 300 seconds or 5 minutes
   }
 );
 ```
 
-You can also set the `maxDuration` to `timeout.None` to turn off the max duration for a specific run:
+You can also set the `maxComputeSeconds` to `timeout.None` to turn off the max duration for a specific run:
 
 ```ts /trigger/max-duration.ts
-import { maxDurationTask } from "./trigger/max-duration-task";
+import { maxComputeSecondsTask } from "./trigger/max-duration-task";
 import { timeout } from "@trigger.dev/sdk";
 
-// Trigger the task with no maxDuration
-const run = await maxDurationTask.trigger(
+// Trigger the task with no maxComputeSeconds
+const run = await maxComputeSecondsTask.trigger(
   { foo: "bar" },
   {
-    maxDuration: timeout.None, // No max duration
+    maxComputeSeconds: timeout.None, // No max duration
   }
 );
 ```
 
-## maxDuration in run context
+## maxComputeSeconds in run context
 
-You can access the `maxDuration` set for a run in the run context:
+You can access the `maxComputeSeconds` set for a run in the run context:
 
 ```ts /trigger/max-duration-task.ts
 import { task } from "@trigger.dev/sdk";
 
-export const maxDurationTask = task({
+export const maxComputeSecondsTask = task({
   id: "max-duration-task",
-  maxDuration: 300, // 300 seconds or 5 minutes
+  maxComputeSeconds: 300, // 300 seconds or 5 minutes
   run: async (payload: any, { ctx }) => {
-    console.log(ctx.run.maxDuration); // 300
+    console.log(ctx.run.maxComputeSeconds); // 300
   },
 });
 ```
 
-## maxDuration and lifecycle functions
+## maxComputeSeconds and lifecycle functions
 
-When a task run exceeds the `maxDuration`, the lifecycle functions `cleanup`, `onSuccess`, and `onFailure` will not be called.
+When a task run exceeds the `maxComputeSeconds`, the lifecycle functions `cleanup`, `onSuccess`, and `onFailure` will not be called.

docs/tasks/overview.mdx

@@ -120,21 +120,21 @@ export const heavyTask = task({
 });
 ```
 
-### `maxDuration` option
+### `maxComputeSeconds` option
 
-By default tasks can execute indefinitely, which can be great! But you also might want to set a `maxDuration` to prevent a task from running too long. You can set the `maxDuration` on a task, and all runs of that task will be stopped if they exceed the duration.
+By default tasks can execute indefinitely, which can be great! But you also might want to set a `maxComputeSeconds` to prevent a task from running too long. You can set the `maxComputeSeconds` on a task, and all runs of that task will be stopped if they exceed the duration.
 
 ```ts /trigger/long-task.ts
 export const longTask = task({
   id: "long-task",
-  maxDuration: 300, // 300 seconds or 5 minutes
+  maxComputeSeconds: 300, // 300 seconds or 5 minutes
   run: async (payload: any, { ctx }) => {
     //...
   },
 });
 ```
 
-See our [maxDuration guide](/runs/max-duration) for more information.
+See our [maxComputeSeconds guide](/runs/max-duration) for more information.
 
 ## Global lifecycle hooks
 

docs/triggering.mdx

@@ -932,7 +932,7 @@ Without `maxDelay`, continuous triggers would prevent the run from ever executin
 
 By default, debounce uses **leading mode** - the run executes with data from the **first** trigger.
 
-With **trailing mode**, each subsequent trigger updates the run's data (payload, metadata, tags, maxAttempts, maxDuration, and machine), so the run executes with data from the **last** trigger:
+With **trailing mode**, each subsequent trigger updates the run's data (payload, metadata, tags, maxAttempts, maxComputeSeconds, and machine), so the run executes with data from the **last** trigger:
 
 ```ts
 // Leading mode (default): runs with first payload
@@ -1090,9 +1090,9 @@ View our [tags doc](/tags) for more information.
 
 View our [metadata doc](/runs/metadata) for more information.
 
-### `maxDuration`
+### `maxComputeSeconds`
 
-View our [maxDuration doc](/runs/max-duration) for more information.
+View our [maxComputeSeconds doc](/runs/max-duration) for more information.
 
 ### `priority`
 

packages/cli-v3/src/entryPoints/dev-index-worker.ts

@@ -117,13 +117,14 @@ if (config.retries?.default) {
   });
 }
 
-// If the config has a maxDuration, we need to apply it to all tasks that don't have a maxDuration
-if (typeof config.maxDuration === "number") {
+// If the config has a maxComputeSeconds or maxDuration, we need to apply it to all tasks that don't have a maxDuration
+const configMaxDuration = config.maxComputeSeconds ?? config.maxDuration;
+if (typeof configMaxDuration === "number") {
   tasks = tasks.map((task) => {
     if (typeof task.maxDuration !== "number") {
       return {
         ...task,
-        maxDuration: config.maxDuration,
+        maxDuration: configMaxDuration,
       } satisfies TaskManifest;
     }
 

packages/cli-v3/src/entryPoints/managed-index-worker.ts

@@ -117,13 +117,14 @@ if (config.retries?.default) {
   });
 }
 
-// If the config has a maxDuration, we need to apply it to all tasks that don't have a maxDuration
-if (typeof config.maxDuration === "number") {
+// If the config has a maxComputeSeconds or maxDuration, we need to apply it to all tasks that don't have a maxDuration
+const configMaxDuration = config.maxComputeSeconds ?? config.maxDuration;
+if (typeof configMaxDuration === "number") {
   tasks = tasks.map((task) => {
     if (typeof task.maxDuration !== "number") {
       return {
         ...task,
-        maxDuration: config.maxDuration,
+        maxDuration: configMaxDuration,
       } satisfies TaskManifest;
     }
 

packages/cli-v3/templates/examples/schedule.mjs.template

@@ -4,8 +4,8 @@ export const firstScheduledTask = schedules.task({
   id: "first-scheduled-task",
   // Every hour
   cron: "0 * * * *",
-  // Set an optional maxDuration to prevent tasks from running indefinitely
-  maxDuration: 300, // Stop executing after 300 secs (5 mins) of compute
+  // Set an optional maxComputeSeconds to prevent tasks from running indefinitely
+  maxComputeSeconds: 300, // Stop executing after 300 secs (5 mins) of compute
   run: async (payload, { ctx }) => {
     // The payload contains the last run timestamp that you can use to check if this is the first run
     // And calculate the time since the last run

packages/cli-v3/templates/examples/schedule.ts.template

@@ -4,8 +4,8 @@ export const firstScheduledTask = schedules.task({
   id: "first-scheduled-task",
   // Every hour
   cron: "0 * * * *",
-  // Set an optional maxDuration to prevent tasks from running indefinitely
-  maxDuration: 300, // Stop executing after 300 secs (5 mins) of compute
+  // Set an optional maxComputeSeconds to prevent tasks from running indefinitely
+  maxComputeSeconds: 300, // Stop executing after 300 secs (5 mins) of compute
   run: async (payload, { ctx }) => {
     // The payload contains the last run timestamp that you can use to check if this is the first run
     // And calculate the time since the last run

packages/cli-v3/templates/examples/simple.mjs.template

@@ -2,8 +2,8 @@ import { logger, task, wait } from "@trigger.dev/sdk/v3";
 
 export const helloWorldTask = task({
   id: "hello-world",
-  // Set an optional maxDuration to prevent tasks from running indefinitely
-  maxDuration: 300, // Stop executing after 300 secs (5 mins) of compute
+  // Set an optional maxComputeSeconds to prevent tasks from running indefinitely
+  maxComputeSeconds: 300, // Stop executing after 300 secs (5 mins) of compute
   run: async (payload, { ctx }) => {
     logger.log("Hello, world!", { payload, ctx });
 

packages/cli-v3/templates/examples/simple.ts.template

@@ -2,8 +2,8 @@ import { logger, task, wait } from "@trigger.dev/sdk/v3";
 
 export const helloWorldTask = task({
   id: "hello-world",
-  // Set an optional maxDuration to prevent tasks from running indefinitely
-  maxDuration: 300, // Stop executing after 300 secs (5 mins) of compute
+  // Set an optional maxComputeSeconds to prevent tasks from running indefinitely
+  maxComputeSeconds: 300, // Stop executing after 300 secs (5 mins) of compute
   run: async (payload: any, { ctx }) => {
     logger.log("Hello, world!", { payload, ctx });