@astrojs/cloudflare 13.0.0-alpha.0 → 13.0.0-alpha.1

package/dist/entrypoints/image-service.js

@@ -20,7 +20,6 @@ const service = {
       return options.src;
     }
     const imageEndpoint = joinPaths(
-      // @ts-expect-error Can't recognise import.meta.env
       import.meta.env.BASE_URL,
       "/cdn-cgi/image",
       resizingParams.join(","),

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

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

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

@@ -0,0 +1,10 @@
+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);
+};
+export {
+  GET,
+  prerender
+};

package/dist/entrypoints/preview.d.ts

@@ -0,0 +1,11 @@
+import type { CreatePreviewServer } from 'astro';
+import { type ResolvedServerUrls } from 'vite';
+declare const createPreviewServer: CreatePreviewServer;
+/** Display server host and startup time */
+export declare function serverStart({ startupTime, resolvedUrls, host, base, }: {
+    startupTime: number;
+    resolvedUrls: ResolvedServerUrls;
+    host: string | undefined;
+    base: string;
+}): string;
+export { createPreviewServer as default };

package/dist/entrypoints/preview.js

@@ -0,0 +1,137 @@
+import {
+  preview
+} from "vite";
+import { fileURLToPath } from "node:url";
+import { cloudflare as cfVitePlugin } from "@cloudflare/vite-plugin";
+import colors from "piccolore";
+import { performance } from "node:perf_hooks";
+import { hasWranglerConfig, defaultCloudflareConfig } from "../wrangler.js";
+import { copyFileSync, existsSync } from "node:fs";
+const createPreviewServer = async ({
+  logger,
+  base,
+  outDir,
+  headers,
+  port,
+  host,
+  createCodegenDir,
+  root
+}) => {
+  const startServerTime = performance.now();
+  let previewServer;
+  let cfPluginConfig = { viteEnvironment: { name: "ssr" } };
+  if (!hasWranglerConfig(outDir)) {
+    cfPluginConfig.config = defaultCloudflareConfig();
+    const codegenDir = createCodegenDir();
+    const devVarsPath = new URL(".dev.vars", outDir);
+    const devVarsCodegenPath = new URL(".dev.vars", codegenDir);
+    if (existsSync(devVarsPath)) {
+      copyFileSync(devVarsPath, devVarsCodegenPath);
+    }
+  }
+  try {
+    previewServer = await preview({
+      configFile: false,
+      base,
+      appType: "mpa",
+      build: {
+        outDir: fileURLToPath(outDir)
+      },
+      root: fileURLToPath(root),
+      preview: {
+        host,
+        port,
+        headers,
+        open: false,
+        allowedHosts: []
+      },
+      plugins: [cfVitePlugin(cfPluginConfig)]
+    });
+  } catch (err) {
+    if (err instanceof Error) {
+      logger.error(err.stack || err.message);
+    }
+    throw err;
+  }
+  const customShortcuts = [
+    // Disable default Vite shortcuts that don't work well with Astro
+    { key: "r", description: "" },
+    { key: "u", description: "" },
+    { key: "c", description: "" },
+    { key: "s", description: "" }
+  ];
+  previewServer.bindCLIShortcuts({
+    customShortcuts
+  });
+  logger.info(
+    serverStart({
+      startupTime: performance.now() - startServerTime,
+      resolvedUrls: previewServer.resolvedUrls ?? { local: [], network: [] },
+      host,
+      base
+    })
+  );
+  function closed() {
+    return new Promise((resolve, reject) => {
+      previewServer.httpServer.addListener("close", resolve);
+      previewServer.httpServer.addListener("error", reject);
+    });
+  }
+  return {
+    host,
+    port,
+    closed,
+    server: previewServer.httpServer,
+    stop: previewServer.close.bind(previewServer)
+  };
+};
+function serverStart({
+  startupTime,
+  resolvedUrls,
+  host,
+  base
+}) {
+  const version = "13.0.0-alpha.1";
+  const localPrefix = `${colors.dim("\u2503")} Local    `;
+  const networkPrefix = `${colors.dim("\u2503")} Network  `;
+  const emptyPrefix = " ".repeat(11);
+  const localUrlMessages = resolvedUrls.local.map((url, i) => {
+    return `${i === 0 ? localPrefix : emptyPrefix}${colors.cyan(new URL(url).origin + base)}`;
+  });
+  const networkUrlMessages = resolvedUrls.network.map((url, i) => {
+    return `${i === 0 ? networkPrefix : emptyPrefix}${colors.cyan(new URL(url).origin + base)}`;
+  });
+  if (networkUrlMessages.length === 0) {
+    const networkLogging = getNetworkLogging(host);
+    if (networkLogging === "host-to-expose") {
+      networkUrlMessages.push(`${networkPrefix}${colors.dim("use --host to expose")}`);
+    } else if (networkLogging === "visible") {
+      networkUrlMessages.push(`${networkPrefix}${colors.dim("unable to find network to expose")}`);
+    }
+  }
+  const messages = [
+    "",
+    `${colors.bgGreen(colors.bold(` astro `))} ${colors.green(`v${version}`)} ${colors.dim(`ready in`)} ${Math.round(
+      startupTime
+    )} ${colors.dim("ms")}`,
+    "",
+    ...localUrlMessages,
+    ...networkUrlMessages,
+    ""
+  ];
+  return messages.filter((msg) => typeof msg === "string").join("\n");
+}
+const LOCAL_IP_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1"]);
+function getNetworkLogging(host) {
+  if (!host) {
+    return "host-to-expose";
+  } else if (typeof host === "string" && LOCAL_IP_HOSTS.has(host)) {
+    return "none";
+  } else {
+    return "visible";
+  }
+}
+export {
+  createPreviewServer as default,
+  serverStart
+};

