workflow 5.0.0-beta.1 → 5.0.0-beta.3

package/docs/cookbook/integrations/sandbox.mdx

@@ -0,0 +1,516 @@
+---
+title: Sandbox
+description: Model one Vercel Sandbox per workflow run — durable, idle-efficient, and not bound by the 5-hour sandbox hard cap.
+type: guide
+summary: Own a sandbox for the lifetime of a workflow run. Hibernate on idle via snapshot(), proactively refresh before the sandbox hard cap, and reconnect by runId — so one logical session can run effectively forever.
+related:
+  - /docs/ai/defining-tools
+  - /docs/foundations/errors-and-retries
+  - /docs/cookbook/common-patterns/scheduling
+  - /docs/cookbook/agent-patterns/durable-agent
+---
+
+[Vercel Sandbox](https://vercel.com/docs/sandbox) provides isolated code execution environments. The `@vercel/sandbox` package has first-class support for the Workflow SDK — the `Sandbox` class is serializable, and its methods (`create`, `runCommand`, `stop`, `snapshot`) implicitly run as steps. You can use `Sandbox` directly inside a workflow function without wrapping each call in a separate `"use step"` function.
+
+## Why Workflow + Sandbox
+
+A sandbox alone gets you an isolated VM. A workflow around it gets you a **durable controller** for that VM's entire lifetime:
+
+- **One workflow run = one sandbox session.** The `runId` is the only state you need to persist on the client. Close the tab, come back a week later, POST the same `runId` and you're back in the same session.
+- **Efficient resource use.** Active sandboxes cost money; hibernated workflows cost nothing. The workflow races a command hook against a `sleep()` timer — when idle, it calls `sandbox.snapshot()` (which also stops the VM) and waits indefinitely. Next command → spin a new sandbox from the snapshot with filesystem, installed packages, and git history intact.
+- **Beyond the 5-hour hard cap.** Every Vercel Sandbox has a maximum lifetime. The workflow tracks that deadline and proactively snapshots + recreates *before* the cap, so the logical session outlives any one VM. Effectively unbounded session duration on top of time-bounded infrastructure.
+- **Automatic cleanup.** `try/finally` in the workflow guarantees the VM is stopped on failure or destroy.
+
+## Use Case: Coding Agents
+
+This is the pattern [Open Agents](https://open-agents.dev/) uses to spawn coding agents that run "infinitely in the cloud." Each agent session gets its own sandbox — full filesystem, network, and runtime access — and the durable workflow keeps the agent loop resumable across restarts, auto-hibernates when the user walks away, and reconnects instantly when they return.
+
+Most coding-agent workloads look like this:
+
+- User sends a task → agent plans, reads files, runs shell commands, commits.
+- User walks away mid-run → agent keeps going, eventually goes idle waiting for input.
+- User comes back days later → same branch, same filesystem, same conversation history.
+
+Without durable workflows you'd need a separate state store for the agent loop, a separate job queue for retries, a separate scheduler for idle cleanup, and bespoke reconnection logic. With the pattern below, all of it is one file.
+
+## Quickstart: One-shot Pipeline
+
+Before the full session pattern, the simplest shape. Each sandbox method is an implicit step, so the event log records every command and the workflow replays from the last completed call on restart.
+
+```typescript title="workflows/sandbox-pipeline.ts" lineNumbers
+import { Sandbox } from "@vercel/sandbox";
+
+export async function sandboxPipeline(input: { commands: string[] }) {
+  "use workflow";
+
+  const sandbox = await Sandbox.create({ runtime: "node22" }); // [!code highlight]
+
+  try {
+    const results = [];
+    for (const command of input.commands) {
+      const result = await sandbox.runCommand({ // [!code highlight]
+        cmd: "bash",
+        args: ["-c", command],
+      });
+      results.push({
+        command,
+        exitCode: result.exitCode,
+        stdout: await result.stdout(),
+        stderr: await result.stderr(),
+      });
+    }
+    return { status: "completed", results };
+  } finally {
+    await sandbox.stop(); // [!code highlight]
+  }
+}
+```
+
+## Session Pattern: Persistent Sandbox Beyond the Hard Cap
+
+One workflow run owns a sandbox for its whole lifetime. The workflow's loop does two jobs simultaneously:
+
+1. **Command pipeline** — await a hook, run the next user command, stream output, loop.
+2. **Sandbox lifecycle** — race the hook against a `sleep()` timer armed for whichever comes first: the idle deadline or the sandbox's refresh deadline (a safety margin before its hard cap).
+
+When the timer wins:
+
+- **Idle** → `sandbox.snapshot()` and wait indefinitely for the next command. No compute while asleep.
+- **Near sandbox hard cap** → `sandbox.snapshot()` and immediately create a new sandbox from the snapshot. The session appears continuous; the underlying VM just rotated.
+
+The only way out is an explicit `/destroy` command.
+
+<Tabs items={['Workflow', 'API Routes', 'Client']}>
+
+<Tab value="Workflow">
+
+```typescript title="workflows/sandbox-session.ts" lineNumbers
+import { defineHook, sleep, getWritable, getWorkflowMetadata } from "workflow";
+import { Sandbox, type Snapshot } from "@vercel/sandbox";
+import { z } from "zod";
+
+export const commandHook = defineHook({ // [!code highlight]
+  schema: z.object({ command: z.string() }),
+});
+
+const RUNTIME = "node22";
+const HIBERNATE_AFTER_MS = 30 * 60_000; // 30 min idle → hibernate
+const SANDBOX_TIMEOUT_MS = 5 * 60 * 60_000; // sandbox hard cap (5h)
+const REFRESH_SAFETY_MS = 5 * 60_000; // refresh 5 min before the cap
+
+export type SandboxEvent =
+  | {
+      type: "created";
+      sandboxId: string;
+      runtime: string;
+      startedAt: number;
+      sandboxExpiresAt: number;
+      hibernateAfterMs: number;
+    }
+  | {
+      type: "status";
+      state:
+        | "active"
+        | "hibernating"
+        | "hibernated"
+        | "resuming"
+        | "refreshing"
+        | "destroyed";
+      at: number;
+      sandboxId?: string;
+      sandboxExpiresAt?: number;
+      snapshotId?: string;
+    }
+  | { type: "activity"; at: number }
+  | { type: "command_start"; id: string; command: string; at: number }
+  | { type: "command_output"; id: string; stream: "stdout" | "stderr"; data: string }
+  | { type: "command_end"; id: string; exitCode: number | null; durationMs: number }
+  | { type: "result"; status: "destroyed"; durationMs: number };
+
+async function emit(event: SandboxEvent) {
+  "use step";
+  const writer = getWritable<SandboxEvent>().getWriter();
+  try {
+    await writer.write(event);
+  } finally {
+    writer.releaseLock();
+  }
+}
+
+async function runCommandAndStream(sandbox: Sandbox, id: string, command: string) {
+  "use step";
+  const writer = getWritable<SandboxEvent>().getWriter();
+  const startedAt = Date.now();
+  try {
+    await writer.write({ type: "command_start", id, command, at: startedAt });
+    const result = await sandbox.runCommand({ cmd: "bash", args: ["-c", command] });
+    const stdout = await result.stdout();
+    if (stdout) await writer.write({ type: "command_output", id, stream: "stdout", data: stdout });
+    const stderr = await result.stderr();
+    if (stderr) await writer.write({ type: "command_output", id, stream: "stderr", data: stderr });
+    await writer.write({
+      type: "command_end", id,
+      exitCode: result.exitCode,
+      durationMs: Date.now() - startedAt,
+    });
+  } finally {
+    writer.releaseLock();
+  }
+}
+
+export async function sandboxSessionWorkflow() {
+  "use workflow";
+
+  const { workflowRunId } = getWorkflowMetadata();
+  // Create the hook once, outside the loop — reusing the same token from inside // [!code highlight]
+  // the loop would throw HookConflictError. // [!code highlight]
+  const hook = commandHook.create({ token: workflowRunId });
+
+  const startedAt = Date.now();
+
+  let sandbox: Sandbox = await Sandbox.create({
+    runtime: RUNTIME,
+    timeout: SANDBOX_TIMEOUT_MS,
+  });
+  let sandboxCreatedAt = Date.now();
+  let sandboxExpiresAt = sandboxCreatedAt + SANDBOX_TIMEOUT_MS;
+
+  await emit({
+    type: "created",
+    sandboxId: sandbox.sandboxId,
+    runtime: RUNTIME,
+    startedAt,
+    sandboxExpiresAt,
+    hibernateAfterMs: HIBERNATE_AFTER_MS,
+  });
+  await emit({
+    type: "status", state: "active", at: Date.now(),
+    sandboxId: sandbox.sandboxId, sandboxExpiresAt,
+  });
+
+  let snapshot: Snapshot | null = null;
+  let hibernated = false;
+  let lastActivityAt = startedAt;
+  let counter = 0;
+  let destroyed = false;
+
+  try {
+    while (!destroyed) {
+      if (hibernated && snapshot) {
+        // While hibernated, the VM is already stopped. Just wait for the next
+        // command — no idle timer, no compute cost.
+        const payload = await hook;
+        if (payload.command === "/destroy") { destroyed = true; break; }
+
+        await emit({ type: "status", state: "resuming", at: Date.now() });
+        sandbox = await Sandbox.create({ // [!code highlight]
+          source: { type: "snapshot", snapshotId: snapshot.snapshotId }, // [!code highlight]
+          timeout: SANDBOX_TIMEOUT_MS, // [!code highlight]
+        });
+        sandboxCreatedAt = Date.now();
+        sandboxExpiresAt = sandboxCreatedAt + SANDBOX_TIMEOUT_MS;
+        hibernated = false;
+        snapshot = null;
+        await emit({
+          type: "status", state: "active", at: Date.now(),
+          sandboxId: sandbox.sandboxId, sandboxExpiresAt,
+        });
+
+        counter += 1;
+        await runCommandAndStream(sandbox, `cmd-${counter}`, payload.command);
+        lastActivityAt = Date.now();
+        await emit({ type: "activity", at: lastActivityAt });
+        continue;
+      }
+
+      // Active — wake at whichever comes first: idle-deadline or refresh-deadline.
+      const idleDeadline = lastActivityAt + HIBERNATE_AFTER_MS;
+      const refreshDeadline = sandboxExpiresAt - REFRESH_SAFETY_MS;
+      const wakeAt = Math.min(idleDeadline, refreshDeadline);
+      const sleepMs = Math.max(0, wakeAt - Date.now());
+
+      const outcome = await Promise.race([ // [!code highlight]
+        hook.then((p) => ({ type: "command" as const, command: p.command })),
+        sleep(`${sleepMs}ms`).then(() => ({ type: "timer" as const })),
+      ]);
+
+      if (outcome.type === "timer") {
+        const nearExpiry = Date.now() >= refreshDeadline;
+
+        if (nearExpiry) {
+          // Proactive refresh — snapshot and immediately recreate so the
+          // session outlives the sandbox hard cap.
+          await emit({ type: "status", state: "refreshing", at: Date.now() });
+          const snap = await sandbox.snapshot(); // [!code highlight]
+          sandbox = await Sandbox.create({ // [!code highlight]
+            source: { type: "snapshot", snapshotId: snap.snapshotId }, // [!code highlight]
+            timeout: SANDBOX_TIMEOUT_MS, // [!code highlight]
+          });
+          sandboxCreatedAt = Date.now();
+          sandboxExpiresAt = sandboxCreatedAt + SANDBOX_TIMEOUT_MS;
+          await emit({
+            type: "status", state: "active", at: Date.now(),
+            sandboxId: sandbox.sandboxId, sandboxExpiresAt,
+            snapshotId: snap.snapshotId,
+          });
+          lastActivityAt = Date.now();
+        } else {
+          // Idle — snapshot and hibernate indefinitely.
+          await emit({ type: "status", state: "hibernating", at: Date.now() });
+          snapshot = await sandbox.snapshot(); // [!code highlight]
+          hibernated = true;
+          await emit({
+            type: "status", state: "hibernated", at: Date.now(),
+            snapshotId: snapshot.snapshotId,
+          });
+        }
+        continue;
+      }
+
+      if (outcome.command === "/destroy") { destroyed = true; break; }
+
+      counter += 1;
+      await runCommandAndStream(sandbox, `cmd-${counter}`, outcome.command);
+      lastActivityAt = Date.now();
+      await emit({ type: "activity", at: lastActivityAt });
+    }
+  } finally {
+    if (!hibernated) {
+      try {
+        if (sandbox.status === "running") await sandbox.stop();
+      } catch { /* best-effort */ }
+    }
+    await emit({ type: "status", state: "destroyed", at: Date.now() });
+    await emit({
+      type: "result",
+      status: "destroyed",
+      durationMs: Date.now() - startedAt,
+    });
+  }
+}
+```
+
+</Tab>
+
+<Tab value="API Routes">
+
+Two endpoints. `/start` accepts an optional `{ runId }` — if the run still exists, it replays the event log from index 0 so a returning client fully rehydrates. `/command` resumes the hook and returns immediately; command output lands on the `/start` stream.
+
+```typescript title="app/api/sandbox/start/route.ts" lineNumbers
+import { start, getRun } from "workflow/api";
+import { sandboxSessionWorkflow } from "@/workflows/sandbox-session";
+
+export async function POST(req: Request) {
+  let body: { runId?: string } = {};
+  try {
+    const text = await req.text();
+    if (text) body = JSON.parse(text);
+  } catch { /* ignore malformed body */ }
+
+  // Reconnect path: if the client sends a known runId, stream the durable
+  // event log from the beginning so the UI can rehydrate.
+  if (body.runId) {
+    const run = getRun(body.runId);
+    if (await run.exists) { // [!code highlight]
+      const readable = run.getReadable({ startIndex: 0 }); // [!code highlight]
+      return new Response(readable.pipeThrough(ndjson()), {
+        headers: {
+          "Content-Type": "application/x-ndjson",
+          "x-workflow-run-id": body.runId,
+          "x-workflow-reconnected": "true",
+          "Cache-Control": "no-cache, no-transform",
+        },
+      });
+    }
+    // Stale runId — fall through to start fresh.
+  }
+
+  const run = await start(sandboxSessionWorkflow, []);
+  return new Response(run.readable.pipeThrough(ndjson()), {
+    headers: {
+      "Content-Type": "application/x-ndjson",
+      "x-workflow-run-id": run.runId,
+      "Cache-Control": "no-cache, no-transform",
+    },
+  });
+}
+
+function ndjson<T>() {
+  return new TransformStream<T, string>({
+    transform(chunk, controller) {
+      controller.enqueue(JSON.stringify(chunk) + "\n");
+    },
+  });
+}
+```
+
+```typescript title="app/api/sandbox/command/route.ts" lineNumbers
+import { commandHook } from "@/workflows/sandbox-session";
+
+export async function POST(req: Request) {
+  const { runId, command } = (await req.json()) as { runId?: string; command?: string };
+
+  if (!runId || typeof command !== "string") {
+    return Response.json({ error: "runId and command are required" }, { status: 400 });
+  }
+
+  try {
+    await commandHook.resume(runId, { command }); // [!code highlight]
+    return Response.json({ ok: true });
+  } catch (error) {
+    const msg = error instanceof Error ? error.message.toLowerCase() : "";
+    if (msg.includes("not found") || msg.includes("expired")) {
+      return Response.json({ ok: false, note: "session expired" }, { status: 410 });
+    }
+    throw error;
+  }
+}
+```
+
+</Tab>
+
+<Tab value="Client">
+
+On mount, if a `runId` is stashed in `localStorage`, reconnect to the existing run. Otherwise start fresh. Commands are POSTed to `/command` — output lands on the `/start` stream.
+
+```tsx title="components/sandbox-runner.tsx" lineNumbers
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import type { SandboxEvent } from "@/workflows/sandbox-session";
+
+const RUN_ID_KEY = "sandbox.runId";
+
+export function SandboxRunner() {
+  const [events, setEvents] = useState<SandboxEvent[]>([]);
+  const runIdRef = useRef<string | null>(null);
+  const didReconnectRef = useRef(false);
+
+  const consume = useCallback(async (res: Response) => {
+    if (!res.ok || !res.body) return;
+    runIdRef.current = res.headers.get("x-workflow-run-id");
+    if (runIdRef.current) {
+      localStorage.setItem(RUN_ID_KEY, runIdRef.current); // [!code highlight]
+    }
+
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          setEvents((prev) => [...prev, JSON.parse(line) as SandboxEvent]);
+        } catch { /* malformed line */ }
+      }
+    }
+  }, []);
+
+  const openStream = useCallback(
+    async (runId?: string) => {
+      setEvents([]);
+      const res = await fetch("/api/sandbox/start", {
+        method: "POST",
+        headers: runId ? { "Content-Type": "application/json" } : undefined,
+        body: runId ? JSON.stringify({ runId }) : undefined,
+      });
+      await consume(res);
+    },
+    [consume]
+  );
+
+  // Auto-reconnect on mount if a runId is stashed.
+  useEffect(() => {
+    if (didReconnectRef.current) return;
+    didReconnectRef.current = true;
+    const stored = localStorage.getItem(RUN_ID_KEY);
+    if (stored) openStream(stored); // [!code highlight]
+  }, [openStream]);
+
+  const start = useCallback(() => {
+    localStorage.removeItem(RUN_ID_KEY);
+    runIdRef.current = null;
+    openStream();
+  }, [openStream]);
+
+  const sendCommand = useCallback(async (command: string) => {
+    if (!runIdRef.current) return;
+    const res = await fetch("/api/sandbox/command", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ runId: runIdRef.current, command }),
+    });
+    if (res.status === 410) localStorage.removeItem(RUN_ID_KEY);
+  }, []);
+
+  const destroy = useCallback(async () => {
+    await sendCommand("/destroy");
+    localStorage.removeItem(RUN_ID_KEY);
+  }, [sendCommand]);
+
+  // Render events as a terminal-style log. Drive UI state from `status` events
+  // (active / hibernating / hibernated / resuming / refreshing / destroyed).
+  return null;
+}
+```
+
+</Tab>
+
+</Tabs>
+
+## How It Works
+
+1. **One workflow = one session.** The workflow owns a sandbox for its entire lifetime. The `runId` is the only state the client has to remember.
+2. **Hook created once.** `commandHook.create({ token: workflowRunId })` outside the loop. Creating it twice with the same token throws `HookConflictError`.
+3. **Two timer branches.** The active-state race wakes on the earlier of `idleDeadline` and `refreshDeadline`. The hibernated state awaits the hook alone — no timer, no compute.
+4. **Proactive refresh.** `refreshDeadline = sandboxExpiresAt - REFRESH_SAFETY_MS`. Hitting this triggers a snapshot + immediate new sandbox from that snapshot, rolling over the hard cap without user intervention.
+5. **`sandbox.snapshot()` stops the VM.** It's documented as part of the snapshot process — don't call `stop()` separately.
+6. **Resume = new sandbox.** `Sandbox.create({ source: { type: "snapshot", snapshotId } })` creates a fresh VM from the snapshot. The new sandbox has a different `sandboxId`; filesystem, installed packages, and git history are preserved.
+7. **Reconnect by runId.** `getRun(runId).getReadable({ startIndex: 0 })` replays the durable event log to a returning client, who rebuilds UI state from the replay.
+8. **Exit only on `/destroy`.** The workflow loop has no hard deadline of its own. Individual sandboxes time out; the session doesn't.
+
+## Pitfalls
+
+### `sandbox.stop()` is terminal
+
+A stopped sandbox cannot be restarted — you have to create a new one. Hibernation is only possible via `snapshot()` + new-sandbox-from-snapshot. Don't try to "pause" an active sandbox with `stop()` and resume later.
+
+### `snapshot()` already stops the VM
+
+Calling `stop()` after `snapshot()` either errors or is a no-op depending on timing. Snapshot takes care of it.
+
+### New `sandboxId` after resume and refresh
+
+Both `resuming` (idle → command) and `refreshing` (near-hard-cap rotation) create a new sandbox with a new `sandboxId`. Emit it on the subsequent `status: "active"` event and have the UI read from there, not from the initial `created` event.
+
+### Keep the refresh margin generous
+
+`snapshot()` + `Sandbox.create({ source })` takes real time (typically tens of seconds). If `REFRESH_SAFETY_MS` is too small, the old sandbox hits its hard cap mid-snapshot. Leave at least 60–90 seconds; 5 minutes is comfortable.
+
+### Don't call `writable.close()` inside a workflow function
+
+Stream closure must happen inside a `"use step"` function. Calling `writable.close()` directly in the workflow body throws `Not supported in workflow functions`. The runtime closes the underlying writable when the workflow returns.
+
+### Handle stale `runId` gracefully
+
+Clients can hold `runId`s from long-gone workflow runs (localStorage, back button, server restart). Gate the reconnect path on `run.exists` and fall through to starting fresh. On `hook.resume`, catch `not found` / `expired` and return 410 so the client clears its state.
+
+### Keep the hook outside the loop
+
+Each iteration's `hook.then(...)` attaches a listener to the same hook instance. Creating a new hook per iteration with the same token throws `HookConflictError`. One hook, one token (`workflowRunId`), reused every iteration.
+
+## Key APIs
+
+- [`Sandbox.create`](https://vercel.com/docs/sandbox) — provision a VM (runtime, source, timeout)
+- [`sandbox.runCommand`](https://vercel.com/docs/sandbox) — execute a command; implicit step
+- [`sandbox.snapshot`](https://vercel.com/docs/sandbox) — save state and stop the VM; returns `Snapshot`
+- [`defineHook()`](/docs/api-reference/workflow/define-hook) — suspension point for user commands
+- [`sleep()`](/docs/api-reference/workflow/sleep) — durable timer that powers both idle hibernation and proactive refresh
+- [`getRun()`](/docs/api-reference/workflow-api/get-run) — look up a run and replay its event log for reconnection
+- [`getWritable()`](/docs/api-reference/workflow/get-writable) — resumable NDJSON event stream

package/docs/cookbook/meta.json

@@ -0,0 +1,5 @@
+{
+  "title": "Cookbook",
+  "defaultOpen": true,
+  "pages": ["agent-patterns", "common-patterns", "integrations", "advanced"]
+}

package/docs/deploying/world/local-world.mdx

@@ -32,7 +32,7 @@ npx workflow web
 
 Learn more in the [Observability](/docs/observability) documentation.
 
-## Testing & Performance
+## Testing & Compatibility
 
 <WorldTestingPerformance />
 

package/docs/deploying/world/postgres-world.mdx

@@ -141,7 +141,7 @@ If `WORKFLOW_POSTGRES_URL` is not set, the CLI defaults to `postgres://world:wor
 
 Learn more in the [Observability](/docs/observability) documentation.
 
-## Testing & Performance
+## Testing & Compatibility
 
 <WorldTestingPerformance />
 

package/docs/deploying/world/vercel-world.mdx

@@ -83,7 +83,7 @@ npx workflow inspect runs \
 
 Learn more in the [Observability](/docs/observability) documentation.
 
-## Testing & Performance
+## Testing & Compatibility
 
 <WorldTestingPerformance />
 

package/docs/errors/start-invalid-workflow-function.mdx

@@ -123,7 +123,7 @@ Before calling `start()`:
 1. Confirm the function includes `"use workflow"` as its first statement.
 2. Confirm your framework integration is enabled (for Next.js, wrap `next.config.ts` with [`withWorkflow()`](/docs/api-reference/workflow-next/with-workflow)).
 3. Pass the imported workflow function directly to `start()`, not a wrapper callback.
-4. Keep the function in a file that goes through Workflow DevKit's transform step.
+4. Keep the function in a file that goes through Workflow SDK's transform step.
 
 ## Related
 

package/docs/foundations/index.mdx

@@ -17,9 +17,6 @@ Workflow programming can be a slight shift from how you traditionally write real
     <Card href="/docs/foundations/starting-workflows" title="Starting Workflows">
         Trigger workflows and track their execution using the `start()` function.
     </Card>
-    <Card href="/docs/foundations/common-patterns" title="Common Patterns">
-        Common patterns useful in workflows.
-    </Card>
     <Card href="/docs/foundations/errors-and-retries" title="Errors & Retrying">
         Types of errors and how retrying work in workflows.
     </Card>

package/docs/foundations/meta.json

@@ -3,7 +3,6 @@
   "pages": [
     "workflows-and-steps",
     "starting-workflows",
-    "common-patterns",
     "errors-and-retries",
     "hooks",
     "streaming",

package/docs/foundations/serialization.mdx

@@ -185,7 +185,7 @@ async function doublePoint(point: Point) {
 
 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
+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
 

package/docs/foundations/starting-workflows.mdx

@@ -213,6 +213,6 @@ export async function GET(request: Request) {
 
 Now that you understand how to start workflows and track their execution:
 
-- Learn about [Common Patterns](/docs/foundations/common-patterns) for organizing complex workflows
+- 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

package/docs/getting-started/index.mdx

@@ -8,7 +8,7 @@ related:
   - /docs/foundations/workflows-and-steps
 ---
 
-import { Next, Nitro, SvelteKit, Nuxt, Hono, Bun, AstroDark, AstroLight, TanStack, Vite, Express, Nest, Fastify } from "@/app/[lang]/(home)/components/frameworks";
+import { Next, Nitro, SvelteKit, Nuxt, Hono, Bun, AstroDark, AstroLight, TanStack, Vite, Express, Nest, Fastify, Python } from "@/app/[lang]/(home)/components/frameworks";
 
 <Cards>
     <Card href="/docs/getting-started/next">
@@ -63,6 +63,13 @@ import { Next, Nitro, SvelteKit, Nuxt, Hono, Bun, AstroDark, AstroLight, TanStac
         <span className="font-medium">SvelteKit</span>
      </div>
     </Card>
+    <Card href="/docs/getting-started/python">
+      <div className="flex flex-col items-center justify-center gap-2">
+        <Python className="size-16" />
+        <span className="font-medium">Python</span>
+        <Badge variant="secondary">Beta</Badge>
+      </div>
+    </Card>
     <Card className="opacity-50">
       <div className="flex flex-col items-center justify-center gap-2">
         <Nest className="size-16 dark:invert grayscale" />

package/docs/getting-started/meta.json

@@ -9,7 +9,8 @@
     "nitro",
     "nuxt",
     "sveltekit",
-    "vite"
+    "vite",
+    "python"
   ],
   "defaultOpen": true
 }