@astrojs/cloudflare 13.0.0-beta.7 → 13.0.0-beta.9

package/dist/entrypoints/{image-service.js → image-service-external.js}

@@ -28,7 +28,7 @@ const service = {
     return imageEndpoint;
   }
 };
-var image_service_default = service;
+var image_service_external_default = service;
 export {
-  image_service_default as default
+  image_service_external_default as default
 };

package/dist/entrypoints/image-service-workerd.d.ts

@@ -0,0 +1,14 @@
+import type { LocalImageService } from 'astro';
+/**
+ * Workerd-compatible image service stub.
+ *
+ * Handles getURL/getHTMLAttributes/addStaticImage in the workerd prerender
+ * environment without importing Sharp. Actual image transforms are handled
+ * elsewhere:
+ * - `compile`: Sharp runs on the Node side via the generation pipeline
+ * - `cloudflare-binding`: image-transform-endpoint uses the IMAGES binding directly
+ *
+ * transform() is a passthrough so the generic endpoint can call it in dev.
+ */
+declare const service: LocalImageService;
+export default service;

package/dist/entrypoints/image-service-workerd.js

@@ -0,0 +1,11 @@
+import { baseService } from "astro/assets";
+const service = {
+  ...baseService,
+  async transform(inputBuffer, transform) {
+    return { data: inputBuffer, format: transform.format };
+  }
+};
+var image_service_workerd_default = service;
+export {
+  image_service_workerd_default as default
+};

package/dist/entrypoints/image-transform-endpoint.js

@@ -1,8 +1,27 @@
-import { transform } from "../utils/image-binding-transform.js";
 import { env } from "cloudflare:workers";