package/dist/entrypoints/server.d.ts

@@ -1,14 +1,5 @@
-import type { ExecutionContext, ExportedHandlerFetchHandler } from '@cloudflare/workers-types';
-import type { SSRManifest } from 'astro';
-type Env = {
-    [key: string]: unknown;
-    ASSETS: {
-        fetch: (req: Request | string) => Promise<Response>;
-    };
+import { handle } from '../utils/handler.js';
+declare const _default: {
+    fetch: typeof handle;
 };
-export declare function createExports(manifest: SSRManifest): {
-    default: {
-        fetch: (request: Parameters<ExportedHandlerFetchHandler>[0], env: Env, context: ExecutionContext) => Promise<Response>;
-    };
-};
-export {};
+export default _default;

package/dist/entrypoints/server.js

@@ -1,12 +1,7 @@
-import { App } from "astro/app";
 import { handle } from "../utils/handler.js";
-function createExports(manifest) {
-  const app = new App(manifest);
-  const fetch = async (request, env, context) => {
-    return await handle(manifest, app, request, env, context);
-  };
-  return { default: { fetch } };
-}
+var server_default = {
+  fetch: handle
+};
 export {
-  createExports
+  server_default as default
 };

package/dist/index.d.ts

@@ -1,5 +1,4 @@
 import type { AstroIntegration } from 'astro';
-import { type GetPlatformProxyOptions } from 'wrangler';
 import { type ImageService } from './utils/image-config.js';
 export type { Runtime } from './utils/handler.js';
 export type Options = {
@@ -29,13 +28,6 @@ export type Options = {
             }[];
         };
     };
-    /**
-     * Proxy configuration for the platform.
-     */
-    platformProxy?: GetPlatformProxyOptions & {
-        /** Toggle the proxy. Default `undefined`, which equals to `true`. */
-        enabled?: boolean;
-    };
     /**
      * Allow bundling cloudflare worker specific file types as importable modules. Defaults to true.
      * When enabled, allows imports of '.wasm', '.bin', and '.txt' file types
@@ -70,6 +62,22 @@ export type Options = {
      *
      */
     sessionKVBindingName?: string;
+    /**
+     * When configured as `cloudflare-binding`, the Cloudflare Images binding will be used to transform images:
+     * - https://developers.cloudflare.com/images/transform-images/bindings/
+     *
+     * By default, this will use the "IMAGES" binding name, but this can be customised in your `wrangler.json`:
+     *
+     * ```json
+     * {
+     *   "images": {
+     *     "binding": "IMAGES" // <-- this should match `imagesBindingName`
+     *   }
+     * }
+     * ```
+     *
+     */
+    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.

package/dist/index.js

@@ -1,4 +1,4 @@
-import { createReadStream } from "node:fs";
+import { createReadStream, copyFileSync, existsSync, readFileSync } from "node:fs";
 import { appendFile, stat } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { createInterface } from "node:readline/promises";
@@ -9,29 +9,16 @@ import {
   removeLeadingForwardSlash
 } from "@astrojs/internal-helpers/path";
 import { createRedirectsFromAstroRoutes, printAsRedirects } from "@astrojs/underscore-redirects";
-import { AstroError } from "astro/errors";
-import { defaultClientConditions } from "vite";
-import { getPlatformProxy } from "wrangler";
-import {
-  cloudflareModuleLoader
-} from "./utils/cloudflare-module-loader.js";
-import { createGetEnv } from "./utils/env.js";
+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 { createConfigPlugin } from "./vite-plugin-config.js";
+import { hasWranglerConfig, defaultCloudflareConfig } from "./wrangler.js";
+import { parse } from "dotenv";
 function wrapWithSlashes(path) {
   return prependForwardSlash(appendForwardSlash(path));
 }
