astro 2.0.6 → 2.0.7

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

@@ -0,0 +1,105 @@
+import * as devalue from "devalue";
+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 { contentFileExts, CONTENT_FLAG } from "./consts.js";
+import {
+  getContentPaths,
+  getEntryData,
+  getEntryInfo,
+  getEntrySlug,
+  getEntryType,
+  globalContentConfigObserver,
+  parseFrontmatter
+} from "./utils.js";
+function isContentFlagImport(viteId) {
+  const { pathname, searchParams } = new URL(viteId, "file://");
+  return searchParams.has(CONTENT_FLAG) && contentFileExts.some((ext) => pathname.endsWith(ext));
+}
+function astroContentImportPlugin({
+  fs,
+  settings
+}) {
+  const contentPaths = getContentPaths(settings.config);
+  return {
+    name: "astro:content-imports",
+    async load(id) {
+      const { fileId } = getFileInfo(id, settings.config);
+      if (isContentFlagImport(id)) {
+        const observable = globalContentConfigObserver.get();
+        if (observable.status === "init") {
+          throw new AstroError({
+            ...AstroErrorData.UnknownContentCollectionError,
+            message: "Content config failed to load."
+          });
+        }
+        let contentConfig = observable.status === "loaded" ? observable.config : void 0;
+        if (observable.status === "loading") {
+          contentConfig = await new Promise((resolve) => {
+            const unsubscribe = globalContentConfigObserver.subscribe((ctx) => {
+              if (ctx.status === "loaded") {
+                resolve(ctx.config);
+                unsubscribe();
+              } else if (ctx.status === "error") {
+                resolve(void 0);
+                unsubscribe();
+              }
+            });
+          });
+        }
+        const rawContents = await fs.promises.readFile(fileId, "utf-8");
+        const {
+          content: body,
+          data: unparsedData,
+          matter: rawData = ""
+        } = parseFrontmatter(rawContents, fileId);
+        const entryInfo = getEntryInfo({
+          entry: pathToFileURL(fileId),
+          contentDir: contentPaths.contentDir
+        });
+        if (entryInfo instanceof Error)
+          return;
+        const _internal = { filePath: fileId, rawData };
+        const partialEntry = { data: unparsedData, body, _internal, ...entryInfo };
+        const slug = getEntrySlug(partialEntry);
+        const collectionConfig = contentConfig == null ? void 0 : contentConfig.collections[entryInfo.collection];
+        const data = collectionConfig ? await getEntryData(partialEntry, collectionConfig) : unparsedData;
+        const code = escapeViteEnvReferences(`
+export const id = ${JSON.stringify(entryInfo.id)};
+export const collection = ${JSON.stringify(entryInfo.collection)};
+export const slug = ${JSON.stringify(slug)};
+export const body = ${JSON.stringify(body)};
+export const data = ${devalue.uneval(data)};
+export const _internal = {
+	filePath: ${JSON.stringify(fileId)},
+	rawData: ${JSON.stringify(rawData)},
+};
+`);
+        return { code };
+      }
+    },
+    configureServer(viteServer) {
+      viteServer.watcher.on("all", async (event, entry) => {
+        if (["add", "unlink", "change"].includes(event) && getEntryType(entry, contentPaths) === "config") {
+          for (const modUrl of viteServer.moduleGraph.urlToModuleMap.keys()) {
+            if (isContentFlagImport(modUrl)) {
+              const mod = await viteServer.moduleGraph.getModuleByUrl(modUrl);
+              if (mod) {
+                viteServer.moduleGraph.invalidateModule(mod);
+              }
+            }
+          }
+        }
+      });
+    },
+    async transform(code, id) {
+      if (isContentFlagImport(id)) {
+        return { code: escapeViteEnvReferences(code) };
+      }
+    }
+  };
+}
+export {
+  astroContentImportPlugin
+};

package/dist/core/app/common.js

@@ -10,9 +10,11 @@ function deserializeManifest(serializedManifest) {
     route.routeData = deserializeRouteData(serializedRoute.routeData);
   }
   const assets = new Set(serializedManifest.assets);
+  const propagation = new Map(serializedManifest.propagation);
   return {
     ...serializedManifest,
     assets,
+    propagation,
     routes
   };
 }

package/dist/core/app/index.js

