astro 7.0.0-beta.4 → 7.0.0-beta.6

package/dist/core/middleware/astro-middleware.d.ts

@@ -1,5 +1,6 @@
 import type { FetchState } from '../fetch/fetch-state.js';
 import type { APIContext } from '../../types/public/context.js';
+import type { BaseApp } from '../app/base.js';
 import { type Pipeline } from '../base-pipeline.js';
 /**
  * Callback invoked at the bottom of the middleware chain to dispatch the
@@ -24,4 +25,22 @@ export declare class AstroMiddleware {
     #private;
     constructor(pipeline: Pipeline);
     handle(state: FetchState, renderRouteCallback: RenderRouteCallback): Promise<Response>;
+    /**
+     * Like `handle`, but mirrors the app-level error handling that
+     * `AstroHandler` provides on the standard path, the same way
+     * `PagesHandler.handleWithErrorFallback` does for `pages()`. When no
+     * route matched it returns a 404 marked with `X-Astro-Error` for the
+     * app's post-check; when Astro's own middleware chain throws it logs the
+     * error and renders the custom `500.astro`.
+     *
+     * Errors surfaced through `renderRouteCallback` (the host framework's
+     * `next`, e.g. host middleware mounted below `middleware()`) are
+     * re-thrown instead, so the host's own error handling still runs rather
+     * than being swallowed into Astro's 500 page. A sentinel tells the two
+     * apart.
+     *
+     * Used by the composable `astro/fetch` `middleware()` entry point, where
+     * there is no surrounding `AstroHandler` to supply this fallback.
+     */
+    handleWithErrorFallback(app: BaseApp<Pipeline>, state: FetchState, renderRouteCallback: RenderRouteCallback): Promise<Response>;
 }

package/dist/core/middleware/astro-middleware.js

@@ -1,4 +1,5 @@
 import { PipelineFeatures } from "../base-pipeline.js";
+import { ASTRO_ERROR_HEADER } from "../constants.js";
 import { attachCookiesToResponse } from "../cookies/index.js";
 import { applyRewriteToState } from "../rewrites/handler.js";
 import { callMiddleware } from "./callMiddleware.js";
@@ -41,6 +42,48 @@ class AstroMiddleware {
     state.response = response;
     return response;
   }
+  /**
+   * Like `handle`, but mirrors the app-level error handling that
+   * `AstroHandler` provides on the standard path, the same way
+   * `PagesHandler.handleWithErrorFallback` does for `pages()`. When no
+   * route matched it returns a 404 marked with `X-Astro-Error` for the
+   * app's post-check; when Astro's own middleware chain throws it logs the
+   * error and renders the custom `500.astro`.
+   *
+   * Errors surfaced through `renderRouteCallback` (the host framework's
+   * `next`, e.g. host middleware mounted below `middleware()`) are
+   * re-thrown instead, so the host's own error handling still runs rather
+   * than being swallowed into Astro's 500 page. A sentinel tells the two
+   * apart.
+   *
+   * Used by the composable `astro/fetch` `middleware()` entry point, where
+   * there is no surrounding `AstroHandler` to supply this fallback.
+   */
+  async handleWithErrorFallback(app, state, renderRouteCallback) {
+    if (!state.routeData) {
+      return new Response(null, { status: 404, headers: { [ASTRO_ERROR_HEADER]: "true" } });
+    }
+    let nextError;
+    try {
+      return await this.handle(state, async (s, ctx) => {
+        try {
+          return await renderRouteCallback(s, ctx);
+        } catch (err) {
+          nextError = err;
+          throw err;
+        }
+      });
+    } catch (err) {
+      if (err === nextError) throw err;
+      app.logger.error(null, err.stack || err.message || String(err));
+      return app.renderError(state.request, {
+        ...state.renderOptions,
+        status: 500,
+        error: err,
+        pathname: state.pathname
+      });
+    }
+  }
   #finalize(state, response) {
     attachCookiesToResponse(response, state.cookies);
     return response;

package/dist/core/middleware/noop-middleware.js

