astro 4.7.1 → 4.8.0

package/dist/core/build/pipeline.js

@@ -1,21 +1,21 @@
-import { getOutputDirectory, isServerLikeOutput } from "../../prerender/utils.js";
+import { getOutputDirectory } from "../../prerender/utils.js";
 import { BEFORE_HYDRATION_SCRIPT_ID, PAGE_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
+import { RouteNotFound } from "../errors/errors-data.js";
+import { AstroError } from "../errors/index.js";
 import { routeIsFallback, routeIsRedirect } from "../redirects/helpers.js";
+import { RedirectSinglePageBuiltModule } from "../redirects/index.js";
 import { Pipeline } from "../render/index.js";
 import {
   createAssetLink,
   createModuleScriptsSet,
   createStylesheetElementSet
 } from "../render/ssr-element.js";
-import {
-  cssOrder,
-  getPageDataByComponent,
-  mergeInlineCss
-} from "./internal.js";
+import { isServerLikeOutput } from "../util.js";
+import { getOutDirWithinCwd } from "./common.js";
+import { cssOrder, getPageData, mergeInlineCss } from "./internal.js";
 import { ASTRO_PAGE_MODULE_ID, ASTRO_PAGE_RESOLVED_MODULE_ID } from "./plugins/plugin-pages.js";
 import { RESOLVED_SPLIT_MODULE_ID } from "./plugins/plugin-ssr.js";
-import { getVirtualModulePageNameFromPath } from "./plugins/util.js";
-import { ASTRO_PAGE_EXTENSION_POST_PATTERN } from "./plugins/util.js";
+import { getPagesFromVirtualModulePageName, getVirtualModulePageName } from "./plugins/util.js";
 import { i18nHasFallback } from "./util.js";
 class BuildPipeline extends Pipeline {
   constructor(internals, manifest, options, config = options.settings.config, settings = options.settings) {
@@ -53,6 +53,16 @@ class BuildPipeline extends Pipeline {
     this.config = config;
     this.settings = settings;
   }
+  #componentsInterner = /* @__PURE__ */ new WeakMap();
+  /**
+   * This cache is needed to map a single `RouteData` to its file path.
+   * @private
+   */
+  #routesByFilePath = /* @__PURE__ */ new WeakMap();
+  get outFolder() {
+    const ssr = isServerLikeOutput(this.settings.config);
+    return ssr ? this.settings.config.build.server : getOutDirWithinCwd(this.settings.config.outDir);
+  }
   static create({
     internals,
     manifest,
@@ -107,7 +117,7 @@ class BuildPipeline extends Pipeline {
       settings
     } = this;
     const links = /* @__PURE__ */ new Set();
-    const pageBuildData = getPageDataByComponent(internals, routeData.component);
+    const pageBuildData = getPageData(internals, routeData.route, routeData.component);
     const scripts = createModuleScriptsSet(
       pageBuildData?.hoistedScript ? [pageBuildData.hoistedScript] : [],
       base,
@@ -140,38 +150,139 @@ class BuildPipeline extends Pipeline {
   }
   /**
    * It collects the routes to generate during the build.
-   *
    * It returns a map of page information and their relative entry point as a string.
    */
   retrieveRoutesToGenerate() {
     const pages = /* @__PURE__ */ new Map();
-    for (const [entrypoint, filePath] of this.internals.entrySpecifierToBundleMap) {
-      if (entrypoint.includes(ASTRO_PAGE_RESOLVED_MODULE_ID) || entrypoint.includes(RESOLVED_SPLIT_MODULE_ID)) {
-        const [, pageName] = entrypoint.split(":");
-        const pageData = this.internals.pagesByComponent.get(
-          `${pageName.replace(ASTRO_PAGE_EXTENSION_POST_PATTERN, ".")}`
-        );
-        if (!pageData) {
-          throw new Error(
-            "Build failed. Astro couldn't find the emitted page from " + pageName + " pattern"
+    for (const [virtualModulePageName, filePath] of this.internals.entrySpecifierToBundleMap) {
+      if (virtualModulePageName.includes(ASTRO_PAGE_RESOLVED_MODULE_ID) || virtualModulePageName.includes(RESOLVED_SPLIT_MODULE_ID)) {
+        let pageDatas = [];
+        if (virtualModulePageName.includes(ASTRO_PAGE_RESOLVED_MODULE_ID)) {
+          pageDatas.push(
+            ...getPagesFromVirtualModulePageName(
+              this.internals,
+              ASTRO_PAGE_RESOLVED_MODULE_ID,
+              virtualModulePageName
+            )
+          );
+        }
+        if (virtualModulePageName.includes(RESOLVED_SPLIT_MODULE_ID)) {
+          pageDatas.push(
+            ...getPagesFromVirtualModulePageName(
+              this.internals,
+              RESOLVED_SPLIT_MODULE_ID,
+              virtualModulePageName
+            )
           );
         }
-        pages.set(pageData, filePath);
+        for (const pageData of pageDatas) {
+          pages.set(pageData, filePath);
+        }
       }
     }
-    for (const [path, pageData] of this.internals.pagesByComponent.entries()) {
+    for (const pageData of this.internals.pagesByKeys.values()) {
       if (routeIsRedirect(pageData.route)) {
-        pages.set(pageData, path);
+        pages.set(pageData, pageData.component);
       } else if (routeIsFallback(pageData.route) && (i18nHasFallback(this.config) || routeIsFallback(pageData.route) && pageData.route.route === "/")) {
-        const moduleSpecifier = getVirtualModulePageNameFromPath(ASTRO_PAGE_MODULE_ID, path);
+        const moduleSpecifier = getVirtualModulePageName(ASTRO_PAGE_MODULE_ID, pageData.component);
         const filePath = this.internals.entrySpecifierToBundleMap.get(moduleSpecifier);
         if (filePath) {
           pages.set(pageData, filePath);
         }
       }
     }
+    for (const [buildData, filePath] of pages.entries()) {
+      this.#routesByFilePath.set(buildData.route, filePath);
+    }
     return pages;
   }
+  async getComponentByRoute(routeData) {
+    if (this.#componentsInterner.has(routeData)) {
+      const entry = this.#componentsInterner.get(routeData);
+      return await entry.page();
+    } else {
+      const filePath = this.#routesByFilePath.get(routeData);
+      const module = await this.retrieveSsrEntry(routeData, filePath);
+      return module.page();
+    }
+  }
+  async tryRewrite(payload) {
+    let foundRoute;
+    for (const route of this.options.manifest.routes) {
+      if (payload instanceof URL) {
+        if (route.pattern.test(payload.pathname)) {
+          foundRoute = route;
+          break;
+        }
+      } else if (payload instanceof Request) {
+        const url = new URL(payload.url);
+        if (route.pattern.test(url.pathname)) {
+          foundRoute = route;
+          break;
+        }
+      } else if (route.pattern.test(decodeURI(payload))) {
+        foundRoute = route;
+        break;
+      }
+    }
+    if (foundRoute) {
+      const componentInstance = await this.getComponentByRoute(foundRoute);
+      return [foundRoute, componentInstance];
+    } else {
+      throw new AstroError(RouteNotFound);
+    }
+  }
+  async retrieveSsrEntry(route, filePath) {
+    if (this.#componentsInterner.has(route)) {
+      return this.#componentsInterner.get(route);
+    }
+    let entry;
+    if (routeIsRedirect(route)) {
+      entry = await this.#getEntryForRedirectRoute(route, this.internals, this.outFolder);
+    } else if (routeIsFallback(route)) {
+      entry = await this.#getEntryForFallbackRoute(route, this.internals, this.outFolder);
+    } else {
+      const ssrEntryURLPage = createEntryURL(filePath, this.outFolder);
+      entry = await import(ssrEntryURLPage.toString());
+    }
+    this.#componentsInterner.set(route, entry);
+    return entry;
+  }
+  async #getEntryForFallbackRoute(route, internals, outFolder) {
+    if (route.type !== "fallback") {
+      throw new Error(`Expected a redirect route.`);
+    }
+    if (route.redirectRoute) {
+      const filePath = getEntryFilePath(this.internals, route.redirectRoute);
+      if (filePath) {
+        const url = createEntryURL(filePath, outFolder);
+        const ssrEntryPage = await import(url.toString());
+        return ssrEntryPage;
+      }
+    }
+    return RedirectSinglePageBuiltModule;
+  }
+  async #getEntryForRedirectRoute(route, internals, outFolder) {
+    if (route.type !== "redirect") {
+      throw new Error(`Expected a redirect route.`);
+    }
+    if (route.redirectRoute) {
+      const filePath = getEntryFilePath(this.internals, route.redirectRoute);
+      if (filePath) {
+        const url = createEntryURL(filePath, outFolder);
+        const ssrEntryPage = await import(url.toString());
+        return ssrEntryPage;
+      }
+    }
+    return RedirectSinglePageBuiltModule;
+  }
+}
+function createEntryURL(filePath, outFolder) {
+  return new URL("./" + filePath + `?time=${Date.now()}`, outFolder);
+}
+function getEntryFilePath(internals, pageData) {
+  const id = "\0" + getVirtualModulePageName(ASTRO_PAGE_MODULE_ID, pageData.component);
+  return internals.entrySpecifierToBundleMap.get(id);
 }
 export {
   BuildPipeline

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

@@ -27,29 +27,12 @@ function vitePluginAnalyzer(options, internals) {
         if (hoistedScripts.size) {
           for (const parentInfo of getParentModuleInfos(from, this, isPropagatedAsset)) {
             if (isPropagatedAsset(parentInfo.id)) {
-              for (const nestedParentInfo of getParentModuleInfos(from, this)) {
-                if (moduleIsTopLevelPage(nestedParentInfo)) {
-                  for (const hid of hoistedScripts) {
-                    if (!pageScripts.has(nestedParentInfo.id)) {
-                      pageScripts.set(nestedParentInfo.id, {
-                        hoistedSet: /* @__PURE__ */ new Set(),
-                        propagatedMapByImporter: /* @__PURE__ */ new Map()
-                      });
-                    }
-                    const entry = pageScripts.get(nestedParentInfo.id);
-                    if (!entry.propagatedMapByImporter.has(parentInfo.id)) {
-                      entry.propagatedMapByImporter.set(parentInfo.id, /* @__PURE__ */ new Set());
-                    }
-                    entry.propagatedMapByImporter.get(parentInfo.id).add(hid);
-                  }
-                }
-              }
+              internals.propagatedScriptsMap.set(parentInfo.id, hoistedScripts);
             } else if (moduleIsTopLevelPage(parentInfo)) {
               for (const hid of hoistedScripts) {
                 if (!pageScripts.has(parentInfo.id)) {
                   pageScripts.set(parentInfo.id, {
-                    hoistedSet: /* @__PURE__ */ new Set(),
-                    propagatedMapByImporter: /* @__PURE__ */ new Map()
+                    hoistedSet: /* @__PURE__ */ new Set()
                   });
                 }
                 pageScripts.get(parentInfo.id)?.hoistedSet.add(hid);
@@ -59,10 +42,14 @@ function vitePluginAnalyzer(options, internals) {
         }
       },
       finalize() {
-        for (const [pageId, { hoistedSet, propagatedMapByImporter }] of pageScripts) {
+        for (const propagatedScripts of internals.propagatedScriptsMap.values()) {
+          for (const propagatedScript of propagatedScripts) {
+            internals.discoveredScripts.add(propagatedScript);
+          }
+        }
+        for (const [pageId, { hoistedSet }] of pageScripts) {
           const pageData = getPageDataByViteID(internals, pageId);
-          if (!pageData)
-            continue;
+          if (!pageData) continue;
           const { component } = pageData;
           const astroModuleId = prependForwardSlash(component);
           const uniqueHoistedId = JSON.stringify(Array.from(hoistedSet).sort());
@@ -74,12 +61,6 @@ function vitePluginAnalyzer(options, internals) {
             uniqueHoistedIds.set(uniqueHoistedId, moduleId);
           }
           internals.discoveredScripts.add(moduleId);
-          pageData.propagatedScripts = propagatedMapByImporter;
-          for (const propagatedScripts of propagatedMapByImporter.values()) {
-            for (const propagatedScript of propagatedScripts) {
-              internals.discoveredScripts.add(propagatedScript);
-            }
-          }
           if (internals.hoistedScriptIdToPagesMap.has(moduleId)) {
             const pages = internals.hoistedScriptIdToPagesMap.get(moduleId);
             pages.add(astroModuleId);
@@ -100,8 +81,7 @@ function vitePluginAnalyzer(options, internals) {
       const ids = this.getModuleIds();
       for (const id of ids) {
         const info = this.getModuleInfo(id);
-        if (!info?.meta?.astro)
-          continue;
+        if (!info?.meta?.astro) continue;
         const astro = info.meta.astro;
         const pageData = getPageDataByViteID(internals, id);
         if (pageData) {
@@ -135,8 +115,7 @@ function vitePluginAnalyzer(options, internals) {
           }
           for (const pageInfo of getTopLevelPageModuleInfos(id, this)) {
             const newPageData = getPageDataByViteID(internals, pageInfo.id);
-            if (!newPageData)
-              continue;
+            if (!newPageData) continue;
             trackClientOnlyPageDatas(internals, newPageData, clientOnlys);
           }
         }

package/dist/core/build/plugins/plugin-content.d.ts

@@ -1,4 +1,5 @@
 import { type BuildInternals } from '../internal.js';
 import type { AstroBuildPlugin } from '../plugin.js';
 import type { StaticBuildOptions } from '../types.js';
+export declare function copyContentToCache(opts: StaticBuildOptions): Promise<void>;
 export declare function pluginContent(opts: StaticBuildOptions, internals: BuildInternals): AstroBuildPlugin;

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

@@ -9,7 +9,6 @@ import {
   generateContentEntryFile,
   generateLookupMap
 } from "../../../content/vite-plugin-content-virtual-mod.js";
-import { isServerLikeOutput } from "../../../prerender/utils.js";
 import { configPaths } from "../../config/index.js";
 import { emptyDir } from "../../fs/index.js";
 import {
@@ -18,6 +17,7 @@ import {
   removeFileExtension,
   removeLeadingForwardSlash
 } from "../../path.js";
+import { isContentCollectionsCacheEnabled } from "../../util.js";
 import { addRollupInput } from "../add-rollup-input.js";
 import { CHUNKS_PATH } from "../consts.js";
 import {} from "../internal.js";
@@ -40,14 +40,14 @@ function createContentManifest() {
     configs: ""
   };
 }
+const getContentRoot = (config) => new URL("./content/", config.outDir);
+const getContentCacheDir = (config) => new URL(CONTENT_CACHE_DIR, config.cacheDir);
+const getCacheTmp = (contentCacheDir) => new URL("./.tmp/", contentCacheDir);
 function vitePluginContent(opts, lookupMap, internals, cachedBuildOutput) {
   const { config } = opts.settings;
-  const { cacheDir } = config;
-  const distRoot = config.outDir;
-  const distContentRoot = new URL("./content/", distRoot);
-  const contentCacheDir = new URL(CONTENT_CACHE_DIR, cacheDir);
+  const distContentRoot = getContentRoot(config);
+  const contentCacheDir = getContentCacheDir(config);
   const contentManifestFile = new URL(CONTENT_MANIFEST_FILE, contentCacheDir);
-  const cacheTmp = new URL("./.tmp/", contentCacheDir);
   let oldManifest = createContentManifest();
   let newManifest = createContentManifest();
   let entries;
@@ -105,6 +105,10 @@ function vitePluginContent(opts, lookupMap, internals, cachedBuildOutput) {
             await copyFiles(cached, dist, true);
           }
         }
+        const cacheExists = fsMod.existsSync(contentCacheDir);
+        if (cacheExists) {
+          await copyFiles(contentCacheDir, distContentRoot, false);
+        }
       }
       if (entries.buildFromSource.length === 0) {
         newOptions = addRollupInput(newOptions, [virtualEmptyModuleId]);
@@ -115,6 +119,7 @@ function vitePluginContent(opts, lookupMap, internals, cachedBuildOutput) {
     outputOptions(outputOptions) {
       const rootPath = normalizePath(fileURLToPath(opts.settings.config.root));
       const srcPath = normalizePath(fileURLToPath(opts.settings.config.srcDir));
+      const entryCache = /* @__PURE__ */ new Map();
       extendManualChunks(outputOptions, {
         before(id, meta) {
           if (id.startsWith(srcPath) && id.slice(srcPath.length).startsWith("content")) {
@@ -127,7 +132,11 @@ function vitePluginContent(opts, lookupMap, internals, cachedBuildOutput) {
               return resultId;
             }
             const [srcRelativePath, flag] = id.replace(rootPath, "/").split("?");
-            const collectionEntry = findEntryFromSrcRelativePath(lookupMap, srcRelativePath);
+            const collectionEntry = findEntryFromSrcRelativePath(
+              lookupMap,
+              srcRelativePath,
+              entryCache
+            );
             if (collectionEntry) {
               let suffix = ".mjs";
               if (flag === PROPAGATED_ASSET_FLAG) {
@@ -169,12 +178,10 @@ export default {}`
         code,
         fileName: "content/entry.mjs"
       });
-      if (!injectedEmptyFile)
-        return;
+      if (!injectedEmptyFile) return;
       Object.keys(bundle).forEach((key) => {
         const mod = bundle[key];
-        if (mod.type === "asset")
-          return;
+        if (mod.type === "asset") return;
         if (mod.facadeModuleId === resolvedVirtualEmptyModuleId) {
           delete bundle[key];
         }
@@ -184,8 +191,7 @@ export default {}`
       const clientComponents = /* @__PURE__ */ new Set([
         ...oldManifest.clientEntries,
         ...internals.discoveredHydratedComponents.keys(),
-        ...internals.discoveredClientOnlyComponents.keys(),
-        ...internals.discoveredScripts
+        ...internals.discoveredClientOnlyComponents.keys()
       ]);
       const serverComponents = /* @__PURE__ */ new Set([
         ...oldManifest.serverEntries,
@@ -201,21 +207,12 @@ export default {}`
       await fsMod.promises.writeFile(contentManifestFile, JSON.stringify(newManifest), {
         encoding: "utf8"
       });
-      await fsMod.promises.mkdir(cacheTmp, { recursive: true });
-      await copyFiles(distContentRoot, cacheTmp, true);
-      if (cacheExists && currentManifestState === "valid") {
-        await copyFiles(contentCacheDir, distContentRoot, false);
-      }
-      await copyFiles(cacheTmp, contentCacheDir);
-      await fsMod.promises.rm(cacheTmp, { recursive: true, force: true });
     }
   };
 }
-const entryCache = /* @__PURE__ */ new Map();
-function findEntryFromSrcRelativePath(lookupMap, srcRelativePath) {
+function findEntryFromSrcRelativePath(lookupMap, srcRelativePath, entryCache) {
   let value = entryCache.get(srcRelativePath);
-  if (value)
-    return value;
+  if (value) return value;
   for (const collection of Object.values(lookupMap)) {
     for (const entry of Object.values(collection)) {
       for (const entryFile of Object.values(entry)) {
@@ -335,6 +332,16 @@ function collectionTypeToFlag(type) {
   const name = type[0].toUpperCase() + type.slice(1);
   return `astro${name}CollectionEntry`;
 }
+async function copyContentToCache(opts) {
+  const { config } = opts.settings;
+  const distContentRoot = getContentRoot(config);
+  const contentCacheDir = getContentCacheDir(config);
+  const cacheTmp = getCacheTmp(contentCacheDir);
+  await fsMod.promises.mkdir(cacheTmp, { recursive: true });
+  await copyFiles(distContentRoot, cacheTmp, true);
+  await copyFiles(cacheTmp, contentCacheDir);
+  await fsMod.promises.rm(cacheTmp, { recursive: true, force: true });
+}
 function pluginContent(opts, internals) {
   const { cacheDir, outDir } = opts.settings.config;
   const chunksFolder = "./" + CHUNKS_PATH;
@@ -347,10 +354,7 @@ function pluginContent(opts, internals) {
     targets: ["server"],
     hooks: {
       async "build:before"() {
-        if (!opts.settings.config.experimental.contentCollectionCache) {
-          return { vitePlugin: void 0 };
-        }
-        if (isServerLikeOutput(opts.settings.config)) {
+        if (!isContentCollectionsCacheEnabled(opts.settings.config)) {
           return { vitePlugin: void 0 };
         }
         const lookupMap = await generateLookupMap({ settings: opts.settings, fs: fsMod });
@@ -359,10 +363,7 @@ function pluginContent(opts, internals) {
         };
       },
       async "build:post"() {
-        if (!opts.settings.config.experimental.contentCollectionCache) {
-          return;
-        }
-        if (isServerLikeOutput(opts.settings.config)) {
+        if (!isContentCollectionsCacheEnabled(opts.settings.config)) {
           return;
         }
         for (const { cached, dist } of cachedBuildOutput) {
@@ -375,5 +376,6 @@ function pluginContent(opts, internals) {
   };
 }
 export {
+  copyContentToCache,
   pluginContent
 };

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

@@ -1,5 +1,4 @@
 import { isBuildableCSSRequest } from "../../../vite-plugin-astro-server/util.js";
-import { RESOLVED_VIRTUAL_MODULE_ID as ASTRO_CONTENT_VIRTUAL_MODULE_ID } from "../../../content/consts.js";
 import { hasAssetPropagationFlag } from "../../../content/index.js";
 import * as assetName from "../css-asset-name.js";
 import {
@@ -8,11 +7,9 @@ import {
   moduleIsTopLevelPage
 } from "../graph.js";
 import {
-  eachPageData,
   getPageDataByViteID,
   getPageDatasByClientOnlyID,
-  getPageDatasByHoistedScriptId,
-  isHoistedScript
+  getPageDatasByHoistedScriptId
 } from "../internal.js";
 import { extendManualChunks, shouldInlineAsset } from "./util.js";
 function pluginCSS(options, internals) {
@@ -37,8 +34,7 @@ function rollupPluginAstroBuildCSS(options) {
   const { settings } = buildOptions;
   let resolvedConfig;
   const pagesToCss = {};
-  const pagesToPropagatedCss = {};
-  const isContentCollectionCache = options.buildOptions.settings.config.output === "static" && options.buildOptions.settings.config.experimental.contentCollectionCache;
+  const moduleIdToPropagatedCss = {};
   const cssBuildPlugin = {
     name: "astro:rollup-plugin-build-css",
     outputOptions(outputOptions) {
@@ -68,13 +64,10 @@ function rollupPluginAstroBuildCSS(options) {
     },
     async generateBundle(_outputOptions, bundle) {
       for (const [, chunk] of Object.entries(bundle)) {
-        if (chunk.type !== "chunk")
-          continue;
-        if ("viteMetadata" in chunk === false)
-          continue;
+        if (chunk.type !== "chunk") continue;
+        if ("viteMetadata" in chunk === false) continue;
         const meta = chunk.viteMetadata;
-        if (meta.importedCss.size < 1)
-          continue;
+        if (meta.importedCss.size < 1) continue;
         if (options.target === "client") {
           for (const id of Object.keys(chunk.modules)) {
             for (const pageData of getParentClientOnlys(id, this, internals)) {
@@ -89,19 +82,9 @@ function rollupPluginAstroBuildCSS(options) {
           const parentModuleInfos = getParentExtendedModuleInfos(id, this, hasAssetPropagationFlag);
           for (const { info: pageInfo, depth, order } of parentModuleInfos) {
             if (hasAssetPropagationFlag(pageInfo.id)) {
-              const walkId = isContentCollectionCache ? ASTRO_CONTENT_VIRTUAL_MODULE_ID : id;
-              for (const parentInfo of getParentModuleInfos(walkId, this)) {
-                if (moduleIsTopLevelPage(parentInfo) === false)
-                  continue;
-                const pageViteID = parentInfo.id;
-                const pageData = getPageDataByViteID(internals, pageViteID);
-                if (pageData === void 0)
-                  continue;
-                for (const css of meta.importedCss) {
-                  const propagatedStyles = pagesToPropagatedCss[pageData.moduleSpecifier] ??= {};
-                  const existingCss = propagatedStyles[pageInfo.id] ??= /* @__PURE__ */ new Set();
-                  existingCss.add(css);
-                }
+              const propagatedCss = moduleIdToPropagatedCss[pageInfo.id] ??= /* @__PURE__ */ new Set();
+              for (const css of meta.importedCss) {
+                propagatedCss.add(css);
               }
             } else if (moduleIsTopLevelPage(pageInfo)) {
               const pageViteID = pageInfo.id;
@@ -109,7 +92,7 @@ function rollupPluginAstroBuildCSS(options) {
               if (pageData) {
                 appendCSSToPage(pageData, meta, pagesToCss, depth, order);
               }
-            } else if (options.target === "client" && isHoistedScript(internals, pageInfo.id)) {
+            } else if (options.target === "client" && internals.hoistedScriptIdToPagesMap.has(pageInfo.id)) {
               for (const pageData of getPageDatasByHoistedScriptId(internals, pageInfo.id)) {
                 appendCSSToPage(pageData, meta, pagesToCss, -1, order);
               }
@@ -142,14 +125,12 @@ function rollupPluginAstroBuildCSS(options) {
       resolvedConfig = config;
     },
     generateBundle(_, bundle) {
-      if (resolvedConfig.build.cssCodeSplit)
-        return;
+      if (resolvedConfig.build.cssCodeSplit) return;
       const cssChunk = Object.values(bundle).find(
         (chunk) => chunk.type === "asset" && chunk.name === "style.css"
       );
-      if (cssChunk === void 0)
-        return;
-      for (const pageData of eachPageData(internals)) {
+      if (cssChunk === void 0) return;
+      for (const pageData of internals.pagesByKeys.values()) {
         const cssToInfoMap = pagesToCss[pageData.moduleSpecifier] ??= {};
         cssToInfoMap[cssChunk.fileName] = { depth: -1, order: -1 };
       }
@@ -169,33 +150,24 @@ function rollupPluginAstroBuildCSS(options) {
           return;
         const toBeInlined = inlineConfig === "always" ? true : inlineConfig === "never" ? false : shouldInlineAsset(stylesheet.source, stylesheet.fileName, assetsInlineLimit);
         const sheet = toBeInlined ? { type: "inline", content: stylesheet.source } : { type: "external", src: stylesheet.fileName };
-        const pages = Array.from(eachPageData(internals));
         let sheetAddedToPage = false;
-        pages.forEach((pageData) => {
+        internals.pagesByKeys.forEach((pageData) => {
           const orderingInfo = pagesToCss[pageData.moduleSpecifier]?.[stylesheet.fileName];
           if (orderingInfo !== void 0) {
             pageData.styles.push({ ...orderingInfo, sheet });
             sheetAddedToPage = true;
-            return;
           }
-          const propagatedPaths = pagesToPropagatedCss[pageData.moduleSpecifier];
-          if (propagatedPaths === void 0)
-            return;
-          Object.entries(propagatedPaths).forEach(([pageInfoId, css]) => {
-            if (css.has(stylesheet.fileName) !== true)
-              return;
-            if (pageData.styles.some((s) => s.sheet === sheet))
-              return;
-            let propagatedStyles;
-            if (isContentCollectionCache) {
-              propagatedStyles = internals.propagatedStylesMap.get(pageInfoId) ?? internals.propagatedStylesMap.set(pageInfoId, /* @__PURE__ */ new Set()).get(pageInfoId);
-            } else {
-              propagatedStyles = pageData.propagatedStyles.get(pageInfoId) ?? pageData.propagatedStyles.set(pageInfoId, /* @__PURE__ */ new Set()).get(pageInfoId);
-            }
-            propagatedStyles.add(sheet);
-            sheetAddedToPage = true;
-          });
         });
+        for (const moduleId in moduleIdToPropagatedCss) {
+          if (!moduleIdToPropagatedCss[moduleId].has(stylesheet.fileName)) continue;
+          let propagatedStyles = internals.propagatedStylesMap.get(moduleId);
+          if (!propagatedStyles) {
+            propagatedStyles = /* @__PURE__ */ new Set();
+            internals.propagatedStylesMap.set(moduleId, propagatedStyles);
+          }
+          propagatedStyles.add(sheet);
+          sheetAddedToPage = true;
+        }
         if (toBeInlined && sheetAddedToPage) {
           delete bundle[id];
           for (const chunk of Object.values(bundle)) {

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

@@ -11,6 +11,7 @@ import { serializeRouteData } from "../../routing/index.js";
 import { addRollupInput } from "../add-rollup-input.js";
 import { getOutFile, getOutFolder } from "../common.js";
 import { cssOrder, mergeInlineCss } from "../internal.js";
+import { makePageDataKey } from "./util.js";
 const manifestReplace = "@@ASTRO_MANIFEST_REPLACE@@";
 const replaceExp = new RegExp(`['"]${manifestReplace}['"]`, "g");
 const SSR_MANIFEST_VIRTUAL_MODULE_ID = "@astrojs-manifest";
@@ -128,10 +129,8 @@ function buildManifest(opts, internals, staticFiles) {
     }
   };
   for (const route of opts.manifest.routes) {
-    if (!route.prerender)
-      continue;
-    if (!route.pathname)
-      continue;
+    if (!route.prerender) continue;
+    if (!route.pathname) continue;
     const outFolder = getOutFolder(opts.settings.config, route.pathname, route);
     const outFile = getOutFile(opts.settings.config, outFolder, route.pathname, route);
     const file = outFile.toString().replace(opts.settings.config.build.client.toString(), "");
@@ -145,9 +144,8 @@ function buildManifest(opts, internals, staticFiles) {
     staticFiles.push(file);
   }
   for (const route of opts.manifest.routes) {
-    const pageData = internals.pagesByComponent.get(route.component);
-    if (route.prerender || !pageData)
-      continue;
+    const pageData = internals.pagesByKeys.get(makePageDataKey(route.route, route.component));
+    if (route.prerender || !pageData) continue;
     const scripts = [];
     if (pageData.hoistedScript) {
       const shouldPrefixAssetPath = pageData.hoistedScript.type === "external";
@@ -214,7 +212,8 @@ function buildManifest(opts, internals, staticFiles) {
     assets: staticFiles.map(prefixAssetPath),
     i18n: i18nManifest,
     buildFormat: settings.config.build.format,
-    checkOrigin: settings.config.experimental.security?.csrfProtection?.origin ?? false
+    checkOrigin: settings.config.experimental.security?.csrfProtection?.origin ?? false,
+    rewritingEnabled: settings.config.experimental.rewriting
   };
 }
 export {

package/dist/core/build/plugins/plugin-pages.d.ts

@@ -3,5 +3,4 @@ import type { AstroBuildPlugin } from '../plugin.js';
 import type { StaticBuildOptions } from '../types.js';
 export declare const ASTRO_PAGE_MODULE_ID = "@astro-page:";
 export declare const ASTRO_PAGE_RESOLVED_MODULE_ID: string;
-export declare function getVirtualModulePageIdFromPath(path: string): string;
 export declare function pluginPages(opts: StaticBuildOptions, internals: BuildInternals): AstroBuildPlugin;