alchemy 0.90.1 → 0.92.1

package/src/cloudflare/email-catch-all.ts

@@ -1,17 +1,23 @@
 import type { Context } from "../context.ts";
-import { Resource } from "../resource.ts";
+import { Resource, ResourceKind } from "../resource.ts";
 import { type CloudflareApiOptions, createCloudflareApi } from "./api.ts";
-import type { EmailAction, EmailMatcher } from "./email-rule.ts";
+import { resolveEmailZoneId } from "./email-common.ts";
+import type { EmailAction } from "./email-rule.ts";
 import type { CloudflareResponse } from "./response.ts";
 import type { Zone } from "./zone.ts";
 
+export interface EmailCatchAllMatcher {
+  type: "all";
+}
+
 /**
  * Cloudflare Email Catch All response format
  */
 interface CloudflareEmailCatchAll {
+  id: string;
   enabled: boolean;
   name: string;
-  matchers: EmailMatcher[];
+  matchers: EmailCatchAllMatcher[];
   actions: EmailAction[];
   tag: string;
 }
@@ -43,7 +49,7 @@ export interface EmailCatchAllProps extends CloudflareApiOptions {
    * Matchers for the catch-all rule (typically matches all emails)
    * If not provided, defaults to matching all emails
    */
-  matchers?: EmailMatcher[];
+  matchers?: EmailCatchAllMatcher[];
 
   /**
    * Actions to take for emails that don't match other rules
@@ -60,6 +66,11 @@ export interface EmailCatchAll {
    */
   zoneId: string;
 
+  /**
+   * Routing rule identifier.
+   */
+  ruleId: string;
+
   /**
    * Whether the catch-all rule is enabled
    */
@@ -73,7 +84,7 @@ export interface EmailCatchAll {
   /**
    * Matchers for the catch-all rule
    */
-  matchers: EmailMatcher[];
+  matchers: EmailCatchAllMatcher[];
 
   /**
    * Actions for the catch-all rule
@@ -81,9 +92,26 @@ export interface EmailCatchAll {
   actions: EmailAction[];
 
   /**
-   * Rule tag
+   * Deprecated rule tag returned by the Cloudflare API.
    */
-  tag: string;
+  tag?: string;
+}
+
+export function isEmailCatchAll(resource: any): resource is EmailCatchAll {
+  return resource?.[ResourceKind] === "cloudflare::EmailCatchAll";
+}
+
+function validateCatchAllActions(actions: EmailAction[]) {
+  for (const action of actions) {
+    if (action.type === "drop") {
+      continue;
+    }
+    if (!action.value?.length) {
+      throw new Error(
+        `EmailCatchAll action "${action.type}" requires at least one value.`,
+      );
+    }
+  }
 }
 
 /**
@@ -151,7 +179,8 @@ export const EmailCatchAll = Resource(
     props: EmailCatchAllProps,
   ): Promise<EmailCatchAll> {
     const api = await createCloudflareApi(props);
-    const zoneId = typeof props.zone === "string" ? props.zone : props.zone.id;
+    const zoneId = await resolveEmailZoneId(api, props.zone);
+    validateCatchAllActions(props.actions);
 
     if (this.phase === "delete") {
       // Disable the catch-all rule by setting enabled to false
@@ -205,11 +234,12 @@ export const EmailCatchAll = Resource(
 
       return {
         zoneId,
+        ruleId: result.result.id,
         enabled: result.result.enabled,
         name: result.result.name,
         matchers: result.result.matchers,
         actions: result.result.actions,
-        tag: result.result.tag,
+        tag: result.result.tag || undefined,
       };
     }
 
@@ -238,11 +268,12 @@ export const EmailCatchAll = Resource(
 
     return {
       zoneId,
+      ruleId: result.result.id,
       enabled: result.result.enabled,
       name: result.result.name,
       matchers: result.result.matchers,
       actions: result.result.actions,
-      tag: result.result.tag,
+      tag: result.result.tag || undefined,
     };
   },
 );

package/src/cloudflare/email-common.ts

@@ -0,0 +1,11 @@
+import type { CloudflareApi } from "./api.ts";
+import { findZoneForHostname, type Zone } from "./zone.ts";
+
+export async function resolveEmailZoneId(
+  api: CloudflareApi,
+  zone: string | Zone,
+): Promise<string> {
+  return typeof zone === "string"
+    ? (await findZoneForHostname(api, zone)).zoneId
+    : zone.id;
+}

package/src/cloudflare/email-routing.ts

@@ -1,7 +1,8 @@
 import type { Context } from "../context.ts";
-import { Resource } from "../resource.ts";
+import { Resource, ResourceKind } from "../resource.ts";
 import { handleApiError } from "./api-error.ts";
 import { type CloudflareApiOptions, createCloudflareApi } from "./api.ts";
+import { resolveEmailZoneId } from "./email-common.ts";
 import type { CloudflareResponse } from "./response.ts";
 import type { Zone } from "./zone.ts";
 
@@ -75,6 +76,10 @@ export interface EmailRouting {
   tag: string;
 }
 
+export function isEmailRouting(resource: any): resource is EmailRouting {
+  return resource?.[ResourceKind] === "cloudflare::EmailRouting";
+}
+
 /**
  * Configures email routing for a Cloudflare zone, allowing emails sent to the zone's domain
  * to be routed according to defined rules.
@@ -116,7 +121,7 @@ export const EmailRouting = Resource(
     props: EmailRoutingProps,
   ): Promise<EmailRouting> {
     const api = await createCloudflareApi(props);
-    const zoneId = typeof props.zone === "string" ? props.zone : props.zone.id;
+    const zoneId = await resolveEmailZoneId(api, props.zone);
 
     if (this.phase === "delete") {
       // Disable email routing DNS

package/src/cloudflare/email-rule.ts

@@ -1,7 +1,8 @@
 import type { Context } from "../context.ts";
-import { Resource } from "../resource.ts";
+import { Resource, ResourceKind } from "../resource.ts";
 import { handleApiError } from "./api-error.ts";
 import { type CloudflareApiOptions, createCloudflareApi } from "./api.ts";
+import { resolveEmailZoneId } from "./email-common.ts";
 import type { CloudflareResponse } from "./response.ts";
 import type { Zone } from "./zone.ts";
 
@@ -19,7 +20,7 @@ export interface EmailMatcher {
   /**
    * Field to match against (required for literal matchers)
    */
-  field?: "to" | "from" | "subject";
+  field?: "to";
 
   /**
    * Value to match (required for literal matchers)
@@ -141,9 +142,42 @@ export interface EmailRule {
   actions: EmailAction[];
 
   /**
-   * Rule tag
+   * Deprecated rule tag returned by the Cloudflare API.
    */
-  tag: string;
+  tag?: string;
+}
+
+export function isEmailRule(resource: any): resource is EmailRule {
+  return resource?.[ResourceKind] === "cloudflare::EmailRule";
+}
+
+function validateMatchers(matchers: EmailMatcher[]) {
+  for (const matcher of matchers) {
+    if (matcher.type === "all") {
+      continue;
+    }
+    if (matcher.field !== "to") {
+      throw new Error(
+        'EmailRule literal matchers currently only support field: "to".',
+      );
+    }
+    if (!matcher.value) {
+      throw new Error("EmailRule literal matchers require a value.");
+    }
+  }
+}
+
+function validateActions(actions: EmailAction[]) {
+  for (const action of actions) {
+    if (action.type === "drop") {
+      continue;
+    }
+    if (!action.value?.length) {
+      throw new Error(
+        `EmailRule action "${action.type}" requires at least one value.`,
+      );
+    }
+  }
 }
 
 /**
@@ -235,7 +269,9 @@ export const EmailRule = Resource(
     props: EmailRuleProps,
   ): Promise<EmailRule> {
     const api = await createCloudflareApi(props);
-    const zoneId = typeof props.zone === "string" ? props.zone : props.zone.id;
+    const zoneId = await resolveEmailZoneId(api, props.zone);
+    validateMatchers(props.matchers);
+    validateActions(props.actions);
 
     if (this.phase === "delete") {
       if (this.output?.ruleId) {
@@ -282,7 +318,7 @@ export const EmailRule = Resource(
           priority: result.result.priority,
           matchers: result.result.matchers,
           actions: result.result.actions,
-          tag: result.result.tag,
+          tag: result.result.tag || undefined,
         };
       }
     }
@@ -316,7 +352,7 @@ export const EmailRule = Resource(
       priority: result.result.priority,
       matchers: result.result.matchers,
       actions: result.result.actions,
-      tag: result.result.tag,
+      tag: result.result.tag || undefined,
     };
   },
 );

package/src/cloudflare/email-sender.ts

@@ -0,0 +1,49 @@
+export interface BaseEmailSenderProps {
+  allowedSenderAddresses?: string[];
+  dev?: {
+    remote?: boolean;
+  };
+}
+
+export type EmailSenderProps = BaseEmailSenderProps &
+  (
+    | {
+        destinationAddress?: string;
+        allowedDestinationAddresses?: never;
+      }
+    | {
+        destinationAddress?: never;
+        allowedDestinationAddresses?: string[];
+      }
+  );
+
+/**
+ * Type representing a Cloudflare Email Service send binding.
+ * @see https://developers.cloudflare.com/email-service/api/send-emails/workers-api/
+ */
+export type EmailSender = EmailSenderProps & {
+  type: "send_email";
+};
+
+/**
+ * Creates a Cloudflare Email Service binding for sending emails from Workers.
+ *
+ * Set `dev.remote` to `true` to use the real Cloudflare email binding while
+ * running the Worker locally.
+ *
+ * @example
+ * ```ts
+ * const email = EmailSender({
+ *   allowedSenderAddresses: ["noreply@example.com"],
+ *   dev: { remote: true },
+ * });
+ * ```
+ *
+ * @see https://developers.cloudflare.com/email-service/api/send-emails/workers-api/
+ */
+export function EmailSender(props: EmailSenderProps = {}): EmailSender {
+  return {
+    type: "send_email",
+    ...props,
+  };
+}

