astro 6.0.2 → 6.0.4

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.0.2";
+  version = "6.0.4";
 }
 export {
   BuildTimeAstroVersionProvider

package/dist/content/content-layer.js

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

package/dist/core/build/generate.js

@@ -139,6 +139,16 @@ ${colors.bgGreen(colors.black(` ${verb} static routes `))}`);
       );
     }
   }
+  for (const { route: generatedRoute } of filteredPaths) {
+    if (generatedRoute.distURL && generatedRoute.distURL.length > 0) {
+      for (const pageData of Object.values(options.allPages)) {
+        if (pageData.route.route === generatedRoute.route && pageData.route.component === generatedRoute.component) {
+          pageData.route.distURL = generatedRoute.distURL;
+          break;
+        }
+      }
+    }
+  }
   const staticImageList = getStaticImageList();
   if (prerenderer.collectStaticImages) {
     const adapterImages = await prerenderer.collectStaticImages();

package/dist/core/build/index.d.ts

@@ -1,4 +1,6 @@
-import type { AstroInlineConfig } from '../../types/public/config.js';
+import type { AstroSettings, RoutesList } from '../../types/astro.js';
+import type { AstroInlineConfig, RuntimeMode } from '../../types/public/config.js';
+import type { Logger } from '../logger/core.js';
 interface BuildOptions {
     /**
      * Output a development-based build similar to code transformed in `astro dev`. This
@@ -25,4 +27,40 @@ interface BuildOptions {
  * @experimental The JavaScript API is experimental
  */
 export default function build(inlineConfig: AstroInlineConfig, options?: BuildOptions): Promise<void>;
+interface AstroBuilderOptions extends BuildOptions {
+    logger: Logger;
+    mode: string;
+    runtimeMode: RuntimeMode;
+    /**
+     * Provide a pre-built routes list to skip filesystem route scanning.
+     * Useful for testing builds with in-memory virtual modules.
+     */
+    routesList?: RoutesList;
+    /**
+     * Whether to run `syncInternal` during setup. Defaults to true.
+     * Set to false for in-memory builds that don't need type generation.
+     */
+    sync?: boolean;
+}
+export declare class AstroBuilder {
+    private settings;
+    private logger;
+    private mode;
+    private runtimeMode;
+    private origin;
+    private routesList;
+    private timer;
+    private teardownCompiler;
+    private sync;
+    constructor(settings: AstroSettings, options: AstroBuilderOptions);
+    /** Setup Vite and run any async setup logic that couldn't run inside of the constructor. */
+    private setup;
+    /** Run the build logic. build() is marked private because usage should go through ".run()" */
+    private build;
+    /** Build the given Astro project.  */
+    run(): Promise<void>;
+    private validateConfig;
+    /** Stats */
+    private printStats;
+}
 export {};

package/dist/core/build/index.js

@@ -56,14 +56,16 @@ class AstroBuilder {
   routesList;
   timer;
   teardownCompiler;
+  sync;
   constructor(settings, options) {
     this.mode = options.mode;
     this.runtimeMode = options.runtimeMode;
     this.settings = settings;
     this.logger = options.logger;
     this.teardownCompiler = options.teardownCompiler ?? true;
+    this.sync = options.sync ?? true;
     this.origin = settings.config.site ? new URL(settings.config.site).origin : `http://localhost:${settings.config.server.port}`;
-    this.routesList = { routes: [] };
+    this.routesList = options.routesList ?? { routes: [] };
     this.timer = {};
   }
   /** Setup Vite and run any async setup logic that couldn't run inside of the constructor. */
@@ -77,7 +79,9 @@ class AstroBuilder {
       logger
     });
     this.settings.buildOutput = getPrerenderDefault(this.settings.config) ? "static" : "server";
-    this.routesList = await createRoutesList({ settings: this.settings }, this.logger);
+    if (this.routesList.routes.length === 0) {
+      this.routesList = await createRoutesList({ settings: this.settings }, this.logger);
+    }
     await runHookConfigDone({ settings: this.settings, logger, command: "build" });
     if (!this.settings.config.adapter && this.settings.buildOutput === "server") {
       throw new AstroError(AstroErrorData.NoAdapterInstalled);
@@ -98,14 +102,16 @@ class AstroBuilder {
         sync: false
       }
     );
-    const { syncInternal } = await import("../sync/index.js");
-    await syncInternal({
-      mode: this.mode,
-      settings: this.settings,
-      logger,
-      fs,
-      command: "build"
-    });
+    if (this.sync) {
+      const { syncInternal } = await import("../sync/index.js");
+      await syncInternal({
+        mode: this.mode,
+        settings: this.settings,
+        logger,
+        fs,
+        command: "build"
+      });
+    }
     return { viteConfig };
   }
   /** Run the build logic. build() is marked private because usage should go through ".run()" */
@@ -215,5 +221,6 @@ class AstroBuilder {
   }
 }
 export {
+  AstroBuilder,
   build as default
 };

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

