astro 6.0.8 → 6.1.1

package/dist/core/head-propagation/resolver.d.ts

@@ -0,0 +1,28 @@
+import type { PropagationHint, SSRResult } from '../../types/public/internal.js';
+/**
+ * Resolves the effective propagation hint for a component.
+ *
+ * Priority: explicit factory hint -> component metadata -> `none`.
+ *
+ * @example
+ * A runtime-created head entry uses `propagation: 'self'`, so it propagates
+ * even when metadata says `none`.
+ */
+export declare function resolvePropagationHint(input: {
+    factoryHint: PropagationHint | undefined;
+    moduleId: string | undefined;
+    metadataLookup: (moduleId: string) => PropagationHint | undefined;
+}): PropagationHint;
+/** Returns true when a hint should register a component as a propagator. */
+export declare function isPropagatingHint(hint: PropagationHint): boolean;
+/**
+ * Reads propagation metadata from an `SSRResult` + component factory.
+ *
+ * @example
+ * A compiled `.astro` module with metadata `in-tree` is treated as propagating
+ * when the factory does not set a stronger explicit hint.
+ */
+export declare function getPropagationHint(result: SSRResult, factory: {
+    propagation?: PropagationHint;
+    moduleId?: string | undefined;
+}): PropagationHint;

package/dist/core/head-propagation/resolver.js

@@ -0,0 +1,25 @@
+function resolvePropagationHint(input) {
+  const explicitHint = input.factoryHint ?? "none";
+  if (explicitHint !== "none") {
+    return explicitHint;
+  }
+  if (!input.moduleId) {
+    return "none";
+  }
+  return input.metadataLookup(input.moduleId) ?? "none";
+}
+function isPropagatingHint(hint) {
+  return hint === "self" || hint === "in-tree";
+}
+function getPropagationHint(result, factory) {
+  return resolvePropagationHint({
+    factoryHint: factory.propagation,
+    moduleId: factory.moduleId,
+    metadataLookup: (moduleId) => result.componentMetadata.get(moduleId)?.propagation
+  });
+}
+export {
+  getPropagationHint,
+  isPropagatingHint,
+  resolvePropagationHint
+};

package/dist/core/messages/runtime.d.ts

@@ -41,6 +41,9 @@ export declare function preferenceReset(name: string): string;
 export declare function telemetryDisabled(): string;
 export declare function telemetryReset(): string;
 export declare function fsStrictWarning(): string;
+export declare function vite8Warning({ viteVersion }: {
+    viteVersion: string;
+}): string;
 export declare function prerelease({ currentVersion }: {
     currentVersion: string;
 }): string;

package/dist/core/messages/runtime.js

