astro 6.2.2 → 6.3.0

package/dist/core/constants.d.ts

@@ -35,6 +35,17 @@ export declare const NOOP_MIDDLEWARE_HEADER = "X-Astro-Noop";
  * The name for the header used to help i18n middleware, which only needs to act on "page" and "fallback" route types.
  */
 export declare const ROUTE_TYPE_HEADER = "X-Astro-Route-Type";
+/**
+ * Internal headers that should be stripped from the response before
+ * sending it to the user agent. Add new internal headers here so
+ * `prepareResponse` removes them automatically.
+ */
+export declare const INTERNAL_RESPONSE_HEADERS: readonly ["X-Astro-Reroute", "X-Astro-Rewrite", "X-Astro-Noop", "X-Astro-Route-Type"];
+/**
+ * Set by internal handlers (e.g. PagesHandler) to signal that a
+ * response should be replaced with the corresponding error page.
+ */
+export declare const ASTRO_ERROR_HEADER = "X-Astro-Error";
 /**
  * The value of the `component` field of the default 404 page, which is used when there is no user-provided 404.astro page.
  */
@@ -55,7 +66,7 @@ export declare const REROUTABLE_STATUS_CODES: number[];
 export declare const clientAddressSymbol: unique symbol;
 /**
  * The symbol used as a field on the request object to store the object to be made available to Astro APIs as `locals`.
- * Use judiciously, as locals are now stored within `RenderContext` by default. Tacking it onto request is no longer necessary.
+ * Use judiciously, as locals are now stored within `FetchState` by default. Tacking it onto request is no longer necessary.
  */
 export declare const clientLocalsSymbol: unique symbol;
 /**
@@ -66,6 +77,21 @@ export declare const originPathnameSymbol: unique symbol;
  * Use this symbol to set and retrieve the pipeline.
  */
 export declare const pipelineSymbol: unique symbol;
+/**
+ * Use this symbol to stash the active `FetchState` on an `APIContext`
+ * (or `ActionAPIContext`). Consumed by internal shims that need access
+ * to per-request state without appearing in the public context shape
+ * — e.g. the manual-strategy i18n middleware wrapper in
+ * `src/i18n/middleware.ts`.
+ */
+export declare const fetchStateSymbol: unique symbol;
+/**
+ * Use this symbol to stash the `BaseApp` on an incoming `Request` at the
+ * top of the pipeline. Fetch handlers loaded from `virtual:astro:fetchable`
+ * (including `DefaultFetchHandler`) read it to find the app associated
+ * with the current request without needing App passed to their constructor.
+ */
+export declare const appSymbol: unique symbol;
 /**
  * Use this symbol to opt into handling prerender routes in Astro core dev middleware.
  */

package/dist/core/constants.js

@@ -1,10 +1,17 @@
-const ASTRO_VERSION = "6.2.2";
+const ASTRO_VERSION = "6.3.0";
 const ASTRO_GENERATOR = `Astro v${ASTRO_VERSION}`;
 const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";
 const REWRITE_DIRECTIVE_HEADER_KEY = "X-Astro-Rewrite";
 const REWRITE_DIRECTIVE_HEADER_VALUE = "yes";
 const NOOP_MIDDLEWARE_HEADER = "X-Astro-Noop";
 const ROUTE_TYPE_HEADER = "X-Astro-Route-Type";
+const INTERNAL_RESPONSE_HEADERS = [
+  REROUTE_DIRECTIVE_HEADER,
+  REWRITE_DIRECTIVE_HEADER_KEY,
+  NOOP_MIDDLEWARE_HEADER,
+  ROUTE_TYPE_HEADER
+];
+const ASTRO_ERROR_HEADER = "X-Astro-Error";
 const DEFAULT_404_COMPONENT = "astro-default-404.astro";
 const REDIRECT_STATUS_CODES = [301, 302, 303, 307, 308, 300, 304];
 const REROUTABLE_STATUS_CODES = [404, 500];