package/src/cloudflare/index.ts

@@ -38,6 +38,7 @@ export * from "./email-address.ts";
 export * from "./email-catch-all.ts";
 export * from "./email-routing.ts";
 export * from "./email-rule.ts";
+export * from "./email-sender.ts";
 export * from "./health-check.ts";
 export * from "./hyperdrive-ref.ts";
 export * from "./hyperdrive.ts";

package/src/cloudflare/miniflare/build-worker-options.ts

@@ -50,7 +50,10 @@ type RemoteBinding =
       }
     > & { raw: true })
   // Fetcher type bindings do not require the `raw` flag and will throw an error if it is present.
-  | Extract<WorkerBindingSpec, { type: "service" | "vpc_service" }>;
+  | Extract<
+      WorkerBindingSpec,
+      { type: "send_email" | "service" | "vpc_service" }
+    >;
 
 type BaseWorkerOptions = {
   [K in keyof miniflare.WorkerOptions]: K extends
@@ -261,6 +264,36 @@ export const buildWorkerOptions = async (
         (options.bindings ??= {})[key] = binding.unencrypted;
         break;
       }
+      case "send_email": {
+        const config = {
+          name: key,
+          destination_address: binding.destinationAddress,
+          allowed_destination_addresses: binding.allowedDestinationAddresses,
+          allowed_sender_addresses: binding.allowedSenderAddresses,
+        };
+        if (isRemoteBinding(binding)) {
+          remoteBindings.push({
+            type: "send_email",
+            ...config,
+          });
+        } else {
+          ((
+            options as BaseWorkerOptions & {
+              email?: {
+                send_email?: Array<typeof config>;
+              };
+            }
+          ).email ??= {}).send_email ??= [];
+          (
+            options as BaseWorkerOptions & {
+              email: {
+                send_email: Array<typeof config>;
+              };
+            }
+          ).email.send_email.push(config);
+        }
+        break;
+      }
       case "secret_key": {
         throw new Error("Secret keys are not supported in local mode");
       }
@@ -441,6 +474,41 @@ export const buildWorkerOptions = async (
             remoteProxyConnectionString: remoteProxy.connectionString,
           };
           break;
+        case "send_email":
+          ((
+            options as BaseWorkerOptions & {
+              email?: {
+                send_email?: Array<{
+                  name: string;
+                  destination_address?: string;
+                  allowed_destination_addresses?: string[];
+                  allowed_sender_addresses?: string[];
+                  remoteProxyConnectionString: typeof remoteProxy.connectionString;
+                }>;
+              };
+            }
+          ).email ??= {}).send_email ??= [];
+          (
+            options as BaseWorkerOptions & {
+              email: {
+                send_email: Array<{
+                  name: string;
+                  destination_address?: string;
+                  allowed_destination_addresses?: string[];
+                  allowed_sender_addresses?: string[];
+                  remoteProxyConnectionString: typeof remoteProxy.connectionString;
+                }>;
+              };
+            }
+          ).email.send_email.push({
+            name: binding.name,
+            destination_address: binding.destination_address,
+            allowed_destination_addresses:
+              binding.allowed_destination_addresses,
+            allowed_sender_addresses: binding.allowed_sender_addresses,
+            remoteProxyConnectionString: remoteProxy.connectionString,
+          });
+          break;
         case "service":
           (options.serviceBindings ??= {})[binding.name] = {
             name: binding.name,

package/src/cloudflare/miniflare/miniflare-controller.ts

@@ -101,7 +101,7 @@ export class MiniflareController {
         unsafeDevRegistryPath: miniflare.getDefaultDevRegistryPath(),
         log: process.env.DEBUG
           ? new miniflare.Log(miniflare.LogLevel.DEBUG)
-          : undefined,
+          : new DefaultLogger(),
         // This is required to allow websites and other separate processes
         // to detect Alchemy-managed Durable Objects via the Wrangler dev registry.
         unsafeDevRegistryDurableObjectProxy: true,
@@ -170,3 +170,20 @@ export class MiniflareController {
     ]);
   }
 }
