astro 7.0.0-alpha.0 → 7.0.0-alpha.2

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

@@ -92,6 +92,13 @@ export interface BuildInternals {
         moduleIds: string[];
         prerender: boolean;
     }>;
+    /**
+     * Component exports that were rendered during the SSR build.
+     * Used by the client build's cssScopeTo recovery to distinguish between
+     * CSS that was tree-shaken because the component wasn't rendered in SSR
+     * vs CSS that was included in SSR.
+     */
+    ssrRenderedExports?: Map<string, Set<string>>;
 }
 /**
  * Creates internal maps used to coordinate the CSS and HTML plugins.

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

@@ -6,5 +6,11 @@ import type { StaticBuildOptions } from '../types.js';
  * bypass the HTML rendering pipeline and miss skew protection query params.
  *
  * Uses es-module-lexer to reliably parse both static and dynamic imports.
+ *
+ * This runs in `generateBundle` (not `renderChunk`) so that Vite's CSS plugin
+ * can first remove pure-CSS wrapper chunks and replace their imports with
+ * `/* empty css * /` comments. If we rewrote imports earlier (in `renderChunk`),
+ * the appended query params would break Vite's regex-based CSS chunk cleanup,
+ * leaving dangling imports to deleted chunks that 404 at runtime.
  */
 export declare function pluginChunkImports(options: StaticBuildOptions): VitePlugin | undefined;

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

@@ -1,5 +1,17 @@
 import { init, parse } from "es-module-lexer";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../../constants.js";