@@ -189,6 +189,7 @@ renderPage_fn = async function(request, routeData, mod, status = 200) {
       request,
       origin: url.origin,
       pathname,
+      propagation: __privateGet(this, _manifest).propagation,
       scripts,
       links,
       route: routeData,

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

@@ -1,5 +1,5 @@
 import type { MarkdownRenderingOptions } from '@astrojs/markdown-remark';
-import type { ComponentInstance, RouteData, SerializedRouteData, SSRLoadedRenderer } from '../../@types/astro';
+import type { ComponentInstance, PropagationHint, RouteData, SerializedRouteData, SSRLoadedRenderer, SSRResult } from '../../@types/astro';
 export type ComponentPath = string;
 export interface RouteInfo {
     routeData: RouteData;
@@ -26,9 +26,11 @@ export interface SSRManifest {
     renderers: SSRLoadedRenderer[];
     entryModules: Record<string, string>;
     assets: Set<string>;
+    propagation: SSRResult['propagation'];
 }
-export type SerializedSSRManifest = Omit<SSRManifest, 'routes' | 'assets'> & {
+export type SerializedSSRManifest = Omit<SSRManifest, 'routes' | 'assets' | 'propagation'> & {
     routes: SerializedRouteInfo[];
     assets: string[];
+    propagation: readonly [string, PropagationHint][];
 };
 export type AdapterCreateExports<T = any> = (manifest: SSRManifest, args?: T) => Record<string, any>;

package/dist/core/build/generate.js

@@ -262,6 +262,7 @@ async function generatePath(pathname, opts, gopts) {
     origin,
     pathname,
     request: createRequest({ url, headers: new Headers(), logging, ssr }),
+    propagation: internals.propagation,
     scripts,
     links,
     route: pageData.route

package/dist/core/build/index.js

@@ -54,6 +54,11 @@ class AstroBuilder {
       { settings: this.settings, logging, mode: "build" }
     );
     await runHookConfigDone({ settings: this.settings, logging });
+    const { sync } = await import("../../cli/sync/index.js");
+    const syncRet = await sync(this.settings, { logging, fs });
+    if (syncRet !== 0) {
+      return process.exit(syncRet);
+    }
     return { viteConfig };
   }
   async build({ viteConfig }) {

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

@@ -1,5 +1,6 @@
 import type { OutputChunk, RenderedChunk } from 'rollup';
 import type { PageBuildData, ViteID } from './types';
+import { SSRResult } from '../../@types/astro';
 import { PageOptions } from '../../vite-plugin-astro/types';
 export interface BuildInternals {
     /**
@@ -47,6 +48,7 @@ export interface BuildInternals {
     discoveredScripts: Set<string>;
     staticFiles: Set<string>;
     ssrEntryChunk?: OutputChunk;
+    propagation: SSRResult['propagation'];
 }
 /**
  * Creates internal maps used to coordinate the CSS and HTML plugins.

package/dist/core/build/internal.js

@@ -16,7 +16,8 @@ function createBuildInternals() {
     discoveredHydratedComponents: /* @__PURE__ */ new Set(),
     discoveredClientOnlyComponents: /* @__PURE__ */ new Set(),
     discoveredScripts: /* @__PURE__ */ new Set(),
-    staticFiles: /* @__PURE__ */ new Set()
+    staticFiles: /* @__PURE__ */ new Set(),
+    propagation: /* @__PURE__ */ new Map()
   };
 }
 function trackPageData(internals, component, pageData, componentModuleId, componentURL) {

package/dist/core/build/page-data.js

@@ -28,7 +28,8 @@ async function collectPagesData(opts) {
         route,
         moduleSpecifier: "",
         css: /* @__PURE__ */ new Map(),
-        contentCollectionCss: /* @__PURE__ */ new Map(),
+        propagatedStyles: /* @__PURE__ */ new Map(),
+        propagatedScripts: /* @__PURE__ */ new Map(),
         hoistedScript: void 0
       };
       clearInterval(routeCollectionLogTimeout);
@@ -48,7 +49,8 @@ async function collectPagesData(opts) {
       route,
       moduleSpecifier: "",
       css: /* @__PURE__ */ new Map(),
-      contentCollectionCss: /* @__PURE__ */ new Map(),
+      propagatedStyles: /* @__PURE__ */ new Map(),
+      propagatedScripts: /* @__PURE__ */ new Map(),
       hoistedScript: void 0
     };
   }

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

@@ -0,0 +1,41 @@
+import type { Plugin as VitePlugin } from 'vite';
+import type { BuildInternals } from './internal';
+import type { StaticBuildOptions, ViteBuildReturn } from './types';
+type RollupOutputArray = Extract<ViteBuildReturn, Array<any>>;
+type OutputChunkorAsset = RollupOutputArray[number]['output'][number];
+type OutputChunk = Extract<OutputChunkorAsset, {
+    type: 'chunk';
+}>;
+type MutateChunk = (chunk: OutputChunk, build: 'server' | 'client', newCode: string) => void;
+export type AstroBuildPlugin = {
+    build: 'ssr' | 'client' | 'both';
+    hooks?: {
+        'build:before'?: (opts: {
+            build: 'ssr' | 'client';
+            input: Set<string>;
+        }) => {
+            enforce?: 'after-user-plugins';
+            vitePlugin: VitePlugin | VitePlugin[] | undefined;
+        };
+        'build:post'?: (opts: {
+            ssrOutputs: RollupOutputArray;
+            clientOutputs: RollupOutputArray;
+            mutate: MutateChunk;
+        }) => void | Promise<void>;
+    };
+};
+export declare function createPluginContainer(options: StaticBuildOptions, internals: BuildInternals): {
+    options: StaticBuildOptions;
+    internals: BuildInternals;
+    register(plugin: AstroBuildPlugin): void;
+    runBeforeHook(build: 'ssr' | 'client', input: Set<string>): {
+        vitePlugins: (VitePlugin | VitePlugin[])[];
+        lastVitePlugins: (VitePlugin | VitePlugin[])[];
+    };
+    runPostHook(ssrReturn: ViteBuildReturn, clientReturn: ViteBuildReturn | null): Promise<Map<string, {
+        build: 'server' | 'client';
+        code: string;
+    }>>;
+};
+export type AstroBuildPluginContainer = ReturnType<typeof createPluginContainer>;
+export {};

package/dist/core/build/plugin.js

@@ -0,0 +1,82 @@
+function createPluginContainer(options, internals) {
+  const clientPlugins = [];
+  const ssrPlugins = [];
+  const allPlugins = /* @__PURE__ */ new Set();
+  return {
+    options,
+    internals,
+    register(plugin) {
+      allPlugins.add(plugin);
+      switch (plugin.build) {
+        case "client": {
+          clientPlugins.push(plugin);
+          break;
+        }
+        case "ssr": {
+          ssrPlugins.push(plugin);
+          break;
+        }
+        case "both": {
+          clientPlugins.push(plugin);
+          ssrPlugins.push(plugin);
+          break;
+        }
+      }
+    },
+    runBeforeHook(build, input) {
+      var _a;
+      let plugins = build === "ssr" ? ssrPlugins : clientPlugins;
+      let vitePlugins = [];
+      let lastVitePlugins = [];
+      for (const plugin of plugins) {
+        if ((_a = plugin.hooks) == null ? void 0 : _a["build:before"]) {
+          let result = plugin.hooks["build:before"]({ build, input });
+          if (result.vitePlugin) {
+            vitePlugins.push(result.vitePlugin);
+          }
+        }
+      }
+      return {
+        vitePlugins,
+        lastVitePlugins
+      };
+    },
+    async runPostHook(ssrReturn, clientReturn) {
+      var _a;
+      const mutations = /* @__PURE__ */ new Map();
+      const ssrOutputs = [];
+      const clientOutputs = [];
+      if (Array.isArray(ssrReturn)) {
+        ssrOutputs.push(...ssrReturn);
+      } else if ("output" in ssrReturn) {
+        ssrOutputs.push(ssrReturn);
+      }
+      if (Array.isArray(clientReturn)) {
+        clientOutputs.push(...clientReturn);
+      } else if (clientReturn && "output" in clientReturn) {
+        clientOutputs.push(clientReturn);
+      }
+      const mutate = (chunk, build, newCode) => {
+        chunk.code = newCode;
+        mutations.set(chunk.fileName, {
+          build,
+          code: newCode
+        });
+      };
+      for (const plugin of allPlugins) {
+        const postHook = (_a = plugin.hooks) == null ? void 0 : _a["build:post"];
+        if (postHook) {
+          await postHook({
+            ssrOutputs,
+            clientOutputs,
+            mutate
+          });
+        }
+      }
+      return mutations;
+    }
+  };
+}
+export {
+  createPluginContainer
+};

package/dist/core/build/plugins/index.d.ts

@@ -0,0 +1,2 @@
+import type { AstroBuildPluginContainer } from '../plugin';
+export declare function registerAllPlugins({ internals, options, register }: AstroBuildPluginContainer): void;

package/dist/core/build/plugins/index.js

@@ -0,0 +1,25 @@
+import { astroConfigBuildPlugin } from "../../../content/vite-plugin-content-assets.js";
+import { astroHeadPropagationBuildPlugin } from "../../../vite-plugin-head-propagation/index.js";
+import { pluginAliasResolve } from "./plugin-alias-resolve.js";
+import { pluginAnalyzer } from "./plugin-analyzer.js";
+import { pluginCSS } from "./plugin-css.js";
+import { pluginHoistedScripts } from "./plugin-hoisted-scripts.js";
+import { pluginInternals } from "./plugin-internals.js";
+import { pluginPages } from "./plugin-pages.js";
+import { pluginPrerender } from "./plugin-prerender.js";
+import { pluginSSR } from "./plugin-ssr.js";
+function registerAllPlugins({ internals, options, register }) {
+  register(pluginAliasResolve(internals));
+  register(pluginAnalyzer(internals));
+  register(pluginInternals(internals));
+  register(pluginPages(options, internals));
+  register(pluginCSS(options, internals));
+  register(astroHeadPropagationBuildPlugin(options, internals));
+  register(pluginPrerender(options, internals));
+  register(astroConfigBuildPlugin(options, internals));
+  register(pluginHoistedScripts(options, internals));
+  register(pluginSSR(options, internals));
+}
+export {
+  registerAllPlugins
+};

package/dist/core/build/{vite-plugin-alias-resolve.d.ts → plugins/plugin-alias-resolve.d.ts}

@@ -1,8 +1,10 @@
 import type { Plugin as VitePlugin } from 'vite';
-import type { BuildInternals } from '../../core/build/internal.js';
+import type { BuildInternals } from '../internal.js';
+import { AstroBuildPlugin } from '../plugin.js';
 /**
  * `@rollup/plugin-alias` doesn't resolve aliases in Rollup input by default. This plugin fixes it
  * with a partial fork of it's resolve function. https://github.com/rollup/plugins/blob/master/packages/alias/src/index.ts
  * When https://github.com/rollup/plugins/pull/1402 is merged, we can remove this plugin.
  */
 export declare function vitePluginAliasResolve(internals: BuildInternals): VitePlugin;
+export declare function pluginAliasResolve(internals: BuildInternals): AstroBuildPlugin;

package/dist/core/build/{vite-plugin-alias-resolve.js → plugins/plugin-alias-resolve.js}

@@ -32,6 +32,19 @@ function matches(pattern, importee) {
   }
   return importee.startsWith(pattern + "/");
 }
+function pluginAliasResolve(internals) {
+  return {
+    build: "client",
+    hooks: {
+      "build:before": () => {
+        return {
+          vitePlugin: vitePluginAliasResolve(internals)
+        };
+      }
+    }
+  };
+}
 export {
+  pluginAliasResolve,
   vitePluginAliasResolve
 };

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

@@ -0,0 +1,5 @@
+import type { Plugin as VitePlugin } from 'vite';
+import type { BuildInternals } from '../internal.js';
+import type { AstroBuildPlugin } from '../plugin.js';
+export declare function vitePluginAnalyzer(internals: BuildInternals): VitePlugin;
+export declare function pluginAnalyzer(internals: BuildInternals): AstroBuildPlugin;

package/dist/core/build/{vite-plugin-analyzer.js → plugins/plugin-analyzer.js}

@@ -1,6 +1,14 @@
-import { prependForwardSlash } from "../../core/path.js";
-import { getTopLevelPages } from "./graph.js";
-import { getPageDataByViteID, trackClientOnlyPageDatas } from "./internal.js";
+import { PROPAGATED_ASSET_FLAG } from "../../../content/consts.js";
+import { prependForwardSlash } from "../../../core/path.js";
+import { getTopLevelPages, moduleIsTopLevelPage, walkParentInfos } from "../graph.js";
+import { getPageDataByViteID, trackClientOnlyPageDatas } from "../internal.js";
+function isPropagatedAsset(id) {
+  try {
+    return new URL("file://" + id).searchParams.has(PROPAGATED_ASSET_FLAG);
+  } catch {
+    return false;
+  }
+}
 function vitePluginAnalyzer(internals) {
   function hoistedScriptScanner() {
     const uniqueHoistedIds = /* @__PURE__ */ new Map();
@@ -14,26 +22,49 @@ function vitePluginAnalyzer(internals) {
           hoistedScripts.add(hid);
         }
         if (hoistedScripts.size) {
-          for (const [pageInfo] of getTopLevelPages(from, this)) {
-            const pageId = pageInfo.id;
-            for (const hid of hoistedScripts) {
-              if (pageScripts.has(pageId)) {
-                (_a = pageScripts.get(pageId)) == null ? void 0 : _a.add(hid);
-              } else {
-                pageScripts.set(pageId, /* @__PURE__ */ new Set([hid]));
+          for (const [parentInfo] of walkParentInfos(from, this, function until(importer) {
+            return isPropagatedAsset(importer);
+          })) {
+            if (isPropagatedAsset(parentInfo.id)) {
+              for (const [nestedParentInfo] of walkParentInfos(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);
+                  }
+                }
+              }
+            } 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()
+                  });
+                }
+                (_a = pageScripts.get(parentInfo.id)) == null ? void 0 : _a.hoistedSet.add(hid);
               }
             }
           }
         }
       },
       finalize() {
-        for (const [pageId, hoistedScripts] of pageScripts) {
+        for (const [pageId, { hoistedSet, propagatedMapByImporter }] of pageScripts) {
           const pageData = getPageDataByViteID(internals, pageId);
           if (!pageData)
             continue;
           const { component } = pageData;
           const astroModuleId = prependForwardSlash(component);
-          const uniqueHoistedId = JSON.stringify(Array.from(hoistedScripts).sort());
+          const uniqueHoistedId = JSON.stringify(Array.from(hoistedSet).sort());
           let moduleId;
           if (uniqueHoistedIds.has(uniqueHoistedId)) {
             moduleId = uniqueHoistedIds.get(uniqueHoistedId);
@@ -42,12 +73,18 @@ function vitePluginAnalyzer(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);
           } else {
             internals.hoistedScriptIdToPagesMap.set(moduleId, /* @__PURE__ */ new Set([astroModuleId]));
-            internals.hoistedScriptIdToHoistedMap.set(moduleId, hoistedScripts);
+            internals.hoistedScriptIdToHoistedMap.set(moduleId, hoistedSet);
           }
         }
       }
@@ -96,6 +133,19 @@ function vitePluginAnalyzer(internals) {
     }
   };
 }