@@ -12,6 +19,8 @@ const clientAddressSymbol = /* @__PURE__ */ Symbol.for("astro.clientAddress");
 const clientLocalsSymbol = /* @__PURE__ */ Symbol.for("astro.locals");
 const originPathnameSymbol = /* @__PURE__ */ Symbol.for("astro.originPathname");
 const pipelineSymbol = /* @__PURE__ */ Symbol.for("astro.pipeline");
+const fetchStateSymbol = /* @__PURE__ */ Symbol.for("astro.fetchState");
+const appSymbol = /* @__PURE__ */ Symbol.for("astro.app");
 const devPrerenderMiddlewareSymbol = /* @__PURE__ */ Symbol.for("astro.devPrerenderMiddleware");
 const nodeRequestAbortControllerCleanupSymbol = /* @__PURE__ */ Symbol.for(
   "astro.nodeRequestAbortControllerCleanup"
@@ -43,10 +52,12 @@ const ASTRO_VITE_ENVIRONMENT_NAMES = {
   prerender: "prerender"
 };
 export {
+  ASTRO_ERROR_HEADER,
   ASTRO_GENERATOR,
   ASTRO_VERSION,
   ASTRO_VITE_ENVIRONMENT_NAMES,
   DEFAULT_404_COMPONENT,
+  INTERNAL_RESPONSE_HEADERS,
   MIDDLEWARE_PATH_SEGMENT_NAME,
   NOOP_MIDDLEWARE_HEADER,
   REDIRECT_STATUS_CODES,
@@ -56,9 +67,11 @@ export {
   REWRITE_DIRECTIVE_HEADER_VALUE,
   ROUTE_TYPE_HEADER,
   SUPPORTED_MARKDOWN_FILE_EXTENSIONS,
+  appSymbol,
   clientAddressSymbol,
   clientLocalsSymbol,
   devPrerenderMiddlewareSymbol,
+  fetchStateSymbol,
   nodeRequestAbortControllerCleanupSymbol,
   originPathnameSymbol,
   pipelineSymbol,

package/dist/core/cookies/cookies.d.ts

@@ -72,8 +72,13 @@ declare class AstroCookies implements AstroCookiesInterface {
      */
     headers(): Generator<string, void, unknown>;
     /**
-     * Behaves the same as AstroCookies.prototype.headers(),
-     * but allows a warning when cookies are set after the instance is consumed.
+     * Marks the cookies as consumed and returns the header values.
+     * After consumption, any subsequent `set()` calls will warn.
+     */
+    consume(): Generator<string, void, unknown>;
+    /**
+     * @deprecated Use the instance method `cookies.consume()` instead.
+     * Kept for backward compatibility with adapters.
      */
     static consume(cookies: AstroCookies): Generator<string, void, unknown>;
 }

package/dist/core/cookies/cookies.js

@@ -173,12 +173,19 @@ class AstroCookies {
     }
   }
   /**
-   * Behaves the same as AstroCookies.prototype.headers(),
-   * but allows a warning when cookies are set after the instance is consumed.
+   * Marks the cookies as consumed and returns the header values.
+   * After consumption, any subsequent `set()` calls will warn.
+   */
+  consume() {
+    this.#consumed = true;
+    return this.headers();
+  }
+  /**
+   * @deprecated Use the instance method `cookies.consume()` instead.
+   * Kept for backward compatibility with adapters.
    */
   static consume(cookies) {
-    cookies.#consumed = true;
-    return cookies.headers();
+    return cookies.consume();
   }
   #ensureParsed() {
     if (!this.#requestValues) {

package/dist/core/cookies/response.d.ts

@@ -1,4 +1,4 @@
-import { AstroCookies } from './cookies.js';
+import type { AstroCookies } from './cookies.js';
 export declare function attachCookiesToResponse(response: Response, cookies: AstroCookies): void;
 export declare function getCookiesFromResponse(response: Response): AstroCookies | undefined;
 export declare function getSetCookiesFromResponse(response: Response): Generator<string, string[]>;

package/dist/core/cookies/response.js

@@ -1,4 +1,3 @@
-import { AstroCookies } from "./cookies.js";
 const astroCookiesSymbol = /* @__PURE__ */ Symbol.for("astro.cookies");
 function attachCookiesToResponse(response, cookies) {
   Reflect.set(response, astroCookiesSymbol, cookies);
@@ -16,7 +15,7 @@ function* getSetCookiesFromResponse(response) {
   if (!cookies) {
     return [];
   }
-  for (const headerValue of AstroCookies.consume(cookies)) {
+  for (const headerValue of cookies.consume()) {
     yield headerValue;
   }
   return [];

package/dist/core/create-vite.js

@@ -23,6 +23,7 @@ import astroDevToolbar from "../toolbar/vite-plugin-dev-toolbar.js";
 import astroTransitions from "../transitions/vite-plugin-transitions.js";
 import { vitePluginAdapterConfig } from "../vite-plugin-adapter-config/index.js";
 import { vitePluginApp } from "../vite-plugin-app/index.js";
+import { vitePluginFetchable } from "./fetch/vite-plugin.js";
 import astroVitePlugin from "../vite-plugin-astro/index.js";
 import { vitePluginAstroServer } from "../vite-plugin-astro-server/index.js";
 import configAliasVitePlugin from "../vite-plugin-config-alias/index.js";
@@ -118,6 +119,19 @@ async function createVite(commandConfig, { settings, logger, mode, command, fs =
     customLogger: createViteLogger(logger, settings.config.vite.logLevel),
     appType: "custom",
     plugins: [
+      // Raise the watcher's maxListeners limit before any other plugin's
+      // configureServer hook can add listeners. Astro registers 12+ change
+      // listeners across its built-in Vite plugins, easily exceeding
+      // Node's default limit of 10.
+      {
+        name: "astro:watcher-max-listeners",
+        configureServer(server) {
+          const current = server.watcher.getMaxListeners();
+          if (current !== 0 && current < 50) {
+            server.watcher.setMaxListeners(50);
+          }
+        }
+      },
       serializedManifestPlugin({ settings, command, sync }),
       vitePluginRenderers({
         settings,
@@ -138,6 +152,7 @@ async function createVite(commandConfig, { settings, logger, mode, command, fs =
       // The server plugin is for dev only and having it run during the build causes
       // the build to run very slow as the filewatcher is triggered often.
       vitePluginApp(),
+      vitePluginFetchable({ settings }),
       command === "dev" && vitePluginAstroServer({ settings, logger }),
       command === "dev" && vitePluginAstroServerClient(),
       astroDevCssPlugin({ routesList, command }),

package/dist/core/csp/runtime.js

@@ -8,25 +8,27 @@ function deduplicateDirectiveValues(existingDirective, newDirective) {
   return `${directiveName} ${finalDirectives.join(" ")}`;
 }
 function pushDirective(directives, newDirective) {
-  let deduplicated = false;
   if (directives.length === 0) {
     return [newDirective];
   }
   const finalDirectives = [];
+  let matched = false;
   for (const directive of directives) {
-    if (deduplicated) {
+    if (matched) {
       finalDirectives.push(directive);
       continue;
     }
     const result = deduplicateDirectiveValues(directive, newDirective);
     if (result) {
       finalDirectives.push(result);
-      deduplicated = true;
+      matched = true;
     } else {
       finalDirectives.push(directive);
-      finalDirectives.push(newDirective);
     }
   }
+  if (!matched) {
+    finalDirectives.push(newDirective);
+  }
   return finalDirectives;
 }
 export {

package/dist/core/dev/dev.js

@@ -37,7 +37,7 @@ async function dev(inlineConfig) {
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "6.2.2";
+  const currentVersion = "6.3.0";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

package/dist/core/errors/build-handler.d.ts

@@ -0,0 +1,17 @@
+import type { BaseApp, RenderErrorOptions } from '../app/base.js';
+import type { Pipeline } from '../base-pipeline.js';
+import type { ErrorHandler } from './handler.js';
+/**
+ * The error handler used during static build / prerendering.
+ *
+ * - For 500 errors, returns the original response if present, otherwise
+ *   throws so the build surfaces the underlying error to the developer.
+ * - For other errors (e.g. 404), delegates to `DefaultErrorHandler` with
+ *   `prerenderedErrorPageFetch` cleared (the build pipeline can't fetch
+ *   prerendered pages the way production SSR can).
+ */
+export declare class BuildErrorHandler implements ErrorHandler {
+    #private;
+    constructor(app: BaseApp<Pipeline>);
+    renderError(request: Request, options: RenderErrorOptions): Promise<Response>;
+}

package/dist/core/errors/build-handler.js

@@ -0,0 +1,22 @@
+import { DefaultErrorHandler } from "./default-handler.js";
+class BuildErrorHandler {
+  #default;
+  constructor(app) {
+    this.#default = new DefaultErrorHandler(app);
+  }
+  async renderError(request, options) {
+    if (options.status === 500) {
+      if (options.response) {
+        return options.response;
+      }
+      throw options.error;
+    }
+    return this.#default.renderError(request, {
+      ...options,
+      prerenderedErrorPageFetch: void 0
+    });
+  }
+}
+export {
+  BuildErrorHandler
+};

package/dist/core/errors/default-handler.d.ts

@@ -0,0 +1,14 @@
+import type { BaseApp, RenderErrorOptions } from '../app/base.js';
+import type { Pipeline } from '../base-pipeline.js';
+import type { ErrorHandler } from './handler.js';
+/**
+ * The default error handler used in production SSR. Attempts to render the
+ * matching error route (404.astro / 500.astro), falling back to a plain
+ * response with the given status. Handles prerendered error pages via
+ * `prerenderedErrorPageFetch`.
+ */
+export declare class DefaultErrorHandler implements ErrorHandler {
+    #private;
+    constructor(app: BaseApp<Pipeline>);
+    renderError(request: Request, { status, response: originalResponse, skipMiddleware, error, pathname, ...resolvedRenderOptions }: RenderErrorOptions): Promise<Response>;
+}

package/dist/core/errors/default-handler.js

@@ -0,0 +1,144 @@
+import { FetchState } from "../fetch/fetch-state.js";
+import { prepareResponse } from "../app/prepare-response.js";
+import { attachCookiesToResponse } from "../cookies/index.js";
+import { getCookiesFromResponse } from "../cookies/response.js";
+import { AstroMiddleware } from "../middleware/astro-middleware.js";
+import { PagesHandler } from "../pages/handler.js";
+import { matchRoute } from "../routing/match.js";
+import { provideSession } from "../session/handler.js";
+class DefaultErrorHandler {
+  #app;
+  #astroMiddleware;
+  #pagesHandler;
+  constructor(app) {
+    this.#app = app;
+    this.#astroMiddleware = new AstroMiddleware(app.pipeline);
+    this.#pagesHandler = new PagesHandler(app.pipeline);
+  }
+  async renderError(request, {
+    status,
+    response: originalResponse,
+    skipMiddleware = false,
+    error,
+    pathname,
+    ...resolvedRenderOptions
+  }) {
+    const app = this.#app;
+    const resolvedPathname = pathname ?? new FetchState(app.pipeline, request).pathname;
+    const errorRoutePath = `/${status}${app.manifest.trailingSlash === "always" ? "/" : ""}`;
+    const errorRouteData = matchRoute(errorRoutePath, app.manifestData);
+    const url = new URL(request.url);
+    if (errorRouteData) {
+      if (errorRouteData.prerender) {
+        const maybeDotHtml = errorRouteData.route.endsWith(`/${status}`) ? ".html" : "";
+        const statusURL = new URL(`${app.baseWithoutTrailingSlash}/${status}${maybeDotHtml}`, url);
+        if (statusURL.toString() !== request.url && resolvedRenderOptions.prerenderedErrorPageFetch) {
+          const response2 = await resolvedRenderOptions.prerenderedErrorPageFetch(
+            statusURL.toString()
+          );
+          const override = { status, removeContentEncodingHeaders: true };
+          const newResponse = mergeResponses(response2, originalResponse, override);
+          prepareResponse(newResponse, resolvedRenderOptions);
+          return newResponse;
+        }
+      }
+      const mod = await app.pipeline.getComponentByRoute(errorRouteData);
+      const errorState = new FetchState(app.pipeline, request);
+      errorState.skipMiddleware = skipMiddleware;
+      errorState.clientAddress = resolvedRenderOptions.clientAddress;
+      errorState.routeData = errorRouteData;
+      errorState.pathname = resolvedPathname;
+      errorState.status = status;
+      errorState.componentInstance = mod;
+      errorState.locals = resolvedRenderOptions.locals ?? {};
+      errorState.initialProps = { error };
+      try {
+        await provideSession(errorState);
+        const response2 = await this.#astroMiddleware.handle(
+          errorState,
+          this.#pagesHandler.handle.bind(this.#pagesHandler)
+        );
+        const newResponse = mergeResponses(response2, originalResponse);
+        prepareResponse(newResponse, resolvedRenderOptions);
+        return newResponse;
+      } catch {
+        if (skipMiddleware === false) {
+          return this.renderError(request, {
+            ...resolvedRenderOptions,
+            status,
+            response: originalResponse,
+            skipMiddleware: true,
+            pathname: resolvedPathname
+          });
+        }
+      } finally {
+        await errorState.finalizeAll();
+      }
+    }
+    const response = mergeResponses(new Response(null, { status }), originalResponse);
+    prepareResponse(response, resolvedRenderOptions);
+    return response;
+  }
+}
+function mergeResponses(newResponse, originalResponse, override) {
+  let newResponseHeaders = newResponse.headers;
+  if (override?.removeContentEncodingHeaders) {
+    newResponseHeaders = new Headers(newResponseHeaders);
+    newResponseHeaders.delete("Content-Encoding");
+    newResponseHeaders.delete("Content-Length");
+  }
+  if (!originalResponse) {
+    if (override !== void 0) {
+      return new Response(newResponse.body, {
+        status: override.status,
+        statusText: newResponse.statusText,
+        headers: newResponseHeaders
+      });
+    }
+    return newResponse;
+  }
+  const status = override?.status ? override.status : originalResponse.status === 200 ? newResponse.status : originalResponse.status;
+  try {
+    originalResponse.headers.delete("Content-type");
+    originalResponse.headers.delete("Content-Length");
+    originalResponse.headers.delete("Transfer-Encoding");
+  } catch {
+  }
+  const newHeaders = new Headers();
+  const seen = /* @__PURE__ */ new Set();
+  for (const [name, value] of originalResponse.headers) {
+    newHeaders.append(name, value);
+    seen.add(name.toLowerCase());
+  }
+  for (const [name, value] of newResponseHeaders) {
+    if (!seen.has(name.toLowerCase())) {
+      newHeaders.append(name, value);
+    }
+  }
+  const mergedResponse = new Response(newResponse.body, {
+    status,
+    statusText: status === 200 ? newResponse.statusText : originalResponse.statusText,
+    // If you're looking at here for possible bugs, it means that it's not a bug.
+    // With the middleware, users can meddle with headers, and we should pass to the 404/500.
+    // If users see something weird, it's because they are setting some headers they should not.
+    //
+    // Although, we don't want it to replace the content-type, because the error page must return `text/html`
+    headers: newHeaders
+  });
+  const originalCookies = getCookiesFromResponse(originalResponse);
+  const newCookies = getCookiesFromResponse(newResponse);
+  if (originalCookies) {
+    if (newCookies) {
+      for (const cookieValue of newCookies.consume()) {
+        originalResponse.headers.append("set-cookie", cookieValue);
+      }
+    }
+    attachCookiesToResponse(mergedResponse, originalCookies);
+  } else if (newCookies) {
+    attachCookiesToResponse(mergedResponse, newCookies);
+  }
+  return mergedResponse;
+}
+export {
+  DefaultErrorHandler
+};

package/dist/core/errors/dev-handler.d.ts

@@ -0,0 +1,21 @@
+import type { BaseApp, RenderErrorOptions } from '../app/base.js';
+import type { Pipeline } from '../base-pipeline.js';
+import type { ErrorHandler } from './handler.js';
+export interface DevErrorHandlerOptions {
+    /**
+     * Whether to inject CSP meta tags into the rendered error page response.
+     * The Vite dev server injects them; the non-runnable dev pipeline does not.
+     */
+    shouldInjectCspMetaTags: boolean;
+}
+/**
+ * The dev-server error handler. Renders custom 404/500 routes if the user
+ * has them, otherwise throws so Vite's dev overlay is shown. Shared between
+ * the Vite dev server (`AstroServerApp`) and the non-runnable dev pipeline
+ * (`DevApp`); only `shouldInjectCspMetaTags` differs between them.
+ */
+export declare class DevErrorHandler implements ErrorHandler {
+    #private;
+    constructor(app: BaseApp<Pipeline>, options: DevErrorHandlerOptions);
+    renderError(request: Request, { skipMiddleware, error, status, response: _response, pathname, ...resolvedRenderOptions }: RenderErrorOptions): Promise<Response>;
+}

package/dist/core/errors/dev-handler.js

@@ -0,0 +1,82 @@
+import { FetchState } from "../fetch/fetch-state.js";
+import { AstroMiddleware } from "../middleware/astro-middleware.js";
+import { PagesHandler } from "../pages/handler.js";
+import { getCustom404Route, getCustom500Route } from "../routing/helpers.js";
+import { isAstroError } from "./index.js";
+import { MiddlewareNoDataOrNextCalled, MiddlewareNotAResponse } from "./errors-data.js";
+class DevErrorHandler {
+  #app;
+  #shouldInjectCspMetaTags;
+  #astroMiddleware;
+  #pagesHandler;
+  constructor(app, options) {
+    this.#app = app;
+    this.#shouldInjectCspMetaTags = options.shouldInjectCspMetaTags;
+    this.#astroMiddleware = new AstroMiddleware(app.pipeline);
+    this.#pagesHandler = new PagesHandler(app.pipeline);
+  }
+  async renderError(request, {
+    skipMiddleware = false,
+    error,
+    status,
+    response: _response,
+    pathname,
+    ...resolvedRenderOptions
+  }) {
+    if (isAstroError(error) && [MiddlewareNoDataOrNextCalled.name, MiddlewareNotAResponse.name].includes(error.name)) {
+      throw error;
+    }
+    const app = this.#app;
+    const shouldInjectCspMetaTags = this.#shouldInjectCspMetaTags;
+    const resolvedPathname = pathname ?? new FetchState(app.pipeline, request).pathname;
+    const renderRoute = async (routeData) => {
+      try {
+        const preloadedComponent = await app.pipeline.getComponentByRoute(routeData);
+        const errorState = new FetchState(app.pipeline, request);
+        errorState.skipMiddleware = skipMiddleware;
+        errorState.clientAddress = resolvedRenderOptions.clientAddress;
+        errorState.shouldInjectCspMetaTags = shouldInjectCspMetaTags ? !!app.manifest.csp : false;
+        errorState.routeData = routeData;
+        errorState.pathname = resolvedPathname;
+        errorState.status = status;
+        errorState.componentInstance = preloadedComponent;
+        errorState.locals = resolvedRenderOptions.locals ?? {};
+        errorState.initialProps = { error };
+        const response = await this.#astroMiddleware.handle(
+          errorState,
+          this.#pagesHandler.handle.bind(this.#pagesHandler)
+        );
+        if (error) {
+          app.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,
+            pathname: resolvedPathname
+          });
+        }
+        throw _err;
+      }
+    };
+    if (status === 404) {
+      const custom404 = getCustom404Route(app.manifestData);
+      if (custom404) {
+        return renderRoute(custom404);
+      }
+    }
+    const custom500 = getCustom500Route(app.manifestData);
+    if (!custom500) {
+      throw error;
+    } else {
+      return renderRoute(custom500);
+    }
+  }
+}
+export {
+  DevErrorHandler
+};

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

@@ -0,0 +1,9 @@
+import type { RenderErrorOptions } from '../app/base.js';
+/**
+ * A strategy for rendering error responses (404, 500, etc.). Each execution
+ * environment (prod SSR, build/prerender, dev server) supplies its own
+ * implementation rather than overriding a method on the app.
+ */
+export interface ErrorHandler {
+    renderError(request: Request, options: RenderErrorOptions): Promise<Response>;
+}

package/dist/core/fetch/default-handler.d.ts

@@ -0,0 +1,17 @@
+import type { BaseApp, ResolvedRenderOptions } from '../app/base.js';
+import type { Pipeline } from '../base-pipeline.js';
+import type { FetchHandler } from './types.js';
+/**
+ * The default request handler for `BaseApp`. Builds the per-request
+ * `FetchState` and delegates to an `AstroHandler`.
+ */
+export declare class DefaultFetchHandler {
+    #private;
+    constructor(app?: BaseApp<Pipeline>);
+    /**
+     * Fast path: called directly by `BaseApp.render()` with pre-resolved
+     * options, avoiding the `Reflect.set/get` round-trip through the request.
+     */
+    renderWithOptions(request: Request, options: ResolvedRenderOptions): Promise<Response>;
+    fetch: FetchHandler;
+}

package/dist/core/fetch/default-handler.js

@@ -0,0 +1,45 @@
+import { FetchState } from "./fetch-state.js";
+import { appSymbol } from "../constants.js";
+import { AstroHandler } from "../routing/handler.js";
+class DefaultFetchHandler {
+  #app;
+  #handler;
+  constructor(app) {
+    this.#app = app ?? null;
+    this.#handler = app ? new AstroHandler(app) : null;
+  }
+  /**
+   * Fast path: called directly by `BaseApp.render()` with pre-resolved
+   * options, avoiding the `Reflect.set/get` round-trip through the request.
+   */
+  renderWithOptions(request, options) {
+    if (!this.#app) {
+      const app = Reflect.get(request, appSymbol);
+      if (!app) {
+        throw new Error("No fetch handler provided.");
+      }
+      this.#app = app;
+      this.#handler = new AstroHandler(app);
+    }
+    const state = new FetchState(this.#app.pipeline, request, options);
+    return this.#handler.handle(state);
+  }
+  fetch = (request) => {
+    if (!this.#app) {
+      const app = Reflect.get(request, appSymbol);
+      if (!app) {
+        throw new Error("No fetch handler provided.");
+      }
+      this.#app = app;
+      this.#handler = new AstroHandler(app);
+    }
+    const state = new FetchState(this.#app.pipeline, request);
+    if (!this.#handler) {
+      throw new Error("No fetch handler provided.");
+    }
+    return this.#handler.handle(state);
+  };
+}
+export {
+  DefaultFetchHandler
+};