@@ -134,6 +134,13 @@ function fsStrictWarning() {
 ${subtitle}
 `;
 }
+function vite8Warning({ viteVersion }) {
+  const title = yellow(`\u25B6 Vite ${bold(viteVersion)} detected in your project.`);
+  const subtitle = `  Astro requires Vite 7. Add ${bold('"overrides": { "vite": "^7" }')} to your ${bold("package.json")} to avoid issues.`;
+  return `${title}
+${subtitle}
+`;
+}
 function prerelease({ currentVersion }) {
   const tag = currentVersion.split("-").slice(1).join("-").replace(/\..*$/, "") || "unknown";
   const badge = bgYellow(black(` ${tag} `));
@@ -269,7 +276,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"6.0.8"}`
+        `v${"6.1.1"}`
       )} ${headline}`
     );
   }
@@ -327,5 +334,6 @@ export {
   telemetryEnabled,
   telemetryNotice,
   telemetryReset,
+  vite8Warning,
   warnIfCspWithShiki
 };

package/dist/core/middleware/vite-plugin.d.ts

@@ -1,4 +1,4 @@
-import type { Plugin as VitePlugin } from 'vite';
+import { type Plugin as VitePlugin } from 'vite';
 import type { AstroSettings } from '../../types/astro.js';
 import type { BuildInternals } from '../build/internal.js';
 import type { StaticBuildOptions } from '../build/types.js';

package/dist/core/middleware/vite-plugin.js

@@ -1,3 +1,7 @@
+import { fileURLToPath } from "node:url";
+import {
+  normalizePath as viteNormalizePath
+} from "vite";
 import { getServerOutputDirectory } from "../../prerender/utils.js";
 import { addRollupInput } from "../build/add-rollup-input.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES, MIDDLEWARE_PATH_SEGMENT_NAME } from "../constants.js";
@@ -11,11 +15,32 @@ function vitePluginMiddleware({ settings }) {
   let resolvedMiddlewareId = void 0;
   const hasIntegrationMiddleware = settings.middlewares.pre.length > 0 || settings.middlewares.post.length > 0;
   let userMiddlewareIsPresent = false;
+  const normalizedSrcDir = viteNormalizePath(fileURLToPath(settings.config.srcDir));
   return {
     name: "@astro/plugin-middleware",
     applyToEnvironment(environment) {
       return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.astro || environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender;
     },
+    configureServer(server) {
+      server.watcher.on("change", (path) => {
+        const normalizedPath = viteNormalizePath(path);
+        if (!normalizedPath.startsWith(normalizedSrcDir)) return;
+        const relativePath = normalizedPath.slice(normalizedSrcDir.length);
+        if (!relativePath.startsWith(`${MIDDLEWARE_PATH_SEGMENT_NAME}.`)) return;
+        for (const name of [
+          ASTRO_VITE_ENVIRONMENT_NAMES.ssr,
+          ASTRO_VITE_ENVIRONMENT_NAMES.astro
+        ]) {
+          const environment = server.environments[name];
+          if (!environment) continue;
+          const virtualMod = environment.moduleGraph.getModuleById(MIDDLEWARE_RESOLVED_MODULE_ID);
+          if (virtualMod) {
+            environment.moduleGraph.invalidateModule(virtualMod);
+          }
+          environment.hot.send("astro:middleware-updated", {});
+        }
+      });
+    },
     resolveId: {
       filter: {
         id: new RegExp(`^${MIDDLEWARE_MODULE_ID}$`)

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

@@ -1,4 +1,21 @@
+import type { Params } from '../../types/public/common.js';
 import type { RedirectConfig } from '../../types/public/index.js';
+import type { RouteData } from '../../types/public/internal.js';
 import type { RenderContext } from '../render-context.js';
 export declare function redirectIsExternal(redirect: RedirectConfig): boolean;
+/**
+ * Computes the HTTP status code for a redirect response.
+ *
+ * - If the route has a `redirectRoute` and an explicit numeric status, that status is used.
+ * - Otherwise: GET → 301, non-GET (e.g. POST) → 308.
+ */
+export declare function computeRedirectStatus(method: string, redirect: RedirectConfig | undefined, redirectRoute: RouteData | undefined): number;
+/**
+ * Resolves the final redirect target URL by substituting dynamic params into
+ * the redirect string (e.g. `/[slug]/page` → `/hello/page`).
+ *
+ * When `redirectRoute` is provided its route generator is used; otherwise params
+ * are substituted manually into the string redirect target.
+ */
+export declare function resolveRedirectTarget(params: Params, redirect: RedirectConfig | undefined, redirectRoute: RouteData | undefined, trailingSlash: 'always' | 'never' | 'ignore'): string;
 export declare function renderRedirect(renderContext: RenderContext): Promise<Response>;

package/dist/core/redirects/render.js

@@ -9,31 +9,12 @@ function redirectIsExternal(redirect) {
     return isExternalURL(redirect.destination);
   }
 }
-async function renderRedirect(renderContext) {
-  const {
-    request: { method },
-    routeData
-  } = renderContext;
-  const { redirect, redirectRoute } = routeData;
-  const status = redirectRoute && typeof redirect === "object" ? redirect.status : method === "GET" ? 301 : 308;
-  const headers = { location: encodeURI(redirectRouteGenerate(renderContext)) };
-  if (redirect && redirectIsExternal(redirect)) {
-    if (typeof redirect === "string") {
-      return Response.redirect(redirect, status);
-    } else {
-      return Response.redirect(redirect.destination, status);
-    }
-  }
-  return new Response(null, { status, headers });
+function computeRedirectStatus(method, redirect, redirectRoute) {
+  return redirectRoute && typeof redirect === "object" ? redirect.status : method === "GET" ? 301 : 308;
 }
-function redirectRouteGenerate(renderContext) {
-  const {
-    params,
-    routeData: { redirect, redirectRoute },
-    pipeline
-  } = renderContext;
+function resolveRedirectTarget(params, redirect, redirectRoute, trailingSlash) {
   if (typeof redirectRoute !== "undefined") {
-    const generate = getRouteGenerator(redirectRoute.segments, pipeline.manifest.trailingSlash);
+    const generate = getRouteGenerator(redirectRoute.segments, trailingSlash);
     return generate(params) || redirectRoute?.pathname || "/";
   } else if (typeof redirect === "string") {
     if (redirectIsExternal(redirect)) {
@@ -51,7 +32,35 @@ function redirectRouteGenerate(renderContext) {
   }
   return redirect.destination;
 }
+async function renderRedirect(renderContext) {
+  const {
+    request: { method },
+    routeData
+  } = renderContext;
+  const { redirect, redirectRoute } = routeData;
+  const status = computeRedirectStatus(method, redirect, redirectRoute);
+  const headers = {
+    location: encodeURI(
+      resolveRedirectTarget(
+        renderContext.params,
+        redirect,
+        redirectRoute,
+        renderContext.pipeline.manifest.trailingSlash
+      )
+    )
+  };
+  if (redirect && redirectIsExternal(redirect)) {
+    if (typeof redirect === "string") {
+      return Response.redirect(redirect, status);
+    } else {
+      return Response.redirect(redirect.destination, status);
+    }
+  }
+  return new Response(null, { status, headers });
+}
 export {
+  computeRedirectStatus,
   redirectIsExternal,
-  renderRedirect
+  renderRedirect,
+  resolveRedirectTarget
 };

package/dist/core/routing/create-manifest.d.ts

@@ -1,5 +1,6 @@
 import nodeFs from 'node:fs';
 import type { AstroSettings, RoutesList } from '../../types/astro.js';
+import type { AstroConfig } from '../../types/public/config.js';
 import type { RouteData } from '../../types/public/internal.js';
 import type { Logger } from '../logger/core.js';
 export interface RouteEntry {
@@ -22,6 +23,20 @@ export declare function createRoutesFromEntries(entries: RouteEntry[], settings:
 export declare function createRoutesList(params: CreateRouteManifestParams, logger: Logger, { dev, }?: {
     dev?: boolean;
 }): Promise<RoutesList>;
+/**
+ * Generates i18n fallback routes and attaches them to their source routes.
+ *
+ * For each locale that has a fallback configured (e.g. `{ es: 'en' }`), this
+ * function inspects the existing route list and creates `type: 'fallback'`
+ * entries for any paths that the source locale does not already have.  The
+ * fallback routes are pushed onto `route.fallbackRoutes` of their source route
+ * so that the build pipeline can serve the fallback content.
+ *
+ * @param routes  The full route list — mutated in-place.
+ * @param i18n    The resolved `config.i18n` object.
+ * @param config  The resolved Astro config (needs `base` and `trailingSlash`).
+ */
+export declare function createI18nFallbackRoutes(routes: RouteData[], i18n: NonNullable<AstroConfig['i18n']>, config: Pick<AstroConfig, 'base' | 'trailingSlash'>): void;
 /**
  * Resolve a route entrypoint to an absolute component path.
  */

package/dist/core/routing/create-manifest.js

@@ -63,6 +63,7 @@ function createFileBasedRoutes({ settings, cwd, fsMod }, logger) {
   const pages = resolvePages(config);
   const localFs = fsMod ?? nodeFs;
   const rootPath = fileURLToPath(config.root);
+  const pagesPath = fileURLToPath(pages);
   if (!localFs.existsSync(pages)) {
     if (settings.injectedRoutes.length === 0) {
       const pagesDirRootRelative = pages.href.slice(settings.config.root.href.length);
@@ -177,7 +178,7 @@ function createFileBasedRoutes({ settings, cwd, fsMod }, logger) {
       }
     }
   }
-  walk(localFs, fileURLToPath(pages), [], []);
+  walk(localFs, pagesPath, [], []);
   return routes;
 }
 function createRoutesFromEntries(entries, settings, logger, pagesDirRelative = "src/pages") {
@@ -467,16 +468,12 @@ async function createRoutesList(params, logger, {
         if (route.type !== "page" && route.type !== "endpoint" && route.type !== "redirect") return;
         if (route.type === "redirect" && !route.redirectRoute) return;
         const localFs = params.fsMod ?? nodeFs;
-        const content = await localFs.promises.readFile(
-          fileURLToPath(
-            new URL(
-              // The destination redirect might be a prerendered
-              route.type === "redirect" && route.redirectRoute ? route.redirectRoute.component : route.component,
-              settings.config.root
-            )
-          ),
-          "utf-8"
+        const componentUrl = new URL(
+          // The destination redirect might be a prerendered
+          route.type === "redirect" && route.redirectRoute ? route.redirectRoute.component : route.component,
+          settings.config.root
         );
+        const content = await localFs.promises.readFile(componentUrl, "utf-8");
         await getRoutePrerenderOption(content, route, settings, logger);
       })
     );
@@ -504,144 +501,147 @@ async function createRoutesList(params, logger, {
         });
       }
     }
-    const routesByLocale = /* @__PURE__ */ new Map();
-    const setRoutes = new Set(routes.filter((route) => route.type === "page"));
-    const filteredLocales = i18n.locales.filter((loc) => {
-      if (typeof loc === "string") {
-        return loc !== i18n.defaultLocale;
-      }
-      return loc.path !== i18n.defaultLocale;
-    }).map((locale) => {
-      if (typeof locale === "string") {
-        return locale;
-      }
-      return locale.path;
-    });
-    for (const locale of filteredLocales) {
-      for (const route of setRoutes) {
-        const hasLocaleInRoute = route.route.split("/").includes(locale);
-        if (!hasLocaleInRoute) {
-          continue;
-        }
-        const currentRoutes = routesByLocale.get(locale);
-        if (currentRoutes) {
-          currentRoutes.push(route);
-          routesByLocale.set(locale, currentRoutes);
-        } else {
-          routesByLocale.set(locale, [route]);
-        }
-        setRoutes.delete(route);
-      }
+    createI18nFallbackRoutes(routes, i18n, config);
+  }
+  if (dev) {
+    ensure404Route({ routes });
+  }
+  if (dev || settings.buildOutput === "server") {
+    injectImageEndpoint(settings, { routes }, dev ? "dev" : "build");
+  }
+  if (dev || settings.config.adapter) {
+    injectServerIslandRoute(settings.config, { routes });
+  }
+  await runHookRoutesResolved({ routes, settings, logger });
+  return {
+    routes
+  };
+}
+function createI18nFallbackRoutes(routes, i18n, config) {
+  const strategy = toRoutingStrategy(i18n.routing, i18n.domains);
+  const routesByLocale = /* @__PURE__ */ new Map();
+  const setRoutes = new Set(routes.filter((route) => route.type === "page"));
+  const filteredLocales = i18n.locales.filter((loc) => {
+    if (typeof loc === "string") {
+      return loc !== i18n.defaultLocale;
     }
+    return loc.path !== i18n.defaultLocale;
+  }).map((locale) => {
+    if (typeof locale === "string") {
+      return locale;
+    }
+    return locale.path;
+  });
+  for (const locale of filteredLocales) {
     for (const route of setRoutes) {
-      const currentRoutes = routesByLocale.get(i18n.defaultLocale);
+      const hasLocaleInRoute = route.route.split("/").includes(locale);
+      if (!hasLocaleInRoute) {
+        continue;
+      }
+      const currentRoutes = routesByLocale.get(locale);
       if (currentRoutes) {
         currentRoutes.push(route);
-        routesByLocale.set(i18n.defaultLocale, currentRoutes);
+        routesByLocale.set(locale, currentRoutes);
       } else {
-        routesByLocale.set(i18n.defaultLocale, [route]);
+        routesByLocale.set(locale, [route]);
       }
       setRoutes.delete(route);
     }
-    if (strategy === "pathname-prefix-always") {
-      const defaultLocaleRoutes = routesByLocale.get(i18n.defaultLocale);
-      if (defaultLocaleRoutes) {
-        const indexDefaultRoute = defaultLocaleRoutes.find(({ route }) => route === "/") ?? defaultLocaleRoutes.find(({ route }) => route === `/${i18n.defaultLocale}`);
-        if (indexDefaultRoute) {
-          const pathname = "/";
-          const route = "/";
-          const segments = removeLeadingForwardSlash(route).split(path.posix.sep).filter(Boolean).map((s) => {
-            validateSegment(s);
-            return getParts(s, route);
-          });
-          routes.push({
-            ...indexDefaultRoute,
-            pathname,
-            route,
-            segments,
-            pattern: getPattern(segments, config.base, config.trailingSlash),
-            type: "fallback"
-          });
-        }
+  }
+  for (const route of setRoutes) {
+    const currentRoutes = routesByLocale.get(i18n.defaultLocale);
+    if (currentRoutes) {
+      currentRoutes.push(route);
+      routesByLocale.set(i18n.defaultLocale, currentRoutes);
+    } else {
+      routesByLocale.set(i18n.defaultLocale, [route]);
+    }
+    setRoutes.delete(route);
+  }
+  if (strategy === "pathname-prefix-always") {
+    const defaultLocaleRoutes = routesByLocale.get(i18n.defaultLocale);
+    if (defaultLocaleRoutes) {
+      const indexDefaultRoute = defaultLocaleRoutes.find(({ route }) => route === "/") ?? defaultLocaleRoutes.find(({ route }) => route === `/${i18n.defaultLocale}`);
+      if (indexDefaultRoute) {
+        const pathname = "/";
+        const route = "/";
+        const segments = removeLeadingForwardSlash(route).split(path.posix.sep).filter(Boolean).map((s) => {
+          validateSegment(s);
+          return getParts(s, route);
+        });
+        routes.push({
+          ...indexDefaultRoute,
+          pathname,
+          route,
+          segments,
+          pattern: getPattern(segments, config.base, config.trailingSlash),
+          type: "fallback"
+        });
       }
     }
-    if (i18n.fallback) {
-      let fallback = Object.entries(i18n.fallback);
-      if (fallback.length > 0) {
-        for (const [fallbackFromLocale, fallbackToLocale] of fallback) {
-          let fallbackToRoutes;
-          if (fallbackToLocale === i18n.defaultLocale) {
-            fallbackToRoutes = routesByLocale.get(i18n.defaultLocale);
-          } else {
-            fallbackToRoutes = routesByLocale.get(fallbackToLocale);
-          }
-          const fallbackFromRoutes = routesByLocale.get(fallbackFromLocale);
-          if (!fallbackToRoutes) {
-            continue;
-          }
-          for (const fallbackToRoute of fallbackToRoutes) {
-            const hasRoute = fallbackFromRoutes && // we check if the fallback from locale (the origin) has already this route
-            fallbackFromRoutes.some((route) => {
-              if (fallbackToLocale === i18n.defaultLocale) {
-                return route.route === `/${fallbackFromLocale}${fallbackToRoute.route}` || route.route.replace(`/${fallbackFromLocale}`, "") === fallbackToRoute.route;
-              } else {
-                const expectedRoute = replaceOrKeep(
-                  fallbackToRoute.route,
-                  fallbackToLocale,
-                  fallbackFromLocale
-                );
-                return route.route === expectedRoute;
+  }
+  if (i18n.fallback) {
+    const fallback = Object.entries(i18n.fallback);
+    if (fallback.length > 0) {
+      for (const [fallbackFromLocale, fallbackToLocale] of fallback) {
+        let fallbackToRoutes;
+        if (fallbackToLocale === i18n.defaultLocale) {
+          fallbackToRoutes = routesByLocale.get(i18n.defaultLocale);
+        } else {
+          fallbackToRoutes = routesByLocale.get(fallbackToLocale);
+        }
+        const fallbackFromRoutes = routesByLocale.get(fallbackFromLocale);
+        if (!fallbackToRoutes) {
+          continue;
+        }
+        for (const fallbackToRoute of fallbackToRoutes) {
+          const hasRoute = fallbackFromRoutes && fallbackFromRoutes.some((route) => {
+            if (fallbackToLocale === i18n.defaultLocale) {
+              return route.route === `/${fallbackFromLocale}${fallbackToRoute.route}` || route.route.replace(`/${fallbackFromLocale}`, "") === fallbackToRoute.route;
+            } else {
+              const expectedRoute = replaceOrKeep(
+                fallbackToRoute.route,
+                fallbackToLocale,
+                fallbackFromLocale
+              );
+              return route.route === expectedRoute;
+            }
+          });
+          if (!hasRoute) {
+            let pathname;
+            let route;
+            if (fallbackToLocale === i18n.defaultLocale && strategy === "pathname-prefix-other-locales") {
+              if (fallbackToRoute.pathname) {
+                pathname = `/${fallbackFromLocale}${fallbackToRoute.pathname}`;
               }
+              route = `/${fallbackFromLocale}${fallbackToRoute.route}`;
+            } else {
+              pathname = fallbackToRoute.pathname ? replaceOrKeep(fallbackToRoute.pathname, fallbackToLocale, fallbackFromLocale) : void 0;
+              route = replaceOrKeep(fallbackToRoute.route, fallbackToLocale, fallbackFromLocale);
+            }
+            const segments = removeLeadingForwardSlash(route).split(path.posix.sep).filter(Boolean).map((s) => {
+              validateSegment(s);
+              return getParts(s, route);
             });
-            if (!hasRoute) {
-              let pathname;
-              let route;
-              if (fallbackToLocale === i18n.defaultLocale && strategy === "pathname-prefix-other-locales") {
-                if (fallbackToRoute.pathname) {
-                  pathname = `/${fallbackFromLocale}${fallbackToRoute.pathname}`;
-                }
-                route = `/${fallbackFromLocale}${fallbackToRoute.route}`;
-              } else {
-                pathname = fallbackToRoute.pathname ? replaceOrKeep(fallbackToRoute.pathname, fallbackToLocale, fallbackFromLocale) : void 0;
-                route = replaceOrKeep(fallbackToRoute.route, fallbackToLocale, fallbackFromLocale);
-              }
-              const segments = removeLeadingForwardSlash(route).split(path.posix.sep).filter(Boolean).map((s) => {
-                validateSegment(s);
-                return getParts(s, route);
-              });
-              const index = routes.findIndex((r) => r === fallbackToRoute);
-              if (index >= 0) {
-                const fallbackRoute = {
-                  ...fallbackToRoute,
-                  pathname,
-                  route,
-                  segments,
-                  pattern: getPattern(segments, config.base, config.trailingSlash),
-                  type: "fallback",
-                  fallbackRoutes: []
-                };
-                const routeData = routes[index];
-                routeData.fallbackRoutes.push(fallbackRoute);
-              }
+            const index = routes.findIndex((r) => r === fallbackToRoute);
+            if (index >= 0) {
+              const fallbackRoute = {
+                ...fallbackToRoute,
+                pathname,
+                route,
+                segments,
+                pattern: getPattern(segments, config.base, config.trailingSlash),
+                type: "fallback",
+                fallbackRoutes: []
+              };
+              const routeData = routes[index];
+              routeData.fallbackRoutes.push(fallbackRoute);
             }
           }
         }
       }
     }
   }
-  if (dev) {
-    ensure404Route({ routes });
-  }
-  if (dev || settings.buildOutput === "server") {
-    injectImageEndpoint(settings, { routes }, dev ? "dev" : "build");
-  }
-  if (dev || settings.config.adapter) {
-    injectServerIslandRoute(settings.config, { routes });
-  }
-  await runHookRoutesResolved({ routes, settings, logger });
-  return {
-    routes
-  };
 }
 function resolveInjectedRoute(entrypoint, root, cwd) {
   let resolved;
@@ -666,6 +666,7 @@ function replaceOrKeep(original, from, to) {
   return original.replace(`/${from}/`, `/${to}/`).replace(`/${from}`, `/${to}`);
 }
 export {
+  createI18nFallbackRoutes,
   createRoutesFromEntries,
   createRoutesList,
   resolveInjectedRoute

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

@@ -1,4 +1,9 @@
 import type { AstroSettings } from '../../types/astro.js';
 import type { RouteData } from '../../types/public/internal.js';
 import type { Logger } from '../logger/core.js';
+/**
+ * Parses the `export const prerender = true|false` declaration from a route's
+ * source content. Returns `true`, `false`, or `undefined` if not present.
+ */
+export declare function parsePrerenderExport(content: string): boolean | undefined;
 export declare function getRoutePrerenderOption(content: string, route: RouteData, settings: AstroSettings, logger: Logger): Promise<void>;

package/dist/core/routing/prerender.js

@@ -1,6 +1,11 @@
 import { runHookRouteSetup } from "../../integrations/hooks.js";
 import { getPrerenderDefault } from "../../prerender/utils.js";
 const PRERENDER_REGEX = /^\s*export\s+const\s+prerender\s*=\s*(true|false);?/m;
+function parsePrerenderExport(content) {
+  const match = PRERENDER_REGEX.exec(content);
+  if (!match) return void 0;
+  return match[1] === "true";
+}
 async function getRoutePrerenderOption(content, route, settings, logger) {
   const match = PRERENDER_REGEX.exec(content);
   if (match) {
@@ -16,5 +21,6 @@ async function getRoutePrerenderOption(content, route, settings, logger) {
   if (!route.prerender) settings.buildOutput = "server";
 }
 export {
-  getRoutePrerenderOption
+  getRoutePrerenderOption,
+  parsePrerenderExport
 };

package/dist/core/server-islands/vite-plugin-server-islands.js

@@ -12,7 +12,7 @@ function vitePluginServerIslands({
   serverIslandsState
 }) {
   let command = "serve";
-  let ssrEnvironment = null;
+  let serverEnvironments = [];
   function ensureServerIslandReferenceIds(ctx) {
     for (const [resolvedPath, island] of serverIslandsState.getDiscoveredIslandEntries()) {
       if (serverIslandsState.hasReferenceId(resolvedPath)) continue;
@@ -38,7 +38,17 @@ function vitePluginServerIslands({
       ensureServerIslandReferenceIds(this);
     },
     configureServer(server) {
-      ssrEnvironment = server.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
+      serverEnvironments = [];
+      for (const name of [
+        ASTRO_VITE_ENVIRONMENT_NAMES.ssr,
+        ASTRO_VITE_ENVIRONMENT_NAMES.prerender,
+        ASTRO_VITE_ENVIRONMENT_NAMES.astro
+      ]) {
+        const env = server.environments[name];
+        if (env) {
+          serverEnvironments.push(env);
+        }
+      }
     },
     resolveId: {
       filter: {
@@ -92,10 +102,12 @@ export const serverIslandNameMap = ${serverIslandPlaceholderNameMap};`
             }
           }
         }
-        if (serverIslandsState.hasIslands() && ssrEnvironment) {
-          const mod = ssrEnvironment.moduleGraph.getModuleById(RESOLVED_SERVER_ISLAND_MANIFEST);
-          if (mod) {
-            ssrEnvironment.moduleGraph.invalidateModule(mod);
+        if (serverIslandsState.hasIslands()) {
+          for (const env of serverEnvironments) {
+            const mod = env.moduleGraph.getModuleById(RESOLVED_SERVER_ISLAND_MANIFEST);
+            if (mod) {
+              env.moduleGraph.invalidateModule(mod);
+            }
           }
         }
         if (id === RESOLVED_SERVER_ISLAND_MANIFEST) {