@astrojs/cloudflare 13.0.0-beta.0 → 13.0.0-beta.10

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 { env } from "cloudflare:workers";
 import { transform } from "../utils/image-binding-transform.js";
 const prerender = false;
 const GET = async (ctx) => {
-  const { env } = await import("cloudflare:workers");
-  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.0";
+  const version = "13.0.0-beta.10";
   const localPrefix = `${colors.dim("\u2503")} Local    `;
   const networkPrefix = `${colors.dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);

package/dist/esbuild-plugin-astro-frontmatter.d.ts

@@ -0,0 +1,9 @@
+import type { DepOptimizationConfig } from 'vite';
+type ESBuildPlugin = NonNullable<NonNullable<DepOptimizationConfig['esbuildOptions']>['plugins']>[0];
+/**
+ * An esbuild plugin that extracts frontmatter from .astro files during
+ * dependency optimization scanning. This allows Vite to discover imports
+ * in the server-side frontmatter code.
+ */
+export declare function astroFrontmatterScanPlugin(): ESBuildPlugin;
+export {};

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

@@ -0,0 +1,30 @@
+import { readFile } from "node:fs/promises";
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---/;
+function astroFrontmatterScanPlugin() {
+  return {
+    name: "astro-frontmatter-scan",
+    setup(build) {
+      build.onLoad({ filter: /\.astro$/ }, async (args) => {
+        try {
+          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,
+              loader: "ts"
+            };
+          }
+        } catch {
+        }
+        return {
+          contents: "",
+          loader: "ts"
+        };
+      });
+    }
+  };
+}
+export {
+  astroFrontmatterScanPlugin
+};

package/dist/index.d.ts

@@ -1,41 +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;
-            }[];
-        };
-    };
-    /**
-     * Allow bundling cloudflare worker specific file types as importable modules. Defaults to true.
-     * When enabled, allows imports of '.wasm', '.bin', and '.txt' file types
-     *
-     * See https://developers.cloudflare.com/pages/functions/module-support/
-     * for reference on how these file types are exported
-     */
-    cloudflareModules?: boolean;
+    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.
@@ -56,25 +25,6 @@ export type Options = {
      * See https://developers.cloudflare.com/images/transform-images/bindings/ for more details.
      */
     imagesBindingName?: string;
-    /**
-     * This configuration option allows you to specify a custom entryPoint for your Cloudflare Worker.
-     * The entry point is the file that will be executed when your Worker is invoked.
-     * By default, this is set to `@astrojs/cloudflare/entrypoints/server.js` and `['default']`.
-     * @docs https://docs.astro.build/en/guides/integrations-guide/cloudflare/#workerEntryPoint
-     */
-    workerEntryPoint?: {
-        /**
-         * The path to the entry file. This should be a relative path from the root of your Astro project.
-         * @example`'src/worker.ts'`
-         * @docs https://docs.astro.build/en/guides/integrations-guide/cloudflare/#workerentrypointpath
-         */
-        path: string | URL;
-        /**
-         * Additional named exports to use for the entry file. Astro always includes the default export (`['default']`). If you need to have other top level named exports use this option.
-         * @example ['MyDurableObject', 'namedExport']
-         * @docs https://docs.astro.build/en/guides/integrations-guide/cloudflare/#workerentrypointnamedexports
-         */
-        namedExports?: 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,40 +1,54 @@
 import { createReadStream, existsSync, readFileSync } from "node:fs";
-import { appendFile, stat } from "node:fs/promises";
-import { createRequire } from "node:module";
+import { appendFile, rm, stat } from "node:fs/promises";
 import { createInterface } from "node:readline/promises";
-import { pathToFileURL } from "node:url";
 import { removeLeadingForwardSlash } from "@astrojs/internal-helpers/path";
 import { createRedirectsFromAstroRoutes, printAsRedirects } from "@astrojs/underscore-redirects";
 import { cloudflare as cfVitePlugin } from "@cloudflare/vite-plugin";
-import { cloudflareModuleLoader } from "./utils/cloudflare-module-loader.js";
-import { createRoutesFile, getParts } from "./utils/generate-routes-json.js";
-import { setImageConfig } from "./utils/image-config.js";
+import { astroFrontmatterScanPlugin } from "./esbuild-plugin-astro-frontmatter.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,
   DEFAULT_SESSION_KV_BINDING_NAME,
   DEFAULT_IMAGES_BINDING_NAME
 } from "./wrangler.js";
-import { parse } from "dotenv";
+import { parseEnv } from "node:util";
 import { sessionDrivers } from "astro/config";
-function createIntegration(args) {
+import { createCloudflarePrerenderer } from "./prerenderer.js";
+import { createRequire } from "node:module";
+function createIntegration({
+  imageService,
+  sessionKVBindingName = DEFAULT_SESSION_KV_BINDING_NAME,
+  imagesBindingName = DEFAULT_IMAGES_BINDING_NAME,
+  ...cloudflareOptions
+} = {}) {
   let _config;
-  let finalBuildOutput;
-  const cloudflareModulePlugin = cloudflareModuleLoader(
-    args?.cloudflareModules ?? true
-  );
   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(
@@ -48,27 +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,
+                  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),
-            serverEntry: "index.js",
             redirects: false
           },
           session,
           vite: {
             plugins: [
-              cfVitePlugin(cfPluginConfig),
-              // https://developers.cloudflare.com/pages/functions/module-support/
-              // Allows imports of '.wasm', '.bin', and '.txt' file types
-              cloudflareModulePlugin,
+              cfVitePlugin({ ...cfPluginConfig, viteEnvironment: { name: "ssr" } }),
               {
                 name: "@astrojs/cloudflare:cf-imports",
                 enforce: "pre",
@@ -84,8 +108,10 @@ function createIntegration(args) {
               {
                 name: "@astrojs/cloudflare:environment",
                 configEnvironment(environmentName, _options) {
-                  const isServerEnvironment = ["ssr", "prerender"].includes(environmentName);
-                  if (isServerEnvironment && _options.optimizeDeps?.noDiscovery === false) {
+                  const isServerEnvironment = ["astro", "ssr", "prerender"].includes(
+                    environmentName
+                  );
+                  if (isServerEnvironment && !_options.optimizeDeps?.noDiscovery) {
                     return {
                       optimizeDeps: {
                         include: [
@@ -96,7 +122,6 @@ function createIntegration(args) {
                           "astro > zod/v4",
                           "astro > zod/v4/core",
                           "astro > clsx",
-                          "astro > cssesc",
                           "astro > cookie",
                           "astro > devalue",
                           "astro > @oslojs/encoding",
@@ -105,20 +130,30 @@ function createIntegration(args) {
                           "astro > neotraverse/modern",
                           "astro > piccolore",
                           "astro/app",
+                          "astro/assets",
                           "astro/compiler-runtime"
                         ],
                         exclude: [
                           "unstorage/drivers/cloudflare-kv-binding",
                           "astro:*",
                           "virtual:astro:*",
-                          "virtual:astro-cloudflare:*"
-                        ]
+                          "virtual:astro-cloudflare:*",
+                          "virtual:@astrojs/*"
+                        ],
+                        esbuildOptions: {
+                          plugins: [astroFrontmatterScanPlugin()]
+                        }
                       }
                     };
                   } else if (environmentName === "client") {
                     return {
                       optimizeDeps: {
-                        include: ["astro/runtime/client/dev-toolbar/entrypoint.js"]
+                        include: ["astro/runtime/client/dev-toolbar/entrypoint.js"],
+                        // Workaround for https://github.com/vitejs/vite/issues/20867
+                        // When dependencies are discovered mid-request (e.g. a linked package
+                        // used with client:only), concurrent requests can fail with 504 because
+                        // the dep optimizer's metadata object gets replaced during `await info.processing`.
+                        ignoreOutdatedRequests: true
                       }
                     };
                   }
@@ -136,55 +171,54 @@ 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" />'
         });
-        let customWorkerEntryPoint;
-        if (args?.workerEntryPoint && typeof args.workerEntryPoint.path === "string") {
-          const require2 = createRequire(config.root);
-          try {
-            customWorkerEntryPoint = pathToFileURL(require2.resolve(args.workerEntryPoint.path));
-          } catch {
-            customWorkerEntryPoint = new URL(args.workerEntryPoint.path, config.root);
-          }
-        }
         setAdapter({
           name: "@astrojs/cloudflare",
-          serverEntrypoint: customWorkerEntryPoint ?? "@astrojs/cloudflare/entrypoints/server.js",
-          exports: [.../* @__PURE__ */ new Set(["default", ...args?.workerEntryPoint?.namedExports ?? []])],
           adapterFeatures: {
             edgeMiddleware: false,
             buildOutput: "server"
           },
+          entrypointResolution: "auto",
           previewEntrypoint: "@astrojs/cloudflare/entrypoints/preview",
           supportedAstroFeatures: {
             serverOutput: "stable",
             hybridOutput: "stable",
-            staticOutput: "unsupported",
+            staticOutput: "stable",
             i18nDomains: "experimental",
             sharpImageService: {
               support: "limited",
-              message: 'Cloudflare does not support sharp at runtime. However, you can configure `imageService: "compile"` to optimize images with sharp on prerendered pages during build time.',
-              // For explicitly set image services, we suppress the warning about sharp not being supported at runtime,
-              // inferring the user is aware of the limitations.
-              suppress: args?.imageService ? "all" : "default"
+              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: buildService === "custom" ? "default" : "all"
             },
             envGetSecret: "stable"
           }
@@ -193,7 +227,7 @@ function createIntegration(args) {
         if (existsSync(devVarsPath)) {
           try {
             const data = readFileSync(devVarsPath, "utf-8");
-            const parsed = parse(data);
+            const parsed = parseEnv(data);
             Object.assign(process.env, parsed);
           } catch {
             logger.error(
@@ -202,6 +236,19 @@ function createIntegration(args) {
           }
         }
       },
+      "astro:build:start": ({ setPrerenderer }) => {
+        setPrerenderer(
+          createCloudflarePrerenderer({
+            root: _config.root,
+            serverDir: _config.build.server,
+            clientDir: _config.build.client,
+            base: _config.base,
+            trailingSlash: _config.trailingSlash,
+            cfPluginConfig,
+            hasCompileImageService: buildService === "compile"
+          })
+        );
+      },
       "astro:build:setup": ({ vite, target }) => {
         if (target === "server") {
           vite.resolve ||= {};
@@ -215,14 +262,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));
@@ -249,26 +294,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(
@@ -277,7 +302,7 @@ function createIntegration(args) {
             )
           ),
           dir,
-          buildOutput: finalBuildOutput,
+          buildOutput: _isFullyStatic ? "static" : "server",
           assets
         });
         if (!trueRedirects.empty()) {
@@ -290,6 +315,10 @@ 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/info.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Re-exports utilities for use by astro add CLI.
+ * This provides a resolvable path from the user's project.
+ */
+export { getLocalWorkerdCompatibilityDate } from '@cloudflare/vite-plugin';

package/dist/info.js

@@ -0,0 +1,4 @@
+import { getLocalWorkerdCompatibilityDate } from "@cloudflare/vite-plugin";
+export {
+  getLocalWorkerdCompatibilityDate
+};

package/dist/prerender-types.d.ts

@@ -0,0 +1,32 @@
+import type { SerializedRouteData } from 'astro/app/manifest';
+/**
+ * A pathname with its serialized route data, used for prerendering over HTTP.
+ */
+interface SerializedPathWithRoute {
+    pathname: string;
+    route: SerializedRouteData;
+}
+/**
+ * Response from the /__astro_static_paths endpoint.
+ */
+export interface StaticPathsResponse {
+    paths: SerializedPathWithRoute[];
+}
+/**
+ * Request body for the /__astro_prerender endpoint.
+ */
+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

@@ -0,0 +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, cfPluginConfig, hasCompileImageService, }: CloudflarePrerendererOptions): AstroPrerenderer;
+export {};