astro 6.2.1 → 7.0.0-alpha.0

package/dist/assets/utils/assets.d.ts

@@ -1,6 +1,5 @@
-import type { Environment, Rollup } from 'vite';
-type PluginContext = Rollup.PluginContext;
-type EmitFileOptions = Parameters<Rollup.PluginContext['emitFile']>[0];
+import type { Environment, Rolldown } from 'vite';
+type EmitFileOptions = Parameters<Rolldown.PluginContext['emitFile']>[0];
 /**
  * Gets or creates the handle set for an environment
  */
@@ -15,9 +14,9 @@ export declare function resetHandles(env: Environment): void;
  * Use this instead of pluginContext.emitFile for assets that should
  * be moved from the server/prerender directory to the client directory.
  *
- * Note: The pluginContext is typed as Rollup.PluginContext for compatibility
+ * Note: The pluginContext is typed as Rolldown.PluginContext for compatibility
  * with content entry types, but in practice it will always have the `environment`
  * property when running in Vite.
  */
-export declare function emitClientAsset(pluginContext: PluginContext, options: EmitFileOptions): string;
+export declare function emitClientAsset(pluginContext: Rolldown.PluginContext, options: EmitFileOptions): string;
 export {};

package/dist/assets/utils/node.d.ts

@@ -1,7 +1,7 @@
-import type * as vite from 'vite';
+import type { Rolldown } from 'vite';
 import type { ImageMetadata } from '../types.js';
 export { hashTransform, propsToFilename } from './hash.js';
-type FileEmitter = vite.Rollup.EmitFile;
+type FileEmitter = (opts: Parameters<Rolldown.PluginContext['emitFile']>[0]) => string;
 type ImageMetadataWithContents = ImageMetadata & {
     contents?: Buffer;
 };

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

@@ -278,7 +278,7 @@ function assets({ fs, settings, sync, logger }) {
             });
           }
           if (isAstroServerEnvironment(this.environment)) {
-            if (id.endsWith(".svg") && !isContentImage) {
+            if (id.endsWith(".svg")) {
               const contents = await fs.promises.readFile(imageMetadata.fsPath, {
                 encoding: "utf8"
               });

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.2.1";
+  version = "7.0.0-alpha.0";
 }
 export {
   BuildTimeAstroVersionProvider

package/dist/content/content-layer.js

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

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

@@ -1,6 +1,6 @@
-import type { PluginContext } from 'rollup';
+import type { Rolldown } from 'vite';
 import * as z from 'zod/v4';
-export declare function createImage(pluginContext: PluginContext, shouldEmitFile: boolean, entryFilePath: string): () => z.ZodPipe<z.ZodString, z.ZodTransform<z.ZodNever | {
+export declare function createImage(pluginContext: Rolldown.PluginContext, shouldEmitFile: boolean, entryFilePath: string): () => z.ZodPipe<z.ZodString, z.ZodTransform<z.ZodNever | {
     ASTRO_ASSET: string;
     format: import("../assets/types.js").ImageInputFormat;
     src: string;

package/dist/content/utils.d.ts

@@ -1,6 +1,5 @@
 import fsMod from 'node:fs';
-import type { PluginContext } from 'rollup';
-import type { RunnableDevEnvironment } from 'vite';
+import type { RunnableDevEnvironment, Rolldown } from 'vite';
 import * as z from 'zod/v4';
 import type { AstroLogger } from '../core/logger/core.js';
 import type { AstroSettings } from '../types/astro.js';
@@ -96,7 +95,7 @@ export declare function getEntryData<TInputData extends Record<string, unknown>
     collection: string;
     unvalidatedData: TInputData;
     _internal: EntryInternal;
-}, collectionConfig: CollectionConfig, shouldEmitFile: boolean, pluginContext?: PluginContext): Promise<TOutputData>;
+}, collectionConfig: CollectionConfig, shouldEmitFile: boolean, pluginContext?: Rolldown.PluginContext): Promise<TOutputData>;
 export declare function getContentEntryExts(settings: Pick<AstroSettings, 'contentEntryTypes'>): string[];
 export declare function getDataEntryExts(settings: Pick<AstroSettings, 'dataEntryTypes'>): string[];
 export declare function getEntryConfigByExtMap<TEntryType extends ContentEntryType | DataEntryType>(entryTypes: TEntryType[]): Map<string, TEntryType>;

package/dist/core/build/add-rolldown-input.d.ts

@@ -0,0 +1,2 @@
+import type { Rolldown } from 'vite';
+export declare function addRolldownInput(inputOptions: Rolldown.InputOptions, newInputs: string[]): Rolldown.InputOptions;

package/dist/core/build/{add-rollup-input.js → add-rolldown-input.js}

@@ -5,7 +5,7 @@ function fromEntries(entries) {
   }
   return obj;
 }