+function getImportSpecifier(code, imp) {
+  if (imp.n != null) return imp.n;
+  if (imp.d > -1) {
+    const raw = code.slice(imp.s, imp.e);
+    const quote = raw[0];
+    if ((quote === "`" || quote === '"' || quote === "'") && raw.at(-1) === quote) {
+      const inner = raw.slice(1, -1);
+      if (!inner.includes("${")) return inner;
+    }
+  }
+  return void 0;
+}
 function pluginChunkImports(options) {
   const assetQueryParams = options.settings.adapter?.client?.assetQueryParams;
   if (!assetQueryParams || assetQueryParams.toString() === "") {
@@ -12,25 +24,25 @@ function pluginChunkImports(options) {
     applyToEnvironment(environment) {
       return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.client;
     },
-    async renderChunk(code, _chunk) {
-      if (!code.includes("./")) {
-        return null;
-      }
+    async generateBundle(_options, bundle) {
       await init;
-      const [imports] = parse(code);
-      const relativeImports = imports.filter(
-        (imp) => imp.n && /^\.\.?\//.test(imp.n) && /\.(?:js|mjs)$/.test(imp.n)
-      );
-      if (relativeImports.length === 0) {
-        return null;
-      }
-      let rewritten = code;
-      for (let i = relativeImports.length - 1; i >= 0; i--) {
-        const imp = relativeImports[i];
-        const insertAt = imp.d > -1 ? imp.e - 1 : imp.e;
-        rewritten = rewritten.slice(0, insertAt) + "?" + queryString + rewritten.slice(insertAt);
+      for (const [, chunk] of Object.entries(bundle)) {
+        if (chunk.type !== "chunk") continue;
+        if (!chunk.code.includes("./")) continue;
+        const [imports] = parse(chunk.code);
+        const relativeImports = imports.filter((imp) => {
+          const name = getImportSpecifier(chunk.code, imp);
+          return name != null && /^\.\.?\//.test(name) && /\.(?:js|mjs)$/.test(name);
+        });
+        if (relativeImports.length === 0) continue;
+        let rewritten = chunk.code;
+        for (let i = relativeImports.length - 1; i >= 0; i--) {
+          const imp = relativeImports[i];
+          const insertAt = imp.d > -1 ? imp.e - 1 : imp.e;
+          rewritten = rewritten.slice(0, insertAt) + "?" + queryString + rewritten.slice(insertAt);
+        }
+        chunk.code = rewritten;
       }
-      return { code: rewritten, map: null };
     }
   };
 }

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

@@ -1,6 +1,7 @@
 import { isCSSRequest } from "vite";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../../constants.js";
 import { isPropagatedAssetBoundary } from "../../head-propagation/boundary.js";
+import { VIRTUAL_PAGE_RESOLVED_MODULE_ID } from "../../../vite-plugin-pages/const.js";
 import {
   getParentExtendedModuleInfos,
   getParentModuleInfos,
@@ -18,7 +19,12 @@ function pluginCSS(options, internals) {
 function isBuildCssBoundary(id, ctx) {
   if (isPropagatedAssetBoundary(id)) return true;
   const info = ctx.getModuleInfo(id);
-  return info ? moduleIsTopLevelPage(info) : false;
+  if (!info || !moduleIsTopLevelPage(info)) return false;
+  const allImporters = info.importers.concat(info.dynamicImporters);
+  const hasNonVirtualPageImporter = allImporters.some(
+    (importer) => !importer.includes(VIRTUAL_PAGE_RESOLVED_MODULE_ID)
+  );
+  return !hasNonVirtualPageImporter;
 }
 function rollupPluginAstroBuildCSS(options) {
   const { internals, buildOptions } = options;
@@ -40,10 +46,25 @@ function rollupPluginAstroBuildCSS(options) {
               internals.cssModuleToChunkIdMap.set(moduleId, chunk.fileName);
             }
           }
+          for (const [moduleId, moduleInfo] of Object.entries(chunk.modules || {})) {
+            if (moduleInfo.renderedExports.length > 0) {
+              const existing = internals.ssrRenderedExports?.get(moduleId);
+              if (existing) {
+                for (const exp of moduleInfo.renderedExports) {
+                  existing.add(exp);
+                }
+              } else {
+                internals.ssrRenderedExports ??= /* @__PURE__ */ new Map();
+                internals.ssrRenderedExports.set(moduleId, new Set(moduleInfo.renderedExports));
+              }
+            }
+          }
         }
       }
       const renderedComponentExports = /* @__PURE__ */ new Map();
       const componentToPages = /* @__PURE__ */ new Map();
+      const deletedCssAssets = /* @__PURE__ */ new Map();
+      const cssScopeToAddedCss = /* @__PURE__ */ new Set();
       if (this.environment?.name === ASTRO_VITE_ENVIRONMENT_NAMES.client) {
         for (const [, item] of Object.entries(bundle)) {
           if (item.type !== "chunk") continue;
@@ -70,6 +91,9 @@ function rollupPluginAstroBuildCSS(options) {
             );
             if (allCssInSSR && shouldDeleteCSSChunk(allModules, internals)) {
               for (const cssId of meta.importedCss) {
+                if (bundle[cssId]) {
+                  deletedCssAssets.set(cssId, bundle[cssId]);
+                }
                 delete bundle[cssId];
               }
             }
@@ -151,6 +175,14 @@ function rollupPluginAstroBuildCSS(options) {
                     }
                   }
                 }
+                const ssrExports = internals.ssrRenderedExports?.get(scopedToModule);
+                if (!ssrExports || !ssrExports.has(scopedToExport)) {
+                  for (const cssId of meta.importedCss) {
+                    if (deletedCssAssets.has(cssId)) {
+                      cssScopeToAddedCss.add(cssId);
+                    }
+                  }
+                }
               }
             }
           }
@@ -185,6 +217,13 @@ function rollupPluginAstroBuildCSS(options) {
           }
         }
       }
+      if (cssScopeToAddedCss.size > 0) {
+        for (const cssId of cssScopeToAddedCss) {
+          if (deletedCssAssets.has(cssId) && !bundle[cssId]) {
+            bundle[cssId] = deletedCssAssets.get(cssId);
+          }
+        }
+      }
     }
   };
   const singleCssPlugin = {

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

@@ -32,7 +32,7 @@ function pluginInternals(options, internals) {
           },
           resolve: {
             // Always bundle Astro runtime when building for SSR
-            noExternal: ["astro"]
+            noExternal: ["astro", "@astrojs/internal-helpers"]
           }
         };
       }

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

@@ -47,7 +47,8 @@ async function manifestBuildPostHook(options, internals, {
       logger: options.logger,
       middlewareEntryPoint: shouldPassMiddlewareEntryPoint ? internals.middlewareEntryPoint : void 0
     });
-    const code = injectManifest(manifest, ssrManifestChunk.code);
+    const ssrManifest = stripPrerenderedRouteStyles(manifest);
+    const code = injectManifest(ssrManifest, ssrManifestChunk.code);
     mutate(ssrManifestChunk.fileName, code, false);
   }
   const prerenderManifestChunk = chunks.find(
@@ -82,6 +83,15 @@ function injectManifest(manifest, code) {
     return JSON.stringify(manifest);
   });
 }