+function pluginAnalyzer(internals) {
+  return {
+    build: "ssr",
+    hooks: {
+      "build:before": () => {
+        return {
+          vitePlugin: vitePluginAnalyzer(internals)
+        };
+      }
+    }
+  };
+}
 export {
+  pluginAnalyzer,
   vitePluginAnalyzer
 };

package/dist/core/build/{vite-plugin-css.d.ts → plugins/plugin-css.d.ts}

@@ -1,10 +1,12 @@
 import { Plugin as VitePlugin } from 'vite';
-import type { BuildInternals } from './internal';
-import type { StaticBuildOptions } from './types';
+import type { BuildInternals } from '../internal';
+import type { AstroBuildPlugin } from '../plugin';
+import type { StaticBuildOptions } from '../types';
 interface PluginOptions {
     internals: BuildInternals;
     buildOptions: StaticBuildOptions;
     target: 'client' | 'server';
 }
 export declare function rollupPluginAstroBuildCSS(options: PluginOptions): VitePlugin[];
+export declare function pluginCSS(options: StaticBuildOptions, internals: BuildInternals): AstroBuildPlugin;
 export {};

package/dist/core/build/{vite-plugin-css.js → plugins/plugin-css.js}

@@ -1,17 +1,18 @@
 import * as crypto from "node:crypto";
 import * as npath from "node:path";
 import { transformWithEsbuild } from "vite";