-function addRollupInput(inputOptions, newInputs) {
+function addRolldownInput(inputOptions, newInputs) {
   if (!inputOptions.input) {
     return { ...inputOptions, input: newInputs };
   }
@@ -30,8 +30,8 @@ function addRollupInput(inputOptions, newInputs) {
       }
     };
   }
-  throw new Error(`Unknown rollup input type. Supported inputs are string, array and object.`);
+  throw new Error(`Unknown rolldown input type. Supported inputs are string, array and object.`);
 }
 export {
-  addRollupInput
+  addRolldownInput
 };

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

@@ -1,17 +1,17 @@
-import type { GetModuleInfo, ModuleInfo } from 'rollup';
+import type { Rolldown } from 'vite';
 interface ExtendedModuleInfo {
-    info: ModuleInfo;
+    info: Rolldown.ModuleInfo;
     depth: number;
     order: number;
 }
 export declare function getParentExtendedModuleInfos(id: string, ctx: {
-    getModuleInfo: GetModuleInfo;
+    getModuleInfo: Rolldown.GetModuleInfo;
 }, until?: (importer: string) => boolean, depth?: number, order?: number, childId?: string, seen?: Set<string>, accumulated?: ExtendedModuleInfo[]): ExtendedModuleInfo[];
 export declare function getParentModuleInfos(id: string, ctx: {
-    getModuleInfo: GetModuleInfo;
-}, until?: (importer: string) => boolean, seen?: Set<string>, accumulated?: ModuleInfo[]): ModuleInfo[];
-export declare function moduleIsTopLevelPage(info: ModuleInfo): boolean;
+    getModuleInfo: Rolldown.GetModuleInfo;
+}, until?: (importer: string) => boolean, seen?: Set<string>, accumulated?: Rolldown.ModuleInfo[]): Rolldown.ModuleInfo[];
+export declare function moduleIsTopLevelPage(info: Rolldown.ModuleInfo): boolean;
 export declare function getTopLevelPageModuleInfos(id: string, ctx: {
-    getModuleInfo: GetModuleInfo;
-}): ModuleInfo[];
+    getModuleInfo: Rolldown.GetModuleInfo;
+}): Rolldown.ModuleInfo[];
 export {};

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

