astro 6.2.2 → 6.3.0

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

@@ -1,6 +1,7 @@
 import type { RouteData } from '../../../types/public/index.js';
+import type { ErrorHandler } from '../../errors/handler.js';
 import type { AstroLogger } from '../../logger/core.js';
-import { BaseApp, type DevMatch, type LogRequestPayload, type RenderErrorOptions } from '../base.js';
+import { BaseApp, type DevMatch, type LogRequestPayload } from '../base.js';
 import type { SSRManifest } from '../types.js';
 import { NonRunnablePipeline } from './pipeline.js';
 import type { RoutesList } from '../../../types/astro.js';
@@ -20,6 +21,6 @@ export declare class DevApp extends BaseApp<NonRunnablePipeline> {
     updateRoutes(newRoutesList: RoutesList): void;
     match(request: Request): RouteData | undefined;
     devMatch(pathname: string): Promise<DevMatch | undefined>;
-    renderError(request: Request, { skipMiddleware, error, status, response: _response, ...resolvedRenderOptions }: RenderErrorOptions): Promise<Response>;
+    protected createErrorHandler(): ErrorHandler;
     logRequest({ pathname, method, statusCode, isRewrite, reqTime }: LogRequestPayload): void;
 }

package/dist/core/app/dev/app.js

@@ -1,10 +1,6 @@
-import { MiddlewareNoDataOrNextCalled, MiddlewareNotAResponse } from "../../errors/errors-data.js";
-import { isAstroError } from "../../errors/index.js";
-import {
-  BaseApp
-} from "../base.js";
+import { DevErrorHandler } from "../../errors/dev-handler.js";
+import { BaseApp } from "../base.js";
 import { NonRunnablePipeline } from "./pipeline.js";
-import { getCustom404Route, getCustom500Route } from "../../routing/helpers.js";
 import { ensure404Route } from "../../routing/astro-designed-error-pages.js";
 import { matchRoute } from "../../routing/dev.js";
 import { req } from "../../messages/runtime.js";
@@ -53,60 +49,8 @@ class DevApp extends BaseApp {
       resolvedPathname: matchedRoute.resolvedPathname
     };
   }
