astro 4.2.4 → 4.2.5

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

@@ -5,11 +5,11 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { getPrerenderDefault } from "../../../prerender/utils.js";
 import { SUPPORTED_MARKDOWN_FILE_EXTENSIONS } from "../../constants.js";
+import { MissingIndexForInternationalization } from "../../errors/errors-data.js";
+import { AstroError } from "../../errors/index.js";
 import { removeLeadingForwardSlash, slash } from "../../path.js";
 import { resolvePages } from "../../util.js";
 import { getRouteGenerator } from "./generator.js";
-import { AstroError } from "../../errors/index.js";
-import { MissingIndexForInternationalization } from "../../errors/errors-data.js";
 const require2 = createRequire(import.meta.url);
 function countOccurrences(needle, haystack) {
   let count = 0;
@@ -446,7 +446,8 @@ function createRouteManifest(params, logger) {
         );
         throw new AstroError({
           ...MissingIndexForInternationalization,
-          message: MissingIndexForInternationalization.message(relativePath)
+          message: MissingIndexForInternationalization.message(i18n.defaultLocale),
+          hint: MissingIndexForInternationalization.hint(relativePath)
         });
       }
     }

package/dist/events/toolbar.d.ts

@@ -0,0 +1,10 @@
+interface AppToggledEventPayload {
+    app: string;
+}
+export declare function eventAppToggled(options: {
+    appName: 'other' | (string & {});
+}): {
+    eventName: string;
+    payload: AppToggledEventPayload;
+}[];
+export {};

package/dist/events/toolbar.js

@@ -0,0 +1,10 @@
+const EVENT_TOOLBAR_APP_TOGGLED = "ASTRO_TOOLBAR_APP_TOGGLED";
+function eventAppToggled(options) {
+  const payload = {
+    app: options.appName
+  };
+  return [{ eventName: EVENT_TOOLBAR_APP_TOGGLED, payload }];
+}
+export {
+  eventAppToggled
+};

package/dist/i18n/index.d.ts