@@ -8,7 +8,7 @@ import {
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../../constants.js";
 function pluginAnalyzer(internals) {
   return {
-    name: "@astro/rollup-plugin-astro-analyzer",
+    name: "@astro/rolldown-plugin-astro-analyzer",
     applyToEnvironment(environment) {
       return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender;
     },

package/dist/core/build/plugins/plugin-component-entry.d.ts

@@ -1,7 +1,7 @@
 import type { Plugin as VitePlugin } from 'vite';
 import type { BuildInternals } from '../internal.js';
 /**
- * When adding hydrated or client:only components as Rollup inputs, sometimes we're not using all
+ * When adding hydrated or client:only components as Rolldown inputs, sometimes we're not using all
  * of the export names, e.g. `import { Counter } from './ManyComponents.jsx'`. This plugin proxies
  * entries to re-export only the names that the user is using.
  */

package/dist/core/build/plugins/plugin-component-entry.js

@@ -27,9 +27,9 @@ function pluginComponentEntry(internals) {
       return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.client;
     },
     config(config) {
-      const rollupInput = config.build?.rollupOptions?.input;
-      if (Array.isArray(rollupInput)) {
-        config.build.rollupOptions.input = rollupInput.map((id) => {
+      const rolldownInput = config.build?.rolldownOptions?.input;
+      if (Array.isArray(rolldownInput)) {
+        config.build.rolldownOptions.input = rolldownInput.map((id) => {
           if (componentToExportNames.has(id)) {
             return astroEntryPrefix + id;
           } else {

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

@@ -21,7 +21,7 @@ function pluginInternals(options, internals) {
       if (environmentName === ASTRO_VITE_ENVIRONMENT_NAMES.prerender) {
         return {
           build: {
-            rollupOptions: {
+            rolldownOptions: {
               // These packages as they're not bundle-friendly. Users with strict package installations
               // need to manually install these themselves if they use the related features.
               external: [

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

@@ -1,7 +1,7 @@
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../../constants.js";
 function pluginPrerender(_opts, internals) {
   return {
-    name: "astro:rollup-plugin-prerender",
+    name: "astro:rolldown-plugin-prerender",
     applyToEnvironment(environment) {
       return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr;
     },

package/dist/core/build/static-build.d.ts

@@ -2,8 +2,8 @@ import { type BuildInternals } from '../../core/build/internal.js';
 import type { RouteData } from '../../types/public/internal.js';
 import type { StaticBuildOptions } from './types.js';
 /**
- * Minimal chunk data extracted from RollupOutput for deferred manifest/content injection.
- * Allows releasing full RollupOutput objects early to reduce memory usage.
+ * Minimal chunk data extracted from RolldownOutput for deferred manifest/content injection.
+ * Allows releasing full RolldownOutput objects early to reduce memory usage.
  */
 export interface ExtractedChunk {
     fileName: string;

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

@@ -30,7 +30,7 @@ import {
   RESOLVED_LEGACY_SSR_ENTRY_VIRTUAL_MODULE
 } from "./plugins/plugin-ssr.js";
 import { ASTRO_PAGE_EXTENSION_POST_PATTERN } from "./plugins/util.js";
-import { cleanChunkName, getTimeStat, viteBuildReturnToRollupOutputs } from "./util.js";
+import { cleanChunkName, 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";
@@ -87,25 +87,25 @@ async function buildEnvironments(opts, internals) {
   const buildPlugins = getAllBuildPlugins(internals, opts);
   const flatPlugins = buildPlugins.flat().filter(Boolean);
   const plugins = [...flatPlugins, ...viteConfig.plugins || []];
-  let currentRollupInput = void 0;
+  let currentRolldownInput = 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
+    // When the rolldown input is safe to update, we normalize it to always be an object
     // so we can reliably identify which entrypoint corresponds to the adapter
     enforce: "post",
     config(config) {
-      if (typeof config.build?.rollupOptions?.input === "string") {
-        config.build.rollupOptions.input = { index: config.build.rollupOptions.input };
-      } else if (Array.isArray(config.build?.rollupOptions?.input)) {
-        config.build.rollupOptions.input = Object.fromEntries(
-          config.build.rollupOptions.input.map((v, i) => [`index_${i}`, v])
+      if (typeof config.build?.rolldownOptions?.input === "string") {
+        config.build.rolldownOptions.input = { index: config.build.rolldownOptions.input };
+      } else if (Array.isArray(config.build?.rolldownOptions?.input)) {
+        config.build.rolldownOptions.input = Object.fromEntries(
+          config.build.rolldownOptions.input.map((v, i) => [`index_${i}`, v])
         );
       }
     },
-    // We save the rollup input to be able to check later on
+    // We save the rolldown input to be able to check later on
     configResolved(config) {
-      currentRollupInput = config.build.rollupOptions.input;
+      currentRolldownInput = config.build.rolldownOptions.input;
     }
   });
   plugins.push({
@@ -137,16 +137,16 @@ async function buildEnvironments(opts, internals) {
       }
     }
   });
-  function isRollupInput(moduleName) {
-    if (!currentRollupInput || !moduleName) {
+  function isRolldownInput(moduleName) {
+    if (!currentRolldownInput || !moduleName) {
       return false;
     }
-    if (typeof currentRollupInput === "string") {
-      return currentRollupInput === moduleName;
-    } else if (Array.isArray(currentRollupInput)) {
-      return currentRollupInput.includes(moduleName);
+    if (typeof currentRolldownInput === "string") {
+      return currentRolldownInput === moduleName;
+    } else if (Array.isArray(currentRolldownInput)) {
+      return currentRolldownInput.includes(moduleName);
     } else {
-      return Object.keys(currentRollupInput).includes(moduleName);
+      return Object.keys(currentRolldownInput).includes(moduleName);
     }
   }
   const viteBuildConfig = {
@@ -161,8 +161,8 @@ async function buildEnvironments(opts, internals) {
       emptyOutDir: false,
       copyPublicDir: false,
       manifest: false,
-      rollupOptions: {
-        ...viteConfig.build?.rollupOptions,
+      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 } : {},
@@ -187,7 +187,7 @@ async function buildEnvironments(opts, internals) {
             return [prefix, cleanChunkName(name), suffix].join("");
           },
           assetFileNames: `${settings.config.build.assets}/[name].[hash][extname]`,
-          ...viteConfig.build?.rollupOptions?.output,
+          ...viteConfig.build?.rolldownOptions?.output,
           entryFileNames(chunkInfo) {
             if (chunkInfo.facadeModuleId?.startsWith(VIRTUAL_PAGE_RESOLVED_MODULE_ID)) {
               return makeAstroPageEntryPointFileName(
@@ -196,8 +196,8 @@ async function buildEnvironments(opts, internals) {
                 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 rollupOptions.input or Astro sets it from `serverEntrypoint`.
-            isRollupInput(chunkInfo.name) || isRollupInput(chunkInfo.facadeModuleId)) {
+            // 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";
@@ -221,7 +221,7 @@ async function buildEnvironments(opts, internals) {
         let prerenderOutput = await builder2.build(builder2.environments.prerender);
         settings.timer.end("Prerender build");
         extractPrerenderEntryFileName(internals, prerenderOutput);
-        const prerenderOutputs = viteBuildReturnToRollupOutputs(prerenderOutput);
+        const prerenderOutputs = viteBuildReturnToRolldownOutputs(prerenderOutput);
         const prerenderChunks = extractRelevantChunks(prerenderOutputs, true);
         prerenderOutput = void 0;
         let ssrChunks = [];
@@ -231,7 +231,7 @@ async function buildEnvironments(opts, internals) {
             builder2.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr]
           );
           settings.timer.end("SSR build");
-          const ssrOutputs = viteBuildReturnToRollupOutputs(ssrOutput);
+          const ssrOutputs = viteBuildReturnToRolldownOutputs(ssrOutput);
           ssrChunks = extractRelevantChunks(ssrOutputs, false);
           ssrOutput = void 0;
         }
@@ -259,14 +259,14 @@ async function buildEnvironments(opts, internals) {
         build: {
           emitAssets: true,
           outDir: fileURLToPath(getPrerenderOutputDirectory(settings)),
-          rollupOptions: {
+          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?.rollupOptions?.output
+              ...viteConfig.environments?.prerender?.build?.rolldownOptions?.output
             }
           },
           ssr: true
@@ -280,7 +280,7 @@ async function buildEnvironments(opts, internals) {
           copyPublicDir: true,
           sourcemap: viteConfig.environments?.client?.build?.sourcemap ?? false,
           minify: true,
-          rollupOptions: {
+          rolldownOptions: {
             preserveEntrySignatures: "exports-only",
             output: {
               entryFileNames(chunkInfo) {
@@ -290,7 +290,7 @@ async function buildEnvironments(opts, internals) {
                 return `${settings.config.build.assets}/${cleanChunkName(chunkInfo.name)}.[hash].js`;
               },
               assetFileNames: `${settings.config.build.assets}/[name].[hash][extname]`,
-              ...viteConfig.environments?.client?.build?.rollupOptions?.output
+              ...viteConfig.environments?.client?.build?.rolldownOptions?.output
             }
           }
         }
@@ -298,9 +298,9 @@ async function buildEnvironments(opts, internals) {
       [ASTRO_VITE_ENVIRONMENT_NAMES.ssr]: {
         build: {
           outDir: fileURLToPath(getServerOutputDirectory(settings)),
-          rollupOptions: {
+          rolldownOptions: {
             output: {
-              ...viteConfig.environments?.ssr?.build?.rollupOptions?.output
+              ...viteConfig.environments?.ssr?.build?.rolldownOptions?.output
             }
           }
         }
@@ -318,7 +318,7 @@ async function buildEnvironments(opts, internals) {
   await builder.buildApp();
 }
 function getPrerenderEntryFileName(prerenderOutput) {
-  const outputs = viteBuildReturnToRollupOutputs(prerenderOutput);
+  const outputs = viteBuildReturnToRolldownOutputs(prerenderOutput);
   for (const output of outputs) {
     for (const chunk of output.output) {
       if (chunk.type !== "asset" && "fileName" in chunk) {

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

@@ -1,4 +1,4 @@
-import type { Rollup } from 'vite';
+import type { Rolldown } from 'vite';
 import type { AstroConfig } from '../../types/public/config.js';
 import type { ViteBuildReturn } from './types.js';
 export declare function getTimeStat(timeStart: number, timeEnd: number): string;
@@ -12,4 +12,4 @@ export declare function shouldAppendForwardSlash(trailingSlash: AstroConfig['tra
  * and break deploys on platforms like Netlify.
  */
 export declare function cleanChunkName(name: string): string;
-export declare function viteBuildReturnToRollupOutputs(viteBuildReturn: ViteBuildReturn): Rollup.RollupOutput[];
+export declare function viteBuildReturnToRolldownOutputs(viteBuildReturn: ViteBuildReturn): Rolldown.RolldownOutput[];

package/dist/core/build/util.js

@@ -34,7 +34,7 @@ function encodeName(name) {
   }
   return name;
 }
-function viteBuildReturnToRollupOutputs(viteBuildReturn) {
+function viteBuildReturnToRolldownOutputs(viteBuildReturn) {
   const result = [];
   if (Array.isArray(viteBuildReturn)) {
     result.push(...viteBuildReturn);
@@ -47,5 +47,5 @@ export {
   cleanChunkName,
   getTimeStat,
   shouldAppendForwardSlash,
-  viteBuildReturnToRollupOutputs
+  viteBuildReturnToRolldownOutputs
 };

package/dist/core/compile/compile.d.ts

@@ -1,4 +1,4 @@
-import type { TransformResult } from '@astrojs/compiler';
+import { type TransformResult } from '@astrojs/compiler-rs';
 import type { ResolvedConfig } from 'vite';
 import type { AstroConfig } from '../../types/public/config.js';
 import type { CompileCssResult } from './types.js';

package/dist/core/compile/compile.js

@@ -1,5 +1,5 @@
 import { fileURLToPath } from "node:url";
-import { transform } from "@astrojs/compiler";
+import { preprocessStyles, transform } from "@astrojs/compiler-rs";
 import { AggregateError, CompilerError } from "../errors/errors.js";
 import { AstroErrorData } from "../errors/index.js";
 import { normalizePath, resolvePath } from "../viteUtils.js";
@@ -15,7 +15,17 @@ async function compile({
   const cssTransformErrors = [];
   let transformResult;
   try {
-    transformResult = await transform(source, {
+    const preprocessedStyles = await preprocessStyles(
+      source,
+      createStylePreprocessor({
+        filename,
+        viteConfig,
+        astroConfig,
+        cssPartialCompileResults,
+        cssTransformErrors
+      })
+    );
+    transformResult = transform(source, {
       compact: astroConfig.compressHTML,
       filename,
       normalizedFilename: normalizeFilename(filename, astroConfig.root),
@@ -27,14 +37,8 @@ async function compile({
       resultScopedSlot: true,
       transitionsAnimationURL: "astro/components/viewtransitions.css",
       annotateSourceFile: viteConfig.command === "serve" && astroConfig.devToolbar && astroConfig.devToolbar.enabled && toolbarEnabled,
-      preprocessStyle: createStylePreprocessor({
-        filename,
-        viteConfig,
-        astroConfig,
-        cssPartialCompileResults,
-        cssTransformErrors
-      }),
-      async resolvePath(specifier) {
+      preprocessedStyles,
+      resolvePath(specifier) {
         return resolvePath(specifier, filename);
       }
     });
@@ -48,7 +52,7 @@ async function compile({
       }
     });
   }
-  handleCompileResultErrors(transformResult, cssTransformErrors);
+  handleCompileResultErrors(filename, transformResult, cssTransformErrors);
   return {
     ...transformResult,
     css: transformResult.css.map((code, i) => ({
@@ -57,16 +61,16 @@ async function compile({
     }))
   };
 }
-function handleCompileResultErrors(result, cssTransformErrors) {
-  const compilerError = result.diagnostics.find((diag) => diag.severity === 1);
+function handleCompileResultErrors(filename, result, cssTransformErrors) {
+  const compilerError = result.diagnostics.find((diag) => diag.severity === "error");
   if (compilerError) {
     throw new CompilerError({
       name: "CompilerError",
       message: compilerError.text,
       location: {
-        line: compilerError.location.line,
-        column: compilerError.location.column,
-        file: compilerError.location.file
+        line: compilerError.labels[0].line,
+        column: compilerError.labels[0].column,
+        file: filename
       },
       hint: compilerError.hint
     });

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

@@ -1,5 +1,5 @@
-import type { RehypePlugin as _RehypePlugin, RemarkPlugin as _RemarkPlugin, RemarkRehype as _RemarkRehype, Smartypants as _Smartypants, ShikiConfig } from '@astrojs/markdown-remark';
 import type { OutgoingHttpHeaders } from 'node:http';
+import type { RehypePlugin as _RehypePlugin, RemarkPlugin as _RemarkPlugin, RemarkRehype as _RemarkRehype, ShikiConfig, Smartypants as _Smartypants } from '@astrojs/markdown-remark';
 import * as z from 'zod/v4';
 import type { ViteUserConfig } from '../../../types/public/config.js';
 /** @lintignore */
@@ -78,7 +78,6 @@ export declare const ASTRO_CONFIG_DEFAULTS: {
         clientPrerender: false;
         contentIntellisense: false;
         chromeDevtoolsWorkspace: false;
-        rustCompiler: false;
         queuedRendering: {
             enabled: false;
         };
@@ -103,10 +102,10 @@ export declare const AstroConfigSchema: z.ZodObject<{
         name: z.ZodString;
         hooks: z.ZodDefault<z.ZodObject<{}, z.core.$loose>>;
     }, z.core.$strip>>;
-    integrations: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodObject<{
+    integrations: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         hooks: z.ZodDefault<z.ZodObject<{}, z.core.$loose>>;
-    }, z.core.$strip>>>>>;
+    }, z.core.$strip>>>>;
     build: z.ZodPrefault<z.ZodObject<{
         format: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"file">, z.ZodLiteral<"directory">, z.ZodLiteral<"preserve">]>>>;
         client: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodString>>, z.ZodTransform<URL, string>>;
@@ -124,7 +123,7 @@ export declare const AstroConfigSchema: z.ZodObject<{
         }>>>;
         concurrency: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     }, z.core.$strip>>;
-    server: z.ZodPrefault<z.ZodPipe<z.ZodTransform<any, unknown>, z.ZodObject<{
+    server: z.ZodPipe<z.ZodTransform<any, unknown>, z.ZodPrefault<z.ZodObject<{
         open: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>>;
         host: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>>;
         port: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
@@ -517,7 +516,6 @@ export declare const AstroConfigSchema: z.ZodObject<{
             swr: z.ZodOptional<z.ZodNumber>;
             tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>>>;
-        rustCompiler: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         queuedRendering: z.ZodPrefault<z.ZodOptional<z.ZodObject<{
             enabled: z.ZodPrefault<z.ZodOptional<z.ZodBoolean>>;
             poolSize: z.ZodOptional<z.ZodNumber>;

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

@@ -2,11 +2,11 @@ import { markdownConfigDefaults, syntaxHighlightDefaults } from "@astrojs/markdo
 import { bundledThemes } from "shiki";
 import * as z from "zod/v4";
 import { FontFamilySchema } from "../../../assets/fonts/config.js";
-import { SvgOptimizerSchema } from "../../../assets/svg/config.js";
 import { EnvSchema } from "../../../env/schema.js";
-import { CacheSchema, RouteRulesSchema } from "../../cache/config.js";
 import { allowedDirectivesSchema, cspAlgorithmSchema, cspHashSchema } from "../../csp/config.js";
+import { CacheSchema, RouteRulesSchema } from "../../cache/config.js";
 import { SessionSchema } from "../../session/config.js";
+import { SvgOptimizerSchema } from "../../../assets/svg/config.js";
 const ASTRO_CONFIG_DEFAULTS = {
   root: ".",
   srcDir: "./src",
@@ -63,7 +63,6 @@ const ASTRO_CONFIG_DEFAULTS = {
     clientPrerender: false,
     contentIntellisense: false,
     chromeDevtoolsWorkspace: false,
-    rustCompiler: false,
     queuedRendering: {
       enabled: false
     },
@@ -105,13 +104,13 @@ const AstroConfigSchema = z.object({
     message: 'The `output: "hybrid"` option has been removed. Use `output: "static"` (the default) instead, which now behaves the same way.'
   }),
   scopedStyleStrategy: z.union([z.literal("where"), z.literal("class"), z.literal("attribute")]).optional().default("attribute"),
-  adapter: z.object({ name: z.string(), hooks: z.object({}).loose().default({}) }).optional(),
+  adapter: z.object({ name: z.string(), hooks: z.object({}).passthrough().default({}) }).optional(),
   integrations: z.preprocess(
     // preprocess
     (val) => Array.isArray(val) ? val.flat(Number.POSITIVE_INFINITY).filter(Boolean) : val,
     // validate
-    z.array(z.object({ name: z.string(), hooks: z.object({}).loose().default({}) }))
-  ).optional().default(ASTRO_CONFIG_DEFAULTS.integrations),
+    z.array(z.object({ name: z.string(), hooks: z.object({}).passthrough().default({}) })).default(ASTRO_CONFIG_DEFAULTS.integrations)
+  ),
   build: z.object({
     format: z.union([z.literal("file"), z.literal("directory"), z.literal("preserve")]).optional().default(ASTRO_CONFIG_DEFAULTS.build.format),
     client: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.build.client).transform((val) => new URL(val)),
@@ -135,8 +134,8 @@ const AstroConfigSchema = z.object({
       port: z.number().optional().default(ASTRO_CONFIG_DEFAULTS.server.port),
       headers: z.custom().optional(),
       allowedHosts: z.union([z.array(z.string()), z.literal(true)]).optional().default(ASTRO_CONFIG_DEFAULTS.server.allowedHosts)
-    })
-  ).prefault({}),
+    }).prefault({})
+  ),
   redirects: z.record(
     z.string(),
     z.union([
@@ -313,7 +312,6 @@ const AstroConfigSchema = z.object({
     svgOptimizer: SvgOptimizerSchema.optional(),
     cache: CacheSchema.optional(),
     routeRules: RouteRulesSchema.optional(),
-    rustCompiler: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.rustCompiler),
     queuedRendering: z.object({
       enabled: z.boolean().optional().prefault(false),
       poolSize: z.number().int().nonnegative().optional(),