@astrojs/cloudflare 14.0.0-alpha.0 → 14.0.0-beta.2

package/README.md

@@ -34,5 +34,5 @@ Copyright (c) 2023–present [Astro][astro]
 [coc]: https://github.com/withastro/.github/blob/main/CODE_OF_CONDUCT.md
 [community]: https://github.com/withastro/.github/blob/main/COMMUNITY_GUIDE.md
 [discord]: https://astro.build/chat/
-[issues]: https://github.com/withastro/adapter/issues
+[issues]: https://github.com/withastro/astro/issues
 [astro-integration]: https://docs.astro.build/en/guides/integrations/

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

@@ -2,6 +2,7 @@ import { imageConfig } from "astro:assets";
 import { isRemotePath } from "@astrojs/internal-helpers/path";
 import { isRemoteAllowed } from "@astrojs/internal-helpers/remote";
 import { env } from "cloudflare:workers";
+import { fetchWithRedirects } from "astro/assets";
 const prerender = false;
 const GET = async ({ request }) => {
   try {
@@ -14,7 +15,10 @@ const GET = async ({ request }) => {
       if (!isRemoteAllowed(href, imageConfig)) {
         return new Response("Forbidden", { status: 403 });
       }
-      response = await fetch(href, { redirect: "manual" });
+      response = await fetchWithRedirects({
+        url: href,
+        imageConfig
+      });
     } else {
       const sourceUrl = new URL(href, url.origin);
       if (sourceUrl.origin !== url.origin) {

package/dist/entrypoints/preview.js

@@ -41,7 +41,7 @@ const createPreviewServer = async ({
         allowedHosts
       },
       plugins: [
-        cfVitePlugin({ ...globalThis.astroCloudflareOptions, viteEnvironment: { name: "ssr" } })
+        cfVitePlugin({ ...globalThis.astroCloudflareConfig, viteEnvironment: { name: "ssr" } })
       ]
     });
   } catch (err) {
@@ -88,7 +88,7 @@ function serverStart({
   host,
   base
 }) {
-  const version = "14.0.0-alpha.0";
+  const version = "14.0.0-beta.2";
   const localPrefix = `${colors.dim("\u2503")} Local    `;
   const networkPrefix = `${colors.dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);

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

@@ -1,15 +1,22 @@
 import { readFile } from "node:fs/promises";
 const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---/;
+const RETURN_REPLACE_RE = /(\/\/[^\n]*|\/\*[\s\S]*?\*\/|`(?:[^`\\]|\\.)*`|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')|(?<!\.)\breturn(\s*;|\b)/g;
+function replaceTopLevelReturns(code) {
+  return code.replace(RETURN_REPLACE_RE, (_match, skip, tail) => {
+    if (skip !== void 0) return skip;
+    return tail.trim() === ";" ? "throw 0;" : "throw ";
+  });
+}
 function astroFrontmatterScanPlugin() {
   return {
     name: "astro-frontmatter-scan",
     setup(build) {
-      build.onLoad({ filter: /\.astro$/ }, async (args) => {
+      build.onLoad({ filter: /\.astro$/, namespace: "file" }, 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\s*;/g, "throw 0;").replace(/\breturn\b/g, "throw ");
+            const contents = replaceTopLevelReturns(frontmatterMatch[1]);
             return {
               contents: contents + "\nexport default {}",
               loader: "ts"

package/dist/fetch.d.ts

@@ -0,0 +1,12 @@
+import type { FetchState } from 'astro/fetch';
+/**
+ * Applies Cloudflare-specific setup to a `FetchState`:
+ * - Injects the SESSION KV binding
+ * - Serves static assets via the ASSETS binding
+ * - Sets `locals.cfContext`, client address, `waitUntil`, and error page fetch
+ *
+ * Returns a `Response` if the request was handled by the ASSETS binding
+ * (static file hit). Returns `undefined` when the caller should continue
+ * to Astro rendering.
+ */
+export declare function cf(state: FetchState, env: Env, ctx: ExecutionContext): Promise<Response | undefined>;

package/dist/fetch.js

@@ -0,0 +1,37 @@
+import { env as globalEnv } from "cloudflare:workers";
+import { createApp } from "astro/app/entrypoint";
+import { setGetEnv } from "astro/env/setup";
+import { createGetEnv } from "./utils/env.js";
+import {
+  injectSessionBinding,
+  matchStaticAsset,
+  fallbackToAssets,
+  createErrorPageFetch,
+  createLocals,
+  getClientAddress
+} from "./utils/cf.js";
+let app;
+function ensureInitialized() {
+  if (!app) {
+    setGetEnv(createGetEnv(globalEnv));
+    app = createApp();
+  }
+}
+async function cf(state, env, ctx) {
+  ensureInitialized();
+  injectSessionBinding(app.manifest, env);
+  const staticAsset = matchStaticAsset(app.manifest, state.request.url, env);
+  if (staticAsset) return staticAsset;
+  if (!state.routeData) {
+    const asset = await fallbackToAssets(state.request.url, env);
+    if (asset) return asset;
+  }
+  Object.assign(state.locals, createLocals(ctx));
+  state.clientAddress = getClientAddress(state.request);
+  state.renderOptions.waitUntil = ctx.waitUntil.bind(ctx);
+  state.renderOptions.prerenderedErrorPageFetch = createErrorPageFetch(env);
+  return void 0;
+}
+export {
+  cf
+};

package/dist/hono.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Duck-typed Hono context — matches Hono's `Context` shape for
+ * Cloudflare Workers without importing from `hono` at runtime.
+ */
+type HonoCloudflareContextLike = {
+    req: {
+        raw: Request;
+    };
+    env: Env;
+    executionCtx: ExecutionContext;
+    get?: (key: string) => unknown;
+    set?: (key: string, value: unknown) => void;
+};
+type HonoMiddlewareHandler = (context: HonoCloudflareContextLike, next: () => Promise<void>) => Promise<Response | void>;
+/**
+ * Hono middleware that applies Cloudflare-specific setup.
+ *
+ * Reads `env` and `executionCtx` from the Hono context (provided
+ * automatically by Hono on Cloudflare Workers). Handles static assets
+ * via the ASSETS binding, injects the SESSION KV binding, and sets
+ * `locals.cfContext`, client address, `waitUntil`, and error page fetch.
+ *
+ * If the request matches a static asset, returns the asset response
+ * directly. Otherwise calls `next()` to continue the middleware chain.
+ */
+export declare function cf(): HonoMiddlewareHandler;
+export {};

package/dist/hono.js

@@ -0,0 +1,21 @@
+import { FetchState } from "astro/fetch";
+import { cf as cfFetch } from "./fetch.js";
+const FETCH_STATE_KEY = "fetchState";
+function getFetchState(context) {
+  const state = context.get?.(FETCH_STATE_KEY);
+  if (state) return state;
+  const nextState = new FetchState(context.req.raw);
+  context.set?.(FETCH_STATE_KEY, nextState);
+  return nextState;
+}
+function cf() {
+  return async (context, next) => {
+    const state = getFetchState(context);
+    const asset = await cfFetch(state, context.env, context.executionCtx);
+    if (asset) return asset;
+    await next();
+  };
+}
+export {
+  cf
+};

package/dist/index.js

@@ -1,11 +1,18 @@
 import { createReadStream, existsSync, readFileSync } from "node:fs";
-import { appendFile, stat } from "node:fs/promises";
+import { appendFile, readFile, rename, stat, unlink, writeFile } from "node:fs/promises";
+import { relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import { normalizePath } from "vite";
 import { createInterface } from "node:readline/promises";
-import { removeLeadingForwardSlash } from "@astrojs/internal-helpers/path";
+import {
+  removeLeadingForwardSlash,
+  removeTrailingForwardSlash
+} from "@astrojs/internal-helpers/path";
 import { createRedirectsFromAstroRoutes, printAsRedirects } from "@astrojs/underscore-redirects";
 import { cloudflare as cfVitePlugin } from "@cloudflare/vite-plugin";
 import { astroFrontmatterScanPlugin } from "./esbuild-plugin-astro-frontmatter.js";
 import { getParts } from "./utils/generate-routes-json.js";
+import { buildAssetsHeadersContent } from "./utils/headers.js";
 import {
   normalizeImageServiceConfig,
   setImageConfig
@@ -20,6 +27,7 @@ import {
 import { parseEnv } from "node:util";
 import { sessionDrivers } from "astro/config";
 import { createCloudflarePrerenderer } from "./prerenderer.js";
+import cfPrismPlugin from "./vite-plugin-prism.js";
 const CLOUDFLARE_KV_SESSION_DRIVER_ENTRYPOINT = sessionDrivers.cloudflareKVBinding().entrypoint;
 function usesCloudflareKVSessionDriver(session) {
   const driver = session?.driver;
@@ -57,15 +65,16 @@ function createIntegration({
   ...cloudflareOptions
 } = {}) {
   let _config;
+  let _buildOutput;
+  let _originalClientDir;
   let _routes;
-  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 }) => {
+      "astro:config:setup": async ({ command, config, updateConfig, logger, addWatchFile }) => {
         if (!!process.versions.webcontainer) {
           throw new Error("`workerd` does not run on Stackblitz.");
         }
@@ -96,7 +105,7 @@ function createIntegration({
         const needsImagesBindingForDev = isCompile && command === "dev";
         const usesContentCollections = hasContentCollectionsConfig(config.srcDir);
         const prebundleContentRuntime = command === "dev" && usesContentCollections;
-        cfPluginConfig = {
+        const adapterPluginConfig = {
           config: cloudflareConfigCustomizer({
             needsSessionKVBinding,
             sessionKVBindingName,
@@ -122,9 +131,17 @@ function createIntegration({
             }
           }
         };
+        cfPluginConfig = { ...cloudflareOptions, ...adapterPluginConfig };
         if (command === "preview") {
-          globalThis.astroCloudflareOptions = cfPluginConfig;
+          globalThis.astroCloudflareConfig = cfPluginConfig;
         }
+        const prismFiles = [
+          "@astrojs/prism > prismjs",
+          "@astrojs/prism > prismjs/components.js",
+          "@astrojs/prism > prismjs/dependencies.js"
+        ];
+        const isAstroPrismPackageInstalled = await getIsAstroPrismInstalled(config.root);
+        const userOptimizeDeps = config.vite?.optimizeDeps;
         updateConfig({
           build: {
             redirects: false
@@ -134,9 +151,9 @@ function createIntegration({
             plugins: [
               ...prerenderEnvironment === "node" && command === "dev" ? [createNodePrerenderPlugin()] : [],
               cfVitePlugin({
-                ...cloudflareOptions,
                 ...cfPluginConfig,
-                viteEnvironment: { name: "ssr" }
+                viteEnvironment: { name: "ssr" },
+                assetsOnly: () => _buildOutput === "static"
               }),
               {
                 name: "@astrojs/cloudflare:cf-imports",
@@ -177,6 +194,9 @@ function createIntegration({
                           "astro > piccolore",
                           "astro > picomatch",
                           "astro/app",
+                          "astro/app/fetch/default-handler",
+                          "astro/fetch",
+                          "astro/hono",
                           "astro/assets",
                           "astro/assets/runtime",
                           "astro/assets/utils/inferRemoteSize.js",
@@ -185,7 +205,9 @@ function createIntegration({
                           "astro/compiler-runtime",
                           "astro/jsx-runtime",
                           "astro/app/entrypoint/dev",
-                          "astro/virtual-modules/middleware.js"
+                          "astro/virtual-modules/middleware.js",
+                          ...isAstroPrismPackageInstalled ? prismFiles : [],
+                          ...Array.isArray(userOptimizeDeps?.include) ? userOptimizeDeps.include : []
                         ],
                         exclude: [
                           "unstorage/drivers/cloudflare-kv-binding",
@@ -193,7 +215,8 @@ function createIntegration({
                           "virtual:astro:*",
                           "virtual:astro-cloudflare:*",
                           "virtual:@astrojs/*",
-                          "@astrojs/starlight"
+                          "@astrojs/starlight",
+                          ...Array.isArray(userOptimizeDeps?.exclude) ? userOptimizeDeps.exclude : []
                         ],
                         esbuildOptions: {
                           // Suppress Vite's `createRequire(import.meta.url)` banner to work around
@@ -201,7 +224,8 @@ function createIntegration({
                           // incorrectly rewrites identifiers inside `import.meta` when an imported
                           // binding shares the same name (e.g. zod v4 exports `meta`).
                           banner: { js: "" },
-                          plugins: [astroFrontmatterScanPlugin()]
+                          plugins: [astroFrontmatterScanPlugin()],
+                          ...userOptimizeDeps?.esbuildOptions?.loader ? { loader: userOptimizeDeps.esbuildOptions.loader } : {}
                         }
                       }
                     };
@@ -237,7 +261,8 @@ function createIntegration({
                   imageServiceEntrypoint: "@astrojs/cloudflare/image-service-workerd",
                   buildAssets: config.build.assets ?? "_astro"
                 } : null
-              })
+              }),
+              cfPrismPlugin()
             ]
           },
           image: setImageConfig(imageService, config.image, command, logger)
@@ -251,11 +276,14 @@ function createIntegration({
       },
       "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, injectTypes, logger }) => {
+      "astro:config:done": ({ setAdapter, config, injectTypes, logger, buildOutput }) => {
         _config = config;
+        _buildOutput = buildOutput;
+        _originalClientDir = new URL(config.build.client.href);
+        if (config.base !== "/") {
+          config.build.client = new URL("." + config.base + "/", config.build.client);
+        }
         injectTypes({
           filename: "cloudflare.d.ts",
           content: '/// <reference types="@astrojs/cloudflare/types.d.ts" />'
@@ -263,9 +291,10 @@ function createIntegration({
         setAdapter({
           name: "@astrojs/cloudflare",
           adapterFeatures: {
-            buildOutput: "server",
+            buildOutput,
             middlewareMode: "classic",
-            preserveBuildClientDir: true
+            preserveBuildClientDir: true,
+            preserveBuildServerDir: true
           },
           entrypointResolution: "auto",
           previewEntrypoint: "@astrojs/cloudflare/entrypoints/preview",
@@ -330,9 +359,65 @@ function createIntegration({
         }
       },
       "astro:build:done": async ({ dir, logger, assets }) => {
+        if (_config.base !== "/") {
+          for (const file of [".assetsignore", "_headers"]) {
+            try {
+              await rename(
+                new URL(`./${file}`, _config.build.client),
+                new URL(`./${file}`, _originalClientDir)
+              );
+            } catch {
+            }
+          }
+          try {
+            const wranglerJsonUrl = new URL("./wrangler.json", _config.build.server);
+            const raw = await readFile(wranglerJsonUrl, "utf-8");
+            const wranglerConfig = JSON.parse(raw);
+            if (wranglerConfig.assets?.directory) {
+              wranglerConfig.assets.directory = normalizePath(
+                relative(fileURLToPath(_config.build.server), fileURLToPath(_originalClientDir))
+              );
+              await writeFile(wranglerJsonUrl, JSON.stringify(wranglerConfig));
+            }
+          } catch {
+          }
+        }
+        if (_config.build.assetsPrefix) {
+          logger.debug(
+            "Skipping Cache-Control injection for assets \u2014 `build.assetsPrefix` is set, so assets are served from a different origin."
+          );
+        } else {
+          const headersPath = new URL("./_headers", _originalClientDir);
+          const result = await buildAssetsHeadersContent(
+            {
+              assetsDir: _config.build.assets,
+              basePrefix: removeTrailingForwardSlash(_config.base),
+              headersPath
+            },
+            (path) => readFile(path, "utf-8")
+          );
+          if (result === null) {
+            logger.debug(
+              `Skipping Cache-Control injection \u2014 _headers already sets Cache-Control on a matching rule.`
+            );
+          } else {
+            const tempPath = new URL("./_headers.tmp", _originalClientDir);
+            try {
+              await writeFile(tempPath, result.content);
+              await rename(tempPath, headersPath);
+            } catch (err) {
+              await unlink(tempPath).catch(() => {
+              });
+              throw err;
+            }
+            logger.info(
+              `Injected immutable Cache-Control for ${result.assetsPattern} into _headers.`
+            );
+          }
+        }
         let redirectsExists = false;
         try {
-          const redirectsStat = await stat(new URL("./_redirects", _config.build.client));
+          const redirectsStat = await stat(new URL("./_redirects", _originalClientDir));
           if (redirectsStat.isFile()) {
             redirectsExists = true;
           }
@@ -342,7 +427,7 @@ function createIntegration({
         const redirects = [];
         if (redirectsExists) {
           const rl = createInterface({
-            input: createReadStream(new URL("./_redirects", _config.build.client)),
+            input: createReadStream(new URL("./_redirects", _originalClientDir)),
             crlfDelay: Number.POSITIVE_INFINITY
           });
           for await (const line of rl) {
@@ -364,13 +449,13 @@ function createIntegration({
             )
           ),
           dir,
-          buildOutput: _isFullyStatic ? "static" : "server",
+          buildOutput: _buildOutput,
           assets
         });
         if (!trueRedirects.empty()) {
           try {
             await appendFile(
-              new URL("./_redirects", _config.build.client),
+              new URL("./_redirects", _originalClientDir),
               printAsRedirects(trueRedirects)
             );
           } catch (_error) {
@@ -382,6 +467,16 @@ function createIntegration({
     }
   };
 }
+async function getIsAstroPrismInstalled(rootURL) {
+  try {
+    const pkgURL = new URL("./package.json", rootURL);
+    const input = await readFile(pkgURL, { encoding: "utf-8" });
+    const pkgJson = JSON.parse(input);
+    return Object.hasOwn(pkgJson["dependencies"], "@astrojs/prism");
+  } catch {
+    return false;
+  }
+}
 export {
   createIntegration as default
 };

package/dist/utils/cf-helpers.d.ts

@@ -0,0 +1,33 @@
+export interface Runtime {
+    cfContext: ExecutionContext;
+}
+/** Minimal manifest shape needed by the Cloudflare helpers. */
+export interface ManifestLike {
+    assets: Set<string>;
+    sessionConfig?: {
+        options?: Record<string, unknown>;
+    } | undefined;
+}
+/**
+ * Returns a `Response` from the ASSETS binding if the request pathname
+ * is a known static asset. Returns `undefined` otherwise.
+ */
+export declare function matchStaticAsset(manifest: ManifestLike, requestUrl: string, env: Env): Response | undefined;
+/**
+ * Tries the ASSETS binding as a fallback for an unmatched route.
+ * Returns the asset `Response` if found (non-404), `undefined` otherwise.
+ */
+export declare function fallbackToAssets(requestUrl: string, env: Env): Promise<Response | undefined>;
+/**
+ * Creates a fetch function for prerendered error pages via the ASSETS binding.
+ */
+export declare function createErrorPageFetch(env: Env): (url: string) => Promise<Response>;
+/**
+ * Creates the Cloudflare-specific locals object with `cfContext`
+ * and deprecated `runtime` property getters.
+ */
+export declare function createLocals(ctx: ExecutionContext): Runtime;
+/**
+ * Extracts the client IP address from the `cf-connecting-ip` header.
+ */
+export declare function getClientAddress(request: Request): string | undefined;

package/dist/utils/cf-helpers.js

@@ -0,0 +1,63 @@
+import { getValidatedIpFromHeader } from "@astrojs/internal-helpers/request";
+function matchStaticAsset(manifest, requestUrl, env) {
+  const { pathname } = new URL(requestUrl);
+  if (manifest.assets.has(pathname)) {
+    return env.ASSETS.fetch(requestUrl.replace(/\.html$/, ""));
+  }
+  return void 0;
+}
+async function fallbackToAssets(requestUrl, env) {
+  const asset = await env.ASSETS.fetch(
+    requestUrl.replace(/index.html$/, "").replace(/\.html$/, "")
+  );
+  if (asset.status !== 404) {
+    return asset;
+  }
+  return void 0;
+}
+function createErrorPageFetch(env) {
+  return async (url) => {
+    return env.ASSETS.fetch(url.replace(/\.html$/, ""));
+  };
+}
+function createLocals(ctx) {
+  const locals = {
+    cfContext: ctx
+  };
+  Object.defineProperty(locals, "runtime", {
+    enumerable: false,
+    value: {
+      get env() {
+        throw new Error(
+          `Astro.locals.runtime.env has been removed in Astro v6. Use 'import { env } from "cloudflare:workers"' instead.`
+        );
+      },
+      get cf() {
+        throw new Error(
+          `Astro.locals.runtime.cf has been removed in Astro v6. Use 'Astro.request.cf' instead.`
+        );
+      },
+      get caches() {
+        throw new Error(
+          `Astro.locals.runtime.caches has been removed in Astro v6. Use the global 'caches' object instead.`
+        );
+      },
+      get ctx() {
+        throw new Error(
+          `Astro.locals.runtime.ctx has been removed in Astro v6. Use 'Astro.locals.cfContext' instead.`
+        );
+      }
+    }
+  });
+  return locals;
+}
+function getClientAddress(request) {
+  return getValidatedIpFromHeader(request.headers.get("cf-connecting-ip"));
+}
+export {
+  createErrorPageFetch,
+  createLocals,
+  fallbackToAssets,
+  getClientAddress,
+  matchStaticAsset
+};

package/dist/utils/cf.d.ts

@@ -0,0 +1,8 @@
+import type { ManifestLike } from './cf-helpers.js';
+export type { Runtime, ManifestLike } from './cf-helpers.js';
+export { matchStaticAsset, fallbackToAssets, createErrorPageFetch, createLocals, getClientAddress, } from './cf-helpers.js';
+/**
+ * Injects the SESSION KV binding into the app manifest's session config.
+ * Idempotent — safe to call on every request.
+ */
+export declare function injectSessionBinding(manifest: ManifestLike, env: Env): void;

package/dist/utils/cf.js

@@ -0,0 +1,24 @@
+import { sessionKVBindingName } from "virtual:astro-cloudflare:config";
+import {
+  matchStaticAsset,
+  fallbackToAssets,
+  createErrorPageFetch,
+  createLocals,
+  getClientAddress
+} from "./cf-helpers.js";
+function injectSessionBinding(manifest, env) {
+  if (env[sessionKVBindingName]) {
+    const sessionConfigOptions = manifest.sessionConfig?.options ?? {};
+    Object.assign(sessionConfigOptions, {
+      binding: env[sessionKVBindingName]
+    });
+  }
+}
+export {
+  createErrorPageFetch,
+  createLocals,
+  fallbackToAssets,
+  getClientAddress,
+  injectSessionBinding,
+  matchStaticAsset
+};

package/dist/utils/handler.d.ts

@@ -1,9 +1,7 @@
-export interface Runtime {
-    cfContext: ExecutionContext;
-}
+import { type Runtime } from './cf.js';
+export type { Runtime };
 declare global {
     var __ASTRO_IMAGES_BINDING_NAME: string;
 }
 type CfResponse = Awaited<ReturnType<Required<ExportedHandler<Env>>['fetch']>>;
 export declare function handle(request: Request, env: Env, context: ExecutionContext): Promise<CfResponse>;
-export {};

package/dist/utils/handler.js

@@ -1,9 +1,5 @@
 import { env as globalEnv } from "cloudflare:workers";
-import {
-  sessionKVBindingName,
-  compileImageConfig,
-  isPrerender
-} from "virtual:astro-cloudflare:config";
+import { 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";
@@ -15,7 +11,14 @@ import {
   isStaticImagesRequest,
   handleStaticImagesRequest
 } from "./prerender.js";
-import { getValidatedIpFromHeader } from "@astrojs/internal-helpers/request";
+import {
+  injectSessionBinding,
+  matchStaticAsset,
+  fallbackToAssets,
+  createErrorPageFetch,
+  createLocals,
+  getClientAddress
+} from "./cf.js";
 setGetEnv(createGetEnv(globalEnv));
 const app = createApp();
 async function handle(request, env, context) {
@@ -34,16 +37,9 @@ async function handle(request, env, context) {
       return handleStaticImagesRequest();
     }
   }
-  const { pathname: requestPathname } = new URL(request.url);
-  if (env[sessionKVBindingName]) {
-    const sessionConfigOptions = app.manifest.sessionConfig?.options ?? {};
-    Object.assign(sessionConfigOptions, {
-      binding: env[sessionKVBindingName]
-    });
-  }
-  if (app.manifest.assets.has(requestPathname)) {
-    return env.ASSETS.fetch(request.url.replace(/\.html$/, ""));
-  }
+  injectSessionBinding(app.manifest, env);
+  const staticAsset = matchStaticAsset(app.manifest, request.url, env);
+  if (staticAsset) return staticAsset;
   let routeData = void 0;
   if (app.isDev()) {
     const result = await app.devMatch(app.getPathnameFromRequest(request));
@@ -54,50 +50,17 @@ async function handle(request, env, context) {
     routeData = app.match(request);
   }
   if (!routeData) {
-    const asset = await env.ASSETS.fetch(
-      request.url.replace(/index.html$/, "").replace(/\.html$/, "")
-    );
-    if (asset.status !== 404) {
-      return asset;
-    }
+    const asset = await fallbackToAssets(request.url, env);
+    if (asset) return asset;
   }
-  const locals = {
-    cfContext: context
-  };
-  Object.defineProperty(locals, "runtime", {
-    enumerable: false,
-    value: {
-      get env() {
-        throw new Error(
-          `Astro.locals.runtime.env has been removed in Astro v6. Use 'import { env } from "cloudflare:workers"' instead.`
-        );
-      },
-      get cf() {
-        throw new Error(
-          `Astro.locals.runtime.cf has been removed in Astro v6. Use 'Astro.request.cf' instead.`
-        );
-      },
-      get caches() {
-        throw new Error(
-          `Astro.locals.runtime.caches has been removed in Astro v6. Use the global 'caches' object instead.`
-        );
-      },
-      get ctx() {
-        throw new Error(
-          `Astro.locals.runtime.ctx has been removed in Astro v6. Use 'Astro.locals.cfContext' instead.`
-        );
-      }
-    }
-  });
+  const locals = createLocals(context);
   const waitUntil = context.waitUntil.bind(context);
   const response = await app.render(request, {
     routeData,
     locals,
     waitUntil,
-    prerenderedErrorPageFetch: async (url) => {
-      return env.ASSETS.fetch(url.replace(/\.html$/, ""));
-    },
-    clientAddress: getValidatedIpFromHeader(request.headers.get("cf-connecting-ip"))
+    prerenderedErrorPageFetch: createErrorPageFetch(env),
+    clientAddress: getClientAddress(request)
   });
   if (app.setCookieHeaders) {
     for (const setCookieHeader of app.setCookieHeaders(response)) {

package/dist/utils/headers.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Returns true if the given `_headers` content already declares (or detaches)
+ * a `Cache-Control` directive on any rule whose URL pattern matches `path`.
+ *
+ * Used to avoid emitting a second `Cache-Control` rule for hashed assets when
+ * the user already has one — Cloudflare merges duplicate header values across
+ * matching rules with a comma, which produces contradictory cache directives.
+ */
+export declare function headersFileHasCacheControlForPath(content: string, path: string): boolean;
+/**
+ * Computes the content to write to `_headers` to inject an immutable
+ * Cache-Control rule for the hashed assets directory.
+ *
+ * Returns `null` when injection should be skipped because the existing
+ * `_headers` already declares `Cache-Control` on a rule matching the assets
+ * path — Cloudflare merges duplicate header values with a comma, which would
+ * produce contradictory directives.
+ */
+export declare function buildAssetsHeadersContent(opts: {
+    assetsDir: string;
+    basePrefix: string;
+    headersPath: URL;
+}, readFile: (path: URL) => Promise<string>): Promise<{
+    content: string;
+    assetsPattern: string;
+} | null>;

package/dist/utils/headers.js

@@ -0,0 +1,63 @@
+function cfHeadersPatternToRegex(pattern) {
+  let regexStr = "";
+  let i = 0;
+  while (i < pattern.length) {
+    const ch = pattern[i];
+    if (ch === "*") {
+      regexStr += ".*";
+      i++;
+    } else if (ch === ":" && /[A-Za-z]/.test(pattern[i + 1] ?? "")) {
+      i++;
+      while (i < pattern.length && /\w/.test(pattern[i])) i++;
+      regexStr += "[^/]+";
+    } else {
+      regexStr += ch.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+      i++;
+    }
+  }
+  return new RegExp(`^${regexStr}$`);
+}
+function headersFileHasCacheControlForPath(content, path) {
+  let matchesCurrentSection = false;
+  for (const rawLine of content.split("\n")) {
+    const trimmed = rawLine.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const isSectionHeader = !/^\s/.test(rawLine);
+    if (isSectionHeader) {
+      const pathOnly = trimmed.replace(/^https?:\/\/[^/]+/, "");
+      try {
+        matchesCurrentSection = cfHeadersPatternToRegex(pathOnly).test(path);
+      } catch {
+        matchesCurrentSection = false;
+      }
+    } else if (matchesCurrentSection && // Either `Cache-Control: value` (set) or `! Cache-Control` (detach).
+    /^\s+(?:!\s+cache-control\s*$|cache-control\s*:)/i.test(rawLine)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function buildAssetsHeadersContent(opts, readFile) {
+  const { assetsDir, basePrefix, headersPath } = opts;
+  const assetsPattern = `${basePrefix}/${assetsDir}/*`;
+  const probePath = `${basePrefix}/${assetsDir}/probe`;
+  let existingHeaders = "";
+  try {
+    existingHeaders = await readFile(headersPath);
+  } catch {
+  }
+  if (headersFileHasCacheControlForPath(existingHeaders, probePath)) {
+    return null;
+  }
+  const cacheBlock = `${assetsPattern}
+  Cache-Control: public, max-age=31536000, immutable
+`;
+  const normalizedExisting = existingHeaders && !existingHeaders.endsWith("\n") ? existingHeaders + "\n" : existingHeaders;
+  const content = normalizedExisting ? `${cacheBlock}
+${normalizedExisting}` : cacheBlock;
+  return { content, assetsPattern };
+}
+export {
+  buildAssetsHeadersContent,
+  headersFileHasCacheControlForPath
+};

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

@@ -1,6 +1,7 @@
 import { imageConfig } from "astro:assets";
 import { isRemotePath } from "@astrojs/internal-helpers/path";
 import { isRemoteAllowed } from "@astrojs/internal-helpers/remote";
+import { fetchWithRedirects } from "astro/assets";
 const qualityTable = {
   low: 25,
   mid: 50,
@@ -14,9 +15,21 @@ async function transform(rawUrl, images, assets) {
     return new Response("Forbidden", { status: 403 });
   }
   const imageSrc = new URL(href, url.origin);
-  const content = await (isRemotePath(href) ? fetch(imageSrc, { redirect: "manual" }) : assets.fetch(imageSrc));
-  if (content.status >= 300 && content.status < 400) {
-    return new Response("Not Found", { status: 404 });
+  let content;
+  if (isRemotePath(href)) {
+    try {
+      content = await fetchWithRedirects({
+        url: imageSrc,
+        imageConfig
+      });
+      if (!isRemoteAllowed(content.url, imageConfig)) {
+        return new Response("Forbidden", { status: 403 });
+      }
+    } catch {
+      return new Response("Not Found", { status: 404 });
+    }
+  } else {
+    content = await assets.fetch(imageSrc);
   }
   if (!content.body) {
     return new Response(null, { status: 404 });

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

@@ -16,6 +16,7 @@ export declare function setImageConfig(service: ImageServiceConfig | undefined,
     endpoint: {
         entrypoint: string;
     };
+    dangerouslyProcessSVG: boolean;
     domains: string[];
     remotePatterns: {
         protocol?: string | undefined;
@@ -34,6 +35,7 @@ export declare function setImageConfig(service: ImageServiceConfig | undefined,
         route: string;
         entrypoint?: string | undefined;
     };
+    dangerouslyProcessSVG: boolean;
     domains: string[];
     remotePatterns: {
         protocol?: string | undefined;

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

@@ -0,0 +1,2 @@
+import type { Plugin } from 'vite';
+export default function cfPrismPlugin(): Plugin;

package/dist/vite-plugin-prism.js

@@ -0,0 +1,56 @@
+import { fileURLToPath } from "node:url";
+import components from "prismjs/components.js";
+const MODULE_ID = "virtual:astro-cloudflare:prism";
+const RESOLVED_MODULE_ID = "\0" + MODULE_ID;
+const languages = Object.keys(components.languages).filter((l) => l !== "meta");
+function cfPrismPlugin() {
+  return {
+    name: "@astrojs/cloudflare:prism",
+    configEnvironment(environmentName) {
+      if (environmentName === "ssr") {
+        return {
+          // Because this virtual module adds a large number of dynamic import statements,
+          // Vite’s logs will consequently display the message “new dependencies optimized” for all languages.
+          // To avoid this, we explicitly specify that the module should be optimized in advance.
+          optimizeDeps: {
+            include: ["prismjs/components/prism-*.js"]
+          }
+        };
+      }
+    },
+    resolveId: {
+      filter: {
+        id: new RegExp(`^${MODULE_ID}$`)
+      },
+      handler() {
+        return RESOLVED_MODULE_ID;
+      }
+    },
+    load: {
+      filter: {
+        id: new RegExp(`^${RESOLVED_MODULE_ID}$`)
+      },
+      async handler() {
+        const importerPath = fileURLToPath(import.meta.url);
+        const resolvedModules = await Promise.all(
+          languages.map(async (lang) => {
+            const resolvedId = await this.resolve(
+              `prismjs/components/prism-${lang}.js`,
+              importerPath
+            );
+            return { resolvedId: resolvedId?.id, lang };
+          })
+        );
+        const prismBundledLanguages = resolvedModules.filter(({ resolvedId }) => resolvedId !== void 0).map(
+          ({ resolvedId, lang }) => `${JSON.stringify(lang)}: () => import(${JSON.stringify(resolvedId)})`
+        );
+        return `
+					export const bundledLanguages = { ${prismBundledLanguages.join(",")} };
+				`;
+      }
+    }
+  };
+}
+export {
+  cfPrismPlugin as default
+};

package/dist/wrangler.js

@@ -13,11 +13,7 @@ function cloudflareConfigCustomizer(options) {
       );
       const hasImagesBinding = nonInheritableConfig?.images?.binding !== void 0;
       return {
-        kv_namespaces: !needsSessionKVBinding || hasSessionBinding ? void 0 : [
-          {
-            binding: sessionKVBindingName
-          }
-        ],
+        kv_namespaces: !needsSessionKVBinding || hasSessionBinding ? void 0 : [{ binding: sessionKVBindingName }],
         images: hasImagesBinding || !imagesBindingName ? void 0 : {
           binding: imagesBindingName
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@astrojs/cloudflare",
   "description": "Deploy your site to Cloudflare Workers",
-  "version": "14.0.0-alpha.0",
+  "version": "14.0.0-beta.2",
   "type": "module",
   "types": "./dist/index.d.ts",
   "author": "withastro",
@@ -27,6 +27,8 @@
     "./image-passthrough-endpoint": "./dist/entrypoints/image-passthrough-endpoint.js",
     "./image-service-workerd": "./dist/entrypoints/image-service-workerd.js",
     "./handler": "./dist/utils/handler.js",
+    "./fetch": "./dist/fetch.js",
+    "./hono": "./dist/hono.js",
     "./types.d.ts": "./types.d.ts",
     "./package.json": "./package.json"
   },
@@ -35,23 +37,25 @@
     "types.d.ts"
   ],
   "dependencies": {
-    "@cloudflare/vite-plugin": "^1.32.3",
+    "@cloudflare/vite-plugin": "^1.39.0",
     "piccolore": "^0.1.3",
     "tinyglobby": "^0.2.15",
-    "vite": "^8.0.8",
-    "@astrojs/internal-helpers": "0.9.0",
+    "vite": "^8.0.13",
+    "@astrojs/internal-helpers": "0.10.0",
     "@astrojs/underscore-redirects": "1.0.3"
   },
   "peerDependencies": {
-    "astro": "^7.0.0-alpha.0",
+    "astro": "^7.0.0-alpha.2",
     "wrangler": "^4.83.0"
   },
   "devDependencies": {
-    "@cloudflare/workers-types": "^4.20260228.0",
-    "@types/node": "^25.2.2",
+    "@cloudflare/workers-types": "^4.20260526.1",
+    "@types/node": "^22.10.6",
+    "@types/prismjs": "1.26.6",
     "cheerio": "1.2.0",
-    "devalue": "^5.6.3",
-    "astro": "7.0.0-alpha.0",
+    "devalue": "^5.8.1",
+    "prismjs": "^1.30.0",
+    "astro": "7.0.0-beta.3",
     "astro-scripts": "0.0.14"
   },
   "publishConfig": {
@@ -59,9 +63,8 @@
   },
   "scripts": {
     "dev": "astro-scripts dev \"src/**/*.ts\"",
-    "build": "astro-scripts build \"src/**/*.ts\" --clean-dts && tsc",
+    "build": "astro-scripts build \"src/**/*.ts\" --clean-dts && tsc -b",
     "build:ci": "astro-scripts build \"src/**/*.ts\"",
-    "test": "astro-scripts test --force-exit \"test/**/*.test.ts\"",
-    "typecheck:tests": "tsc --build tsconfig.test.json"
+    "test": "astro-scripts test --force-exit \"test/**/*.test.ts\""
   }
 }