+function stripPrerenderedRouteStyles(manifest) {
+  let stripped = false;
+  const routes = manifest.routes.map((route) => {
+    if (!route.routeData.prerender || route.styles.length === 0) return route;
+    stripped = true;
+    return { ...route, styles: [] };
+  });
+  return stripped ? { ...manifest, routes } : manifest;
+}
 async function buildManifest(opts, internals, staticFiles, encodedKey) {
   const { settings } = opts;
   const routes = [];

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

@@ -10,31 +10,23 @@ 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,
-  getPrerenderOutputDirectory,
-  getServerOutputDirectory
-} from "../../prerender/utils.js";
-import { VIRTUAL_PAGE_RESOLVED_MODULE_ID } from "../../vite-plugin-pages/const.js";
+import { getPrerenderOutputDirectory, getServerOutputDirectory } from "../../prerender/utils.js";
 import { PAGE_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
 import { routeIsRedirect } from "../routing/helpers.js";
-import { getOutDirWithinCwd } from "./common.js";
-import { CHUNKS_PATH } from "./consts.js";
 import { generatePages } from "./generate.js";
 import { trackPageData } from "./internal.js";
 import { getAllBuildPlugins } from "./plugins/index.js";
 import { manifestBuildPostHook } from "./plugins/plugin-manifest.js";
-import {
-  isLegacyAdapter,
-  LEGACY_SSR_ENTRY_VIRTUAL_MODULE,
-  RESOLVED_LEGACY_SSR_ENTRY_VIRTUAL_MODULE
-} from "./plugins/plugin-ssr.js";
 import { ASTRO_PAGE_EXTENSION_POST_PATTERN } from "./plugins/util.js";
-import { cleanChunkName, getTimeStat, viteBuildReturnToRolldownOutputs } from "./util.js";
+import { getTimeStat, viteBuildReturnToRolldownOutputs } from "./util.js";
 import { NOOP_MODULE_ID } from "./plugins/plugin-noop.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../constants.js";
 import { getSSRAssets } from "./internal.js";
-import { SERVER_ISLAND_MAP_MARKER } from "../server-islands/vite-plugin-server-islands.js";
+import {
+  SERVER_ISLAND_MAP_MARKER,
+  hasServerIslands
+} from "../server-islands/vite-plugin-server-islands.js";
+import { createViteBuildConfig } from "./vite-build-config.js";
 const PRERENDER_ENTRY_FILENAME_PREFIX = "prerender-entry";
 function extractRelevantChunks(outputs, prerender) {
   const extracted = [];
@@ -83,7 +75,6 @@ async function viteBuild(opts) {
 async function buildEnvironments(opts, internals) {
   const { allPages, settings, viteConfig } = opts;
   const routes = Object.values(allPages).flatMap((pageData) => pageData.route);
-  const legacyAdapter = !settings.adapter || isLegacyAdapter(settings.adapter);
   const buildPlugins = getAllBuildPlugins(internals, opts);
   const flatPlugins = buildPlugins.flat().filter(Boolean);
   const plugins = [...flatPlugins, ...viteConfig.plugins || []];
@@ -149,69 +140,10 @@ async function buildEnvironments(opts, internals) {
       return Object.keys(currentRolldownInput).includes(moduleName);
     }
   }
-  const viteBuildConfig = {
-    ...viteConfig,
-    logLevel: viteConfig.logLevel ?? "error",
-    build: {
-      target: "esnext",
-      // Vite defaults cssMinify to false in SSR by default, but we want to minify it
-      // as the CSS generated are used and served to the client.
-      cssMinify: viteConfig.build?.minify == null ? true : !!viteConfig.build?.minify,
-      ...viteConfig.build,
-      emptyOutDir: false,
-      copyPublicDir: false,
-      manifest: false,
-      rolldownOptions: {
-        ...viteConfig.build?.rolldownOptions,
-        // Setting as `exports-only` allows us to safely delete inputs that are only used during prerendering
-        preserveEntrySignatures: "exports-only",
-        ...legacyAdapter && settings.buildOutput === "server" ? { input: LEGACY_SSR_ENTRY_VIRTUAL_MODULE } : {},
-        output: {
-          hoistTransitiveImports: false,
-          format: "esm",
-          minifyInternalExports: true,
-          // Server chunks can't go in the assets (_astro) folder
-          // We need to keep these separate
-          chunkFileNames(chunkInfo) {
-            const { name } = chunkInfo;
-            let prefix = CHUNKS_PATH;
-            let suffix = "_[hash].mjs";
-            if (name.includes(ASTRO_PAGE_EXTENSION_POST_PATTERN)) {
-              const [sanitizedName] = name.split(ASTRO_PAGE_EXTENSION_POST_PATTERN);
-              return [prefix, cleanChunkName(sanitizedName), suffix].join("");
-            }
-            if (name.startsWith("pages/")) {
-              const sanitizedName = name.split(".")[0];
-              return [prefix, cleanChunkName(sanitizedName), suffix].join("");
-            }
-            return [prefix, cleanChunkName(name), suffix].join("");
-          },
-          assetFileNames: `${settings.config.build.assets}/[name].[hash][extname]`,
-          ...viteConfig.build?.rolldownOptions?.output,
-          entryFileNames(chunkInfo) {
-            if (chunkInfo.facadeModuleId?.startsWith(VIRTUAL_PAGE_RESOLVED_MODULE_ID)) {
-              return makeAstroPageEntryPointFileName(
-                VIRTUAL_PAGE_RESOLVED_MODULE_ID,
-                chunkInfo.facadeModuleId,
-                routes
-              );
-            } else if (chunkInfo.facadeModuleId === RESOLVED_LEGACY_SSR_ENTRY_VIRTUAL_MODULE || // This catches the case when the adapter uses `entrypointResolution: 'auto'`. When doing so,
-            // the adapter must set rolldownOptions.input or Astro sets it from `serverEntrypoint`.
-            isRolldownInput(chunkInfo.name) || isRolldownInput(chunkInfo.facadeModuleId)) {
-              return opts.settings.config.build.serverEntry;
-            } else {
-              return "[name].mjs";
-            }
-          }
-        }
-      },
-      ssr: true,
-      ssrEmitAssets: true,
-      // improve build performance
-      minify: false,
-      modulePreload: { polyfill: false },
-      reportCompressedSize: false
-    },
+  const viteBuildConfig = createViteBuildConfig({
+    settings,
+    viteConfig,
+    routes,
     plugins,
     // Top-level buildApp for framework build orchestration
     // This takes precedence over platform plugin fallbacks (e.g., Cloudflare)
@@ -225,7 +157,7 @@ async function buildEnvironments(opts, internals) {
         const prerenderChunks = extractRelevantChunks(prerenderOutputs, true);
         prerenderOutput = void 0;
         let ssrChunks = [];
-        if (settings.buildOutput !== "static") {
+        if (needsServerBuild(settings, builder2)) {
           settings.timer.start("SSR build");
           let ssrOutput = await builder2.build(
             builder2.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr]
@@ -244,69 +176,15 @@ async function buildEnvironments(opts, internals) {
           internals.clientInput.add(NOOP_MODULE_ID);
         }
         const sortedClientInput = Array.from(internals.clientInput).sort();
-        builder2.environments.client.config.build.rollupOptions.input = sortedClientInput;
+        builder2.environments.client.config.build.rolldownOptions.input = sortedClientInput;
         settings.timer.start("Client build");
         await builder2.build(builder2.environments.client);
         settings.timer.end("Client build");
         internals.extractedChunks = [...ssrChunks, ...prerenderChunks];
       }
     },
-    envPrefix: viteConfig.envPrefix ?? "PUBLIC_",
-    base: settings.config.base,
-    environments: {
-      ...viteConfig.environments ?? {},
-      [ASTRO_VITE_ENVIRONMENT_NAMES.prerender]: {
-        build: {
-          emitAssets: true,
-          outDir: fileURLToPath(getPrerenderOutputDirectory(settings)),
-          rolldownOptions: {
-            // Only skip the default prerender entrypoint if an adapter with `entrypointResolution: 'self'` is used
-            // AND provides a custom prerenderer. Otherwise, use the default.
-            ...!legacyAdapter && settings.prerenderer ? {} : { input: "astro/entrypoints/prerender" },
-            output: {
-              entryFileNames: `${PRERENDER_ENTRY_FILENAME_PREFIX}.[hash].mjs`,
-              format: "esm",
-              ...viteConfig.environments?.prerender?.build?.rolldownOptions?.output
-            }
-          },
-          ssr: true
-        }
-      },
-      [ASTRO_VITE_ENVIRONMENT_NAMES.client]: {
-        build: {
-          emitAssets: true,
-          target: "esnext",
-          outDir: fileURLToPath(getClientOutputDirectory(settings)),
-          copyPublicDir: true,
-          sourcemap: viteConfig.environments?.client?.build?.sourcemap ?? false,
-          minify: true,
-          rolldownOptions: {
-            preserveEntrySignatures: "exports-only",
-            output: {
-              entryFileNames(chunkInfo) {
-                return `${settings.config.build.assets}/${cleanChunkName(chunkInfo.name)}.[hash].js`;
-              },
-              chunkFileNames(chunkInfo) {
-                return `${settings.config.build.assets}/${cleanChunkName(chunkInfo.name)}.[hash].js`;
-              },
-              assetFileNames: `${settings.config.build.assets}/[name].[hash][extname]`,
-              ...viteConfig.environments?.client?.build?.rolldownOptions?.output
-            }
-          }
-        }
-      },
-      [ASTRO_VITE_ENVIRONMENT_NAMES.ssr]: {
-        build: {
-          outDir: fileURLToPath(getServerOutputDirectory(settings)),
-          rolldownOptions: {
-            output: {
-              ...viteConfig.environments?.ssr?.build?.rolldownOptions?.output
-            }
-          }
-        }
-      }
-    }
-  };
+    isRolldownInput
+  });
   const updatedViteBuildConfig = await runHookBuildSetup({
     config: settings.config,
     pages: internals.pagesByKeys,
@@ -355,15 +233,12 @@ async function runManifestInjection(opts, internals, chunks, buildPostHooks) {
 }
 async function writeMutatedChunks(opts, mutations) {
   const { settings } = opts;
-  const config = settings.config;
   for (const [fileName, mutation] of mutations) {
     let root;
     if (mutation.prerender) {
       root = getPrerenderOutputDirectory(settings);
-    } else if (settings.buildOutput === "server") {
-      root = config.build.server;
     } else {
-      root = getOutDirWithinCwd(config.outDir);
+      root = getServerOutputDirectory(settings);
     }
     const fullPath = path.join(fileURLToPath(root), fileName);
     const fileURL = pathToFileURL(fullPath);
@@ -421,6 +296,12 @@ function getClientInput(internals, settings) {
   }
   return clientInput;
 }
+function needsServerBuild(settings, builder) {
+  if (settings.buildOutput === "server") {
+    return true;
+  }
+  return hasServerIslands(builder.environments.prerender);
+}
 function makeAstroPageEntryPointFileName(prefix, facadeModuleId, routes) {
   const pageModuleId = facadeModuleId.replace(prefix, "").replace(ASTRO_PAGE_EXTENSION_POST_PATTERN, ".");
   const route = routes.find((routeData) => routeData.component === pageModuleId);

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

@@ -37,7 +37,6 @@ export interface StaticBuildOptions {
     origin: string;
     pageNames: string[];
     viteConfig: InlineConfig;
-    teardownCompiler: boolean;
     key: Promise<CryptoKey>;
 }
 type ImportComponentInstance = () => Promise<ComponentInstance>;

package/dist/core/build/util.js

@@ -1,6 +1,13 @@
 function getTimeStat(timeStart, timeEnd) {
   const buildTime = timeEnd - timeStart;
-  return buildTime < 1e3 ? `${Math.round(buildTime)}ms` : `${(buildTime / 1e3).toFixed(2)}s`;
+  if (buildTime < 1e3) {
+    return `${Math.round(buildTime)}ms`;
+  } else if (buildTime < 6e4) {
+    return `${(buildTime / 1e3).toFixed(2)}s`;
+  }
+  const mins = Math.floor(buildTime / 6e4);
+  const secs = Math.round(buildTime % 6e4 / 1e3);
+  return `${mins}m ${secs}s`;
 }
 function shouldAppendForwardSlash(trailingSlash, buildFormat) {
   switch (trailingSlash) {

package/dist/core/build/vite-build-config.d.ts

@@ -0,0 +1,28 @@
+import type * as vite from 'vite';
+import type { RouteData } from '../../types/public/internal.js';
+import type { AstroSettings } from '../../types/astro.js';
+export interface CreateViteBuildConfigOptions {
+    /** The resolved Astro settings. */
+    settings: AstroSettings;
+    /** The base Vite config produced by createVite(). */
+    viteConfig: vite.InlineConfig;
+    /** All routes to be built. */
+    routes: RouteData[];
+    /** Assembled Vite plugins (build plugins + user plugins). */
+    plugins: vite.PluginOption[];
+    /** The buildApp callback for the Vite builder. */
+    builder: vite.BuilderOptions;
+    /**
+     * A function that checks whether a given module name is a rollup input.
+     * Used by entryFileNames to determine the server entry.
+     */
+    isRolldownInput: (moduleName: string | undefined) => boolean;
+}
+/**
+ * Creates the Vite InlineConfig used for the multi-environment build.
+ *
+ * This is a pure config assembly function — it does not execute the build.
+ * Extracted from `buildEnvironments()` to enable unit testing of config
+ * merging behavior (e.g. user rollup output overrides).
+ */
+export declare function createViteBuildConfig(opts: CreateViteBuildConfigOptions): vite.InlineConfig;

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

@@ -0,0 +1,165 @@
+import { fileURLToPath } from "node:url";
+import {
+  getClientOutputDirectory,
+  getPrerenderOutputDirectory,
+  getServerOutputDirectory
+} from "../../prerender/utils.js";
+import { VIRTUAL_PAGE_RESOLVED_MODULE_ID } from "../../vite-plugin-pages/const.js";
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../constants.js";
+import { CHUNKS_PATH } from "./consts.js";
+import {
+  isLegacyAdapter,
+  LEGACY_SSR_ENTRY_VIRTUAL_MODULE,
+  RESOLVED_LEGACY_SSR_ENTRY_VIRTUAL_MODULE
+} from "./plugins/plugin-ssr.js";
+import { ASTRO_PAGE_EXTENSION_POST_PATTERN } from "./plugins/util.js";
+import { cleanChunkName } from "./util.js";
+import { makeAstroPageEntryPointFileName } from "./static-build.js";
+const PRERENDER_ENTRY_FILENAME_PREFIX = "prerender-entry";
+function createViteBuildConfig(opts) {
+  const { settings, viteConfig, routes, plugins, builder, isRolldownInput } = opts;
+  const legacyAdapter = !settings.adapter || isLegacyAdapter(settings.adapter);
+  return {
+    ...viteConfig,
+    logLevel: viteConfig.logLevel ?? "error",
+    build: {
+      target: "esnext",
+      // Vite defaults cssMinify to false in SSR by default, but we want to minify it
+      // as the CSS generated are used and served to the client.
+      cssMinify: viteConfig.build?.minify == null ? true : !!viteConfig.build?.minify,
+      ...viteConfig.build,
+      emptyOutDir: false,
+      copyPublicDir: false,
+      manifest: false,
+      rolldownOptions: {
+        ...viteConfig.build?.rolldownOptions,
+        // Setting as `exports-only` allows us to safely delete inputs that are only used during prerendering
+        preserveEntrySignatures: "exports-only",
+        ...legacyAdapter && settings.buildOutput === "server" ? { input: LEGACY_SSR_ENTRY_VIRTUAL_MODULE } : {},
+        output: {
+          hoistTransitiveImports: false,
+          format: "esm",
+          minifyInternalExports: true,
+          // Server chunks can't go in the assets (_astro) folder
+          // We need to keep these separate
+          chunkFileNames(chunkInfo) {
+            const { name } = chunkInfo;
+            let prefix = CHUNKS_PATH;
+            let suffix = "_[hash].mjs";
+            if (name.includes(ASTRO_PAGE_EXTENSION_POST_PATTERN)) {
+              const [sanitizedName] = name.split(ASTRO_PAGE_EXTENSION_POST_PATTERN);
+              return [prefix, cleanChunkName(sanitizedName), suffix].join("");
+            }
+            if (name.startsWith("pages/")) {
+              const sanitizedName = name.split(".")[0];
+              return [prefix, cleanChunkName(sanitizedName), suffix].join("");
+            }
+            return [prefix, cleanChunkName(name), suffix].join("");
+          },
+          assetFileNames(assetInfo) {
+            const name = assetInfo.names?.[0] ?? "";
+            if (name.includes(ASTRO_PAGE_EXTENSION_POST_PATTERN)) {
+              const [sanitizedName] = name.split(ASTRO_PAGE_EXTENSION_POST_PATTERN);
+              return `${settings.config.build.assets}/${sanitizedName}.[hash][extname]`;
+            }
+            return `${settings.config.build.assets}/[name].[hash][extname]`;
+          },
+          ...viteConfig.build?.rolldownOptions?.output,
+          entryFileNames(chunkInfo) {
+            if (chunkInfo.facadeModuleId?.startsWith(VIRTUAL_PAGE_RESOLVED_MODULE_ID)) {
+              return makeAstroPageEntryPointFileName(
+                VIRTUAL_PAGE_RESOLVED_MODULE_ID,
+                chunkInfo.facadeModuleId,
+                routes
+              );
+            } else if (chunkInfo.facadeModuleId === RESOLVED_LEGACY_SSR_ENTRY_VIRTUAL_MODULE || // This catches the case when the adapter uses `entrypointResolution: 'auto'`. When doing so,
+            // the adapter must set rolldownOptions.input or Astro sets it from `serverEntrypoint`.
+            isRolldownInput(chunkInfo.name) || isRolldownInput(chunkInfo.facadeModuleId)) {
+              return settings.config.build.serverEntry;
+            } else {
+              return "[name].mjs";
+            }
+          }
+        }
+      },
+      ssr: true,
+      ssrEmitAssets: true,
+      // improve build performance
+      minify: false,
+      modulePreload: { polyfill: false },
+      reportCompressedSize: false
+    },
+    plugins,
+    builder,
+    envPrefix: viteConfig.envPrefix ?? "PUBLIC_",
+    base: settings.config.base,
+    environments: {
+      ...viteConfig.environments ?? {},
+      [ASTRO_VITE_ENVIRONMENT_NAMES.prerender]: {
+        build: {
+          emitAssets: true,
+          outDir: fileURLToPath(getPrerenderOutputDirectory(settings)),
+          rolldownOptions: {
+            // Only skip the default prerender entrypoint if an adapter with `entrypointResolution: 'self'` is used
+            // AND provides a custom prerenderer. Otherwise, use the default.
+            ...!legacyAdapter && settings.prerenderer ? {} : { input: "astro/entrypoints/prerender" },
+            output: {
+              entryFileNames: `${PRERENDER_ENTRY_FILENAME_PREFIX}.[hash].mjs`,
+              format: "esm",
+              ...viteConfig.environments?.prerender?.build?.rolldownOptions?.output
+            }
+          },
+          ssr: true
+        }
+      },
+      [ASTRO_VITE_ENVIRONMENT_NAMES.client]: {
+        build: {
+          emitAssets: true,
+          target: "esnext",
+          outDir: fileURLToPath(getClientOutputDirectory(settings)),
+          copyPublicDir: true,
+          sourcemap: viteConfig.environments?.client?.build?.sourcemap ?? viteConfig.build?.sourcemap ?? false,
+          minify: viteConfig.environments?.client?.build?.minify ?? viteConfig.build?.minify ?? true,
+          rolldownOptions: {
+            preserveEntrySignatures: "exports-only",
+            output: {
+              // Inherit top-level rolldown output options (e.g. compact) as a
+              // base, then layer Astro defaults on top so that Astro's
+              // naming functions are preserved unless explicitly overridden
+              // via the environment-specific config.
+              ...viteConfig.build?.rolldownOptions?.output,
+              entryFileNames(chunkInfo) {
+                return `${settings.config.build.assets}/${cleanChunkName(chunkInfo.name)}.[hash].js`;
+              },
+              chunkFileNames(chunkInfo) {
+                return `${settings.config.build.assets}/${cleanChunkName(chunkInfo.name)}.[hash].js`;
+              },
+              assetFileNames(assetInfo) {
+                const name = assetInfo.names?.[0] ?? "";
+                if (name.includes(ASTRO_PAGE_EXTENSION_POST_PATTERN)) {
+                  const [sanitizedName] = name.split(ASTRO_PAGE_EXTENSION_POST_PATTERN);
+                  return `${settings.config.build.assets}/${sanitizedName}.[hash][extname]`;
+                }
+                return `${settings.config.build.assets}/[name].[hash][extname]`;
+              },
+              ...viteConfig.environments?.client?.build?.rolldownOptions?.output
+            }
+          }
+        }
+      },
+      [ASTRO_VITE_ENVIRONMENT_NAMES.ssr]: {
+        build: {
+          outDir: fileURLToPath(getServerOutputDirectory(settings)),
+          rolldownOptions: {
+            output: {
+              ...viteConfig.environments?.ssr?.build?.rolldownOptions?.output
+            }
+          }
+        }
+      }
+    }
+  };
+}
+export {
+  createViteBuildConfig
+};