alchemy 2.0.0-beta.47 → 2.0.0-beta.49

package/src/Cloudflare/Tunnel/TunnelRead.ts

@@ -0,0 +1,168 @@
+import type {
+  GetTunnelCloudflaredConfigurationError,
+  GetTunnelCloudflaredConfigurationResponse,
+  GetTunnelCloudflaredError,
+  GetTunnelCloudflaredResponse,
+  GetTunnelCloudflaredTokenError,
+  GetTunnelCloudflaredTokenResponse,
+  ListTunnelCloudflaredsError,
+  ListTunnelCloudflaredsRequest,
+  ListTunnelCloudflaredsResponse,
+} from "@distilled.cloud/cloudflare/zero-trust";
+import * as zeroTrust from "@distilled.cloud/cloudflare/zero-trust";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import type { RuntimeContext } from "../../RuntimeContext.ts";
+import type { AccountApiToken } from "../ApiToken/AccountApiToken.ts";
+import type { Worker } from "../Workers/Worker.ts";
+import {
+  authorizeWith,
+  makeTunnelClient,
+  makeTunnelPolicyLive,
+  type TunnelToken,
+} from "./TunnelBinding.ts";
+
+/** List-tunnels request, minus the account id (supplied by the binding). */
+export type ListTunnelsRequest = Omit<
+  ListTunnelCloudflaredsRequest,
+  "accountId"
+>;
+
+/**
+ * Read-only tunnel operations. Backed by the `Cloudflare Tunnel Read`
+ * permission group.
+ */
+export interface TunnelReadClient {
+  /** Fetch a single tunnel by id. */
+  get(
+    tunnelId: string,
+  ): Effect.Effect<
+    GetTunnelCloudflaredResponse,
+    GetTunnelCloudflaredError,
+    RuntimeContext
+  >;
+  /** List tunnels in the account. */
+  list(
+    request?: ListTunnelsRequest,
+  ): Effect.Effect<
+    ListTunnelCloudflaredsResponse,
+    ListTunnelCloudflaredsError,
+    RuntimeContext
+  >;
+  /** Fetch the connector token used to run the tunnel. */
+  getToken(
+    tunnelId: string,
+  ): Effect.Effect<
+    GetTunnelCloudflaredTokenResponse,
+    GetTunnelCloudflaredTokenError,
+    RuntimeContext
+  >;
+  /** Read the remotely-managed configuration (ingress rules) for a tunnel. */
+  getConfiguration(
+    tunnelId: string,
+  ): Effect.Effect<
+    GetTunnelCloudflaredConfigurationResponse,
+    GetTunnelCloudflaredConfigurationError,
+    RuntimeContext
+  >;
+}
+
+/** Build the read-only client over a bound token. */
+export const readClient = (token: TunnelToken): TunnelReadClient => {
+  const authorize = authorizeWith(token);
+  return {
+    get: Effect.fn("Cloudflare.Tunnel.get")(function* (tunnelId) {
+      const accountId = yield* token.accountId;
+      return yield* authorize(
+        zeroTrust.getTunnelCloudflared({ accountId, tunnelId }),
+      );
+    }),
+    list: Effect.fn("Cloudflare.Tunnel.list")(function* (request) {
+      const accountId = yield* token.accountId;
+      return yield* authorize(
+        zeroTrust.listTunnelCloudflareds({ accountId, ...request }),
+      );
+    }),
+    getToken: Effect.fn("Cloudflare.Tunnel.getToken")(function* (tunnelId) {
+      const accountId = yield* token.accountId;
+      return yield* authorize(
+        zeroTrust.getTunnelCloudflaredToken({ accountId, tunnelId }),
+      );
+    }),
+    getConfiguration: Effect.fn("Cloudflare.Tunnel.getConfiguration")(
+      function* (tunnelId) {
+        const accountId = yield* token.accountId;
+        return yield* authorize(
+          zeroTrust.getTunnelCloudflaredConfiguration({ accountId, tunnelId }),
+        );
+      },
+    ),
+  };
+};
+
+/**
+ * Binding that lets a Worker read Cloudflare Tunnels at runtime.
+ *
+ * Creates a scoped {@link AccountApiToken} with only the `Cloudflare Tunnel
+ * Read` permission and binds its outputs into the Worker (the token value as a
+ * `secret_text` binding) so runtime code can authenticate.
+ *
+ * @binding
+ *
+ * @section Reading tunnels at runtime
+ * @example Bind the read client
+ * Bind once in the Init phase; every method is available on the returned client.
+ * ```typescript
+ * const tunnels = yield* Cloudflare.TunnelRead.bind();
+ * ```
+ *
+ * @example List tunnels
+ * ```typescript
+ * const { result } = yield* tunnels.list({ isDeleted: false });
+ * ```
+ *
+ * @example Fetch a tunnel and its connector token
+ * `getToken` returns the plaintext token used to run `cloudflared`.
+ * ```typescript
+ * const tunnel = yield* tunnels.get(tunnelId);
+ * const token = yield* tunnels.getToken(tunnelId);
+ * ```
+ *
+ * @example Read the ingress configuration
+ * ```typescript
+ * const { config } = yield* tunnels.getConfiguration(tunnelId);
+ * ```
+ *
+ * @section Runtime Layer
+ * Provide {@link TunnelReadLive} in the Worker's runtime layer.
+ * ```typescript
+ * Effect.provide(Cloudflare.TunnelReadLive)
+ * ```
+ */
+export class TunnelRead extends Binding.Service<
+  TunnelRead,
+  () => Effect.Effect<TunnelReadClient, never, Worker>
+>()("Cloudflare.TunnelRead") {}
+
+/**
+ * Deploy-time policy for {@link TunnelRead}. Attaches the `Cloudflare Tunnel
+ * Read` permission to the token via its binding contract.
+ */
+export class TunnelReadPolicy extends Binding.Policy<
+  TunnelReadPolicy,
+  (token: AccountApiToken) => Effect.Effect<void>
+>()("Cloudflare.TunnelRead") {}
+
+/** Runtime layer for {@link TunnelRead}. */
+export const TunnelReadLive = Layer.effect(
+  TunnelRead,
+  makeTunnelClient(TunnelReadPolicy, readClient),
+);
+
+/** Live deploy-time policy layer for {@link TunnelReadPolicy}. */
+export const TunnelReadPolicyLive = makeTunnelPolicyLive(
+  TunnelReadPolicy,
+  "Cloudflare.TunnelRead",
+  ["Cloudflare Tunnel Read"],
+);

