astro 6.3.1 → 7.0.0-alpha.1

package/dist/assets/endpoint/generic.js

@@ -4,7 +4,21 @@ import { isRemoteAllowed } from "@astrojs/internal-helpers/remote";
 import * as mime from "mrmime";
 import { getConfiguredImageService } from "../internal.js";
 import { etag } from "../utils/etag.js";
-import { loadImage } from "./loadImage.js";
+import { fetchWithRedirects } from "../utils/redirectValidation.js";
+async function loadRemoteImage(src, headers) {
+  try {
+    const res = await fetchWithRedirects({ url: src, headers, imageConfig });
+    if (!isRemoteAllowed(res.url, imageConfig)) {
+      return void 0;
+    }
+    if (!res.ok) {
+      return void 0;
+    }
+    return await res.arrayBuffer();
+  } catch {
+    return void 0;
+  }
+}
 const GET = async ({ request }) => {
   try {
     const imageService = await getConfiguredImageService();
@@ -25,12 +39,7 @@ const GET = async ({ request }) => {
     if (!isRemoteImage && sourceUrl.origin !== url.origin) {
       return new Response("Forbidden", { status: 403 });
     }
-    inputBuffer = await loadImage(
-      sourceUrl,
-      isRemoteImage ? new Headers() : request.headers,
-      imageConfig,
-      isRemoteImage
-    );
+    inputBuffer = await loadRemoteImage(sourceUrl, isRemoteImage ? new Headers() : request.headers);
     if (!inputBuffer) {
       return new Response("Not Found", { status: 404 });
     }

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/add/index.js

@@ -197,12 +197,6 @@ async function add(names, { flags }) {
           logger,
           scripts: { "generate-types": "wrangler types" }
         });
-        await updatePackageJsonOverrides({
-          configURL,
-          flags,
-          logger,
-          overrides: { vite: "^7" }
-        });
       }
       if (integrations.find((integration) => integration.id === "tailwind")) {
         const dir = new URL("./styles/", new URL(userConfig.srcDir ?? "./src/", root));
@@ -590,54 +584,6 @@ async function updateAstroConfig({
     return "cancelled";
   }
 }
-async function updatePackageJsonOverrides({
-  configURL,
-  flags,
-  logger,
-  overrides
-}) {
-  const pkgURL = new URL("./package.json", configURL);
-  if (!existsSync(pkgURL)) {
-    logger.debug("add", "No package.json found, skipping overrides update");
-    return "none";
-  }
-  const pkgPath = fileURLToPath(pkgURL);
-  const input = await fs.readFile(pkgPath, { encoding: "utf-8" });
-  const pkgJson = JSON.parse(input);
-  pkgJson.overrides ??= {};
-  let hasChanges = false;
-  for (const [name, range] of Object.entries(overrides)) {
-    if (!(name in pkgJson.overrides)) {
-      pkgJson.overrides[name] = range;
-      hasChanges = true;
-    }
-  }
-  if (!hasChanges) {
-    return "none";
-  }
-  const output = JSON.stringify(pkgJson, null, 2);
-  const diff = getDiffContent(input, output);
-  if (!diff) {
-    return "none";
-  }
-  logger.info(
-    "SKIP_FORMAT",
-    `
-  ${magenta("Astro will add the following overrides to your package.json:")}`
-  );
-  clack.box(diff, "package.json", {
-    rounded: true,
-    withGuide: false,
-    width: "auto"
-  });
-  if (await askToContinue({ flags, logger })) {
-    await fs.writeFile(pkgPath, output, { encoding: "utf-8" });
-    logger.debug("add", "Updated package.json overrides");
-    return "updated";
-  } else {
-    return "cancelled";
-  }
-}
 async function updatePackageJsonScripts({
   configURL,
   flags,

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

package/dist/content/content-layer.js

@@ -191,7 +191,7 @@ ${contentConfig.error.message}`
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "6.3.1") {
+    if (previousAstroVersion && previousAstroVersion !== "7.0.0-alpha.1") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -199,8 +199,8 @@ ${contentConfig.error.message}`
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("6.3.1") {
-      this.#store.metaStore().set("astro-version", "6.3.1");
+    if ("7.0.0-alpha.1") {
+      this.#store.metaStore().set("astro-version", "7.0.0-alpha.1");
     }
     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/content/vite-plugin-content-assets.js

@@ -97,6 +97,7 @@ function astroContentAssetPropagationPlugin({
             stringifiedStyles = JSON.stringify(STYLES_PLACEHOLDER);
           }
           const code = `
+					"use astro:head-inject";
 					async function getMod() {
 						return import(${JSON.stringify(basePath)});
 					}

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 } : {},
@@ -194,7 +194,7 @@ async function buildEnvironments(opts, internals) {
             }
             return `${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(
@@ -203,8 +203,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";
@@ -228,7 +228,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 = [];
@@ -238,7 +238,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;
         }
@@ -266,14 +266,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
@@ -287,7 +287,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) {
@@ -304,7 +304,7 @@ async function buildEnvironments(opts, internals) {
                 }
                 return `${settings.config.build.assets}/[name].[hash][extname]`;
               },
-              ...viteConfig.environments?.client?.build?.rollupOptions?.output
+              ...viteConfig.environments?.client?.build?.rolldownOptions?.output
             }
           }
         }
@@ -312,9 +312,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
             }
           }
         }
@@ -332,7 +332,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

@@ -80,7 +80,6 @@ export declare const ASTRO_CONFIG_DEFAULTS: {
         clientPrerender: false;
         contentIntellisense: false;
         chromeDevtoolsWorkspace: false;
-        rustCompiler: false;
         queuedRendering: {
             enabled: false;
         };
@@ -521,7 +520,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

@@ -65,7 +65,6 @@ const ASTRO_CONFIG_DEFAULTS = {
     clientPrerender: false,
     contentIntellisense: false,
     chromeDevtoolsWorkspace: false,
-    rustCompiler: false,
     queuedRendering: {
       enabled: false
     },
@@ -317,7 +316,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(),