astro 6.3.7 → 6.4.0

package/components/Code.astro

@@ -1,5 +1,5 @@
 ---
-import { createShikiHighlighter, type ThemePresets } from '@astrojs/markdown-remark/shiki';
+import { createShikiHighlighter, type ThemePresets } from '@astrojs/internal-helpers/shiki';
 import type { ShikiTransformer, ThemeRegistration, ThemeRegistrationRaw } from 'shiki';
 import { bundledLanguages } from 'shiki/langs';
 import type { CodeLanguage } from '../dist/types/public/common.js';

package/dist/assets/fonts/config.d.ts

@@ -7,11 +7,11 @@ export declare const StyleSchema: z.ZodEnum<{
     oblique: "oblique";
 }>;
 export declare const DisplaySchema: z.ZodEnum<{
-    optional: "optional";
     auto: "auto";
+    optional: "optional";
+    fallback: "fallback";
     block: "block";
     swap: "swap";
-    fallback: "fallback";
 }>;
 export declare const FontProviderSchema: z.ZodCustom<FontProvider<never>, FontProvider<never>>;
 export declare const FontFamilySchema: z.ZodObject<{
@@ -45,11 +45,11 @@ export declare const FontFamilySchema: 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>;

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

package/dist/content/content-layer.js

@@ -1,8 +1,5 @@
 import { existsSync, promises as fs } from "node:fs";
-import {
-  createMarkdownProcessor,
-  parseFrontmatter
-} from "@astrojs/markdown-remark";
+import { parseFrontmatter } from "@astrojs/internal-helpers/frontmatter";
 import PQueue from "p-queue";
 import xxhash from "xxhash-wasm";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
@@ -28,7 +25,7 @@ class ContentLayer {
   #watcher;
   #lastConfigDigest;
   #unsubscribe;
-  #markdownProcessor;
+  #markdownRenderer;
   #generateDigest;
   #contentConfigObserver;
   #queue;
@@ -108,9 +105,18 @@ class ContentLayer {
     };
   }
   async #processMarkdown(content, options) {
-    this.#markdownProcessor ??= await createMarkdownProcessor(this.#settings.config.markdown);
+    if (!this.#markdownRenderer) {
+      const { markdown, image } = this.#settings.config;
+      this.#markdownRenderer = await markdown.processor.createRenderer({
+        image,
+        syntaxHighlight: markdown.syntaxHighlight,
+        shikiConfig: markdown.shikiConfig,
+        gfm: markdown.gfm,
+        smartypants: markdown.smartypants
+      });
+    }
     const { frontmatter, content: body } = parseFrontmatter(content);
-    const { code, metadata } = await this.#markdownProcessor.render(body, {
+    const { code, metadata } = await this.#markdownRenderer.render(body, {
       frontmatter,
       fileURL: options?.fileURL
     });