@@ -35,29 +35,32 @@ export declare function getLocaleRelativeUrl({ locale, base, locales: _locales,
  * The absolute URL
  */
 export declare function getLocaleAbsoluteUrl({ site, ...rest }: GetLocaleAbsoluteUrl): string;
-type GetLocalesBaseUrl = GetLocaleOptions & {
+interface GetLocalesRelativeUrlList extends GetLocaleOptions {
     base: string;
     locales: Locales;
     trailingSlash: AstroConfig['trailingSlash'];
     format: AstroConfig['build']['format'];
     routing?: RoutingStrategies;
     defaultLocale: string;
-};
-export declare function getLocaleRelativeUrlList({ base, locales: _locales, trailingSlash, format, path, prependWith, normalizeLocale, routing, defaultLocale, }: GetLocalesBaseUrl): string[];
-export declare function getLocaleAbsoluteUrlList({ site, ...rest }: GetLocaleAbsoluteUrl): string[];
+}
+export declare function getLocaleRelativeUrlList({ base, locales: _locales, trailingSlash, format, path, prependWith, normalizeLocale, routing, defaultLocale, }: GetLocalesRelativeUrlList): string[];
+interface GetLocalesAbsoluteUrlList extends GetLocalesRelativeUrlList {
+    site?: string;
+}
+export declare function getLocaleAbsoluteUrlList({ site, ...rest }: GetLocalesAbsoluteUrlList): string[];
 /**
  * Given a locale (code), it returns its corresponding path
  * @param locale
  * @param locales
  */
-export declare function getPathByLocale(locale: string, locales: Locales): string | undefined;
+export declare function getPathByLocale(locale: string, locales: Locales): string;
 /**
  * An utility function that retrieves the preferred locale that correspond to a path.
  *
  * @param path
  * @param locales
  */
-export declare function getLocaleByPath(path: string, locales: Locales): string | undefined;
+export declare function getLocaleByPath(path: string, locales: Locales): string;
 /**
  *
  * Given a locale, this function:

package/dist/i18n/index.js

@@ -95,19 +95,22 @@ function getPathByLocale(locale, locales) {
       }
     }
   }
+  throw new Unreachable();
 }
 function getLocaleByPath(path, locales) {
   for (const locale of locales) {
     if (typeof locale !== "string") {
       if (locale.path === path) {
         const code = locale.codes.at(0);
+        if (code === void 0)
+          throw new Unreachable();
         return code;
       }
     } else if (locale === path) {
       return locale;
     }
   }
-  return void 0;
+  throw new Unreachable();
 }
 function normalizeTheLocale(locale) {
   return locale.replaceAll("_", "-").toLowerCase();
@@ -150,6 +153,13 @@ function peekCodePathToUse(locales, locale) {
   }
   return void 0;
 }
+class Unreachable extends Error {
+  constructor() {
+    super(
+      "Astro encountered an unexpected line of code.\nIn most cases, this is not your fault, but a bug in astro code.\nIf there isn't one already, please create an issue.\nhttps://astro.build/issues"
+    );
+  }
+}
 export {
   getLocaleAbsoluteUrl,
   getLocaleAbsoluteUrlList,

package/dist/i18n/middleware.d.ts

@@ -1,6 +1,6 @@
 import type { MiddlewareHandler, SSRManifest } from '../@types/astro.js';
 import type { PipelineHookFunction } from '../core/pipeline.js';
-export declare function createI18nMiddleware(i18n: SSRManifest['i18n'], base: SSRManifest['base'], trailingSlash: SSRManifest['trailingSlash'], buildFormat: SSRManifest['buildFormat']): MiddlewareHandler | undefined;
+export declare function createI18nMiddleware(i18n: SSRManifest['i18n'], base: SSRManifest['base'], trailingSlash: SSRManifest['trailingSlash'], buildFormat: SSRManifest['buildFormat']): MiddlewareHandler;
 /**
  * This pipeline hook attaches a `RouteData` object to the `Request`
  */

package/dist/i18n/middleware.js

@@ -18,18 +18,12 @@ function pathnameHasLocale(pathname, locales) {
   return false;
 }
 function createI18nMiddleware(i18n, base, trailingSlash, buildFormat) {
-  if (!i18n) {
-    return void 0;
-  }
+  if (!i18n)
+    return (_, next) => next();
   return async (context, next) => {
-    if (!i18n) {
-      return await next();
-    }
     const routeData = Reflect.get(context.request, routeDataSymbol);
-    if (routeData) {
-      if (routeData.type !== "page" && routeData.type !== "fallback") {
-        return await next();
-      }
+    if (routeData?.type !== "page" && routeData?.type !== "fallback") {
+      return await next();
     }
     const url = context.url;
     const { locales, defaultLocale, fallback, routing } = i18n;

package/dist/i18n/vite-plugin-i18n.d.ts

@@ -1,7 +1,9 @@
 import type * as vite from 'vite';
-import type { AstroSettings } from '../@types/astro.js';
+import type { AstroConfig, AstroSettings } from '../@types/astro.js';
 type AstroInternationalization = {
     settings: AstroSettings;
 };
+export interface I18nInternalConfig extends Pick<AstroConfig, 'base' | 'site' | 'trailingSlash'>, NonNullable<AstroConfig['i18n']>, Pick<AstroConfig['build'], 'format'> {
+}
 export default function astroInternationalization({ settings, }: AstroInternationalization): vite.Plugin;
 export {};

package/dist/i18n/vite-plugin-i18n.js

@@ -1,61 +1,44 @@
+import { AstroError } from "../core/errors/errors.js";
+import { AstroErrorData } from "../core/errors/index.js";
 const virtualModuleId = "astro:i18n";
-const resolvedVirtualModuleId = "\0" + virtualModuleId;
+const configId = "astro-internal:i18n-config";
+const resolvedConfigId = `\0${configId}`;
 function astroInternationalization({
   settings
 }) {
+  const {
+    base,
+    build: { format },
+    i18n,
+    site,
+    trailingSlash
+  } = settings.config;
   return {
     name: "astro:i18n",
     enforce: "pre",
     async resolveId(id) {
       if (id === virtualModuleId) {
-        return resolvedVirtualModuleId;
+        if (i18n === void 0)
+          throw new AstroError(AstroErrorData.i18nNotEnabled);
+        return this.resolve("astro/virtual-modules/i18n.js");
       }
+      if (id === configId)
+        return resolvedConfigId;
     },
     load(id) {
-      if (id === resolvedVirtualModuleId) {
-        return `
-					import { 
-						getLocaleRelativeUrl as _getLocaleRelativeUrl, 
-						getLocaleRelativeUrlList as _getLocaleRelativeUrlList,
-						getLocaleAbsoluteUrl as _getLocaleAbsoluteUrl, 
-						getLocaleAbsoluteUrlList as _getLocaleAbsoluteUrlList,
-						getPathByLocale as _getPathByLocale, 
-						getLocaleByPath as _getLocaleByPath,
-					} from "astro/virtual-modules/i18n.js";
-					
-					const base =  ${JSON.stringify(settings.config.base)};
-					const trailingSlash =  ${JSON.stringify(settings.config.trailingSlash)};
-					const format =  ${JSON.stringify(settings.config.build.format)};
-					const site = ${JSON.stringify(settings.config.site)};
-					const i18n = ${JSON.stringify(settings.config.i18n)};
-					
-					export const getRelativeLocaleUrl = (locale, path = "", opts) => _getLocaleRelativeUrl({ 
-						locale,
-						path, 
-						base, 
-						trailingSlash, 
-						format,
-						...i18n,
-						...opts 
-					});
-					export const getAbsoluteLocaleUrl = (locale, path = "", opts) => _getLocaleAbsoluteUrl({ 
-						locale, 
-						path, 
-						base, 
-						trailingSlash, 
-						format, 
-						site, 
-						...i18n,
-						...opts 
-					});
-					
-					export const getRelativeLocaleUrlList = (path = "", opts) => _getLocaleRelativeUrlList({ 
-						base, path, trailingSlash, format, ...i18n, ...opts });
-					export const getAbsoluteLocaleUrlList = (path = "", opts) => _getLocaleAbsoluteUrlList({ base, path, trailingSlash, format, site, ...i18n, ...opts });
-					
-					export const getPathByLocale = (locale) => _getPathByLocale(locale, i18n.locales);
-					export const getLocaleByPath = (path) => _getLocaleByPath(path, i18n.locales);
-				`;
+      if (id === resolvedConfigId) {
+        const { defaultLocale, locales, routing, fallback } = i18n;
+        const config = {
+          base,
+          format,
+          site,
+          trailingSlash,
+          defaultLocale,
+          locales,
+          routing,
+          fallback
+        };
+        return `export default ${JSON.stringify(config)};`;
       }
     }
   };

package/dist/runtime/client/dev-toolbar/toolbar.js

@@ -371,6 +371,11 @@ class AstroDevToolbar extends HTMLElement {
       return;
     if (app !== activeApp) {
       await this.setAppStatus(app, true);
+      if (import.meta.hot && app.id !== "astro:more") {
+        import.meta.hot.send("astro:devtoolbar:app:toggled", {
+          app
+        });
+      }
     }
   }
   async setAppStatus(app, newStatus) {

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

@@ -0,0 +1 @@
+export declare const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";

package/dist/runtime/server/consts.js

@@ -0,0 +1,4 @@
+const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";
+export {
+  REROUTE_DIRECTIVE_HEADER
+};

package/dist/runtime/server/endpoint.js

@@ -1,4 +1,5 @@
 import { bold } from "kleur/colors";
+import { REROUTE_DIRECTIVE_HEADER } from "./consts.js";
 async function renderEndpoint(mod, context, ssr, logger) {
   const { request, url } = context;
   const method = request.method.toUpperCase();
@@ -22,7 +23,7 @@ Found handlers: ${Object.keys(mod).map((exp) => JSON.stringify(exp)).join(", ")}
     return new Response(null, { status: 404 });
   }
   const response = await handler.call(mod, context);
-  response.headers.set("X-Astro-Reroute", "no");
+  response.headers.set(REROUTE_DIRECTIVE_HEADER, "no");
   return response;
 }
 export {

package/dist/runtime/server/transition.js

@@ -1,5 +1,6 @@
 import { fade, slide } from "../../transitions/index.js";
 import { markHTMLString } from "./escape.js";
+import cssesc from "cssesc";
 const transitionNameMap = /* @__PURE__ */ new WeakMap();
 function incrementTransitionNumber(result) {
   let num = 1;
@@ -13,9 +14,6 @@ function createTransitionScope(result, hash) {
   const num = incrementTransitionNumber(result);
   return `astro-${hash}-${num}`;
 }
-function toValidIdent(name) {
-  return name.replace(/[^a-zA-Z0-9\-\_]/g, "_").replace(/^\_+|\_+$/g, "");
-}
 const getAnimations = (name) => {
   if (name === "fade")
     return fade();
@@ -35,7 +33,7 @@ function renderTransition(result, hash, animationName, transitionName) {
   if (!animationName)
     animationName = "fade";
   const scope = createTransitionScope(result, hash);
-  const name = transitionName ? toValidIdent(transitionName) : scope;
+  const name = transitionName ? cssesc(transitionName, { isIdentifier: true }) : scope;
   const sheet = new ViewTransitionStyleSheet(scope, name);
   const animations = getAnimations(animationName);
   if (animations) {

package/dist/virtual-modules/i18n.d.ts

@@ -1 +1,126 @@
-export * from '../i18n/index.js';
+import * as I18nInternals from '../i18n/index.js';
+export { normalizeTheLocale, toCodes, toPaths } from '../i18n/index.js';
+export type GetLocaleOptions = I18nInternals.GetLocaleOptions;
+/**
+ * @param locale A locale
+ * @param path An optional path to add after the `locale`.
+ * @param options Customise the generated path
+ *
+ * Returns a _relative_ path with passed locale.
+ *
+ * ## Errors
+ *
+ * Throws an error if the locale doesn't exist in the list of locales defined in the configuration.
+ *
+ * ## Examples
+ *
+ * ```js
+ * import { getRelativeLocaleUrl } from "astro:i18n";
+ * getRelativeLocaleUrl("es"); // /es
+ * getRelativeLocaleUrl("es", "getting-started"); // /es/getting-started
+ * getRelativeLocaleUrl("es_US", "getting-started", { prependWith: "blog" }); // /blog/es-us/getting-started
+ * getRelativeLocaleUrl("es_US", "getting-started", { prependWith: "blog", normalizeLocale: false }); // /blog/es_US/getting-started
+ * ```
+ */
+export declare const getRelativeLocaleUrl: (locale: string, path?: string, options?: GetLocaleOptions) => string;
+/**
+ *
+ * @param locale A locale
+ * @param path An optional path to add after the `locale`.
+ * @param options Customise the generated path
+ *
+ * Returns an absolute path with the passed locale. The behaviour is subject to change based on `site` configuration.
+ * If _not_ provided, the function will return a _relative_ URL.
+ *
+ * ## Errors
+ *
+ * Throws an error if the locale doesn't exist in the list of locales defined in the configuration.
+ *
+ * ## Examples
+ *
+ * If `site` is `https://example.com`:
+ *
+ * ```js
+ * import { getAbsoluteLocaleUrl } from "astro:i18n";
+ * getAbsoluteLocaleUrl("es"); // https://example.com/es
+ * getAbsoluteLocaleUrl("es", "getting-started"); // https://example.com/es/getting-started
+ * getAbsoluteLocaleUrl("es_US", "getting-started", { prependWith: "blog" }); // https://example.com/blog/es-us/getting-started
+ * getAbsoluteLocaleUrl("es_US", "getting-started", { prependWith: "blog", normalizeLocale: false }); // https://example.com/blog/es_US/getting-started
+ * ```
+ */
+export declare const getAbsoluteLocaleUrl: (locale: string, path?: string, options?: GetLocaleOptions) => string;
+/**
+ * @param path An optional path to add after the `locale`.
+ * @param options Customise the generated path
+ *
+ * Works like `getRelativeLocaleUrl` but it emits the relative URLs for ALL locales:
+ */
+export declare const getRelativeLocaleUrlList: (path?: string, options?: GetLocaleOptions) => string[];
+/**
+ * @param path An optional path to add after the `locale`.
+ * @param options Customise the generated path
+ *
+ * Works like `getAbsoluteLocaleUrl` but it emits the absolute URLs for ALL locales:
+ */
+export declare const getAbsoluteLocaleUrlList: (path?: string, options?: GetLocaleOptions) => string[];
+/**
+ * A function that return the `path` associated to a locale (defined as code). It's particularly useful in case you decide
+ * to use locales that are broken down in paths and codes.
+ *
+ * @param locale The code of the locale
+ * @returns The path associated to the locale
+ *
+ * ## Example
+ *
+ * ```js
+ * // astro.config.mjs
+ *
+ * export default defineConfig({
+ * 	i18n: {
+ * 		locales: [
+ * 			{ codes: ["it", "it-VT"], path: "italiano" },
+ * 			"es"
+ * 		]
+ * 	}
+ * })
+ * ```
+ *
+ * ```js
+ * import { getPathByLocale } from "astro:i18n";
+ * getPathByLocale("it"); // returns "italiano"
+ * getPathByLocale("it-VT"); // returns "italiano"
+ * getPathByLocale("es"); // returns "es"
+ * ```
+ */
+export declare const getPathByLocale: (locale: string) => string;
+/**
+ * A function that returns the preferred locale given a certain path. This is particularly useful if you configure a locale using
+ * `path` and `codes`. When you define multiple `code`, this function will return the first code of the array.
+ *
+ * Astro will treat the first code as the one that the user prefers.
+ *
+ * @param path The path that maps to a locale
+ * @returns The path associated to the locale
+ *
+ * ## Example
+ *
+ * ```js
+ * // astro.config.mjs
+ *
+ * export default defineConfig({
+ * 	i18n: {
+ * 		locales: [
+ * 			{ codes: ["it-VT", "it"], path: "italiano" },
+ * 			"es"
+ * 		]
+ * 	}
+ * })
+ * ```
+ *
+ * ```js
+ * import { getLocaleByPath } from "astro:i18n";
+ * getLocaleByPath("italiano"); // returns "it-VT" because that's the first code configured
+ * getLocaleByPath("es"); // returns "es"
+ * ```
+ */
+export declare const getLocaleByPath: (path: string) => string;

package/dist/virtual-modules/i18n.js

@@ -1 +1,62 @@
-export * from "../i18n/index.js";
+import * as I18nInternals from "../i18n/index.js";
+import { normalizeTheLocale, toCodes, toPaths } from "../i18n/index.js";
+import config from "astro-internal:i18n-config";
+const { trailingSlash, format, site, defaultLocale, locales, routing } = config;
+const base = import.meta.env.BASE_URL;
+const getRelativeLocaleUrl = (locale, path, options) => I18nInternals.getLocaleRelativeUrl({
+  locale,
+  path,
+  base,
+  trailingSlash,
+  format,
+  defaultLocale,
+  locales,
+  routing,
+  ...options
+});
+const getAbsoluteLocaleUrl = (locale, path = "", options) => I18nInternals.getLocaleAbsoluteUrl({
+  locale,
+  path,
+  base,
+  trailingSlash,
+  format,
+  site,
+  defaultLocale,
+  locales,
+  routing,
+  ...options
+});
+const getRelativeLocaleUrlList = (path, options) => I18nInternals.getLocaleRelativeUrlList({
+  base,
+  path,
+  trailingSlash,
+  format,
+  defaultLocale,
+  locales,
+  routing,
+  ...options
+});
+const getAbsoluteLocaleUrlList = (path, options) => I18nInternals.getLocaleAbsoluteUrlList({
+  site,
+  base,
+  path,
+  trailingSlash,
+  format,
+  defaultLocale,
+  locales,
+  routing,
+  ...options
+});
+const getPathByLocale = (locale) => I18nInternals.getPathByLocale(locale, locales);
+const getLocaleByPath = (path) => I18nInternals.getLocaleByPath(path, locales);
+export {
+  getAbsoluteLocaleUrl,
+  getAbsoluteLocaleUrlList,
+  getLocaleByPath,
+  getPathByLocale,
+  getRelativeLocaleUrl,
+  getRelativeLocaleUrlList,
+  normalizeTheLocale,
+  toCodes,
+  toPaths
+};

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

@@ -108,7 +108,10 @@ function createDevelopmentManifest(settings) {
     assetsPrefix: settings.config.build.assetsPrefix,
     site: settings.config.site ? new URL(settings.config.base, settings.config.site).toString() : settings.config.site,
     componentMetadata: /* @__PURE__ */ new Map(),
-    i18n: i18nManifest
+    i18n: i18nManifest,
+    middleware(_, next) {
+      return next();
+    }
   };
 }
 export {

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

@@ -22,6 +22,7 @@ import { preload } from "./index.js";
 import { getComponentMetadata } from "./metadata.js";
 import { handle404Response, writeSSRResult, writeWebResponse } from "./response.js";
 import { getScriptsForURL } from "./scripts.js";
+import { REROUTE_DIRECTIVE_HEADER } from "../runtime/server/consts.js";
 const clientLocalsSymbol = Symbol.for("astro.locals");
 function isLoggedRequest(url) {
   return url !== "/favicon.ico";
@@ -203,11 +204,9 @@ async function handleRoute({
       preload: preloadedComponent,
       pathname,
       request,
-      route
+      route,
+      middleware
     };
-    if (middleware) {
-      options.middleware = middleware;
-    }
     mod = options.preload;
     const { scripts, links, styles, metadata } = await getScriptsAndStyles({
       pipeline,
@@ -229,7 +228,7 @@ async function handleRoute({
       defaultLocale: i18n?.defaultLocale
     });
   }
-  const onRequest = middleware?.onRequest;
+  const onRequest = middleware.onRequest;
   if (config.i18n) {
     const i18Middleware = createI18nMiddleware(
       config.i18n,
@@ -238,16 +237,12 @@ async function handleRoute({
       config.build.format
     );
     if (i18Middleware) {
-      if (onRequest) {
-        pipeline.setMiddlewareFunction(sequence(i18Middleware, onRequest));
-      } else {
-        pipeline.setMiddlewareFunction(i18Middleware);
-      }
+      pipeline.setMiddlewareFunction(sequence(i18Middleware, onRequest));
       pipeline.onBeforeRenderRoute(i18nPipelineHook);
-    } else if (onRequest) {
+    } else {
       pipeline.setMiddlewareFunction(onRequest);
     }
-  } else if (onRequest) {
+  } else {
     pipeline.setMiddlewareFunction(onRequest);
   }
   let response = await pipeline.renderRoute(renderContext, mod);
@@ -263,7 +258,7 @@ async function handleRoute({
       })
     );
   }
-  if (response.status === 404 && has404Route(manifestData)) {
+  if (response.status === 404 && has404Route(manifestData) && response.headers.get(REROUTE_DIRECTIVE_HEADER) !== "no") {
     const fourOhFourRoute = await matchRoute("/404", manifestData, pipeline);
     if (options && fourOhFourRoute?.route !== options.route)
       return handleRoute({

package/dist/vite-plugin-dev-toolbar/vite-plugin-dev-toolbar.js

@@ -1,6 +1,9 @@
+import { telemetry } from "../events/index.js";
+import { eventAppToggled } from "../events/toolbar.js";
 const VIRTUAL_MODULE_ID = "astro:dev-toolbar";
 const resolvedVirtualModuleId = "\0" + VIRTUAL_MODULE_ID;
 function astroDevToolbar({ settings, logger }) {
+  let telemetryTimeout;
   return {
     name: "astro:dev-toolbar",
     config() {
@@ -30,6 +33,20 @@ function astroDevToolbar({ settings, logger }) {
 ${args.error}`
         );
       });
+      server.ws.on("astro:devtoolbar:app:toggled", (args) => {
+        clearTimeout(telemetryTimeout);
+        telemetryTimeout = setTimeout(() => {
+          let nameToRecord = args?.app?.id;
+          if (!nameToRecord || !nameToRecord.startsWith("astro:")) {
+            nameToRecord = "other";
+          }
+          telemetry.record(
+            eventAppToggled({
+              appName: nameToRecord
+            })
+          );
+        }, 200);
+      });
     },
     async load(id) {
       if (id === resolvedVirtualModuleId) {

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

@@ -4,6 +4,7 @@ import { transform } from "esbuild";
 import MagicString from "magic-string";
 const importMetaEnvOnlyRe = /\bimport\.meta\.env\b(?!\.)/;
 const isValidIdentifierRe = /^[_$a-zA-Z][_$a-zA-Z0-9]*$/;
+const exportConstPrerenderRe = /\bexport\s+const\s+prerender\s*=\s*import\.meta\.env\.(.+?)\b/;
 function getPrivateEnv(viteConfig, astroConfig) {
   let envPrefixes = ["PUBLIC_"];
   if (viteConfig.envPrefix) {
@@ -114,6 +115,13 @@ function envVitePlugin({ settings }) {
           devImportMetaEnvPrepend += "});";
         }
         s.prepend(devImportMetaEnvPrepend);
+        s.replace(exportConstPrerenderRe, (m, key) => {
+          if (privateEnv[key] != null) {
+            return `export const prerender = ${privateEnv[key]}`;
+          } else {
+            return m;
+          }
+        });
         return {
           code: s.toString(),
           map: s.generateMap({ hires: "boundary" })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "4.2.4",
+  "version": "4.2.5",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -118,6 +118,7 @@
     "clsx": "^2.0.0",
     "common-ancestor-path": "^1.0.1",
     "cookie": "^0.6.0",
+    "cssesc": "^3.0.0",
     "debug": "^4.3.4",
     "deterministic-object-hash": "^2.0.1",
     "devalue": "^4.3.2",
@@ -178,6 +179,7 @@
     "@types/common-ancestor-path": "^1.0.2",
     "@types/connect": "^3.4.38",
     "@types/cookie": "^0.5.4",
+    "@types/cssesc": "^3.0.2",
     "@types/debug": "^4.1.12",
     "@types/diff": "^5.0.8",
     "@types/dlv": "^1.1.4",