+import { transform } from "../utils/image-binding-transform.js";
 const prerender = false;
 const GET = async (ctx) => {
-  return transform(ctx.request.url, env.IMAGES, env.ASSETS);
+  const cache = caches.default;
+  if (cache) {
+    const cached = await cache.match(ctx.request.url);
+    if (cached) return cached;
+  }
+  const response = await transform(ctx.request.url, env.IMAGES, env.ASSETS);
+  if (!response.ok) return response;
+  const headers = new Headers(response.headers);
+  headers.set("Cache-Control", "public, max-age=31536000, immutable");
+  const cachedResponse = new Response(response.body, {
+    status: response.status,
+    headers
+  });
+  if (cache) {
+    const cfContext = ctx.locals.cfContext;
+    if (cfContext) {
+      cfContext.waitUntil(cache.put(ctx.request.url, cachedResponse.clone()));
+    }
+  }
+  return cachedResponse;
 };
 export {
   GET,

package/dist/entrypoints/preview.js

@@ -5,7 +5,6 @@ import { fileURLToPath } from "node:url";
 import { cloudflare as cfVitePlugin } from "@cloudflare/vite-plugin";
 import colors from "piccolore";
 import { performance } from "node:perf_hooks";
-import { cloudflareConfigCustomizer } from "../wrangler.js";
 const createPreviewServer = async ({
   logger,
   base,
@@ -17,10 +16,6 @@ const createPreviewServer = async ({
 }) => {
   const startServerTime = performance.now();
   let previewServer;
-  const cfPluginConfig = {
-    viteEnvironment: { name: "ssr" },
-    config: cloudflareConfigCustomizer()
-  };
   try {
     previewServer = await preview({
       configFile: false,
@@ -37,7 +32,9 @@ const createPreviewServer = async ({
         open: false,
         allowedHosts: []
       },
-      plugins: [cfVitePlugin(cfPluginConfig)]
+      plugins: [
+        cfVitePlugin({ ...globalThis.astroCloudflareOptions, viteEnvironment: { name: "ssr" } })
+      ]
     });
   } catch (err) {
     if (err instanceof Error) {
@@ -83,7 +80,7 @@ function serverStart({
   host,
   base
 }) {
-  const version = "13.0.0-beta.7";
+  const version = "13.0.0-beta.9";
   const localPrefix = `${colors.dim("\u2503")} Local    `;
   const networkPrefix = `${colors.dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);

package/dist/esbuild-plugin-astro-frontmatter.js

@@ -9,8 +9,9 @@ function astroFrontmatterScanPlugin() {
           const code = await readFile(args.path, "utf-8");
           const frontmatterMatch = FRONTMATTER_RE.exec(code);
           if (frontmatterMatch) {
+            const contents = frontmatterMatch[1].replace(/\breturn\b/g, "throw ");
             return {
-              contents: frontmatterMatch[1],
+              contents,
               loader: "ts"
             };
           }

package/dist/index.d.ts

@@ -1,33 +1,10 @@
+import { type PluginConfig } from '@cloudflare/vite-plugin';
 import type { AstroIntegration } from 'astro';
-import { type ImageService } from './utils/image-config.js';
+import { type ImageServiceConfig } from './utils/image-config.js';
 export type { Runtime } from './utils/handler.js';
-export type Options = {
+export interface Options extends Pick<PluginConfig, 'auxiliaryWorkers' | 'configPath' | 'inspectorPort' | 'persistState' | 'remoteBindings'> {
     /** Options for handling images. */
-    imageService?: ImageService;
-    /** Configuration for `_routes.json` generation. A _routes.json file controls when your Function is invoked. This file will include three different properties:
-     *
-     * - version: Defines the version of the schema. Currently there is only one version of the schema (version 1), however, we may add more in the future and aim to be backwards compatible.
-     * - include: Defines routes that will be invoked by Functions. Accepts wildcard behavior.
-     * - exclude: Defines routes that will not be invoked by Functions. Accepts wildcard behavior. `exclude` always take priority over `include`.
-     *
-     * Wildcards match any number of path segments (slashes). For example, `/users/*` will match everything after the `/users/` path.
-     *
-     */
-    routes?: {
-        /** Extend `_routes.json` */
-        extend: {
-            /** Paths which should be routed to the SSR function */
-            include?: {
-                /** Generally this is in pathname format, but does support wildcards, e.g. `/users`, `/products/*` */
-                pattern: string;
-            }[];
-            /** Paths which should be routed as static assets */
-            exclude?: {
-                /** Generally this is in pathname format, but does support wildcards, e.g. `/static`, `/assets/*`, `/images/avatar.jpg` */
-                pattern: string;
-            }[];
-        };
-    };
+    imageService?: ImageServiceConfig;
     /**
      * By default, Astro will be configured to use Cloudflare KV to store session data. The KV namespace
      * will be automatically provisioned when you deploy.
@@ -48,5 +25,6 @@ export type Options = {
      * See https://developers.cloudflare.com/images/transform-images/bindings/ for more details.
      */
     imagesBindingName?: string;
-};
-export default function createIntegration(args?: Options): AstroIntegration;
+    experimental?: Pick<NonNullable<PluginConfig['experimental']>, 'headersAndRedirectsDevModeSupport'>;
+}
+export default function createIntegration({ imageService, sessionKVBindingName, imagesBindingName, ...cloudflareOptions }?: Options): AstroIntegration;

package/dist/index.js

@@ -1,12 +1,15 @@
 import { createReadStream, existsSync, readFileSync } from "node:fs";
-import { appendFile, stat } from "node:fs/promises";
+import { appendFile, rm, stat } from "node:fs/promises";
 import { createInterface } from "node:readline/promises";
 import { removeLeadingForwardSlash } from "@astrojs/internal-helpers/path";
 import { createRedirectsFromAstroRoutes, printAsRedirects } from "@astrojs/underscore-redirects";
 import { cloudflare as cfVitePlugin } from "@cloudflare/vite-plugin";
 import { astroFrontmatterScanPlugin } from "./esbuild-plugin-astro-frontmatter.js";
-import { createRoutesFile, getParts } from "./utils/generate-routes-json.js";
-import { setImageConfig } from "./utils/image-config.js";
+import { getParts } from "./utils/generate-routes-json.js";
+import {
+  normalizeImageServiceConfig,
+  setImageConfig
+} from "./utils/image-config.js";
 import { createConfigPlugin } from "./vite-plugin-config.js";
 import {
   cloudflareConfigCustomizer,
@@ -16,21 +19,36 @@ import {
 import { parseEnv } from "node:util";
 import { sessionDrivers } from "astro/config";
 import { createCloudflarePrerenderer } from "./prerenderer.js";
-function createIntegration(args) {
+import { createRequire } from "node:module";
+function createIntegration({
+  imageService,
+  sessionKVBindingName = DEFAULT_SESSION_KV_BINDING_NAME,
+  imagesBindingName = DEFAULT_IMAGES_BINDING_NAME,
+  ...cloudflareOptions
+} = {}) {
   let _config;
-  let finalBuildOutput;
   let _routes;
-  const sessionKVBindingName = args?.sessionKVBindingName ?? DEFAULT_SESSION_KV_BINDING_NAME;
-  const imagesBindingName = args?.imagesBindingName ?? DEFAULT_IMAGES_BINDING_NAME;
+  let _isFullyStatic = false;
+  let cfPluginConfig;
+  const { buildService, runtimeService } = normalizeImageServiceConfig(imageService);
+  const needsImagesBinding = runtimeService === "cloudflare-binding";
   return {
     name: "@astrojs/cloudflare",
     hooks: {
       "astro:config:setup": ({ command, config, updateConfig, logger, addWatchFile }) => {
+        if (!!process.versions.webcontainer) {
+          throw new Error("`workerd` does not run on Stackblitz.");
+        }
         let session = config.session;
-        if (args?.imageService === "cloudflare-binding") {
+        const isCompile = buildService === "compile";
+        if (needsImagesBinding) {
           logger.info(
             `Enabling image processing with Cloudflare Images for production with the "${imagesBindingName}" Images binding.`
           );
+        } else if (isCompile) {
+          logger.info(
+            `Enabling compile-time image optimization. Images will be pre-optimized at build time.`
+          );
         }
         if (!session?.driver) {
           logger.info(
@@ -44,34 +62,37 @@ function createIntegration(args) {
             ttl: session?.ttl
           };
         }
-        const cfPluginConfig = {
-          viteEnvironment: { name: "ssr" },
+        const needsImagesBindingForDev = isCompile && command === "dev";
+        cfPluginConfig = {
           config: cloudflareConfigCustomizer({
-            sessionKVBindingName: args?.sessionKVBindingName,
-            imagesBindingName: args?.imageService === "cloudflare-binding" ? args?.imagesBindingName : false
+            sessionKVBindingName,
+            imagesBindingName: needsImagesBinding || needsImagesBindingForDev ? imagesBindingName : false
           }),
           experimental: {
             prerenderWorker: {
               config(_, { entryWorkerConfig }) {
                 return {
                   ...entryWorkerConfig,
-                  // This is the Vite environment name used for prerendering
-                  name: "prerender"
+                  name: "prerender",
+                  ...needsImagesBinding && !entryWorkerConfig.images && {
+                    images: { binding: imagesBindingName }
+                  }
                 };
               }
             }
           }
         };
+        if (command === "preview") {
+          globalThis.astroCloudflareOptions = cfPluginConfig;
+        }
         updateConfig({
           build: {
-            client: new URL(`./client/`, config.outDir),
-            server: new URL("./_worker.js/", config.outDir),
             redirects: false
           },
           session,
           vite: {
             plugins: [
-              cfVitePlugin(cfPluginConfig),
+              cfVitePlugin({ ...cfPluginConfig, viteEnvironment: { name: "ssr" } }),
               {
                 name: "@astrojs/cloudflare:cf-imports",
                 enforce: "pre",
@@ -110,6 +131,7 @@ function createIntegration(args) {
                           "astro > neotraverse/modern",
                           "astro > piccolore",
                           "astro/app",
+                          "astro/assets",
                           "astro/compiler-runtime"
                         ],
                         exclude: [
@@ -150,22 +172,32 @@ function createIntegration(args) {
                 }
               },
               createConfigPlugin({
-                sessionKVBindingName
+                sessionKVBindingName,
+                compileImageConfig: isCompile && command !== "dev" ? {
+                  base: config.base,
+                  assetsPrefix: typeof config.build.assetsPrefix === "string" ? config.build.assetsPrefix : void 0,
+                  imageServiceEntrypoint: "@astrojs/cloudflare/image-service-workerd",
+                  buildAssets: config.build.assets ?? "_astro"
+                } : null
               })
             ]
           },
-          image: setImageConfig(args?.imageService ?? "compile", config.image, command, logger)
+          image: setImageConfig(imageService, config.image, command, logger)
         });
+        if (cloudflareOptions.configPath) {
+          addWatchFile(createRequire(import.meta.url).resolve(cloudflareOptions.configPath));
+        }
         addWatchFile(new URL("./wrangler.toml", config.root));
         addWatchFile(new URL("./wrangler.json", config.root));
         addWatchFile(new URL("./wrangler.jsonc", config.root));
       },
       "astro:routes:resolved": ({ routes }) => {
         _routes = routes;
+        const nonInternalRoutes = routes.filter((route) => route.origin !== "internal");
+        _isFullyStatic = nonInternalRoutes.length > 0 && nonInternalRoutes.every((route) => route.isPrerendered);
       },
-      "astro:config:done": ({ setAdapter, config, buildOutput, injectTypes, logger }) => {
+      "astro:config:done": ({ setAdapter, config, injectTypes, logger }) => {
         _config = config;
-        finalBuildOutput = buildOutput;
         injectTypes({
           filename: "cloudflare.d.ts",
           content: '/// <reference types="@astrojs/cloudflare/types.d.ts" />'
@@ -176,18 +208,18 @@ function createIntegration(args) {
             edgeMiddleware: false,
             buildOutput: "server"
           },
-          entryType: "self",
+          entrypointResolution: "auto",
           previewEntrypoint: "@astrojs/cloudflare/entrypoints/preview",
           supportedAstroFeatures: {
             serverOutput: "stable",
             hybridOutput: "stable",
-            staticOutput: "unsupported",
+            staticOutput: "stable",
             i18nDomains: "experimental",
             sharpImageService: {
               support: "limited",
               message: "When using a custom image service, ensure it is compatible with the Cloudflare Workers runtime.",
               // Only 'custom' could potentially use sharp at runtime.
-              suppress: args?.imageService === "custom" ? "default" : "all"
+              suppress: buildService === "custom" ? "default" : "all"
             },
             envGetSecret: "stable"
           }
@@ -212,7 +244,9 @@ function createIntegration(args) {
             serverDir: _config.build.server,
             clientDir: _config.build.client,
             base: _config.base,
-            trailingSlash: _config.trailingSlash
+            trailingSlash: _config.trailingSlash,
+            cfPluginConfig,
+            hasCompileImageService: buildService === "compile"
           })
         );
       },
@@ -229,14 +263,12 @@ function createIntegration(args) {
           vite.build.rollupOptions.output.banner ||= "globalThis.process ??= {}; globalThis.process.env ??= {};";
           vite.define = {
             "process.env": "process.env",
-            "globalThis.__ASTRO_IMAGES_BINDING_NAME": JSON.stringify(
-              args?.imagesBindingName ?? "IMAGES"
-            ),
+            "globalThis.__ASTRO_IMAGES_BINDING_NAME": JSON.stringify(imagesBindingName),
             ...vite.define
           };
         }
       },
-      "astro:build:done": async ({ pages, dir, logger, assets }) => {
+      "astro:build:done": async ({ dir, logger, assets }) => {
         let redirectsExists = false;
         try {
           const redirectsStat = await stat(new URL("./_redirects", _config.build.client));
@@ -263,26 +295,6 @@ function createIntegration(args) {
             }
           }
         }
-        let routesExists = false;
-        try {
-          const routesStat = await stat(new URL("./_routes.json", _config.build.client));
-          if (routesStat.isFile()) {
-            routesExists = true;
-          }
-        } catch (_error) {
-          routesExists = false;
-        }
-        if (!routesExists) {
-          await createRoutesFile(
-            _config,
-            logger,
-            _routes,
-            pages,
-            redirects,
-            args?.routes?.extend?.include,
-            args?.routes?.extend?.exclude
-          );
-        }
         const trueRedirects = createRedirectsFromAstroRoutes({
           config: _config,
           routeToDynamicTargetMap: new Map(
@@ -291,7 +303,7 @@ function createIntegration(args) {
             )
           ),
           dir,
-          buildOutput: finalBuildOutput,
+          buildOutput: _isFullyStatic ? "static" : "server",
           assets
         });
         if (!trueRedirects.empty()) {
@@ -304,6 +316,9 @@ function createIntegration(args) {
             logger.error("Failed to write _redirects file");
           }
         }
+        if (_isFullyStatic) {
+          await rm(_config.build.server, { recursive: true, force: true });
+        }
         delete process.env.CLOUDFLARE_VITE_BUILD;
       }
     }

package/dist/prerender-types.d.ts

@@ -19,4 +19,14 @@ export interface PrerenderRequest {
     url: string;
     routeData: SerializedRouteData;
 }
+export interface SerializedStaticImageEntry {
+    originalPath: string;
+    originalSrcPath: string | undefined;
+    transforms: Array<{
+        hash: string;
+        finalPath: string;
+        transform: Record<string, any>;
+    }>;
+}
+export type StaticImagesResponse = SerializedStaticImageEntry[];
 export {};

package/dist/prerenderer.d.ts

@@ -1,14 +1,17 @@
 import type { AstroConfig, AstroPrerenderer } from 'astro';
+import { type PluginConfig } from '@cloudflare/vite-plugin';
 interface CloudflarePrerendererOptions {
     root: AstroConfig['root'];
     serverDir: AstroConfig['build']['server'];
     clientDir: AstroConfig['build']['client'];
     base: AstroConfig['base'];
     trailingSlash: AstroConfig['trailingSlash'];
+    cfPluginConfig: PluginConfig;
+    hasCompileImageService: boolean;
 }
 /**
  * Creates a prerenderer that uses Cloudflare's workerd runtime via a preview server.
  * This allows prerendering to happen in the same runtime that will serve the pages.
  */
-export declare function createCloudflarePrerenderer({ root, serverDir, clientDir, base, trailingSlash, }: CloudflarePrerendererOptions): AstroPrerenderer;
+export declare function createCloudflarePrerenderer({ root, serverDir, clientDir, base, trailingSlash, cfPluginConfig, hasCompileImageService, }: CloudflarePrerendererOptions): AstroPrerenderer;
 export {};

package/dist/prerenderer.js

@@ -2,15 +2,20 @@ import { preview } from "vite";
 import { fileURLToPath } from "node:url";
 import { mkdir } from "node:fs/promises";
 import { cloudflare as cfVitePlugin } from "@cloudflare/vite-plugin";
-import { cloudflareConfigCustomizer } from "./wrangler.js";
 import { serializeRouteData, deserializeRouteData } from "astro/app/manifest";
-import { STATIC_PATHS_ENDPOINT, PRERENDER_ENDPOINT } from "./utils/prerender-constants.js";
+import {
+  STATIC_PATHS_ENDPOINT,
+  PRERENDER_ENDPOINT,
+  STATIC_IMAGES_ENDPOINT
+} from "./utils/prerender-constants.js";
 function createCloudflarePrerenderer({
   root,
   serverDir,
   clientDir,
   base,
-  trailingSlash
+  trailingSlash,
+  cfPluginConfig,
+  hasCompileImageService
 }) {
   let previewServer;
   let serverUrl;
@@ -18,10 +23,6 @@ function createCloudflarePrerenderer({
     name: "@astrojs/cloudflare:prerenderer",
     async setup() {
       await mkdir(clientDir, { recursive: true });
-      const cfPluginConfig = {
-        viteEnvironment: { name: "prerender" },
-        config: cloudflareConfigCustomizer()
-      };
       previewServer = await preview({
         configFile: false,
         base,
@@ -36,7 +37,7 @@ function createCloudflarePrerenderer({
           // Let the OS pick a free port
           open: false
         },
-        plugins: [cfVitePlugin(cfPluginConfig)]
+        plugins: [cfVitePlugin({ ...cfPluginConfig, viteEnvironment: { name: "prerender" } })]
       });
       const address = previewServer.httpServer.address();
       if (address && typeof address === "object") {
@@ -75,6 +76,33 @@ function createCloudflarePrerenderer({
       });
       return response;
     },
+    collectStaticImages: hasCompileImageService ? async () => {
+      const response = await fetch(`${serverUrl}${STATIC_IMAGES_ENDPOINT}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" }
+      });
+      if (!response.ok) {
+        throw new Error(
+          `Failed to get static images from the Cloudflare prerender server (${response.status}: ${response.statusText}).`
+        );
+      }
+      const entries = await response.json();
+      const { default: sharpService } = await import("astro/assets/services/sharp");
+      globalThis.astroAsset ??= {};
+      globalThis.astroAsset.imageService = sharpService;
+      const staticImages = /* @__PURE__ */ new Map();
+      for (const entry of entries) {
+        const transforms = /* @__PURE__ */ new Map();
+        for (const t of entry.transforms) {
+          transforms.set(t.hash, { finalPath: t.finalPath, transform: t.transform });
+        }
+        staticImages.set(entry.originalPath, {
+          originalSrcPath: entry.originalSrcPath,
+          transforms
+        });
+      }
+      return staticImages;
+    } : void 0,
     async teardown() {
       if (previewServer) {
         await previewServer.close();

package/dist/utils/generate-routes-json.d.ts

@@ -1,9 +1,2 @@
-import type { AstroConfig, AstroIntegrationLogger, IntegrationResolvedRoute, RoutePart } from 'astro';
+import type { RoutePart } from 'astro';
 export declare function getParts(part: string): RoutePart[];
-export declare function createRoutesFile(_config: AstroConfig, logger: AstroIntegrationLogger, routes: IntegrationResolvedRoute[], pages: {
-    pathname: string;
-}[], redirects: IntegrationResolvedRoute['segments'][], includeExtends: {
-    pattern: string;
-}[] | undefined, excludeExtends: {
-    pattern: string;
-}[] | undefined): Promise<void>;

package/dist/utils/generate-routes-json.js

@@ -1,13 +1,3 @@
-import { existsSync } from "node:fs";
-import { writeFile } from "node:fs/promises";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import {
-  prependForwardSlash,
-  removeLeadingForwardSlash,
-  removeTrailingForwardSlash
-} from "@astrojs/internal-helpers/path";
-import { glob } from "tinyglobby";
 const ROUTE_DYNAMIC_SPLIT = /\[(.+?\(.+?\)|.+?)\]/;
 const ROUTE_SPREAD = /^\.{3}.+$/;
 function getParts(part) {
@@ -27,199 +17,6 @@ function getParts(part) {
   });
   return result;
 }
-async function writeRoutesFileToOutDir(_config, logger, include, exclude) {
-  try {
-    await writeFile(
-      new URL("./_routes.json", _config.outDir),
-      JSON.stringify(
-        {
-          version: 1,
-          include,
-          exclude
-        },
-        null,
-        2
-      ),
-      "utf-8"
-    );
-  } catch (_error) {
-    logger.error("There was an error writing the '_routes.json' file to the output directory.");
-  }
-}
-function segmentsToCfSyntax(segments, _config) {
-  const pathSegments = [];
-  if (removeLeadingForwardSlash(removeTrailingForwardSlash(_config.base)).length > 0) {
-    pathSegments.push(removeLeadingForwardSlash(removeTrailingForwardSlash(_config.base)));
-  }
-  for (const segment of segments.flat()) {
-    if (segment.dynamic) pathSegments.push("*");
-    else pathSegments.push(segment.content);
-  }
-  return pathSegments;
-}
-class TrieNode {
-  children = /* @__PURE__ */ new Map();
-  isEndOfPath = false;
-  hasWildcardChild = false;
-}
-class PathTrie {
-  root;
-  returnHasWildcard = false;
-  constructor() {
-    this.root = new TrieNode();
-  }
-  insert(thisPath) {
-    let node = this.root;
-    for (const segment of thisPath) {
-      if (segment === "*") {
-        node.hasWildcardChild = true;
-        break;
-      }
-      if (!node.children.has(segment)) {
-        node.children.set(segment, new TrieNode());
-      }
-      node = node.children.get(segment);
-    }
-    node.isEndOfPath = true;
-  }
-  /**
-   * Depth-first search (dfs), traverses the "graph"  segment by segment until the end or wildcard (*).
-   * It makes sure that all necessary paths are returned, but not paths with an existing wildcard prefix.
-   * e.g. if we have a path like /foo/* and /foo/bar, we only want to return /foo/*
-   */
-  dfs(node, thisPath, allPaths) {
-    if (node.hasWildcardChild) {
-      this.returnHasWildcard = true;
-      allPaths.push([...thisPath, "*"]);
-      return;
-    }
-    if (node.isEndOfPath) {
-      allPaths.push([...thisPath]);
-    }
-    for (const [segment, childNode] of node.children) {
-      this.dfs(childNode, [...thisPath, segment], allPaths);
-    }
-  }
-  /**
-   * The reduce function is used to remove unnecessary paths from the trie.
-   * It receives a trie node to compare with the current node.
-   */
-  reduce(compNode, node) {
-    if (node.hasWildcardChild || compNode.hasWildcardChild) return;
-    for (const [segment, childNode] of node.children) {
-      if (childNode.children.size === 0) continue;
-      const compChildNode = compNode.children.get(segment);
-      if (compChildNode === void 0) {
-        childNode.hasWildcardChild = true;
-        continue;
-      }
-      this.reduce(compChildNode, childNode);
-    }
-  }
-  reduceAllPaths(compTrie) {
-    this.reduce(compTrie.root, this.root);
-    return this;
-  }
-  getAllPaths() {
-    const allPaths = [];
-    this.dfs(this.root, [], allPaths);
-    return [allPaths, this.returnHasWildcard];
-  }
-}
-async function createRoutesFile(_config, logger, routes, pages, redirects, includeExtends, excludeExtends) {
-  const includePaths = [];
-  const excludePaths = [];
-  const assetsPath = segmentsToCfSyntax(
-    [
-      [{ content: _config.build.assets, dynamic: false, spread: false }],
-      [{ content: "", dynamic: true, spread: false }]
-    ],
-    _config
-  );
-  excludePaths.push(assetsPath);
-  for (const redirect of redirects) {
-    excludePaths.push(segmentsToCfSyntax(redirect, _config));
-  }
-  if (existsSync(fileURLToPath(_config.publicDir))) {
-    const staticFiles = await glob(`**/*`, {
-      cwd: fileURLToPath(_config.publicDir),
-      dot: true
-    });
-    for (const staticFile of staticFiles) {
-      if (["_headers", "_redirects", "_routes.json"].includes(staticFile)) continue;
-      const staticPath = staticFile;
-      const segments = removeLeadingForwardSlash(staticPath).split(path.sep).filter(Boolean).map((s) => {
-        return getParts(s);
-      });
-      excludePaths.push(segmentsToCfSyntax(segments, _config));
-    }
-  }
-  let hasPrerendered404 = false;
-  for (const route of routes) {
-    const convertedPath = segmentsToCfSyntax(route.segments, _config);
-    if (route.pathname === "/404" && route.isPrerendered === true) hasPrerendered404 = true;
-    switch (route.type) {
-      case "page":
-        if (route.isPrerendered === false) includePaths.push(convertedPath);
-        break;
-      case "endpoint":
-        if (route.isPrerendered === false) includePaths.push(convertedPath);
-        else excludePaths.push(convertedPath);
-        break;
-      case "redirect":
-        excludePaths.push(convertedPath);
-        break;
-      default:
-        includePaths.push(convertedPath);
-        break;
-    }
-  }
-  for (const page of pages) {
-    if (page.pathname === "404") hasPrerendered404 = true;
-    const pageSegments = removeLeadingForwardSlash(page.pathname).split(path.posix.sep).filter(Boolean).map((s) => {
-      return getParts(s);
-    });
-    excludePaths.push(segmentsToCfSyntax(pageSegments, _config));
-  }
-  const includeTrie = new PathTrie();
-  for (const includePath of includePaths) {
-    includeTrie.insert(includePath);
-  }
-  const excludeTrie = new PathTrie();
-  for (const excludePath of excludePaths) {
-    if (excludePath[0] === "*") continue;
-    excludeTrie.insert(excludePath);
-  }
-  const [deduplicatedIncludePaths, includedPathsHaveWildcard] = includeTrie.reduceAllPaths(excludeTrie).getAllPaths();
-  const [deduplicatedExcludePaths, _excludedPathsHaveWildcard] = excludeTrie.reduceAllPaths(includeTrie).getAllPaths();
-  const CLOUDFLARE_COMBINED_LIMIT = 100;
-  const AUTOMATIC_INCLUDE_RULES_COUNT = deduplicatedIncludePaths.length;
-  const EXTENDED_INCLUDE_RULES_COUNT = includeExtends?.length ?? 0;
-  const INCLUDE_RULES_COUNT = AUTOMATIC_INCLUDE_RULES_COUNT + EXTENDED_INCLUDE_RULES_COUNT;
-  const AUTOMATIC_EXCLUDE_RULES_COUNT = deduplicatedExcludePaths.length;
-  const EXTENDED_EXCLUDE_RULES_COUNT = excludeExtends?.length ?? 0;
-  const EXCLUDE_RULES_COUNT = AUTOMATIC_EXCLUDE_RULES_COUNT + EXTENDED_EXCLUDE_RULES_COUNT;
-  const OPTION2_TOTAL_COUNT = INCLUDE_RULES_COUNT + (includedPathsHaveWildcard ? EXCLUDE_RULES_COUNT : 0);
-  if (!hasPrerendered404 || OPTION2_TOTAL_COUNT > CLOUDFLARE_COMBINED_LIMIT) {
-    await writeRoutesFileToOutDir(
-      _config,
-      logger,
-      ["/*"].concat(includeExtends?.map((entry) => entry.pattern) ?? []),
-      deduplicatedExcludePaths.map((thisPath) => `${prependForwardSlash(thisPath.join("/"))}`).slice(
-        0,
-        CLOUDFLARE_COMBINED_LIMIT - EXTENDED_INCLUDE_RULES_COUNT - EXTENDED_EXCLUDE_RULES_COUNT - 1
-      ).concat(excludeExtends?.map((entry) => entry.pattern) ?? [])
-    );
-  } else {
-    await writeRoutesFileToOutDir(
-      _config,
-      logger,
-      deduplicatedIncludePaths.map((thisPath) => `${prependForwardSlash(thisPath.join("/"))}`).concat(includeExtends?.map((entry) => entry.pattern) ?? []),
-      includedPathsHaveWildcard ? deduplicatedExcludePaths.map((thisPath) => `${prependForwardSlash(thisPath.join("/"))}`).concat(excludeExtends?.map((entry) => entry.pattern) ?? []) : []
-    );
-  }
-}
 export {
-  createRoutesFile,
   getParts
 };

package/dist/utils/handler.js

@@ -1,5 +1,9 @@
 import { env as globalEnv } from "cloudflare:workers";
-import { sessionKVBindingName, isPrerender } from "virtual:astro-cloudflare:config";
+import {
+  sessionKVBindingName,
+  compileImageConfig,
+  isPrerender
+} from "virtual:astro-cloudflare:config";
 import { createApp } from "astro/app/entrypoint";
 import { setGetEnv } from "astro/env/setup";
 import { createGetEnv } from "../utils/env.js";
@@ -7,18 +11,27 @@ import {
   isStaticPathsRequest,
   isPrerenderRequest,
   handleStaticPathsRequest,
-  handlePrerenderRequest
+  handlePrerenderRequest,
+  isStaticImagesRequest,
+  handleStaticImagesRequest
 } from "./prerender.js";
 setGetEnv(createGetEnv(globalEnv));
 const app = createApp();
 async function handle(request, env, context) {
   if (isPrerender) {
+    if (compileImageConfig) {
+      const { installAddStaticImage } = await import("./static-image-collection.js");
+      installAddStaticImage(compileImageConfig);
+    }
     if (isStaticPathsRequest(request)) {
       return handleStaticPathsRequest(app);
     }
     if (isPrerenderRequest(request)) {
       return handlePrerenderRequest(app, request);
     }
+    if (isStaticImagesRequest(request)) {
+      return handleStaticImagesRequest();
+    }
   }
   const { pathname: requestPathname } = new URL(request.url);
   if (env[sessionKVBindingName]) {

package/dist/utils/image-binding-transform.js

@@ -13,17 +13,25 @@ async function transform(rawUrl, images, assets) {
     return new Response(null, { status: 404 });
   }
   const input = images.input(content.body);
-  const format = url.searchParams.get("f");
-  if (!format || !["avif", "webp", "jpeg"].includes(format)) {
-    return new Response(`The "${format}" format is not supported`, { status: 400 });
+  const supportedFormats = {
+    jpeg: "image/jpeg",
+    jpg: "image/jpeg",
+    png: "image/png",
+    gif: "image/gif",
+    webp: "image/webp",
+    avif: "image/avif"
+  };
+  const outputFormat = supportedFormats[url.searchParams.get("f") ?? ""];
+  if (!outputFormat) {
+    return new Response(`Unsupported format: ${url.searchParams.get("f")}`, { status: 400 });
   }
   return (await input.transform({
-    width: url.searchParams.has("w") ? parseInt(url.searchParams.get("w")) : void 0,
-    height: url.searchParams.has("h") ? parseInt(url.searchParams.get("h")) : void 0,
+    width: url.searchParams.has("w") ? Number.parseInt(url.searchParams.get("w")) : void 0,
+    height: url.searchParams.has("h") ? Number.parseInt(url.searchParams.get("h")) : void 0,
     // `quality` is documented, but doesn't appear to work in manual testing...
     // quality: url.searchParams.get('q'),
     fit: url.searchParams.get("fit")
-  }).output({ format: `image/${format}` })).response();
+  }).output({ format: outputFormat })).response();
 }
 export {
   transform

package/dist/utils/image-config.d.ts

@@ -1,8 +1,19 @@
 import type { AstroConfig, AstroIntegrationLogger, HookParameters } from 'astro';
-export type ImageService = 'passthrough' | 'cloudflare' | 'cloudflare-binding' | 'compile' | 'custom';
-export declare function setImageConfig(service: ImageService, config: AstroConfig['image'], command: HookParameters<'astro:config:setup'>['command'], logger: AstroIntegrationLogger): {
+export type ImageServiceMode = 'passthrough' | 'cloudflare' | 'cloudflare-binding' | 'compile' | 'custom';
+export type ImageServiceConfig = ImageServiceMode | {
+    build: 'compile';
+    runtime?: 'passthrough' | 'cloudflare-binding';
+};
+/** Normalize string | compound config into separate build/runtime modes. */
+export declare function normalizeImageServiceConfig(config: ImageServiceConfig | undefined): {
+    buildService: ImageServiceMode;
+    runtimeService: ImageServiceMode;
+};
+export declare function setImageConfig(service: ImageServiceConfig | undefined, config: AstroConfig['image'], command: HookParameters<'astro:config:setup'>['command'], logger: AstroIntegrationLogger): {
     service: import("astro").ImageServiceConfig<Record<string, any>>;
     endpoint: {
+        entrypoint: string;
+    } | {
         route: string;
         entrypoint?: string | undefined;
     };
@@ -19,9 +30,11 @@ export declare function setImageConfig(service: ImageService, config: AstroConfi
     objectPosition?: string | undefined;
     breakpoints?: number[] | undefined;
 } | {
-    service: import("astro").ImageServiceConfig<Record<string, any>>;
+    service: {
+        entrypoint: string;
+    };
     endpoint: {
-        entrypoint: string | undefined;
+        entrypoint: string;
     };
     domains: string[];
     remotePatterns: {

package/dist/utils/image-config.js

@@ -1,16 +1,37 @@
-import { passthroughImageService, sharpImageService } from "astro/config";
+import { passthroughImageService } from "astro/config";
+function normalizeImageServiceConfig(config) {
+  if (!config || typeof config === "string") {
+    const mode = config ?? "cloudflare-binding";
+    return {
+      buildService: mode,
+      runtimeService: mode === "compile" ? "passthrough" : mode
+    };
+  }
+  return {
+    buildService: "compile",
+    runtimeService: config.runtime ?? "passthrough"
+  };
+}
+const GENERIC_ENDPOINT = { entrypoint: "astro/assets/endpoint/generic" };
+const WORKERD_IMAGE_SERVICE = { entrypoint: "@astrojs/cloudflare/image-service-workerd" };
 function setImageConfig(service, config, command, logger) {
-  switch (service) {
+  const { buildService, runtimeService } = normalizeImageServiceConfig(service);
+  switch (buildService) {
     case "passthrough":
-      return { ...config, service: passthroughImageService() };
+      return {
+        ...config,
+        service: passthroughImageService(),
+        endpoint: command === "dev" ? GENERIC_ENDPOINT : config.endpoint
+      };
     case "cloudflare":
       return {
         ...config,
-        service: command === "dev" ? sharpImageService() : { entrypoint: "@astrojs/cloudflare/image-service" }
+        service: { entrypoint: "@astrojs/cloudflare/image-service" }
       };
     case "cloudflare-binding":
       return {
         ...config,
+        service: WORKERD_IMAGE_SERVICE,
         endpoint: {
           entrypoint: "@astrojs/cloudflare/image-transform-endpoint"
         }
@@ -18,10 +39,10 @@ function setImageConfig(service, config, command, logger) {
     case "compile":
       return {
         ...config,
-        service: sharpImageService(),
-        endpoint: {
-          entrypoint: command === "dev" ? void 0 : "@astrojs/cloudflare/image-endpoint"
-        }
+        service: WORKERD_IMAGE_SERVICE,
+        // Dev: IMAGES binding (via Cloudflare Vite plugin) for real transforms.
+        // Build: endpoint depends on runtime - `cloudflare-binding` uses IMAGES, `passthrough` uses generic.
+        endpoint: command === "dev" || runtimeService === "cloudflare-binding" ? { entrypoint: "@astrojs/cloudflare/image-transform-endpoint" } : GENERIC_ENDPOINT
       };
     case "custom":
       return { ...config };
@@ -36,5 +57,6 @@ function setImageConfig(service, config, command, logger) {
   }
 }
 export {
+  normalizeImageServiceConfig,
   setImageConfig
 };

package/dist/utils/prerender-constants.d.ts

@@ -5,3 +5,5 @@
 export declare const STATIC_PATHS_ENDPOINT = "/__astro_static_paths";
 /** Internal endpoint for rendering a specific page during prerendering */
 export declare const PRERENDER_ENDPOINT = "/__astro_prerender";
+/** Internal endpoint for fetching static images collected in workerd during `compile` builds */
+export declare const STATIC_IMAGES_ENDPOINT = "/__astro_static_images";

package/dist/utils/prerender-constants.js

@@ -1,6 +1,8 @@
 const STATIC_PATHS_ENDPOINT = "/__astro_static_paths";
 const PRERENDER_ENDPOINT = "/__astro_prerender";
+const STATIC_IMAGES_ENDPOINT = "/__astro_static_images";
 export {
   PRERENDER_ENDPOINT,
+  STATIC_IMAGES_ENDPOINT,
   STATIC_PATHS_ENDPOINT
 };

package/dist/utils/prerender.d.ts

@@ -32,3 +32,6 @@ export declare function handleStaticPathsRequest(app: BaseApp): Promise<Response
  * Handles a prerender request, rendering the specified page.
  */
 export declare function handlePrerenderRequest(app: BaseApp, request: Request): Promise<Response>;
+export declare function isStaticImagesRequest(request: Request): boolean;
+/** Serializes the global staticImages map collected in workerd back to the Node-side build. */
+export declare function handleStaticImagesRequest(): Response;

package/dist/utils/prerender.js

@@ -1,6 +1,10 @@
 import { serializeRouteData, deserializeRouteData } from "astro/app/manifest";
 import { StaticPaths } from "astro:static-paths";
-import { STATIC_PATHS_ENDPOINT, PRERENDER_ENDPOINT } from "./prerender-constants.js";
+import {
+  STATIC_PATHS_ENDPOINT,
+  PRERENDER_ENDPOINT,
+  STATIC_IMAGES_ENDPOINT
+} from "./prerender-constants.js";
 function isStaticPathsRequest(request) {
   const { pathname } = new URL(request.url);
   return pathname === STATIC_PATHS_ENDPOINT && request.method === "POST";
@@ -35,9 +39,38 @@ async function handlePrerenderRequest(app, request) {
   });
   return app.render(prerenderRequest, { routeData });
 }
+function isStaticImagesRequest(request) {
+  const { pathname } = new URL(request.url);
+  return pathname === STATIC_IMAGES_ENDPOINT && request.method === "POST";
+}
+function handleStaticImagesRequest() {
+  const staticImages = globalThis.astroAsset?.staticImages;
+  if (!staticImages || staticImages.size === 0) {
+    return new Response("[]", {
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  const entries = [];
+  for (const [originalPath, { originalSrcPath, transforms }] of staticImages) {
+    const serializedTransforms = [];
+    for (const [hash, { finalPath, transform }] of transforms) {
+      serializedTransforms.push({
+        hash,
+        finalPath,
+        transform
+      });
+    }
+    entries.push({ originalPath, originalSrcPath, transforms: serializedTransforms });
+  }
+  return new Response(JSON.stringify(entries), {
+    headers: { "Content-Type": "application/json" }
+  });
+}
 export {
   handlePrerenderRequest,
+  handleStaticImagesRequest,
   handleStaticPathsRequest,
   isPrerenderRequest,
+  isStaticImagesRequest,
   isStaticPathsRequest
 };

package/dist/utils/static-image-collection.d.ts

@@ -0,0 +1,7 @@
+import type { CompileImageConfig } from '../vite-plugin-config.js';
+/**
+ * Installs `globalThis.astroAsset.addStaticImage` for use inside workerd
+ * during prerendering. This mirrors the logic in astro's vite-plugin-assets.ts
+ * but uses only workerd-safe APIs (no node: imports).
+ */
+export declare function installAddStaticImage(config: CompileImageConfig): void;

package/dist/utils/static-image-collection.js

@@ -0,0 +1,51 @@
+import { joinPaths, prependForwardSlash, removeBase } from "@astrojs/internal-helpers/path";
+import { hashTransform, propsToFilename } from "astro/assets";
+import { isESMImportedImage } from "astro/assets/utils";
+function installAddStaticImage(config) {
+  if (globalThis.astroAsset?.addStaticImage) return;
+  if (!globalThis.astroAsset) {
+    globalThis.astroAsset = { referencedImages: /* @__PURE__ */ new Set() };
+  }
+  globalThis.astroAsset.addStaticImage = (options, hashProperties, _originalFSPath) => {
+    if (!globalThis.astroAsset.staticImages) {
+      globalThis.astroAsset.staticImages = /* @__PURE__ */ new Map();
+    }
+    const ESMImportedImageSrc = isESMImportedImage(options.src) ? options.src.src : options.src;
+    const finalOriginalPath = removeBase(
+      removeBase(ESMImportedImageSrc, config.base),
+      config.assetsPrefix ?? ""
+    );
+    const hash = hashTransform(options, config.imageServiceEntrypoint, hashProperties);
+    let finalFilePath;
+    let transformsForPath = globalThis.astroAsset.staticImages.get(finalOriginalPath);
+    const transformForHash = transformsForPath?.transforms.get(hash);
+    if (transformsForPath && transformForHash) {
+      finalFilePath = transformForHash.finalPath;
+    } else {
+      finalFilePath = prependForwardSlash(
+        joinPaths(
+          isESMImportedImage(options.src) ? "" : config.buildAssets,
+          prependForwardSlash(propsToFilename(finalOriginalPath, options, hash))
+        )
+      );
+      if (!transformsForPath) {
+        globalThis.astroAsset.staticImages.set(finalOriginalPath, {
+          originalSrcPath: _originalFSPath,
+          transforms: /* @__PURE__ */ new Map()
+        });
+        transformsForPath = globalThis.astroAsset.staticImages.get(finalOriginalPath);
+      }
+      transformsForPath.transforms.set(hash, {
+        finalPath: finalFilePath,
+        transform: options
+      });
+    }
+    if (config.assetsPrefix) {
+      return encodeURI(joinPaths(config.assetsPrefix, finalFilePath));
+    }
+    return encodeURI(prependForwardSlash(joinPaths(config.base, finalFilePath)));
+  };
+}
+export {
+  installAddStaticImage
+};

package/dist/vite-plugin-config.d.ts

@@ -1,6 +1,13 @@
 import type { PluginOption } from 'vite';
+export interface CompileImageConfig {
+    base: string;
+    assetsPrefix: string | undefined;
+    imageServiceEntrypoint: string;
+    buildAssets: string;
+}
 export interface Config {
     sessionKVBindingName: string;
+    compileImageConfig: CompileImageConfig | null;
     isPrerender: boolean;
 }
 export declare function createConfigPlugin(config: Omit<Config, 'isPrerender'>): PluginOption;

package/dist/wrangler.d.ts

@@ -3,12 +3,12 @@ export declare const DEFAULT_SESSION_KV_BINDING_NAME = "SESSION";
 export declare const DEFAULT_IMAGES_BINDING_NAME = "IMAGES";
 export declare const DEFAULT_ASSETS_BINDING_NAME = "ASSETS";
 interface CloudflareConfigOptions {
-    sessionKVBindingName?: string;
-    imagesBindingName?: string | false;
+    sessionKVBindingName: string | undefined;
+    imagesBindingName: string | false | undefined;
 }
 /**
  * Returns a config customizer that sets up the Astro Cloudflare defaults.
  * Sets the main entrypoint and adds bindings for auto-provisioning.
  */
-export declare function cloudflareConfigCustomizer(options?: CloudflareConfigOptions): PluginConfig['config'];
+export declare function cloudflareConfigCustomizer(options: CloudflareConfigOptions): PluginConfig['config'];
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@astrojs/cloudflare",
-  "description": "Deploy your site to Cloudflare Workers/Pages",
-  "version": "13.0.0-beta.7",
+  "description": "Deploy your site to Cloudflare Workers",
+  "version": "13.0.0-beta.9",
   "type": "module",
   "types": "./dist/index.d.ts",
   "author": "withastro",
@@ -23,9 +23,9 @@
     "./entrypoints/server": "./dist/entrypoints/server.js",
     "./entrypoints/preview": "./dist/entrypoints/preview.js",
     "./entrypoints/server.js": "./dist/entrypoints/server.js",
-    "./image-service": "./dist/entrypoints/image-service.js",
-    "./image-endpoint": "./dist/entrypoints/image-endpoint.js",
+    "./image-service": "./dist/entrypoints/image-service-external.js",
     "./image-transform-endpoint": "./dist/entrypoints/image-transform-endpoint.js",
+    "./image-service-workerd": "./dist/entrypoints/image-service-workerd.js",
     "./handler": "./dist/utils/handler.js",
     "./types.d.ts": "./types.d.ts",
     "./package.json": "./package.json"
@@ -35,7 +35,7 @@
     "types.d.ts"
   ],
   "dependencies": {
-    "@cloudflare/vite-plugin": "^1.23.0",
+    "@cloudflare/vite-plugin": "^1.25.2",
     "piccolore": "^0.1.3",
     "tinyglobby": "^0.2.15",
     "vite": "^7.3.1",
@@ -47,11 +47,11 @@
     "wrangler": "^4.61.1"
   },
   "devDependencies": {
-    "@cloudflare/workers-types": "^4.20260131.0",
+    "@cloudflare/workers-types": "^4.20260228.0",
     "@types/node": "^25.2.2",
     "cheerio": "1.2.0",
-    "devalue": "^5.6.2",
-    "astro": "6.0.0-beta.11",
+    "devalue": "^5.6.3",
+    "astro": "6.0.0-beta.15",
     "astro-scripts": "0.0.14"
   },
   "publishConfig": {

package/dist/entrypoints/image-endpoint.d.ts

@@ -1,3 +0,0 @@
-import type { APIRoute } from 'astro';
-export declare const prerender = false;
-export declare const GET: APIRoute;

package/dist/entrypoints/image-endpoint.js

@@ -1,29 +0,0 @@
-import { imageConfig } from "astro:assets";
-import { isRemotePath } from "@astrojs/internal-helpers/path";
-import { isRemoteAllowed } from "@astrojs/internal-helpers/remote";
-const prerender = false;
-const GET = (ctx) => {
-  const href = ctx.url.searchParams.get("href");
-  if (!href) {
-    return new Response("Missing 'href' query parameter", {
-      status: 400,
-      statusText: "Missing 'href' query parameter"
-    });
-  }
-  if (isRemotePath(href)) {
-    if (isRemoteAllowed(href, imageConfig) === false) {
-      return new Response("Forbidden", { status: 403 });
-    } else {
-      return Response.redirect(href, 302);
-    }
-  }
-  const proxied = new URL(href, ctx.url.origin);
-  if (proxied.origin !== ctx.url.origin) {
-    return new Response("Forbidden", { status: 403 });
-  }
-  return fetch(proxied);
-};
-export {
-  GET,
-  prerender
-};