astro 7.0.0-alpha.1 → 7.0.0-alpha.2

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,76 +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(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 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)
@@ -232,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]
@@ -251,76 +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(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
-            }
-          }
-        }
-      }
-    }
-  };
+    isRolldownInput
+  });
   const updatedViteBuildConfig = await runHookBuildSetup({
     config: settings.config,
     pages: internals.pagesByKeys,
@@ -369,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);
@@ -435,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
+};

package/dist/core/config/merge.js

@@ -38,6 +38,10 @@ function mergeConfigRecursively(defaults, overrides, rootPath) {
       merged[key] = value;
       continue;
     }
+    if (key === "processor" && rootPath === "markdown" && isObject(value) && typeof value.createRenderer === "function") {
+      merged[key] = value;
+      continue;
+    }
     if (isObject(existing) && isObject(value)) {
       merged[key] = mergeConfigRecursively(existing, value, rootPath ? `${rootPath}.${key}` : key);
       continue;

package/dist/core/config/schemas/base.d.ts

@@ -1,4 +1,4 @@
-import type { RehypePlugin as _RehypePlugin, RemarkPlugin as _RemarkPlugin, RemarkRehype as _RemarkRehype, Smartypants as _Smartypants, ShikiConfig } from '@astrojs/markdown-remark';
+import type { RehypePlugin as _RehypePlugin, RemarkPlugin as _RemarkPlugin, RemarkRehype as _RemarkRehype, Smartypants as _Smartypants, ShikiConfig } from '@astrojs/internal-helpers/markdown';
 import type { OutgoingHttpHeaders } from 'node:http';
 import * as z from 'zod/v4';
 import type { ViteUserConfig } from '../../../types/public/config.js';
@@ -57,7 +57,7 @@ export declare const ASTRO_CONFIG_DEFAULTS: {
         allowedHosts: never[];
     };
     integrations: never[];
-    markdown: Required<import("@astrojs/markdown-remark").AstroMarkdownOptions>;
+    markdown: Required<Omit<import("@astrojs/markdown-remark").AstroMarkdownOptions, "image">>;
     vite: {};
     legacy: {
         collectionsBackwardsCompat: false;
@@ -120,8 +120,8 @@ export declare const AstroConfigSchema: z.ZodObject<{
         redirects: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         inlineStylesheets: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
             never: "never";
-            auto: "auto";
             always: "always";
+            auto: "auto";
         }>>>;
         concurrency: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     }, z.core.$strip>>;
@@ -139,10 +139,10 @@ export declare const AstroConfigSchema: z.ZodObject<{
     prefetch: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
         prefetchAll: z.ZodOptional<z.ZodBoolean>;
         defaultStrategy: z.ZodOptional<z.ZodEnum<{
-            load: "load";
             tap: "tap";
             hover: "hover";
             viewport: "viewport";
+            load: "load";
         }>>;
     }, z.core.$strip>]>>;
     image: z.ZodPrefault<z.ZodObject<{
@@ -164,9 +164,9 @@ export declare const AstroConfigSchema: z.ZodObject<{
         }, z.core.$strip>>>;
         layout: z.ZodOptional<z.ZodEnum<{
             fixed: "fixed";
-            none: "none";
             constrained: "constrained";
             "full-width": "full-width";
+            none: "none";
         }>>;
         objectFit: z.ZodOptional<z.ZodString>;
         objectPosition: z.ZodOptional<z.ZodString>;
@@ -330,8 +330,14 @@ export declare const AstroConfigSchema: z.ZodObject<{
         remarkPlugins: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodTuple<[z.ZodString, z.ZodAny], null>, z.ZodCustom<RemarkPlugin, RemarkPlugin>, z.ZodTuple<[z.ZodCustom<RemarkPlugin, RemarkPlugin>, z.ZodAny], null>]>>>;
         rehypePlugins: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodTuple<[z.ZodString, z.ZodAny], null>, z.ZodCustom<RehypePlugin, RehypePlugin>, z.ZodTuple<[z.ZodCustom<RehypePlugin, RehypePlugin>, z.ZodAny], null>]>>>;
         remarkRehype: z.ZodDefault<z.ZodCustom<RemarkRehype, RemarkRehype>>;
