Update docs to use ow.runWorkflow (#286)

Author: jamescmartinez

packages/docs/docs/advanced-patterns.mdx

@@ -111,7 +111,7 @@ TypeScript will catch type errors at compile time, preventing runtime issues.
 Wait for a workflow to complete and get its result:
 
 ```ts
-const run = await myWorkflow.run({ data: "..." });
+const run = await ow.runWorkflow(myWorkflow.spec, { data: "..." });
 
 // Wait for the workflow to finish (polls the database)
 const result = await run.result();
@@ -129,7 +129,7 @@ Cancel a workflow that is pending, running, or sleeping to prevent it from
 continuing:
 
 ```ts
-const handle = await myWorkflow.run({ data: "..." });
+const handle = await ow.runWorkflow(myWorkflow.spec, { data: "..." });
 
 // Cancel the workflow
 await handle.cancel();
@@ -191,7 +191,7 @@ const summarizeDoc = defineWorkflow(
 );
 
 // Throws before enqueueing the workflow because the input isn't a URL
-await summarizeDoc.run({ docUrl: "not-a-url" });
+await ow.runWorkflow(summarizeDoc.spec, { docUrl: "not-a-url" });
 ```
 
 Any validator function works as long as it throws on invalid data. This supports

packages/docs/docs/canceling.mdx

@@ -10,6 +10,7 @@ You can cancel workflow runs that are pending, running, or sleeping.
 Use the `cancel()` method on a workflow run handle:
 
 ```ts
+import { ow } from "./openworkflow/client";
 import { defineWorkflow } from "openworkflow";
 
 const longRunning = defineWorkflow(
@@ -21,7 +22,7 @@ const longRunning = defineWorkflow(
 );
 
 // Start the workflow
-const handle = await longRunning.run();
+const handle = await ow.runWorkflow(longRunning.spec);
 
 // Cancel it before it completes
 await handle.cancel();
@@ -67,7 +68,7 @@ no new steps will run on the next poll.
 After calling `cancel()`, you can verify the status:
 
 ```ts
-const handle = await workflow.run();
+const handle = await ow.runWorkflow(workflow.spec);
 await handle.cancel();
 
 // Waiting for result on a canceled workflow throws

packages/docs/docs/overview.mdx

@@ -21,7 +21,8 @@ Your application enqueues workflow runs. Workers pick them up. The backend
 
 When a run starts:
 
-1. Your app calls `workflow.run()`, creating a `pending` run in the database
+1. Your app enqueues a run (for example, with `ow.runWorkflow(workflow.spec,
+input)`), creating a `pending` run in the database
 2. A worker claims the run and marks it `running`
 3. The worker replays workflow code from the beginning
 4. Completed steps return cached outputs; new steps execute and persist results

packages/docs/docs/quickstart.mdx

@@ -74,14 +74,14 @@ bun openworkflow/hello-world.run.ts
 
 </CodeGroup>
 
-This script calls `workflow.run()` to create a new workflow run in the database.
-The worker in your first terminal picks it up, executes each step, and marks it
-complete.
+This script calls `ow.runWorkflow(helloWorld.spec, {})` to create a new workflow
+run in the database. The worker in your first terminal picks it up, executes
+each step, and marks it complete.
 
 <Note>
   The `hello-world.run.ts` file is a temporary helper for testing. In a real
-  app, you'd call `workflow.run()` from your API routes, scripts, or other
-  application code.
+  app, you'd call `ow.runWorkflow(workflow.spec, input)` from your API routes,
+  scripts, or other application code.
 </Note>
 
 ## 4. View workflows in the dashboard

packages/docs/docs/standard-schema.mdx

@@ -15,9 +15,10 @@ is even enqueued — preventing invalid data from entering your system.
 When you define a workflow, you can provide a `schema`. OpenWorkflow uses this
 schema to:
 
-1. **Validate inputs at runtime**: When `workflow.run()` is called, the input is
-   validated immediately. If validation fails, an error is thrown before the
-   workflow is enqueued, preventing invalid data from entering your system.
+1. **Validate inputs at runtime**: When you start a run (for example, with
+   `ow.runWorkflow(workflow.spec, input)`), the input is validated immediately.
+   If validation fails, an error is thrown before the workflow is enqueued,
+   preventing invalid data from entering your system.
 2. **Type Safety**: The `input` parameter in your workflow function is
    automatically typed based on your schema.
 
@@ -141,10 +142,11 @@ When validation fails, OpenWorkflow throws a detailed error that includes
 information about what went wrong:
 
 ```ts
+import { ow } from "./openworkflow/client";
 import { sendEmail } from "./workflows/send-email";
 
 try {
-  await sendEmail.run({
+  await ow.runWorkflow(sendEmail.spec, {
     to: "invalid-email", // Invalid email format
     subject: "", // Too short
     body: "Hello",

packages/docs/docs/type-safety.mdx

@@ -115,7 +115,7 @@ ow.implementWorkflow(emailSpec, async ({ input, step }) => {
 When you run a workflow, the handle is typed with the output:
 
 ```ts
-const handle = await processOrder.run({
+const handle = await ow.runWorkflow(processOrder.spec, {
   orderId: "123",
   customerId: "456",
 });

packages/docs/docs/workflows.mdx

@@ -43,25 +43,34 @@ A workflow consists of:
 
 ## Running a Workflow
 
-Start a workflow by calling `.run()`:
+Start a workflow by calling `ow.runWorkflow()` with the workflow's `spec`:
 
 ```ts
+import { ow } from "./openworkflow/client";
 import { sendWelcomeEmail } from "./workflows/send-welcome-email";
 
-const handle = await sendWelcomeEmail.run({ userId: "user_123" });
+const handle = await ow.runWorkflow(sendWelcomeEmail.spec, {
+  userId: "user_123",
+});
 ```
 
-The `run()` method returns a handle immediately. The actual workflow execution
+`ow.runWorkflow()` returns a handle immediately. The actual workflow execution
 happens in a worker process. This lets your application continue without waiting
 for the workflow to complete.
 
+<Note>
+  If you define a workflow with `ow.defineWorkflow(...)` instead, it returns a
+  runnable workflow that supports `.run(...)` directly.
+</Note>
+
 ### Scheduling a Workflow Run
 
 You can schedule a workflow run for a specific time by passing `availableAt`:
 
 ```ts
 const runAt = new Date("2026-02-05T15:00:00.000Z");
-const handle = await sendWelcomeEmail.run(
+const handle = await ow.runWorkflow(
+  sendWelcomeEmail.spec,
   { userId: "user_123" },
   { availableAt: runAt },
 );
@@ -71,7 +80,8 @@ You can also pass a duration string using the same [duration
 format](/docs/sleeping#duration-formats) as `step.sleep`:
 
 ```ts
-const handle = await sendWelcomeEmail.run(
+const handle = await ow.runWorkflow(
+  sendWelcomeEmail.spec,
   { userId: "user_123" },
   { availableAt: "5m" },
 );
@@ -85,7 +95,9 @@ it. If `availableAt` is in the past, the run is immediately available.
 If you need to wait for a workflow to complete, use `.result()` on the handle:
 
 ```ts
-const handle = await sendWelcomeEmail.run({ userId: "user_123" });
+const handle = await ow.runWorkflow(sendWelcomeEmail.spec, {
+  userId: "user_123",
+});
 
 // Wait for completion (polls the database)
 const result = await handle.result();
@@ -183,7 +195,7 @@ The workflow function receives an object with three properties:
 
 | Parameter | Type             | Description                                       |
 | --------- | ---------------- | ------------------------------------------------- |
-| `input`   | Generic          | The input data passed to `workflow.run()`         |
+| `input`   | Generic          | The input data passed when starting the workflow  |
 | `step`    | `StepApi`        | API for defining steps (`step.run`, `step.sleep`) |
 | `version` | `string \| null` | The workflow version, if specified                |