astro 2.5.3 → 2.5.5

package/client-base.d.ts

@@ -1,5 +1,32 @@
 /// <reference path="./import-meta.d.ts" />
 
+// eslint-disable-next-line  @typescript-eslint/no-namespace
+declare namespace App {
+	// eslint-disable-next-line  @typescript-eslint/no-empty-interface
+	export interface Locals {}
+}
+
+interface ImportMetaEnv {
+	/**
+	 * The prefix for Astro-generated asset links if the build.assetsPrefix config option is set. This can be used to create asset links not handled by Astro.
+	 */
+	readonly ASSETS_PREFIX: string;
+	/**
+	 * This is set to the site option specified in your project’s Astro config file.
+	 */
+	readonly SITE: string;
+}
+
+interface ImportMeta {
+	/**
+	 * Astro and Vite expose environment variables through `import.meta.env`. For a complete list of the environment variables available, see the two references below.
+	 *
+	 * - [Astro reference](https://docs.astro.build/en/guides/environment-variables/#default-environment-variables)
+	 * - [Vite reference](https://vitejs.dev/guide/env-and-mode.html#env-variables)
+	 */
+	readonly env: ImportMetaEnv;
+}
+
 declare module 'astro:assets' {
 	// Exporting things one by one is a bit cumbersome, not sure if there's a better way - erika, 2023-02-03
 	type AstroAssets = {
@@ -387,9 +414,3 @@ declare module '*?inline' {
 	const src: string;
 	export default src;
 }
-
-// eslint-disable-next-line  @typescript-eslint/no-namespace
-declare namespace App {
-	// eslint-disable-next-line  @typescript-eslint/no-empty-interface
-	export interface Locals {}
-}

package/client-image.d.ts

@@ -2,7 +2,7 @@
 
 // TODO: Merge this file with `client-base.d.ts` in 3.0, when the `astro:assets` feature isn't under a flag anymore.
 
-type InputFormat = import('./dist/assets/types.js').InputFormat;
+type InputFormat = import('./dist/assets/types.js').ImageInputFormat;
 
 interface ImageMetadata {
 	src: string;

package/client.d.ts

@@ -21,10 +21,6 @@ declare module '*.svg' {
 	const src: string;
 	export default src;
 }
-declare module '*.ico' {
-	const src: string;
-	export default src;
-}
 declare module '*.webp' {
 	const src: string;
 	export default src;

package/dist/@types/astro.d.ts

@@ -1170,12 +1170,6 @@ export interface ContentEntryType {
         entry: ContentEntryModule;
     }): rollup.LoadResult | Promise<rollup.LoadResult>;
     contentModuleTypes?: string;
-    /**
-     * Handle asset propagation for rendered content to avoid bleed.
-     * Ex. MDX content can import styles and scripts, so `handlePropagation` should be true.
-     * @default true
-     */
-    handlePropagation?: boolean;
 }
 type GetContentEntryInfoReturnType = {
     data: Record<string, unknown>;

package/dist/content/consts.d.ts

@@ -1,10 +1,9 @@
 export declare const PROPAGATED_ASSET_FLAG = "astroPropagatedAssets";
-export declare const CONTENT_RENDER_FLAG = "astroRenderContent";
 export declare const CONTENT_FLAG = "astroContentCollectionEntry";
 export declare const DATA_FLAG = "astroDataCollectionEntry";
+export declare const CONTENT_FLAGS: readonly ["astroContentCollectionEntry", "astroDataCollectionEntry", "astroPropagatedAssets"];
 export declare const VIRTUAL_MODULE_ID = "astro:content";
 export declare const LINKS_PLACEHOLDER = "@@ASTRO-LINKS@@";
 export declare const STYLES_PLACEHOLDER = "@@ASTRO-STYLES@@";
 export declare const SCRIPTS_PLACEHOLDER = "@@ASTRO-SCRIPTS@@";
-export declare const CONTENT_FLAGS: readonly ["astroContentCollectionEntry", "astroRenderContent", "astroDataCollectionEntry", "astroPropagatedAssets"];
 export declare const CONTENT_TYPES_FILE = "types.d.ts";

package/dist/content/consts.js

@@ -1,22 +1,15 @@
 const PROPAGATED_ASSET_FLAG = "astroPropagatedAssets";
-const CONTENT_RENDER_FLAG = "astroRenderContent";
 const CONTENT_FLAG = "astroContentCollectionEntry";
 const DATA_FLAG = "astroDataCollectionEntry";
+const CONTENT_FLAGS = [CONTENT_FLAG, DATA_FLAG, PROPAGATED_ASSET_FLAG];
 const VIRTUAL_MODULE_ID = "astro:content";
 const LINKS_PLACEHOLDER = "@@ASTRO-LINKS@@";
 const STYLES_PLACEHOLDER = "@@ASTRO-STYLES@@";
 const SCRIPTS_PLACEHOLDER = "@@ASTRO-SCRIPTS@@";
-const CONTENT_FLAGS = [
-  CONTENT_FLAG,
-  CONTENT_RENDER_FLAG,
-  DATA_FLAG,
-  PROPAGATED_ASSET_FLAG
-];
 const CONTENT_TYPES_FILE = "types.d.ts";
 export {
   CONTENT_FLAG,
   CONTENT_FLAGS,
-  CONTENT_RENDER_FLAG,
   CONTENT_TYPES_FILE,
   DATA_FLAG,
   LINKS_PLACEHOLDER,

package/dist/content/runtime.js

@@ -184,7 +184,7 @@ async function render({
   id,
   renderEntryImport
 }) {
-  var _a, _b;
+  var _a;
   const UnexpectedRenderError = new AstroError({
     ...AstroErrorData.UnknownContentCollectionError,
     message: `Unexpected error while rendering ${String(collection)} \u2192 ${String(id)}.`
@@ -194,69 +194,53 @@ async function render({
   const baseMod = await renderEntryImport();
   if (baseMod == null || typeof baseMod !== "object")
     throw UnexpectedRenderError;
-  if (baseMod.default != null && typeof baseMod.default === "object" && baseMod.default.__astroPropagation === true) {
-    const { collectedStyles, collectedLinks, collectedScripts, getMod } = baseMod.default;
-    if (typeof getMod !== "function")
-      throw UnexpectedRenderError;
-    const propagationMod = await getMod();
-    if (propagationMod == null || typeof propagationMod !== "object")
-      throw UnexpectedRenderError;
-    const Content = createComponent({
-      factory(result, baseProps, slots) {
-        let styles = "", links = "", scripts = "";
-        if (Array.isArray(collectedStyles)) {
-          styles = collectedStyles.map((style) => {
-            return renderUniqueStylesheet(result, {
-              type: "inline",
-              content: style
-            });
-          }).join("");
-        }
-        if (Array.isArray(collectedLinks)) {
-          links = collectedLinks.map((link) => {
-            return renderUniqueStylesheet(result, {
-              type: "external",
-              src: prependForwardSlash(link)
-            });
-          }).join("");
-        }
-        if (Array.isArray(collectedScripts)) {
-          scripts = collectedScripts.map((script) => renderScriptElement(script)).join("");
-        }
-        let props = baseProps;
-        if (id.endsWith("mdx")) {
-          props = {
-            components: propagationMod.components ?? {},
-            ...baseProps
-          };
-        }
-        return createHeadAndContent(
-          unescapeHTML(styles + links + scripts),
-          renderTemplate`${renderComponent(
-            result,
-            "Content",
-            propagationMod.Content,
-            props,
-            slots
-          )}`
-        );
-      },
-      propagation: "self"
-    });
-    return {
-      Content,
-      headings: ((_a = propagationMod.getHeadings) == null ? void 0 : _a.call(propagationMod)) ?? [],
-      remarkPluginFrontmatter: propagationMod.frontmatter ?? {}
-    };
-  } else if (baseMod.Content && typeof baseMod.Content === "function") {
-    return {
-      Content: baseMod.Content,
-      headings: ((_b = baseMod.getHeadings) == null ? void 0 : _b.call(baseMod)) ?? [],
-      remarkPluginFrontmatter: baseMod.frontmatter ?? {}
-    };
-  } else {
+  const { collectedStyles, collectedLinks, collectedScripts, getMod } = baseMod;
+  if (typeof getMod !== "function")
     throw UnexpectedRenderError;
-  }
+  const mod = await getMod();
+  if (mod == null || typeof mod !== "object")
+    throw UnexpectedRenderError;
+  const Content = createComponent({
+    factory(result, baseProps, slots) {
+      let styles = "", links = "", scripts = "";
+      if (Array.isArray(collectedStyles)) {
+        styles = collectedStyles.map((style) => {
+          return renderUniqueStylesheet(result, {
+            type: "inline",
+            content: style
+          });
+        }).join("");
+      }
+      if (Array.isArray(collectedLinks)) {
+        links = collectedLinks.map((link) => {
+          return renderUniqueStylesheet(result, {
+            type: "external",
+            src: prependForwardSlash(link)
+          });
+        }).join("");
+      }
+      if (Array.isArray(collectedScripts)) {
+        scripts = collectedScripts.map((script) => renderScriptElement(script)).join("");
+      }
+      let props = baseProps;
+      if (id.endsWith("mdx")) {
+        props = {
+          components: mod.components ?? {},
+          ...baseProps
+        };
+      }
+      return createHeadAndContent(
+        unescapeHTML(styles + links + scripts),
+        renderTemplate`${renderComponent(result, "Content", mod.Content, props, slots)}`
+      );
+    },
+    propagation: "self"
+  });
+  return {
+    Content,
+    headings: ((_a = mod.getHeadings) == null ? void 0 : _a.call(mod)) ?? [],
+    remarkPluginFrontmatter: mod.frontmatter ?? {}
+  };
 }
 function createReference({ lookupMap }) {
   return function reference(collection) {

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

@@ -1,5 +1,4 @@
-import { extname } from "node:path";
-import { pathToFileURL } from "node:url";
+import { pathToFileURL } from "url";
 import { moduleIsTopLevelPage, walkParentInfos } from "../core/build/graph.js";
 import { getPageDataByViteID } from "../core/build/internal.js";
 import { createViteLoader } from "../core/module-loader/vite.js";
@@ -7,13 +6,15 @@ import { joinPaths, prependForwardSlash } from "../core/path.js";
 import { getStylesForURL } from "../core/render/dev/css.js";
 import { getScriptsForURL } from "../core/render/dev/scripts.js";
 import {
-  CONTENT_RENDER_FLAG,
   LINKS_PLACEHOLDER,
   PROPAGATED_ASSET_FLAG,
   SCRIPTS_PLACEHOLDER,
   STYLES_PLACEHOLDER
 } from "./consts.js";
-import { hasContentFlag } from "./utils.js";
+function isPropagatedAsset(viteId) {
+  const flags = new URLSearchParams(viteId.split("?")[1]);
+  return flags.has(PROPAGATED_ASSET_FLAG);
+}
 function astroContentAssetPropagationPlugin({
   mode,
   settings
@@ -21,21 +22,6 @@ function astroContentAssetPropagationPlugin({
   let devModuleLoader;
   return {
     name: "astro:content-asset-propagation",
-    enforce: "pre",
-    async resolveId(id, importer, opts) {
-      if (hasContentFlag(id, CONTENT_RENDER_FLAG)) {
-        const base = id.split("?")[0];
-        for (const { extensions, handlePropagation = true } of settings.contentEntryTypes) {
-          if (handlePropagation && extensions.includes(extname(base))) {
-            return this.resolve(`${base}?${PROPAGATED_ASSET_FLAG}`, importer, {
-              skipSelf: true,
-              ...opts
-            });
-          }
-        }
-        return this.resolve(base, importer, { skipSelf: true, ...opts });
-      }
-    },
     configureServer(server) {
       if (mode === "dev") {
         devModuleLoader = createViteLoader(server);
@@ -43,7 +29,7 @@ function astroContentAssetPropagationPlugin({
     },
     async transform(_, id, options) {
       var _a;
-      if (hasContentFlag(id, PROPAGATED_ASSET_FLAG)) {
+      if (isPropagatedAsset(id)) {
         const basePath = id.split("?")[0];
         let stringifiedLinks, stringifiedStyles, stringifiedScripts;
         if ((options == null ? void 0 : options.ssr) && devModuleLoader) {
@@ -69,14 +55,12 @@ function astroContentAssetPropagationPlugin({
           stringifiedScripts = JSON.stringify(SCRIPTS_PLACEHOLDER);
         }
         const code = `
-					async function getMod() {
+					export async function getMod() {
 						return import(${JSON.stringify(basePath)});
 					}
-					const collectedLinks = ${stringifiedLinks};
-					const collectedStyles = ${stringifiedStyles};
-					const collectedScripts = ${stringifiedScripts};
-					const defaultMod = { __astroPropagation: true, getMod, collectedLinks, collectedStyles, collectedScripts };
-					export default defaultMod;
+					export const collectedLinks = ${stringifiedLinks};
+					export const collectedStyles = ${stringifiedStyles};
+					export const collectedScripts = ${stringifiedScripts};
 				`;
         return { code, map: { mappings: "" } };
       }

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

@@ -2,6 +2,7 @@ import glob from "fast-glob";
 import fsMod from "node:fs";
 import { extname } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import pLimit from "p-limit";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { rootRelativePath } from "../core/util.js";
 import { VIRTUAL_MODULE_ID } from "./consts.js";
@@ -83,57 +84,62 @@ async function getStringifiedLookupMap({
       }
     }
   );
-  await Promise.all(
-    contentGlob.map(async (filePath) => {
-      var _a, _b, _c;
-      const entryType = getEntryType(filePath, contentPaths, contentEntryExts, dataEntryExts);
-      if (entryType !== "content" && entryType !== "data")
-        return;
-      const collection = getEntryCollectionName({ contentDir, entry: pathToFileURL(filePath) });
-      if (!collection)
-        throw UnexpectedLookupMapError;
-      if (((_a = lookupMap[collection]) == null ? void 0 : _a.type) && lookupMap[collection].type !== entryType) {
-        throw new AstroError({
-          ...AstroErrorData.MixedContentDataCollectionError,
-          message: AstroErrorData.MixedContentDataCollectionError.message(collection)
-        });
-      }
-      if (entryType === "content") {
-        const contentEntryType = contentEntryConfigByExt.get(extname(filePath));
-        if (!contentEntryType)
+  const limit = pLimit(10);
+  const promises = [];
+  for (const filePath of contentGlob) {
+    promises.push(
+      limit(async () => {
+        var _a, _b, _c;
+        const entryType = getEntryType(filePath, contentPaths, contentEntryExts, dataEntryExts);
+        if (entryType !== "content" && entryType !== "data")
+          return;
+        const collection = getEntryCollectionName({ contentDir, entry: pathToFileURL(filePath) });
+        if (!collection)
           throw UnexpectedLookupMapError;
-        const { id, slug: generatedSlug } = await getContentEntryIdAndSlug({
-          entry: pathToFileURL(filePath),
-          contentDir,
-          collection
-        });
-        const slug = await getEntrySlug({
-          id,
-          collection,
-          generatedSlug,
-          fs,
-          fileUrl: pathToFileURL(filePath),
-          contentEntryType
-        });
-        lookupMap[collection] = {
-          type: "content",
-          entries: {
-            ...(_b = lookupMap[collection]) == null ? void 0 : _b.entries,
-            [slug]: rootRelativePath(root, filePath)
-          }
-        };
-      } else {
-        const id = getDataEntryId({ entry: pathToFileURL(filePath), contentDir, collection });
-        lookupMap[collection] = {
-          type: "data",
-          entries: {
-            ...(_c = lookupMap[collection]) == null ? void 0 : _c.entries,
-            [id]: rootRelativePath(root, filePath)
-          }
-        };
-      }
-    })
-  );
+        if (((_a = lookupMap[collection]) == null ? void 0 : _a.type) && lookupMap[collection].type !== entryType) {
+          throw new AstroError({
+            ...AstroErrorData.MixedContentDataCollectionError,
+            message: AstroErrorData.MixedContentDataCollectionError.message(collection)
+          });
+        }
+        if (entryType === "content") {
+          const contentEntryType = contentEntryConfigByExt.get(extname(filePath));
+          if (!contentEntryType)
+            throw UnexpectedLookupMapError;
+          const { id, slug: generatedSlug } = await getContentEntryIdAndSlug({
+            entry: pathToFileURL(filePath),
+            contentDir,
+            collection
+          });
+          const slug = await getEntrySlug({
+            id,
+            collection,
+            generatedSlug,
+            fs,
+            fileUrl: pathToFileURL(filePath),
+            contentEntryType
+          });
+          lookupMap[collection] = {
+            type: "content",
+            entries: {
+              ...(_b = lookupMap[collection]) == null ? void 0 : _b.entries,
+              [slug]: rootRelativePath(root, filePath)
+            }
+          };
+        } else {
+          const id = getDataEntryId({ entry: pathToFileURL(filePath), contentDir, collection });
+          lookupMap[collection] = {
+            type: "data",
+            entries: {
+              ...(_c = lookupMap[collection]) == null ? void 0 : _c.entries,
+              [id]: rootRelativePath(root, filePath)
+            }
+          };
+        }
+      })
+    );
+  }
+  await Promise.all(promises);
   return JSON.stringify(lookupMap);
 }
 const UnexpectedLookupMapError = new AstroError({

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

@@ -9,12 +9,14 @@ import { pluginInternals } from "./plugin-internals.js";
 import { pluginMiddleware } from "./plugin-middleware.js";
 import { pluginPages } from "./plugin-pages.js";
 import { pluginPrerender } from "./plugin-prerender.js";
+import { pluginRenderers } from "./plugin-renderers.js";
 import { pluginSSR } from "./plugin-ssr.js";
 function registerAllPlugins({ internals, options, register }) {
   register(pluginComponentEntry(internals));
   register(pluginAliasResolve(internals));
   register(pluginAnalyzer(internals));
   register(pluginInternals(internals));
+  register(pluginRenderers(options, internals));
   register(pluginMiddleware(options, internals));
   register(pluginPages(options, internals));
   register(pluginCSS(options, internals));

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

@@ -2,6 +2,7 @@ import { pagesVirtualModuleId, resolvedPagesVirtualModuleId } from "../../app/in
 import { addRollupInput } from "../add-rollup-input.js";
 import { eachPageData } from "../internal.js";
 import { MIDDLEWARE_MODULE_ID } from "./plugin-middleware.js";
+import { RENDERERS_MODULE_ID } from "./plugin-renderers.js";
 function vitePluginPages(opts, internals) {
   return {
     name: "@astro/plugin-build-pages",
@@ -18,8 +19,12 @@ function vitePluginPages(opts, internals) {
     async load(id) {
       if (id === resolvedPagesVirtualModuleId) {
         let importMap = "";
-        let imports = [];
+        const imports = [];
+        const exports = [];
+        const content = [];
         let i = 0;
+        imports.push(`import { renderers } from "${RENDERERS_MODULE_ID}";`);
+        exports.push(`export { renderers };`);
         for (const pageData of eachPageData(internals)) {
           const variable = `_page${i}`;
           imports.push(
@@ -28,23 +33,12 @@ function vitePluginPages(opts, internals) {
           importMap += `[${JSON.stringify(pageData.component)}, ${variable}],`;
           i++;
         }
-        i = 0;
-        let rendererItems = "";
-        for (const renderer of opts.settings.renderers) {
-          const variable = `_renderer${i}`;
-          imports.unshift(`import ${variable} from '${renderer.serverEntrypoint}';`);
-          rendererItems += `Object.assign(${JSON.stringify(renderer)}, { ssr: ${variable} }),`;
-          i++;
+        if (opts.settings.config.experimental.middleware) {
+          imports.push(`import * as _middleware from "${MIDDLEWARE_MODULE_ID}";`);
+          exports.push(`export const middleware = _middleware;`);
         }
-        const def = `${imports.join("\n")}
-
-${opts.settings.config.experimental.middleware ? `import * as _middleware from "${MIDDLEWARE_MODULE_ID}";` : ""}
-
-export const pageMap = new Map([${importMap}]);
-export const renderers = [${rendererItems}];
-${opts.settings.config.experimental.middleware ? `export const middleware = _middleware;` : ""}
-`;
-        return def;
+        content.push(`export const pageMap = new Map([${importMap}]);`);
+        return `${imports.join("\n")}${content.join("\n")}${exports.join("\n")}`;
       }
     }
   };

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

@@ -0,0 +1,8 @@
+import type { Plugin as VitePlugin } from 'vite';
+import type { BuildInternals } from '../internal.js';
+import type { AstroBuildPlugin } from '../plugin';
+import type { StaticBuildOptions } from '../types';
+export declare const RENDERERS_MODULE_ID = "@astro-renderers";
+export declare const RESOLVED_RENDERERS_MODULE_ID: string;
+export declare function vitePluginRenderers(opts: StaticBuildOptions, _internals: BuildInternals): VitePlugin;
+export declare function pluginRenderers(opts: StaticBuildOptions, internals: BuildInternals): AstroBuildPlugin;

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

@@ -0,0 +1,54 @@
+import { addRollupInput } from "../add-rollup-input.js";
+const RENDERERS_MODULE_ID = "@astro-renderers";
+const RESOLVED_RENDERERS_MODULE_ID = `\0${RENDERERS_MODULE_ID}`;
+let inputs = /* @__PURE__ */ new Set();
+function vitePluginRenderers(opts, _internals) {
+  return {
+    name: "@astro/plugin-renderers",
+    options(options) {
+      return addRollupInput(options, [RENDERERS_MODULE_ID]);
+    },
+    resolveId(id) {
+      if (id === RENDERERS_MODULE_ID) {
+        return RESOLVED_RENDERERS_MODULE_ID;
+      }
+    },
+    async load(id) {
+      if (id === RESOLVED_RENDERERS_MODULE_ID) {
+        if (opts.settings.renderers.length > 0) {
+          const imports = [];
+          const exports = [];
+          let i = 0;
+          let rendererItems = "";
+          for (const renderer of opts.settings.renderers) {
+            const variable = `_renderer${i}`;
+            imports.push(`import ${variable} from '${renderer.serverEntrypoint}';`);
+            rendererItems += `Object.assign(${JSON.stringify(renderer)}, { ssr: ${variable} }),`;
+            i++;
+          }
+          exports.push(`export const renderers = [${rendererItems}];`);
+          return `${imports.join("\n")}
+${exports.join("\n")}`;
+        }
+      }
+    }
+  };
+}
+function pluginRenderers(opts, internals) {
+  return {
+    build: "ssr",
+    hooks: {
+      "build:before": () => {
+        return {
+          vitePlugin: vitePluginRenderers(opts, internals)
+        };
+      }
+    }
+  };
+}
+export {
+  RENDERERS_MODULE_ID,
+  RESOLVED_RENDERERS_MODULE_ID,
+  pluginRenderers,
+  vitePluginRenderers
+};

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

@@ -9,6 +9,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 { RENDERERS_MODULE_ID } from "./plugin-renderers.js";
 const virtualModuleId = "@astrojs-ssr-virtual-entry";
 const resolvedVirtualModuleId = "\0" + virtualModuleId;
 const manifestReplace = "@@ASTRO_MANIFEST_REPLACE@@";
@@ -33,6 +34,7 @@ function vitePluginSSR(internals, adapter, config) {
           middleware = "middleware: _main.middleware";
         }
         return `import * as adapter from '${adapter.serverEntrypoint}';
+import { renderers } from '${RENDERERS_MODULE_ID}'; 
 import * as _main from '${pagesVirtualModuleId}';
 import { deserializeManifest as _deserializeManifest } from 'astro/app';
 import { _privateSetManifestDontUseThis } from 'astro:ssr-manifest';

package/dist/core/build/static-build.js

@@ -25,6 +25,7 @@ import { trackPageData } from "./internal.js";
 import { createPluginContainer } from "./plugin.js";
 import { registerAllPlugins } from "./plugins/index.js";
 import { RESOLVED_MIDDLEWARE_MODULE_ID } from "./plugins/plugin-middleware.js";
+import { RESOLVED_RENDERERS_MODULE_ID } from "./plugins/plugin-renderers.js";
 import { getTimeStat } from "./util.js";
 async function viteBuild(opts) {
   var _a, _b, _c;
@@ -132,6 +133,8 @@ async function ssrBuild(opts, internals, input, container) {
               return opts.buildConfig.serverEntry;
             } else if (chunkInfo.facadeModuleId === RESOLVED_MIDDLEWARE_MODULE_ID) {
               return "middleware.mjs";
+            } else if (chunkInfo.facadeModuleId === RESOLVED_RENDERERS_MODULE_ID) {
+              return "renderers.mjs";
             } else {
               return "[name].mjs";
             }

package/dist/core/config/vite-load.js

@@ -3,7 +3,7 @@ import * as vite from "vite";
 import loadFallbackPlugin from "../../vite-plugin-load-fallback/index.js";
 async function createViteLoader(root, fs) {
   const viteServer = await vite.createServer({
-    server: { middlewareMode: true, hmr: false },
+    server: { middlewareMode: true, hmr: false, watch: { ignored: ["**"] } },
     optimizeDeps: { disabled: true },
     clearScreen: false,
     appType: "custom",

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "2.5.3";
+const ASTRO_VERSION = "2.5.5";
 const SUPPORTED_MARKDOWN_FILE_EXTENSIONS = [
   ".markdown",
   ".mdown",

package/dist/core/dev/dev.js

@@ -53,7 +53,7 @@ async function dev(settings, options) {
       isRestart: options.isRestart
     })
   );
-  const currentVersion = "2.5.3";
+  const currentVersion = "2.5.5";
   if (currentVersion.includes("-")) {
     warn(options.logging, null, msg.prerelease({ currentVersion }));
   }

package/dist/core/endpoint/index.js

@@ -5,7 +5,6 @@ import { AstroCookies, attachToResponse } from "../cookies/index.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import { warn } from "../logger/core.js";
 import { callMiddleware } from "../middleware/callMiddleware.js";
-import { isValueSerializable } from "../render/core.js";
 const clientAddressSymbol = Symbol.for("astro.clientAddress");
 const clientLocalsSymbol = Symbol.for("astro.locals");
 function createAPIContext({
@@ -76,12 +75,6 @@ async function callEndpoint(mod, env, ctx, logging, middleware) {
       onRequest,
       context,
       async () => {
-        if (env.mode === "development" && !isValueSerializable(context.locals)) {
-          throw new AstroError({
-            ...AstroErrorData.LocalsNotSerializable,
-            message: AstroErrorData.LocalsNotSerializable.message(ctx.pathname)
-          });
-        }
         return await renderEndpoint(mod, context, env.ssr);
       }
     );

package/dist/core/errors/errors-data.d.ts

@@ -613,29 +613,6 @@ export declare const AstroErrorData: {
         readonly message: "`locals` can only be assigned to an object. Other values like numbers, strings, etc. are not accepted.";
         readonly hint: "If you tried to remove some information from the `locals` object, try to use `delete` or set the property to `undefined`.";
     };
-    /**
-     * @docs
-     * @description
-     * Thrown in development mode when a user attempts to store something that is not serializable in `locals`.
-     *
-     * For example:
-     * ```ts
-     * import {defineMiddleware} from "astro/middleware";
-     * export const onRequest = defineMiddleware((context, next) => {
-     *   context.locals = {
-     *     foo() {
-     *       alert("Hello world!")
-     *     }
-     *   };
-     *   return next();
-     * });
-     * ```
-     */
-    readonly LocalsNotSerializable: {
-        readonly title: "`Astro.locals` is not serializable";
-        readonly code: 3034;
-        readonly message: (href: string) => string;
-    };
     /**
      * @docs
      * @see

package/dist/core/errors/errors-data.js

@@ -627,32 +627,6 @@ Expected \`${defaultExpectedValue}\` value but got \`${suffix}\`.`;
     message: "`locals` can only be assigned to an object. Other values like numbers, strings, etc. are not accepted.",
     hint: "If you tried to remove some information from the `locals` object, try to use `delete` or set the property to `undefined`."
   },
-  /**
-   * @docs
-   * @description
-   * Thrown in development mode when a user attempts to store something that is not serializable in `locals`.
-   *
-   * For example:
-   * ```ts
-   * import {defineMiddleware} from "astro/middleware";
-   * export const onRequest = defineMiddleware((context, next) => {
-   *   context.locals = {
-   *     foo() {
-   *       alert("Hello world!")
-   *     }
-   *   };
-   *   return next();
-   * });
-   * ```
-   */
-  LocalsNotSerializable: {
-    title: "`Astro.locals` is not serializable",
-    code: 3034,
-    message: (href) => {
-      return `The information stored in \`Astro.locals\` for the path "${href}" is not serializable.
-Make sure you store only serializable data.`;
-    }
-  },
   // No headings here, that way Vite errors are merged with Astro ones in the docs, which makes more sense to users.
   // Vite Errors - 4xxx
   /**

package/dist/core/messages.js

@@ -47,7 +47,7 @@ function serverStart({
   base,
   isRestart = false
 }) {
-  const version = "2.5.3";
+  const version = "2.5.5";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);
@@ -233,7 +233,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"2.5.3"}`
+        `v${"2.5.5"}`
       )} ${headline}`
     );
   }

package/dist/core/render/core.d.ts

@@ -27,13 +27,4 @@ export type RenderPage = {
     apiContext?: APIContext;
 };
 export declare function renderPage({ mod, renderContext, env, apiContext }: RenderPage): Promise<Response>;
-/**
- * Checks whether any value can is serializable.
- *
- * A serializable value contains plain values. For example, `Proxy`, `Set`, `Map`, functions, etc.
- * are not serializable objects.
- *
- * @param object
- */
-export declare function isValueSerializable(value: unknown): boolean;
 export {};

package/dist/core/render/core.js

@@ -65,16 +65,7 @@ async function renderPage({ mod, renderContext, env, apiContext }) {
   const Component = mod.default;
   if (!Component)
     throw new Error(`Expected an exported Astro component but received typeof ${typeof Component}`);
-  let locals = {};
-  if (apiContext) {
-    if (env.mode === "development" && !isValueSerializable(apiContext.locals)) {
-      throw new AstroError({
-        ...AstroErrorData.LocalsNotSerializable,
-        message: AstroErrorData.LocalsNotSerializable.message(renderContext.pathname)
-      });
-    }
-    locals = apiContext.locals;
-  }
+  let locals = (apiContext == null ? void 0 : apiContext.locals) ?? {};
   const result = createResult({
     adapterName: env.adapterName,
     links: renderContext.links,
@@ -113,38 +104,9 @@ async function renderPage({ mod, renderContext, env, apiContext }) {
   }
   return response;
 }
-function isValueSerializable(value) {
-  let type = typeof value;
-  let plainObject = true;
-  if (type === "object" && isPlainObject(value)) {
-    for (const [, nestedValue] of Object.entries(value)) {
-      if (!isValueSerializable(nestedValue)) {
-        plainObject = false;
-        break;
-      }
-    }
-  } else {
-    plainObject = false;
-  }
-  let result = value === null || type === "string" || type === "number" || type === "boolean" || Array.isArray(value) || plainObject;
-  return result;
-}
-function isPlainObject(value) {
-  if (typeof value !== "object" || value === null)
-    return false;
-  let proto = Object.getPrototypeOf(value);
-  if (proto === null)
-    return true;
-  let baseProto = proto;
-  while (Object.getPrototypeOf(baseProto) !== null) {
-    baseProto = Object.getPrototypeOf(baseProto);
-  }
-  return proto === baseProto;
-}
 export {
   GetParamsAndPropsError,
   getParamsAndProps,
   getParamsAndPropsOrThrow,
-  isValueSerializable,
   renderPage
 };

package/dist/core/render/dev/vite.js

@@ -1,13 +1,15 @@
 import npath from "path";
+import { PROPAGATED_ASSET_FLAG } from "../../../content/consts.js";
 import { SUPPORTED_MARKDOWN_FILE_EXTENSIONS } from "../../constants.js";
 import { unwrapId } from "../../util.js";
 import { isCSSRequest } from "./util.js";
-const fileExtensionsToSSR = /* @__PURE__ */ new Set([".astro", ".mdoc", ...SUPPORTED_MARKDOWN_FILE_EXTENSIONS]);
+const fileExtensionsToSSR = /* @__PURE__ */ new Set([".astro", ...SUPPORTED_MARKDOWN_FILE_EXTENSIONS]);
 const STRIP_QUERY_PARAMS_REGEX = /\?.*$/;
-const ASTRO_PROPAGATED_ASSET_REGEX = /\?astroPropagatedAssets/;
 async function* crawlGraph(loader, _id, isRootFile, scanned = /* @__PURE__ */ new Set()) {
   const id = unwrapId(_id);
   const importedModules = /* @__PURE__ */ new Set();
+  if (new URL(id, "file://").searchParams.has(PROPAGATED_ASSET_FLAG))
+    return;
   const moduleEntriesForId = isRootFile ? (
     // "getModulesByFile" pulls from a delayed module cache (fun implementation detail),
     // So we can get up-to-date info on initial server load.
@@ -31,11 +33,14 @@ async function* crawlGraph(loader, _id, isRootFile, scanned = /* @__PURE__ */ ne
           if (entryIsStyle && !isCSSRequest(importedModulePathname)) {
             continue;
           }
-          const isFileTypeNeedingSSR = fileExtensionsToSSR.has(
-            npath.extname(importedModulePathname)
-          );
-          if (isFileTypeNeedingSSR && // Should not SSR a module with ?astroPropagatedAssets
-          !ASTRO_PROPAGATED_ASSET_REGEX.test(importedModule.id)) {
+          if (fileExtensionsToSSR.has(
+            npath.extname(
+              // Use `id` instead of `pathname` to preserve query params.
+              // Should not SSR a module with an unexpected query param,
+              // like "?astroPropagatedAssets"
+              importedModule.id
+            )
+          )) {
             const mod = loader.getModuleById(importedModule.id);
             if (!(mod == null ? void 0 : mod.ssrModule)) {
               try {

package/dist/core/render/result.js

@@ -1,3 +1,4 @@
+import { isHTMLString } from "../../runtime/server/escape.js";
 import {
   renderSlotToString,
   stringifyChunk
@@ -69,10 +70,10 @@ class Slots {
       const component = typeof slotValue === "function" ? await slotValue(result) : await slotValue;
       const expression = getFunctionExpression(component);
       if (expression) {
-        const slot = () => expression(...args);
-        return await renderSlotToString(result, slot).then(
-          (res) => res != null ? String(res) : res
-        );
+        const slot = async () => isHTMLString(await expression) ? expression : expression(...args);
+        return await renderSlotToString(result, slot).then((res) => {
+          return res != null ? String(res) : res;
+        });
       }
       if (typeof component === "function") {
         return await renderJSX(result, component(...args)).then(

package/dist/core/sync/index.js

@@ -34,7 +34,7 @@ async function sync(settings, { logging, fs }) {
   const tempViteServer = await createServer(
     await createVite(
       {
-        server: { middlewareMode: true, hmr: false },
+        server: { middlewareMode: true, hmr: false, watch: { ignored: ["**"] } },
         optimizeDeps: { disabled: true },
         ssr: { external: [] },
         logLevel: "silent"

package/dist/runtime/server/render/slot.d.ts

@@ -4,7 +4,7 @@ import type { RenderInstruction } from './types.js';
 import { HTMLString } from '../escape.js';
 type RenderTemplateResult = ReturnType<typeof renderTemplate>;
 export type ComponentSlots = Record<string, ComponentSlotValue>;
-export type ComponentSlotValue = (result: SSRResult) => RenderTemplateResult;
+export type ComponentSlotValue = (result: SSRResult) => RenderTemplateResult | Promise<RenderTemplateResult>;
 declare const slotString: unique symbol;
 export declare class SlotString extends HTMLString {
     instructions: null | RenderInstruction[];

package/dist/runtime/server/render/util.js

@@ -20,9 +20,10 @@ const toStyleString = (obj) => Object.entries(obj).map(([k, v]) => {
   return `${k}:${v}`;
 }).join(";");
 function defineScriptVars(vars) {
+  var _a;
   let output = "";
   for (const [key, value] of Object.entries(vars)) {
-    output += `const ${toIdent(key)} = ${JSON.stringify(value).replace(
+    output += `const ${toIdent(key)} = ${(_a = JSON.stringify(value)) == null ? void 0 : _a.replace(
       /<\/script>/g,
       "\\x3C/script>"
     )};

package/dist/vite-plugin-head/index.js

@@ -1,6 +1,6 @@
 import { getTopLevelPages, walkParentInfos } from "../core/build/graph.js";
 import { getAstroMetadata } from "../vite-plugin-astro/index.js";
-const injectExp = /(^\/\/|\/\/!)\s*astro-head-inject/;
+const injectExp = /^\/\/\s*astro-head-inject/;
 function configHeadVitePlugin({
   settings
 }) {

package/dist/vite-plugin-markdown/content-entry-type.js

@@ -10,9 +10,7 @@ const markdownContentEntryType = {
       slug: parsed.data.slug,
       rawData: parsed.matter
     };
-  },
-  // We need to handle propagation for Markdown because they support layouts which will bring in styles.
-  handlePropagation: true
+  }
 };
 const mdxContentEntryType = {
   extensions: [".mdx"],
@@ -25,9 +23,6 @@ const mdxContentEntryType = {
       rawData: parsed.matter
     };
   },
-  // MDX can import scripts and styles,
-  // so wrap all MDX files with script / style propagation checks
-  handlePropagation: true,
   contentModuleTypes: `declare module 'astro:content' {
 	interface Render {
 		'.mdx': Promise<{

package/import-meta.d.ts

@@ -1,4 +1,4 @@
-// File vendored from Vite itself, as a workaround to https://github.com/vitejs/vite/pull/9827 until Vite 4 comes out
+// File vendored from Vite itself, as a workaround to https://github.com/vitejs/vite/issues/13309 until Vite 5 comes out
 
 // This file is an augmentation to the built-in ImportMeta interface
 // Thus cannot contain any top-level imports
@@ -6,13 +6,6 @@
 
 /* eslint-disable @typescript-eslint/consistent-type-imports */
 
-// Duplicate of import('../src/node/importGlob').GlobOptions in order to
-// avoid breaking the production client type. Because this file is referenced
-// in vite/client.d.ts and in production src/node/importGlob.ts doesn't exist.
-interface GlobOptions {
-	as?: string;
-}
-
 interface ImportMeta {
 	url: string;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "2.5.3",
+  "version": "2.5.5",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -135,6 +135,7 @@
     "magic-string": "^0.27.0",
     "mime": "^3.0.0",
     "ora": "^6.1.0",
+    "p-limit": "^4.0.0",
     "path-to-regexp": "^6.2.1",
     "preferred-pm": "^3.0.3",
     "prompts": "^2.4.2",

package/src/content/template/virtual-mod.mjs

@@ -46,7 +46,7 @@ function createGlobLookup(glob) {
 }
 
 const renderEntryGlob = import.meta.glob('@@RENDER_ENTRY_GLOB_PATH@@', {
-	query: { astroRenderContent: true },
+	query: { astroPropagatedAssets: true },
 });
 const collectionToRenderEntryMap = createCollectionToGlobResultMap({
 	globResult: renderEntryGlob,