@@ -10,7 +10,11 @@ import { emptyDir, removeEmptyDirs } from "../../core/fs/index.js";
 import { appendForwardSlash, prependForwardSlash } from "../../core/path.js";
 import { runHookBuildSetup } from "../../integrations/hooks.js";
 import { SERIALIZED_MANIFEST_RESOLVED_ID } from "../../manifest/serialized.js";
-import { getClientOutputDirectory, getServerOutputDirectory } from "../../prerender/utils.js";
+import {
+  getClientOutputDirectory,
+  getPrerenderOutputDirectory,
+  getServerOutputDirectory
+} from "../../prerender/utils.js";
 import { VIRTUAL_PAGE_RESOLVED_MODULE_ID } from "../../vite-plugin-pages/const.js";
 import { PAGE_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
 import { routeIsRedirect } from "../routing/helpers.js";
@@ -30,6 +34,7 @@ import { encodeName, getTimeStat, viteBuildReturnToRollupOutputs } from "./util.
 import { NOOP_MODULE_ID } from "./plugins/plugin-noop.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../constants.js";
 import { getSSRAssets } from "./internal.js";
+import { serverIslandPlaceholderMap } from "../server-islands/vite-plugin-server-islands.js";
 const PRERENDER_ENTRY_FILENAME_PREFIX = "prerender-entry";
 function extractRelevantChunks(outputs, prerender) {
   const extracted = [];
@@ -38,7 +43,8 @@ function extractRelevantChunks(outputs, prerender) {
       if (chunk.type === "asset") continue;
       const needsContentInjection = chunk.code.includes(LINKS_PLACEHOLDER);
       const needsManifestInjection = chunk.moduleIds.includes(SERIALIZED_MANIFEST_RESOLVED_ID);
-      if (needsContentInjection || needsManifestInjection) {
+      const needsServerIslandInjection = chunk.code.includes(serverIslandPlaceholderMap);
+      if (needsContentInjection || needsManifestInjection || needsServerIslandInjection) {
         extracted.push({
           fileName: chunk.fileName,
           code: chunk.code,
@@ -82,6 +88,7 @@ async function buildEnvironments(opts, internals) {
   const flatPlugins = buildPlugins.flat().filter(Boolean);
   const plugins = [...flatPlugins, ...viteConfig.plugins || []];
   let currentRollupInput = void 0;
+  let buildPostHooks = [];
   plugins.push({
     name: "astro:resolve-input",
     // When the rollup input is safe to update, we normalize it to always be an object
@@ -107,8 +114,13 @@ async function buildEnvironments(opts, internals) {
     buildApp: {
       order: "post",
       async handler() {
-        await runManifestInjection(opts, internals, internals.extractedChunks ?? []);
-        const prerenderOutputDir = new URL("./.prerender/", getServerOutputDirectory(settings));
+        await runManifestInjection(
+          opts,
+          internals,
+          internals.extractedChunks ?? [],
+          buildPostHooks
+        );
+        const prerenderOutputDir = getPrerenderOutputDirectory(settings);
         if (settings.buildOutput === "static") {
           settings.timer.start("Static generate");
           await ssrMoveAssets(opts, internals, prerenderOutputDir);
@@ -224,6 +236,10 @@ async function buildEnvironments(opts, internals) {
         const prerenderOutputs = viteBuildReturnToRollupOutputs(prerenderOutput);
         const prerenderChunks = extractRelevantChunks(prerenderOutputs, true);
         prerenderOutput = void 0;
+        const ssrPlugins = builder2.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr]?.config.plugins ?? [];
+        buildPostHooks = ssrPlugins.map(
+          (plugin) => typeof plugin.api?.buildPostHook === "function" ? plugin.api.buildPostHook : void 0
+        ).filter(Boolean);
         internals.clientInput = getClientInput(internals, settings);
         if (!internals.clientInput.size) {
           internals.clientInput.add(NOOP_MODULE_ID);
@@ -244,7 +260,7 @@ async function buildEnvironments(opts, internals) {
       [ASTRO_VITE_ENVIRONMENT_NAMES.prerender]: {
         build: {
           emitAssets: true,
-          outDir: fileURLToPath(new URL("./.prerender/", getServerOutputDirectory(settings))),
+          outDir: fileURLToPath(getPrerenderOutputDirectory(settings)),
           rollupOptions: {
             // Only skip the default prerender entrypoint if an adapter with `entrypointResolution: 'self'` is used
             // AND provides a custom prerenderer. Otherwise, use the default.
@@ -318,7 +334,7 @@ function getPrerenderEntryFileName(prerenderOutput) {
 function extractPrerenderEntryFileName(internals, prerenderOutput) {
   internals.prerenderEntryFileName = getPrerenderEntryFileName(prerenderOutput);
 }
-async function runManifestInjection(opts, internals, chunks) {
+async function runManifestInjection(opts, internals, chunks, buildPostHooks) {
   const mutations = /* @__PURE__ */ new Map();
   const mutate = (fileName, newCode, prerender) => {
     mutations.set(fileName, { code: newCode, prerender });
@@ -330,16 +346,18 @@ async function runManifestInjection(opts, internals, chunks) {
     internals,
     { chunks, mutate }
   );
+  for (const buildPostHook of buildPostHooks) {
+    await buildPostHook({ chunks, mutate });
+  }
   await writeMutatedChunks(opts, mutations);
 }
 async function writeMutatedChunks(opts, mutations) {
   const { settings } = opts;
   const config = settings.config;
-  const serverOutputDir = getServerOutputDirectory(settings);
   for (const [fileName, mutation] of mutations) {
     let root;
     if (mutation.prerender) {
-      root = new URL("./.prerender/", serverOutputDir);
+      root = getPrerenderOutputDirectory(settings);
     } else if (settings.buildOutput === "server") {
       root = config.build.server;
     } else {

package/dist/core/constants.d.ts

@@ -66,6 +66,10 @@ export declare const originPathnameSymbol: unique symbol;
  * Use this symbol to set and retrieve the pipeline.
  */
 export declare const pipelineSymbol: unique symbol;
+/**
+ * Use this symbol to opt into handling prerender routes in Astro core dev middleware.
+ */
+export declare const devPrerenderMiddlewareSymbol: unique symbol;
 /**
  * The symbol used as a field on the request object to store a cleanup callback associated with aborting the request when the underlying socket closes.
  */

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "6.0.2";
+const ASTRO_VERSION = "6.0.4";
 const ASTRO_GENERATOR = `Astro v${ASTRO_VERSION}`;
 const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";
 const REWRITE_DIRECTIVE_HEADER_KEY = "X-Astro-Rewrite";
@@ -12,6 +12,7 @@ const clientAddressSymbol = /* @__PURE__ */ Symbol.for("astro.clientAddress");
 const clientLocalsSymbol = /* @__PURE__ */ Symbol.for("astro.locals");
 const originPathnameSymbol = /* @__PURE__ */ Symbol.for("astro.originPathname");
 const pipelineSymbol = /* @__PURE__ */ Symbol.for("astro.pipeline");
+const devPrerenderMiddlewareSymbol = /* @__PURE__ */ Symbol.for("astro.devPrerenderMiddleware");
 const nodeRequestAbortControllerCleanupSymbol = /* @__PURE__ */ Symbol.for(
   "astro.nodeRequestAbortControllerCleanup"
 );
@@ -57,6 +58,7 @@ export {
   SUPPORTED_MARKDOWN_FILE_EXTENSIONS,
   clientAddressSymbol,
   clientLocalsSymbol,
+  devPrerenderMiddlewareSymbol,
   nodeRequestAbortControllerCleanupSymbol,
   originPathnameSymbol,
   pipelineSymbol,

package/dist/core/dev/dev.js

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

package/dist/core/errors/dev/utils.js

@@ -90,7 +90,7 @@ function collectErrorMetadata(e, rootFolder) {
 function generateHint(err) {
   const commonBrowserAPIs = ["document", "window"];
   if (/Unknown file extension "\.(?:jsx|vue|svelte|astro|css)" for /.test(err.message)) {
-    return "You likely need to add this package to `vite.ssr.noExternal` in your astro config file.";
+    return "You likely need to add this package to `vite.resolve.noExternal` in your astro config file.";
   } else if (commonBrowserAPIs.some((api) => err.toString().includes(api))) {
     const hint = `Browser APIs are not available on the server.
 

package/dist/core/messages/runtime.js

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

package/dist/core/server-islands/endpoint.js

@@ -59,10 +59,10 @@ async function getRequestData(request, bodySizeLimit = DEFAULT_BODY_SIZE_LIMIT)
         const body = await readBodyWithLimit(request, bodySizeLimit);
         const raw = new TextDecoder().decode(body);
         const data = JSON.parse(raw);
-        if ("slots" in data && typeof data.slots === "object") {
+        if (Object.hasOwn(data, "slots") && typeof data.slots === "object") {
           return badRequest("Plaintext slots are not allowed. Slots must be encrypted.");
         }
-        if ("componentExport" in data && typeof data.componentExport === "string") {
+        if (Object.hasOwn(data, "componentExport") && typeof data.componentExport === "string") {
           return badRequest(
             "Plaintext componentExport is not allowed. componentExport must be encrypted."
           );

package/dist/core/server-islands/vite-plugin-server-islands.d.ts

@@ -1,4 +1,5 @@
 import type { Plugin as VitePlugin } from 'vite';
 import type { AstroPluginOptions } from '../../types/astro.js';
 export declare const SERVER_ISLAND_MANIFEST = "virtual:astro:server-island-manifest";
+export declare const serverIslandPlaceholderMap = "'$$server-islands-map$$'";
 export declare function vitePluginServerIslands({ settings }: AstroPluginOptions): VitePlugin;

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

@@ -1,16 +1,32 @@
-import MagicString from "magic-string";
+import fs from "node:fs";
+import { getPrerenderOutputDirectory, getServerOutputDirectory } from "../../prerender/utils.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
+import { appendForwardSlash } from "../path.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../constants.js";
 const SERVER_ISLAND_MANIFEST = "virtual:astro:server-island-manifest";
 const RESOLVED_SERVER_ISLAND_MANIFEST = "\0" + SERVER_ISLAND_MANIFEST;
 const serverIslandPlaceholderMap = "'$$server-islands-map$$'";
 const serverIslandPlaceholderNameMap = "'$$server-islands-name-map$$'";
+function createServerIslandImportMapSource(entries, toImportPath) {
+  const mappings = Array.from(entries, ([islandName, fileName]) => {
+    const importPath = toImportPath(fileName);
+    return `	[${JSON.stringify(islandName)}, () => import(${JSON.stringify(importPath)})],`;
+  });
+  return `new Map([
+${mappings.join("\n")}
+])`;
+}
+function createNameMapSource(entries) {
+  return `new Map(${JSON.stringify(Array.from(entries), null, 2)})`;
+}
 function vitePluginServerIslands({ settings }) {
   let command = "serve";
   let ssrEnvironment = null;
   const referenceIdMap = /* @__PURE__ */ new Map();
   const serverIslandMap = /* @__PURE__ */ new Map();
   const serverIslandNameMap = /* @__PURE__ */ new Map();
+  const resolvedIslandImports = /* @__PURE__ */ new Map();
+  let ssrManifestChunk = null;
   return {
     name: "astro:server-islands",
     enforce: "post",
@@ -70,7 +86,7 @@ export const serverIslandNameMap = ${serverIslandPlaceholderNameMap};`
               serverIslandNameMap.set(comp.resolvedPath, name);
               serverIslandMap.set(name, comp.resolvedPath);
               if (command === "build") {
-                let referenceId = this.emitFile({
+                const referenceId = this.emitFile({
                   type: "chunk",
                   id: comp.specifier,
                   importer: id,
@@ -95,18 +111,17 @@ export const serverIslandNameMap = ${serverIslandPlaceholderNameMap};`
             }
           }
           if (serverIslandNameMap.size > 0 && serverIslandMap.size > 0) {
-            let mapSource = "new Map([\n	";
-            for (let [name, path] of serverIslandMap) {
-              mapSource += `
-	['${name}', () => import('${path}')],`;
-            }
-            mapSource += "]);";
+            const mapSource = createServerIslandImportMapSource(
+              serverIslandMap,
+              (fileName) => fileName
+            );
+            const nameMapSource = createNameMapSource(serverIslandNameMap);
             return {
               code: `
 					export const serverIslandMap = ${mapSource};
 					
 
-export const serverIslandNameMap = new Map(${JSON.stringify(Array.from(serverIslandNameMap.entries()), null, 2)});
+export const serverIslandNameMap = ${nameMapSource};
 					`
             };
           }
@@ -115,38 +130,116 @@ export const serverIslandNameMap = new Map(${JSON.stringify(Array.from(serverIsl
     },
     renderChunk(code, chunk) {
       if (code.includes(serverIslandPlaceholderMap)) {
-        if (referenceIdMap.size === 0) {
+        if (command === "build") {
+          if (referenceIdMap.size === 0) {
+            return;
+          }
+          const isRelativeChunk = !chunk.isEntry;
+          const dots = isRelativeChunk ? ".." : ".";
+          const mapEntries = [];
+          for (const [resolvedPath, referenceId] of referenceIdMap) {
+            const fileName = this.getFileName(referenceId);
+            const islandName = serverIslandNameMap.get(resolvedPath);
+            if (!islandName) continue;
+            if (!resolvedIslandImports.has(islandName)) {
+              resolvedIslandImports.set(islandName, fileName);
+            }
+            mapEntries.push([islandName, fileName]);
+          }
+          const mapSource = createServerIslandImportMapSource(
+            mapEntries,
+            (fileName) => `${dots}/${fileName}`
+          );
+          const nameMapSource = createNameMapSource(serverIslandNameMap);
           return {
-            code: code.replace(serverIslandPlaceholderMap, "new Map();").replace(serverIslandPlaceholderNameMap, "new Map()"),
+            code: code.replace(serverIslandPlaceholderMap, mapSource).replace(serverIslandPlaceholderNameMap, nameMapSource),
             map: null
           };
         }
-        const isRelativeChunk = !chunk.isEntry;
-        const dots = isRelativeChunk ? ".." : ".";
-        let mapSource = "new Map([";
-        let nameMapSource = "new Map(";
-        for (let [resolvedPath, referenceId] of referenceIdMap) {
-          const fileName = this.getFileName(referenceId);
-          const islandName = serverIslandNameMap.get(resolvedPath);
-          mapSource += `
-	['${islandName}', () => import('${dots}/${fileName}')],`;
-        }
-        nameMapSource += `${JSON.stringify(Array.from(serverIslandNameMap.entries()), null, 2)}`;
-        mapSource += "\n])";
-        nameMapSource += "\n)";
-        referenceIdMap.clear();
-        const ms = new MagicString(code);
-        ms.replace(serverIslandPlaceholderMap, mapSource);
-        ms.replace(serverIslandPlaceholderNameMap, nameMapSource);
         return {
-          code: ms.toString(),
-          map: ms.generateMap({ hires: "boundary" })
+          code: code.replace(serverIslandPlaceholderMap, "new Map();").replace(serverIslandPlaceholderNameMap, "new Map()"),
+          map: null
         };
       }
+    },
+    generateBundle(_options, bundle) {
+      const envName = this.environment?.name;
+      if (envName === ASTRO_VITE_ENVIRONMENT_NAMES.ssr) {
+        for (const chunk of Object.values(bundle)) {
+          if (chunk.type === "chunk" && chunk.code.includes(serverIslandPlaceholderMap)) {
+            ssrManifestChunk = chunk;
+            break;
+          }
+        }
+      }
+      if (envName === ASTRO_VITE_ENVIRONMENT_NAMES.prerender && ssrManifestChunk) {
+        if (resolvedIslandImports.size > 0) {
+          const isRelativeChunk = ssrManifestChunk.fileName.includes("/");
+          const dots = isRelativeChunk ? ".." : ".";
+          const mapSource = createServerIslandImportMapSource(
+            resolvedIslandImports,
+            (fileName) => `${dots}/${fileName}`
+          );
+          const nameMapSource = createNameMapSource(serverIslandNameMap);
+          ssrManifestChunk.code = ssrManifestChunk.code.replace(serverIslandPlaceholderMap, mapSource).replace(serverIslandPlaceholderNameMap, nameMapSource);
+        } else {
+          ssrManifestChunk.code = ssrManifestChunk.code.replace(serverIslandPlaceholderMap, "new Map()").replace(serverIslandPlaceholderNameMap, "new Map()");
+        }
+      }
+    },
+    api: {
+      /**
+       * Post-build hook that patches SSR chunks containing server island placeholders.
+       *
+       * During build, SSR can run before all server islands are discovered (e.g. islands
+       * only used in prerendered pages). This hook runs after SSR + prerender builds and:
+       * 1) replaces placeholders with the complete map of discovered islands
+       * 2) copies island chunks emitted in prerender into the SSR output directory
+       *
+       * Two cases:
+       * 1. Islands were discovered: Replace placeholders with real import maps.
+       * 2. No islands found: Replace placeholders with empty maps.
+       */
+      async buildPostHook({
+        chunks,
+        mutate
+      }) {
+        const ssrChunkWithPlaceholder = chunks.find(
+          (c) => !c.prerender && c.code.includes(serverIslandPlaceholderMap)
+        );
+        if (!ssrChunkWithPlaceholder) {
+          return;
+        }
+        if (resolvedIslandImports.size > 0) {
+          const isRelativeChunk = ssrChunkWithPlaceholder.fileName.includes("/");
+          const dots = isRelativeChunk ? ".." : ".";
+          const mapSource = createServerIslandImportMapSource(
+            resolvedIslandImports,
+            (fileName) => `${dots}/${fileName}`
+          );
+          const nameMapSource = createNameMapSource(serverIslandNameMap);
+          const newCode = ssrChunkWithPlaceholder.code.replace(serverIslandPlaceholderMap, mapSource).replace(serverIslandPlaceholderNameMap, nameMapSource);
+          mutate(ssrChunkWithPlaceholder.fileName, newCode, false);
+          const serverOutputDir = getServerOutputDirectory(settings);
+          const prerenderOutputDir = getPrerenderOutputDirectory(settings);
+          for (const [, fileName] of resolvedIslandImports) {
+            const srcPath = new URL(fileName, appendForwardSlash(prerenderOutputDir.toString()));
+            const destPath = new URL(fileName, appendForwardSlash(serverOutputDir.toString()));
+            if (!fs.existsSync(srcPath)) continue;
+            const destDir = new URL("./", destPath);
+            await fs.promises.mkdir(destDir, { recursive: true });
+            await fs.promises.copyFile(srcPath, destPath);
+          }
+        } else {
+          const newCode = ssrChunkWithPlaceholder.code.replace(serverIslandPlaceholderMap, "new Map()").replace(serverIslandPlaceholderNameMap, "new Map()");
+          mutate(ssrChunkWithPlaceholder.fileName, newCode, false);
+        }
+      }
     }
   };
 }
 export {
   SERVER_ISLAND_MANIFEST,
+  serverIslandPlaceholderMap,
   vitePluginServerIslands
 };

package/dist/i18n/router.js

@@ -74,9 +74,10 @@ class I18nRouter {
   matchPrefixAlways(pathname, _context) {
     const isRoot = pathname === this.#base + "/" || pathname === this.#base;
     if (isRoot) {
+      const basePrefix = this.#base === "/" ? "" : this.#base;
       return {
         type: "redirect",
-        location: `${this.#base}/${this.#defaultLocale}`
+        location: `${basePrefix}/${this.#defaultLocale}`
       };
     }
     if (!pathHasLocale(pathname, this.#locales)) {

package/dist/prerender/utils.d.ts

@@ -5,6 +5,10 @@ export declare function getPrerenderDefault(config: AstroConfig): boolean;
  * Returns the correct output directory of the SSR build based on the configuration
  */
 export declare function getServerOutputDirectory(settings: AstroSettings): URL;
+/**
+ * Returns the output directory used by the prerender environment.
+ */
+export declare function getPrerenderOutputDirectory(settings: AstroSettings): URL;
 /**
  * Returns the correct output directory of the client build based on the configuration
  */

package/dist/prerender/utils.js

@@ -5,6 +5,9 @@ function getPrerenderDefault(config) {
 function getServerOutputDirectory(settings) {
   return settings.buildOutput === "server" ? settings.config.build.server : getOutDirWithinCwd(settings.config.outDir);
 }
+function getPrerenderOutputDirectory(settings) {
+  return new URL("./.prerender/", getServerOutputDirectory(settings));
+}
 function getClientOutputDirectory(settings) {
   const preserveStructure = settings.adapter?.adapterFeatures?.preserveBuildClientDir;
   if (settings.buildOutput === "server" || preserveStructure) {
@@ -15,5 +18,6 @@ function getClientOutputDirectory(settings) {
 export {
   getClientOutputDirectory,
   getPrerenderDefault,
+  getPrerenderOutputDirectory,
   getServerOutputDirectory
 };

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

@@ -10,7 +10,11 @@ function astroDevToolbar({ settings, logger }) {
       return {
         optimizeDeps: {
           // Optimize CJS dependencies used by the dev toolbar
-          include: ["astro > aria-query", "astro > axobject-query"]
+          include: [
+            "astro > aria-query",
+            "astro > axobject-query",
+            ...settings.devToolbarApps.length > 0 ? ["astro/toolbar"] : []
+          ]
         }
       };
     },

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

@@ -3,7 +3,7 @@ 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 } from "../core/constants.js";
+import { ASTRO_VITE_ENVIRONMENT_NAMES, devPrerenderMiddlewareSymbol } from "../core/constants.js";
 import {
   getAlgorithm,
   getDirectives,
@@ -19,6 +19,7 @@ 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";
@@ -40,15 +41,23 @@ function createVitePluginAstroServer({
       return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr;
     },
     async configureServer(viteServer) {
-      if (!isRunnableDevEnvironment(viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr])) {
+      const ssrEnvironment = viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
+      const prerenderEnvironment = viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.prerender];
+      const runnableSsrEnvironment = isRunnableDevEnvironment(ssrEnvironment) ? ssrEnvironment : void 0;
+      const runnablePrerenderEnvironment = isRunnableDevEnvironment(prerenderEnvironment) ? prerenderEnvironment : void 0;
+      if (!runnableSsrEnvironment && !runnablePrerenderEnvironment) {
         return;
       }
-      const environment = viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
-      const loader = createViteLoader(viteServer, environment);
-      const { default: createAstroServerApp } = await environment.runner.import(ASTRO_DEV_SERVER_APP_ID);
-      const controller = createController({ loader });
-      const { handler } = await createAstroServerApp(controller, settings, loader, logger);
-      const { manifest } = await environment.runner.import(SERIALIZED_MANIFEST_ID);
+      async function createHandler(environment) {
+        const loader = createViteLoader(viteServer, environment);
+        const { default: createAstroServerApp } = await environment.runner.import(ASTRO_DEV_SERVER_APP_ID);
+        const controller = createController({ loader });
+        const { handler } = await createAstroServerApp(controller, settings, loader, logger);
+        const { manifest } = await environment.runner.import(SERIALIZED_MANIFEST_ID);
+        return { controller, handler, loader, manifest, environment };
+      }
+      const ssrHandler = runnableSsrEnvironment ? await createHandler(runnableSsrEnvironment) : void 0;
+      const prerenderHandler = runnablePrerenderEnvironment ? await createHandler(runnablePrerenderEnvironment) : void 0;
       const localStorage = new AsyncLocalStorage();
       function handleUnhandledRejection(rejection) {
         const error = AstroError.is(rejection) ? rejection : new AstroError({
@@ -56,20 +65,36 @@ function createVitePluginAstroServer({
           message: AstroErrorData.UnhandledRejection.message(rejection?.stack || rejection)
         });
         const store = localStorage.getStore();
-        if (store instanceof IncomingMessage) {
-          setRouteError(controller.state, store.url, error);
+        const handlers = [];
+        if (ssrHandler) handlers.push(ssrHandler);
+        if (prerenderHandler) handlers.push(prerenderHandler);
+        for (const currentHandler of handlers) {
+          if (store instanceof IncomingMessage) {
+            setRouteError(currentHandler.controller.state, store.url, error);
+          }
+          const { errorWithMetadata } = recordServerError(
+            currentHandler.loader,
+            currentHandler.manifest,
+            logger,
+            error
+          );
+          setTimeout(
+            async () => currentHandler.loader.webSocketSend(await getViteErrorPayload(errorWithMetadata)),
+            200
+          );
         }
-        const { errorWithMetadata } = recordServerError(loader, manifest, logger, error);
-        setTimeout(
-          async () => loader.webSocketSend(await getViteErrorPayload(errorWithMetadata)),
-          200
-        );
       }
       process.on("unhandledRejection", handleUnhandledRejection);
       viteServer.httpServer?.on("close", () => {
         process.off("unhandledRejection", handleUnhandledRejection);
       });
       return () => {
+        const shouldHandlePrerenderInCore = Boolean(
+          viteServer[devPrerenderMiddlewareSymbol]
+        );
+        if (!ssrHandler && !(prerenderHandler && shouldHandlePrerenderInCore)) {
+          return;
+        }
         viteServer.middlewares.stack.unshift({
           route: "",
           handle: baseMiddleware(settings, logger)
@@ -86,16 +111,49 @@ function createVitePluginAstroServer({
           route: "",
           handle: secFetchMiddleware(logger, settings.config.security?.allowedDomains)
         });
-        viteServer.middlewares.use(async function astroDevHandler(request, response) {
-          if (request.url === void 0 || !request.method) {
-            response.writeHead(500, "Incomplete request");
-            response.end();
-            return;
-          }
-          localStorage.run(request, () => {
-            handler(request, response);
+        if (prerenderHandler && shouldHandlePrerenderInCore) {
+          viteServer.middlewares.use(
+            async function astroDevPrerenderHandler(request, response, next) {
+              if (request.url === void 0 || !request.method) {
+                response.writeHead(500, "Incomplete request");
+                response.end();
+                return;
+              }
+              if (request.url.startsWith("/@") || request.url.startsWith("/__")) {
+                return next();
+              }
+              if (request.url.includes("/node_modules/")) {
+                return next();
+              }
+              try {
+                const pathname = decodeURI(new URL(request.url, "http://localhost").pathname);
+                const { routes } = await prerenderHandler.environment.runner.import("virtual:astro:routes");
+                const routesList = { routes: routes.map((r) => r.routeData) };
+                const matches = matchAllRoutes(pathname, routesList);
+                if (!matches.some((route) => route.prerender)) {
+                  return next();
+                }
+                localStorage.run(request, () => {
+                  prerenderHandler.handler(request, response);
+                });
+              } catch (err) {
+                next(err);
+              }
+            }
+          );
+        }
+        if (ssrHandler) {
+          viteServer.middlewares.use(async function astroDevHandler(request, response) {
+            if (request.url === void 0 || !request.method) {
+              response.writeHead(500, "Incomplete request");
+              response.end();
+              return;
+            }
+            localStorage.run(request, () => {
+              ssrHandler.handler(request, response);
+            });
           });
-        });
+        }
       };
     }
   };

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

@@ -42,9 +42,13 @@ function routeGuardMiddleware(settings) {
       return next();
     }
     const rootFilePath = new URL("." + pathname, config.root);
-    if (fs.existsSync(rootFilePath)) {
-      const html = notFoundTemplate(pathname);
-      return writeHtmlResponse(res, 404, html);
+    try {
+      const stat = fs.statSync(rootFilePath);
+      if (stat.isFile()) {
+        const html = notFoundTemplate(pathname);
+        return writeHtmlResponse(res, 404, html);
+      }
+    } catch {
     }
     return next();
   };

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

@@ -42,16 +42,19 @@ function* collectCSSWithOrder(id, mod, seen = /* @__PURE__ */ new Set()) {
   }
 }
 function astroDevCssPlugin({ routesList, command }) {
-  let ssrEnvironment = void 0;
+  let server;
   const cssContentCache = /* @__PURE__ */ new Map();
+  function getCurrentEnvironment(pluginEnv) {
+    return pluginEnv ?? server?.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
+  }
   return [
     {
       name: MODULE_DEV_CSS,
-      async configureServer(server) {
-        ssrEnvironment = server.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
+      async configureServer(viteServer) {
+        server = viteServer;
       },
       applyToEnvironment(env) {
-        return env.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || env.name === ASTRO_VITE_ENVIRONMENT_NAMES.client;
+        return env.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || env.name === ASTRO_VITE_ENVIRONMENT_NAMES.client || env.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender;
       },
       resolveId: {
         filter: {
@@ -81,14 +84,15 @@ function astroDevCssPlugin({ routesList, command }) {
             );
             const cssWithOrder = /* @__PURE__ */ new Map();
             const componentPageId = getVirtualModulePageNameForComponent(componentPath);
-            await ssrEnvironment?.fetchModule(componentPageId);
-            const resolved = await ssrEnvironment?.pluginContainer.resolveId(componentPageId);
+            const env = getCurrentEnvironment(this.environment);
+            await env?.fetchModule(componentPageId);
+            const resolved = await env?.pluginContainer.resolveId(componentPageId);
             if (!resolved?.id) {
               return {
                 code: "export const css = new Set()"
               };
             }
-            const mod = ssrEnvironment?.moduleGraph.getModuleById(resolved.id);
+            const mod = env?.moduleGraph.getModuleById(resolved.id);
             if (!mod) {
               return {
                 code: "export const css = new Set()"
@@ -123,7 +127,8 @@ function astroDevCssPlugin({ routesList, command }) {
           if (command === "build") {
             return;
           }
-          const mod = ssrEnvironment?.moduleGraph.getModuleById(id);
+          const env = getCurrentEnvironment(this.environment);
+          const mod = env?.moduleGraph.getModuleById(id);
           if (mod) {
             cssContentCache.set(id, code);
           }
@@ -133,7 +138,7 @@ function astroDevCssPlugin({ routesList, command }) {
     {
       name: MODULE_DEV_CSS_ALL,
       applyToEnvironment(env) {
-        return env.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || env.name === ASTRO_VITE_ENVIRONMENT_NAMES.client || env.name === ASTRO_VITE_ENVIRONMENT_NAMES.astro;
+        return env.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || env.name === ASTRO_VITE_ENVIRONMENT_NAMES.client || env.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender;
       },
       resolveId: {
         filter: {

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

@@ -62,7 +62,7 @@ function vitePluginEnvironment({
             // For the dev toolbar
             "astro > html-escaper"
           ],
-          exclude: ["astro:*", "virtual:astro:*"],
+          exclude: ["astro:*", "virtual:astro:*", "astro/virtual-modules/prefetch.js"],
           // Astro files can't be rendered on the client
           entries: [`${srcDirPattern}**/*.{jsx,tsx,vue,svelte,html}`]
         };

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

@@ -11,6 +11,7 @@ import { rootRelativePath } from "../core/viteUtils.js";
 import { createDefaultAstroMetadata } from "../vite-plugin-astro/metadata.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
 import { isAstroServerEnvironment } from "../environments.js";
+import { RESOLVED_MODULE_DEV_CSS_ALL } from "../vite-plugin-css/const.js";
 import { PAGE_SCRIPT_ID } from "../vite-plugin-scripts/index.js";
 const ASTRO_ROUTES_MODULE_ID = "virtual:astro:routes";
 const ASTRO_ROUTES_MODULE_ID_RESOLVED = "\0" + ASTRO_ROUTES_MODULE_ID;
@@ -77,11 +78,26 @@ async function astroPluginRoutes({
           routeData: serializeRouteData(r, settings.config.trailingSlash)
         };
       });
-      let environment = server.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
-      const virtualMod = environment.moduleGraph.getModuleById(ASTRO_ROUTES_MODULE_ID_RESOLVED);
-      if (!virtualMod) return;
-      environment.moduleGraph.invalidateModule(virtualMod);
-      environment.hot.send("astro:routes-updated", {});
+      const environmentsToInvalidate = [];
+      for (const name of [
+        ASTRO_VITE_ENVIRONMENT_NAMES.ssr,
+        ASTRO_VITE_ENVIRONMENT_NAMES.prerender
+      ]) {
+        const environment = server.environments[name];
+        if (environment) {
+          environmentsToInvalidate.push(environment);
+        }
+      }
+      for (const environment of environmentsToInvalidate) {
+        const virtualMod = environment.moduleGraph.getModuleById(ASTRO_ROUTES_MODULE_ID_RESOLVED);
+        if (!virtualMod) continue;
+        environment.moduleGraph.invalidateModule(virtualMod);
+        const cssMod = environment.moduleGraph.getModuleById(RESOLVED_MODULE_DEV_CSS_ALL);
+        if (cssMod) {
+          environment.moduleGraph.invalidateModule(cssMod);
+        }
+        environment.hot.send("astro:routes-updated", {});
+      }
     }
   }
   return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "6.0.2",
+  "version": "6.0.4",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -154,8 +154,8 @@
     "yargs-parser": "^22.0.0",
     "zod": "^4.3.6",
     "@astrojs/internal-helpers": "0.8.0",
-    "@astrojs/telemetry": "3.3.0",
-    "@astrojs/markdown-remark": "7.0.0"
+    "@astrojs/markdown-remark": "7.0.0",
+    "@astrojs/telemetry": "3.3.0"
   },
   "optionalDependencies": {
     "sharp": "^0.34.0"

package/templates/env.mjs

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
 // @ts-check
 import { schema } from 'virtual:astro:env/internal';
 import {