astro 7.2.1 → 7.2.3

package/dist/core/app/prepare-response.d.ts

@@ -3,7 +3,7 @@
  * and marks the response as sent.
  *
  * This is a pure function with no dependencies on the app; it is shared by
- * `AstroHandler` and the various error handlers.
+ * `handleRequest` and the various error handlers.
  */
 export declare function prepareResponse(response: Response, { addCookieHeader }: {
     addCookieHeader: boolean;

package/dist/core/app/validate-headers.js

@@ -9,6 +9,7 @@ function sanitizeHost(hostname) {
 }
 function parseHost(host) {
   const parts = host.split(":");
+  if (parts.length > 2) return void 0;
   return {
     hostname: parts[0],
     port: parts[1]
@@ -28,7 +29,9 @@ function validateHost(host, protocol, allowedDomains) {
   if (!allowedDomains || allowedDomains.length === 0) return void 0;
   const sanitized = sanitizeHost(host);
   if (!sanitized) return void 0;
-  const { hostname, port } = parseHost(sanitized);
+  const parsed = parseHost(sanitized);
+  if (!parsed) return void 0;
+  const { hostname, port } = parsed;
   if (matchesAllowedDomains(hostname, protocol, port, allowedDomains)) {
     return sanitized;
   }
@@ -67,8 +70,9 @@ function validateForwardedHeaders(forwardedProtocol, forwardedHost, forwardedPor
   if (forwardedHost && forwardedHost.length > 0 && allowedDomains && allowedDomains.length > 0) {
     const protoForValidation = result.protocol || "https";
     const sanitized = sanitizeHost(forwardedHost);
-    if (sanitized) {
-      const { hostname, port: portFromHost } = parseHost(sanitized);
+    const parsed = sanitized ? parseHost(sanitized) : void 0;
+    if (sanitized && parsed) {
+      const { hostname, port: portFromHost } = parsed;
       const portForValidation = result.port || portFromHost;
       if (matchesAllowedDomains(hostname, protoForValidation, portForValidation, allowedDomains)) {
         result.host = sanitized;

package/dist/core/build/app.d.ts

@@ -1,17 +1,42 @@
 import { BaseApp } from '../app/entrypoints/index.js';
+import type { LogRequestPayload } from '../app/base.js';
 import type { SSRManifest } from '../app/types.js';
+import type { ComponentInstance } from '../../types/astro.js';
+import type { RouteData } from '../../types/public/internal.js';
+import { type RouteCache } from '../render/route-cache.js';
+import type { BuildEnvironmentSlots } from './environment.js';
 import type { BuildInternals } from './internal.js';
-import { BuildPipeline } from './pipeline.js';
 import type { StaticBuildOptions } from './types.js';
-import type { LogRequestPayload } from '../app/base.js';
-import type { ErrorHandler } from '../errors/handler.js';
-export declare class BuildApp extends BaseApp<BuildPipeline> {
-    createPipeline(_streaming: boolean, manifest: SSRManifest, ..._args: any[]): BuildPipeline;
+/**
+ * The build / prerender facade: a thin shell over the
+ * build environment record. The two-phase init state (`setInternals` /
+ * `setOptions`, injected by `createDefaultPrerenderer.setup()` after the
+ * prerender bundle import) lives in the `BuildEnvironmentSlots` closure
+ * created by the prerender entrypoint; the facade only forwards across the
+ * bundle boundary into those slots.
+ */
+export declare class BuildApp extends BaseApp {
+    #private;
+    constructor(manifest: SSRManifest, buildEnv: BuildEnvironmentSlots);
     isDev(): boolean;
+    /**
+     * Streaming falls through to the environment default
+     * (`manifest.serverLike` for the build environment) — we can skip
+     * streaming in SSG for performance, as writing strings is faster.
+     */
+    protected resolveStreaming(): boolean | undefined;
     setInternals(internals: BuildInternals): void;
     setOptions(options: StaticBuildOptions): void;
     getOptions(): StaticBuildOptions;
     getSettings(): import("../../types/astro.js").AstroSettings;
-    protected createErrorHandler(): ErrorHandler;
+    /**
+     * Route cache and component loader for `StaticPaths`. Defined on the app
+     * (rather than reached through the functional core at the call site) so
+     * they execute inside the prerender bundle's module graph: the default
+     * prerenderer constructs `StaticPaths` from a different bundle, whose
+     * copies of the core modules hold separate per-manifest state.
+     */
+    get routeCache(): RouteCache;
+    getComponentByRoute(routeData: RouteData): Promise<ComponentInstance>;
     logRequest(_options: LogRequestPayload): void;
 }

package/dist/core/build/app.js

@@ -1,31 +1,49 @@
 import { BaseApp } from "../app/entrypoints/index.js";
-import { BuildPipeline } from "./pipeline.js";
-import { BuildErrorHandler } from "../errors/build-handler.js";
+import { getEnvironment } from "../environment/index.js";
+import { getRouteCache } from "../render/route-cache.js";
 class BuildApp extends BaseApp {
-  createPipeline(_streaming, manifest, ..._args) {
-    return BuildPipeline.create({
-      manifest
-    });
+  #buildEnv;
+  constructor(manifest, buildEnv) {
+    super(manifest);
+    this.#buildEnv = buildEnv;
   }
   isDev() {
     return true;
   }
+  /**
+   * Streaming falls through to the environment default
+   * (`manifest.serverLike` for the build environment) — we can skip
+   * streaming in SSG for performance, as writing strings is faster.
+   */
+  resolveStreaming() {
+    return void 0;
+  }
   setInternals(internals) {
-    this.pipeline.setInternals(internals);
+    this.#buildEnv.setInternals(internals);
   }
   setOptions(options) {
-    this.pipeline.setOptions(options);
+    this.#buildEnv.setOptions(options);
     this.logger.setDestination(options.logger.options.destination);
     this.resetAdapterLogger();
   }
   getOptions() {
-    return this.pipeline.getOptions();
+    return this.#buildEnv.getOptions();
   }
   getSettings() {
-    return this.pipeline.getSettings();
-  }
-  createErrorHandler() {
-    return new BuildErrorHandler(this);
+    return this.#buildEnv.getSettings();
+  }
+  /**
+   * Route cache and component loader for `StaticPaths`. Defined on the app
+   * (rather than reached through the functional core at the call site) so
+   * they execute inside the prerender bundle's module graph: the default
+   * prerenderer constructs `StaticPaths` from a different bundle, whose
+   * copies of the core modules hold separate per-manifest state.
+   */
+  get routeCache() {
+    return getRouteCache(this.manifest);
+  }
+  getComponentByRoute(routeData) {
+    return getEnvironment(this.manifest).getComponentByRoute(this.manifest, routeData);
   }
   logRequest(_options) {
   }

package/dist/core/build/environment.d.ts

@@ -0,0 +1,25 @@
+import type { AstroSettings } from '../../types/astro.js';
+import type { RenderEnvironment } from '../environment/index.js';
+import type { BuildInternals } from './internal.js';
+import type { StaticBuildOptions } from './types.js';
+/**
+ * The build / prerender environment record and its mutable closure slots.
+ * The build has a two-phase initialization: the prerender bundle is imported
+ * first, and `createDefaultPrerenderer.setup()` injects `BuildInternals` /
+ * `StaticBuildOptions` afterwards through the facade. The slots live in this
+ * closure; accessors throw before injection, and the environment functions
+ * close over the same slots.
+ */
+export interface BuildEnvironmentSlots {
+    /** The build `RenderEnvironment`; its functions close over the slots below. */
+    env: RenderEnvironment;
+    setInternals(internals: BuildInternals): void;
+    setOptions(options: StaticBuildOptions): void;
+    /** Throws `No internals defined` before injection. */
+    getInternals(): BuildInternals;
+    /** Throws `No options defined` before injection. */
+    getOptions(): StaticBuildOptions;
+    /** Throws `No options defined` before injection. */
+    getSettings(): AstroSettings;
+}
+export declare function createBuildEnvironment(): BuildEnvironmentSlots;

package/dist/core/build/environment.js

@@ -0,0 +1,157 @@
+import { BEFORE_HYDRATION_SCRIPT_ID, PAGE_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
+import { RedirectSinglePageBuiltModule } from "../redirects/index.js";
+import { createAssetLink, createStylesheetElementSet } from "../render/ssr-element.js";
+import { getDefaultRoutes } from "../routing/default.js";
+import { getFallbackRoute, routeIsFallback, routeIsRedirect } from "../routing/helpers.js";
+import { findRouteToRewrite } from "../routing/rewrite.js";
+import { cssOrder, getPageData, mergeInlineCss } from "./runtime.js";
+async function getModuleForRoute(manifest, route) {
+  for (const defaultRoute of getDefaultRoutes(manifest)) {
+    if (route.component === defaultRoute.component) {
+      return {
+        page: () => Promise.resolve(defaultRoute.instance)
+      };
+    }
+  }
+  let routeToProcess = route;
+  if (routeIsRedirect(route)) {
+    if (route.redirectRoute) {
+      routeToProcess = route.redirectRoute;
+    } else {
+      return RedirectSinglePageBuiltModule;
+    }
+  } else if (routeIsFallback(route)) {
+    routeToProcess = getFallbackRoute(route, manifest.routes);
+  }
+  if (manifest.pageMap) {
+    const importComponentInstance = manifest.pageMap.get(routeToProcess.component);
+    if (!importComponentInstance) {
+      throw new Error(`Unexpectedly unable to find a component instance for route ${route.route}`);
+    }
+    return await importComponentInstance();
+  } else if (manifest.pageModule) {
+    return manifest.pageModule;
+  }
+  throw new Error(
+    "Astro couldn't find the correct page to render, probably because it wasn't correctly mapped for SSR usage. This is an internal error, please file an issue."
+  );
+}
+async function getComponentByRoute(manifest, routeData) {
+  const module = await getModuleForRoute(manifest, routeData);
+  return module.page();
+}
+function createBuildEnvironment() {
+  let internals;
+  let options;
+  function getInternals() {
+    if (!internals) {
+      throw new Error("No internals defined");
+    }
+    return internals;
+  }
+  function getOptions() {
+    if (!options) {
+      throw new Error("No options defined");
+    }
+    return options;
+  }
+  function getSettings() {
+    return getOptions().settings;
+  }
+  const resolveCache = /* @__PURE__ */ new Map();
+  const env = {
+    name: "build",
+    runtimeMode: "production",
+    // We can skip streaming in SSG for performance as writing as strings is
+    // faster.
+    defaultStreaming: (manifest) => manifest.serverLike,
+    async resolve(manifest, specifier) {
+      if (resolveCache.has(specifier)) {
+        return resolveCache.get(specifier);
+      }
+      const hashedFilePath = manifest.entryModules[specifier];
+      if (typeof hashedFilePath !== "string" || hashedFilePath === "") {
+        if (specifier === BEFORE_HYDRATION_SCRIPT_ID) {
+          resolveCache.set(specifier, "");
+          return "";
+        }
+        throw new Error(`Cannot find the built path for ${specifier}`);
+      }
+      const assetLink = createAssetLink(hashedFilePath, manifest.base, manifest.assetsPrefix);
+      resolveCache.set(specifier, assetLink);
+      return assetLink;
+    },
+    headElements(manifest, routeData) {
+      const { assetsPrefix, base } = manifest;
+      const settings = getSettings();
+      const buildInternals = getInternals();
+      const links = /* @__PURE__ */ new Set();
+      const pageBuildData = getPageData(buildInternals, routeData.route, routeData.component);
+      const scripts = /* @__PURE__ */ new Set();
+      const sortedCssAssets = pageBuildData?.styles.sort(cssOrder).map(({ sheet }) => sheet).reduce(mergeInlineCss, []);
+      const styles = createStylesheetElementSet(sortedCssAssets ?? [], base, assetsPrefix);
+      if (settings.scripts.some((script) => script.stage === "page")) {
+        const hashedFilePath = buildInternals.entrySpecifierToBundleMap.get(PAGE_SCRIPT_ID);
+        if (typeof hashedFilePath !== "string") {
+          throw new Error(`Cannot find the built path for ${PAGE_SCRIPT_ID}`);
+        }
+        const src = createAssetLink(hashedFilePath, base, assetsPrefix);
+        scripts.add({
+          props: { type: "module", src },
+          children: ""
+        });
+      }
+      for (const script of settings.scripts) {
+        if (script.stage === "head-inline") {
+          scripts.add({
+            props: {},
+            children: script.content
+          });
+        }
+      }
+      return { scripts, styles, links };
+    },
+    componentMetadata() {
+    },
+    getComponentByRoute,
+    getModuleForRoute,
+    async tryRewrite(manifest, payload, request) {
+      const { routeData, pathname, newUrl } = findRouteToRewrite({
+        payload,
+        request,
+        // RAW manifest routes, exactly like `BuildPipeline.tryRewrite` — see
+        // the production environment's tryRewrite for why the derived
+        // (ensured-404) table is NOT observably identical here.
+        routes: manifest.routes.map((r) => r.routeData),
+        trailingSlash: manifest.trailingSlash,
+        buildFormat: manifest.buildFormat,
+        base: manifest.base,
+        outDir: manifest.serverLike ? manifest.buildClientDir : manifest.outDir
+      });
+      const componentInstance = await getComponentByRoute(manifest, routeData);
+      return { routeData, componentInstance, newUrl, pathname };
+    },
+    getRenderers(manifest) {
+      return manifest.renderers;
+    },
+    errorStrategy: "build",
+    injectCspMetaTagsOnErrorPages: false,
+    logRequest() {
+    }
+  };
+  return {
+    env,
+    setInternals(value) {
+      internals = value;
+    },
+    setOptions(value) {
+      options = value;
+    },
+    getInternals,
+    getOptions,
+    getSettings
+  };
+}
+export {
+  createBuildEnvironment
+};

package/dist/core/build/generate.js

@@ -222,7 +222,16 @@ ${colors.bgGreen(colors.black(` ${verb} static routes `))}`);
     if (prerenderer.collectStaticImages) {
       const adapterImages = await prerenderer.collectStaticImages();
       for (const [path, entry] of adapterImages) {
-        staticImageList.set(path, entry);
+        const existing = staticImageList.get(path);
+        if (existing) {
+          for (const [hash, transform] of entry.transforms) {
+            if (!existing.transforms.has(hash)) {
+              existing.transforms.set(hash, transform);
+            }
+          }
+        } else {
+          staticImageList.set(path, entry);
+        }
       }
     }
   } finally {

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,29 +8,13 @@ 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);
-    }
-  }
-  return [...deps].sort();
-}
 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) {
@@ -42,6 +27,9 @@ function resolveAssetPlaceholders(graph, code) {
       }
     });
   }
+  if (resolved.includes(FONTS_SERVER_ADDRESS_PLACEHOLDER)) {
+    resolved = resolved.replace(FONTS_ADDRESS_DECLARATION, "");
+  }
   return resolved;
 }
 function hashModules(graph, sortedIds) {
@@ -57,11 +45,131 @@ function hashModules(graph, sortedIds) {
   }
   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) {
@@ -75,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
@@ -98,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",
@@ -127,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()) {
@@ -135,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/cache/handler.d.ts

@@ -1,6 +1,6 @@
-import type { BaseApp } from '../app/base.js';
 import type { FetchState } from '../fetch/fetch-state.js';
-import type { Pipeline } from '../base-pipeline.js';
+import type { SSRManifest } from '../app/types.js';
+import { type CompiledCacheRoute } from './runtime/route-matching.js';
 /**
  * Registers a cache provider on the given `FetchState`. When
  * `state.resolve('cache')` is first called, the appropriate cache
@@ -22,8 +22,14 @@ export declare function provideCache(state: FetchState): Promise<void> | void;
  * Cache headers (`CDN-Cache-Control`, `Cache-Tag`) are stripped from
  * the final response after the runtime provider has read them.
  */
-export declare class CacheHandler {
-    #private;
-    constructor(app: BaseApp<Pipeline>);
-    handle(state: FetchState, next: () => Promise<Response>): Promise<Response>;
-}
+export declare function handleCache(state: FetchState, next: () => Promise<Response>): Promise<Response>;
+/**
+ * Config-level cache routes compiled from `manifest.cacheConfig`, derived
+ * lazily on the first cache-seeded request.
+ */
+export declare function getCompiledCacheRoutes(manifest: SSRManifest): CompiledCacheRoute[];
+/**
+ * Internal raw setter — exists only so the transitional `Pipeline` bridge can
+ * expose `compiledCacheRoutes` as a get/set pair.
+ */
+export declare function setCompiledCacheRoutes(manifest: SSRManifest, routes: CompiledCacheRoute[]): void;