@@ -191,7 +197,7 @@ ${contentConfig.error.message}`
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "6.3.7") {
+    if (previousAstroVersion && previousAstroVersion !== "6.4.0") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -199,8 +205,8 @@ ${contentConfig.error.message}`
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("6.3.7") {
-      this.#store.metaStore().set("astro-version", "6.3.7");
+    if ("6.4.0") {
+      this.#store.metaStore().set("astro-version", "6.4.0");
     }
     if (currentConfigDigest) {
       this.#store.metaStore().set("content-config-digest", currentConfigDigest);

package/dist/content/data-store.d.ts

@@ -1,4 +1,4 @@
-import type { MarkdownHeading } from '@astrojs/markdown-remark';
+import type { MarkdownHeading } from '@astrojs/internal-helpers/markdown';
 export interface RenderedContent {
     /** Rendered HTML string. If present then `render(entry)` will return a component that renders this HTML. */
     html: string;

package/dist/content/runtime-assets.d.ts

@@ -2,10 +2,10 @@ import type { PluginContext } from 'rollup';
 import * as z from 'zod/v4';
 export declare function createImage(pluginContext: PluginContext, shouldEmitFile: boolean, entryFilePath: string): () => z.ZodPipe<z.ZodString, z.ZodTransform<z.ZodNever | {
     ASTRO_ASSET: string;
-    format: import("../assets/types.js").ImageInputFormat;
-    src: string;
     width: number;
     height: number;
+    format: import("../assets/types.js").ImageInputFormat;
+    src: string;
     fsPath: string;
     orientation?: number | undefined;
 }, string>>;

package/dist/content/runtime.d.ts

@@ -1,4 +1,4 @@
-import type { MarkdownHeading } from '@astrojs/markdown-remark';
+import type { MarkdownHeading } from '@astrojs/internal-helpers/markdown';
 import * as z from 'zod/v4';
 import type * as zCore from 'zod/v4/core';
 import type { ImageMetadata } from '../assets/types.js';

package/dist/content/runtime.js

@@ -322,7 +322,9 @@ async function updateImageReferencesInBody(html, fileName) {
   const { getImage } = await import("virtual:astro:get-image");
   for (const [_full, imagePath] of html.matchAll(CONTENT_LAYER_IMAGE_REGEX)) {
     try {
-      const decodedImagePath = JSON.parse(imagePath.replaceAll(""", '"'));
+      const decodedImagePath = JSON.parse(
+        imagePath.replace(/&(?:#x22|quot);/g, '"').replace(/&(?:#x27|apos);/g, "'")
+      );
       let image;
       if (URL.canParse(decodedImagePath.src)) {
         image = await getImage(decodedImagePath);

package/dist/content/utils.d.ts

@@ -125,7 +125,7 @@ export declare function getContentEntryIdAndSlug({ entry, contentDir, collection
     slug: string;
 };
 export declare function getEntryType(entryPath: string, paths: Pick<ContentPaths, 'config' | 'contentDir' | 'root'>, contentFileExts: string[], dataFileExts: string[]): 'content' | 'data' | 'config' | 'ignored';
-export declare function safeParseFrontmatter(source: string, id?: string): import("@astrojs/markdown-remark").ParseFrontmatterResult;
+export declare function safeParseFrontmatter(source: string, id?: string): import("@astrojs/internal-helpers/frontmatter").ParseFrontmatterResult;
 /**
  * The content config is loaded separately from other `src/` files.
  * This global observable lets dependent plugins (like the content flag plugin)

package/dist/content/utils.js

@@ -1,7 +1,7 @@
 import fsMod from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { parseFrontmatter } from "@astrojs/markdown-remark";
+import { parseFrontmatter } from "@astrojs/internal-helpers/frontmatter";
 import { slug as githubSlug } from "github-slugger";
 import colors from "piccolore";
 import xxhash from "xxhash-wasm";

package/dist/core/app/entrypoints/node.d.ts

@@ -1 +1 @@
-export { NodeApp, loadApp, loadManifest, createRequest, writeResponse, getAbortControllerCleanup, } from '../node.js';
+export { NodeApp, loadApp, loadManifest, createRequest, createRequestFromNodeRequest, writeResponse, getAbortControllerCleanup, } from '../node.js';

package/dist/core/app/entrypoints/node.js

@@ -3,12 +3,14 @@ import {
   loadApp,
   loadManifest,
   createRequest,
+  createRequestFromNodeRequest,
   writeResponse,
   getAbortControllerCleanup
 } from "../node.js";
 export {
   NodeApp,
   createRequest,
+  createRequestFromNodeRequest,
   getAbortControllerCleanup,
   loadApp,
   loadManifest,

package/dist/core/app/node.d.ts

@@ -25,6 +25,22 @@ interface NodeRequest extends IncomingMessage {
  * })
  * ```
  */
+/**
+ * Internal version of `createRequest` that skips X-Forwarded-* header
+ * validation. Forwarded headers are resolved later inside `FetchState`,
+ * so doing it here too would duplicate work on every request.
+ *
+ * Use this for all internal call sites that go through `app.render()`
+ * (which creates a `FetchState`). The public `createRequest` keeps the
+ * forwarded header logic for external adapters that may not use
+ * `FetchState`.
+ */
+export declare function createRequestFromNodeRequest(req: NodeRequest, { skipBody, allowedDomains, bodySizeLimit, port: serverPort, }?: {
+    skipBody?: boolean;
+    allowedDomains?: Partial<RemotePattern>[];
+    bodySizeLimit?: number;
+    port?: number;
+}): Request;
 export declare function createRequest(req: NodeRequest, { skipBody, allowedDomains, bodySizeLimit, port: serverPort, }?: {
     skipBody?: boolean;
     allowedDomains?: Partial<RemotePattern>[];

package/dist/core/app/node.js

@@ -9,6 +9,48 @@ import {
   validateForwardedHeaders,
   validateHost
 } from "./validate-headers.js";
+function createRequestFromNodeRequest(req, {
+  skipBody = false,
+  allowedDomains = [],
+  bodySizeLimit,
+  port: serverPort
+} = {}) {
+  const controller = new AbortController();
+  const isEncrypted = "encrypted" in req.socket && req.socket.encrypted;
+  const protocol = isEncrypted ? "https" : "http";
+  const hostname = typeof req.headers.host === "string" ? req.headers.host : typeof req.headers[":authority"] === "string" ? req.headers[":authority"] : serverPort ? `localhost:${serverPort}` : "localhost";
+  let url;
+  try {
+    url = new URL(`${protocol}://${hostname}${req.url}`);
+  } catch {
+    url = new URL(`${protocol}://${hostname}`);
+  }
+  const options = {
+    method: req.method || "GET",
+    headers: makeRequestHeaders(req),
+    signal: controller.signal
+  };
+  const bodyAllowed = options.method !== "HEAD" && options.method !== "GET" && skipBody === false;
+  if (bodyAllowed) {
+    Object.assign(options, makeRequestBody(req, bodySizeLimit));
+  }
+  const request = new Request(url, options);
+  wireAbortController(req, controller);
+  const untrustedHostname = req.headers.host ?? req.headers[":authority"];
+  const validatedHostname = validateHost(
+    typeof untrustedHostname === "string" ? untrustedHostname : void 0,
+    protocol,
+    allowedDomains
+  );
+  const forwardedHost = getFirstForwardedValue(req.headers["x-forwarded-host"]);
+  const hostValidated = validatedHostname !== void 0 || forwardedHost !== void 0 && allowedDomains.length > 0;
+  const forwardedClientIp = hostValidated ? getFirstForwardedValue(req.headers["x-forwarded-for"]) : void 0;
+  const clientIp = forwardedClientIp || req.socket?.remoteAddress;
+  if (clientIp) {
+    Reflect.set(request, clientAddressSymbol, clientIp);
+  }
+  return request;
+}
 function createRequest(req, {
   skipBody = false,
   allowedDomains = [],
@@ -51,6 +93,16 @@ function createRequest(req, {
     Object.assign(options, makeRequestBody(req, bodySizeLimit));
   }
   const request = new Request(url, options);
+  wireAbortController(req, controller);
+  const hostValidated = validated.host !== void 0 || validatedHostname !== void 0;
+  const forwardedClientIp = hostValidated ? getFirstForwardedValue(req.headers["x-forwarded-for"]) : void 0;
+  const clientIp = forwardedClientIp || req.socket?.remoteAddress;
+  if (clientIp) {
+    Reflect.set(request, clientAddressSymbol, clientIp);
+  }
+  return request;
+}
+function wireAbortController(req, controller) {
   const socket = getRequestSocket(req);
   if (socket && typeof socket.on === "function") {
     const existingCleanup = getAbortControllerCleanup(req);
@@ -85,13 +137,6 @@ function createRequest(req, {
       onSocketClose();
     }
   }
-  const hostValidated = validated.host !== void 0 || validatedHostname !== void 0;
-  const forwardedClientIp = hostValidated ? getFirstForwardedValue(req.headers["x-forwarded-for"]) : void 0;
-  const clientIp = forwardedClientIp || req.socket?.remoteAddress;
-  if (clientIp) {
-    Reflect.set(request, clientAddressSymbol, clientIp);
-  }
-  return request;
 }
 async function writeResponse(source, destination) {
   const { status, headers, body, statusText } = source;
@@ -147,18 +192,15 @@ class NodeApp extends App {
   }
   match(req, allowPrerenderedRoutes = false) {
     if (!(req instanceof Request)) {
-      req = createRequest(req, {
-        skipBody: true,
-        allowedDomains: this.manifest.allowedDomains
+      req = createRequestFromNodeRequest(req, {
+        skipBody: true
       });
     }
     return super.match(req, allowPrerenderedRoutes);
   }
   render(request, options) {
     if (!(request instanceof Request)) {
-      request = createRequest(request, {
-        allowedDomains: this.manifest.allowedDomains
-      });
+      request = createRequestFromNodeRequest(request);
     }
     return super.render(request, options);
   }
@@ -283,6 +325,7 @@ async function loadApp(rootFolder) {
 export {
   NodeApp,
   createRequest,
+  createRequestFromNodeRequest,
   getAbortControllerCleanup,
   loadApp,
   loadManifest,

package/dist/core/base-pipeline.js

@@ -182,7 +182,8 @@ class Pipeline {
     if (this.resolvedActions) {
       return this.resolvedActions;
     } else if (this.actions) {
-      return this.actions();
+      this.resolvedActions = await this.actions();
+      return this.resolvedActions;
     }
     return NOOP_ACTIONS_MOD;
   }

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

@@ -12,25 +12,24 @@ 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) => imp.n && /^\.\.?\//.test(imp.n) && /\.(?:js|mjs)$/.test(imp.n)
+        );
+        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

@@ -46,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;
@@ -76,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];
               }
             }
@@ -157,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);
+                    }
+                  }
+                }
               }
             }
           }
@@ -191,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/static-build.js

@@ -10,10 +10,9 @@ 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 { getPrerenderOutputDirectory } from "../../prerender/utils.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 { generatePages } from "./generate.js";
 import { trackPageData } from "./internal.js";
 import { getAllBuildPlugins } from "./plugins/index.js";
@@ -23,7 +22,10 @@ import { getTimeStat, viteBuildReturnToRollupOutputs } 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) {
@@ -155,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]
@@ -231,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);
@@ -297,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/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;
@@ -121,8 +121,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>>;
@@ -140,10 +140,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<{
@@ -165,9 +165,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>;
@@ -331,8 +331,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<{
@@ -442,9 +448,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<{
@@ -488,11 +494,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>;