astro 5.16.5 → 6.0.0-alpha.1

package/dist/content/utils.js

@@ -5,10 +5,9 @@ import { parseFrontmatter } from "@astrojs/markdown-remark";
 import { slug as githubSlug } from "github-slugger";
 import colors from "piccolore";
 import xxhash from "xxhash-wasm";
-import { z } from "zod";
+import * as z from "zod/v4";
 import { AstroError, AstroErrorData, errorMap, MarkdownError } from "../core/errors/index.js";
 import { isYAMLException } from "../core/errors/utils.js";
-import { appendForwardSlash } from "../core/path.js";
 import { normalizePath } from "../core/viteUtils.js";
 import {
   CONTENT_LAYER_TYPE,
@@ -18,11 +17,10 @@ import {
   LIVE_CONTENT_TYPE,
   PROPAGATED_ASSET_FLAG
 } from "./consts.js";
-import { glob } from "./loaders/glob.js";
 import { createImage } from "./runtime-assets.js";
 const entryTypeSchema = z.object({
   id: z.string({
-    invalid_type_error: "Content entry `id` must be a string"
+    error: "Content entry `id` must be a string"
     // Default to empty string so we can validate properly in the loader
   })
 }).passthrough();
@@ -32,20 +30,12 @@ const loaderReturnSchema = z.union([
     z.string(),
     z.object({
       id: z.string({
-        invalid_type_error: "Content entry `id` must be a string"
+        error: "Content entry `id` must be a string"
       }).optional()
     }).passthrough()
   )
 ]);
 const collectionConfigParser = z.union([
-  z.object({
-    type: z.literal("content").optional().default("content"),
-    schema: z.any().optional()
-  }),
-  z.object({
-    type: z.literal("data"),
-    schema: z.any().optional()
-  }),
   z.object({
     type: z.literal(CONTENT_LAYER_TYPE),
     schema: z.any().optional(),
@@ -53,32 +43,38 @@ const collectionConfigParser = z.union([
       z.function(),
       z.object({
         name: z.string(),
-        load: z.function(
-          z.tuple(
-            [
-              z.object({
-                collection: z.string(),
-                store: z.any(),
-                meta: z.any(),
-                logger: z.any(),
-                config: z.any(),
-                entryTypes: z.any(),
-                parseData: z.any(),
-                renderMarkdown: z.any(),
-                generateDigest: z.function(z.tuple([z.any()], z.string())),
-                watcher: z.any().optional(),
-                refreshContextData: z.record(z.unknown()).optional()
-              })
-            ],
-            z.unknown()
+        load: z.function({
+          input: [z.custom()],
+          output: z.custom()
+        }),
+        schema: z.any().transform((v) => {
+          if (typeof v === "function") {
+            console.warn(
+              `Your loader's schema is defined using a function. This is no longer supported and the schema will be ignored. Please update your loader to use the \`createSchema()\` utility instead, or report this to the loader author. In a future major version, this will cause the loader to break entirely.`
+            );
+            return void 0;
+          }
+          return v;
+        }).superRefine((v, ctx) => {
+          if (v !== void 0 && !("_zod" in v)) {
+            ctx.addIssue({
+              code: z.ZodIssueCode.custom,
+              message: "Invalid Zod schema"
+            });
+            return z.NEVER;
+          }
+        }).optional(),
+        createSchema: z.function({
+          input: [],
+          output: z.promise(
+            z.object({
+              schema: z.custom((v) => "_zod" in v),
+              types: z.string()
+            })
           )
-        ),
-        schema: z.any().optional(),
-        render: z.function(z.tuple([z.any()], z.unknown())).optional()
+        }).optional()
       })
-    ]),
-    /** deprecated */
-    _legacy: z.boolean().optional()
+    ])
   }),
   z.object({
     type: z.literal(LIVE_CONTENT_TYPE).optional().default(LIVE_CONTENT_TYPE),
@@ -87,7 +83,7 @@ const collectionConfigParser = z.union([
   })
 ]);
 const contentConfigParser = z.object({
-  collections: z.record(collectionConfigParser)
+  collections: z.record(z.string(), collectionConfigParser)
 });
 function parseEntrySlug({
   id,
@@ -104,25 +100,13 @@ function parseEntrySlug({
     });
   }
 }
-async function getEntryDataAndImages(entry, collectionConfig, shouldEmitFile, experimentalSvgEnabled, pluginContext) {
-  let data;
-  if (collectionConfig.type === "content" || collectionConfig._legacy) {
-    const { slug, ...unvalidatedData } = entry.unvalidatedData;
-    data = unvalidatedData;
-  } else {
-    data = entry.unvalidatedData;
-  }
+async function getEntryData(entry, collectionConfig, shouldEmitFile, pluginContext) {
+  let data = entry.unvalidatedData;
   let schema = collectionConfig.schema;
-  const imageImports = /* @__PURE__ */ new Set();
   if (typeof schema === "function") {
     if (pluginContext) {
       schema = schema({
-        image: createImage(
-          pluginContext,
-          shouldEmitFile,
-          entry._internal.filePath,
-          experimentalSvgEnabled
-        )
+        image: createImage(pluginContext, shouldEmitFile, entry._internal.filePath)
       });
     } else if (collectionConfig.type === CONTENT_LAYER_TYPE) {
       schema = schema({
@@ -131,41 +115,37 @@ async function getEntryDataAndImages(entry, collectionConfig, shouldEmitFile, ex
           if (val && !val.startsWith("./") && !val.startsWith("../") && !val.startsWith("/") && !val.startsWith("~") && !val.startsWith("@") && !val.includes("://")) {
             normalizedPath = `./${val}`;
           }
-          imageImports.add(normalizedPath);
           return `${IMAGE_IMPORT_PREFIX}${normalizedPath}`;
         })
       });
     }
   }
   if (schema) {
-    if (collectionConfig.type === "content" && typeof schema === "object" && "shape" in schema && schema.shape.slug) {
-      throw new AstroError({
-        ...AstroErrorData.ContentSchemaContainsSlugError,
-        message: AstroErrorData.ContentSchemaContainsSlugError.message(entry.collection)
-      });
-    }
     let formattedError;
     const parsed = await schema.safeParseAsync(data, {
-      errorMap(error, ctx) {
-        if (error.code === "custom" && error.params?.isHoistedAstroError) {
-          formattedError = error.params?.astroError;
+      error(issue) {
+        if (issue.code === "custom" && issue.params?.isHoistedAstroError) {
+          formattedError = issue.params?.astroError;
         }
-        return errorMap(error, ctx);
+        return errorMap(issue);
       }
     });
     if (parsed.success) {
       data = parsed.data;
     } else {
       if (!formattedError) {
-        const errorType = collectionConfig.type === "content" ? AstroErrorData.InvalidContentEntryFrontmatterError : AstroErrorData.InvalidContentEntryDataError;
         formattedError = new AstroError({
-          ...errorType,
-          message: errorType.message(entry.collection, entry.id, parsed.error),
+          ...AstroErrorData.InvalidContentEntryDataError,
+          message: AstroErrorData.InvalidContentEntryDataError.message(
+            entry.collection,
+            entry.id,
+            parsed.error
+          ),
           location: {
             file: entry._internal?.filePath,
             line: getYAMLErrorLine(
               entry._internal?.rawData,
-              String(parsed.error.errors[0].path[0])
+              String(parsed.error.issues[0].path[0])
             ),
             column: 0
           }
@@ -174,16 +154,6 @@ async function getEntryDataAndImages(entry, collectionConfig, shouldEmitFile, ex
       throw formattedError;
     }
   }
-  return { data, imageImports: Array.from(imageImports) };
-}
-async function getEntryData(entry, collectionConfig, shouldEmitFile, experimentalSvgEnabled, pluginContext) {
-  const { data } = await getEntryDataAndImages(
-    entry,
-    collectionConfig,
-    shouldEmitFile,
-    experimentalSvgEnabled,
-    pluginContext
-  );
   return data;
 }
 function getContentEntryExts(settings) {
@@ -370,19 +340,18 @@ function isDeferredModule(viteId) {
 async function loadContentConfig({
   fs,
   settings,
-  viteServer
+  environment
 }) {
   const contentPaths = getContentPaths(settings.config, fs);
-  let unparsedConfig;
   if (!contentPaths.config.exists) {
     return void 0;
   }
   const configPathname = fileURLToPath(contentPaths.config.url);
-  unparsedConfig = await viteServer.ssrLoadModule(configPathname);
+  const unparsedConfig = await environment.runner.import(configPathname);
   const config = contentConfigParser.safeParse(unparsedConfig);
   if (config.success) {
     const hasher = await xxhash();
-    const digest = await hasher.h64ToString(await fs.promises.readFile(configPathname, "utf-8"));
+    const digest = hasher.h64ToString(await fs.promises.readFile(configPathname, "utf-8"));
     return { ...config.data, digest };
   } else {
     const message = config.error.issues.map((issue) => `  \u2192 ${colors.green(issue.path.join("."))}: ${colors.red(issue.message)}`).join("\n");
@@ -392,96 +361,21 @@ async function loadContentConfig({
 ${message}
 `
     );
-    if (settings.config.experimental.liveContentCollections) {
-      const liveCollections = Object.entries(unparsedConfig.collections ?? {}).filter(
-        ([, collection]) => collection?.type === LIVE_CONTENT_TYPE
-      );
-      if (liveCollections.length > 0) {
-        throw new AstroError({
-          ...AstroErrorData.LiveContentConfigError,
-          message: AstroErrorData.LiveContentConfigError.message(
-            "Live collections must be defined in a `src/live.config.ts` file.",
-            path.relative(fileURLToPath(settings.config.root), configPathname)
-          )
-        });
-      }
+    const liveCollections = Object.entries(unparsedConfig.collections ?? {}).filter(
+      ([, collection]) => collection?.type === LIVE_CONTENT_TYPE
+    );
+    if (liveCollections.length > 0) {
+      throw new AstroError({
+        ...AstroErrorData.LiveContentConfigError,
+        message: AstroErrorData.LiveContentConfigError.message(
+          "Live collections must be defined in a `src/live.config.ts` file.",
+          path.relative(fileURLToPath(settings.config.root), configPathname)
+        )
+      });
     }
     return void 0;
   }
 }
-async function autogenerateCollections({
-  config,
-  settings,
-  fs
-}) {
-  if (settings.config.legacy.collections) {
-    return config;
-  }
-  const contentDir = new URL("./content/", settings.config.srcDir);
-  const collections = config?.collections ?? {};
-  const contentExts = getContentEntryExts(settings);
-  const dataExts = getDataEntryExts(settings);
-  const contentPattern = globWithUnderscoresIgnored("", contentExts);
-  const dataPattern = globWithUnderscoresIgnored("", dataExts);
-  let usesContentLayer = false;
-  for (const collectionName of Object.keys(collections)) {
-    if (collections[collectionName]?.type === "content_layer" || collections[collectionName]?.type === "live") {
-      usesContentLayer = true;
-      continue;
-    }
-    const isDataCollection = collections[collectionName]?.type === "data";
-    const base = new URL(`${collectionName}/`, contentDir);
-    const _legacy = !isDataCollection || void 0;
-    collections[collectionName] = {
-      ...collections[collectionName],
-      type: "content_layer",
-      _legacy,
-      loader: glob({
-        base,
-        pattern: isDataCollection ? dataPattern : contentPattern,
-        _legacy,
-        // Legacy data collections IDs aren't slugified
-        generateId: isDataCollection ? ({ entry }) => getDataEntryId({
-          entry: new URL(entry, base),
-          collection: collectionName,
-          contentDir
-        }) : void 0
-        // Zod weirdness has trouble with typing the args to the load function
-      })
-    };
-  }
-  if (!usesContentLayer && fs.existsSync(contentDir)) {
-    const orphanedCollections = [];
-    for (const entry of await fs.promises.readdir(contentDir, { withFileTypes: true })) {
-      const collectionName = entry.name;
-      if (["_", "."].includes(collectionName.at(0) ?? "")) {
-        continue;
-      }
-      if (entry.isDirectory() && !(collectionName in collections)) {
-        orphanedCollections.push(collectionName);
-        const base = new URL(`${collectionName}/`, contentDir);
-        collections[collectionName] = {
-          type: "content_layer",
-          loader: glob({
-            base,
-            pattern: contentPattern,
-            _legacy: true
-          })
-        };
-      }
-    }
-    if (orphanedCollections.length > 0) {
-      console.warn(
-        `
-Auto-generating collections for folders in "src/content/" that are not defined as collections.
-This is deprecated, so you should define these collections yourself in "src/content.config.ts".
-The following collections have been auto-generated: ${orphanedCollections.map((name) => colors.green(name)).join(", ")}
-`
-      );
-    }
-  }
-  return { ...config, collections };
-}
 async function reloadContentConfigObserver({
   observer = globalContentConfigObserver,
   ...loadContentConfigOpts
@@ -489,10 +383,6 @@ async function reloadContentConfigObserver({
   observer.set({ status: "loading" });
   try {
     let config = await loadContentConfig(loadContentConfigOpts);
-    config = await autogenerateCollections({
-      config,
-      ...loadContentConfigOpts
-    });
     if (config) {
       observer.set({ status: "loaded", config });
     } else {
@@ -527,14 +417,19 @@ function contentObservable(initialCtx) {
     subscribe
   };
 }
-function getContentPaths({
-  srcDir,
-  legacy,
-  root,
-  experimental
-}, fs = fsMod) {
-  const configStats = searchConfig(fs, srcDir, legacy?.collections);
-  const liveConfigStats = experimental?.liveContentCollections ? searchLiveConfig(fs, srcDir) : { exists: false, url: new URL("./", srcDir) };
+function getContentPaths({ srcDir, root }, fs = fsMod) {
+  const configStats = searchConfig(fs, srcDir);
+  if (!configStats.exists) {
+    const legacyConfigStats = searchLegacyConfig(fs, srcDir);
+    if (legacyConfigStats.exists) {
+      const relativePath = path.relative(fileURLToPath(root), fileURLToPath(legacyConfigStats.url));
+      throw new AstroError({
+        ...AstroErrorData.LegacyContentConfigError,
+        message: AstroErrorData.LegacyContentConfigError.message(relativePath)
+      });
+    }
+  }
+  const liveConfigStats = searchLiveConfig(fs, srcDir);
   const pkgBase = new URL("../../", import.meta.url);
   return {
     root: new URL("./", root),
@@ -546,13 +441,21 @@ function getContentPaths({
     liveConfig: liveConfigStats
   };
 }
-function searchConfig(fs, srcDir, legacy) {
+function searchConfig(fs, srcDir) {
   const paths = [
-    ...legacy ? [] : ["content.config.mjs", "content.config.js", "content.config.mts", "content.config.ts"],
-    "content/config.mjs",
+    "content.config.mjs",
+    "content.config.js",
+    "content.config.mts",
+    "content.config.ts"
+  ];
+  return search(fs, srcDir, paths);
+}
+function searchLegacyConfig(fs, srcDir) {
+  const paths = [
+    "content/config.ts",
     "content/config.js",
-    "content/config.mts",
-    "content/config.ts"
+    "content/config.mjs",
+    "content/config.mts"
   ];
   return search(fs, srcDir, paths);
 }
@@ -589,12 +492,6 @@ async function getEntrySlug({
   });
   return parseEntrySlug({ generatedSlug, frontmatterSlug, id, collection });
 }
-function getExtGlob(exts) {
-  return exts.length === 1 ? (
-    // Wrapping {...} breaks when there is only one extension
-    exts[0]
-  ) : `{${exts.join(",")}}`;
-}
 function hasAssetPropagationFlag(id) {
   try {
     return new URL(id, "file://").searchParams.has(PROPAGATED_ASSET_FLAG);
@@ -602,15 +499,6 @@ function hasAssetPropagationFlag(id) {
     return false;
   }
 }
-function globWithUnderscoresIgnored(relContentDir, exts) {
-  const extGlob = getExtGlob(exts);
-  const contentDir = relContentDir.length > 0 ? appendForwardSlash(relContentDir) : relContentDir;
-  return [
-    `${contentDir}**/*${extGlob}`,
-    `!${contentDir}**/_*/**/*${extGlob}`,
-    `!${contentDir}**/_*${extGlob}`
-  ];
-}
 function posixifyPath(filePath) {
   return filePath.split(path.sep).join("/");
 }
@@ -654,12 +542,9 @@ export {
   getEntryCollectionName,
   getEntryConfigByExtMap,
   getEntryData,
-  getEntryDataAndImages,
   getEntrySlug,
   getEntryType,
-  getExtGlob,
   getSymlinkedContentCollections,
-  globWithUnderscoresIgnored,
   globalContentConfigObserver,
   hasAssetPropagationFlag,
   hasContentFlag,

package/dist/content/vite-plugin-content-assets.d.ts

@@ -1,9 +1,17 @@
-import type { Plugin } from 'vite';
+import type * as vite from 'vite';
+import { type Plugin } from 'vite';
 import type { BuildInternals } from '../core/build/internal.js';
-import type { AstroBuildPlugin } from '../core/build/plugin.js';
-import type { StaticBuildOptions } from '../core/build/types.js';
 import type { AstroSettings } from '../types/astro.js';
 export declare function astroContentAssetPropagationPlugin({ settings, }: {
     settings: AstroSettings;
 }): Plugin;
-export declare function astroConfigBuildPlugin(options: StaticBuildOptions, internals: BuildInternals): AstroBuildPlugin;
+/**
+ * Post-build hook that injects propagated styles into content collection chunks.
+ * Finds chunks with LINKS_PLACEHOLDER and STYLES_PLACEHOLDER, and replaces them
+ * with actual styles from propagatedStylesMap.
+ */
+export declare function contentAssetsBuildPostHook(base: string, internals: BuildInternals, { ssrOutputs, prerenderOutputs, mutate, }: {
+    ssrOutputs: vite.Rollup.RollupOutput[];
+    prerenderOutputs: vite.Rollup.RollupOutput[];
+    mutate: (chunk: vite.Rollup.OutputChunk, envs: ['server'], code: string) => void;
+}): Promise<void>;

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

@@ -1,10 +1,11 @@
 import { extname } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { getAssetsPrefix } from "../assets/utils/getAssetsPrefix.js";
+import { fileURLToPath } from "node:url";
+import { isRunnableDevEnvironment } from "vite";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { createViteLoader } from "../core/module-loader/vite.js";
-import { joinPaths, prependForwardSlash } from "../core/path.js";
-import { getStylesForURL } from "../vite-plugin-astro-server/css.js";
+import { wrapId } from "../core/util.js";
+import { isBuildableCSSRequest } from "../vite-plugin-astro-server/util.js";
+import { crawlGraph } from "../vite-plugin-astro-server/vite.js";
 import {
   CONTENT_IMAGE_FLAG,
   CONTENT_RENDER_FLAG,
@@ -13,6 +14,9 @@ import {
   STYLES_PLACEHOLDER
 } from "./consts.js";
 import { hasContentFlag } from "./utils.js";
+import { joinPaths, prependForwardSlash, slash } from "@astrojs/internal-helpers/path";
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
+import { isAstroServerEnvironment } from "../environments.js";
 function astroContentAssetPropagationPlugin({
   settings
 }) {
@@ -49,13 +53,19 @@ function astroContentAssetPropagationPlugin({
       }
     },
     configureServer(server) {
-      devModuleLoader = createViteLoader(server);
+      if (!isRunnableDevEnvironment(server.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr])) {
+        return;
+      }
+      devModuleLoader = createViteLoader(
+        server,
+        server.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr]
+      );
     },
-    async transform(_, id, options) {
+    async transform(_, id) {
       if (hasContentFlag(id, PROPAGATED_ASSET_FLAG)) {
         const basePath = id.split("?")[0];
         let stringifiedLinks, stringifiedStyles;
-        if (options?.ssr && devModuleLoader) {
+        if (isAstroServerEnvironment(this.environment) && devModuleLoader) {
           if (!devModuleLoader.getModuleById(basePath)?.ssrModule) {
             await devModuleLoader.import(basePath);
           }
@@ -63,7 +73,7 @@ function astroContentAssetPropagationPlugin({
             styles,
             urls,
             crawledFiles: styleCrawledFiles
-          } = await getStylesForURL(pathToFileURL(basePath), devModuleLoader);
+          } = await getStylesForURL(basePath, devModuleLoader.getSSREnvironment());
           for (const file of styleCrawledFiles) {
             if (!file.includes("node_modules")) {
               this.addWatchFile(file);
@@ -89,60 +99,94 @@ function astroContentAssetPropagationPlugin({
     }
   };
 }
-function astroConfigBuildPlugin(options, internals) {
-  return {
-    targets: ["server"],
-    hooks: {
-      "build:post": ({ ssrOutputs, mutate }) => {
-        const outputs = ssrOutputs.flatMap((o) => o.output);
-        const prependBase = (src) => {
-          const { assetsPrefix } = options.settings.config.build;
-          if (assetsPrefix) {
-            const fileExtension = extname(src);
-            const pf = getAssetsPrefix(fileExtension, assetsPrefix);
-            return joinPaths(pf, src);
+const INLINE_QUERY_REGEX = /(?:\?|&)inline(?:$|&)/;
+async function getStylesForURL(filePath, environment) {
+  const importedCssUrls = /* @__PURE__ */ new Set();
+  const importedStylesMap = /* @__PURE__ */ new Map();
+  const crawledFiles = /* @__PURE__ */ new Set();
+  for await (const importedModule of crawlGraph(environment, filePath, false)) {
+    if (importedModule.file) {
+      crawledFiles.add(importedModule.file);
+    }
+    if (isBuildableCSSRequest(importedModule.url)) {
+      let css = "";
+      if (typeof importedModule.ssrModule?.default === "string") {
+        css = importedModule.ssrModule.default;
+      } else {
+        let modId = importedModule.url;
+        if (!INLINE_QUERY_REGEX.test(importedModule.url)) {
+          if (importedModule.url.includes("?")) {
+            modId = importedModule.url.replace("?", "?inline&");
           } else {
-            return prependForwardSlash(joinPaths(options.settings.config.base, src));
-          }
-        };
-        for (const chunk of outputs) {
-          if (chunk.type === "chunk" && chunk.code.includes(LINKS_PLACEHOLDER)) {
-            const entryStyles = /* @__PURE__ */ new Set();
-            const entryLinks = /* @__PURE__ */ new Set();
-            for (const id of chunk.moduleIds) {
-              const _entryCss = internals.propagatedStylesMap.get(id);
-              if (_entryCss) {
-                for (const value of _entryCss) {
-                  if (value.type === "inline") entryStyles.add(value.content);
-                  if (value.type === "external") entryLinks.add(value.src);
-                }
-              }
-            }
-            let newCode = chunk.code;
-            if (entryStyles.size) {
-              newCode = newCode.replace(
-                JSON.stringify(STYLES_PLACEHOLDER),
-                JSON.stringify(Array.from(entryStyles))
-              );
-            } else {
-              newCode = newCode.replace(JSON.stringify(STYLES_PLACEHOLDER), "[]");
-            }
-            if (entryLinks.size) {
-              newCode = newCode.replace(
-                JSON.stringify(LINKS_PLACEHOLDER),
-                JSON.stringify(Array.from(entryLinks).map(prependBase))
-              );
-            } else {
-              newCode = newCode.replace(JSON.stringify(LINKS_PLACEHOLDER), "[]");
-            }
-            mutate(chunk, ["server"], newCode);
+            modId += "?inline";
           }
         }
+        try {
+          const ssrModule = await environment.runner.import(modId);
+          css = ssrModule.default;
+        } catch {
+          continue;
+        }
       }
+      importedStylesMap.set(importedModule.url, {
+        id: wrapId(importedModule.id ?? importedModule.url),
+        url: wrapId(importedModule.url),
+        content: css
+      });
     }
+  }
+  return {
+    urls: importedCssUrls,
+    styles: [...importedStylesMap.values()],
+    crawledFiles
   };
 }
+async function contentAssetsBuildPostHook(base, internals, {
+  ssrOutputs,
+  prerenderOutputs,
+  mutate
+}) {
+  const outputs = ssrOutputs.flatMap((o) => o.output).concat(
+    ...(Array.isArray(prerenderOutputs) ? prerenderOutputs : [prerenderOutputs]).flatMap(
+      (o) => o.output
+    )
+  );
+  for (const chunk of outputs) {
+    if (chunk.type !== "chunk") continue;
+    if (!chunk.code.includes(LINKS_PLACEHOLDER)) continue;
+    const entryStyles = /* @__PURE__ */ new Set();
+    const entryLinks = /* @__PURE__ */ new Set();
+    for (const id of chunk.moduleIds) {
+      const entryCss = internals.propagatedStylesMap.get(id);
+      if (entryCss) {
+        for (const value of entryCss) {
+          if (value.type === "inline") entryStyles.add(value.content);
+          if (value.type === "external")
+            entryLinks.add(prependForwardSlash(joinPaths(base, slash(value.src))));
+        }
+      }
+    }
+    let newCode = chunk.code;
+    if (entryStyles.size) {
+      newCode = newCode.replace(
+        JSON.stringify(STYLES_PLACEHOLDER),
+        JSON.stringify(Array.from(entryStyles))
+      );
+    } else {
+      newCode = newCode.replace(JSON.stringify(STYLES_PLACEHOLDER), "[]");
+    }
+    if (entryLinks.size) {
+      newCode = newCode.replace(
+        JSON.stringify(LINKS_PLACEHOLDER),
+        JSON.stringify(Array.from(entryLinks))
+      );
+    } else {
+      newCode = newCode.replace(JSON.stringify(LINKS_PLACEHOLDER), "[]");
+    }
+    mutate(chunk, ["server"], newCode);
+  }
+}
 export {
-  astroConfigBuildPlugin,
-  astroContentAssetPropagationPlugin
+  astroContentAssetPropagationPlugin,
+  contentAssetsBuildPostHook
 };