-        gfm: z.ZodDefault<z.ZodBoolean>;
-        smartypants: z.ZodPrefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodType<Smartypants, unknown, z.core.$ZodTypeInternals<Smartypants, unknown>>]>, z.ZodTransform<false | Smartypants, boolean | Smartypants>>>;
+        gfm: z.ZodOptional<z.ZodBoolean>;
+        smartypants: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodType<Smartypants, unknown, z.core.$ZodTypeInternals<Smartypants, unknown>>]>, z.ZodTransform<false | Smartypants, boolean | Smartypants>>>;
+        processor: z.ZodDefault<z.ZodObject<{
+            name: z.ZodString;
+            options: z.ZodDefault<z.ZodCustom<object, object>>;
+            createRenderer: z.ZodCustom<(shared: import("@astrojs/markdown-remark").AstroMarkdownOptions) => Promise<import("@astrojs/markdown-remark").MarkdownRenderer>, (shared: import("@astrojs/markdown-remark").AstroMarkdownOptions) => Promise<import("@astrojs/markdown-remark").MarkdownRenderer>>;
+            createMdxRenderer: z.ZodOptional<z.ZodCustom<((shared: import("@astrojs/markdown-remark").AstroMarkdownOptions, mdx: import("@astrojs/internal-helpers/markdown").MdxRendererOptions) => Promise<import("@astrojs/internal-helpers/markdown").MdxRenderer>) | undefined, ((shared: import("@astrojs/markdown-remark").AstroMarkdownOptions, mdx: import("@astrojs/internal-helpers/markdown").MdxRendererOptions) => Promise<import("@astrojs/internal-helpers/markdown").MdxRenderer>) | undefined>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     vite: z.ZodDefault<z.ZodCustom<ViteUserConfig, ViteUserConfig>>;
     i18n: z.ZodOptional<z.ZodOptional<z.ZodObject<{
@@ -441,9 +447,9 @@ export declare const AstroConfigSchema: z.ZodObject<{
             path: z.ZodOptional<z.ZodString>;
             maxAge: z.ZodOptional<z.ZodNumber>;
             sameSite: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+                none: "none";
                 strict: "strict";
                 lax: "lax";
-                none: "none";
             }>, z.ZodBoolean]>>;
             secure: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>, z.ZodPipe<z.ZodString, z.ZodTransform<{
@@ -487,11 +493,11 @@ export declare const AstroConfigSchema: z.ZodObject<{
         fallbacks: z.ZodOptional<z.ZodArray<z.ZodString>>;
         optimizedFallbacks: z.ZodOptional<z.ZodBoolean>;
         display: z.ZodOptional<z.ZodEnum<{
-            optional: "optional";
             auto: "auto";
+            optional: "optional";
+            fallback: "fallback";
             block: "block";
             swap: "swap";
-            fallback: "fallback";
         }>>;
         stretch: z.ZodOptional<z.ZodString>;
         featureSettings: z.ZodOptional<z.ZodString>;
@@ -500,7 +506,9 @@ export declare const AstroConfigSchema: z.ZodObject<{
         options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     }, z.core.$strict>>>;
     experimental: z.ZodPrefault<z.ZodObject<{
-        advancedRouting: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        advancedRouting: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+            fetchFile: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+        }, z.core.$strict>]>>>;
         clientPrerender: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         contentIntellisense: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         chromeDevtoolsWorkspace: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;

package/dist/core/config/schemas/base.js

@@ -1,4 +1,8 @@
-import { markdownConfigDefaults, syntaxHighlightDefaults } from "@astrojs/markdown-remark";
+import {
+  markdownConfigDefaults,
+  syntaxHighlightDefaults
+} from "@astrojs/internal-helpers/markdown";
+import { unified } from "@astrojs/markdown-remark";
 import { bundledThemes } from "shiki";
 import * as z from "zod/v4";
 import { FontFamilySchema } from "../../../assets/fonts/config.js";
@@ -238,11 +242,27 @@ const AstroConfigSchema = z.object({
       z.tuple([z.custom((data) => typeof data === "function"), z.any()])
     ]).array().default(ASTRO_CONFIG_DEFAULTS.markdown.rehypePlugins),
     remarkRehype: z.custom((data) => data instanceof Object && !Array.isArray(data)).default(ASTRO_CONFIG_DEFAULTS.markdown.remarkRehype),
-    gfm: z.boolean().default(ASTRO_CONFIG_DEFAULTS.markdown.gfm),
+    // Deprecated: left undefined unless the user explicitly sets them, so the
+    // deprecation warning only fires when actually used. The active processor
+    // (`unified()`) supplies the real default (`gfm`/smart punctuation on) when
+    // these are absent.
+    gfm: z.boolean().optional(),
     smartypants: z.union([z.boolean(), smartypantsOptionsSchema]).transform((val) => {
       if (val === true) return smartypantsOptionsSchema.parse({});
       return val;
-    }).prefault(ASTRO_CONFIG_DEFAULTS.markdown.smartypants)
+    }).optional(),
+    processor: z.object({
+      name: z.string(),
+      // `z.custom` preserves reference identity; `z.record` would clone, breaking
+      // the closure inside `createRenderer` that reads `processor.options.*`.
+      options: z.custom((v) => typeof v === "object" && v !== null && !Array.isArray(v)).default(() => ({})),
+      createRenderer: z.custom(
+        (v) => typeof v === "function"
+      ),
+      createMdxRenderer: z.custom(
+        (v) => v === void 0 || typeof v === "function"
+      ).optional()
+    }).default(() => unified())
   }).prefault({}),
   vite: z.custom((data) => data instanceof Object && !Array.isArray(data)).default(ASTRO_CONFIG_DEFAULTS.vite),
   i18n: z.optional(
@@ -309,7 +329,12 @@ const AstroConfigSchema = z.object({
   prerenderConflictBehavior: z.enum(["error", "warn", "ignore"]).optional().default(ASTRO_CONFIG_DEFAULTS.prerenderConflictBehavior),
   fonts: z.array(FontFamilySchema).optional(),
   experimental: z.strictObject({
-    advancedRouting: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.advancedRouting),
+    advancedRouting: z.union([
+      z.boolean(),
+      z.strictObject({
+        fetchFile: z.string().nullable().optional().default("app")
+      })
+    ]).optional().default(ASTRO_CONFIG_DEFAULTS.experimental.advancedRouting),
     clientPrerender: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.clientPrerender),
     contentIntellisense: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.contentIntellisense),
     chromeDevtoolsWorkspace: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.chromeDevtoolsWorkspace),