[Workflows] Add dynamic workflows example docs

Author: mia303

src/assets/images/workflows/dynamic-workflows.png

@@ -0,0 +1,8 @@
+---
+title: Dynamic Workers and Workflows
+description: Route Workflow runs into dynamically loaded Worker code while keeping durable Workflow steps and state.
+pcx_content_type: example
+external_link: /workflows/examples/dynamic-workflows/
+sidebar:
+  order: 5
+---

src/content/docs/dynamic-workers/examples/dynamic-workers-and-workflows.mdx

@@ -0,0 +1,190 @@
+---
+title: Dynamic Workflows
+description: Create and run Workflow logic dynamically while keeping Workflow steps durable.
+pcx_content_type: example
+sidebar:
+  order: 3
+---
+
+import { TypeScriptExample, WranglerConfig } from "~/components";
+
+Use this pattern when your workflow logic is not known at deploy time, but you still need Workflow durability. In this example, we implement a simple Dynamic Workflow which allows you to run arbitrary workflow code at runtime.
+
+## Understand the model
+
+This setup has three parts:
+
+- **Loader Worker**: the front door. It receives HTTP requests, knows how to load Dynamic Worker code, and can create Workflow instances.
+- **Workflow class**: the durable orchestrator. It persists state, survives restarts, and executes steps, including steps that pause for days while waiting for human input.
+- **Dynamic Worker**: the user-authored code that defines what the workflow actually does. It is loaded on-demand by script ID.
+
+![Dynamic Workers and Workflows architecture diagram](~/assets/images/workflows/dynamic-workflows.png)
+
+## Configure your Worker
+
+Your Worker needs a Worker Loader binding and a Workflow binding. The Worker Loader creates Dynamic Workers at runtime, and the Workflow binding points to the durable Workflow class that runs them.
+
+- A Worker Loader binding
+- A Workflow binding that points to the Workflow class
+
+<WranglerConfig>
+
+```toml
+name = "dynamic-workflow-loader"
+main = "src/index.ts"
+compatibility_date = "$today"
+
+[[worker_loaders]]
+binding = "LOADER"
+
+[[workflows]]
+name = "dynamic-workflow"
+binding = "WORKFLOW"
+class_name = "DynamicWorkflow"
+```
+
+</WranglerConfig>
+
+## Create your Worker entrypoint
+
+Your Worker entrypoint accepts a script, creates a Workflow instance with that script in `params`, and returns the new instance ID. The same entrypoint can also look up the status of an existing Workflow instance.
+
+<TypeScriptExample>
+
+```ts
+export { DynamicWorkflow } from "./workflow";
+
+export default {
+	async fetch(request: Request, env: Env): Promise<Response> {
+		const url = new URL(request.url);
+
+		if (url.pathname === "/api/run" && request.method === "POST") {
+			try {
+				const { script } = (await request.json()) as { script: string };
+
+				if (!script || typeof script !== "string") {
+					return Response.json(
+						{ error: "script is required" },
+						{ status: 400 },
+					);
+				}
+
+				const instance = await env.WORKFLOW.create({
+					params: { script },
+				});
+
+				return Response.json({
+					instanceId: instance.id,
+					status: await instance.status(),
+				});
+			} catch (error) {
+				return Response.json(
+					{ error: error instanceof Error ? error.message : String(error) },
+					{ status: 500 },
+				);
+			}
+		}
+
+		if (url.pathname === "/api/status") {
+			const instanceId = url.searchParams.get("instanceId");
+			if (!instanceId) {
+				return Response.json(
+					{ error: "instanceId query param is required" },
+					{ status: 400 },
+				);
+			}
+
+			try {
+				const instance = await env.WORKFLOW.get(instanceId);
+				return Response.json(await instance.status());
+			} catch (error) {
+				return Response.json(
+					{ error: error instanceof Error ? error.message : String(error) },
+					{ status: 500 },
+				);
+			}
+		}
+
+		return new Response("Not Found", { status: 404 });
+	},
+} satisfies ExportedHandler<Env>;
+```
+
+</TypeScriptExample>
+
+## Define the Workflow class
+
+You still deploy one normal Workflow class. Its job is to load the dynamic code for the current run and call it with the `WorkflowStep` object. This is what keeps the [Workflows API](/workflows/build/workers-api/), including `step.do()`, `step.sleep()`, and `step.waitForEvent()`, working as normal.
+
+Use `env.LOADER.get()` via the [Worker Loader API](/dynamic-workers/api-reference/#get) to load the Dynamic Worker for the current Workflow instance. If the loader already has a warm isolate for the same ID, it can reuse it. Otherwise, it calls the callback to create the Worker from the script in the workflow payload.
+
+<TypeScriptExample>
+
+```ts
+import {
+	WorkflowEntrypoint,
+	type WorkflowEvent,
+	type WorkflowStep,
+} from "cloudflare:workers";
+
+type Params = {
+	script: string;
+};
+
+export class DynamicWorkflow extends WorkflowEntrypoint<Env, Params> {
+	async run(event: WorkflowEvent<Params>, step: WorkflowStep) {
+		const { script } = event.payload;
+
+		const worker = this.env.LOADER.get(
+			`dyn-wf-${event.instanceId}`,
+			async () => ({
+				mainModule: "index.js",
+				modules: { "index.js": script },
+				compatibilityDate: "2026-04-21",
+				compatibilityFlags: ["nodejs_compat"],
+			}),
+		);
+
+		const entrypoint = worker.getEntrypoint() as unknown as {
+			run(event: Record<string, unknown>, step: WorkflowStep): Promise<unknown>;
+		};
+
+		return await entrypoint.run({}, step);
+	}
+}
+```
+
+</TypeScriptExample>
+
+In this example, `event.payload.script` contains the workflow logic to run. The Workflow class loads that code as a Dynamic Worker, gets its entrypoint, and calls `run({}, step)` so the dynamic code can use the same durable step methods as any other Workflow.
+
+## Trigger a dynamic workflow
+
+Send a `POST` request to `/api/run` with the workflow code in the `script` field. The response includes an `instanceId` that you can use to check status later.
+
+```bash
+curl -X POST http://localhost:8787/api/run \
+  -H 'Content-Type: application/json' \
+  --data-binary @- <<'EOF'
+{
+  "script": "import { WorkerEntrypoint } from 'cloudflare:workers';\n\nexport default class extends WorkerEntrypoint {\n  async run(event, step) {\n    const result = await step.do('hello', async () => {\n      return { message: 'Hello from API' };\n    });\n\n    return result;\n  }\n}"
+}
+EOF
+```
+
+## Check workflow status
+
+Use the `instanceId` returned from `/api/run` to retrieve the current Workflow status.
+
+```bash
+curl "http://localhost:8787/api/status?instanceId=YOUR_INSTANCE_ID"
+```
+
+## Related resources
+
+- [Workers API](/workflows/build/workers-api/)
+- [Trigger Workflows](/workflows/build/trigger-workflows/)
+- [Events and parameters](/workflows/build/events-and-parameters/)
+- [Dynamic Workers getting started](/dynamic-workers/getting-started/)
+- [Dynamic Worker Loaders](/workers/runtime-apis/bindings/worker-loader/)
+- [Bindings with Dynamic Workers](/dynamic-workers/usage/bindings/)