@astrojs/cloudflare 13.0.0-beta.8 → 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.8";
+  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,9 +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;
+    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.
@@ -24,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

@@ -6,7 +6,10 @@ import { createRedirectsFromAstroRoutes, printAsRedirects } from "@astrojs/under
 import { cloudflare as cfVitePlugin } from "@cloudflare/vite-plugin";
 import { astroFrontmatterScanPlugin } from "./esbuild-plugin-astro-frontmatter.js";
 import { getParts } from "./utils/generate-routes-json.js";
-import { setImageConfig } from "./utils/image-config.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 _routes;
   let _isFullyStatic = false;
-  const sessionKVBindingName = args?.sessionKVBindingName ?? DEFAULT_SESSION_KV_BINDING_NAME;
-  const imagesBindingName = args?.imagesBindingName ?? DEFAULT_IMAGES_BINDING_NAME;
+  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,24 +62,29 @@ 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: {
             redirects: false
@@ -69,7 +92,7 @@ function createIntegration(args) {
           session,
           vite: {
             plugins: [
-              cfVitePlugin(cfPluginConfig),
+              cfVitePlugin({ ...cfPluginConfig, viteEnvironment: { name: "ssr" } }),
               {
                 name: "@astrojs/cloudflare:cf-imports",
                 enforce: "pre",
@@ -108,6 +131,7 @@ function createIntegration(args) {
                           "astro > neotraverse/modern",
                           "astro > piccolore",
                           "astro/app",
+                          "astro/assets",
                           "astro/compiler-runtime"
                         ],
                         exclude: [
@@ -148,12 +172,21 @@ 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));
@@ -186,7 +219,7 @@ function createIntegration(args) {
               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"
           }
@@ -211,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"
           })
         );
       },
@@ -228,9 +263,7 @@ 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
           };
         }

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/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",
-  "version": "13.0.0-beta.8",
+  "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.25.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.20260213.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.12",
+    "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
-};