@astrojs/cloudflare 13.6.1 → 13.7.0

package/dist/entrypoints/preview.js

@@ -88,7 +88,7 @@ function serverStart({
   host,
   base
 }) {
-  const version = "13.6.1";
+  const version = "13.7.0";
   const localPrefix = `${colors.dim("\u2503")} Local    `;
   const networkPrefix = `${colors.dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);

package/dist/fetch.js

@@ -10,9 +10,15 @@ import {
   createLocals,
   getClientAddress
 } from "./utils/cf.js";
-setGetEnv(createGetEnv(globalEnv));
-const app = createApp();
+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;

package/dist/index.js

@@ -1,14 +1,18 @@
 import { createReadStream, existsSync, readFileSync } from "node:fs";
-import { appendFile, readFile, rename, stat, writeFile } 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
@@ -378,6 +382,39 @@ function createIntegration({
           } 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", _originalClientDir));

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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@astrojs/cloudflare",
   "description": "Deploy your site to Cloudflare Workers",
-  "version": "13.6.1",
+  "version": "13.7.0",
   "type": "module",
   "types": "./dist/index.d.ts",
   "author": "withastro",
@@ -55,7 +55,7 @@
     "cheerio": "1.2.0",
     "devalue": "^5.8.1",
     "prismjs": "^1.30.0",
-    "astro": "6.4.3",
+    "astro": "6.4.5",
     "astro-scripts": "0.0.14"
   },
   "publishConfig": {