package/src/Cloudflare/Tunnel/TunnelReadWrite.ts

@@ -0,0 +1,88 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import type { AccountApiToken } from "../ApiToken/AccountApiToken.ts";
+import type { Worker } from "../Workers/Worker.ts";
+import {
+  makeTunnelClient,
+  makeTunnelPolicyLive,
+  type TunnelToken,
+} from "./TunnelBinding.ts";
+import { readClient, type TunnelReadClient } from "./TunnelRead.ts";
+import { writeClient, type TunnelWriteClient } from "./TunnelWrite.ts";
+
+/** Combined read + write tunnel operations. */
+export interface TunnelReadWriteClient
+  extends TunnelReadClient, TunnelWriteClient {}
+
+/** Build the combined read + write client over a bound token. */
+export const readWriteClient = (token: TunnelToken): TunnelReadWriteClient => ({
+  ...readClient(token),
+  ...writeClient(token),
+});
+
+/**
+ * Binding that lets a Worker perform the full Cloudflare Tunnel CRUD surface at
+ * runtime.
+ *
+ * Creates a scoped {@link AccountApiToken} with both the `Cloudflare Tunnel
+ * Read` and `Cloudflare Tunnel Write` permissions and binds its outputs into
+ * the Worker (the token value as a `secret_text` binding) so runtime code can
+ * authenticate.
+ *
+ * @binding
+ *
+ * @section Managing tunnels at runtime
+ * @example Create, configure, and delete a tunnel from a request handler
+ * ```typescript
+ * // init
+ * const tunnels = yield* Cloudflare.TunnelReadWrite.bind();
+ *
+ * return {
+ *   fetch: Effect.gen(function* () {
+ *     const tunnel = yield* tunnels.create({ name: "on-demand-tunnel" });
+ *     yield* tunnels.putConfiguration(tunnel.id!, {
+ *       ingress: [
+ *         { hostname: "app.example.com", service: "http://localhost:3000" },
+ *         { service: "http_status:404" },
+ *       ],
+ *     });
+ *     const token = yield* tunnels.getToken(tunnel.id!);
+ *     return HttpServerResponse.json({ id: tunnel.id, token });
+ *   }),
+ * };
+ * ```
+ *
+ * @section Runtime Layer
+ * Provide {@link TunnelReadWriteLive} in the Worker's runtime layer.
+ * ```typescript
+ * Effect.provide(Cloudflare.TunnelReadWriteLive)
+ * ```
+ */
+export class TunnelReadWrite extends Binding.Service<
+  TunnelReadWrite,
+  () => Effect.Effect<TunnelReadWriteClient, never, Worker>
+>()("Cloudflare.TunnelReadWrite") {}
+
+/**
+ * Deploy-time policy for {@link TunnelReadWrite}. Attaches both the `Cloudflare
+ * Tunnel Read` and `Cloudflare Tunnel Write` permissions to the token via its
+ * binding contract.
+ */
+export class TunnelReadWritePolicy extends Binding.Policy<
+  TunnelReadWritePolicy,
+  (token: AccountApiToken) => Effect.Effect<void>
+>()("Cloudflare.TunnelReadWrite") {}
+
+/** Runtime layer for {@link TunnelReadWrite}. */
+export const TunnelReadWriteLive = Layer.effect(
+  TunnelReadWrite,
+  makeTunnelClient(TunnelReadWritePolicy, readWriteClient),
+);
+
+/** Live deploy-time policy layer for {@link TunnelReadWritePolicy}. */
+export const TunnelReadWritePolicyLive = makeTunnelPolicyLive(
+  TunnelReadWritePolicy,
+  "Cloudflare.TunnelReadWrite",
+  ["Cloudflare Tunnel Read", "Cloudflare Tunnel Write"],
+);

