astro 7.2.0 → 7.2.2

package/dist/core/build/plugins/plugin-incremental.js

@@ -1,4 +1,5 @@
 import crypto from "node:crypto";
+import { FONTS_SERVER_ADDRESS_PLACEHOLDER } from "../../../assets/fonts/constants.js";
 import { PROPAGATED_ASSET_FLAG } from "../../../content/consts.js";
 import { hasContentFlag } from "../../../content/utils.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../../constants.js";
@@ -7,24 +8,29 @@ import { rootRelativePath } from "../../viteUtils.js";
 import { moduleIsTopLevelPage } from "../graph.js";
 import { isContentDataIncrementalModule } from "../incremental-metadata.js";
 import { getPageDataByViteID } from "../internal.js";
-function collectTransitiveDeps(graph, rootId) {
-  const deps = /* @__PURE__ */ new Set();
-  const queue = [rootId];
-  while (queue.length > 0) {
-    const current = queue.pop();
-    if (deps.has(current)) continue;
-    const modInfo = graph.getModuleInfo(current);
-    if (isContentDataIncrementalModule(modInfo)) continue;
-    deps.add(current);
-    if (!modInfo) continue;
-    for (const dep of modInfo.importedIds) {
-      if (!deps.has(dep)) queue.push(dep);
-    }
-    for (const dep of modInfo.dynamicallyImportedIds) {
-      if (!deps.has(dep)) queue.push(dep);
-    }
+const ASSET_PLACEHOLDERS = [
+  { token: "__ASTRO_ASSET_IMAGE__", pattern: /__ASTRO_ASSET_IMAGE__([\w$]+)__(?:_(.*?)__)?/g },
+  { token: "__VITE_ASSET__", pattern: /__VITE_ASSET__([\w$]+)__(?:\$_(.*?)__)?/g }
+];
+const FONTS_ADDRESS_DECLARATION = new RegExp(
+  `(?:const|let|var)\\s+${FONTS_SERVER_ADDRESS_PLACEHOLDER}\\s*=[^;]+;`
+);
+function resolveAssetPlaceholders(graph, code) {
+  let resolved = code;
+  for (const { token, pattern } of ASSET_PLACEHOLDERS) {
+    if (!resolved.includes(token)) continue;
+    resolved = resolved.replace(pattern, (placeholder, handle, postfix = "") => {
+      try {
+        return graph.getFileName(handle) + postfix;
+      } catch {
+        return placeholder;
+      }
+    });
+  }
+  if (resolved.includes(FONTS_SERVER_ADDRESS_PLACEHOLDER)) {
+    resolved = resolved.replace(FONTS_ADDRESS_DECLARATION, "");
   }
-  return [...deps].sort();
+  return resolved;
 }
 function hashModules(graph, sortedIds) {
   const hasher = crypto.createHash("sha256");
@@ -33,17 +39,137 @@ function hashModules(graph, sortedIds) {
     hasher.update("\n");
     const code = graph.getModuleInfo(id)?.code;
     if (code != null) {
-      hasher.update(code);
+      hasher.update(resolveAssetPlaceholders(graph, code));
     }
     hasher.update("\n");
   }
   return hasher.digest("hex");
 }
-function collectClientEntrypointHashes(graph, entrypointIds, pagesByEntrypoint, hashesByComponent) {
+function createTransitiveGraphCache(graph) {
+  const modules = /* @__PURE__ */ new Map();
+  const dependencies = /* @__PURE__ */ new Map();
+  const excludedModules = /* @__PURE__ */ new Set();
+  const pending = [...graph.getModuleIds()];
+  for (const id of pending) {
+    if (modules.has(id)) continue;
+    const info = graph.getModuleInfo(id);
+    modules.set(id, info);
+    if (isContentDataIncrementalModule(info)) {
+      excludedModules.add(id);
+      continue;
+    }
+    const importedIds = [...info?.importedIds ?? [], ...info?.dynamicallyImportedIds ?? []];
+    dependencies.set(id, importedIds);
+    pending.push(...importedIds);
+  }
+  for (const id of excludedModules) modules.delete(id);
+  for (const [id, importedIds] of dependencies) {
+    dependencies.set(
+      id,
+      importedIds.filter((importedId) => !excludedModules.has(importedId))
+    );
+  }
+  const reverseDependencies = /* @__PURE__ */ new Map();
+  for (const id of modules.keys()) reverseDependencies.set(id, []);
+  for (const [id, importedIds] of dependencies) {
+    for (const importedId of importedIds) reverseDependencies.get(importedId)?.push(id);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const finishOrder = [];
+  for (const rootId of modules.keys()) {
+    if (visited.has(rootId)) continue;
+    visited.add(rootId);
+    const stack = [[rootId, 0]];
+    while (stack.length > 0) {
+      const frame = stack[stack.length - 1];
+      const importedIds = dependencies.get(frame[0]) ?? [];
+      if (frame[1] < importedIds.length) {
+        const importedId = importedIds[frame[1]++];
+        if (!visited.has(importedId)) {
+          visited.add(importedId);
+          stack.push([importedId, 0]);
+        }
+      } else {
+        finishOrder.push(frame[0]);
+        stack.pop();
+      }
+    }
+  }
+  const componentByModule = /* @__PURE__ */ new Map();
+  const components = [];
+  for (const rootId of finishOrder.toReversed()) {
+    if (componentByModule.has(rootId)) continue;
+    const componentIndex = components.length;
+    const component = [];
+    const stack = [rootId];
+    componentByModule.set(rootId, componentIndex);
+    while (stack.length > 0) {
+      const id = stack.pop();
+      component.push(id);
+      for (const importerId of reverseDependencies.get(id) ?? []) {
+        if (!componentByModule.has(importerId)) {
+          componentByModule.set(importerId, componentIndex);
+          stack.push(importerId);
+        }
+      }
+    }
+    components.push(component.sort());
+  }
+  const componentDependencies = components.map(() => /* @__PURE__ */ new Set());
+  const componentImporters = components.map(() => /* @__PURE__ */ new Set());
+  for (const [id, importedIds] of dependencies) {
+    const componentIndex = componentByModule.get(id);
+    for (const importedId of importedIds) {
+      const dependencyIndex = componentByModule.get(importedId);
+      if (dependencyIndex === componentIndex) continue;
+      componentDependencies[componentIndex].add(dependencyIndex);
+      componentImporters[dependencyIndex].add(componentIndex);
+    }
+  }
+  const componentHashes = /* @__PURE__ */ new Map();
+  const componentHasServerIsland = /* @__PURE__ */ new Map();
+  const unresolvedDependencies = componentDependencies.map((items) => items.size);
+  const ready = unresolvedDependencies.flatMap((count, index) => count === 0 ? [index] : []);
+  for (const componentIndex of ready) {
+    const hasher = crypto.createHash("sha256");
+    hasher.update(hashModules(graph, components[componentIndex]));
+    const dependencyHashes = [...componentDependencies[componentIndex]].map((dependencyIndex) => componentHashes.get(dependencyIndex)).sort();
+    for (const dependencyHash of dependencyHashes) {
+      hasher.update("\n");
+      hasher.update(dependencyHash);
+    }
+    componentHashes.set(componentIndex, hasher.digest("hex"));
+    componentHasServerIsland.set(
+      componentIndex,
+      components[componentIndex].some(
+        (id) => (modules.get(id)?.meta?.astro?.serverComponents?.length ?? 0) > 0
+      ) || [...componentDependencies[componentIndex]].some(
+        (dependencyIndex) => componentHasServerIsland.get(dependencyIndex)
+      )
+    );
+    for (const importerIndex of componentImporters[componentIndex]) {
+      unresolvedDependencies[importerIndex]--;
+      if (unresolvedDependencies[importerIndex] === 0) ready.push(importerIndex);
+    }
+  }
+  return {
+    hashes: new Map(
+      [...componentByModule].map(([id, componentIndex]) => [
+        id,
+        componentHashes.get(componentIndex)
+      ])
+    ),
+    serverIslandModules: new Set(
+      [...componentByModule].filter(([, componentIndex]) => componentHasServerIsland.get(componentIndex)).map(([id]) => id)
+    )
+  };
+}
+function collectClientEntrypointHashes(transitiveHashes, entrypointIds, pagesByEntrypoint, hashesByComponent) {
   for (const entrypointId of entrypointIds) {
     const pages = pagesByEntrypoint.get(entrypointId);
     if (!pages?.size) continue;
-    const hash = hashModules(graph, collectTransitiveDeps(graph, entrypointId));
+    const hash = transitiveHashes.get(entrypointId);
+    if (!hash) continue;
     for (const pageData of pages) {
       let list = hashesByComponent.get(pageData.component);
       if (!list) {
@@ -57,15 +183,16 @@ function collectClientEntrypointHashes(graph, entrypointIds, pagesByEntrypoint,
 function foldClientDependencies(graph, internals) {
   const baseHashes = internals.pageDependencyHashes;
   if (!baseHashes) return;
+  const { hashes: transitiveHashes } = createTransitiveGraphCache(graph);
   const hashesByComponent = /* @__PURE__ */ new Map();
   collectClientEntrypointHashes(
-    graph,
+    transitiveHashes,
     internals.discoveredClientOnlyComponents.keys(),
     internals.pagesByClientOnly,
     hashesByComponent
   );
   collectClientEntrypointHashes(
-    graph,
+    transitiveHashes,
     internals.discoveredScripts,
     internals.pagesByScriptId,
     hashesByComponent
@@ -80,24 +207,17 @@ function foldClientDependencies(graph, internals) {
     baseHashes.set(component, hasher.digest("hex"));
   }
 }
-function collectContentEntryHashes(graph, root) {
+function collectContentEntryHashes(graph, root, transitiveHashes) {
   const entryHashes = /* @__PURE__ */ new Map();
   for (const id of graph.getModuleIds()) {
     if (!hasContentFlag(id, PROPAGATED_ASSET_FLAG)) continue;
     const renderModuleId = removeQueryString(id);
     const key = rootRelativePath(root, renderModuleId, false);
-    const deps = collectTransitiveDeps(graph, renderModuleId);
-    entryHashes.set(key, hashModules(graph, deps));
+    const hash = transitiveHashes.get(renderModuleId);
+    if (hash) entryHashes.set(key, hash);
   }
   return entryHashes;
 }
-function pageContainsServerIsland(graph, ids) {
-  for (const id of ids) {
-    const serverComponents = graph.getModuleInfo(id)?.meta?.astro?.serverComponents;
-    if (serverComponents?.length) return true;
-  }
-  return false;
-}
 function pluginIncremental(internals, root) {
   return {
     name: "@astro/plugin-incremental",
@@ -109,6 +229,7 @@ function pluginIncremental(internals, root) {
         foldClientDependencies(this, internals);
         return;
       }
+      const transitiveGraph = createTransitiveGraphCache(this);
       const hashes = /* @__PURE__ */ new Map();
       const serverIslandComponents = /* @__PURE__ */ new Set();
       for (const id of this.getModuleIds()) {
@@ -117,14 +238,19 @@ function pluginIncremental(internals, root) {
         if (!moduleIsTopLevelPage(info)) continue;
         const pageData = getPageDataByViteID(internals, info.id);
         if (!pageData) continue;
-        const deps = collectTransitiveDeps(this, info.id);
-        hashes.set(pageData.component, hashModules(this, deps));
-        if (pageContainsServerIsland(this, deps)) {
+        const hash = transitiveGraph.hashes.get(info.id);
+        if (!hash) continue;
+        hashes.set(pageData.component, hash);
+        if (transitiveGraph.serverIslandModules.has(info.id)) {
           serverIslandComponents.add(pageData.component);
         }
       }
       internals.pageDependencyHashes = hashes;
-      internals.contentEntryRenderHashes = collectContentEntryHashes(this, root);
+      internals.contentEntryRenderHashes = collectContentEntryHashes(
+        this,
+        root,
+        transitiveGraph.hashes
+      );
       internals.serverIslandPageComponents = serverIslandComponents;
     }
   };

package/dist/core/build/plugins/plugin-manifest.js

@@ -21,7 +21,8 @@ import {
   trackStyleHashes
 } from "../../csp/common.js";
 import { partitionByKind } from "../../csp/runtime.js";
-import { encodeKey } from "../../encryption.js";
+import { generateSpeculationRulesContent } from "../../../prefetch/speculation-rules.js";
+import { encodeKey, generateCspDigest } from "../../encryption.js";
 import { fileExtension, joinPaths, prependForwardSlash } from "../../path.js";
 import { DEFAULT_COMPONENTS } from "../../routing/default.js";
 import { getOutFile, getOutFolder } from "../common.js";
@@ -204,6 +205,13 @@ async function buildManifest(opts, internals, staticFiles, encodedKey) {
       ...settings.injectedCsp.styleHashes,
       ...await trackStyleHashes(internals, settings, algorithm)
     ];
+    let speculationRulesContent;
+    if (settings.config.experimental.clientPrerender && settings.config.prefetch) {
+      const prefetchAll = typeof settings.config.prefetch === "object" ? settings.config.prefetch.prefetchAll ?? false : false;
+      speculationRulesContent = generateSpeculationRulesContent(prefetchAll);
+      const speculationRulesHash = await generateCspDigest(speculationRulesContent, algorithm);
+      scriptHashes.push(speculationRulesHash);
+    }
     const scriptDirective = {
       resources: getScriptResources(cspConfig),
       hashes: scriptHashes,
@@ -225,7 +233,8 @@ async function buildManifest(opts, internals, staticFiles, encodedKey) {
       styleHashes: styleDefault.hashes,
       styleResources: styleDefault.resources,
       scriptDirective,
-      styleDirective
+      styleDirective,
+      speculationRulesContent
     };
   }
   let internalFetchHeaders = void 0;

package/dist/core/config/settings.js

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import yaml from "js-yaml";
+import * as yaml from "js-yaml";
 import * as toml from "smol-toml";
 import { getContentPaths } from "../../content/index.js";
 import createPreferences from "../../preferences/index.js";

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "7.2.0";
+const ASTRO_VERSION = "7.2.2";
 const ASTRO_GENERATOR = `Astro v${ASTRO_VERSION}`;
 const ASTRO_ERROR_HEADER = "X-Astro-Error";
 const DEFAULT_404_COMPONENT = "astro-default-404.astro";

package/dist/core/dev/dev.js

@@ -26,7 +26,7 @@ async function dev(inlineConfig) {
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "7.2.0";
+  const currentVersion = "7.2.2";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

package/dist/core/dev/lockfile.d.ts

@@ -32,6 +32,22 @@ export declare function serializeLockFile(data: LockFileData): string;
  * Signal 0 does not kill the process — it only checks whether the process exists.
  */
 export declare function isProcessAlive(pid: number): boolean;
+/**
+ * Check whether a process command points to the Astro CLI.
+ */
+export declare function isAstroCommand(command: string): boolean;
+interface ProcessInfo {
+    pid: number;
+    cmd?: string;
+}
+type ProcessLookup = (by: 'pid', value: number, options: {
+    logLevel: 'error';
+}) => Promise<ProcessInfo[]>;
+/**
+ * Check whether the live process recorded in a lock file is still Astro.
+ * If the command cannot be inspected, keep the existing PID-only behavior.
+ */
+export declare function isLockFileProcessAlive(data: LockFileData, find?: ProcessLookup): Promise<boolean>;
 /**
  * Read the lock file from disk. Returns null if it doesn't exist or is invalid.
  */
@@ -58,8 +74,9 @@ export declare function evaluateExistingServer(data: LockFileData | null, alive:
  */
 export declare function killDevServer(root: URL, data: LockFileData): Promise<void>;
 /**
- * Check for an existing server by reading the lock file and checking process liveness.
+ * Check for an existing server by reading the lock file and checking process identity.
  * Automatically cleans up stale lock files.
  * Returns the server info if a live server is found, null otherwise.
  */
-export declare function checkExistingServer(root: URL, command?: ServerCommand): LockFileData | null;
+export declare function checkExistingServer(root: URL, command?: ServerCommand): Promise<LockFileData | null>;
+export {};

package/dist/core/dev/lockfile.js

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync, unlinkSync, writeFileSync, mkdirSync } from "node:fs";
 import { fileURLToPath } from "node:url";
+import findProcess from "find-process";
 const GRACEFUL_SHUTDOWN_TIMEOUT = 5e3;
 function getLockFileURL(root, command = "dev") {
   return new URL(`.astro/${command}.json`, root);
@@ -42,6 +43,23 @@ function isProcessAlive(pid) {
     return false;
   }
 }
+const ASTRO_COMMAND_PATTERN = /(?:^|[\\/\s"'])(?:astro[\\/]bin[\\/]astro\.mjs|\.bin[\\/]astro(?:\.cmd)?)(?=$|[\s"'])/i;
+function isAstroCommand(command) {
+  return ASTRO_COMMAND_PATTERN.test(command);
+}
+async function isLockFileProcessAlive(data, find = findProcess) {
+  if (!isProcessAlive(data.pid)) {
+    return false;
+  }
+  try {
+    const processInfo = (await find("pid", data.pid, { logLevel: "error" })).find(
+      ({ pid }) => pid === data.pid
+    );
+    return processInfo?.cmd === void 0 || isAstroCommand(processInfo.cmd);
+  } catch {
+    return true;
+  }
+}
 function readLockFile(root, command = "dev") {
   const lockFileURL = getLockFileURL(root, command);
   try {
@@ -98,9 +116,12 @@ async function killDevServer(root, data) {
   }
   removeLockFile(root);
 }
-function checkExistingServer(root, command = "dev") {
+async function checkExistingServer(root, command = "dev") {
   const data = readLockFile(root, command);
-  const result = evaluateExistingServer(data, data !== null && isProcessAlive(data.pid));
+  const result = evaluateExistingServer(
+    data,
+    data !== null && await isLockFileProcessAlive(data)
+  );
   if (result === null) {
     return null;
   }
@@ -115,6 +136,8 @@ export {
   checkExistingServer,
   evaluateExistingServer,
   getLogFileURL,
+  isAstroCommand,
+  isLockFileProcessAlive,
   isProcessAlive,
   killDevServer,
   parseLockFile,

package/dist/core/fetch/fetch-state.js

@@ -330,6 +330,7 @@ class FetchState {
         resources: manifest.csp?.styleDirective ? [...manifest.csp.styleDirective.resources] : [],
         hashes: manifest.csp?.styleDirective ? [...manifest.csp.styleDirective.hashes] : []
       },
+      speculationRulesContent: manifest.csp?.speculationRulesContent,
       internalFetchHeaders: manifest.internalFetchHeaders
     };
     this.result = result;

package/dist/core/messages/runtime.js

@@ -270,7 +270,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"7.2.0"}`
+        `v${"7.2.2"}`
       )} ${headline}`
     );
   }

package/dist/core/middleware/vite-plugin.d.ts

@@ -1,4 +1,4 @@
-import { type Plugin as VitePlugin } from 'vite';
+import type { Plugin as VitePlugin } from 'vite';
 import type { AstroSettings } from '../../types/astro.js';
 import type { BuildInternals } from '../build/internal.js';
 import type { StaticBuildOptions } from '../build/types.js';

package/dist/core/middleware/vite-plugin.js

@@ -1,13 +1,10 @@
-import { fileURLToPath } from "node:url";
-import {
-  normalizePath as viteNormalizePath
-} from "vite";
 import { getServerOutputDirectory } from "../../prerender/utils.js";
 import { addRolldownInput } from "../build/add-rolldown-input.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES, MIDDLEWARE_PATH_SEGMENT_NAME } from "../constants.js";
 import { MissingMiddlewareForInternationalization } from "../errors/errors-data.js";
 import { AstroError } from "../errors/index.js";
 import { normalizePath } from "../viteUtils.js";
+import { isAstroServerEnvironment } from "../../environments.js";
 const MIDDLEWARE_MODULE_ID = "virtual:astro:middleware";
 const MIDDLEWARE_RESOLVED_MODULE_ID = "\0" + MIDDLEWARE_MODULE_ID;
 const NOOP_MIDDLEWARE = "\0noop-middleware";
@@ -18,31 +15,21 @@ function vitePluginMiddleware({ settings }) {
   let resolvedMiddlewareId = void 0;
   const hasIntegrationMiddleware = settings.middlewares.pre.length > 0 || settings.middlewares.post.length > 0;
   let userMiddlewareIsPresent = false;
-  const normalizedSrcDir = viteNormalizePath(fileURLToPath(settings.config.srcDir));
   return {
     name: "@astro/plugin-middleware",
     applyToEnvironment(environment) {
       return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.astro || environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender;
     },
-    configureServer(server) {
-      server.watcher.on("change", (path) => {
-        const normalizedPath = viteNormalizePath(path);
-        if (!normalizedPath.startsWith(normalizedSrcDir)) return;
-        const relativePath = normalizedPath.slice(normalizedSrcDir.length);
-        if (!isMiddlewarePath(relativePath)) return;
-        for (const name of [
-          ASTRO_VITE_ENVIRONMENT_NAMES.ssr,
-          ASTRO_VITE_ENVIRONMENT_NAMES.astro
-        ]) {
-          const environment = server.environments[name];
-          if (!environment) continue;
-          const virtualMod = environment.moduleGraph.getModuleById(MIDDLEWARE_RESOLVED_MODULE_ID);
-          if (virtualMod) {
-            environment.moduleGraph.invalidateModule(virtualMod);
-          }
-          environment.hot.send("astro:middleware-updated", {});
-        }
-      });
+    hotUpdate: {
+      handler() {
+        if (!isAstroServerEnvironment(this.environment)) return;
+        const middlewareVirtualMod = this.environment.moduleGraph.getModuleById(
+          MIDDLEWARE_RESOLVED_MODULE_ID
+        );
+        if (!middlewareVirtualMod) return;
+        this.environment.moduleGraph.invalidateModule(middlewareVirtualMod);
+        this.environment.hot.send("astro:middleware-updated", {});
+      }
     },
     resolveId: {
       filter: {

package/dist/core/routing/dev.d.ts

@@ -10,5 +10,7 @@ interface MatchedRoute {
     filePath: URL;
     resolvedPathname: string;
 }
-export declare function matchRoute(pathname: string, routesList: RoutesList, pipeline: RunnablePipeline, manifest: SSRManifest): Promise<MatchedRoute | undefined>;
+export declare function matchRoute(pathname: string, routesList: RoutesList, pipeline: RunnablePipeline, manifest: SSRManifest, { prerenderOnly }?: {
+    prerenderOnly?: boolean;
+}): Promise<MatchedRoute | undefined>;
 export {};

package/dist/core/routing/dev.js

@@ -5,7 +5,7 @@ import { getCustom404Route } from "./helpers.js";
 import { NoMatchingStaticPathFound } from "../errors/errors-data.js";
 import { isAstroError } from "../errors/errors.js";
 import { getErrorRoutePath } from "../../i18n/error-routes.js";
-async function matchRoute(pathname, routesList, pipeline, manifest) {
+async function matchRoute(pathname, routesList, pipeline, manifest, { prerenderOnly } = {}) {
   const { logger, routeCache } = pipeline;
   const matches = matchAllRoutes(pathname, routesList);
   const preloadedMatches = getSortedPreloadedMatches({
@@ -13,7 +13,12 @@ async function matchRoute(pathname, routesList, pipeline, manifest) {
     manifest
   });
   let firstError = null;
+  let skippedPrerenderOnly = false;
   for await (const { route: maybeRoute, filePath } of preloadedMatches) {
+    if (prerenderOnly && !maybeRoute.prerender) {
+      skippedPrerenderOnly = true;
+      continue;
+    }
     try {
       await getProps({
         mod: await pipeline.getComponentByRoute(maybeRoute),
@@ -43,7 +48,10 @@ async function matchRoute(pathname, routesList, pipeline, manifest) {
   }
   const altPathname = pathname.replace(/\/index\.html$/, "/").replace(/\.html$/, "");
   if (altPathname !== pathname) {
-    return await matchRoute(altPathname, routesList, pipeline, manifest);
+    return await matchRoute(altPathname, routesList, pipeline, manifest, { prerenderOnly });
+  }
+  if (skippedPrerenderOnly) {
+    return void 0;
   }
   if (matches.length) {
     const possibleRoutes = matches.flatMap((route) => route.component);

package/dist/core/util.js

@@ -47,8 +47,8 @@ function resolvePages(config) {
   return new URL("./pages", config.srcDir);
 }
 function isInPagesDir(file, config) {
-  const pagesDir = resolvePages(config);
-  return file.toString().startsWith(pagesDir.toString());
+  const pagesDir = `${resolvePages(config).toString()}/`;
+  return file.toString().startsWith(pagesDir);
 }
 function isInjectedRoute(file, settings) {
   let fileURL = file.toString();

package/dist/prefetch/index.js

@@ -129,7 +129,7 @@ function prefetch(url, opts) {
   const ignoreSlowConnection = opts?.ignoreSlowConnection ?? false;
   if (!canPrefetchUrl(url, ignoreSlowConnection)) return;
   prefetchedUrls.add(url);
-  if (clientPrerender && HTMLScriptElement.supports?.("speculationrules")) {
+  if (clientPrerender && HTMLScriptElement.supports?.("speculationrules") && !hasStaticSpeculationRules()) {
     debug?.(`[astro] Prefetching ${url} with <script type="speculationrules">`);
     appendSpeculationRules(url, opts?.eagerness ?? "immediate");
   } else if (document.createElement("link").relList?.supports?.("prefetch")) {
@@ -203,6 +203,23 @@ function onPageLoad(cb) {
     }
   }).observe(document.body, { childList: true, subtree: true });
 }
+let _hasStaticRules;
+function hasStaticSpeculationRules() {
+  if (_hasStaticRules === void 0) {
+    _hasStaticRules = Array.from(document.querySelectorAll('script[type="speculationrules"]')).some(
+      (el) => {
+        try {
+          const rules = JSON.parse(el.textContent ?? "");
+          const entries = [...rules.prerender ?? [], ...rules.prefetch ?? []];
+          return entries.some((entry) => entry.source === "document");
+        } catch {
+          return false;
+        }
+      }
+    );
+  }
+  return _hasStaticRules;
+}
 function appendSpeculationRules(url, eagerness) {
   const script = document.createElement("script");
   script.type = "speculationrules";

package/dist/prefetch/speculation-rules.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generates static speculation rules JSON using `"source": "document"` with CSS selector matching.
+ * This produces a deterministic payload that can be hashed at build time for CSP compatibility,
+ * unlike the dynamic per-URL `"source": "list"` approach in `appendSpeculationRules()`.
+ */
+export declare function generateSpeculationRulesContent(prefetchAll: boolean): string;

package/dist/prefetch/speculation-rules.js

@@ -0,0 +1,22 @@
+function generateSpeculationRulesContent(prefetchAll) {
+  const selector = prefetchAll ? "a" : "a[data-astro-prefetch]";
+  return JSON.stringify({
+    prerender: [
+      {
+        source: "document",
+        where: { selector_matches: selector },
+        eagerness: "moderate"
+      }
+    ],
+    prefetch: [
+      {
+        source: "document",
+        where: { selector_matches: selector },
+        eagerness: "moderate"
+      }
+    ]
+  });
+}
+export {
+  generateSpeculationRulesContent
+};

package/dist/runtime/server/render/head.js

@@ -53,6 +53,16 @@ function renderAllHeadContent(result) {
   );
   const sep = result.compressHTML === true || result.compressHTML === "jsx" ? "" : "\n";
   content += styles.join(sep) + links.join(sep) + scripts.join(sep);
+  if (result.speculationRulesContent) {
+    content += renderElement(
+      "script",
+      {
+        props: { type: "speculationrules" },
+        children: result.speculationRulesContent
+      },
+      false
+    );
+  }
   content += result._metadata.extraHead.join("");
   return markHTMLString(content);
 }