-function setProcessEnv(config, env) {
-  const getEnv = createGetEnv(env);
-  if (config.env?.schema) {
-    for (const key of Object.keys(config.env.schema)) {
-      const value = getEnv(key);
-      if (value !== void 0) {
-        process.env[key] = value;
-      }
-    }
-  }
-}
 function createIntegration(args) {
   let _config;
   let finalBuildOutput;
@@ -49,9 +36,18 @@ function createIntegration(args) {
         updateConfig,
         logger,
         addWatchFile,
-        addMiddleware
+        createCodegenDir
       }) => {
         let session = config.session;
+        if (args?.imageService === "cloudflare-binding") {
+          const bindingName = args?.imagesBindingName ?? "IMAGES";
+          logger.info(
+            `Enabling image processing with Cloudflare Images for production with the "${bindingName}" Images binding.`
+          );
+          logger.info(
+            `If you see the error "Invalid binding \`${bindingName}\`" in your build output, you need to add the binding to your wrangler config file.`
+          );
+        }
         if (!session?.driver) {
           logger.info(
             `Enabling sessions with Cloudflare KV with the "${SESSION_KV_BINDING_NAME}" KV binding.`
@@ -68,6 +64,16 @@ function createIntegration(args) {
             }
           };
         }
+        const cfPluginConfig = { viteEnvironment: { name: "ssr" } };
+        if (!hasWranglerConfig(config.root)) {
+          cfPluginConfig.config = defaultCloudflareConfig();
+          const codegenDir = createCodegenDir();
+          const devVarsPath = new URL(".dev.vars", config.root);
+          const devVarsCodegenPath = new URL(".dev.vars", codegenDir);
+          if (existsSync(devVarsPath)) {
+            copyFileSync(devVarsPath, devVarsCodegenPath);
+          }
+        }
         updateConfig({
           build: {
             client: new URL(`.${wrapWithSlashes(config.base)}`, config.outDir),
@@ -78,11 +84,12 @@ function createIntegration(args) {
           session,
           vite: {
             plugins: [
+              cfVitePlugin(cfPluginConfig),
               // https://developers.cloudflare.com/pages/functions/module-support/
               // Allows imports of '.wasm', '.bin', and '.txt' file types
               cloudflareModulePlugin,
               {
-                name: "vite:cf-imports",
+                name: "@astrojs/cloudflare:cf-imports",
                 enforce: "pre",
                 resolveId(source) {
                   if (source.startsWith("cloudflare:")) {
@@ -90,29 +97,72 @@ function createIntegration(args) {
                   }
                   return null;
                 }
-              }
+              },
+              {
+                name: "@astrojs/cloudflare:environment",
+                configEnvironment(environmentName, _options) {
+                  const isServerEnvironment = ["ssr", "prerender"].includes(environmentName);
+                  if (isServerEnvironment && _options.optimizeDeps?.noDiscovery === false) {
+                    return {
+                      optimizeDeps: {
+                        include: [
+                          "astro",
+                          "astro/runtime/**",
+                          "astro > html-escaper",
+                          "astro > mrmime",
+                          "astro > zod/v4",
+                          "astro > zod/v4/core",
+                          "astro > clsx",
+                          "astro > cssesc",
+                          "astro > cookie",
+                          "astro > devalue",
+                          "astro > @oslojs/encoding",
+                          "astro > es-module-lexer",
+                          "astro > unstorage",
+                          "astro > neotraverse/modern"
+                        ],
+                        exclude: [
+                          "unstorage/drivers/cloudflare-kv-binding",
+                          "astro:toolbar:internal",
+                          "virtual:astro:middleware"
+                        ]
+                      }
+                    };
+                  }
+                }
+              },
+              {
+                enforce: "post",
+                name: "@astrojs/cloudflare:cf-externals",
+                applyToEnvironment: (environment) => environment.name === "ssr",
+                config(conf) {
+                  if (conf.ssr) {
+                    conf.ssr.external = void 0;
+                    conf.ssr.noExternal = true;
+                  }
+                }
+              },
+              createConfigPlugin({
+                sessionKVBindingName: SESSION_KV_BINDING_NAME
+              })
             ]
           },
           image: setImageConfig(args?.imageService ?? "compile", config.image, command, logger)
         });
-        if (args?.platformProxy?.configPath) {
-          addWatchFile(new URL(args.platformProxy.configPath, config.root));
-        } else {
-          addWatchFile(new URL("./wrangler.toml", config.root));
-          addWatchFile(new URL("./wrangler.json", config.root));
-          addWatchFile(new URL("./wrangler.jsonc", config.root));
-        }
-        addMiddleware({
-          entrypoint: "@astrojs/cloudflare/entrypoints/middleware.js",
-          order: "pre"
-        });
+        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;
       },
-      "astro:config:done": ({ setAdapter, config, buildOutput }) => {
+      "astro:config:done": ({ setAdapter, config, buildOutput, 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);
@@ -130,6 +180,7 @@ function createIntegration(args) {
             edgeMiddleware: false,
             buildOutput: "server"
           },
+          previewEntrypoint: "@astrojs/cloudflare/entrypoints/preview",
           supportedAstroFeatures: {
             serverOutput: "stable",
             hybridOutput: "stable",
@@ -145,75 +196,40 @@ function createIntegration(args) {
             envGetSecret: "stable"
           }
         });
-      },
-      "astro:server:setup": async ({ server }) => {
-        if ((args?.platformProxy?.enabled ?? true) === true) {
-          const platformProxy = await getPlatformProxy(args?.platformProxy);
-          server.httpServer?.on("close", async () => {
-            await platformProxy.dispose();
-          });
-          setProcessEnv(_config, platformProxy.env);
-          globalThis.__env__ ??= {};
-          globalThis.__env__[SESSION_KV_BINDING_NAME] = platformProxy.env[SESSION_KV_BINDING_NAME];
-          const clientLocalsSymbol = Symbol.for("astro.locals");
-          server.middlewares.use(async function middleware(req, _res, next) {
-            Reflect.set(req, clientLocalsSymbol, {
-              runtime: {
-                env: platformProxy.env,
-                cf: platformProxy.cf,
-                caches: platformProxy.caches,
-                ctx: {
-                  waitUntil: (promise) => platformProxy.ctx.waitUntil(promise),
-                  // Currently not available: https://developers.cloudflare.com/pages/platform/known-issues/#pages-functions
-                  passThroughOnException: () => {
-                    throw new AstroError(
-                      "`passThroughOnException` is currently not available in Cloudflare Pages. See https://developers.cloudflare.com/pages/platform/known-issues/#pages-functions."
-                    );
-                  }
-                }
-              }
-            });
-            next();
-          });
+        const devVarsPath = new URL(".dev.vars", config.root);
+        if (existsSync(devVarsPath)) {
+          try {
+            const data = readFileSync(devVarsPath, "utf-8");
+            const parsed = parse(data);
+            Object.assign(process.env, parsed);
+          } catch {
+            logger.error(
+              `Unable to parse .dev.vars, variables will not be available to your application.`
+            );
+          }
         }
       },
       "astro:build:setup": ({ vite, target }) => {
         if (target === "server") {
           vite.resolve ||= {};
           vite.resolve.alias ||= {};
-          const aliases = [
-            {
-              find: "react-dom/server",
-              replacement: "react-dom/server.browser"
-            }
-          ];
-          if (Array.isArray(vite.resolve.alias)) {
-            vite.resolve.alias = [...vite.resolve.alias, ...aliases];
-          } else {
-            for (const alias of aliases) {
-              vite.resolve.alias[alias.find] = alias.replacement;
-            }
-          }
           vite.ssr ||= {};
-          vite.ssr.resolve ||= {};
-          vite.ssr.resolve.conditions ||= [...defaultClientConditions];
-          vite.ssr.resolve.conditions.push("workerd", "worker");
-          vite.ssr.target = "webworker";
           vite.ssr.noExternal = true;
           vite.build ||= {};
           vite.build.rollupOptions ||= {};
           vite.build.rollupOptions.output ||= {};
+          vite.build.rollupOptions.external = ["sharp"];
           vite.build.rollupOptions.output.banner ||= "globalThis.process ??= {}; globalThis.process.env ??= {};";
           vite.define = {
             "process.env": "process.env",
-            // Allows the request handler to know what the binding name is
-            "globalThis.__ASTRO_SESSION_BINDING_NAME": JSON.stringify(SESSION_KV_BINDING_NAME),
+            "globalThis.__ASTRO_IMAGES_BINDING_NAME": JSON.stringify(
+              args?.imagesBindingName ?? "IMAGES"
+            ),
             ...vite.define
           };
         }
       },
       "astro:build:done": async ({ pages, dir, logger, assets }) => {
-        await cloudflareModulePlugin.afterBuildCompleted(_config);
         let redirectsExists = false;
         try {
           const redirectsStat = await stat(new URL("./_redirects", _config.outDir));

package/dist/utils/assets.js

@@ -1,49 +1,5 @@
 import { isRemotePath } from "@astrojs/internal-helpers/path";
-function matchHostname(url, hostname, allowWildcard) {
-  if (!hostname) {
-    return true;
-  }
-  if (!allowWildcard || !hostname.startsWith("*")) {
-    return hostname === url.hostname;
-  }
-  if (hostname.startsWith("**.")) {
-    const slicedHostname = hostname.slice(2);
-    return slicedHostname !== url.hostname && url.hostname.endsWith(slicedHostname);
-  }
-  if (hostname.startsWith("*.")) {
-    const slicedHostname = hostname.slice(1);
-    const additionalSubdomains = url.hostname.replace(slicedHostname, "").split(".").filter(Boolean);
-    return additionalSubdomains.length === 1;
-  }
-  return false;
-}
-function matchPort(url, port) {
-  return !port || port === url.port;
-}
-function matchProtocol(url, protocol) {
-  return !protocol || protocol === url.protocol.slice(0, -1);
-}
-function matchPathname(url, pathname, allowWildcard) {
-  if (!pathname) {
-    return true;
-  }
-  if (!allowWildcard || !pathname.endsWith("*")) {
-    return pathname === url.pathname;
-  }
-  if (pathname.endsWith("/**")) {
-    const slicedPathname = pathname.slice(0, -2);
-    return slicedPathname !== url.pathname && url.pathname.startsWith(slicedPathname);
-  }
-  if (pathname.endsWith("/*")) {
-    const slicedPathname = pathname.slice(0, -1);
-    const additionalPathChunks = url.pathname.replace(slicedPathname, "").split("/").filter(Boolean);
-    return additionalPathChunks.length === 1;
-  }
-  return false;
-}
-function matchPattern(url, remotePattern) {
-  return matchProtocol(url, remotePattern.protocol) && matchHostname(url, remotePattern.hostname, true) && matchPort(url, remotePattern.port) && matchPathname(url, remotePattern.pathname, true);
-}
+import { matchHostname, matchPattern } from "@astrojs/internal-helpers/remote";
 function isRemoteAllowed(src, {
   domains = [],
   remotePatterns = []

package/dist/utils/cloudflare-module-loader.d.ts

@@ -1,8 +1,4 @@
-import type { AstroConfig } from 'astro';
 import type { PluginOption } from 'vite';
-export interface CloudflareModulePluginExtra {
-    afterBuildCompleted(config: AstroConfig): Promise<void>;
-}
 /**
  * Enables support for various non-standard extensions in module imports that cloudflare workers supports.
  *
@@ -17,4 +13,4 @@ export interface CloudflareModulePluginExtra {
  * @param enabled - if true, will load all cloudflare pages supported types
  * @returns Vite plugin with additional extension method to hook into astro build
  */
-export declare function cloudflareModuleLoader(enabled: boolean): PluginOption & CloudflareModulePluginExtra;
+export declare function cloudflareModuleLoader(enabled: boolean): PluginOption;

package/dist/utils/cloudflare-module-loader.js

@@ -1,6 +1,5 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import * as url from "node:url";
 function cloudflareModuleLoader(enabled) {
   const adaptersByExtension = enabled ? { ...defaultAdapters } : {};
   const extensions = Object.keys(adaptersByExtension);
@@ -10,6 +9,9 @@ function cloudflareModuleLoader(enabled) {
   return {
     name: "vite:cf-module-loader",
     enforce: "pre",
+    applyToEnvironment(environment) {
+      return environment.name === "ssr" || environment.name === "client";
+    },
     configResolved(config) {
       isDev = config.command === "serve";
     },
@@ -20,7 +22,7 @@ function cloudflareModuleLoader(enabled) {
           rollupOptions: {
             // mark the wasm files as external so that they are not bundled and instead are loaded from the files
             external: extensions.map(
-              (x) => new RegExp(`^${MAGIC_STRING}.+${escapeRegExp(x)}.mjs$`, "i")
+              (x) => new RegExp(`^${MAGIC_STRING}.+${escapeRegExp(x)}$`, "i")
             )
           }
         }
@@ -50,18 +52,18 @@ function cloudflareModuleLoader(enabled) {
       const assetName = `${path.basename(filePath).split(".")[0]}.${hash}${extension}`;
       this.emitFile({
         type: "asset",
-        // emit the data explicitly as an esset with `fileName` rather than `name` so that
+        // emit the data explicitly as an asset with `fileName` rather than `name` so that
         // vite doesn't give it a random hash-id in its name--We need to be able to easily rewrite from
-        // the .mjs loader and the actual wasm asset later in the ESbuild for the worker
+        // the loader and the actual asset later in the build for the worker
         fileName: assetName,
         source: data
       });
       const chunkId = this.emitFile({
         type: "prebuilt-chunk",
-        fileName: `${assetName}.mjs`,
+        fileName: assetName,
         code: inlineModule
       });
-      return `import module from "${MAGIC_STRING}${chunkId}${extension}.mjs";export default module;`;
+      return `import module from "${MAGIC_STRING}${chunkId}${extension}";export default module;`;
     },
     // output original wasm file relative to the chunk now that chunking has been achieved
     renderChunk(code, chunk, _) {
@@ -71,13 +73,13 @@ function cloudflareModuleLoader(enabled) {
       for (const ext of extensions) {
         const extension = ext.replace(/\?\w+$/, "");
         replaced = replaced.replaceAll(
-          new RegExp(`${MAGIC_STRING}([^\\s]+?)${escapeRegExp(extension)}\\.mjs`, "g"),
+          new RegExp(`${MAGIC_STRING}([^\\s]+?)${escapeRegExp(extension)}`, "g"),
           (_s, assetId) => {
             const fileName = this.getFileName(assetId);
             const relativePath = path.relative(path.dirname(chunk.fileName), fileName).replaceAll("\\", "/");
             replacements.push({
               chunkName: chunk.name,
-              cloudflareImport: relativePath.replace(/\.mjs$/, ""),
+              cloudflareImport: relativePath,
               nodejsImport: relativePath
             });
             return `./${relativePath}`;
@@ -104,34 +106,6 @@ function cloudflareModuleLoader(enabled) {
           replacement.fileName.push(chunk.fileName);
         }
       }
-    },
-    /**
-     * Once prerendering is complete, restore the imports in the _worker.js to cloudflare compatible ones, removing the .mjs suffix.
-     */
-    async afterBuildCompleted(config) {
-      const baseDir = url.fileURLToPath(config.outDir);
-      const replacementsByFileName = /* @__PURE__ */ new Map();
-      for (const replacement of replacements) {
-        if (!replacement.fileName) {
-          continue;
-        }
-        for (const fileName of replacement.fileName) {
-          const repls = replacementsByFileName.get(fileName) || [];
-          if (!repls.length) {
-            replacementsByFileName.set(fileName, repls);
-          }
-          repls.push(replacement);
-        }
-      }
-      for (const [fileName, repls] of replacementsByFileName.entries()) {
-        const filepath = path.join(baseDir, "_worker.js", fileName);
-        const contents = await fs.readFile(filepath, "utf-8");
-        let updated = contents;
-        for (const replacement of repls) {
-          updated = updated.replaceAll(replacement.nodejsImport, replacement.cloudflareImport);
-        }
-        await fs.writeFile(filepath, updated, "utf-8");
-      }
     }
   };
 }

package/dist/utils/handler.d.ts

@@ -1,23 +1,14 @@
-import type { CacheStorage as CloudflareCacheStorage, ExecutionContext, ExportedHandlerFetchHandler } from '@cloudflare/workers-types';
-import type { SSRManifest } from 'astro';
-import type { App } from 'astro/app';
-type Env = {
+import type { Response as CfResponse, ExecutionContext, ExportedHandlerFetchHandler } from '@cloudflare/workers-types';
+export type Env = {
     [key: string]: unknown;
     ASSETS: {
-        fetch: (req: Request | string) => Promise<Response>;
+        fetch: (req: Request | string) => Promise<CfResponse>;
     };
 };
-export interface Runtime<T extends object = object> {
-    runtime: {
-        env: Env & T;
-        cf: Parameters<ExportedHandlerFetchHandler>[0]['cf'];
-        caches: CloudflareCacheStorage;
-        ctx: ExecutionContext;
-    };
+export interface Runtime {
+    cfContext: ExecutionContext;
 }
 declare global {
-    var __ASTRO_SESSION_BINDING_NAME: string;
-    var __env__: Partial<Env>;
+    var __ASTRO_IMAGES_BINDING_NAME: string;
 }
-export declare function handle(manifest: SSRManifest, app: App, request: Parameters<ExportedHandlerFetchHandler>[0], env: Env, context: ExecutionContext): Promise<Response>;
-export {};
+export declare function handle(request: Parameters<ExportedHandlerFetchHandler>[0], env: Env, context: ExecutionContext): Promise<CfResponse>;

package/dist/utils/handler.js

@@ -1,13 +1,19 @@
 import { env as globalEnv } from "cloudflare:workers";
+import { sessionKVBindingName } from "virtual:astro-cloudflare:config";
+import { createApp } from "astro/app/entrypoint";
 import { setGetEnv } from "astro/env/setup";
 import { createGetEnv } from "../utils/env.js";
 setGetEnv(createGetEnv(globalEnv));
-async function handle(manifest, app, request, env, context) {
+async function handle(request, env, context) {
+  const app = createApp(import.meta.env.DEV);
   const { pathname } = new URL(request.url);
-  const bindingName = globalThis.__ASTRO_SESSION_BINDING_NAME;
-  globalThis.__env__ ??= {};
-  globalThis.__env__[bindingName] = env[bindingName];
-  if (manifest.assets.has(pathname)) {
+  if (env[sessionKVBindingName]) {
+    const sessionConfigOptions = app.manifest.sessionConfig?.options ?? {};
+    Object.assign(sessionConfigOptions, {
+      binding: env[sessionKVBindingName]
+    });
+  }
+  if (app.manifest.assets.has(pathname)) {
     return env.ASSETS.fetch(request.url.replace(/\.html$/, ""));
   }
   const routeData = app.match(request);
@@ -20,21 +26,7 @@ async function handle(manifest, app, request, env, context) {
     }
   }
   const locals = {
-    runtime: {
-      env,
-      cf: request.cf,
-      caches,
-      ctx: {
-        waitUntil: (promise) => context.waitUntil(promise),
-        // Currently not available: https://developers.cloudflare.com/pages/platform/known-issues/#pages-functions
-        passThroughOnException: () => {
-          throw new Error(
-            "`passThroughOnException` is currently not available in Cloudflare Pages. See https://developers.cloudflare.com/pages/platform/known-issues/#pages-functions."
-          );
-        },
-        props: {}
-      }
-    }
+    cfContext: context
   };
   const response = await app.render(
     request,

package/dist/utils/image-binding-transform.d.ts

@@ -0,0 +1,2 @@
+import type { Fetcher, ImagesBinding } from '@cloudflare/workers-types';
+export declare function transform(rawUrl: string, images: ImagesBinding, assets: Fetcher): Promise<import("@cloudflare/workers-types").Response | Response>;

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

@@ -0,0 +1,30 @@
+import { imageConfig } from "astro:assets";
+import { isRemotePath } from "@astrojs/internal-helpers/path";
+import { isRemoteAllowed } from "@astrojs/internal-helpers/remote";
+async function transform(rawUrl, images, assets) {
+  const url = new URL(rawUrl);
+  const href = url.searchParams.get("href");
+  if (!href || isRemotePath(href) && !isRemoteAllowed(href, imageConfig)) {
+    return new Response("Forbidden", { status: 403 });
+  }
+  const imageSrc = new URL(href, url.origin);
+  const content = await (isRemotePath(href) ? fetch(imageSrc) : assets.fetch(imageSrc));
+  if (!content.body) {
+    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 });
+  }
+  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,
+    // `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();
+}
+export {
+  transform
+};

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

@@ -1,20 +1,20 @@
 import type { AstroConfig, AstroIntegrationLogger, HookParameters } from 'astro';
-export type ImageService = 'passthrough' | 'cloudflare' | 'compile' | 'custom';
+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): {
     service: import("astro").ImageServiceConfig<Record<string, any>>;
-    responsiveStyles: boolean;
     endpoint: {
         route: string;
         entrypoint?: string | undefined;
     };
     domains: string[];
     remotePatterns: {
-        port?: string | undefined;
         protocol?: string | undefined;
         hostname?: string | undefined;
+        port?: string | undefined;
         pathname?: string | undefined;
     }[];
-    layout?: "fixed" | "constrained" | "full-width" | "none" | undefined;
+    responsiveStyles: boolean;
+    layout?: "none" | "fixed" | "constrained" | "full-width" | undefined;
     objectFit?: string | undefined;
     objectPosition?: string | undefined;
     breakpoints?: number[] | undefined;
@@ -23,15 +23,15 @@ export declare function setImageConfig(service: ImageService, config: AstroConfi
     endpoint: {
         entrypoint: string | undefined;
     };
-    responsiveStyles: boolean;
     domains: string[];
     remotePatterns: {
-        port?: string | undefined;
         protocol?: string | undefined;
         hostname?: string | undefined;
+        port?: string | undefined;
         pathname?: string | undefined;
     }[];
-    layout?: "fixed" | "constrained" | "full-width" | "none" | undefined;
+    responsiveStyles: boolean;
+    layout?: "none" | "fixed" | "constrained" | "full-width" | undefined;
     objectFit?: string | undefined;
     objectPosition?: string | undefined;
     breakpoints?: number[] | undefined;

package/dist/utils/image-config.js

@@ -8,6 +8,13 @@ function setImageConfig(service, config, command, logger) {
         ...config,
         service: command === "dev" ? sharpImageService() : { entrypoint: "@astrojs/cloudflare/image-service" }
       };
+    case "cloudflare-binding":
+      return {
+        ...config,
+        endpoint: {
+          entrypoint: "@astrojs/cloudflare/image-transform-endpoint"
+        }
+      };
     case "compile":
       return {
         ...config,

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

@@ -0,0 +1,6 @@
+import type { PluginOption } from 'vite';
+interface CloudflareConfig {
+    sessionKVBindingName: string;
+}
+export declare function createConfigPlugin(config: CloudflareConfig): PluginOption;
+export {};

package/dist/vite-plugin-config.js

@@ -0,0 +1,20 @@
+const VIRTUAL_CONFIG_ID = "virtual:astro-cloudflare:config";
+const RESOLVED_VIRTUAL_CONFIG_ID = "\0" + VIRTUAL_CONFIG_ID;
+function createConfigPlugin(config) {
+  return {
+    name: "vite:astro-cloudflare-config",
+    resolveId(id) {
+      if (id === VIRTUAL_CONFIG_ID) {
+        return RESOLVED_VIRTUAL_CONFIG_ID;
+      }
+    },
+    load(id) {
+      if (id === RESOLVED_VIRTUAL_CONFIG_ID) {
+        return `export const sessionKVBindingName = ${JSON.stringify(config.sessionKVBindingName)};`;
+      }
+    }
+  };
+}
+export {
+  createConfigPlugin
+};

package/dist/wrangler.d.ts

@@ -0,0 +1,10 @@
+import type { PluginConfig } from '@cloudflare/vite-plugin';
+/**
+ * Checks whether a wrangler file exists at the given path
+ * @param root
+ */
+export declare function hasWranglerConfig(root: URL): boolean;
+/**
+ * Returns the default wrangler configuration used by Astro Cloudflare configuration.
+ */
+export declare function defaultCloudflareConfig(): PluginConfig['config'];

package/dist/wrangler.js

@@ -0,0 +1,29 @@
+import { existsSync } from "node:fs";
+function hasWranglerConfig(root) {
+  return existsSync(new URL("wrangler.jsonc", root)) || existsSync(new URL("wrangler.toml", root)) || existsSync(new URL("wrangler.json", root));
+}
+function defaultCloudflareConfig() {
+  return {
+    // TODO: better way to handle name, maybe package.json#name ?
+    name: "test-application",
+    compatibility_date: "2025-05-21",
+    main: "@astrojs/cloudflare/entrypoints/server",
+    assets: {
+      directory: "./dist",
+      binding: "ASSETS"
+    },
+    images: {
+      binding: "IMAGES"
+    },
+    kv_namespaces: [
+      {
+        binding: "SESSION",
+        id: "SESSION"
+      }
+    ]
+  };
+}
+export {
+  defaultCloudflareConfig,
+  hasWranglerConfig
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@astrojs/cloudflare",
   "description": "Deploy your site to Cloudflare Workers/Pages",
-  "version": "13.0.0-alpha.0",
+  "version": "13.0.0-alpha.1",
   "type": "module",
   "types": "./dist/index.d.ts",
   "author": "withastro",
@@ -19,22 +19,29 @@
   "homepage": "https://docs.astro.build/en/guides/integrations-guide/cloudflare/",
   "exports": {
     ".": "./dist/index.js",
+    "./entrypoints/server": "./dist/entrypoints/server.js",
+    "./entrypoints/preview": "./dist/entrypoints/preview.js",
     "./entrypoints/server.js": "./dist/entrypoints/server.js",
-    "./entrypoints/middleware.js": "./dist/entrypoints/middleware.js",
     "./image-service": "./dist/entrypoints/image-service.js",
     "./image-endpoint": "./dist/entrypoints/image-endpoint.js",
+    "./image-transform-endpoint": "./dist/entrypoints/image-transform-endpoint.js",
     "./handler": "./dist/utils/handler.js",
+    "./types.d.ts": "./types.d.ts",
     "./package.json": "./package.json"
   },
   "files": [
-    "dist"
+    "dist",
+    "types.d.ts"
   ],
   "dependencies": {
-    "@cloudflare/workers-types": "^4.20251106.1",
+    "@cloudflare/vite-plugin": "^1.17.0",
+    "@cloudflare/workers-types": "^4.20251121.0",
+    "dotenv": "^17.2.3",
+    "piccolore": "^0.1.3",
     "tinyglobby": "^0.2.15",
-    "vite": "^7.1.7",
-    "wrangler": "4.46.0",
-    "@astrojs/internal-helpers": "0.7.4",
+    "vite": "^7.1.12",
+    "wrangler": "4.53.0",
+    "@astrojs/internal-helpers": "0.7.5",
     "@astrojs/underscore-redirects": "1.0.0"
   },
   "peerDependencies": {
@@ -42,9 +49,9 @@
   },
   "devDependencies": {
     "cheerio": "1.1.2",
-    "devalue": "^5.4.2",
-    "rollup": "^4.52.5",
-    "astro": "6.0.0-alpha.0",
+    "devalue": "^5.5.0",
+    "rollup": "^4.53.3",
+    "astro": "6.0.0-alpha.1",
     "astro-scripts": "0.0.14"
   },
   "publishConfig": {

package/types.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Cloudflare Worker Request types
+ * Extends the global Request object with Cloudflare-specific properties
+ */
+
+import type { IncomingRequestCfProperties } from '@cloudflare/workers-types';
+
+declare global {
+	interface Request {
+		/**
+		 * Cloudflare-specific properties available on incoming requests
+		 * Contains metadata about the request such as:
+		 * - Geographic information (country, colo, timezone)
+		 * - TLS/Security details (cipher, protocol version)
+		 * - Bot Management scores
+		 * - Client information (ASN, TCP metrics)
+		 */
+		readonly cf?: IncomingRequestCfProperties;
+	}
+}

package/dist/entrypoints/middleware.d.ts

@@ -1,2 +0,0 @@
-import type { MiddlewareHandler } from 'astro';
-export declare const onRequest: MiddlewareHandler;

package/dist/entrypoints/middleware.js

@@ -1,11 +0,0 @@
-const onRequest = (context, next) => {
-  if (context.isPrerendered) {
-    context.locals.runtime ??= {
-      env: process.env
-    };
-  }
-  return next();
-};
-export {
-  onRequest
-};