package/src/Cloudflare/Tunnel/TunnelWrite.ts

@@ -0,0 +1,194 @@
+import type {
+  CreateTunnelCloudflaredError,
+  CreateTunnelCloudflaredRequest,
+  CreateTunnelCloudflaredResponse,
+  DeleteTunnelCloudflaredError,
+  DeleteTunnelCloudflaredResponse,
+  PatchTunnelCloudflaredError,
+  PatchTunnelCloudflaredRequest,
+  PatchTunnelCloudflaredResponse,
+  PutTunnelCloudflaredConfigurationError,
+  PutTunnelCloudflaredConfigurationRequest,
+  PutTunnelCloudflaredConfigurationResponse,
+} from "@distilled.cloud/cloudflare/zero-trust";
+import * as zeroTrust from "@distilled.cloud/cloudflare/zero-trust";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import type { RuntimeContext } from "../../RuntimeContext.ts";
+import type { AccountApiToken } from "../ApiToken/AccountApiToken.ts";
+import type { Worker } from "../Workers/Worker.ts";
+import {
+  authorizeWith,
+  makeTunnelClient,
+  makeTunnelPolicyLive,
+  type TunnelToken,
+} from "./TunnelBinding.ts";
+
+/** Create-tunnel request, minus the account id (supplied by the binding). */
+export type CreateTunnelRequest = Omit<
+  CreateTunnelCloudflaredRequest,
+  "accountId"
+>;
+
+/** Update-tunnel request, minus the account id and tunnel id (positional). */
+export type UpdateTunnelRequest = Omit<
+  PatchTunnelCloudflaredRequest,
+  "accountId" | "tunnelId"
+>;
+
+/** Tunnel configuration body, minus the account id and tunnel id (positional). */
+export type TunnelConfiguration = NonNullable<
+  PutTunnelCloudflaredConfigurationRequest["config"]
+>;
+
+/**
+ * Mutating tunnel operations. Backed by the `Cloudflare Tunnel Write`
+ * permission group.
+ */
+export interface TunnelWriteClient {
+  /** Create a new tunnel. */
+  create(
+    request: CreateTunnelRequest,
+  ): Effect.Effect<
+    CreateTunnelCloudflaredResponse,
+    CreateTunnelCloudflaredError,
+    RuntimeContext
+  >;
+  /** Update a tunnel's mutable fields (name, secret). */
+  update(
+    tunnelId: string,
+    request: UpdateTunnelRequest,
+  ): Effect.Effect<
+    PatchTunnelCloudflaredResponse,
+    PatchTunnelCloudflaredError,
+    RuntimeContext
+  >;
+  /** Delete a tunnel by id. */
+  delete(
+    tunnelId: string,
+  ): Effect.Effect<
+    DeleteTunnelCloudflaredResponse,
+    DeleteTunnelCloudflaredError,
+    RuntimeContext
+  >;
+  /** Replace the remotely-managed configuration (ingress rules) for a tunnel. */
+  putConfiguration(
+    tunnelId: string,
+    config: TunnelConfiguration,
+  ): Effect.Effect<
+    PutTunnelCloudflaredConfigurationResponse,
+    PutTunnelCloudflaredConfigurationError,
+    RuntimeContext
+  >;
+}
+
+/** Build the write client over a bound token. */
+export const writeClient = (token: TunnelToken): TunnelWriteClient => {
+  const authorize = authorizeWith(token);
+  return {
+    create: Effect.fn("Cloudflare.Tunnel.create")(function* (request) {
+      const accountId = yield* token.accountId;
+      return yield* authorize(
+        zeroTrust.createTunnelCloudflared({ accountId, ...request }),
+      );
+    }),
+    update: Effect.fn("Cloudflare.Tunnel.update")(
+      function* (tunnelId, request) {
+        const accountId = yield* token.accountId;
+        return yield* authorize(
+          zeroTrust.patchTunnelCloudflared({ accountId, tunnelId, ...request }),
+        );
+      },
+    ),
+    delete: Effect.fn("Cloudflare.Tunnel.delete")(function* (tunnelId) {
+      const accountId = yield* token.accountId;
+      return yield* authorize(
+        zeroTrust.deleteTunnelCloudflared({ accountId, tunnelId }),
+      );
+    }),
+    putConfiguration: Effect.fn("Cloudflare.Tunnel.putConfiguration")(
+      function* (tunnelId, config) {
+        const accountId = yield* token.accountId;
+        return yield* authorize(
+          zeroTrust.putTunnelCloudflaredConfiguration({
+            accountId,
+            tunnelId,
+            config,
+          }),
+        );
+      },
+    ),
+  };
+};
+
+/**
+ * Binding that lets a Worker create, update, and delete Cloudflare Tunnels at
+ * runtime.
+ *
+ * Creates a scoped {@link AccountApiToken} with only the `Cloudflare Tunnel
+ * Write` permission and binds its outputs into the Worker (the token value as a
+ * `secret_text` binding) so runtime code can authenticate.
+ *
+ * @binding
+ *
+ * @section Mutating tunnels at runtime
+ * @example Bind the write client
+ * Bind once in the Init phase; every method is available on the returned client.
+ * ```typescript
+ * const tunnels = yield* Cloudflare.TunnelWrite.bind();
+ * ```
+ *
+ * @example Create a tunnel
+ * ```typescript
+ * const tunnel = yield* tunnels.create({ name: "on-demand-tunnel" });
+ * ```
+ *
+ * @example Push ingress configuration
+ * ```typescript
+ * yield* tunnels.putConfiguration(tunnel.id!, {
+ *   ingress: [
+ *     { hostname: "app.example.com", service: "http://localhost:3000" },
+ *     { service: "http_status:404" },
+ *   ],
+ * });
+ * ```
+ *
+ * @example Rename and delete a tunnel
+ * ```typescript
+ * yield* tunnels.update(tunnel.id!, { name: "renamed-tunnel" });
+ * yield* tunnels.delete(tunnel.id!);
+ * ```
+ *
+ * @section Runtime Layer
+ * Provide {@link TunnelWriteLive} in the Worker's runtime layer.
+ * ```typescript
+ * Effect.provide(Cloudflare.TunnelWriteLive)
+ * ```
+ */
+export class TunnelWrite extends Binding.Service<
+  TunnelWrite,
+  () => Effect.Effect<TunnelWriteClient, never, Worker>
+>()("Cloudflare.TunnelWrite") {}
+
+/**
+ * Deploy-time policy for {@link TunnelWrite}. Attaches the `Cloudflare Tunnel
+ * Write` permission to the token via its binding contract.
+ */
+export class TunnelWritePolicy extends Binding.Policy<
+  TunnelWritePolicy,
+  (token: AccountApiToken) => Effect.Effect<void>
+>()("Cloudflare.TunnelWrite") {}
+
+/** Runtime layer for {@link TunnelWrite}. */
+export const TunnelWriteLive = Layer.effect(
+  TunnelWrite,
+  makeTunnelClient(TunnelWritePolicy, writeClient),
+);
+
+/** Live deploy-time policy layer for {@link TunnelWritePolicy}. */
+export const TunnelWritePolicyLive = makeTunnelPolicyLive(
+  TunnelWritePolicy,
+  "Cloudflare.TunnelWrite",
+  ["Cloudflare Tunnel Write"],
+);