+
+class DefaultLogger extends miniflare.Log {
+  constructor() {
+    // Miniflare emits send_email activity at info level.
+    super(miniflare.LogLevel.INFO);
+  }
+
+  override info(message: string) {
+    if (
+      message.startsWith("Ready on") ||
+      message.startsWith("Updated and ready on")
+    ) {
+      return;
+    }
+    super.info(message);
+  }
+}

package/src/cloudflare/nuxt/nuxt.ts

@@ -14,16 +14,20 @@ import type { Worker } from "../worker.ts";
  * Properties for creating a Nuxt resource.
  * Extends WebsiteProps, allowing customization of the underlying Website.
  */
-export interface NuxtProps<B extends Bindings> extends WebsiteProps<B> {}
+export interface NuxtProps<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> extends WebsiteProps<B, RPC> {}
 
 /**
  * Represents the output of a Nuxt resource deployment.
  * It resolves to the underlying Cloudflare Worker type, ensuring type safety.
  * Prevents overriding the internal ASSETS binding.
  */
-export type Nuxt<B extends Bindings> = B extends { ASSETS: any }
-  ? never
-  : Worker<B & { ASSETS: Assets }>;
+export type Nuxt<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> = B extends { ASSETS: any } ? never : Worker<B & { ASSETS: Assets }, RPC>;
 
 /**
  * Creates and deploys a Nuxt application using the Cloudflare Workers preset.
@@ -52,10 +56,10 @@ export type Nuxt<B extends Bindings> = B extends { ASSETS: any }
  *   },
  * });
  */