-  async renderError(request, {
-    skipMiddleware = false,
-    error,
-    status,
-    response: _response,
-    ...resolvedRenderOptions
-  }) {
-    if (isAstroError(error) && [MiddlewareNoDataOrNextCalled.name, MiddlewareNotAResponse.name].includes(error.name)) {
-      throw error;
-    }
-    const renderRoute = async (routeData) => {
-      try {
-        const preloadedComponent = await this.pipeline.getComponentByRoute(routeData);
-        const renderContext = await this.createRenderContext({
-          locals: resolvedRenderOptions.locals,
-          pipeline: this.pipeline,
-          pathname: this.getPathnameFromRequest(request),
-          skipMiddleware,
-          request,
-          routeData,
-          clientAddress: resolvedRenderOptions.clientAddress,
-          status,
-          shouldInjectCspMetaTags: false
-        });
-        renderContext.props.error = error;
-        const response = await renderContext.render(preloadedComponent);
-        if (error) {
-          this.logger.error("router", error.stack || error.message);
-        }
-        return response;
-      } catch (_err) {
-        if (skipMiddleware === false) {
-          return this.renderError(request, {
-            ...resolvedRenderOptions,
-            status: 500,
-            skipMiddleware: true,
-            error: _err
-          });
-        }
-        throw _err;
-      }
-    };
-    if (status === 404) {
-      const custom404 = getCustom404Route(this.manifestData);
-      if (custom404) {
-        return renderRoute(custom404);
-      }
-    }
-    const custom500 = getCustom500Route(this.manifestData);
-    if (!custom500) {
-      throw error;
-    } else {
-      return renderRoute(custom500);
-    }
+  createErrorHandler() {
+    return new DevErrorHandler(this, { shouldInjectCspMetaTags: false });
   }
   logRequest({ pathname, method, statusCode, isRewrite, reqTime }) {
     if (pathname === "/favicon.ico") {

package/dist/core/app/entrypoints/virtual/dev.js

@@ -1,3 +1,4 @@
+import fetchable from "virtual:astro:fetchable";
 import { manifest } from "virtual:astro:manifest";
 import { DevApp } from "../../dev/app.js";
 import { createConsoleLogger } from "../../../logger/impls/console.js";
@@ -5,6 +6,7 @@ let currentDevApp = null;
 const createApp = ({ streaming } = {}) => {
   const logger = createConsoleLogger(manifest.logLevel);
   currentDevApp = new DevApp(manifest, streaming, logger);
+  currentDevApp.setFetchHandler(fetchable);
   if (import.meta.hot) {
     import.meta.hot.on("astro:routes-updated", async () => {
       if (!currentDevApp) return;

package/dist/core/app/entrypoints/virtual/prod.js

@@ -1,7 +1,10 @@
+import fetchable from "virtual:astro:fetchable";
 import { manifest } from "virtual:astro:manifest";
 import { App } from "../../app.js";
 const createApp = ({ streaming } = {}) => {
-  return new App(manifest, streaming);
+  const app = new App(manifest, streaming);
+  app.setFetchHandler(fetchable);
+  return app;
 };
 export {
   createApp

package/dist/core/app/prepare-response.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Strips internal-only headers from the response before sending it to the
+ * user agent, and optionally appends cookies written via `Astro.cookie.set()`
+ * to the `Set-Cookie` header.
+ *
+ * This is a pure function with no dependencies on the app; it is shared by
+ * `AstroHandler` and the various error handlers.
+ */
+export declare function prepareResponse(response: Response, { addCookieHeader }: {
+    addCookieHeader: boolean;
+}): void;

package/dist/core/app/prepare-response.js

@@ -0,0 +1,18 @@
+import { INTERNAL_RESPONSE_HEADERS, responseSentSymbol } from "../constants.js";
+import { getSetCookiesFromResponse } from "../cookies/index.js";
+function prepareResponse(response, { addCookieHeader }) {
+  for (const headerName of INTERNAL_RESPONSE_HEADERS) {
+    if (response.headers.has(headerName)) {
+      response.headers.delete(headerName);
+    }
+  }
+  if (addCookieHeader) {
+    for (const setCookieHeaderValue of getSetCookiesFromResponse(response)) {
+      response.headers.append("set-cookie", setCookieHeaderValue);
+    }
+  }
+  Reflect.set(response, responseSentSymbol, true);
+}
+export {
+  prepareResponse
+};

package/dist/core/app/render-options.d.ts

@@ -0,0 +1,11 @@
+import type { ResolvedRenderOptions } from './base.js';
+/**
+ * Reads `ResolvedRenderOptions` that were attached to a request via
+ * `renderOptionsSymbol`. Returns `undefined` if no options are attached.
+ */
+export declare function getRenderOptions(request: Request): ResolvedRenderOptions | undefined;
+/**
+ * Attaches `ResolvedRenderOptions` to a request via `renderOptionsSymbol` so
+ * that downstream handlers can read them.
+ */
+export declare function setRenderOptions(request: Request, options: ResolvedRenderOptions): void;

package/dist/core/app/render-options.js

@@ -0,0 +1,11 @@
+const renderOptionsSymbol = /* @__PURE__ */ Symbol.for("astro.renderOptions");
+function getRenderOptions(request) {
+  return Reflect.get(request, renderOptionsSymbol);
+}
+function setRenderOptions(request, options) {
+  Reflect.set(request, renderOptionsSymbol, options);
+}
+export {
+  getRenderOptions,
+  setRenderOptions
+};

package/dist/core/base-pipeline.d.ts

@@ -14,13 +14,29 @@ import type { CompiledCacheRoute } from './cache/runtime/route-matching.js';
 import type { SessionDriverFactory } from './session/types.js';
 import { NodePool } from '../runtime/server/render/queue/pool.js';
 import { HTMLStringCache } from '../runtime/server/html-string-cache.js';
+/**
+ * Bit flags for pipeline features that handler classes register as
+ * "used" when a custom `src/app.ts` fetch handler is in play. After the
+ * first request (dev) or at runtime (prod SSR), we compare against the
+ * manifest to warn about features the user configured but forgot to
+ * include in their custom pipeline.
+ */
+export declare const PipelineFeatures: {
+    readonly redirects: number;
+    readonly sessions: number;
+    readonly actions: number;
+    readonly middleware: number;
+    readonly i18n: number;
+    readonly cache: number;
+};
 /**
  * The `Pipeline` represents the static parts of rendering that do not change between requests.
  * These are mostly known when the server first starts up and do not change.
  *
- * Thus, a `Pipeline` is created once at process start and then used by every `RenderContext`.
+ * Thus, a `Pipeline` is created once at process start and then used by every `FetchState`.
  */
 export declare abstract class Pipeline {
+    #private;
     readonly internalMiddleware: MiddlewareHandler[];
     resolvedMiddleware: MiddlewareHandler | undefined;
     resolvedLogger: boolean;
@@ -30,6 +46,12 @@ export declare abstract class Pipeline {
     compiledCacheRoutes: CompiledCacheRoute[] | undefined;
     nodePool: NodePool | undefined;
     htmlStringCache: HTMLStringCache | undefined;
+    /**
+     * Bit mask of pipeline features activated by handler classes.
+     * Each handler sets its bit via `|=`. Only meaningful when a
+     * custom `src/app.ts` fetch handler is in use.
+     */
+    usedFeatures: number;
     logger: AstroLogger;
     readonly manifest: SSRManifest;
     /**
@@ -63,6 +85,10 @@ export declare abstract class Pipeline {
     readonly cacheProvider: SSRManifest['cacheProvider'];
     readonly cacheConfig: SSRManifest['cacheConfig'];
     readonly serverIslands: SSRManifest['serverIslandMappings'];
+    /** Route data derived from the manifest, used for route matching. */
+    manifestData: {
+        routes: RouteData[];
+    };
     constructor(logger: AstroLogger, manifest: SSRManifest, 
     /**
      * "development" or "production" only
@@ -85,6 +111,17 @@ export declare abstract class Pipeline {
     }>) | undefined, cacheProvider?: (() => Promise<{
         default: CacheProviderFactory | null;
     }>) | undefined, cacheConfig?: import("./cache/types.js").SSRManifestCache | undefined, serverIslands?: (() => Promise<ServerIslandMappings> | ServerIslandMappings) | undefined);
+    /**
+     * Low-level route matching against the manifest routes. Returns the
+     * matched `RouteData` or `undefined`. Does not filter prerendered
+     * routes or check public assets — use `BaseApp.match()` for that.
+     */
+    matchRoute(pathname: string): RouteData | undefined;
+    /**
+     * Rebuilds the internal router after routes have been added or
+     * removed (e.g. by the dev server on HMR).
+     */
+    rebuildRouter(): void;
     abstract headElements(routeData: RouteData): Promise<HeadElements> | HeadElements;
     abstract componentMetadata(routeData: RouteData): Promise<SSRResult['componentMetadata']> | void;
     /**

package/dist/core/base-pipeline.js

@@ -1,5 +1,4 @@
 import { NOOP_ACTIONS_MOD } from "../actions/noop-actions.js";
-import { createI18nMiddleware } from "../i18n/middleware.js";
 import { createOriginCheckMiddleware } from "./app/middlewares.js";
 import { ActionNotFoundError } from "./errors/errors-data.js";
 import { AstroError } from "./errors/index.js";
@@ -8,10 +7,20 @@ import { sequence } from "./middleware/sequence.js";
 import { RedirectSinglePageBuiltModule } from "./redirects/index.js";
 import { RouteCache } from "./render/route-cache.js";
 import { createDefaultRoutes } from "./routing/default.js";
+import { ensure404Route } from "./routing/astro-designed-error-pages.js";
+import { Router } from "./routing/router.js";
 import { NodePool } from "../runtime/server/render/queue/pool.js";
 import { HTMLStringCache } from "../runtime/server/html-string-cache.js";
 import { FORBIDDEN_PATH_KEYS } from "@astrojs/internal-helpers/object";
 import { loadLogger } from "./logger/load.js";
+const PipelineFeatures = {
+  redirects: 1 << 0,
+  sessions: 1 << 1,
+  actions: 1 << 2,
+  middleware: 1 << 3,
+  i18n: 1 << 4,
+  cache: 1 << 5
+};
 class Pipeline {
   internalMiddleware;
   resolvedMiddleware = void 0;
@@ -22,6 +31,12 @@ class Pipeline {
   compiledCacheRoutes = void 0;
   nodePool;
   htmlStringCache;
+  /**
+   * Bit mask of pipeline features activated by handler classes.
+   * Each handler sets its bit via `|=`. Only meaningful when a
+   * custom `src/app.ts` fetch handler is in use.
+   */
+  usedFeatures = 0;
   logger;
   manifest;
   /**
@@ -55,6 +70,10 @@ class Pipeline {
   cacheProvider;
   cacheConfig;
   serverIslands;
+  /** Route data derived from the manifest, used for route matching. */
+  manifestData;
+  /** Pattern-matching router built from manifestData. */
+  #router;
   constructor(logger, manifest, runtimeMode, renderers, resolve, streaming, adapterName = manifest.adapterName, clientDirectives = manifest.clientDirectives, inlinedScripts = manifest.inlinedScripts, compressHTML = manifest.compressHTML, i18n = manifest.i18n, middleware = manifest.middleware, routeCache = new RouteCache(logger, runtimeMode), site = manifest.site ? new URL(manifest.site) : void 0, defaultRoutes = createDefaultRoutes(manifest), actions = manifest.actions, sessionDriver = manifest.sessionDriver, cacheProvider = manifest.cacheProvider, cacheConfig = manifest.cacheConfig, serverIslands = manifest.serverIslandMappings) {
     this.logger = logger;
     this.manifest = manifest;
@@ -76,12 +95,14 @@ class Pipeline {
     this.cacheProvider = cacheProvider;
     this.cacheConfig = cacheConfig;
     this.serverIslands = serverIslands;
+    this.manifestData = { routes: (manifest.routes ?? []).map((route) => route.routeData) };
+    ensure404Route(this.manifestData);
+    this.#router = new Router(this.manifestData.routes, {
+      base: manifest.base,
+      trailingSlash: manifest.trailingSlash,
+      buildFormat: manifest.buildFormat
+    });
     this.internalMiddleware = [];
-    if (i18n?.strategy !== "manual") {
-      this.internalMiddleware.push(
-        createI18nMiddleware(i18n, manifest.base, manifest.trailingSlash, manifest.buildFormat)
-      );
-    }
     if (manifest.experimentalQueuedRendering.enabled) {
       this.nodePool = this.createNodePool(
         manifest.experimentalQueuedRendering.poolSize ?? 1e3,
@@ -92,6 +113,27 @@ class Pipeline {
       }
     }
   }
+  /**
+   * Low-level route matching against the manifest routes. Returns the
+   * matched `RouteData` or `undefined`. Does not filter prerendered
+   * routes or check public assets — use `BaseApp.match()` for that.
+   */
+  matchRoute(pathname) {
+    const match = this.#router.match(pathname, { allowWithoutBase: true });
+    if (match.type !== "match") return void 0;
+    return match.route;
+  }
+  /**
+   * Rebuilds the internal router after routes have been added or
+   * removed (e.g. by the dev server on HMR).
+   */
+  rebuildRouter() {
+    this.#router = new Router(this.manifestData.routes, {
+      base: this.manifest.base,
+      trailingSlash: this.manifest.trailingSlash,
+      buildFormat: this.manifest.buildFormat
+    });
+  }
   /**
    * Resolves the middleware from the manifest, and returns the `onRequest` function. If `onRequest` isn't there,
    * it returns a no-op function
@@ -243,5 +285,6 @@ class Pipeline {
   }
 }
 export {
-  Pipeline
+  Pipeline,
+  PipelineFeatures
 };

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

@@ -1,20 +1,19 @@
-import { BaseApp, type RenderErrorOptions } from '../app/entrypoints/index.js';
+import { BaseApp } from '../app/entrypoints/index.js';
 import type { SSRManifest } from '../app/types.js';
 import type { BuildInternals } from './internal.js';
 import { BuildPipeline } from './pipeline.js';
 import type { StaticBuildOptions } from './types.js';
-import type { CreateRenderContext, RenderContext } from '../render-context.js';
 import type { LogRequestPayload } from '../app/base.js';
+import type { ErrorHandler } from '../errors/handler.js';
 import type { PoolStatsReport } from '../../runtime/server/render/queue/pool.js';
 export declare class BuildApp extends BaseApp<BuildPipeline> {
     createPipeline(_streaming: boolean, manifest: SSRManifest, ..._args: any[]): BuildPipeline;
-    createRenderContext(payload: CreateRenderContext): Promise<RenderContext>;
     isDev(): boolean;
     setInternals(internals: BuildInternals): void;
     setOptions(options: StaticBuildOptions): void;
     getOptions(): StaticBuildOptions;
     getSettings(): import("../../types/astro.js").AstroSettings;
-    renderError(request: Request, options: RenderErrorOptions): Promise<Response>;
+    protected createErrorHandler(): ErrorHandler;
     getQueueStats(): PoolStatsReport | undefined;
     logRequest(_options: LogRequestPayload): void;
 }

package/dist/core/build/app.js

@@ -1,16 +1,12 @@
 import { BaseApp } from "../app/entrypoints/index.js";
 import { BuildPipeline } from "./pipeline.js";
+import { BuildErrorHandler } from "../errors/build-handler.js";
 class BuildApp extends BaseApp {
   createPipeline(_streaming, manifest, ..._args) {
     return BuildPipeline.create({
       manifest
     });
   }
-  async createRenderContext(payload) {
-    return await super.createRenderContext({
-      ...payload
-    });
-  }
   isDev() {
     return true;
   }
@@ -28,18 +24,8 @@ class BuildApp extends BaseApp {
   getSettings() {
     return this.pipeline.getSettings();
   }
-  async renderError(request, options) {
-    if (options.status === 500) {
-      if (options.response) {
-        return options.response;
-      }
-      throw options.error;
-    } else {
-      return super.renderError(request, {
-        ...options,
-        prerenderedErrorPageFetch: void 0
-      });
-    }
+  createErrorHandler() {
+    return new BuildErrorHandler(this);
   }
   getQueueStats() {
     if (this.pipeline.nodePool) {

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

@@ -0,0 +1,29 @@
+import type { BaseApp } from '../app/base.js';
+import type { FetchState } from '../fetch/fetch-state.js';
+import type { Pipeline } from '../base-pipeline.js';
+/**
+ * Registers a cache provider on the given `FetchState`. When
+ * `state.resolve('cache')` is first called, the appropriate cache
+ * implementation is created (disabled, noop for dev, or real).
+ *
+ * Returns synchronously when cache is not configured or in dev mode.
+ */
+export declare function provideCache(state: FetchState): Promise<void> | void;
+/**
+ * Wraps a render callback with cache provider logic. Handles both
+ * runtime caching (onRequest) and CDN-based providers (headers only).
+ *
+ * - When a cache provider with `onRequest` is configured, the callback
+ *   is wrapped so the provider can serve from cache or fall through.
+ * - When only CDN headers are needed, the callback runs directly and
+ *   cache headers are applied to the response.
+ * - When no cache provider is configured, the callback runs as-is.
+ *
+ * Cache headers (`CDN-Cache-Control`, `Cache-Tag`) are stripped from
+ * the final response after the runtime provider has read them.
+ */
+export declare class CacheHandler {
+    #private;
+    constructor(app: BaseApp<Pipeline>);
+    handle(state: FetchState, next: () => Promise<Response>): Promise<Response>;
+}

package/dist/core/cache/handler.js

@@ -0,0 +1,81 @@
+import { PipelineFeatures } from "../base-pipeline.js";
+import { AstroCache, applyCacheHeaders } from "./runtime/cache.js";
+import { NoopAstroCache, DisabledAstroCache } from "./runtime/noop.js";
+import { compileCacheRoutes, matchCacheRoute } from "./runtime/route-matching.js";
+const CACHE_KEY = "cache";
+function provideCache(state) {
+  const pipeline = state.pipeline;
+  if (!pipeline.cacheConfig) {
+    state.provide(CACHE_KEY, {
+      create: () => new DisabledAstroCache(pipeline.logger)
+    });
+    return;
+  }
+  if (pipeline.runtimeMode === "development") {
+    state.provide(CACHE_KEY, {
+      create: () => new NoopAstroCache()
+    });
+    return;
+  }
+  return provideCacheAsync(state, pipeline);
+}
+async function provideCacheAsync(state, pipeline) {
+  const cacheProvider = await pipeline.getCacheProvider();
+  state.provide(CACHE_KEY, {
+    create() {
+      const cache = new AstroCache(cacheProvider);
+      if (pipeline.cacheConfig?.routes) {
+        if (!pipeline.compiledCacheRoutes) {
+          pipeline.compiledCacheRoutes = compileCacheRoutes(
+            pipeline.cacheConfig.routes,
+            pipeline.manifest.base,
+            pipeline.manifest.trailingSlash
+          );
+        }
+        const matched = matchCacheRoute(state.pathname, pipeline.compiledCacheRoutes);
+        if (matched) {
+          cache.set(matched);
+        }
+      }
+      return cache;
+    }
+  });
+}
+class CacheHandler {
+  #app;
+  constructor(app) {
+    this.#app = app;
+  }
+  async handle(state, next) {
+    this.#app.pipeline.usedFeatures |= PipelineFeatures.cache;
+    if (!this.#app.pipeline.cacheProvider) {
+      return next();
+    }
+    const cache = state.resolve(CACHE_KEY);
+    const cacheProvider = await this.#app.pipeline.getCacheProvider();
+    if (cacheProvider?.onRequest) {
+      const response2 = await cacheProvider.onRequest(
+        {
+          request: state.request,
+          url: new URL(state.request.url),
+          waitUntil: state.renderOptions.waitUntil
+        },
+        async () => {
+          const res = await next();
+          applyCacheHeaders(cache, res);
+          return res;
+        }
+      );
+      response2.headers.delete("CDN-Cache-Control");
+      response2.headers.delete("Cache-Tag");
+      return response2;
+    }
+    const response = await next();
+    applyCacheHeaders(cache, response);
+    return response;
+  }
+}
+export {
+  CacheHandler,
+  provideCache
+};

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

@@ -43,6 +43,7 @@ export declare const ASTRO_CONFIG_DEFAULTS: {
             entrypoint: "astro/assets/services/sharp";
             config: {};
         };
+        dangerouslyProcessSVG: false;
         responsiveStyles: false;
     };
     devToolbar: {
@@ -75,6 +76,7 @@ export declare const ASTRO_CONFIG_DEFAULTS: {
     };
     prerenderConflictBehavior: "warn";
     experimental: {
+        advancedRouting: false;
         clientPrerender: false;
         contentIntellisense: false;
         chromeDevtoolsWorkspace: false;
@@ -153,6 +155,7 @@ export declare const AstroConfigSchema: z.ZodObject<{
             entrypoint: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"astro/assets/services/sharp">, z.ZodString]>>;
             config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodAny>>;
         }, z.core.$strip>>;
+        dangerouslyProcessSVG: z.ZodDefault<z.ZodBoolean>;
         domains: z.ZodDefault<z.ZodArray<z.ZodString>>;
         remotePatterns: z.ZodDefault<z.ZodArray<z.ZodObject<{
             protocol: z.ZodOptional<z.ZodString>;
@@ -498,6 +501,7 @@ export declare const AstroConfigSchema: z.ZodObject<{
         options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     }, z.core.$strict>>>;
     experimental: z.ZodPrefault<z.ZodObject<{
+        advancedRouting: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         clientPrerender: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         contentIntellisense: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         chromeDevtoolsWorkspace: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;

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

@@ -28,6 +28,7 @@ const ASTRO_CONFIG_DEFAULTS = {
   image: {
     endpoint: { entrypoint: void 0, route: "/_image" },
     service: { entrypoint: "astro/assets/services/sharp", config: {} },
+    dangerouslyProcessSVG: false,
     responsiveStyles: false
   },
   devToolbar: {
@@ -60,6 +61,7 @@ const ASTRO_CONFIG_DEFAULTS = {
   },
   prerenderConflictBehavior: "warn",
   experimental: {
+    advancedRouting: false,
     clientPrerender: false,
     contentIntellisense: false,
     chromeDevtoolsWorkspace: false,
@@ -171,6 +173,7 @@ const AstroConfigSchema = z.object({
       entrypoint: z.union([z.literal("astro/assets/services/sharp"), z.string()]).default(ASTRO_CONFIG_DEFAULTS.image.service.entrypoint),
       config: z.record(z.string(), z.any()).default({})
     }).default(ASTRO_CONFIG_DEFAULTS.image.service),
+    dangerouslyProcessSVG: z.boolean().default(ASTRO_CONFIG_DEFAULTS.image.dangerouslyProcessSVG),
     domains: z.array(z.string()).default([]),
     remotePatterns: z.array(
       z.object({
@@ -307,6 +310,7 @@ const AstroConfigSchema = z.object({
   prerenderConflictBehavior: z.enum(["error", "warn", "ignore"]).optional().default(ASTRO_CONFIG_DEFAULTS.prerenderConflictBehavior),
   fonts: z.array(FontFamilySchema).optional(),
   experimental: z.strictObject({
+    advancedRouting: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.advancedRouting),
     clientPrerender: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.clientPrerender),
     contentIntellisense: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.contentIntellisense),
     chromeDevtoolsWorkspace: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.chromeDevtoolsWorkspace),

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

@@ -36,6 +36,7 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
             entrypoint: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"astro/assets/services/sharp">, z.ZodString]>>;
             config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodAny>>;
         }, z.core.$strip>>;
+        dangerouslyProcessSVG: z.ZodDefault<z.ZodBoolean>;
         domains: z.ZodDefault<z.ZodArray<z.ZodString>>;
         remotePatterns: z.ZodDefault<z.ZodArray<z.ZodObject<{
             protocol: z.ZodOptional<z.ZodString>;
@@ -381,6 +382,7 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     }, z.core.$strict>>>;
     experimental: z.ZodPrefault<z.ZodObject<{
+        advancedRouting: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         clientPrerender: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         contentIntellisense: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         chromeDevtoolsWorkspace: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -468,6 +470,7 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
             entrypoint: string;
             config: Record<string, any>;
         };
+        dangerouslyProcessSVG: boolean;
         domains: string[];
         remotePatterns: {
             protocol?: string | undefined;
@@ -573,6 +576,7 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
     };
     prerenderConflictBehavior: "error" | "ignore" | "warn";
     experimental: {
+        advancedRouting: boolean;
         clientPrerender: boolean;
         contentIntellisense: boolean;
         chromeDevtoolsWorkspace: boolean;
@@ -716,6 +720,7 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
             entrypoint: string;
             config: Record<string, any>;
         };
+        dangerouslyProcessSVG: boolean;
         domains: string[];
         remotePatterns: {
             protocol?: string | undefined;
@@ -821,6 +826,7 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
     };
     prerenderConflictBehavior: "error" | "ignore" | "warn";
     experimental: {
+        advancedRouting: boolean;
         clientPrerender: boolean;
         contentIntellisense: boolean;
         chromeDevtoolsWorkspace: boolean;