@@ -1,7 +1,5 @@
-import { NOOP_MIDDLEWARE_HEADER } from "../constants.js";
 const NOOP_MIDDLEWARE_FN = async (_ctx, next) => {
   const response = await next();
-  response.headers.set(NOOP_MIDDLEWARE_HEADER, "true");
   return response;
 };
 export {

package/dist/core/pages/handler.d.ts

@@ -1,4 +1,5 @@
 import type { APIContext } from '../../types/public/context.js';
+import type { BaseApp } from '../app/base.js';
 import type { FetchState } from '../fetch/fetch-state.js';
 import type { Pipeline } from '../base-pipeline.js';
 /**
@@ -17,4 +18,16 @@ export declare class PagesHandler {
     #private;
     constructor(pipeline: Pipeline);
     handle(state: FetchState, ctx: APIContext): Promise<Response>;
+    /**
+     * Like `handle`, but mirrors the app-level error handling that
+     * `AstroHandler` provides on the standard path: unmatched routes
+     * return a 404 marked with `X-Astro-Error` for the app's post-check
+     * to render the 404 error page, and render-time errors are logged
+     * and render the 500 error page instead of propagating to the host
+     * framework.
+     *
+     * Used by the composable `astro/fetch` `pages()` entry point, where
+     * there is no surrounding `AstroHandler` to supply this fallback.
+     */
+    handleWithErrorFallback(app: BaseApp<Pipeline>, state: FetchState): Promise<Response>;
 }

package/dist/core/pages/handler.js

@@ -1,12 +1,6 @@
 import { renderEndpoint } from "../../runtime/server/endpoint.js";
 import { renderPage } from "../../runtime/server/index.js";