-import { isCSSRequest } from "../render/util.js";
-import { PROPAGATED_ASSET_FLAG } from "../../content/consts.js";
-import * as assetName from "./css-asset-name.js";
-import { moduleIsTopLevelPage, walkParentInfos } from "./graph.js";
+import { isBuildableCSSRequest } from "../../render/dev/util.js";
+import { PROPAGATED_ASSET_FLAG } from "../../../content/consts.js";
+import * as assetName from "../css-asset-name.js";
+import { moduleIsTopLevelPage, walkParentInfos } from "../graph.js";
 import {
   eachPageData,
   getPageDataByViteID,
   getPageDatasByClientOnlyID,
   getPageDatasByHoistedScriptId,
   isHoistedScript
-} from "./internal.js";
+} from "../internal.js";
+import { extendManualChunks } from "./util.js";
 function rollupPluginAstroBuildCSS(options) {
   const { internals, buildOptions } = options;
   const { settings } = buildOptions;
@@ -35,32 +36,23 @@ function rollupPluginAstroBuildCSS(options) {
     {
       name: "astro:rollup-plugin-build-css",
       outputOptions(outputOptions) {
-        const manualChunks = outputOptions.manualChunks || Function.prototype;
         const assetFileNames = outputOptions.assetFileNames;
         const namingIncludesHash = assetFileNames == null ? void 0 : assetFileNames.toString().includes("[hash]");
         const createNameForParentPages = namingIncludesHash ? assetName.shortHashedName : assetName.createSlugger(settings);
-        outputOptions.manualChunks = function(id, ...args) {
-          if (typeof manualChunks == "object") {
-            if (id in manualChunks) {
-              return manualChunks[id];
-            }
-          } else if (typeof manualChunks === "function") {
-            const outid = manualChunks.call(this, id, ...args);
-            if (outid) {
-              return outid;
-            }
-          }
-          if (isCSSRequest(id)) {
-            for (const [pageInfo] of walkParentInfos(id, {
-              getModuleInfo: args[0].getModuleInfo
-            })) {
-              if (new URL(pageInfo.id, "file://").searchParams.has(PROPAGATED_ASSET_FLAG)) {
-                return createNameHash(id, [id]);
+        extendManualChunks(outputOptions, {
+          after(id, meta) {
+            if (isBuildableCSSRequest(id)) {
+              for (const [pageInfo] of walkParentInfos(id, {
+                getModuleInfo: meta.getModuleInfo
+              })) {
+                if (new URL(pageInfo.id, "file://").searchParams.has(PROPAGATED_ASSET_FLAG)) {
+                  return createNameHash(id, [id]);
+                }
               }
+              return createNameForParentPages(id, meta);
             }
-            return createNameForParentPages(id, args[0]);
           }
-        };
+        });
       },
       async generateBundle(_outputOptions, bundle) {
         const appendCSSToPage = (pageData, meta, depth, order) => {
@@ -125,8 +117,8 @@ function rollupPluginAstroBuildCSS(options) {
                           const pageData = getPageDataByViteID(internals, pageViteID);
                           if (pageData) {
                             for (const css of meta.importedCss) {
-                              const existingCss = pageData.contentCollectionCss.get(pageInfo.id) ?? /* @__PURE__ */ new Set();
-                              pageData.contentCollectionCss.set(
+                              const existingCss = pageData.propagatedStyles.get(pageInfo.id) ?? /* @__PURE__ */ new Set();
+                              pageData.propagatedStyles.set(
                                 pageInfo.id,
                                 /* @__PURE__ */ new Set([...existingCss, css])
                               );
@@ -205,6 +197,24 @@ function rollupPluginAstroBuildCSS(options) {
     }
   ];
 }
+function pluginCSS(options, internals) {
+  return {
+    build: "both",
+    hooks: {
+      "build:before": ({ build }) => {
+        let plugins = rollupPluginAstroBuildCSS({
+          buildOptions: options,
+          internals,
+          target: build === "ssr" ? "server" : "client"
+        });
+        return {
+          vitePlugin: plugins
+        };
+      }
+    }
+  };
+}
 export {
+  pluginCSS,
   rollupPluginAstroBuildCSS
 };

package/dist/core/build/plugins/plugin-hoisted-scripts.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin as VitePlugin } from 'vite';
+import type { AstroSettings } from '../../../@types/astro';
+import type { BuildInternals } from '../internal.js';
+import { AstroBuildPlugin } from '../plugin';
+import { StaticBuildOptions } from '../types';
+export declare function vitePluginHoistedScripts(settings: AstroSettings, internals: BuildInternals): VitePlugin;
+export declare function pluginHoistedScripts(options: StaticBuildOptions, internals: BuildInternals): AstroBuildPlugin;