alchemy 0.69.0 → 0.70.0

package/src/cloudflare/bucket.ts

@@ -1,3 +1,4 @@
+import type { R2PutOptions } from "@cloudflare/workers-types/experimental/index.ts";
 import * as mf from "miniflare";
 import { isDeepStrictEqual } from "node:util";
 import type { Context } from "../context.ts";
@@ -253,6 +254,7 @@ export type R2ObjectMetadata = {
   etag: string;
   uploaded: Date;
   size: number;
+  httpMetadata?: R2HTTPMetadata;
 };
 
 export type R2ObjectContent = R2ObjectMetadata & {
@@ -272,7 +274,7 @@ export type PutR2ObjectResponse = {
 };
 
 export type R2Objects = {
-  objects: R2ObjectMetadata[];
+  objects: Omit<R2ObjectMetadata, "httpMetadata">[];
 } & (
   | {
       truncated: true;
@@ -296,6 +298,7 @@ export type R2Bucket = _R2Bucket & {
       | string
       | null
       | Blob,
+    options?: Pick<R2PutOptions, "httpMetadata">,
   ): Promise<PutR2ObjectResponse>;
   delete(key: string): Promise<Response>;
   list(options?: R2ListOptions): Promise<R2Objects>;
@@ -449,7 +452,17 @@ export async function R2Bucket(
     ...bucket,
     head: async (key: string) => {
       if (isLocal) {
-        return (await localBucket()).head(key);
+        const result = await (await localBucket()).head(key);
+        if (result) {
+          return {
+            key: result.key,
+            etag: result.etag,
+            uploaded: result.uploaded,
+            size: result.size,
+            httpMetadata: result.httpMetadata,
+          } as R2ObjectMetadata;
+        }
+        return null;
       }
       return headObject(api, {
         bucketName: bucket.name,
@@ -489,9 +502,9 @@ export async function R2Bucket(
     put: async (
       key: string,
       value: PutObjectObject,
+      options?: Pick<R2PutOptions, "httpMetadata">,
     ): Promise<PutR2ObjectResponse> => {
       if (isLocal) {
-        // @ts-expect-error - node built-ins vs cloudflare built-ins
         return await (await localBucket()).put(
           key,
           typeof value === "string"
@@ -505,12 +518,14 @@ export async function R2Bucket(
                 : value instanceof ReadableStream
                   ? new Uint8Array(await streamToBuffer(value))
                   : value,
+          options,
         );
       }
       const response = await putObject(api, {
         bucketName: bucket.name,
         key: key,
         object: value,
+        options: options,
       });
       const body = (await response.json()) as {
         result: {
@@ -546,6 +561,7 @@ const parseR2Object = (key: string, response: Response): R2ObjectContent => ({
   uploaded: parseDate(response.headers),
   key,
   size: Number(response.headers.get("Content-Length")),
+  httpMetadata: mapHeadersToHttpMetadata(response.headers),
   arrayBuffer: () => response.arrayBuffer(),
   bytes: () => response.bytes(),
   text: () => response.text(),
@@ -1155,6 +1171,7 @@ export async function headObject(
     etag: response.headers.get("ETag")?.replace(/"/g, "")!,
     uploaded: parseDate(response.headers),
     size: Number(response.headers.get("Content-Length")),
+    httpMetadata: mapHeadersToHttpMetadata(response.headers),
   };
 }
 
@@ -1192,27 +1209,76 @@ export type PutObjectObject =
   | Buffer
   | Blob;
 
+function mapHttpMetadataToHeaders(
+  httpMetadata: R2PutOptions["httpMetadata"],
+): Record<string, string> {
+  const headers: Record<string, string> = {};
+
+  if (httpMetadata instanceof Headers) {
+    httpMetadata.forEach((value, key) => {
+      headers[key] = value;
+    });
+  } else {
+    const {
+      contentType,
+      contentLanguage,
+      contentDisposition,
+      contentEncoding,
+      cacheControl,
+      cacheExpiry,
+    } = httpMetadata as R2HTTPMetadata;
+    if (contentType) headers["Content-Type"] = contentType;
+    if (contentLanguage) headers["Content-Language"] = contentLanguage;
+    if (contentDisposition) headers["Content-Disposition"] = contentDisposition;
+    if (contentEncoding) headers["Content-Encoding"] = contentEncoding;
+    if (cacheControl) headers["Cache-Control"] = cacheControl;
+    if (cacheExpiry) headers.Expires = cacheExpiry.toUTCString();
+  }
+
+  return headers;
+}
+
+function mapHeadersToHttpMetadata(headers: Headers): R2HTTPMetadata {
+  return {
+    contentType: headers.get("Content-Type") ?? undefined,
+    contentLanguage: headers.get("Content-Language") ?? undefined,
+    contentDisposition: headers.get("Content-Disposition") ?? undefined,
+    contentEncoding: headers.get("Content-Encoding") ?? undefined,
+    cacheControl: headers.get("Cache-Control") ?? undefined,
+    cacheExpiry: headers.get("Expires")
+      ? new Date(headers.get("Expires")!)
+      : undefined,
+  };
+}
+
 export async function putObject(
   api: CloudflareApi,
   {
     bucketName,
     key,
     object,
+    options,
   }: {
     bucketName: string;
     key: string;
     object: PutObjectObject;
+    options?: Pick<R2PutOptions, "httpMetadata">;
   },
 ): Promise<Response> {
   // Using withExponentialBackoff for reliability
   return await withRetries(async () => {
+    const headers: Record<string, string> = {
+      "Content-Type": "application/octet-stream",
+      ...(options?.httpMetadata
+        ? mapHttpMetadataToHeaders(options?.httpMetadata)
+        : {}),
+    };
+
     const response = await api.put(
       `/accounts/${api.accountId}/r2/buckets/${bucketName}/objects/${key}`,
       object,
       {
-        headers: {
-          "Content-Type": "application/octet-stream",
-        },
+        headers,
       },
     );
     if (!response.ok) {

package/src/cloudflare/bun-spa/bun-spa.ts

@@ -0,0 +1,139 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Scope } from "../../scope.ts";
+import { exists } from "../../util/exists.ts";
+import type { Assets } from "../assets.ts";
+import type { Bindings } from "../bindings.ts";
+import {
+  extractStringAndSecretBindings,
+  unencryptSecrets,
+} from "../util/filter-env-bindings.ts";
+import {
+  spreadBuildProps,
+  spreadDevProps,
+  Website,
+  type WebsiteProps,
+} from "../website.ts";
+import type { Worker } from "../worker.ts";
+
+export interface BunSPAProps<B extends Bindings> extends WebsiteProps<B> {
+  frontend: string;
+  outDir?: string;
+}
+
+export type BunSPA<B extends Bindings> = B extends { ASSETS: any }
+  ? never
+  : Worker<B & { ASSETS: Assets }>;
+
+export async function BunSPA<B extends Bindings>(
+  id: string,
+  props: BunSPAProps<B>,
+): Promise<BunSPA<B>> {
+  const frontendPath = path.resolve(props.frontend);
+  if (!(await exists(frontendPath))) {
+    throw new Error(`Frontend path ${frontendPath} does not exist`);
+  }
+
+  const stats = await fs.stat(frontendPath);
+  if (!stats.isFile()) {
+    throw new Error(`Frontend path ${frontendPath} is not a file`);
+  }
+  const outDir = path.resolve(props.outDir ?? "dist/client");
+
+  if (props.assets) {
+    throw new Error("assets are not supported in BunSPA");
+  }
+
+  const scope = Scope.current;
+  console.log("creating website", outDir);
+  const website = await Website(id, {
+    spa: true,
+    ...props,
+    bindings: {
+      ...props.bindings,
+      // set NODE_ENV in worker appropriately if not already set
+      NODE_ENV:
+        (props.bindings?.NODE_ENV ?? scope.local)
+          ? "development"
+          : "production",
+    } as unknown as B,
+    assets: {
+      directory: path.resolve(outDir),
+    },
+    build: spreadBuildProps(
+      props,
+      `bun build '${frontendPath}' --outdir ${outDir}`,
+    ),
+  });
+
+  // in dev
+  if (scope.local) {
+    const cwd = props.cwd ?? process.cwd();
+    await validateBunfigToml(cwd);
+    const dev = spreadDevProps(
+      props,
+      `bun '${path.relative(cwd, frontendPath)}'`,
+    );
+    console.log("backend url", website.url);
+    const secrets = props.wrangler?.secrets ?? !props.wrangler?.path;
+    const env = {
+      ...(process.env ?? {}),
+      ...(props.env ?? {}),
+      ...extractStringAndSecretBindings(props.bindings ?? {}, secrets),
+    };
+    website.url = await scope.spawn(website.name, {
+      cmd: typeof dev === "string" ? dev : dev.command!,
+      cwd,
+      extract: (line) => {
+        const URL_REGEX =
+          /http:\/\/(localhost|0\.0\.0\.0|127\.0\.0\.1|\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}):\d+\/?/;
+        const match = line
+          .replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "")
+          .match(URL_REGEX);
+        if (match) {
+          return match[0];
+        }
+      },
+      env: {
+        ...unencryptSecrets(env ?? {}),
+        ...(typeof dev === "object" ? dev.env : {}),
+        FORCE_COLOR: "1",
+        ...process.env,
+        NODE_ENV: "development",
+        ALCHEMY_ROOT: Scope.current.rootDir,
+        PUBLIC_BACKEND_URL: website.url!,
+      },
+    });
+  }
+  return website;
+}
+
+async function validateBunfigToml(cwd: string): Promise<void> {
+  const bunfigPath = path.join(cwd, "bunfig.toml");
+
+  if (!(await exists(bunfigPath))) {
+    throw new Error(
+      "bunfig.toml is required for BunSPA to work correctly.\n\n" +
+        `Create ${bunfigPath} with the following content:\n\n` +
+        "[serve.static]\n" +
+        `env='PUBLIC_*'\n\n` +
+        "This allows Bun to expose PUBLIC_* environment variables to the frontend during development.",
+    );
+  }
+
+  const content = await fs.readFile(bunfigPath, "utf-8");
+  const config = Bun.TOML.parse(content) as Record<string, any>;
+
+  const hasServeStatic = config.serve?.static;
+  const hasEnvConfig = hasServeStatic && config.serve.static.env === "PUBLIC_*";
+
+  if (!hasServeStatic || !hasEnvConfig) {
+    throw new Error(
+      "bunfig.toml is missing required configuration for BunSPA.\n\n" +
+        `Add the following section to ${bunfigPath}:\n\n` +
+        "[serve.static]\n" +
+        `env='PUBLIC_*'\n\n` +
+        "This allows Bun to expose PUBLIC_* environment variables to the frontend during development.",
+    );
+  }
+}

package/src/cloudflare/compatibility-date.gen.ts

@@ -4,4 +4,4 @@
 /**
  * The default Cloudflare Workers compatibility date, set based on the latest workerd release at the time of build.
  */
-export const DEFAULT_COMPATIBILITY_DATE = "2025-09-27";
+export const DEFAULT_COMPATIBILITY_DATE = "2025-10-01";

package/src/cloudflare/container.ts

@@ -93,9 +93,28 @@ export interface ContainerProps
  * - `basic`: Basic production instances with standard resources
  * - `standard`: Standard production instances with enhanced resources
  *
+ * | Instance Type  | vCPU | Memory (Min) | Memory (Max) |
+ * |---------------|------|--------------|--------------|
+ * | lite          | 1/16 | 256 MiB      | 2 GB         |
+ * | basic         | 1/4  | 1 GiB        | 4 GB         |
+ * | standard-1    | 1/2  | 4 GiB        | 8 GB         |
+ * | standard-2    | 1    | 6 GiB        | 12 GB        |
+ * | standard-3    | 2    | 8 GiB        | 16 GB        |
+ * | standard-4    | 4    | 12 GiB       | 20 GB        |
+ *
  * @see https://developers.cloudflare.com/containers/pricing/
+ * @see https://developers.cloudflare.com/changelog/2025-10-01-new-container-instance-types/
  */
-export type InstanceType = "dev" | "basic" | "standard" | (string & {});
+export type InstanceType =
+  | "lite"
+  | "dev"
+  | "basic"
+  | "standard"
+  | "standard-1"
+  | "standard-2"
+  | "standard-3"
+  | "standard-4"
+  | (string & {});
 
 /**
  * Type guard to check if a binding is a Container binding.
@@ -1044,13 +1063,13 @@ export async function createContainerApplicationRollout(
   );
   const result = (await response.json()) as {
     result: CreateRolloutApplicationResponse;
-    errors: { message: string }[];
+    errors: { message: string; code: number }[];
   };
   if (response.ok) {
     return result.result;
   }
   throw Error(
-    `Failed to create container application rollout: ${result.errors.map((e: { message: string }) => e.message).join(", ")}`,
+    `Failed to create container application rollout: ${result.errors.map((e) => `[${e.code}] ${e.message}`).join(", ")}`,
   );
 }
 

package/src/cloudflare/index.ts

@@ -15,6 +15,7 @@ export * from "./bound.ts";
 export * from "./browser-rendering.ts";
 export * from "./bucket-object.ts";
 export * from "./bucket.ts";
+export * from "./bun-spa/bun-spa.ts";
 export * from "./certificate-pack.ts";
 export * from "./cloudflare-env-proxy.ts";
 export * from "./compatibility-date.gen.ts";

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

@@ -52,7 +52,9 @@ type RemoteBinding =
   | WorkerBindingService;
 
 type BaseWorkerOptions = {
-  [K in keyof miniflare.WorkerOptions]: K extends "compatibilityFlags"
+  [K in keyof miniflare.WorkerOptions]: K extends
+    | "compatibilityFlags"
+    | "routes"
     ? miniflare.WorkerOptions[K]
     : Exclude<miniflare.WorkerOptions[K], string[]>;
 };
@@ -70,11 +72,9 @@ export const buildWorkerOptions = async (
     compatibilityFlags: input.compatibilityFlags,
     unsafeDirectSockets: [
       // This matches the Wrangler configuration by exposing the default handler (e.g. `export default { fetch }`).
-      // However, unlike Wrangler, we set `proxy: false` to avoid the following error when connecting via a websocket:
-      // workerd/io/worker.c++:2164: info: uncaught exception; source = Uncaught (in promise); stack = TypeError: Invalid URL string.
       {
         entrypoint: "default",
-        proxy: false,
+        proxy: true,
       },
     ],
     containerEngine: {
@@ -85,6 +85,8 @@ export const buildWorkerOptions = async (
             : "unix:///var/run/docker.sock",
       },
     },
+    // This exposes the worker as a route that can be accessed by setting the MF-Route-Override header.
+    routes: [input.name],
   };
   for (const [key, binding] of Object.entries(input.bindings ?? {})) {
     if (typeof binding === "string") {

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

@@ -104,6 +104,8 @@ export class MiniflareController {
         // This is required to allow websites and other separate processes
         // to detect Alchemy-managed Durable Objects via the Wrangler dev registry.
         unsafeDevRegistryDurableObjectProxy: true,
+        // This exposes other handlers like `scheduled` and `email` via HTTP.
+        unsafeTriggerHandlers: true,
       };
       for (const worker of this.options.values()) {
         options.workers.push(worker);

package/src/cloudflare/miniflare/miniflare-worker-proxy.ts

@@ -13,7 +13,7 @@ export interface MiniflareWorkerProxy {
 export async function createMiniflareWorkerProxy(options: {
   port: number;
   transformRequest?: (request: RequestInfo) => void;
-  getWorkerName: (request: miniflare.Request) => string;
+  getWorkerName: (request: RequestInfo) => string;
   miniflare: miniflare.Miniflare;
   mode: "local" | "remote";
 }) {
@@ -31,10 +31,7 @@ export async function createMiniflareWorkerProxy(options: {
   });
   server.on("request", async (req, res) => {
     try {
-      const request = toMiniflareRequest(req);
-      const name = options.getWorkerName(request);
-      const worker = await options.miniflare.getWorker(name);
-      const response = await worker.fetch(request);
+      const response = await handleFetch(req);
       writeMiniflareResponseToNode(response, res);
     } catch (error) {
       console.error(error);
@@ -45,27 +42,53 @@ export async function createMiniflareWorkerProxy(options: {
     }
   });
 
-  const toMiniflareRequest = (req: http.IncomingMessage): miniflare.Request => {
+  const handleFetch = async (
+    req: http.IncomingMessage,
+  ): Promise<miniflare.Response> => {
     const info = parseIncomingMessage(req);
     options.transformRequest?.(info);
-    return new miniflare.Request(info.url, {
+
+    const name = options.getWorkerName(info);
+    info.headers.set("MF-Route-Override", name);
+
+    // Handle scheduled events.
+    // Wrangler exposes this as /__scheduled, but Miniflare exposes it as /cdn-cgi/handler/scheduled.
+    // https://developers.cloudflare.com/workers/runtime-apis/handlers/scheduled/#background
+    // https://github.com/cloudflare/workers-sdk/blob/7d53b9ab6b370944b7934ad51ebef43160c3c775/packages/wrangler/templates/middleware/middleware-scheduled.ts#L6
+    if (info.url.pathname === "/__scheduled") {
+      info.url.pathname = "/cdn-cgi/handler/scheduled";
+    }
+
+    const request = new miniflare.Request(info.url, {
       method: info.method,
       headers: info.headers,
       body: info.body,
       redirect: info.redirect,
       duplex: info.duplex,
     });
+    return await options.miniflare.dispatchFetch(request);
   };
 
   const createServerWebSocket = async (req: http.IncomingMessage) => {
-    const name = options.getWorkerName(toMiniflareRequest(req));
-    const target = await options.miniflare.unsafeGetDirectURL(name);
+    // Rewrite to Miniflare entry URL
+    const target = await options.miniflare.ready;
     const url = new URL(req.url ?? "/", target);
     url.protocol = url.protocol.replace("http", "ws");
+
     const protocols = req.headers["sec-websocket-protocol"]
       ?.split(",")
       .map((p) => p.trim());
-    const server = new WebSocket(url, protocols);
+
+    // Get worker name to set MF-Route-Override header
+    const info = parseIncomingMessage(req);
+    options.transformRequest?.(info);
+    const name = options.getWorkerName(info);
+
+    const server = new WebSocket(url, protocols, {
+      headers: {
+        "MF-Route-Override": name,
+      },
+    });
     await once(server, "open");
     return server;
   };
@@ -77,10 +100,8 @@ export async function createMiniflareWorkerProxy(options: {
   return {
     url,
     close: async () => {
-      await Promise.all([
-        new Promise((resolve) => server.close(resolve)),
-        new Promise((resolve) => wss.close(resolve)),
-      ]);
+      // If we await this while the `wss` server is open, the server will hang.
+      server.close();
     },
   };
 }
@@ -128,7 +149,13 @@ const writeMiniflareResponseToNode = (
 ) => {
   out.statusCode = res.status;
   res.headers.forEach((value, key) => {
-    out.setHeader(key, value);
+    // The `transfer-encoding` header prevents Cloudflare Tunnels from working because of the following error:
+    // Request failed error="Unable to reach the origin service. The service may be down or it may not be
+    // responding to traffic from cloudflared: net/http: HTTP/1.x transport connection broken: too many
+    // transfer encodings: [\"chunked\" \"chunked\"]"
+    if (key !== "transfer-encoding") {
+      out.setHeader(key, value);
+    }
   });
 
   if (res.body) {

package/src/cloudflare/permission-groups.ts

@@ -1,5 +1,5 @@
-import type { Context } from "../context.ts";
 import { Resource } from "../resource.ts";
+import { extractCloudflareResult } from "./api-response.ts";
 import { createCloudflareApi, type CloudflareApiOptions } from "./api.ts";
 
 /**
@@ -22,16 +22,6 @@ export interface PermissionGroup {
   scopes: string[];
 }
 
-/**
- * Response from the Cloudflare permission groups API
- */
-interface PermissionGroupsResponse {
-  result: PermissionGroup[];
-  success: boolean;
-  errors: any[];
-  messages: any[];
-}
-
 export type PermissionGroupName = R2PermissionGroups | (string & {});
 
 export type R2PermissionGroups =
@@ -86,7 +76,7 @@ export type PermissionGroups = {
  *
  * @example
  * // Get all permission groups including those for R2
- * const permissions = await PermissionGroups("cloudflare-permissions");
+ * const permissions = await PermissionGroups();
  *
  * // Use with AccountApiToken to create a token with proper permissions
  * const token = await AccountApiToken("r2-token", {
@@ -106,42 +96,24 @@ export type PermissionGroups = {
  *   ]
  * });
  */
-export const PermissionGroups = Resource(
-  "cloudflare::PermissionGroups",
-  async function (
-    this: Context<PermissionGroups>,
-    _id: string,
-    options: CloudflareApiOptions = {},
-  ): Promise<PermissionGroups> {
-    // Only create and update phases are supported
-    if (this.phase === "delete") {
-      return this.destroy();
-    }
-
-    // Initialize API client
-    const api = await createCloudflareApi(options);
-
-    // Fetch permission groups from Cloudflare API
-    const response = await api.get(
-      `/accounts/${api.accountId}/tokens/permission_groups`,
-    );
-
-    if (!response.ok) {
-      throw new Error(
-        `Failed to fetch permission groups: ${response.statusText}`,
-      );
-    }
-
-    const data = (await response.json()) as PermissionGroupsResponse;
+export async function PermissionGroups(
+  options: CloudflareApiOptions = {},
+): Promise<PermissionGroups> {
+  const api = await createCloudflareApi(options);
+  const result = await extractCloudflareResult<PermissionGroup[]>(
+    "fetch permission groups",
+    api.get(`/accounts/${api.accountId}/tokens/permission_groups`),
+  );
+  return Object.fromEntries(
+    result.map((group) => [group.name, group]),
+  ) as PermissionGroups;
+}
 
-    if (!data.success || !data.result) {
-      throw new Error(
-        `API returned error: ${data.errors?.[0]?.message || "Unknown error"}`,
-      );
-    }
+// we are deprecating the PermissionGroups resource (it is now just a function)
+Resource("cloudflare::PermissionGroups", async function (this) {
+  if (this.phase === "delete") {
+    return this.destroy();
+  }
 
-    return Object.fromEntries(
-      data.result.map((group) => [group.name, group]),
-    ) as PermissionGroups;
-  },
-);
+  throw new Error("Not implemented");
+});

package/src/cloudflare/redwood/redwood.ts

@@ -12,7 +12,7 @@ export type Redwood<B extends Bindings> = B extends { ASSETS: any }
   : Worker<B & { ASSETS: Assets }>;
 
 /**
- * Deploy a RedwoodJS application to Cloudflare Pages with automatically configured defaults.
+ * Deploy a RedwoodJS application to Cloudflare Workers with automatically configured defaults.
  *
  * This resource handles the deployment of RedwoodJS applications with optimized settings for
  * Cloudflare Workers, including proper build commands and compatibility flags.

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

@@ -1,30 +1,9 @@
-import type { GetPlatformProxyOptions } from "wrangler";
-import { dedent } from "../../util/dedent.ts";
+import type { PluginConfig } from "@cloudflare/vite-plugin";
+import alchemyVite from "../vite/plugin.ts";
 
-/**
- * TanStackStart server functions and middleware run in Node.js intead of Miniflare when using `vite dev`.
- *
- * This plugin polyfills the cloudflare:workers module & includes `process.env` during the dev server phase.
- *
- * @see https://developers.cloudflare.com/workers/framework-guides/web-apps/tanstack/#using-cloudflare-bindings
- */
-export default function alchemy(options: GetPlatformProxyOptions = {}) {
-  return {
-    name: "cloudflare-workers-dev-shim",
-    apply: "serve", // dev‑only
-    enforce: "pre",
-    resolveId(id: string) {
-      if (id === "cloudflare:workers") return id; // tell Vite we handled it
-    },
-    load(id: string) {
-      if (id === "cloudflare:workers") {
-        return dedent`
-          import { getCloudflareEnvProxy } from "alchemy/cloudflare";
-          export const env = await getCloudflareEnvProxy(${JSON.stringify(
-            options,
-          )});
-        `;
-      }
-    },
-  } as const;
+export default function alchemy(options: PluginConfig = {}) {
+  return alchemyVite({
+    viteEnvironment: { name: "ssr" },
+    ...options,
+  });
 }