-import {
-  ASTRO_ERROR_HEADER,
-  REROUTE_DIRECTIVE_HEADER,
-  REWRITE_DIRECTIVE_HEADER_KEY,
-  REWRITE_DIRECTIVE_HEADER_VALUE,
-  ROUTE_TYPE_HEADER
-} from "../constants.js";
+import { ASTRO_ERROR_HEADER } from "../constants.js";
 import { getCookiesFromResponse } from "../cookies/response.js";
 const EMPTY_SLOTS = Object.freeze({});
 class PagesHandler {
@@ -17,6 +11,7 @@ class PagesHandler {
   async handle(state, ctx) {
     const pipeline = this.#pipeline;
     const { logger, streaming } = pipeline;
+    state.resetResponseMetadata();
     let response;
     const componentInstance = await state.loadComponentInstance();
     switch (state.routeData.type) {
@@ -25,7 +20,8 @@ class PagesHandler {
           componentInstance,
           ctx,
           state.routeData.prerender,
-          logger
+          logger,
+          state
         );
         break;
       }
@@ -46,12 +42,9 @@ class PagesHandler {
           result.cancelled = true;
           throw e;
         }
-        response.headers.set(ROUTE_TYPE_HEADER, "page");
+        state.responseRouteType = "page";
         if (state.routeData.route === "/404" || state.routeData.route === "/500") {
-          response.headers.set(REROUTE_DIRECTIVE_HEADER, "no");
-        }
-        if (state.isRewriting) {
-          response.headers.set(REWRITE_DIRECTIVE_HEADER_KEY, REWRITE_DIRECTIVE_HEADER_VALUE);
+          state.skipErrorReroute = true;
         }
         break;
       }
@@ -59,7 +52,8 @@ class PagesHandler {
         return new Response(null, { status: 404, headers: { [ASTRO_ERROR_HEADER]: "true" } });
       }
       case "fallback": {
-        return new Response(null, { status: 500, headers: { [ROUTE_TYPE_HEADER]: "fallback" } });
+        state.responseRouteType = "fallback";
+        return new Response(null, { status: 500 });
       }
     }
     const responseCookies = getCookiesFromResponse(response);
@@ -69,6 +63,33 @@ class PagesHandler {
     state.response = response;
     return response;
   }
+  /**
+   * Like `handle`, but mirrors the app-level error handling that
+   * `AstroHandler` provides on the standard path: unmatched routes
+   * return a 404 marked with `X-Astro-Error` for the app's post-check
+   * to render the 404 error page, and render-time errors are logged
+   * and render the 500 error page instead of propagating to the host
+   * framework.
+   *
+   * Used by the composable `astro/fetch` `pages()` entry point, where
+   * there is no surrounding `AstroHandler` to supply this fallback.
+   */
+  async handleWithErrorFallback(app, state) {
+    if (!state.routeData) {
+      return new Response(null, { status: 404, headers: { [ASTRO_ERROR_HEADER]: "true" } });
+    }
+    try {
+      return await this.handle(state, state.getAPIContext());
+    } catch (err) {
+      app.logger.error(null, err.stack || err.message || String(err));
+      return app.renderError(state.request, {
+        ...state.renderOptions,
+        status: 500,
+        error: err,
+        pathname: state.pathname
+      });
+    }
+  }
 }
 export {
   PagesHandler

package/dist/core/routing/handler.js

@@ -1,9 +1,5 @@
 import { ActionHandler } from "../../actions/handler.js";
-import {
-  REROUTABLE_STATUS_CODES,
-  REROUTE_DIRECTIVE_HEADER,
-  REWRITE_DIRECTIVE_HEADER_KEY
-} from "../constants.js";
+import { REROUTABLE_STATUS_CODES } from "../constants.js";
 import { TrailingSlashHandler } from "./trailing-slash-handler.js";
 import { CacheHandler, provideCache } from "../cache/handler.js";
 import { I18n } from "../i18n/handler.js";
@@ -65,6 +61,9 @@ class AstroHandler {
   }
   async handle(state) {
     state.pipeline.usedFeatures |= ALL_PIPELINE_FEATURES;
+    if (state.invalidEncoding) {
+      return new Response(null, { status: 400, statusText: "Bad Request" });
+    }
     const trailingSlashRedirect = this.#trailingSlashHandler.handle(state);
     if (trailingSlashRedirect) {
       return trailingSlashRedirect;
@@ -128,12 +127,11 @@ class AstroHandler {
         };
         response = await this.#cacheHandler.handle(state, runPipeline);
       }
-      const isRewrite = response.headers.has(REWRITE_DIRECTIVE_HEADER_KEY);
       this.#app.logThisRequest({
         pathname,
         method: request.method,
         statusCode: response.status,
-        isRewrite,
+        isRewrite: state.isRewriting,
         timeStart: state.timeStart
       });
     } catch (err) {
@@ -150,7 +148,7 @@ class AstroHandler {
     }
     if (REROUTABLE_STATUS_CODES.includes(response.status) && // If the body isn't null, that means the user sets the 404 status
     // but uses the current route to handle the 404
-    response.body === null && response.headers.get(REROUTE_DIRECTIVE_HEADER) !== "no") {
+    response.body === null && !state.skipErrorReroute) {
       return this.#app.renderError(request, {
         ...state.renderOptions,
         response,

package/dist/core/routing/rewrite.js

@@ -10,6 +10,7 @@ import {
   trimSlashes
 } from "../path.js";
 import { createRequest } from "../request.js";
+import { validateAndDecodePathname } from "../util/pathname.js";
 import { DEFAULT_404_ROUTE } from "./internal/astro-designed-error-pages.js";
 import { isRoute404, isRoute500 } from "./internal/route-errors.js";
 function findRouteToRewrite({
@@ -36,7 +37,7 @@ function findRouteToRewrite({
     buildFormat
   );
   newUrl.pathname = resolvedUrlPathname;
-  const decodedPathname = decodeURI(pathname);
+  const decodedPathname = validateAndDecodePathname(pathname);
   if (isRoute404(decodedPathname)) {
     const errorRoute = routes.find((route) => route.route === "/404");
     if (errorRoute) {

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

@@ -1,25 +1,26 @@
 /**
- * Error thrown when multi-level URL encoding is detected in a pathname.
- * This is a distinct error type so callers can handle it specifically
- * (e.g., returning a 400 response) rather than falling back to partial decoding.
- *
- * @deprecated No longer thrown internally — multi-level encoding is now
- * decoded iteratively instead of rejected. Kept for backwards compatibility
- * in case third-party code references the class.
+ * Thrown when a URL path is encoded so many times that we give up decoding it
+ * (see {@link validateAndDecodePathname}). When this happens we reject the
+ * request with a `400` instead of guessing the path. If we let a half-decoded
+ * path through, your middleware might check one path while Astro routes to a
+ * different one.
  */
 export declare class MultiLevelEncodingError extends Error {
     constructor();
 }
 /**
- * Decodes a pathname iteratively until stable, collapsing all levels of
- * percent-encoding into a single canonical form. This prevents
- * double/triple encoding from bypassing middleware authorization checks
- * (CVE-2025-66202) — instead of rejecting multi-level encoding, we
- * fully resolve it so middleware always sees the true decoded path.
+ * Decodes a URL path over and over until it stops changing, so a path that was
+ * encoded several times ends up as a single, final path. This stops someone
+ * from sneaking a path like `/admin` past middleware by encoding it multiple
+ * times — middleware always sees the real, decoded path.
  *
- * @param pathname - The pathname to decode
- * @returns The fully decoded pathname
- * @throws Error if the pathname contains invalid URL encoding that
- *   cannot be decoded at all (e.g., a bare `%` not followed by hex digits)
+ * @param pathname - The path to decode
+ * @returns The final, fully decoded path
+ * @throws Error if the path has broken encoding that can't be decoded at all
+ *   (for example a lone `%` that isn't followed by two hex digits)
+ * @throws MultiLevelEncodingError if the path is still changing after
+ *   {@link MAX_DECODE_ITERATIONS} tries (it was encoded too many times).
+ *   Handing back a half-decoded path here would bring back the security hole
+ *   this function exists to close.
  */
 export declare function validateAndDecodePathname(pathname: string): string;

package/dist/core/util/pathname.js

@@ -1,9 +1,10 @@
 class MultiLevelEncodingError extends Error {
   constructor() {
-    super("Multi-level URL encoding is not allowed");
+    super("URL encoding depth exceeded the maximum number of decode iterations");
     this.name = "MultiLevelEncodingError";
   }
 }
+const MAX_DECODE_ITERATIONS = 10;
 function validateAndDecodePathname(pathname) {
   let decoded;
   try {
@@ -12,7 +13,10 @@ function validateAndDecodePathname(pathname) {
     throw new Error("Invalid URL encoding");
   }
   let iterations = 0;
-  while (decoded !== pathname && iterations < 10) {
+  while (decoded !== pathname) {
+    if (iterations >= MAX_DECODE_ITERATIONS) {
+      throw new MultiLevelEncodingError();
+    }
     pathname = decoded;
     try {
       decoded = decodeURI(pathname);

package/dist/i18n/index.js

@@ -4,7 +4,7 @@ import {
   removeTrailingForwardSlash
 } from "@astrojs/internal-helpers/path";
 import { shouldAppendForwardSlash } from "../core/build/util.js";
-import { REROUTE_DIRECTIVE_HEADER } from "../core/constants.js";
+import { getFetchStateFromAPIContext } from "../core/fetch/fetch-state.js";
 import { i18nNoLocaleFoundInPath, MissingLocale } from "../core/errors/errors-data.js";
 import { AstroError } from "../core/errors/index.js";
 import { createI18nMiddleware } from "./middleware.js";
@@ -200,24 +200,22 @@ function redirectToDefaultLocale({
 }
 function notFound({ base, locales, fallback }) {
   return function(context, response) {
-    if (response?.headers.get(REROUTE_DIRECTIVE_HEADER) === "no" && typeof fallback === "undefined") {
+    const fetchState = getFetchStateFromAPIContext(context);
+    if (fetchState.skipErrorReroute && typeof fallback === "undefined") {
       return response;
     }
     const url = context.url;
     const isRoot = url.pathname === base + "/" || url.pathname === base;
     if (!(isRoot || pathHasLocale(url.pathname, locales))) {
+      fetchState.skipErrorReroute = true;
       if (response) {
-        response.headers.set(REROUTE_DIRECTIVE_HEADER, "no");
         return new Response(response.body, {
           status: 404,
           headers: response.headers
         });
       } else {
         return new Response(null, {
-          status: 404,
-          headers: {
-            [REROUTE_DIRECTIVE_HEADER]: "no"
-          }
+          status: 404
         });
       }
     }

package/dist/manifest/serialized.js

@@ -83,7 +83,7 @@ function serializedManifestPlugin({
           const serialized = await createSerializedManifest(settings, await getEncodedKey());
           manifestData = JSON.stringify(serialized);
         }
-        const hasCacheConfig = !!settings.config.experimental?.cache?.provider;
+        const hasCacheConfig = !!settings.config.cache?.provider;
         const cacheProviderLine = hasCacheConfig ? `cacheProvider: () => import('${VIRTUAL_CACHE_PROVIDER_ID}'),` : "";
         const code = `
 					import { deserializeManifest as _deserializeManifest } from 'astro/app';
@@ -181,10 +181,7 @@ async function createSerializedManifest(settings, encodedKey) {
     // 1mb default
     key: encodedKey ?? await encodeKey(hasEnvironmentKey() ? await getEnvironmentKey() : await createKey()),
     sessionConfig: sessionConfigToManifest(settings.config.session),
-    cacheConfig: cacheConfigToManifest(
-      settings.config.experimental?.cache,
-      settings.config.experimental?.routeRules
-    ),
+    cacheConfig: cacheConfigToManifest(settings.config.cache, settings.config.routeRules),
     csp,
     image: {
       objectFit: settings.config.image.objectFit,

package/dist/runtime/server/endpoint.d.ts

@@ -1,7 +1,8 @@
+import type { FetchState } from '../../core/fetch/fetch-state.js';
 import type { AstroLogger } from '../../core/logger/core.js';
 import type { APIRoute } from '../../types/public/common.js';
 import type { APIContext } from '../../types/public/context.js';
 /** Renders an endpoint request to completion, returning the body. */
 export declare function renderEndpoint(mod: {
     [method: string]: APIRoute;
-}, context: APIContext, isPrerendered: boolean, logger: AstroLogger): Promise<Response>;
+}, context: APIContext, isPrerendered: boolean, logger: AstroLogger, state?: FetchState): Promise<Response>;

package/dist/runtime/server/endpoint.js

@@ -1,8 +1,8 @@
 import colors from "piccolore";
-import { REROUTABLE_STATUS_CODES, REROUTE_DIRECTIVE_HEADER } from "../../core/constants.js";
+import { REROUTABLE_STATUS_CODES } from "../../core/constants.js";
 import { AstroError } from "../../core/errors/errors.js";
 import { EndpointDidNotReturnAResponse } from "../../core/errors/errors-data.js";
-async function renderEndpoint(mod, context, isPrerendered, logger) {
+async function renderEndpoint(mod, context, isPrerendered, logger, state) {
   const { request, url } = context;
   const method = request.method.toUpperCase();
   let handler = mod[method] ?? mod["ALL"];
@@ -38,17 +38,8 @@ Found handlers: ${Object.keys(mod).map((exp) => JSON.stringify(exp)).join(", ")}
   if (!response || response instanceof Response === false) {
     throw new AstroError(EndpointDidNotReturnAResponse);
   }
-  if (REROUTABLE_STATUS_CODES.includes(response.status)) {
-    try {
-      response.headers.set(REROUTE_DIRECTIVE_HEADER, "no");
-    } catch (err) {
-      if (err.message?.includes("immutable")) {
-        response = new Response(response.body, response);
-        response.headers.set(REROUTE_DIRECTIVE_HEADER, "no");
-      } else {
-        throw err;
-      }
-    }
+  if (state && REROUTABLE_STATUS_CODES.includes(response.status)) {
+    state.skipErrorReroute = true;
   }
   if (method === "HEAD") {
     return new Response(null, response);

package/dist/types/public/config.d.ts

@@ -420,22 +420,22 @@ export interface AstroUserConfig<TLocales extends Locales = never, TDriver exten
      * @docs
      * @name compressHTML
      * @type {boolean | "jsx"}
-     * @default `true`
+     * @default `'jsx'`
      * @description
      *
      * Controls how Astro handles whitespace in your HTML. This affects both development mode and the final build output.
      *
-     * By default, Astro removes whitespace from your HTML, including line breaks, in a lossless manner from `.astro` components. Some whitespace may be preserved as needed to maintain the visual rendering of your HTML.
+     * Since v7.0,  Astro applies by default the JSX whitespace rules used by frameworks like React. This removes whitespace and line breaks around elements, collapses multi-line text onto a single line, and preserves whitespace within a single line (e.g. a space between two inline elements). To keep a space that would otherwise be removed, include it explicitly in the source through constructs such as `{" "}`.
      *
-     * Since 6.2.0, this option can also be set to `"jsx"`, Astro will apply the JSX whitespace stripping rules used by frameworks like React. Leading and trailing whitespace is only preserved when explicitly included in the source code through constructs such as `{" "}`, and is otherwise removed entirely.
+     * Setting this option to `true` instead removes whitespace, including line breaks, in a lossless manner from `.astro` components. Some whitespace may be preserved as needed to maintain the visual rendering of your HTML.
      *
-     * Setting this option to false disables HTML compression and preserves all whitespace.
+     * Setting this option to `false` disables HTML compression and preserves all whitespace.
      *
      * ```js
      * {
-     *   compressHTML: false
+     *   compressHTML: true
      *   // or:
-     *   // compressHTML: 'jsx'
+     *   // compressHTML: false
      * }
      * ```
      */
@@ -2752,6 +2752,85 @@ export interface AstroUserConfig<TLocales extends Locales = never, TDriver exten
     fonts?: [TFontProviders] extends [never] ? Array<FontFamily> : {
         [K in keyof TFontProviders]: FontFamily<TFontProviders[K]>;
     };
+    /**
+     * @docs
+     * @kind heading
+     * @name cache
+     * @type {object}
+     * @default `undefined`
+     * @version 7.0.0
+     * @description
+     *
+     * Enables route caching for SSR responses. Provides a platform-agnostic API
+     * for caching rendered pages and API responses, with pluggable providers
+     * that adapters can configure automatically.
+     *
+     * ```js
+     * // astro.config.mjs
+     * import { memoryCache } from 'astro/config';
+     *
+     * {
+     *   cache: {
+     *     provider: memoryCache(),
+     *   },
+     *   routeRules: {
+     *     '/blog/[...path]': { maxAge: 300, swr: 60 },
+     *   },
+     * }
+     * ```
+     *
+     * Use `Astro.cache.set()` in routes and `context.cache.set()` in middleware
+     * or API routes to control caching per-request.
+     */
+    cache?: {
+        /**
+         * @docs
+         * @name cache.provider
+         * @type {CacheProviderConfig}
+         * @version 7.0.0
+         * @description
+         *
+         * A provider that controls how responses are cached.
+         *
+         * Use the provider's config function to get type-safe configuration:
+         *
+         * ```js
+         * import { defineConfig, memoryCache } from 'astro/config';
+         *
+         * export default defineConfig({
+         *   cache: { provider: memoryCache() },
+         * });
+         * ```
+         */
+        provider?: CacheProviderConfig;
+    };
+    /**
+     * @docs
+     * @kind heading
+     * @name routeRules
+     * @type {Record<string, RouteRule>}
+     * @default `undefined`
+     * @version 7.0.0
+     * @description
+     *
+     * Route patterns mapped to cache rules.
+     * Uses the same `[param]` and `[...rest]` syntax as [file-based routing](/en/guides/routing/#route-priority-order).
+     * Use a `[...rest]` parameter to match a group of routes:
+     *
+     * ```js
+     * // astro.config.mjs
+     * import { memoryCache } from 'astro/config';
+     *
+     * {
+     *   cache: { provider: memoryCache() },
+     *   routeRules: {
+     *     '/api/[...path]': { swr: 600 },
+     *     '/products/[...slug]': { maxAge: 3600, tags: ['products'] },
+     *   },
+     * }
+     * ```
+     */
+    routeRules?: RouteRules;
     /**
      *
      * @kind heading
@@ -2895,83 +2974,6 @@ export interface AstroUserConfig<TLocales extends Locales = never, TDriver exten
          * See the [experimental SVG optimization docs](https://docs.astro.build/en/reference/experimental-flags/svg-optimization/) for more information.
          */
         svgOptimizer?: SvgOptimizer;
-        /**
-         * @name experimental.cache
-         * @type {object}
-         * @default `undefined`
-         * @description
-         *
-         * Enables route caching for SSR responses. Provides a platform-agnostic API
-         * for caching rendered pages and API responses, with pluggable providers
-         * that adapters can configure automatically.
-         *
-         * ```js
-         * // astro.config.mjs
-         * import { memoryCache } from 'astro/config';
-         *
-         * {
-         *   experimental: {
-         *     cache: {
-         *       provider: memoryCache(),
-         *     },
-         *     routeRules: {
-         *       '/blog/[...path]': { maxAge: 300, swr: 60 },
-         *     },
-         *   },
-         * }
-         * ```
-         *
-         * Use `Astro.cache.set()` in routes and `context.cache.set()` in middleware
-         * or API routes to control caching per-request.
-         */
-        cache?: {
-            /**
-             * @name experimental.cache.provider
-             * @type {import('../../core/cache/types.js').CacheProviderConfig}
-             * @description
-             *
-             * The cache provider. Adapters typically set a default, but you can
-             * override it with your own.
-             *
-             * Use the provider's config function to get type-safe configuration:
-             *
-             * ```js
-             * import { memoryCache } from 'astro/config';
-             *
-             * export default defineConfig({
-             *   experimental: {
-             *     cache: { provider: memoryCache() },
-             *   },
-             * });
-             * ```
-             */
-            provider?: CacheProviderConfig;
-        };
-        /**
-         * @name experimental.routeRules
-         * @type {Record<string, RouteRule>}
-         * @default `undefined`
-         * @description
-         *
-         * Route patterns mapped to cache rules.
-         * Uses the same `[param]` and `[...rest]` syntax as file-based routing.
-         *
-         * ```js
-         * // astro.config.mjs
-         * import { memoryCache } from 'astro/config';
-         *
-         * {
-         *   experimental: {
-         *     cache: { provider: memoryCache() },
-         *     routeRules: {
-         *       '/api/*': { swr: 600 },
-         *       '/products/*': { maxAge: 3600, tags: ['products'] },
-         *     },
-         *   },
-         * }
-         * ```
-         */
-        routeRules?: RouteRules;
     };
 }
 /**

package/dist/virtual-modules/container.d.ts

@@ -4,7 +4,7 @@ import type { SSRLoadedRenderer } from '../types/public/internal.js';
  * Use this function to provide renderers to the `AstroContainer`:
  *
  * ```js
- * import { getContainerRenderer } from "@astrojs/react";
+ * import { getContainerRenderer } from "@astrojs/react/container-renderer";
  * import { experimental_AstroContainer as AstroContainer } from "astro/container";
  * import { loadRenderers } from "astro:container"; // use this only when using vite/vitest
  *

package/dist/vite-plugin-config-alias/index.d.ts

@@ -1,6 +1,6 @@
 import { type Plugin as VitePlugin } from 'vite';
 import type { AstroSettings } from '../types/astro.js';
-/** Returns a Vite plugin used to alias paths from tsconfig.json and jsconfig.json. */
+/** Returns Vite plugins used to alias paths from tsconfig.json and jsconfig.json. */
 export default function configAliasVitePlugin({ settings, }: {
     settings: AstroSettings;
-}): VitePlugin | null;
+}): VitePlugin[] | null;