alchemy 2.0.0-beta.46 → 2.0.0-beta.48

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/DurableObjectBridge.ts

@@ -6,6 +6,7 @@ import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
 import * as Layer from "effect/Layer";
 import * as Scope from "effect/Scope";
+import * as Stream from "effect/Stream";
 
 import { HttpServerResponse } from "effect/unstable/http";
 import type {
@@ -89,7 +90,15 @@ export const makeDurableObjectBridge =
               this.#execute((instance) => {
                 const method = instance[prop as keyof DurableObjectShape];
                 if (typeof method === "function") {
-                  return (method as any)(...args);
+                  const result = (method as any)(...args);
+                  // A streaming RPC method returns a `Stream` directly rather
+                  // than an `Effect`. Lift it into the success channel so the
+                  // resulting `Exit.value` is the `Stream` and `handleRpcExit`
+                  // can encode it as a stream envelope instead of trying to run
+                  // it as an effect.
+                  return Stream.isStream(result)
+                    ? Effect.succeed(result)
+                    : result;
                 } else if (Effect.isEffect(method)) {
                   return method;
                 } else {

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> =>

package/src/Cloudflare/Workers/InferEnv.ts

@@ -40,21 +40,25 @@ export type GetBindingType<T> =
                       ? AnalyticsEngineDataset
                       : T extends Cloudflare.Artifacts
                         ? Artifacts
-                        : T extends Cloudflare.Images
-                          ? ImagesBinding
-                          : T extends Cloudflare.BrowserRendering
-                            ? Fetcher
-                            : T extends Cloudflare.Hyperdrive
-                              ? Hyperdrive
-                              : T extends Cloudflare.DurableObjectNamespaceLike
-                                ? DurableObjectNamespace<
-                                    Exclude<T["Shape"], undefined>
-                                  >
-                                : T extends Redacted<any>
-                                  ? // redacteds are always stored as secret_text, so are always string
-                                    // we JSON.stringify when not a Redacted<string>
-                                    string
-                                  : T;
+                        : T extends Cloudflare.RateLimit
+                          ? RateLimit
+                          : T extends Cloudflare.Images
+                            ? ImagesBinding
+                            : T extends Cloudflare.Browser
+                              ? Fetcher
+                              : T extends Cloudflare.Hyperdrive
+                                ? Hyperdrive
+                                : T extends Cloudflare.DynamicWorkerLoader
+                                  ? Cloudflare.DynamicWorkerLoaderBinding
+                                  : T extends Cloudflare.DurableObjectNamespaceLike
+                                    ? DurableObjectNamespace<
+                                        Exclude<T["Shape"], undefined>
+                                      >
+                                    : T extends Redacted<any>
+                                      ? // redacteds are always stored as secret_text, so are always string
+                                        // we JSON.stringify when not a Redacted<string>
+                                        string
+                                      : T;
 
 /**
  * Cloudflare service-binding wire shape for an Effect-native Worker.

package/src/Cloudflare/Workers/LocalWorkerProvider.ts

@@ -232,7 +232,19 @@ export const LocalWorkerProvider = () =>
       }) {
         const name = yield* createWorkerName(id, props.name);
         const compatibility = getCompatibility(props);
-        const workerBindings: BindingHook<BindingServices>[] = [];
+        const workerBindings: BindingHook<BindingServices>[] = [
+          Text.local("ALCHEMY_PHASE", "runtime"),
+          Text.local("ALCHEMY_STACK_NAME", stack.name),
+          Text.local("ALCHEMY_STAGE", stack.stage),
+          ...Object.entries(props.env ?? {}).map(([key, value]) => {
+            const unredacted = Redacted.isRedacted(value)
+              ? Redacted.value(value)
+              : value;
+            return typeof unredacted === "string"
+              ? Text.local(key, unredacted)
+              : Json.local(key, unredacted);
+          }),
+        ];
         const durableObjectNamespaces: Record<string, string> = {};
         const hyperdrives: Record<string, Required<HyperdriveOrigin>> = {};
         for (const { data } of bindings) {
@@ -583,8 +595,19 @@ const toRuntimeAssets = (
     directory: "directory" in assets ? assets.directory : assets.path,
     headers: assets.config?.headers,
     redirects: assets.config?.redirects,
-    htmlHandling: assets.config?.htmlHandling,
-    notFoundHandling: assets.config?.notFoundHandling,
+    // Distilled widened generated string enums to open unions (`string & {}`);
+    // the API only ever returns the known variants here.
+    htmlHandling: assets.config?.htmlHandling as
+      | "none"
+      | "auto-trailing-slash"
+      | "force-trailing-slash"
+      | "drop-trailing-slash"
+      | undefined,
+    notFoundHandling: assets.config?.notFoundHandling as
+      | "none"
+      | "404-page"
+      | "single-page-application"
+      | undefined,
     runWorkerFirst: assets.config?.runWorkerFirst,
     serveDirectly: assets.config?.serveDirectly,
   };

package/src/Cloudflare/Workers/Rpc.ts

@@ -223,19 +223,48 @@ export const makeRpcStub = <Shape>(
         return target[prop];
       }
       return (...args: any[]) =>
-        Effect.gen(function* () {
-          const stub = isLazy
-            ? yield* stubSource as Effect.Effect<any>
-            : stubSource;
-          return yield* Effect.tryPromise({
-            try: () => (stub as any)[prop](...args),
-            catch: (cause) => new RpcCallError({ method: String(prop), cause }),
-          }).pipe(Effect.flatMap(decodeRpcResult));
-        });
+        asEffectOrStream(
+          Effect.gen(function* () {
+            const stub = isLazy
+              ? yield* stubSource as Effect.Effect<any>
+              : stubSource;
+            return yield* Effect.tryPromise({
+              try: () => (stub as any)[prop](...args),
+              catch: (cause) =>
+                new RpcCallError({ method: String(prop), cause }),
+            }).pipe(Effect.flatMap(decodeRpcResult));
+          }),
+        );
     },
   }) as Shape;
 };
 
+// Effect's internal Stream brand. `Stream.isStream` recognises a value by
+// this property and reads its `channel`. A `makeRpcStub` method can't know
+// synchronously whether the remote method returns a value or a `Stream`
+// (the call is async), yet its declared type mirrors the DO `Shape`
+// verbatim — value methods are typed `Effect<A>`, streaming methods `Stream<A>`.
+// We satisfy BOTH by handing back the call `Effect` augmented with the Stream
+// brand + channel, so the single return value can be `yield*`-ed / `.pipe`d as
+// an Effect (value methods, e.g. `stub.put(k, v).pipe(Effect.orDie)`) AND piped
+// through `Stream.*` combinators (streaming methods, e.g.
+// `stub.tick(n).pipe(Stream.map(...))`).
+const StreamTypeId = "~effect/Stream";
+
+const asEffectOrStream = (
+  call: Effect.Effect<unknown, unknown>,
+): Effect.Effect<unknown, unknown> => {
+  const streamForm = Stream.unwrap(
+    Effect.map(call, (value) =>
+      Stream.isStream(value) ? value : Stream.succeed(value),
+    ),
+  );
+  return Object.assign(call, {
+    [StreamTypeId]: streamForm[StreamTypeId],
+    channel: streamForm.channel,
+  });
+};
+
 export const toRpcStream = (stream: Stream.Stream<any, any, any>) =>
   Effect.scoped(
     Effect.gen(function* () {

package/src/Cloudflare/Workers/WorkerAsyncBindings.ts

@@ -10,7 +10,7 @@ import { asEffect } from "../../Util/types.ts";
 import { isAiGateway } from "../AiGateway/AiGateway.ts";
 import { isAnalyticsEngineDataset } from "../AnalyticsEngine/AnalyticsEngineDataset.ts";
 import { isArtifacts } from "../Artifacts/Artifacts.ts";
-import { isBrowserRendering } from "../BrowserRendering/BrowserRendering.ts";
+import { isBrowser } from "../Browser/Browser.ts";
 import { isD1Database } from "../D1/D1Database.ts";
 import { isSendEmail } from "../Email/SendEmail.ts";
 import { isHyperdrive } from "../Hyperdrive/Hyperdrive.ts";
@@ -19,9 +19,11 @@ import { isImages } from "../Images/Images.ts";
 import { isKVNamespace } from "../KV/KVNamespace.ts";
 import { isQueue } from "../Queue/Queue.ts";
 import { isR2Bucket } from "../R2/R2Bucket.ts";
+import { isRateLimit } from "../RateLimit/RateLimit.ts";
 import { isVectorizeIndex } from "../Vectorize/VectorizeIndex.ts";
 import { isAssets } from "./Assets.ts";
 import { isDurableObjectNamespaceLike } from "./DurableObjectNamespace.ts";
+import { isDynamicWorkerLoader } from "./DynamicWorkerLoader.ts";
 import type { WorkerBindingProps } from "./Worker.ts";
 import { isWorker, type Worker, type WorkerProps } from "./Worker.ts";
 import type { WorkerBinding, WorkerBindingResource } from "./WorkerBinding.ts";
@@ -119,7 +121,7 @@ const toBinding = (
       type: "images",
       name: bindingName,
     };
-  } else if (isBrowserRendering(binding)) {
+  } else if (isBrowser(binding)) {
     return {
       type: "browser",
       name: bindingName,
@@ -130,6 +132,13 @@ const toBinding = (
       name: bindingName,
       dataset: binding.dataset,
     };
+  } else if (isRateLimit(binding)) {
+    return {
+      type: "ratelimit",
+      name: bindingName,
+      namespaceId: binding.namespaceId,
+      simple: binding.simple,
+    };
   } else if (isSendEmail(binding)) {
     return {
       type: "send_email",
@@ -197,6 +206,11 @@ const toBinding = (
       name: bindingName,
       indexName: binding.indexName,
     };
+  } else if (isDynamicWorkerLoader(binding)) {
+    return {
+      type: "worker_loader",
+      name: bindingName,
+    } as any;
   } else {
     return {
       type: "json",