-export async function Nuxt<B extends Bindings>(
-  id: string,
-  props?: Partial<NuxtProps<B>>,
-): Promise<Nuxt<B>> {
+export async function Nuxt<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+>(id: string, props?: Partial<NuxtProps<B, RPC>>): Promise<Nuxt<B, RPC>> {
   const runner = await getPackageManagerRunner();
   return await Website(id, {
     ...props,

package/src/cloudflare/react-router/react-router.ts

@@ -5,7 +5,10 @@ import type { Bindings } from "../bindings.ts";
 import { Vite, type ViteProps } from "../vite/vite.ts";
 import type { Worker } from "../worker.ts";
 
-export interface ReactRouterProps<B extends Bindings> extends ViteProps<B> {
+export interface ReactRouterProps<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> extends ViteProps<B, RPC> {
   /**
    * @default workers/app.ts
    */
@@ -13,14 +16,18 @@ export interface ReactRouterProps<B extends Bindings> extends ViteProps<B> {
 }
 
 // don't allow the ASSETS to be overriden
-export type ReactRouter<B extends Bindings> = B extends { ASSETS: any }
-  ? never
-  : Worker<B & { ASSETS: Assets }>;
+export type ReactRouter<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> = B extends { ASSETS: any } ? never : Worker<B & { ASSETS: Assets }, RPC>;
 
-export async function ReactRouter<B extends Bindings>(
+export async function ReactRouter<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+>(
   id: string,
-  props: ReactRouterProps<B> = {},
-): Promise<ReactRouter<B>> {
+  props: ReactRouterProps<B, RPC> = {},
+): Promise<ReactRouter<B, RPC>> {
   const runner = await getPackageManagerRunner();
   const cwd = path.resolve(props.cwd ?? process.cwd());
   const ssr = await detectSSREnabled(cwd);

package/src/cloudflare/redwood/redwood.ts

@@ -4,12 +4,16 @@ import type { Bindings } from "../bindings.ts";
 import { Vite, type ViteProps } from "../vite/vite.ts";
 import type { Worker } from "../worker.ts";
 
-export interface RedwoodProps<B extends Bindings> extends ViteProps<B> {}
+export interface RedwoodProps<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> extends ViteProps<B, RPC> {}
 
 // don't allow the ASSETS to be overridden
-export type Redwood<B extends Bindings> = B extends { ASSETS: any }
-  ? never
-  : Worker<B & { ASSETS: Assets }>;
+export type Redwood<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> = B extends { ASSETS: any } ? never : Worker<B & { ASSETS: Assets }, RPC>;
 
 /**
  * Deploy a RedwoodJS application to Cloudflare Workers with automatically configured defaults.
@@ -37,10 +41,10 @@ export type Redwood<B extends Bindings> = B extends { ASSETS: any }
  * @param props - Configuration properties for the RedwoodJS deployment
  * @returns A Cloudflare Worker resource representing the deployed RedwoodJS application
  */
-export async function Redwood<B extends Bindings>(
-  id: string,
-  props?: Partial<RedwoodProps<B>>,
-): Promise<Redwood<B>> {
+export async function Redwood<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+>(id: string, props?: Partial<RedwoodProps<B, RPC>>): Promise<Redwood<B, RPC>> {
   return await Vite(id, {
     ...props,
     build: props?.build ?? {

package/src/cloudflare/route.ts

@@ -49,6 +49,14 @@ export interface RouteProps extends CloudflareApiOptions {
    */
   adopt?: boolean;
 
+  /**
+   * Whether to delete the route when removed from Alchemy.
+   * If set to false, the route will remain but the resource will be removed from state.
+   *
+   * @default true
+   */
+  delete?: boolean;
+
   /**
    * If true, the route will not be created, but will be retained if it already exists.
    * This is used for local development.
@@ -151,7 +159,7 @@ export const Route = Resource(
 
       // Only delete if we have complete output data (both ID and zoneId)
       // If creation failed, we won't have proper output, so just skip deletion
-      if (this.output?.id && this.output?.zoneId) {
+      if (props.delete !== false && this.output?.id && this.output?.zoneId) {
         await deleteRoute(api, this.output.zoneId, this.output.id);
       }
 

package/src/cloudflare/sveltekit/sveltekit.ts

@@ -4,12 +4,16 @@ import type { Bindings } from "../bindings.ts";
 import { Vite, type ViteProps } from "../vite/vite.ts";
 import type { Worker } from "../worker.ts";
 
-export interface SvelteKitProps<B extends Bindings> extends ViteProps<B> {}
+export interface SvelteKitProps<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> extends ViteProps<B, RPC> {}
 
 // don't allow the ASSETS to be overriden
-export type SvelteKit<B extends Bindings> = B extends { ASSETS: any }
-  ? never
-  : Worker<B & { ASSETS: Assets }>;
+export type SvelteKit<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> = B extends { ASSETS: any } ? never : Worker<B & { ASSETS: Assets }, RPC>;
 
 /**
  * Deploy a SvelteKit application to Cloudflare Workers with automatically configured defaults.
@@ -47,10 +51,13 @@ export type SvelteKit<B extends Bindings> = B extends { ASSETS: any }
  * @param props - Configuration properties for the SvelteKit deployment
  * @returns A Cloudflare Worker resource representing the deployed SvelteKit application
  */
-export async function SvelteKit<B extends Bindings>(
+export async function SvelteKit<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+>(
   id: string,
-  props?: Partial<SvelteKitProps<B>>,
-): Promise<SvelteKit<B>> {
+  props?: Partial<SvelteKitProps<B, RPC>>,
+): Promise<SvelteKit<B, RPC>> {
   if (props?.compatibilityDate) {
     const providedDate = new Date(props.compatibilityDate);
     const minDate = new Date("2024-09-23");

package/src/cloudflare/tanstack-start/tanstack-start.ts

@@ -5,17 +5,24 @@ import type { Bindings } from "../bindings.ts";
 import { Vite, type ViteProps } from "../vite/vite.ts";
 import type { Worker } from "../worker.ts";
 
-export interface TanStackStartProps<B extends Bindings> extends ViteProps<B> {}
+export interface TanStackStartProps<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> extends ViteProps<B, RPC> {}
 
 // don't allow the ASSETS to be overriden
-export type TanStackStart<B extends Bindings> = B extends { ASSETS: any }
-  ? never
-  : Worker<B & { ASSETS: Assets }>;
+export type TanStackStart<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> = B extends { ASSETS: any } ? never : Worker<B & { ASSETS: Assets }, RPC>;
 
-export async function TanStackStart<B extends Bindings>(
+export async function TanStackStart<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+>(
   id: string,
-  props?: Partial<TanStackStartProps<B>>,
-): Promise<TanStackStart<B>> {
+  props?: Partial<TanStackStartProps<B, RPC>>,
+): Promise<TanStackStart<B, RPC>> {
   const main =
     props?.wrangler?.main ??
     ((await exists(path.resolve(props?.cwd ?? process.cwd(), "src/server.ts")))

package/src/cloudflare/vite/vite.ts

@@ -11,16 +11,20 @@ import {
 } from "../website.ts";
 import type { Worker } from "../worker.ts";
 
-export interface ViteProps<B extends Bindings> extends WebsiteProps<B> {}
+export interface ViteProps<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> extends WebsiteProps<B, RPC> {}
 
-export type Vite<B extends Bindings> = B extends { ASSETS: any }
-  ? never
-  : Worker<B & { ASSETS: Assets }>;
+export type Vite<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+> = B extends { ASSETS: any } ? never : Worker<B & { ASSETS: Assets }, RPC>;
 
-export async function Vite<B extends Bindings>(
-  id: string,
-  props: ViteProps<B>,
-): Promise<Vite<B>> {
+export async function Vite<
+  B extends Bindings,
+  RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
+>(id: string, props: ViteProps<B, RPC>): Promise<Vite<B, RPC>> {
   const runner = await getPackageManagerRunner();
   let dev = spreadDevProps(props, `${runner} vite dev`);
   let domain = typeof dev === "object" ? dev.domain : undefined;