astro 6.1.2 → 6.1.3

package/dist/actions/integration.js

@@ -1,6 +1,6 @@
 import { AstroError } from "../core/errors/errors.js";
 import { ActionsWithoutServerOutputError } from "../core/errors/errors-data.js";
-import { hasNonPrerenderedProjectRoute } from "../core/routing/helpers.js";
+import { hasNonPrerenderedRoute } from "../core/routing/helpers.js";
 import { viteID } from "../core/util.js";
 import { ACTION_RPC_ROUTE_PATTERN, ACTIONS_TYPES_FILE, VIRTUAL_MODULE_ID } from "./consts.js";
 function astroIntegrationActionsRouteHandler({
@@ -30,7 +30,7 @@ function astroIntegrationActionsRouteHandler({
         });
       },
       "astro:routes:resolved": ({ routes }) => {
-        if (!hasNonPrerenderedProjectRoute(routes)) {
+        if (!hasNonPrerenderedRoute(routes)) {
           const error = new AstroError(ActionsWithoutServerOutputError);
           error.stack = void 0;
           throw error;

package/dist/cli/infra/build-time-astro-version-provider.js

@@ -1,6 +1,6 @@
 class BuildTimeAstroVersionProvider {
   // Injected during the build through esbuild define
-  version = "6.1.2";
+  version = "6.1.3";
 }
 export {
   BuildTimeAstroVersionProvider

package/dist/content/content-layer.js

@@ -192,7 +192,7 @@ ${contentConfig.error.message}`
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "6.1.2") {
+    if (previousAstroVersion && previousAstroVersion !== "6.1.3") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -200,8 +200,8 @@ ${contentConfig.error.message}`
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("6.1.2") {
-      this.#store.metaStore().set("astro-version", "6.1.2");
+    if ("6.1.3") {
+      this.#store.metaStore().set("astro-version", "6.1.3");
     }
     if (currentConfigDigest) {
       this.#store.metaStore().set("content-config-digest", currentConfigDigest);

package/dist/content/loaders/glob.js

@@ -242,8 +242,12 @@ function glob(globOptions) {
         const entryType = configForFile(changedPath);
         const baseUrl = pathToFileURL(basePath);
         const oldId = fileToIdMap.get(changedPath);
-        await syncData(entry, baseUrl, entryType, oldId);
-        logger.info(`Reloaded data from ${colors.green(entry)}`);
+        try {
+          await syncData(entry, baseUrl, entryType, oldId);
+          logger.info(`Reloaded data from ${colors.green(entry)}`);
+        } catch (e) {
+          logger.error(`Failed to reload ${entry}: ${e.message}`);
+        }
       }
       watcher.on("change", onChange);
       watcher.on("add", onChange);

package/dist/content/mutable-data-store.js

@@ -35,15 +35,18 @@ class MutableDataStore extends ImmutableDataStore {
     if (collection) {
       collection.delete(String(key));
       this.#saveToDiskDebounced();
+      this.#writeAssetsImportsDebounced();
     }
   }
   clear(collectionName) {
     this._collections.delete(collectionName);
     this.#saveToDiskDebounced();
+    this.#writeAssetsImportsDebounced();
   }
   clearAll() {
     this._collections.clear();
     this.#saveToDiskDebounced();
+    this.#writeAssetsImportsDebounced();
   }
   addAssetImport(assetImport, filePath) {
     const id = imageSrcToImportId(assetImport, filePath);
@@ -62,8 +65,31 @@ class MutableDataStore extends ImmutableDataStore {
       this.#writeModulesImportsDebounced();
     }
   }
+  /**
+   * Rebuilds #assetImports from the current entries in _collections.
+   * This ensures stale import IDs are removed when entries are updated or deleted,
+   * preventing unrecoverable ImageNotFound errors in astro dev after a content entry's
+   * image path is temporarily set to an invalid value and then restored.
+   */
+  #rebuildAssetImports() {
+    this.#assetImports.clear();
+    for (const collection of this._collections.values()) {
+      for (const entry of collection.values()) {
+        const typedEntry = entry;
+        if (typedEntry.assetImports?.length) {
+          for (const assetImport of typedEntry.assetImports) {
+            const id = imageSrcToImportId(assetImport, typedEntry.filePath);
+            if (id) {
+              this.#assetImports.add(id);
+            }
+          }
+        }
+      }
+    }
+  }
   async writeAssetImports(filePath) {
     this.#assetsFile = filePath;
+    this.#rebuildAssetImports();
     if (this.#assetImports.size === 0) {
       try {
         await this.#writeFileAtomic(filePath, "export default new Map();");

package/dist/core/app/dev/pipeline.js

@@ -42,6 +42,10 @@ class NonRunnablePipeline extends Pipeline {
     return pipeline;
   }
   async headElements(routeData) {
+    const { componentMetadataEntries } = await import("virtual:astro:component-metadata");
+    for (const [id, entry] of componentMetadataEntries) {
+      this.manifest.componentMetadata.set(id, entry);
+    }
     const { assetsPrefix, base } = this.manifest;
     const routeInfo = this.manifest.routes.find((route) => route.routeData === routeData);
     const links = /* @__PURE__ */ new Set();

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

@@ -8,6 +8,7 @@ import { pluginMiddleware } from "./plugin-middleware.js";
 import { pluginPrerender } from "./plugin-prerender.js";
 import { pluginScripts } from "./plugin-scripts.js";
 import { pluginSSR } from "./plugin-ssr.js";
+import { pluginChunkImports } from "./plugin-chunk-imports.js";
 import { pluginNoop } from "./plugin-noop.js";
 import { vitePluginSSRAssets } from "../vite-plugin-ssr-assets.js";
 function getAllBuildPlugins(internals, options) {
@@ -23,7 +24,8 @@ function getAllBuildPlugins(internals, options) {
     pluginScripts(internals),
     ...pluginSSR(options, internals),
     pluginNoop(),
-    vitePluginSSRAssets(internals)
+    vitePluginSSRAssets(internals),
+    pluginChunkImports(options)
   ].filter(Boolean);
 }
 export {

package/dist/core/build/plugins/plugin-chunk-imports.d.ts

@@ -0,0 +1,10 @@
+import type { Plugin as VitePlugin } from 'vite';
+import type { StaticBuildOptions } from '../types.js';
+/**
+ * Appends assetQueryParams (e.g., ?dpl=<VERCEL_DEPLOYMENT_ID>) to relative
+ * JS import paths inside client chunks. Without this, inter-chunk imports
+ * bypass the HTML rendering pipeline and miss skew protection query params.
+ *
+ * Uses es-module-lexer to reliably parse both static and dynamic imports.
+ */
+export declare function pluginChunkImports(options: StaticBuildOptions): VitePlugin | undefined;

package/dist/core/build/plugins/plugin-chunk-imports.js

@@ -0,0 +1,38 @@
+import { init, parse } from "es-module-lexer";
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../../constants.js";
+function pluginChunkImports(options) {
+  const assetQueryParams = options.settings.adapter?.client?.assetQueryParams;
+  if (!assetQueryParams || assetQueryParams.toString() === "") {
+    return void 0;
+  }
+  const queryString = assetQueryParams.toString();
+  return {
+    name: "@astro/plugin-chunk-imports",
+    enforce: "post",
+    applyToEnvironment(environment) {
+      return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.client;
+    },
+    async renderChunk(code, _chunk) {
+      if (!code.includes("./")) {
+        return null;
+      }
+      await init;
+      const [imports] = parse(code);
+      const relativeImports = imports.filter(
+        (imp) => imp.n && /^\.\.?\//.test(imp.n) && /\.(?:js|mjs)$/.test(imp.n)
+      );
+      if (relativeImports.length === 0) {
+        return null;
+      }
+      let rewritten = code;
+      for (let i = relativeImports.length - 1; i >= 0; i--) {
+        const imp = relativeImports[i];
+        rewritten = rewritten.slice(0, imp.e) + "?" + queryString + rewritten.slice(imp.e);
+      }
+      return { code: rewritten, map: null };
+    }
+  };
+}
+export {
+  pluginChunkImports
+};

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

@@ -15,6 +15,11 @@ function pluginCSS(options, internals) {
     internals
   });
 }
+function isBuildCssBoundary(id, ctx) {
+  if (isPropagatedAssetBoundary(id)) return true;
+  const info = ctx.getModuleInfo(id);
+  return info ? moduleIsTopLevelPage(info) : false;
+}
 function rollupPluginAstroBuildCSS(options) {
   const { internals, buildOptions } = options;
   const { settings } = buildOptions;
@@ -95,7 +100,7 @@ function rollupPluginAstroBuildCSS(options) {
                 const parentModuleInfos = getParentExtendedModuleInfos(
                   scopedToModule,
                   this,
-                  isPropagatedAssetBoundary
+                  (moduleId) => isBuildCssBoundary(moduleId, this)
                 );
                 for (const { info: pageInfo, depth, order } of parentModuleInfos) {
                   if (moduleIsTopLevelPage(pageInfo)) {
@@ -155,7 +160,7 @@ function rollupPluginAstroBuildCSS(options) {
           const parentModuleInfos = getParentExtendedModuleInfos(
             id,
             this,
-            isPropagatedAssetBoundary
+            (importer) => isBuildCssBoundary(importer, this)
           );
           for (const { info: pageInfo, depth, order } of parentModuleInfos) {
             if (isPropagatedAssetBoundary(pageInfo.id)) {

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "6.1.2";
+const ASTRO_VERSION = "6.1.3";
 const ASTRO_GENERATOR = `Astro v${ASTRO_VERSION}`;
 const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";
 const REWRITE_DIRECTIVE_HEADER_KEY = "X-Astro-Rewrite";

package/dist/core/cookies/cookies.d.ts

@@ -3,7 +3,7 @@ export type AstroCookieSetOptions = Pick<SerializeOptions, 'domain' | 'path' | '
 export interface AstroCookieGetOptions {
     decode?: (value: string) => string;
 }
-type AstroCookieDeleteOptions = Omit<AstroCookieSetOptions, 'expires' | 'maxAge' | 'encode'>;
+export type AstroCookieDeleteOptions = Omit<AstroCookieSetOptions, 'expires' | 'maxAge' | 'encode'>;
 interface AstroCookieInterface {
     value: string;
     json(): Record<string, any>;

package/dist/core/dev/dev.js

@@ -37,7 +37,7 @@ async function dev(inlineConfig) {
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "6.1.2";
+  const currentVersion = "6.1.3";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

package/dist/core/messages/runtime.js

@@ -276,7 +276,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"6.1.2"}`
+        `v${"6.1.3"}`
       )} ${headline}`
     );
   }

package/dist/core/routing/dev.js

@@ -8,7 +8,6 @@ async function matchRoute(pathname, routesList, pipeline, manifest) {
   const { logger, routeCache } = pipeline;
   const matches = matchAllRoutes(pathname, routesList);
   const preloadedMatches = getSortedPreloadedMatches({
-    pipeline,
     matches,
     manifest
   });

package/dist/core/routing/helpers.d.ts

@@ -38,10 +38,12 @@ export declare function getCustom500Route(manifestData: RoutesList): RouteData |
  * `.html` suffix from pathnames that intentionally include it.
  */
 export declare function routeHasHtmlExtension(route: RouteData): boolean;
-export declare function hasNonPrerenderedProjectRoute(routes: Array<Pick<RouteData, 'type' | 'origin' | 'prerender'>>, options?: {
+export declare function hasNonPrerenderedRoute(routes: Array<Pick<RouteData, 'type' | 'origin' | 'prerender'>>, options?: {
     includeEndpoints?: boolean;
+    includeExternal?: boolean;
 }): boolean;
-export declare function hasNonPrerenderedProjectRoute(routes: Array<Pick<IntegrationResolvedRoute, 'type' | 'origin' | 'isPrerendered'>>, options?: {
+export declare function hasNonPrerenderedRoute(routes: Array<Pick<IntegrationResolvedRoute, 'type' | 'origin' | 'isPrerendered'>>, options?: {
     includeEndpoints?: boolean;
+    includeExternal?: boolean;
 }): boolean;
 export {};

package/dist/core/routing/helpers.js

@@ -30,19 +30,21 @@ function routeHasHtmlExtension(route) {
     (segment) => segment.some((part) => !part.dynamic && part.content.includes(".html"))
   );
 }
-function hasNonPrerenderedProjectRoute(routes, options) {
+function hasNonPrerenderedRoute(routes, options) {
   const includeEndpoints = options?.includeEndpoints ?? true;
+  const includeExternal = options?.includeExternal ?? false;
   const routeTypes = includeEndpoints ? ["page", "endpoint"] : ["page"];
+  const origins = includeExternal ? ["project", "external"] : ["project"];
   return routes.some((route) => {
     const isPrerendered = "isPrerendered" in route ? route.isPrerendered : route.prerender;
-    return routeTypes.includes(route.type) && route.origin === "project" && !isPrerendered;
+    return routeTypes.includes(route.type) && origins.includes(route.origin) && !isPrerendered;
   });
 }
 export {
   getCustom404Route,
   getCustom500Route,
   getFallbackRoute,
-  hasNonPrerenderedProjectRoute,
+  hasNonPrerenderedRoute,
   routeHasHtmlExtension,
   routeIsFallback,
   routeIsRedirect

package/dist/prerender/routing.d.ts

@@ -1,11 +1,9 @@
 import type { RouteData, SSRManifest } from '../types/public/internal.js';
-import type { RunnablePipeline } from '../vite-plugin-app/pipeline.js';
 type GetSortedPreloadedMatchesParams = {
-    pipeline: RunnablePipeline;
     matches: RouteData[];
     manifest: SSRManifest;
 };
-export declare function getSortedPreloadedMatches({ pipeline, matches, manifest, }: GetSortedPreloadedMatchesParams): PreloadAndSetPrerenderStatusResult[];
+export declare function getSortedPreloadedMatches({ matches, manifest }: GetSortedPreloadedMatchesParams): PreloadAndSetPrerenderStatusResult[];
 type PreloadAndSetPrerenderStatusResult = {
     filePath: URL;
     route: RouteData;

package/dist/prerender/routing.js

@@ -1,12 +1,7 @@
 import { routeIsRedirect } from "../core/routing/helpers.js";
 import { routeComparator } from "../core/routing/priority.js";
-function getSortedPreloadedMatches({
-  pipeline,
-  matches,
-  manifest
-}) {
+function getSortedPreloadedMatches({ matches, manifest }) {
   return preloadAndSetPrerenderStatus({
-    pipeline,
     matches,
     manifest
   }).sort((a, b) => routeComparator(a.route, b.route)).sort((a, b) => prioritizePrerenderedMatchesComparator(a.route, b.route));

package/dist/runtime/server/escape.d.ts

@@ -1,12 +1,13 @@
 export declare const escapeHTML: (str: string) => string;
 export declare class HTMLBytes extends Uint8Array {
 }
+declare const htmlStringSymbol: unique symbol;
 /**
  * A "blessed" extension of String that tells Astro that the string
  * has already been escaped. This helps prevent double-escaping of HTML.
  */
 export declare class HTMLString extends String {
-    get [Symbol.toStringTag](): string;
+    [htmlStringSymbol]: boolean;
 }
 type BlessedType = string | HTMLBytes;
 /**

package/dist/runtime/server/escape.js

@@ -8,13 +8,12 @@ Object.defineProperty(HTMLBytes.prototype, Symbol.toStringTag, {
     return "HTMLBytes";
   }
 });
+const htmlStringSymbol = /* @__PURE__ */ Symbol.for("astro:html-string");
 class HTMLString extends String {
-  get [Symbol.toStringTag]() {
-    return "HTMLString";
-  }
+  [htmlStringSymbol] = true;
 }
 const markHTMLString = (value) => {
-  if (value instanceof HTMLString) {
+  if (isHTMLString(value)) {
     return value;
   }
   if (typeof value === "string") {
@@ -23,7 +22,7 @@ const markHTMLString = (value) => {
   return value;
 };
 function isHTMLString(value) {
-  return value instanceof HTMLString;
+  return !!value?.[htmlStringSymbol];
 }
 function markHTMLBytes(bytes) {
   return new HTMLBytes(bytes);

package/dist/vite-plugin-astro-server/plugin.d.ts

@@ -1,5 +1,4 @@
 import type * as vite from 'vite';
-import type { SSRManifest } from '../core/app/types.js';
 import type { Logger } from '../core/logger/core.js';
 import type { AstroSettings } from '../types/astro.js';
 interface AstroPluginOptions {
@@ -7,11 +6,4 @@ interface AstroPluginOptions {
     logger: Logger;
 }
 export default function createVitePluginAstroServer({ settings, logger, }: AstroPluginOptions): vite.Plugin;
-/**
- * It creates a `SSRManifest` from the `AstroSettings`.
- *
- * Renderers needs to be pulled out from the page module emitted during the build.
- * @param settings
- */
-export declare function createDevelopmentManifest(settings: AstroSettings): Promise<SSRManifest>;
 export {};

package/dist/vite-plugin-astro-server/plugin.js

@@ -1,26 +1,11 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { IncomingMessage } from "node:http";
 import { isRunnableDevEnvironment } from "vite";
-import { toFallbackType } from "../core/app/common.js";
-import { toRoutingStrategy } from "../core/app/entrypoints/index.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES, devPrerenderMiddlewareSymbol } from "../core/constants.js";
-import {
-  getAlgorithm,
-  getDirectives,
-  getScriptHashes,
-  getScriptResources,
-  getStrictDynamic,
-  getStyleHashes,
-  getStyleResources,
-  shouldTrackCspHashes
-} from "../core/csp/common.js";
-import { createKey, getEnvironmentKey, hasEnvironmentKey } from "../core/encryption.js";
 import { getViteErrorPayload } from "../core/errors/dev/index.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
-import { NOOP_MIDDLEWARE_FN } from "../core/middleware/noop-middleware.js";
 import { createViteLoader } from "../core/module-loader/index.js";
 import { matchAllRoutes } from "../core/routing/match.js";
-import { resolveMiddlewareMode } from "../integrations/adapter-utils.js";
 import { SERIALIZED_MANIFEST_ID } from "../manifest/serialized.js";
 import { ASTRO_DEV_SERVER_APP_ID } from "../vite-plugin-app/index.js";
 import { baseMiddleware } from "./base.js";
@@ -30,7 +15,6 @@ import { setRouteError } from "./server-state.js";
 import { routeGuardMiddleware } from "./route-guard.js";
 import { secFetchMiddleware } from "./sec-fetch.js";
 import { trailingSlashMiddleware } from "./trailing-slash.js";
-import { sessionConfigToManifest } from "../core/session/utils.js";
 function createVitePluginAstroServer({
   settings,
   logger
@@ -154,97 +138,6 @@ function createVitePluginAstroServer({
     }
   };
 }
-async function createDevelopmentManifest(settings) {
-  let i18nManifest;
-  let csp;
-  if (settings.config.i18n) {
-    i18nManifest = {
-      fallback: settings.config.i18n.fallback,
-      strategy: toRoutingStrategy(settings.config.i18n.routing, settings.config.i18n.domains),
-      defaultLocale: settings.config.i18n.defaultLocale,
-      locales: settings.config.i18n.locales,
-      domainLookupTable: {},
-      fallbackType: toFallbackType(settings.config.i18n.routing),
-      domains: settings.config.i18n.domains
-    };
-  }
-  if (shouldTrackCspHashes(settings.config.security.csp)) {
-    const styleHashes = [
-      ...getStyleHashes(settings.config.security.csp),
-      ...settings.injectedCsp.styleHashes
-    ];
-    csp = {
-      cspDestination: settings.adapter?.adapterFeatures?.staticHeaders ? "adapter" : void 0,
-      scriptHashes: getScriptHashes(settings.config.security.csp),
-      scriptResources: getScriptResources(settings.config.security.csp),
-      styleHashes,
-      styleResources: getStyleResources(settings.config.security.csp),
-      algorithm: getAlgorithm(settings.config.security.csp),
-      directives: getDirectives(settings),
-      isStrictDynamic: getStrictDynamic(settings.config.security.csp)
-    };
-  }
-  return {
-    rootDir: settings.config.root,
-    srcDir: settings.config.srcDir,
-    cacheDir: settings.config.cacheDir,
-    outDir: settings.config.outDir,
-    buildServerDir: settings.config.build.server,
-    buildClientDir: settings.config.build.client,
-    publicDir: settings.config.publicDir,
-    trailingSlash: settings.config.trailingSlash,
-    buildFormat: settings.config.build.format,
-    compressHTML: settings.config.compressHTML,
-    assetsDir: settings.config.build.assets,
-    serverLike: settings.buildOutput === "server",
-    middlewareMode: resolveMiddlewareMode(settings.adapter?.adapterFeatures),
-    assets: /* @__PURE__ */ new Set(),
-    entryModules: {},
-    routes: [],
-    adapterName: settings?.adapter?.name ?? "",
-    clientDirectives: settings.clientDirectives,
-    renderers: [],
-    base: settings.config.base,
-    userAssetsBase: settings.config?.vite?.base,
-    assetsPrefix: settings.config.build.assetsPrefix,
-    site: settings.config.site,
-    componentMetadata: /* @__PURE__ */ new Map(),
-    inlinedScripts: /* @__PURE__ */ new Map(),
-    i18n: i18nManifest,
-    checkOrigin: settings.config.security?.checkOrigin ?? false,
-    allowedDomains: settings.config.security?.allowedDomains,
-    actionBodySizeLimit: settings.config.security?.actionBodySizeLimit ? settings.config.security.actionBodySizeLimit : 1024 * 1024,
-    // 1mb default
-    serverIslandBodySizeLimit: settings.config.security?.serverIslandBodySizeLimit ? settings.config.security.serverIslandBodySizeLimit : 1024 * 1024,
-    // 1mb default
-    key: hasEnvironmentKey() ? getEnvironmentKey() : createKey(),
-    middleware() {
-      return {
-        onRequest: NOOP_MIDDLEWARE_FN
-      };
-    },
-    sessionConfig: sessionConfigToManifest(settings.config.session),
-    csp,
-    image: {
-      objectFit: settings.config.image.objectFit,
-      objectPosition: settings.config.image.objectPosition,
-      layout: settings.config.image.layout
-    },
-    devToolbar: {
-      enabled: settings.config.devToolbar.enabled && await settings.preferences.get("devToolbar.enabled"),
-      latestAstroVersion: settings.latestAstroVersion,
-      debugInfoOutput: "",
-      placement: settings.config.devToolbar.placement
-    },
-    logLevel: settings.logLevel,
-    shouldInjectCspMetaTags: false,
-    experimentalQueuedRendering: {
-      enabled: !!settings.config.experimental?.queuedRendering,
-      poolSize: settings.config.experimental?.queuedRendering?.poolSize ?? 1e3
-    }
-  };
-}
 export {
-  createDevelopmentManifest,
   createVitePluginAstroServer as default
 };

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

@@ -6,8 +6,16 @@ import {
 import { getTopLevelPageModuleInfos } from "../core/build/graph.js";
 import { getAstroMetadata } from "../vite-plugin-astro/index.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
+const VIRTUAL_COMPONENT_METADATA = "virtual:astro:component-metadata";
+const RESOLVED_VIRTUAL_COMPONENT_METADATA = `\0${VIRTUAL_COMPONENT_METADATA}`;
 function configHeadVitePlugin() {
   let environment;
+  function invalidateComponentMetadataModule() {
+    const virtualMod = environment.moduleGraph.getModuleById(RESOLVED_VIRTUAL_COMPONENT_METADATA);
+    if (virtualMod) {
+      environment.moduleGraph.invalidateModule(virtualMod);
+    }
+  }
   function buildImporterGraphFromEnvironment(seed) {
     const queue = [seed];
     const collected = /* @__PURE__ */ new Set();
@@ -46,15 +54,44 @@ function configHeadVitePlugin() {
         }
       }
     }
+    invalidateComponentMetadataModule();
   }
   return {
     name: "astro:head-metadata",
     enforce: "pre",
     apply: "serve",
-    configureServer(server) {
-      environment = server.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
+    configureServer(devServer) {
+      environment = devServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
+      devServer.watcher.on("add", invalidateComponentMetadataModule);
+      devServer.watcher.on("unlink", invalidateComponentMetadataModule);
+      devServer.watcher.on("change", invalidateComponentMetadataModule);
+    },
+    load(id) {
+      if (id !== RESOLVED_VIRTUAL_COMPONENT_METADATA) {
+        return;
+      }
+      const componentMetadataEntries = [];
+      for (const [moduleId, mod] of environment.moduleGraph.idToModuleMap) {
+        const info = this.getModuleInfo(moduleId) ?? (mod.id ? this.getModuleInfo(mod.id) : null);
+        if (!info) continue;
+        const astro = getAstroMetadata(info);
+        if (!astro) continue;
+        componentMetadataEntries.push([
+          moduleId,
+          {
+            containsHead: astro.containsHead,
+            propagation: astro.propagation
+          }
+        ]);
+      }
+      return {
+        code: `export const componentMetadataEntries = ${JSON.stringify(componentMetadataEntries)};`
+      };
     },
     resolveId(source, importer) {
+      if (source === VIRTUAL_COMPONENT_METADATA) {
+        return RESOLVED_VIRTUAL_COMPONENT_METADATA;
+      }
       if (importer) {
         return this.resolve(source, importer, { skipSelf: true }).then((result) => {
           if (result) {
@@ -81,6 +118,7 @@ function configHeadVitePlugin() {
       if (hasHeadInjectComment(source)) {
         propagateMetadata.call(this, id, "propagation", "in-tree");
       }
+      invalidateComponentMetadataModule();
     }
   };
 }

package/dist/vite-plugin-hmr-reload/index.js

@@ -1,6 +1,6 @@
-import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
 import { VIRTUAL_PAGE_RESOLVED_MODULE_ID } from "../vite-plugin-pages/const.js";
 import { getDevCssModuleNameFromPageVirtualModuleName } from "../vite-plugin-css/util.js";
+import { isAstroServerEnvironment } from "../environments.js";
 function hmrReload() {
   return {
     name: "astro:hmr-reload",
@@ -8,7 +8,7 @@ function hmrReload() {
     hotUpdate: {
       order: "post",
       handler({ modules, server, timestamp }) {
-        if (this.environment.name !== ASTRO_VITE_ENVIRONMENT_NAMES.ssr) return;
+        if (!isAstroServerEnvironment(this.environment)) return;
         let hasSsrOnlyModules = false;
         const invalidatedModules = /* @__PURE__ */ new Set();
         for (const mod of modules) {

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

@@ -1,5 +1,5 @@
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
-import { hasNonPrerenderedProjectRoute } from "../core/routing/helpers.js";
+import { hasNonPrerenderedRoute } from "../core/routing/helpers.js";
 const ASTRO_RENDERERS_MODULE_ID = "virtual:astro:renderers";
 const RESOLVED_ASTRO_RENDERERS_MODULE_ID = `\0${ASTRO_RENDERERS_MODULE_ID}`;
 function vitePluginRenderers(options) {
@@ -20,8 +20,9 @@ function vitePluginRenderers(options) {
         id: new RegExp(`^${RESOLVED_ASTRO_RENDERERS_MODULE_ID}$`)
       },
       handler() {
-        if (options.command === "build" && this.environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr && renderers.length > 0 && !options.serverIslandsState.hasIslands() && !hasNonPrerenderedProjectRoute(options.routesList.routes, {
-          includeEndpoints: false
+        if (options.command === "build" && this.environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr && renderers.length > 0 && !options.serverIslandsState.hasIslands() && !hasNonPrerenderedRoute(options.routesList.routes, {
+          includeEndpoints: false,
+          includeExternal: true
         })) {
           return { code: `export const renderers = [];` };
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "6.1.2",
+  "version": "6.1.3",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -175,7 +175,7 @@
     "cheerio": "1.2.0",
     "eol": "^0.10.0",
     "expect-type": "^1.3.0",
-    "fs-fixture": "^2.11.0",
+    "fs-fixture": "^2.13.0",
     "mdast-util-mdx": "^3.0.0",
     "mdast-util-mdx-jsx": "^3.2.0",
     "node-mocks-http": "^1.17.2",