workflow 5.0.0-beta.9 → 5.0.0

package/docs/foundations/serialization.mdx

@@ -15,11 +15,11 @@ All function arguments and return values passed between workflow and step functi
 The serialization system ensures that all data persists correctly across workflow suspensions and resumptions, enabling durable execution.
 </Callout>
 
-## Supported Serializable Types
+## Supported serializable types
 
 The following types can be serialized and passed through workflow functions:
 
-**Standard JSON Types:**
+**Standard JSON types:**
 
 - `string`
 - `number`
@@ -28,12 +28,13 @@ The following types can be serialized and passed through workflow functions:
 - Arrays of serializable values
 - Objects with string keys and serializable values
 
-**Extended Types:**
+**Extended types:**
 
 - `undefined`
 - `bigint`
 - `ArrayBuffer`
 - `BigInt64Array`, `BigUint64Array`
+- `DataView`
 - `Date`
 - `Float32Array`, `Float64Array`
 - `Int8Array`, `Int16Array`, `Int32Array`
@@ -58,7 +59,7 @@ These types have special handling and are explained in detail in the sections be
 - `AbortController`
 - `AbortSignal`
 
-## Pass-by-Value Semantics
+## Pass-by-value semantics
 
 **Parameters are passed by value, not by reference.** Steps receive deserialized copies of data. Mutations inside a step won't affect the original in the workflow.
 
@@ -81,7 +82,7 @@ async function updateUserStep(user: { id: string; name: string; email: string })
 }
 ```
 
-**Correct - return the modified data:**
+**Correct, return the modified data:**
 
 ```typescript title="workflows/correct-mutation.ts" lineNumbers
 export async function updateUserWorkflow(userId: string) {
@@ -100,7 +101,7 @@ async function updateUserStep(user: { id: string; name: string; email: string })
 }
 ```
 
-**Custom Classes:**
+**Custom classes:**
 
 - Class instances that implement [`WORKFLOW_SERIALIZE` and `WORKFLOW_DESERIALIZE`](#custom-class-serialization)
 
@@ -110,7 +111,7 @@ async function updateUserStep(user: { id: string; name: string; email: string })
 
 For complete information about using streams in workflows, including patterns for AI streaming, file processing, and progress updates, see the [Streaming Guide](/docs/foundations/streaming).
 
-## Request & Response
+## Request & response
 
 The Web API [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request) and [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response) APIs are supported by the serialization system,
 and can be passed around between workflow and step functions similarly to other data types.
@@ -140,7 +141,7 @@ export async function handleWebhookWorkflow() {
 }
 ```
 
-### Using `fetch` in Workflows
+### Using `fetch` in workflows
 
 Because `Request` and `Response` are serializable, Workflow SDK provides a `fetch` function that can be used directly in workflow functions:
 