package/src/Cloudflare/Tunnel/index.ts

@@ -1 +1,5 @@
 export * from "./Tunnel.ts";
+export * from "./TunnelBinding.ts";
+export * from "./TunnelRead.ts";
+export * from "./TunnelReadWrite.ts";
+export * from "./TunnelWrite.ts";

package/src/Cloudflare/Vectorize/VectorizeIndex.ts

@@ -253,7 +253,8 @@ const toAttributes = (
 ): VectorizeIndexAttributes => ({
   indexName: index.name ?? name,
   dimensions: index.config?.dimensions,
-  metric: index.config?.metric,
+  // Distilled widened generated string enums to open unions (`string & {}`).
+  metric: index.config?.metric as DistanceMetric | undefined,
   description: index.description ?? undefined,
   accountId,
   createdOn: index.createdOn ?? undefined,

package/src/Cloudflare/VpcService/VpcService.ts

@@ -262,7 +262,9 @@ export const formatVpcService = (
   service: {
     serviceId?: string | null;
     name: string;
-    type: "http" | "tcp";
+    // Distilled widened generated string enums to open unions (`string & {}`);
+    // the API only ever returns the known variants here.
+    type: string;
     createdAt?: string | null;
     updatedAt?: string | null;
     httpPort?: number | null;
@@ -300,7 +302,7 @@ export const formatVpcService = (
   return {
     serviceId: service.serviceId!,
     serviceName: service.name,
-    serviceType: service.type,
+    serviceType: service.type as "http" | "tcp",
     httpPort: service.httpPort ?? undefined,
     httpsPort: service.httpsPort ?? undefined,
     host,

package/src/Cloudflare/Workers/DynamicWorkerLoader.ts

@@ -1,4 +1,5 @@
 import * as Effect from "effect/Effect";
+import { SingleShotGen } from "effect/Utils";
 import { ALCHEMY_PHASE } from "../../Phase.ts";
 import { fromCloudflareFetcher, type Fetcher } from "../Fetcher.ts";
 import { makeRpcStub } from "./Rpc.ts";
@@ -56,10 +57,10 @@ export interface DynamicWorkerInstance extends Fetcher {
 }
 
 /**
- * The handle returned by `DynamicWorker(name)`. Provides a `.load()` method
- * for spinning up isolated dynamic workers at runtime.
+ * The runtime handle obtained by `yield* Cloudflare.DynamicWorkerLoader(name)`.
+ * Provides a `.load()` method for spinning up isolated dynamic workers.
  */
-export type DynamicWorkerLoader = {
+export interface DynamicWorkerLoaderHandle {
   Type: DynamicWorkerTypeId;
   name: string;
   /**
@@ -67,7 +68,57 @@ export type DynamicWorkerLoader = {
    * exposes `.getEntrypoint()` and `.fetch()` for calling into the worker.
    */
   load(options: DynamicWorkerLoadOptions): DynamicWorkerInstance;
-};
+}
+
+/**
+ * The native `worker_loader` runtime binding shape, as seen by an async
+ * (non-Effect) Worker that declares the loader through `env`. `InferEnv` maps
+ * a `DynamicWorkerLoader` marker in `env` to this type.
+ */
+export interface DynamicWorkerLoaderBinding {
+  load(options: DynamicWorkerLoadOptions): {
+    getEntrypoint(name?: string): {
+      fetch(request: Request): Promise<Response>;
+      [method: string]: unknown;
+    };
+  };
+}
+
+/**
+ * The Effect yielded when a `DynamicWorkerLoader` marker is used inside a
+ * Worker init phase: it registers the `worker_loader` binding on the
+ * surrounding Worker and resolves to a {@link DynamicWorkerLoaderHandle}.
+ */
+type BindEffect = ReturnType<typeof bindLoader>;
+
+/**
+ * Marker for a Cloudflare Worker Loader binding.
+ *
+ * It is a plain data structure (so it can be declared directly on a Worker's
+ * `env`) that is **also** yieldable inside an Effect-native Worker. Yielding it
+ * (`yield* Cloudflare.DynamicWorkerLoader(name)`) registers the binding on the
+ * surrounding Worker and returns a {@link DynamicWorkerLoaderHandle} with
+ * `.load()` — no separate `.bind(...)` step required.
+ *
+ * The divergence is achieved via `[Symbol.iterator]`: the object is not an
+ * `Effect` (so `InferEnv` resolves it to the native
+ * {@link DynamicWorkerLoaderBinding} in the `env` position), but it is iterable
+ * as one when `yield*`-ed.
+ */
+export interface DynamicWorkerLoader {
+  kind: DynamicWorkerTypeId;
+  name: string;
+  asEffect(): BindEffect;
+  [Symbol.iterator](): SingleShotGen<BindEffect, DynamicWorkerLoaderHandle>;
+}
+
+export const isDynamicWorkerLoader = (
+  value: unknown,
+): value is DynamicWorkerLoader =>
+  typeof value === "object" &&
+  value !== null &&
+  "kind" in value &&
+  (value as DynamicWorkerLoader).kind === DynamicWorkerTypeId;
 
 /**
  * Load and run ephemeral Workers at runtime from inline JavaScript
@@ -86,14 +137,79 @@ export type DynamicWorkerLoader = {
  * @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.
+ * Yield `Cloudflare.DynamicWorkerLoader(name)` in your Worker's init
+ * phase to register the binding and get back a runtime handle. The
+ * string argument becomes the binding name on the deployed Worker.
  *
- * @example Registering a loader
+ * @example Registering a loader (effect-native Worker)
  * ```typescript
- * // init
- * const loader = yield* Cloudflare.DynamicWorkerLoader("Loader");
+ * import * as Cloudflare from "alchemy/Cloudflare";
+ * import * as Effect from "effect/Effect";
+ * import { HttpServerRequest } from "effect/unstable/http/HttpServerRequest";
+ * import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
+ * import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
+ *
+ * export default class EvalWorker extends Cloudflare.Worker<EvalWorker>()(
+ *   "EvalWorker",
+ *   { main: import.meta.filename },
+ *   Effect.gen(function* () {
+ *     // Registers the `worker_loader` binding on this Worker and returns the
+ *     // runtime handle in one step — no separate `.bind(...)`.
+ *     const loader = yield* Cloudflare.DynamicWorkerLoader("LOADER");
+ *
+ *     return {
+ *       fetch: Effect.gen(function* () {
+ *         const request = yield* HttpServerRequest;
+ *         const code = yield* request.text;
+ *
+ *         // Spin up an isolated, sandboxed Worker from inline source.
+ *         const worker = loader.load({
+ *           compatibilityDate: "2026-01-28",
+ *           mainModule: "worker.js",
+ *           modules: {
+ *             "worker.js": `export default {
+ *               async fetch(req) {
+ *                 const result = (0, eval)(await req.text());
+ *                 return new Response(String(result));
+ *               }
+ *             }`,
+ *           },
+ *           globalOutbound: null, // block outbound network access
+ *         });
+ *
+ *         // Call the loaded Worker over Effect-native HTTP.
+ *         const response = yield* worker.fetch(
+ *           HttpClientRequest.post("https://worker/").pipe(
+ *             HttpClientRequest.bodyText(code),
+ *           ),
+ *         );
+ *         return HttpServerResponse.fromClientResponse(response);
+ *       }),
+ *     };
+ *   }),
+ * ) {}
+ * ```
+ *
+ * @example Declaring on env (async Worker)
+ * ```typescript
+ * export const Worker = Cloudflare.Worker("Worker", {
+ *   main: "./src/worker.ts",
+ *   env: { LOADER: Cloudflare.DynamicWorkerLoader() },
+ * });
+ *
+ * export type WorkerEnv = Cloudflare.InferEnv<typeof Worker>;
+ *
+ * // worker.ts
+ * export default {
+ *   async fetch(req: Request, env: WorkerEnv) {
+ *     const worker = env.LOADER.load({
+ *       compatibilityDate: "2026-01-28",
+ *       mainModule: "worker.js",
+ *       modules: { "worker.js": "export default { fetch: () => new Response('ok') }" },
+ *     });
+ *     return worker.getEntrypoint().fetch(req);
+ *   },
+ * };
  * ```
  *
  * @section Loading a Worker
@@ -155,7 +271,17 @@ export type DynamicWorkerLoader = {
  * const greeting = yield* api.greet("world");
  * ```
  */
-export const DynamicWorkerLoader = Effect.fnUntraced(function* (name: string) {
+export const DynamicWorkerLoader = (name = "LOADER"): DynamicWorkerLoader => {
+  const self: DynamicWorkerLoader = {
+    kind: DynamicWorkerTypeId,
+    name,
+    asEffect: () => bindLoader(name),
+    [Symbol.iterator]: () => new SingleShotGen(bindLoader(name)),
+  };
+  return self;
+};
+
+const bindLoader = Effect.fnUntraced(function* (name: string) {
   const worker = yield* Worker;
 
   yield* worker.bind`${name}`({
@@ -177,14 +303,14 @@ export const DynamicWorkerLoader = Effect.fnUntraced(function* (name: string) {
     }),
   );
 
-  const self: DynamicWorkerLoader = {
+  const handle: DynamicWorkerLoaderHandle = {
     Type: DynamicWorkerTypeId,
     name,
     load: (options: DynamicWorkerLoadOptions): DynamicWorkerInstance =>
       wrapLoadedWorker(binding.load(options)),
   };
 
-  return self;
+  return handle;
 });
 
 const wrapEntrypoint = <Shape>(raw: any): DynamicWorkerEntrypoint<Shape> =>