astro 2.5.5 → 2.5.7

package/dist/content/vite-plugin-content-imports.js

@@ -3,16 +3,16 @@ import { extname } from "node:path";
 import { pathToFileURL } from "url";
 import { AstroErrorData } from "../core/errors/errors-data.js";
 import { AstroError } from "../core/errors/errors.js";
-import { escapeViteEnvReferences, getFileInfo } from "../vite-plugin-utils/index.js";
+import { escapeViteEnvReferences } from "../vite-plugin-utils/index.js";
 import { CONTENT_FLAG, DATA_FLAG } from "./consts.js";
 import {
-  getContentEntryConfigByExtMap,
   getContentEntryExts,
   getContentEntryIdAndSlug,
   getContentPaths,
   getDataEntryExts,
   getDataEntryId,
   getEntryCollectionName,
+  getEntryConfigByExtMap,
   getEntryData,
   getEntryType,
   globalContentConfigObserver,
@@ -40,13 +40,9 @@ function astroContentImportPlugin({
   const contentPaths = getContentPaths(settings.config, fs);
   const contentEntryExts = getContentEntryExts(settings);
   const dataEntryExts = getDataEntryExts(settings);
-  const contentEntryConfigByExt = getContentEntryConfigByExtMap(settings);
-  const dataEntryExtToParser = /* @__PURE__ */ new Map();
-  for (const entryType of settings.dataEntryTypes) {
-    for (const ext of entryType.extensions) {
-      dataEntryExtToParser.set(ext, entryType.getEntryInfo);
-    }
-  }
+  const contentEntryConfigByExt = getEntryConfigByExtMap(settings.contentEntryTypes);
+  const dataEntryConfigByExt = getEntryConfigByExtMap(settings.dataEntryTypes);
+  const { contentDir } = contentPaths;
   const plugins = [
     {
       name: "astro:content-imports",
@@ -55,9 +51,9 @@ function astroContentImportPlugin({
           const fileId = viteId.split("?")[0] ?? viteId;
           const { id, data, collection, _internal } = await getDataEntryModule({
             fileId,
-            dataEntryExtToParser,
-            contentPaths,
-            settings,
+            entryConfigByExt: dataEntryConfigByExt,
+            contentDir,
+            config: settings.config,
             fs,
             pluginContext: this
           });
@@ -74,8 +70,12 @@ export const _internal = {
           return code;
         } else if (hasContentFlag(viteId, CONTENT_FLAG)) {
           const fileId = viteId.split("?")[0];
-          const { id, slug, collection, body, data, _internal } = await setContentEntryModuleCache({
+          const { id, slug, collection, body, data, _internal } = await getContentEntryModule({
             fileId,
+            entryConfigByExt: contentEntryConfigByExt,
+            contentDir,
+            config: settings.config,
+            fs,
             pluginContext: this
           });
           const code = escapeViteEnvReferences(`
@@ -123,103 +123,115 @@ export const _internal = {
   if (settings.contentEntryTypes.some((t) => t.getRenderModule)) {
     plugins.push({
       name: "astro:content-render-imports",
-      async transform(_, viteId) {
+      async transform(contents, viteId) {
         const contentRenderer = getContentRendererByViteId(viteId, settings);
         if (!contentRenderer)
           return;
-        const { fileId } = getFileInfo(viteId, settings.config);
-        const entry = await getContentEntryModuleFromCache(fileId);
-        if (!entry) {
-          throw new AstroError({
-            ...AstroErrorData.UnknownContentCollectionError,
-            message: `Unable to render ${JSON.stringify(
-              fileId
-            )}. Did you import this module directly without using a content collection query?`
-          });
-        }
-        return contentRenderer.bind(this)({ entry, viteId });
+        const fileId = viteId.split("?")[0];
+        return contentRenderer.bind(this)({ viteId, contents, fileUrl: pathToFileURL(fileId) });
       }
     });
   }
-  const contentEntryModuleByIdCache = /* @__PURE__ */ new Map();
-  function isAwaitingQueue(cacheEntry) {
-    return typeof cacheEntry === "object" && cacheEntry != null && "awaitingQueue" in cacheEntry;
-  }
-  function getContentEntryModuleFromCache(id) {
-    const cacheEntry = contentEntryModuleByIdCache.get(id);
-    if (isAwaitingQueue(cacheEntry)) {
-      return new Promise((resolve, reject) => {
-        cacheEntry.awaitingQueue.push(resolve);
-      });
-    } else if (cacheEntry) {
-      return Promise.resolve(cacheEntry);
-    }
-    return Promise.resolve(void 0);
-  }
-  async function setContentEntryModuleCache({
-    fileId,
-    pluginContext
-  }) {
-    contentEntryModuleByIdCache.set(fileId, { awaitingQueue: [] });
-    const contentConfig = await getContentConfigFromGlobal();
-    const rawContents = await fs.promises.readFile(fileId, "utf-8");
-    const fileExt = extname(fileId);
-    if (!contentEntryConfigByExt.has(fileExt)) {
-      throw new AstroError({
-        ...AstroErrorData.UnknownContentCollectionError,
-        message: `No parser found for content entry ${JSON.stringify(
-          fileId
-        )}. Did you apply an integration for this file type?`
-      });
-    }
-    const contentEntryConfig = contentEntryConfigByExt.get(fileExt);
-    const {
-      rawData,
-      body,
-      slug: frontmatterSlug,
-      data: unvalidatedData
-    } = await contentEntryConfig.getEntryInfo({
-      fileUrl: pathToFileURL(fileId),
-      contents: rawContents
+  return plugins;
+}
+async function getContentEntryModule(params) {
+  const { fileId, contentDir, pluginContext, config } = params;
+  const { collectionConfig, entryConfig, entry, rawContents, collection } = await getEntryModuleBaseInfo(params);
+  const {
+    rawData,
+    data: unvalidatedData,
+    body,
+    slug: frontmatterSlug
+  } = await entryConfig.getEntryInfo({
+    fileUrl: pathToFileURL(fileId),
+    contents: rawContents
+  });
+  const _internal = { filePath: fileId, rawData };
+  const { id, slug: generatedSlug } = getContentEntryIdAndSlug({ entry, contentDir, collection });
+  const slug = parseEntrySlug({
+    id,
+    collection,
+    generatedSlug,
+    frontmatterSlug
+  });
+  const data = collectionConfig ? await getEntryData(
+    { id, collection, _internal, unvalidatedData },
+    collectionConfig,
+    pluginContext,
+    config
+  ) : unvalidatedData;
+  const contentEntryModule = {
+    id,
+    slug,
+    collection,
+    data,
+    body,
+    _internal
+  };
+  return contentEntryModule;
+}
+async function getDataEntryModule(params) {
+  const { fileId, contentDir, pluginContext, config } = params;
+  const { collectionConfig, entryConfig, entry, rawContents, collection } = await getEntryModuleBaseInfo(params);
+  const { rawData = "", data: unvalidatedData } = await entryConfig.getEntryInfo({
+    fileUrl: pathToFileURL(fileId),
+    contents: rawContents
+  });
+  const _internal = { filePath: fileId, rawData };
+  const id = getDataEntryId({ entry, contentDir, collection });
+  const data = collectionConfig ? await getEntryData(
+    { id, collection, _internal, unvalidatedData },
+    collectionConfig,
+    pluginContext,
+    config
+  ) : unvalidatedData;
+  const dataEntryModule = {
+    id,
+    collection,
+    data,
+    _internal
+  };
+  return dataEntryModule;
+}
+async function getEntryModuleBaseInfo({
+  fileId,
+  entryConfigByExt,
+  contentDir,
+  fs
+}) {
+  const contentConfig = await getContentConfigFromGlobal();
+  let rawContents;
+  try {
+    rawContents = await fs.promises.readFile(fileId, "utf-8");
+  } catch (e) {
+    throw new AstroError({
+      ...AstroErrorData.UnknownContentCollectionError,
+      message: `Unexpected error reading entry ${JSON.stringify(fileId)}.`,
+      stack: e instanceof Error ? e.stack : void 0
     });
-    const entry = pathToFileURL(fileId);
-    const { contentDir } = contentPaths;
-    const collection = getEntryCollectionName({ entry, contentDir });
-    if (collection === void 0)
-      throw new AstroError(AstroErrorData.UnknownContentCollectionError);
-    const { id, slug: generatedSlug } = getContentEntryIdAndSlug({ entry, contentDir, collection });
-    const _internal = { filePath: fileId, rawData };
-    const slug = parseEntrySlug({
-      id,
-      collection,
-      generatedSlug,
-      frontmatterSlug
+  }
+  const fileExt = extname(fileId);
+  const entryConfig = entryConfigByExt.get(fileExt);
+  if (!entryConfig) {
+    throw new AstroError({
+      ...AstroErrorData.UnknownContentCollectionError,
+      message: `No parser found for data entry ${JSON.stringify(
+        fileId
+      )}. Did you apply an integration for this file type?`
     });
-    const collectionConfig = contentConfig == null ? void 0 : contentConfig.collections[collection];
-    let data = collectionConfig ? await getEntryData(
-      { id, collection, _internal, unvalidatedData },
-      collectionConfig,
-      pluginContext,
-      settings.config
-    ) : unvalidatedData;
-    const contentEntryModule = {
-      id,
-      slug,
-      collection,
-      data,
-      body,
-      _internal
-    };
-    const cacheEntry = contentEntryModuleByIdCache.get(fileId);
-    if (isAwaitingQueue(cacheEntry)) {
-      for (const resolve of cacheEntry.awaitingQueue) {
-        resolve(contentEntryModule);
-      }
-    }
-    contentEntryModuleByIdCache.set(fileId, contentEntryModule);
-    return contentEntryModule;
   }
-  return plugins;
+  const entry = pathToFileURL(fileId);
+  const collection = getEntryCollectionName({ entry, contentDir });
+  if (collection === void 0)
+    throw new AstroError(AstroErrorData.UnknownContentCollectionError);
+  const collectionConfig = contentConfig == null ? void 0 : contentConfig.collections[collection];
+  return {
+    collectionConfig,
+    entry,
+    entryConfig,
+    collection,
+    rawContents
+  };
 }
 async function getContentConfigFromGlobal() {
   const observable = globalContentConfigObserver.get();
@@ -249,55 +261,6 @@ async function getContentConfigFromGlobal() {
   }
   return contentConfig;
 }
-async function getDataEntryModule({
-  fileId,
-  dataEntryExtToParser,
-  contentPaths,
-  fs,
-  pluginContext,
-  settings
-}) {
-  const contentConfig = await getContentConfigFromGlobal();
-  let rawContents;
-  try {
-    rawContents = await fs.promises.readFile(fileId, "utf-8");
-  } catch (e) {
-    throw new AstroError({
-      ...AstroErrorData.UnknownContentCollectionError,
-      message: `Unexpected error reading entry ${JSON.stringify(fileId)}.`,
-      stack: e instanceof Error ? e.stack : void 0
-    });
-  }
-  const fileExt = extname(fileId);
-  const dataEntryParser = dataEntryExtToParser.get(fileExt);
-  if (!dataEntryParser) {
-    throw new AstroError({
-      ...AstroErrorData.UnknownContentCollectionError,
-      message: `No parser found for data entry ${JSON.stringify(
-        fileId
-      )}. Did you apply an integration for this file type?`
-    });
-  }
-  const { data: unvalidatedData, rawData = "" } = await dataEntryParser({
-    fileUrl: pathToFileURL(fileId),
-    contents: rawContents
-  });
-  const entry = pathToFileURL(fileId);
-  const { contentDir } = contentPaths;
-  const collection = getEntryCollectionName({ entry, contentDir });
-  if (collection === void 0)
-    throw new AstroError(AstroErrorData.UnknownContentCollectionError);
-  const id = getDataEntryId({ entry, contentDir, collection });
-  const _internal = { filePath: fileId, rawData };
-  const collectionConfig = contentConfig == null ? void 0 : contentConfig.collections[collection];
-  const data = collectionConfig ? await getEntryData(
-    { id, collection, _internal, unvalidatedData },
-    collectionConfig,
-    pluginContext,
-    settings.config
-  ) : unvalidatedData;
-  return { id, collection, data, _internal };
-}
 export {
   astroContentImportPlugin
 };

package/dist/content/vite-plugin-content-virtual-mod.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" />
 import fsMod from 'node:fs';
 import type { Plugin } from 'vite';
-import type { AstroSettings } from '../@types/astro.js';
-import { getContentEntryConfigByExtMap, type ContentPaths } from './utils.js';
+import type { AstroSettings, ContentEntryType } from '../@types/astro.js';
+import { type ContentPaths } from './utils.js';
 interface AstroContentVirtualModPluginParams {
     settings: AstroSettings;
 }
@@ -13,7 +13,7 @@ export declare function astroContentVirtualModPlugin({ settings, }: AstroContent
  * @see `src/content/virtual-mod.mjs`
  */
 export declare function getStringifiedLookupMap({ contentPaths, contentEntryConfigByExt, dataEntryExts, root, fs, }: {
-    contentEntryConfigByExt: ReturnType<typeof getContentEntryConfigByExtMap>;
+    contentEntryConfigByExt: Map<string, ContentEntryType>;
     dataEntryExts: string[];
     contentPaths: Pick<ContentPaths, 'contentDir' | 'config'>;
     root: URL;

package/dist/content/vite-plugin-content-virtual-mod.js

@@ -7,12 +7,12 @@ import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { rootRelativePath } from "../core/util.js";
 import { VIRTUAL_MODULE_ID } from "./consts.js";
 import {
-  getContentEntryConfigByExtMap,
   getContentEntryIdAndSlug,
   getContentPaths,
   getDataEntryExts,
   getDataEntryId,
   getEntryCollectionName,
+  getEntryConfigByExtMap,
   getEntrySlug,
   getEntryType,
   getExtGlob
@@ -22,18 +22,27 @@ function astroContentVirtualModPlugin({
 }) {
   const contentPaths = getContentPaths(settings.config);
   const relContentDir = rootRelativePath(settings.config.root, contentPaths.contentDir);
-  const contentEntryConfigByExt = getContentEntryConfigByExtMap(settings);
+  const contentEntryConfigByExt = getEntryConfigByExtMap(settings.contentEntryTypes);
   const contentEntryExts = [...contentEntryConfigByExt.keys()];
   const dataEntryExts = getDataEntryExts(settings);
   const virtualModContents = fsMod.readFileSync(contentPaths.virtualModTemplate, "utf-8").replace(
     "@@COLLECTION_NAME_BY_REFERENCE_KEY@@",
     new URL("reference-map.json", contentPaths.cacheDir).pathname
-  ).replace("@@CONTENT_DIR@@", relContentDir).replace("@@CONTENT_ENTRY_GLOB_PATH@@", `${relContentDir}**/*${getExtGlob(contentEntryExts)}`).replace("@@DATA_ENTRY_GLOB_PATH@@", `${relContentDir}**/*${getExtGlob(dataEntryExts)}`).replace(
-    "@@RENDER_ENTRY_GLOB_PATH@@",
-    `${relContentDir}**/*${getExtGlob(
-      /** Note: data collections excluded */
-      contentEntryExts
-    )}`
+  ).replace("@@CONTENT_DIR@@", relContentDir).replace(
+    "'@@CONTENT_ENTRY_GLOB_PATH@@'",
+    JSON.stringify(globWithUnderscoresIgnored(relContentDir, contentEntryExts))
+  ).replace(
+    "'@@DATA_ENTRY_GLOB_PATH@@'",
+    JSON.stringify(globWithUnderscoresIgnored(relContentDir, dataEntryExts))
+  ).replace(
+    "'@@RENDER_ENTRY_GLOB_PATH@@'",
+    JSON.stringify(
+      globWithUnderscoresIgnored(
+        relContentDir,
+        /** Note: data collections excluded */
+        contentEntryExts
+      )
+    )
   );
   const astroContentVirtualModuleId = "\0" + VIRTUAL_MODULE_ID;
   return {
@@ -146,6 +155,10 @@ const UnexpectedLookupMapError = new AstroError({
   ...AstroErrorData.UnknownContentCollectionError,
   message: `Unexpected error while parsing content entry IDs and slugs.`
 });
+function globWithUnderscoresIgnored(relContentDir, exts) {
+  const extGlob = getExtGlob(exts);
+  return [`${relContentDir}/**/*${extGlob}`, `!**/_*/**${extGlob}`, `!**/_*${extGlob}`];
+}
 export {
   astroContentVirtualModPlugin,
   getStringifiedLookupMap

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

@@ -1,8 +1,6 @@
 import type { RouteData } from '../../@types/astro';
 import type { SSRManifest as Manifest } from './types';
 export { deserializeManifest } from './common.js';
-export declare const pagesVirtualModuleId = "@astrojs-pages-virtual-entry";
-export declare const resolvedPagesVirtualModuleId: string;
 export interface MatchOptions {
     matchNotFound?: boolean | undefined;
 }

package/dist/core/app/index.js

@@ -19,8 +19,6 @@ import {
 import { matchRoute } from "../routing/match.js";
 import { deserializeManifest } from "./common.js";
 const clientLocalsSymbol = Symbol.for("astro.locals");
-const pagesVirtualModuleId = "@astrojs-pages-virtual-entry";
-const resolvedPagesVirtualModuleId = "\0" + pagesVirtualModuleId;
 const responseSentSymbol = Symbol.for("astro.responseSent");
 class App {
   #env;
@@ -115,13 +113,15 @@ class App {
     if (routeData.route === "/404") {
       defaultStatus = 404;
     }
-    let mod = await this.#manifest.pageMap.get(routeData.component)();
+    let page = await this.#manifest.pageMap.get(routeData.component)();
+    let mod = await page.page();
     if (routeData.type === "page") {
       let response = await this.#renderPage(request, routeData, mod, defaultStatus);
       if (response.status === 500 || response.status === 404) {
         const errorPageData = matchRoute("/" + response.status, this.#manifestData);
         if (errorPageData && errorPageData.route !== routeData.route) {
-          mod = await this.#manifest.pageMap.get(errorPageData.component)();
+          page = await this.#manifest.pageMap.get(errorPageData.component)();
+          mod = await page.page();
           try {
             let errorResponse = await this.#renderPage(
               request,
@@ -265,7 +265,5 @@ class App {
 }
 export {
   App,
-  deserializeManifest,
-  pagesVirtualModuleId,
-  resolvedPagesVirtualModuleId
+  deserializeManifest
 };

package/dist/core/app/node.js

@@ -7,11 +7,12 @@ const clientAddressSymbol = Symbol.for("astro.clientAddress");
 function createRequestFromNodeRequest(req, body) {
   var _a;
   const protocol = req.socket instanceof TLSSocket || req.headers["x-forwarded-proto"] === "https" ? "https" : "http";
-  let url = `${protocol}://${req.headers.host}${req.url}`;
-  let rawHeaders = req.headers;
+  const hostname = req.headers.host || req.headers[":authority"];
+  const url = `${protocol}://${hostname}${req.url}`;
+  const rawHeaders = req.headers;
   const entries = Object.entries(rawHeaders);
   const method = req.method || "GET";
-  let request = new Request(url, {
+  const request = new Request(url, {
     method,
     headers: new Headers(entries),
     body: ["HEAD", "GET"].includes(method) ? null : body

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

@@ -1,5 +1,6 @@
 import type { MarkdownRenderingOptions } from '@astrojs/markdown-remark';
-import type { AstroMiddlewareInstance, ComponentInstance, RouteData, SerializedRouteData, SSRComponentMetadata, SSRLoadedRenderer, SSRResult } from '../../@types/astro';
+import type { AstroMiddlewareInstance, RouteData, SerializedRouteData, SSRComponentMetadata, SSRLoadedRenderer, SSRResult } from '../../@types/astro';
+import type { SinglePageBuiltModule } from '../build/types';
 export type ComponentPath = string;
 export type StylesheetAsset = {
     type: 'inline';
@@ -24,7 +25,7 @@ export interface RouteInfo {
 export type SerializedRouteInfo = Omit<RouteInfo, 'routeData'> & {
     routeData: SerializedRouteData;
 };
-type ImportComponentInstance = () => Promise<ComponentInstance>;
+type ImportComponentInstance = () => Promise<SinglePageBuiltModule>;
 export interface SSRManifest {
     adapterName: string;
     routes: RouteInfo[];

package/dist/core/build/generate.js

@@ -6,7 +6,10 @@ import {
   generateImage as generateImageInternal,
   getStaticImageList
 } from "../../assets/generate.js";
-import { hasPrerenderedPages } from "../../core/build/internal.js";
+import {
+  eachPageDataFromEntryPoint,
+  hasPrerenderedPages
+} from "../../core/build/internal.js";
 import {
   prependForwardSlash,
   removeLeadingForwardSlash,
@@ -30,7 +33,7 @@ import { createRequest } from "../request.js";
 import { matchRoute } from "../routing/match.js";
 import { getOutputFilename } from "../util.js";
 import { getOutDirWithinCwd, getOutFile, getOutFolder } from "./common.js";
-import { cssOrder, eachPageData, getPageDataByComponent, mergeInlineCss } from "./internal.js";
+import { cssOrder, getPageDataByComponent, mergeInlineCss } from "./internal.js";
 import { getTimeStat } from "./util.js";
 function shouldSkipDraft(pageModule, settings) {
   var _a;
@@ -66,17 +69,20 @@ async function generatePages(opts, internals) {
   const verb = ssr ? "prerendering" : "generating";
   info(opts.logging, null, `
 ${bgGreen(black(` ${verb} static routes `))}`);
-  const ssrEntryURL = new URL("./" + serverEntry + `?time=${Date.now()}`, outFolder);
-  const ssrEntry = await import(ssrEntryURL.toString());
   const builtPaths = /* @__PURE__ */ new Set();
   if (ssr) {
-    for (const pageData of eachPageData(internals)) {
-      if (pageData.route.prerender)
-        await generatePage(opts, internals, pageData, ssrEntry, builtPaths);
+    for (const [pageData, filePath] of eachPageDataFromEntryPoint(internals)) {
+      if (pageData.route.prerender) {
+        const ssrEntryURLPage = new URL("./" + filePath + `?time=${Date.now()}`, outFolder);
+        const ssrEntryPage = await import(ssrEntryURLPage.toString());
+        await generatePage(opts, internals, pageData, ssrEntryPage, builtPaths);
+      }
     }
   } else {
-    for (const pageData of eachPageData(internals)) {
-      await generatePage(opts, internals, pageData, ssrEntry, builtPaths);
+    for (const [pageData, filePath] of eachPageDataFromEntryPoint(internals)) {
+      const ssrEntryURLPage = new URL("./" + filePath + `?time=${Date.now()}`, outFolder);
+      const ssrEntryPage = await import(ssrEntryURLPage.toString());
+      await generatePage(opts, internals, pageData, ssrEntryPage, builtPaths);
     }
   }
   if (opts.settings.config.experimental.assets) {
@@ -108,14 +114,13 @@ async function generateImage(opts, transform, path) {
   info(opts.logging, null, `  ${green("\u25B6")} ${path} ${dim(statsText)} ${dim(timeIncrease)}`);
 }
 async function generatePage(opts, internals, pageData, ssrEntry, builtPaths) {
-  var _a;
   let timeStart = performance.now();
   const renderers = ssrEntry.renderers;
   const pageInfo = getPageDataByComponent(internals, pageData.route.component);
   const linkIds = [];
   const scripts = (pageInfo == null ? void 0 : pageInfo.hoistedScript) ?? null;
   const styles = pageData.styles.sort(cssOrder).map(({ sheet }) => sheet).reduce(mergeInlineCss, []);
-  const pageModulePromise = (_a = ssrEntry.pageMap) == null ? void 0 : _a.get(pageData.component);
+  const pageModulePromise = ssrEntry.page;
   const middleware = ssrEntry.middleware;
   if (!pageModulePromise) {
     throw new Error(

package/dist/core/build/graph.js

@@ -1,4 +1,4 @@
-import { resolvedPagesVirtualModuleId } from "../app/index.js";
+import { ASTRO_PAGE_RESOLVED_MODULE_ID } from "./plugins/plugin-pages.js";
 function* walkParentInfos(id, ctx, until, depth = 0, order = 0, seen = /* @__PURE__ */ new Set(), childId = "") {
   seen.add(id);
   const info = ctx.getModuleInfo(id);
@@ -25,7 +25,8 @@ function* walkParentInfos(id, ctx, until, depth = 0, order = 0, seen = /* @__PUR
   }
 }
 function moduleIsTopLevelPage(info) {
-  return info.importers[0] === resolvedPagesVirtualModuleId || info.dynamicImporters[0] == resolvedPagesVirtualModuleId;
+  var _a, _b;
+  return ((_a = info.importers[0]) == null ? void 0 : _a.includes(ASTRO_PAGE_RESOLVED_MODULE_ID)) || ((_b = info.dynamicImporters[0]) == null ? void 0 : _b.includes(ASTRO_PAGE_RESOLVED_MODULE_ID));
 }
 function* getTopLevelPages(id, ctx) {
   for (const res of walkParentInfos(id, ctx)) {

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

@@ -1,13 +1,16 @@
 import type { Rollup } from 'vite';
-import type { PageBuildData, StylesheetAsset, ViteID } from './types';
 import type { SSRResult } from '../../@types/astro';
 import type { PageOptions } from '../../vite-plugin-astro/types';
+import type { PageBuildData, StylesheetAsset, ViteID } from './types';
 export interface BuildInternals {
     /**
-     * The module ids of all CSS chunks, used to deduplicate CSS assets between
-     * SSR build and client build in vite-plugin-css.
+     * Each CSS module is named with a chunk id derived from the Astro pages they
+     * are used in by default. It's easy to crawl this relation in the SSR build as
+     * the Astro pages are the entrypoint, but not for the client build as hydratable
+     * components are the entrypoint instead. This map is used as a cache from the SSR
+     * build so the client can pick up the same information and use the same chunk ids.
      */
-    cssChunkModuleIds: Set<string>;
+    cssModuleToChunkIdMap: Map<string, string>;
     hoistedScriptIdToHoistedMap: Map<string, Set<string>>;
     hoistedScriptIdToPagesMap: Map<string, Set<string>>;
     entrySpecifierToBundleMap: Map<string, string>;
@@ -76,6 +79,7 @@ export declare function getPageDataByComponent(internals: BuildInternals, compon
 export declare function getPageDataByViteID(internals: BuildInternals, viteid: ViteID): PageBuildData | undefined;
 export declare function hasPageDataByViteID(internals: BuildInternals, viteid: ViteID): boolean;
 export declare function eachPageData(internals: BuildInternals): Generator<PageBuildData, void, undefined>;
+export declare function eachPageDataFromEntryPoint(internals: BuildInternals): Generator<[PageBuildData, string]>;
 export declare function hasPrerenderedPages(internals: BuildInternals): boolean;
 interface OrderInfo {
     depth: number;

package/dist/core/build/internal.js

@@ -1,10 +1,11 @@
 import { prependForwardSlash, removeFileExtension } from "../path.js";
 import { viteID } from "../util.js";
+import { ASTRO_PAGE_EXTENSION_POST_PATTERN, ASTRO_PAGE_MODULE_ID } from "./plugins/plugin-pages.js";
 function createBuildInternals() {
   const hoistedScriptIdToHoistedMap = /* @__PURE__ */ new Map();
   const hoistedScriptIdToPagesMap = /* @__PURE__ */ new Map();
   return {
-    cssChunkModuleIds: /* @__PURE__ */ new Set(),
+    cssModuleToChunkIdMap: /* @__PURE__ */ new Map(),
     hoistedScriptIdToHoistedMap,
     hoistedScriptIdToPagesMap,
     entrySpecifierToBundleMap: /* @__PURE__ */ new Map(),
@@ -82,6 +83,22 @@ function hasPageDataByViteID(internals, viteid) {
 function* eachPageData(internals) {
   yield* internals.pagesByComponent.values();
 }
+function* eachPageDataFromEntryPoint(internals) {
+  for (const [entryPoint, filePath] of internals.entrySpecifierToBundleMap) {
+    if (entryPoint.includes(ASTRO_PAGE_MODULE_ID)) {
+      const [, pageName] = entryPoint.split(":");
+      const pageData = 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"
+        );
+      }
+      yield [pageData, filePath];
+    }
+  }
+}
 function hasPrerenderedPages(internals) {
   for (const pageData of eachPageData(internals)) {
     if (pageData.route.prerender) {
@@ -140,6 +157,7 @@ export {
   createBuildInternals,
   cssOrder,
   eachPageData,
+  eachPageDataFromEntryPoint,
   getPageDataByComponent,
   getPageDataByViteID,
   getPageDatasByChunk,