alchemy 2.0.0-beta.2 → 2.0.0-beta.3

package/src/Cloudflare/Workers/{DurableObject.ts → DurableObjectNamespace.ts}

@@ -119,6 +119,248 @@ export class DurableObjectNamespaceScope extends Context.Service<
   DurableObjectNamespace
 >()("Cloudflare.DurableObjectNamespace") {}
 
+/**
+ * A Cloudflare Durable Object namespace that manages globally unique, stateful
+ * instances with WebSocket hibernation support.
+ *
+ * A Durable Object uses a two-phase pattern with two nested `Effect.gen`
+ * blocks. The outer Effect resolves shared dependencies (other DOs,
+ * containers, etc.). The inner Effect runs once per instance and returns
+ * the object's public methods and WebSocket handlers.
+ *
+ * ```typescript
+ * Effect.gen(function* () {
+ *   // Phase 1: resolve shared dependencies
+ *   const db = yield* Cloudflare.D1Connection.bind(MyDB);
+ *
+ *   return Effect.gen(function* () {
+ *     // Phase 2: per-instance setup and public API
+ *     const state = yield* Cloudflare.DurableObjectState;
+ *
+ *     return {
+ *       save: (data: string) => db.exec("INSERT ..."),
+ *       fetch: Effect.gen(function* () { ... }),
+ *       webSocketMessage: Effect.fnUntraced(function* (ws, msg) { ... }),
+ *     };
+ *   });
+ * })
+ * ```
+ *
+ * There are two ways to define a Durable Object. See the
+ * {@link https://alchemy.run/concepts/platform | Platform concept} page
+ * for the full explanation.
+ *
+ * - **Inline** — Effect implementation passed directly, single file.
+ * - **Modular** — class and implementation in separate files for tree-shaking.
+ *
+ * @resource
+ *
+ * @section Inline Durable Objects
+ * Pass the Effect implementation as the second argument. This is the
+ * simplest approach — everything lives in one file. Convenient when
+ * the DO doesn't need to be referenced by other Workers or DOs that
+ * would pull in its runtime dependencies.
+ *
+ * @example Inline Durable Object
+ * ```typescript
+ * export default class Counter extends Cloudflare.DurableObjectNamespace<Counter>()(
+ *   "Counter",
+ *   Effect.gen(function* () {
+ *     // init: bind resources
+ *     const db = yield* Cloudflare.D1Connection.bind(MyDB);
+ *
+ *     return Effect.gen(function* () {
+ *       const state = yield* Cloudflare.DurableObjectState;
+ *       const count = (yield* state.storage.get<number>("count")) ?? 0;
+ *
+ *       return {
+ *         // runtime: use them
+ *         increment: () =>
+ *           Effect.gen(function* () {
+ *             const next = count + 1;
+ *             yield* state.storage.put("count", next);
+ *             return next;
+ *           }),
+ *         get: () => Effect.succeed(count),
+ *       };
+ *     });
+ *   }),
+ * ) {}
+ * ```
+ *
+ * @section Modular Durable Objects
+ * When a Worker and a DO reference each other, or multiple Workers
+ * bind the same DO, define the class separately from its `.make()`
+ * call. The class is a lightweight identifier; `.make()` provides
+ * the runtime implementation as an `export default`. Rolldown treats
+ * `.make()` as pure, so the bundler tree-shakes it and all its
+ * runtime dependencies out of any consumer's bundle.
+ *
+ * The class and `.make()` can live in the same file. This is the
+ * same pattern used by `Worker` and `Container`.
+ *
+ * @example Modular Durable Object (class + .make() in one file)
+ * ```typescript
+ * // src/Counter.ts
+ * export default class Counter extends Cloudflare.DurableObjectNamespace<Counter>()(
+ *   "Counter",
+ * ) {}
+ *
+ * export default Counter.make(
+ *   Effect.gen(function* () {
+ *     // init: bind resources
+ *     const db = yield* Cloudflare.D1Connection.bind(MyDB);
+ *
+ *     return Effect.gen(function* () {
+ *       const state = yield* Cloudflare.DurableObjectState;
+ *       const count = (yield* state.storage.get<number>("count")) ?? 0;
+ *
+ *       return {
+ *         // runtime: use them
+ *         increment: () =>
+ *           Effect.gen(function* () {
+ *             const next = count + 1;
+ *             yield* state.storage.put("count", next);
+ *             yield* db.prepare("INSERT INTO logs (count) VALUES (?)").bind(next).run();
+ *             return next;
+ *           }),
+ *         get: () => Effect.succeed(count),
+ *       };
+ *     });
+ *   }),
+ * );
+ * ```
+ *
+ * @example Binding a modular DO from a Worker
+ * ```typescript
+ * // imports Counter; bundler tree-shakes .make()
+ * import Counter from "./Counter.ts";
+ *
+ * // init
+ * const counters = yield* Counter;
+ *
+ * return {
+ *   fetch: Effect.gen(function* () {
+ *     const counter = counters.getByName("user-123");
+ *     return HttpServerResponse.text(String(yield* counter.get()));
+ *   }),
+ * };
+ * ```
+ *
+ * @section RPC Methods
+ * Any function you return from the inner Effect becomes an RPC method
+ * that Workers can call through a stub. Methods must return an `Effect`.
+ * The caller gets a fully typed stub — if your DO returns `increment`
+ * and `get`, the stub exposes `counter.increment()` and `counter.get()`.
+ *
+ * @example Defining RPC methods
+ * ```typescript
+ * return {
+ *   increment: () => Effect.succeed(++count),
+ *   get: () => Effect.succeed(count),
+ *   reset: () => Effect.sync(() => { count = 0; }),
+ * };
+ * ```
+ *
+ * @section Accessing Instance State
+ * Each Durable Object instance has its own transactional key-value
+ * storage via `Cloudflare.DurableObjectState`. Use `storage.get` and
+ * `storage.put` inside the inner Effect to persist data across requests
+ * and restarts.
+ *
+ * @example Reading and writing durable storage
+ * ```typescript
+ * const state = yield* Cloudflare.DurableObjectState;
+ *
+ * yield* state.storage.put("counter", 42);
+ * const value = yield* state.storage.get("counter");
+ * ```
+ *
+ * @section WebSocket Hibernation
+ * Durable Objects support WebSocket hibernation — the runtime can
+ * evict the object from memory while keeping connections open. Use
+ * `Cloudflare.upgrade()` to accept a connection, and return
+ * `webSocketMessage` / `webSocketClose` handlers to process events
+ * when the object wakes back up.
+ *
+ * @example Accepting a WebSocket connection
+ * ```typescript
+ * return {
+ *   fetch: Effect.gen(function* () {
+ *     const [response, socket] = yield* Cloudflare.upgrade();
+ *     socket.serializeAttachment({ id: crypto.randomUUID() });
+ *     return response;
+ *   }),
+ * };
+ * ```
+ *
+ * @example Handling messages and close events
+ * ```typescript
+ * return {
+ *   webSocketMessage: Effect.fnUntraced(function* (
+ *     socket: Cloudflare.DurableWebSocket,
+ *     message: string | Uint8Array,
+ *   ) {
+ *     const text = typeof message === "string"
+ *       ? message
+ *       : new TextDecoder().decode(message);
+ *     // process the message
+ *   }),
+ *   webSocketClose: Effect.fnUntraced(function* (
+ *     ws: Cloudflare.DurableWebSocket,
+ *     code: number,
+ *     reason: string,
+ *   ) {
+ *     yield* ws.close(code, reason);
+ *   }),
+ * };
+ * ```
+ *
+ * @example Recovering sessions after hibernation
+ * ```typescript
+ * const state = yield* Cloudflare.DurableObjectState;
+ * const sockets = yield* state.getWebSockets();
+ *
+ * for (const socket of sockets) {
+ *   const data = socket.deserializeAttachment<{ id: string }>();
+ *   // re-populate your session map
+ * }
+ * ```
+ *
+ * @section Using from a Worker
+ * Yield the DO class in your Worker's init phase to get a namespace
+ * handle. Call `getByName` or `getById` to get a typed stub, then
+ * call any RPC method or forward an HTTP request with `fetch`.
+ *
+ * @example Calling RPC methods
+ * ```typescript
+ * // init
+ * const counters = yield* Counter;
+ *
+ * return {
+ *   fetch: Effect.gen(function* () {
+ *     const counter = counters.getByName("user-123");
+ *     yield* counter.increment();
+ *     const value = yield* counter.get();
+ *     return HttpServerResponse.text(String(value));
+ *   }),
+ * };
+ * ```
+ *
+ * @example Forwarding an HTTP request
+ * ```typescript
+ * // init
+ * const rooms = yield* Room;
+ *
+ * return {
+ *   fetch: Effect.gen(function* () {
+ *     const request = yield* HttpServerRequest;
+ *     const room = rooms.getByName(roomId);
+ *     return yield* room.fetch(request);
+ *   }),
+ * };
+ * ```
+ */
 export const DurableObjectNamespace: DurableObjectNamespaceClass =
   taggedFunction(DurableObjectNamespaceScope, ((
     ...args:

package/src/Cloudflare/Workers/DynamicWorkerLoader.ts

@@ -70,16 +70,40 @@ export type DynamicWorkerLoader = {
 };
 
 /**
- * Declare a Dynamic Worker loader binding inside a Worker program.
+ * Load and run ephemeral Workers at runtime from inline JavaScript
+ * modules.
  *
- * At deploy time this registers a `worker_loader` binding on the parent
- * Worker. At runtime it exposes an Effect-wrapped interface for loading
- * and calling into dynamic workers.
+ * `DynamicWorkerLoader` registers a `worker_loader` binding on the
+ * parent Worker at deploy time. At runtime you call `.load()` with
+ * inline module source code and get back a fully typed Worker
+ * instance you can `fetch` or call RPC methods on. Each loaded
+ * Worker runs in its own isolate with full sandboxing.
  *
- * @example
+ * This is useful for evaluating user-provided code, running
+ * untrusted plugins, or dynamically generating Workers from
+ * templates.
+ *
+ * @resource
+ *
+ * @section Creating a Loader
+ * Yield `Cloudflare.DynamicWorkerLoader` in your Worker's init
+ * phase to register the binding. The string argument becomes the
+ * binding name on the deployed Worker.
+ *
+ * @example Registering a loader
  * ```typescript
- * const loader = yield* DynamicWorker("LOADER");
+ * // init
+ * const loader = yield* Cloudflare.DynamicWorkerLoader("Loader");
+ * ```
+ *
+ * @section Loading a Worker
+ * Call `loader.load()` with a compatibility date, a main module
+ * name, and a map of module names to source code strings. The
+ * returned instance exposes `.fetch()` for HTTP and RPC methods
+ * for named entrypoints.
  *
+ * @example Loading and calling a dynamic Worker
+ * ```typescript
  * const worker = loader.load({
  *   compatibilityDate: "2026-01-28",
  *   mainModule: "worker.js",
@@ -90,10 +114,45 @@ export type DynamicWorkerLoader = {
  *       }
  *     }`,
  *   },
+ * });
+ *
+ * const response = yield* worker.fetch(
+ *   HttpClientRequest.get("https://worker/"),
+ * );
+ * ```
+ *
+ * @section Sandboxing
+ * Set `globalOutbound` to `null` to block all outbound network
+ * access from the dynamic Worker, or pass an RPC stub to intercept
+ * and proxy outbound requests.
+ *
+ * @example Blocking outbound access
+ * ```typescript
+ * const worker = loader.load({
+ *   compatibilityDate: "2026-01-28",
+ *   mainModule: "worker.js",
+ *   modules: {
+ *     "worker.js": `export default {
+ *       async fetch(req) {
+ *         // fetch() calls from here will fail
+ *         return new Response("sandboxed");
+ *       }
+ *     }`,
+ *   },
  *   globalOutbound: null,
  * });
+ * ```
  *
- * const response = yield* worker.fetch(request);
+ * @section Named Entrypoints
+ * If the dynamic Worker exports named entrypoints, use
+ * `.getEntrypoint(name)` to get a typed stub for calling its
+ * methods.
+ *
+ * @example Calling a named entrypoint
+ * ```typescript
+ * const worker = loader.load({ ... });
+ * const api = worker.getEntrypoint<{ greet: (name: string) => Effect.Effect<string> }>("api");
+ * const greeting = yield* api.greet("world");
  * ```
  */
 export const DynamicWorkerLoader = Effect.fnUntraced(function* (name: string) {

package/src/Cloudflare/Workers/WebSocket.ts

@@ -2,7 +2,7 @@ import type * as cf from "@cloudflare/workers-types";
 import * as Effect from "effect/Effect";
 import * as HttpBody from "effect/unstable/http/HttpBody";
 import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
-import { DurableObjectState } from "./DurableObject.ts";
+import { DurableObjectState } from "./DurableObjectNamespace.ts";
 
 export type RawWebSocket = cf.WebSocket;
 

package/src/Cloudflare/Workers/Worker.ts

@@ -50,7 +50,7 @@ import type { R2Bucket } from "../R2/R2Bucket.ts";
 import type { AssetsConfig, AssetsProps } from "./Assets.ts";
 import * as Assets from "./Assets.ts";
 import cloudflare_workers from "./cloudflare_workers.ts";
-import { isDurableObjectExport } from "./DurableObject.ts";
+import { isDurableObjectExport } from "./DurableObjectNamespace.ts";
 import { workersHttpHandler } from "./HttpServer.ts";
 import { Request } from "./Request.ts";
 import { makeRpcStub } from "./Rpc.ts";
@@ -256,17 +256,322 @@ export type Worker<Bindings extends WorkerBindings = any> = Resource<
  * A Cloudflare Worker host with deploy-time binding support and runtime export
  * collection.
  *
- * `Worker` behaves like a resource during deploy, but it also carries a runtime
- * execution context so KV, R2, Durable Objects, assets, and service bindings
- * can be inferred from the worker program itself.
+ * A Worker follows a two-phase pattern. The outer `Effect.gen` runs at
+ * deploy time to bind resources (KV, R2, Durable Objects, etc.). It returns
+ * an object whose properties are the Worker's runtime handlers — `fetch` for
+ * HTTP requests and any additional RPC methods.
  *
- * @section Creating Workers
- * @example Basic Worker
  * ```typescript
- * const worker = yield* Worker("ApiWorker", {
+ * Effect.gen(function* () {
+ *   // Phase 1: bind resources (runs at deploy time)
+ *   const kv = yield* Cloudflare.KVNamespace.bind(MyKV);
+ *
+ *   return {
+ *     // Phase 2: runtime handlers (runs on each request)
+ *     fetch: Effect.gen(function* () {
+ *       const value = yield* kv.get("key");
+ *       return HttpServerResponse.text(value ?? "not found");
+ *     }),
+ *   };
+ * })
+ * ```
+ *
+ * There are three ways to define a Worker, from simplest to most
+ * flexible. See the {@link https://alchemy.run/concepts/platform | Platform concept}
+ * page for the full explanation.
+ *
+ * - **Async** — plain `async fetch` handler, no Effect runtime in the bundle.
+ * - **Effect** — Effect implementation passed directly, single file.
+ * - **Layer** — class and `.make()` in a single file; Rolldown tree-shakes `.make()` from consumers.
+ *
+ * @section Async Workers
+ * You don't have to use Effect for your runtime code. If you create
+ * a Worker resource with `main` pointing at a file but provide no
+ * `Effect.gen` implementation, Alchemy bundles and deploys that file
+ * as-is. Your handler is a plain `async fetch` — no Effect runtime
+ * is included in the bundle.
+ *
+ * Use the `bindings` prop to declare which resources are available
+ * at runtime, and `Cloudflare.InferEnv` to extract a fully typed
+ * `env` object from those bindings.
+ *
+ * @example Defining an async Worker in your stack
+ * ```typescript
+ * // alchemy.run.ts
+ * const db = yield* Cloudflare.D1Database("DB");
+ * const bucket = yield* Cloudflare.R2Bucket("Bucket");
+ *
+ * export type WorkerEnv = Cloudflare.InferEnv<typeof Worker>;
+ *
+ * export const Worker = Cloudflare.Worker("Worker", {
  *   main: "./src/worker.ts",
+ *   bindings: { db, bucket },
+ * });
+ * ```
+ *
+ * @example Writing the async handler
+ * ```typescript
+ * // src/worker.ts
+ * import type { WorkerEnv } from "../alchemy.run.ts";
+ *
+ * export default {
+ *   async fetch(request: Request, env: WorkerEnv) {
+ *     if (request.method === "GET") {
+ *       const object = await env.bucket.get("key");
+ *       return new Response(object?.body ?? null);
+ *     }
+ *     return new Response("Not Found", { status: 404 });
+ *   },
+ * };
+ * ```
+ *
+ * @section Effect Workers
+ * Pass the Effect implementation as the third argument. This is the
+ * simplest Effect-based approach — everything lives in one file.
+ * Convenient for standalone Workers that don't need to be referenced
+ * by other Workers.
+ *
+ * @example Worker Effect
+ * ```typescript
+ * export default class MyWorker extends Cloudflare.Worker<MyWorker>()(
+ *   "MyWorker",
+ *   { main: import.meta.path },
+ *   Effect.gen(function* () {
+ *     // init: bind resources
+ *     const kv = yield* Cloudflare.KVNamespace.bind(MyKV);
+ *
+ *     return {
+ *       // runtime: use them
+ *       fetch: Effect.gen(function* () {
+ *         const value = yield* kv.get("key");
+ *         return HttpServerResponse.text(value ?? "not found");
+ *       }),
+ *     };
+ *   }),
+ * ) {}
+ * ```
+ *
+ * @section Worker Layer
+ * When two Workers need to reference each other (e.g. WorkerA calls
+ * WorkerB and vice versa), or you simply want optimal tree-shaking,
+ * define the Worker class separately from its `.make()` call. The
+ * class is a lightweight identifier; `.make()` provides the runtime
+ * implementation as an `export default`. Rolldown treats `.make()`
+ * as pure, so any Worker that imports the class to bind it will not
+ * pull in the `.make()` dependencies — the bundler tree-shakes
+ * them away entirely.
+ *
+ * The class and `.make()` can live in the same file. This is the
+ * same pattern used by `Container` and `DurableObjectNamespace`,
+ * and is recommended for any cross-Worker or cross-DO bindings.
+ *
+ * @example Worker Layer (class + .make() in one file)
+ * ```typescript
+ * // src/WorkerB.ts
+ * export default class WorkerB extends Cloudflare.Worker<WorkerB>()(
+ *   "WorkerB",
+ *   { main: import.meta.path },
+ * ) {}
+ *
+ * export default WorkerB.make(
+ *   Effect.gen(function* () {
+ *     // init: bind resources
+ *     const kv = yield* Cloudflare.KVNamespace.bind(MyKV);
+ *
+ *     return {
+ *       // runtime: use them
+ *       greet: (name: string) =>
+ *         Effect.gen(function* () {
+ *           yield* kv.put("last-greeted", name);
+ *           return `Hello ${name}`;
+ *         }),
+ *     };
+ *   }),
+ * );
+ * ```
+ *
+ * @example Binding a Worker Layer from another Worker
+ * ```typescript
+ * // src/WorkerA.ts — imports WorkerB; bundler tree-shakes .make()
+ * import WorkerB from "./WorkerB.ts";
+ *
+ * export default class WorkerA extends Cloudflare.Worker<WorkerA>()(
+ *   "WorkerA",
+ *   { main: import.meta.path },
+ *   Effect.gen(function* () {
+ *     const b = yield* Cloudflare.Worker.bind(WorkerB);
+ *     return {
+ *       fetch: Effect.gen(function* () {
+ *         return yield* b.greet("world");
+ *       }),
+ *     };
+ *   }),
+ * ) {}
+ * ```
+ *
+ * @section Configuration
+ * The props object controls compatibility flags, static assets, and
+ * build options. These are evaluated at deploy time.
+ *
+ * @example Enabling Node.js compatibility
+ * ```typescript
+ * {
+ *   main: import.meta.path,
+ *   compatibility: {
+ *     flags: ["nodejs_compat"],
+ *     date: "2026-03-17",
+ *   },
+ * }
+ * ```
+ *
+ * @example Serving static assets
+ * ```typescript
+ * {
+ *   main: import.meta.path,
+ *   assets: "./public",
+ * }
+ * ```
+ *
+ * @section R2 Bucket
+ * Bind an R2 bucket in the init phase with `Cloudflare.R2Bucket.bind`.
+ * The returned handle exposes `get`, `put`, `delete`, and `list`
+ * methods you can call in your runtime handlers.
+ *
+ * @example Binding and using R2
+ * ```typescript
+ * // init
+ * const bucket = yield* Cloudflare.R2Bucket.bind(MyBucket);
+ *
+ * return {
+ *   fetch: Effect.gen(function* () {
+ *     const request = yield* HttpServerRequest;
+ *     const key = request.url.split("/").pop()!;
+ *
+ *     if (request.method === "GET") {
+ *       const object = yield* bucket.get(key);
+ *       return object
+ *         ? HttpServerResponse.text(yield* object.text())
+ *         : HttpServerResponse.empty({ status: 404 });
+ *     }
+ *
+ *     yield* bucket.put(key, request.stream);
+ *     return HttpServerResponse.empty({ status: 201 });
+ *   }),
+ * };
+ * ```
+ *
+ * @section KV Namespace
+ * Bind a KV namespace with `Cloudflare.KVNamespace.bind`. KV provides
+ * eventually-consistent, low-latency key-value reads replicated
+ * globally across Cloudflare's edge.
+ *
+ * @example Binding and using KV
+ * ```typescript
+ * // init
+ * const kv = yield* Cloudflare.KVNamespace.bind(MyKV);
+ *
+ * return {
+ *   fetch: Effect.gen(function* () {
+ *     const value = yield* kv.get("my-key");
+ *     return HttpServerResponse.text(value ?? "not found");
+ *   }),
+ * };
+ * ```
+ *
+ * @section D1 Database
+ * Bind a D1 database with `Cloudflare.D1Connection.bind`. D1 is a
+ * serverless SQLite database — use `prepare` to build parameterized
+ * queries and `all`, `first`, or `run` to execute them.
+ *
+ * @example Binding and querying D1
+ * ```typescript
+ * // init
+ * const db = yield* Cloudflare.D1Connection.bind(MyDB);
+ *
+ * return {
+ *   fetch: Effect.gen(function* () {
+ *     const results = yield* db
+ *       .prepare("SELECT * FROM users WHERE id = ?")
+ *       .bind(userId)
+ *       .all();
+ *     return yield* HttpServerResponse.json(results);
+ *   }),
+ * };
+ * ```
+ *
+ * @section Durable Objects
+ * Yield a `DurableObjectNamespace` class in the init phase to get a
+ * namespace handle. Call `getByName` or `getById` to get a typed RPC
+ * stub, then call its methods from your runtime handlers.
+ *
+ * @example Using a Durable Object
+ * ```typescript
+ * // init
+ * const counters = yield* Counter;
+ *
+ * return {
+ *   fetch: Effect.gen(function* () {
+ *     const counter = counters.getByName("user-123");
+ *     const value = yield* counter.increment();
+ *     return HttpServerResponse.text(String(value));
+ *   }),
+ * };
+ * ```
+ *
+ * @section Containers
+ * Containers run long-lived processes alongside Durable Objects. Bind
+ * one with `Cloudflare.Container.bind` and start it with
+ * `Cloudflare.start`. You can call typed methods on the running
+ * container or make HTTP requests to its exposed ports.
+ *
+ * @example Binding and starting a Container
+ * ```typescript
+ * // init (inside a DurableObjectNamespace)
+ * const sandbox = yield* Cloudflare.Container.bind(Sandbox);
+ *
+ * return Effect.gen(function* () {
+ *   const container = yield* Cloudflare.start(sandbox);
+ *
+ *   return {
+ *     exec: (cmd: string) => container.exec(cmd),
+ *     fetch: Effect.gen(function* () {
+ *       const { fetch } = yield* container.getTcpPort(3000);
+ *       const res = yield* fetch(HttpClientRequest.get("http://container/"));
+ *       return HttpServerResponse.fromClientResponse(res);
+ *     }),
+ *   };
  * });
  * ```
+ *
+ * @section Dynamic Workers
+ * `DynamicWorkerLoader` lets you spin up ephemeral Workers at runtime
+ * from inline JavaScript modules. This is useful for sandboxing
+ * user-provided code or running untrusted scripts in isolation.
+ *
+ * @example Loading a dynamic Worker
+ * ```typescript
+ * // init
+ * const loader = yield* Cloudflare.DynamicWorkerLoader("Loader");
+ *
+ * return {
+ *   fetch: Effect.gen(function* () {
+ *     const worker = loader.load({
+ *       compatibilityDate: "2026-01-28",
+ *       mainModule: "worker.js",
+ *       modules: {
+ *         "worker.js": `export default {
+ *           async fetch(req) { return new Response("sandboxed"); }
+ *         }`,
+ *       },
+ *     });
+ *
+ *     const res = yield* worker.fetch(
+ *       HttpClientRequest.get("https://worker/"),
+ *     );
+ *     return HttpServerResponse.fromClientResponse(res);
+ *   }),
+ * };
+ * ```
  */
 export const Worker: Platform<
   Worker,