@@ -158,7 +159,7 @@ export async function apiWorkflow() {
 }
 ```
 
-The implementation is straightforward - `fetch` from workflow is a step function that wraps the standard `fetch`:
+The `fetch` implementation from `workflow` is a step function that wraps the standard `fetch`:
 
 ```typescript title="Implementation" lineNumbers
 export async function fetch(...args: Parameters<typeof globalThis.fetch>) {
@@ -202,11 +203,11 @@ async function fetchData(signal: AbortSignal) {
 
 For usage patterns including timeouts, parallel cancellation, user-triggered cancellation, and run cancellation, see the [Cancellation Guide](/docs/foundations/cancellation). For details on the hook and stream backing that makes this work, see [How Cancellation Works](/docs/how-it-works/cancellation).
 
-## Custom Class Serialization
+## Custom class serialization
 
 By default, custom class instances cannot be serialized because the serialization system doesn't know how to reconstruct them. You can make your classes serializable by implementing two static methods using special symbols from the `@workflow/serde` package.
 
-### Basic Example
+### Basic example
 
 {/* @expect-error:2351 */}
 
@@ -256,13 +257,13 @@ async function doublePoint(point: Point) {
 }
 ```
 
-### How It Works
+### How it works
 
 1. **`WORKFLOW_SERIALIZE`**: A static method that receives a class instance and returns serializable data (primitives, plain objects, arrays, etc.)
 
 2. **`WORKFLOW_DESERIALIZE`**: A static method that receives the serialized data and returns a new class instance
 
-3. **Automatic Registration**: The SWC compiler plugin automatically detects classes that implement these symbols and registers them for serialization. Each class receives a deterministic `classId` derived from its file path and class name, and is registered into the global `Symbol.for("workflow-class-registry")` registry at build time — no manual registration step is required
+3. **Automatic Registration**: The SWC compiler plugin automatically detects classes that implement these symbols and registers them for serialization. Each class receives a deterministic `classId` derived from its file path and class name, and is registered into the global `Symbol.for("workflow-class-registry")` registry at build time. No manual registration step is required
 
 ### Requirements
 
@@ -279,12 +280,12 @@ The `WORKFLOW_SERIALIZE` and `WORKFLOW_DESERIALIZE` methods run inside the workf
 - No non-deterministic operations (like `Math.random()` or `Date.now()`)
 - No external network calls
 
-Keep these methods simple and focused on data transformation only.
+Keep these methods focused on data transformation only.
 </Callout>
 
-### Instance Methods as Steps
+### Instance methods as steps
 
-In practice, many classes have methods that need Node.js APIs, perform network calls, or interact with databases — operations that are not allowed in the `"use workflow"` execution context. You can make these methods workflow-compatible by adding `"use step"` to them. The SWC compiler will strip the method bodies from the workflow bundle and replace them with proxy functions that invoke the method as a step — with full Node.js runtime access. The `this` context (the class instance) is automatically serialized and deserialized across the workflow/step boundary.
+In practice, many classes have methods that need Node.js APIs, perform network calls, or interact with databases, operations that are not allowed in the `"use workflow"` execution context. You can make these methods workflow-compatible by adding `"use step"` to them. The SWC compiler will strip the method bodies from the workflow bundle and replace them with proxy functions that invoke the method as a step, with full Node.js runtime access. The `this` context (the class instance) is automatically serialized and deserialized across the workflow/step boundary.
 
 This requires the class to implement `WORKFLOW_SERIALIZE` and `WORKFLOW_DESERIALIZE`, so that the instance can be passed to the step execution context.
 
@@ -301,7 +302,7 @@ class Order {
     public createdAt: Date
   ) {}
 
-  // Custom serialization — data must be serializable types
+  // Custom serialization: data must be serializable types
   static [WORKFLOW_SERIALIZE](instance: Order) { // [!code highlight]
     return { // [!code highlight]
       id: instance.id, // [!code highlight]
@@ -329,7 +330,7 @@ class Order {
   }
 
   // Instance methods with "use step" run as step functions
-  // with full Node.js access — `this` is automatically serialized
+  // with full Node.js access; `this` is automatically serialized
   async save(): Promise<void> {
     "use step"; // [!code highlight]
     await db.orders.insert({ // [!code highlight]
@@ -355,7 +356,7 @@ class Order {
 }
 ```
 
-The class can then be used naturally inside a workflow function. Instance methods marked with `"use step"` are each executed as a step — with automatic caching, retry semantics, and full Node.js runtime access. Methods _without_ `"use step"` run directly in the workflow context, so they must follow the same constraints as workflow functions:
+The class can then be used naturally inside a workflow function. Instance methods marked with `"use step"` are each executed as a step, with automatic caching, retry semantics, and full Node.js runtime access. Methods _without_ `"use step"` run directly in the workflow context, so they must follow the same constraints as workflow functions:
 
 {/* @expect-error:2693 */}
 
@@ -369,7 +370,7 @@ export async function processOrderWorkflow(
 
   const order = new Order(orderId, items, new Date()); // [!code highlight]
 
-  // Runs in the workflow context — no "use step" needed
+  // Runs in the workflow context; no "use step" needed
   const itemCount = order.total(); // [!code highlight]
 
   // Each "use step" instance method call runs as a separate step
@@ -380,7 +381,7 @@ export async function processOrderWorkflow(
 }
 ```
 
-Note that [pass-by-value semantics](#pass-by-value-semantics) also apply to the `this` context of `"use step"` instance methods. Modifying instance properties inside a step method will not affect the original instance in the workflow. If you need to update instance state, return `this` from the step method and re-assign the variable in the workflow:
+[Pass-by-value semantics](#pass-by-value-semantics) also apply to the `this` context of `"use step"` instance methods. Modifying instance properties inside a step method will not affect the original instance in the workflow. If you need to update instance state, return `this` from the step method and re-assign the variable in the workflow:
 
 {/* @expect-error:2351 */}
 
@@ -408,4 +409,3 @@ export async function processOrderWorkflow() {
   order = await order.addItem("Widget", 3); // [!code highlight]
 }
 ```
-

package/docs/foundations/starting-workflows.mdx

@@ -1,5 +1,5 @@
 ---
-title: Starting Workflows
+title: Starting workflows
 description: Trigger workflow execution with the start() function and track progress with Run objects.
 type: guide
 summary: Trigger workflows and track their execution using the start() function.
@@ -9,11 +9,11 @@ related:
   - /docs/api-reference/workflow-api/start
 ---
 
-Once you've defined your workflow functions, you need to trigger them to begin execution. This is done using the `start()` function from `workflow/api`, which enqueues a new workflow run and returns a `Run` object that you can use to track its progress.
+After you define a workflow function, use the `start()` function from `workflow/api` to trigger it. The function enqueues a new workflow run and returns a `Run` object for tracking its progress.
 
-## The `start()` Function
+## The `start()` function
 
-The [`start()`](/docs/api-reference/workflow-api/start) function is used to programmatically trigger workflow executions from runtime contexts like API routes, Server Actions, or any server-side code. In v5, you can also call `start()` from inside a workflow function when you want to spawn a child run or continue work in a new run.
+The [`start()`](/docs/api-reference/workflow-api/start) function programmatically triggers workflow executions from runtime contexts such as API routes, Server Actions, or other server-side code. In v5, you can also call `start()` inside a workflow function to spawn a child run or continue work in a new run.
 
 ```typescript lineNumbers
 import { start } from "workflow/api";
@@ -32,20 +32,21 @@ export async function POST(request: Request) {
 }
 ```
 
-**Key Points:**
+**Key points:**
 
-- `start()` returns immediately after enqueuing the workflow - it doesn't wait for completion
+- `start()` returns immediately after enqueuing the workflow. It doesn't wait for completion
 - The first argument is your workflow function
 - The second argument is an array of arguments to pass to the workflow (optional if the workflow takes no arguments)
 - All arguments must be [serializable](/docs/foundations/serialization)
+- On Worlds with a regional dimension, the optional `region` option pins the new run's storage, queuing, and streams to a specific region. See [Multi-region on the Vercel World](/worlds/vercel#multi-region)
 
-**Learn more**: [`start()` API Reference](/docs/api-reference/workflow-api/start)
+**Learn more**: [`start()` API reference](/docs/api-reference/workflow-api/start)
 
 <Callout type="info">
 For parent-child workflow patterns, see [Workflow Composition](/cookbook/common-patterns/workflow-composition). For long-lived workflows that intentionally hand off to newer deployments with `deploymentId: "latest"`, see [Versioning](/docs/foundations/versioning).
 </Callout>
 
-## The `Run` Object
+## The `Run` object
 
 When you call `start()`, it returns a [`Run`](/docs/api-reference/workflow-api/start#returns) object that provides access to the workflow's status and results.
 
@@ -65,24 +66,55 @@ const status = await run.status; // "running" | "completed" | "failed"
 const result = await run.returnValue;
 ```
 
-**Key Properties:**
+**Key properties:**
 
-- `runId` - Unique identifier for this workflow run
-- `status` - Current status of the workflow (async)
-- `returnValue` - The value returned by the workflow function (async, blocks until completion)
-- `readable` - ReadableStream for streaming updates from the workflow
+- `runId`: Unique identifier for this workflow run
+- `status`: Current status of the workflow (async)
+- `returnValue`: The value returned by the workflow function (async, blocks until completion)
+- `readable`: `ReadableStream` for streaming updates from the workflow
 
 <Callout type="info">
-Most `Run` properties are async getters that return promises. You need to `await` them to get their values. For a complete list of properties and methods, see the API reference below.
+Most `Run` properties are async getters that return promises. `await` them to get their values. For a complete list of properties and methods, see the API reference below.
 </Callout>
 
-**Learn more**: [`Run` API Reference](/docs/api-reference/workflow-api/start#returns)
+**Learn more**: [`Run` API reference](/docs/api-reference/workflow-api/start#returns)
 
-## Common Patterns
+## Common patterns
 
-### Fire and Forget
+### Starting workflows from workflow functions
 
-The most common pattern is to start a workflow and immediately return, letting it execute in the background:
+You can also call `start()` directly inside workflow functions to spawn child workflows. For choosing between this and awaiting a workflow function directly, see [Workflow Composition](/cookbook/common-patterns/workflow-composition).
+
+```typescript lineNumbers
+import { start } from "workflow/api";
+import { childWorkflow } from "./workflows/child";
+
+export async function parentWorkflow(inputValue: number) {
+  "use workflow";
+
+  const childRun = await start(childWorkflow, [inputValue]); // [!code highlight]
+
+  // childRun is a full Run object. Use it like normal.
+  const childResult = await childRun.returnValue;
+  return { childRunId: childRun.runId, childResult };
+}
+```
+
+When you call `start()` inside a workflow function, it automatically executes through an internal step to maintain deterministic replay. The returned `Run` object works as it does outside workflows. Properties such as `.runId`, `.status`, and `.returnValue`, and methods such as `.cancel()`, are all available. Each property access or method call executes as a separate step.
+
+If the child run fails or is canceled, `await childRun.returnValue` throws [`WorkflowRunFailedError`](/docs/api-reference/workflow-errors/workflow-run-failed-error) or [`WorkflowRunCancelledError`](/docs/api-reference/workflow-errors/workflow-run-cancelled-error) on the first attempt.
+
+<Callout type="info">
+Inside workflow functions, each `Run` property access (e.g., `run.status`, `run.returnValue`) triggers a workflow step. This means each access is recorded in the event log and replayed deterministically.
+</Callout>
+
+<Callout type="warn">
+Awaiting `returnValue` polls the child run every second, and the polling step holds its worker slot open until the child finishes. Size worker-based Worlds to cover the peak number of these polls in flight. If the child workflow is long-running, spawn it without awaiting `returnValue` and have it resume a [hook](/docs/foundations/hooks) when it completes. See the [`startAndWait()` pattern](/cookbook/advanced/child-workflows).
+</Callout>
+
+### Fire and forget
+
+Start a workflow and immediately return to let it execute in the background:
 
 ```typescript lineNumbers
 import { start } from "workflow/api";
@@ -100,7 +132,7 @@ export async function POST(request: Request) {
 }
 ```
 
-### Wait for Completion
+### Wait for completion
 
 If you need to wait for the workflow to complete before responding:
 
@@ -119,12 +151,12 @@ export async function POST(request: Request) {
 ```
 
 <Callout type="warn">
-Be cautious when waiting for `returnValue` - if your workflow takes a long time, your API route may timeout.
+Waiting for `returnValue` can cause your API route to time out if the workflow takes a long time.
 </Callout>
 
-### Stream Updates to Client
+### Stream updates to client
 
-Stream real-time updates from your workflow as it executes, without waiting for completion:
+Stream updates from your workflow as it executes without waiting for completion:
 
 ```typescript lineNumbers
 import { start } from "workflow/api";
@@ -148,7 +180,7 @@ export async function POST(request: Request) {
 }
 ```
 
-Your workflow can obtain a writable stream using [`getWritable()`](/docs/api-reference/workflow/get-writable):
+Your workflow can write to the stream using [`getWritable()`](/docs/api-reference/workflow/get-writable):
 
 ```typescript lineNumbers
 import { getWritable } from "workflow";
@@ -182,12 +214,12 @@ async function streamContentToClient(
 ```
 
 <Callout type="info">
-Streams are particularly useful for AI workflows where you want to show progress to users in real-time, or for long-running processes that produce intermediate results.
+Use streams to show users real-time progress from AI workflows or intermediate results from long-running processes.
 </Callout>
 
-**Learn more**: [Streaming in Workflows](/docs/foundations/serialization#streaming)
+**Learn more**: [Streaming in workflows](/docs/foundations/serialization#streaming)
 
-### Check Status Later
+### Check status later
 
 You can retrieve a workflow run later using its `runId` with [`getRun()`](/docs/api-reference/workflow-api/get-run):
 
@@ -213,10 +245,52 @@ export async function GET(request: Request) {
 }
 ```
 
-## Next Steps
+### Recursive and repeating workflows
+
+A workflow can start a new instance of itself. This pattern prevents a single long-running workflow from accumulating too many events. Large event logs are slower to replay, more expensive to store, and harder to inspect in the UI. Breaking work into smaller runs that chain together keeps each run lean.
+
+```typescript lineNumbers
+import { start } from "workflow/api";
+declare function fetchBatch(cursor?: string): Promise<{ items: string[]; nextCursor?: string }>; // @setup
+declare function processBatch(items: string[]): Promise<void>; // @setup
+
+export async function processQueue(cursor?: string) {
+  "use workflow";
+
+  const { items, nextCursor } = await fetchBatch(cursor);
+  await processBatch(items);
+
+  if (nextCursor) {
+    // Continue processing in a new workflow run
+    await start(processQueue, [nextCursor]); // [!code highlight]
+  }
+}
+```
+
+This pattern also enables **repeating cron-like workflows**. A workflow can complete its work, sleep, and then schedule a new instance of itself. This creates an indefinite chain without allowing any single run to grow too large:
+
+```typescript lineNumbers
+import { sleep } from "workflow";
+import { start } from "workflow/api";
+declare function refreshMetrics(): Promise<void>; // @setup
+
+export async function syncDashboard() {
+  "use workflow";
+
+  await refreshMetrics();
+  await sleep("1h");
+
+  // Schedule the next run
+  await start(syncDashboard); // [!code highlight]
+}
+```
+
+#### Starting against the latest deployment
+
+By default a chained run starts on the same deployment as its parent. For workflows that chain over long periods, pass [`deploymentId: "latest"`](/docs/api-reference/workflow-api/start#using-deploymentid-latest) so the next run picks up new code. [Versioning](/docs/foundations/versioning#self-upgrading-workflows) covers this pattern in full, including how the serialized state acts as the migration boundary between versions.
 
-Now that you understand how to start workflows and track their execution:
+## Next steps
 
 - Browse the [Cookbook](/cookbook) for copy-paste recipes covering composition, scheduling, timeouts, and more
-- Explore [Errors & Retrying](/docs/foundations/errors-and-retries) to handle failures gracefully
-- Check the [`start()` API Reference](/docs/api-reference/workflow-api/start) for complete details
+- Explore [Errors and retrying](/docs/foundations/errors-and-retries) to handle failures
+- Check the [`start()` API reference](/docs/api-reference/workflow-api/start) for complete details