astro 7.0.0-alpha.0 → 7.0.0-alpha.2

package/dist/core/app/base.js

@@ -1,48 +1,45 @@
 import {
-  appendForwardSlash,
   collapseDuplicateLeadingSlashes,
-  collapseDuplicateTrailingSlashes,
-  hasFileExtension,
-  isInternalPath,
-  joinPaths,
   prependForwardSlash,
   removeTrailingForwardSlash
 } from "@astrojs/internal-helpers/path";
 import { matchPattern } from "@astrojs/internal-helpers/remote";
-import { normalizeTheLocale } from "../../i18n/index.js";
-import {
-  clientAddressSymbol,
-  DEFAULT_404_COMPONENT,
-  NOOP_MIDDLEWARE_HEADER,
-  REROUTABLE_STATUS_CODES,
-  REROUTE_DIRECTIVE_HEADER,
-  responseSentSymbol,
-  REWRITE_DIRECTIVE_HEADER_KEY,
-  ROUTE_TYPE_HEADER
-} from "../constants.js";
-import {
-  AstroCookies,
-  attachCookiesToResponse,
-  getSetCookiesFromResponse
-} from "../cookies/index.js";
-import { getCookiesFromResponse } from "../cookies/response.js";
+import { computePathnameFromDomain } from "../i18n/domain.js";
+import { PipelineFeatures } from "../base-pipeline.js";
+import { ASTRO_ERROR_HEADER, clientAddressSymbol } from "../constants.js";
+import { getSetCookiesFromResponse } from "../cookies/index.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import { AstroIntegrationLogger } from "../logger/core.js";
-import { RenderContext } from "../render-context.js";
-import { redirectTemplate } from "../routing/3xx.js";
-import { ensure404Route } from "../routing/astro-designed-error-pages.js";
-import { routeHasHtmlExtension } from "../routing/helpers.js";
-import { matchRoute } from "../routing/match.js";
-import { applyCacheHeaders } from "../cache/runtime/cache.js";
-import { Router } from "../routing/router.js";
-import { PERSIST_SYMBOL } from "../session/runtime.js";
+import { DefaultFetchHandler } from "../fetch/default-handler.js";
+import { appSymbol } from "../constants.js";
+import { DefaultErrorHandler } from "../errors/default-handler.js";
+import { setRenderOptions } from "./render-options.js";
+import { MultiLevelEncodingError } from "../util/pathname.js";
 class BaseApp {
   manifest;
   manifestData;
   pipeline;
   #adapterLogger;
   baseWithoutTrailingSlash;
-  #router;
+  /**
+   * The handler that turns incoming `Request` objects into `Response`s.
+   * Defaults to a `DefaultFetchHandler` pinned to this app and can be
+   * overridden via `setFetchHandler` — typically by the bundled
+   * entrypoint after importing `virtual:astro:fetchable`.
+   */
+  #fetchHandler;
+  #errorHandler;
+  /**
+   * Whether a custom fetch handler (from `src/app.ts`) has been set
+   * via `setFetchHandler`. When false, the `DefaultFetchHandler` is
+   * in use and all features are implicitly active.
+   */
+  #hasCustomFetchHandler = false;
+  /**
+   * Whether the missing-feature check has already run. We only want
+   * to warn once — after the first request in dev, or at build end.
+   */
+  #featureCheckDone = false;
   get logger() {
     return this.pipeline.logger;
   }
@@ -57,17 +54,27 @@ class BaseApp {
   }
   constructor(manifest, streaming = true, ...args) {
     this.manifest = manifest;
-    this.manifestData = { routes: manifest.routes.map((route) => route.routeData) };
     this.baseWithoutTrailingSlash = removeTrailingForwardSlash(manifest.base);
     this.pipeline = this.createPipeline(streaming, manifest, ...args);
-    ensure404Route(this.manifestData);
-    this.#router = this.createRouter(this.manifestData);
+    this.manifestData = this.pipeline.manifestData;
+    this.#fetchHandler = new DefaultFetchHandler(this);
+    this.#errorHandler = this.createErrorHandler();
   }
-  async createRenderContext(payload) {
-    return RenderContext.create(payload);
+  /**
+   * Override the fetch handler used to dispatch requests. Entrypoints
+   * call this with the default export of `virtual:astro:fetchable` to
+   * plug in a user-authored handler from `src/app.ts`.
+   */
+  setFetchHandler(handler) {
+    this.#fetchHandler = handler;
+    this.#hasCustomFetchHandler = !(handler instanceof DefaultFetchHandler);
   }
-  getAdapterLogger() {
-    return this.adapterLogger;
+  /**
+   * Returns the error handler strategy used by this app. Override to
+   * provide environment-specific behavior (dev overlay, build-time throws, etc.).
+   */
+  createErrorHandler() {
+    return new DefaultErrorHandler(this);
   }
   /**
    * Resets the cached adapter logger so it picks up a new logger instance.
@@ -97,7 +104,8 @@ class BaseApp {
   }
   set setManifestData(newManifestData) {
     this.manifestData = newManifestData;
-    this.#router = this.createRouter(this.manifestData);
+    this.pipeline.manifestData = newManifestData;
+    this.pipeline.rebuildRouter();
   }
   removeBase(pathname) {
     pathname = collapseDuplicateLeadingSlashes(pathname);
@@ -107,21 +115,30 @@ class BaseApp {
     return pathname;
   }
   /**
-   * It removes the base from the request URL, prepends it with a forward slash and attempts to decoded it.
-   *
-   * If the decoding fails, it logs the error and return the pathname as is.
-   * @param request
+   * Decodes a pathname with `decodeURI`, falling back to the raw pathname when it
+   * contains an invalid percent-sequence (e.g. `%C0%AF`, an overlong-UTF-8 encoding of
+   * `/` commonly sent by path-traversal scanners). A raw `decodeURI()` would throw
+   * `URIError: URI malformed`, and because `match()` runs before `render()` that error
+   * escapes the adapter's request handler as an uncaught exception (HTTP 500) that user
+   * middleware can't catch.
    */
-  getPathnameFromRequest(request) {
-    const url = new URL(request.url);
-    const pathname = prependForwardSlash(this.removeBase(url.pathname));
+  safeDecodeURI(pathname) {
     try {
       return decodeURI(pathname);
     } catch (e) {
-      this.getAdapterLogger().error(e.toString());
+      this.adapterLogger.debug(e.toString());
       return pathname;
     }
   }
+  /**
+   * Extracts the base-stripped, decoded pathname from a request.
+   * Used by adapters to compute the pathname for dev-mode route matching.
+   */
+  getPathnameFromRequest(request) {
+    const url = new URL(request.url);
+    const pathname = prependForwardSlash(this.removeBase(url.pathname));
+    return this.safeDecodeURI(pathname);
+  }
   /**
    * Given a `Request`, it returns the `RouteData` that matches its `pathname`. By default, prerendered
    * routes aren't returned, even if they are matched.
@@ -137,23 +154,20 @@ class BaseApp {
     if (!pathname) {
       pathname = prependForwardSlash(this.removeBase(url.pathname));
     }
-    const match = this.#router.match(decodeURI(pathname), { allowWithoutBase: true });
-    if (match.type !== "match") return void 0;
-    const routeData = match.route;
+    const routeData = this.pipeline.matchRoute(this.safeDecodeURI(pathname));
+    if (!routeData) return void 0;
     if (allowPrerenderedRoutes) {
       return routeData;
-    } else if (routeData.prerender) {
+    }
+    if (routeData.prerender) {
+      if (routeData.params.length > 0) {
+        const allMatches = this.pipeline.matchAllRoutes(this.safeDecodeURI(pathname));
+        return allMatches.find((r) => !r.prerender);
+      }
       return void 0;
     }
     return routeData;
   }
-  createRouter(manifestData) {
-    return new Router(manifestData.routes, {
-      base: this.manifest.base,
-      trailingSlash: this.manifest.trailingSlash,
-      buildFormat: this.manifest.buildFormat
-    });
-  }
   /**
    * A matching route function to use in the development server.
    * Contrary to the `.match` function, this function resolves props and params, returning the correct
@@ -165,75 +179,14 @@ class BaseApp {
     return void 0;
   }
   computePathnameFromDomain(request) {
-    let pathname = void 0;
-    const url = new URL(request.url);
-    if (this.manifest.i18n && (this.manifest.i18n.strategy === "domains-prefix-always" || this.manifest.i18n.strategy === "domains-prefix-other-locales" || this.manifest.i18n.strategy === "domains-prefix-always-no-redirect")) {
-      let host = request.headers.get("X-Forwarded-Host");
-      let protocol = request.headers.get("X-Forwarded-Proto");
-      if (protocol) {
-        protocol = protocol + ":";
-      } else {
-        protocol = url.protocol;
-      }
-      if (!host) {
-        host = request.headers.get("Host");
-      }
-      if (host && protocol) {
-        host = host.split(":")[0];
-        try {
-          let locale;
-          const hostAsUrl = new URL(`${protocol}//${host}`);
-          for (const [domainKey, localeValue] of Object.entries(
-            this.manifest.i18n.domainLookupTable
-          )) {
-            const domainKeyAsUrl = new URL(domainKey);
-            if (hostAsUrl.host === domainKeyAsUrl.host && hostAsUrl.protocol === domainKeyAsUrl.protocol) {
-              locale = localeValue;
-              break;
-            }
-          }
-          if (locale) {
-            pathname = prependForwardSlash(
-              joinPaths(normalizeTheLocale(locale), this.removeBase(url.pathname))
-            );
-            if (this.manifest.trailingSlash === "always") {
-              pathname = appendForwardSlash(pathname);
-            } else if (this.manifest.trailingSlash === "never") {
-              pathname = removeTrailingForwardSlash(pathname);
-            } else if (url.pathname.endsWith("/")) {
-              pathname = appendForwardSlash(pathname);
-            }
-          }
-        } catch (e) {
-          this.logger.error(
-            "router",
-            `Astro tried to parse ${protocol}//${host} as an URL, but it threw a parsing error. Check the X-Forwarded-Host and X-Forwarded-Proto headers.`
-          );
-          this.logger.error("router", `Error: ${e}`);
-        }
-      }
-    }
-    return pathname;
-  }
-  redirectTrailingSlash(pathname) {
-    const { trailingSlash } = this.manifest;
-    if (pathname === "/" || isInternalPath(pathname)) {
-      return pathname;
-    }
-    const path = collapseDuplicateTrailingSlashes(pathname, trailingSlash !== "never");
-    if (path !== pathname) {
-      return path;
-    }
-    if (trailingSlash === "ignore") {
-      return pathname;
-    }
-    if (trailingSlash === "always" && !hasFileExtension(pathname)) {
-      return appendForwardSlash(pathname);
-    }
-    if (trailingSlash === "never") {
-      return removeTrailingForwardSlash(pathname);
-    }
-    return pathname;
+    return computePathnameFromDomain(
+      request,
+      new URL(request.url),
+      this.manifest.i18n,
+      this.manifest.base,
+      this.manifest.trailingSlash,
+      this.logger
+    );
   }
   async render(request, {
     addCookieHeader = false,
@@ -244,28 +197,6 @@ class BaseApp {
     waitUntil
   } = {}) {
     await this.pipeline.getLogger();
-    const timeStart = performance.now();
-    const url = new URL(request.url);
-    const redirect = this.redirectTrailingSlash(url.pathname);
-    if (redirect !== url.pathname) {
-      const status = request.method === "GET" ? 301 : 308;
-      const response2 = new Response(
-        redirectTemplate({
-          status,
-          relativeLocation: url.pathname,
-          absoluteLocation: redirect,
-          from: request.url
-        }),
-        {
-          status,
-          headers: {
-            location: redirect + url.search
-          }
-        }
-      );
-      this.#prepareResponse(response2, { addCookieHeader });
-      return response2;
-    }
     if (routeData) {
       this.logger.debug(
         "router",
@@ -275,150 +206,71 @@ class BaseApp {
       this.logger.debug("router", "RouteData");
       this.logger.debug("router", routeData);
     }
-    const resolvedRenderOptions = {
-      addCookieHeader,
-      clientAddress,
-      prerenderedErrorPageFetch,
-      locals,
-      routeData,
-      waitUntil
-    };
     if (locals) {
       if (typeof locals !== "object") {
         const error = new AstroError(AstroErrorData.LocalsNotAnObject);
         this.logger.error(null, error.stack);
         return this.renderError(request, {
-          ...resolvedRenderOptions,
+          addCookieHeader,
+          clientAddress,
+          prerenderedErrorPageFetch,
           // If locals are invalid, we don't want to include them when
           // rendering the error page
           locals: void 0,
+          routeData,
+          waitUntil,
           status: 500,
           error
         });
       }
     }
     if (!routeData) {
-      if (this.isDev()) {
-        const result = await this.devMatch(this.getPathnameFromRequest(request));
-        if (result) {
-          routeData = result.routeData;
-        }
-      } else {
-        routeData = this.match(request);
+      const domainPathname = this.computePathnameFromDomain(request);
+      if (domainPathname) {
+        routeData = this.pipeline.matchRoute(this.safeDecodeURI(domainPathname));
       }
-      this.logger.debug("router", "Astro matched the following route for " + request.url);
-      this.logger.debug("router", "RouteData:\n" + routeData);
-    }
-    if (!routeData) {
-      routeData = this.manifestData.routes.find(
-        (route) => route.component === "404.astro" || route.component === DEFAULT_404_COMPONENT
-      );
-    }
-    if (!routeData) {
-      this.logger.debug("router", "Astro hasn't found routes that match " + request.url);
-      this.logger.debug("router", "Here's the available routes:\n", this.manifestData);
-      return this.renderError(request, {
-        ...resolvedRenderOptions,
-        status: 404
-      });
     }
-    let pathname = this.getPathnameFromRequest(request);
-    if (this.isDev() && !routeHasHtmlExtension(routeData)) {
-      pathname = pathname.replace(/\/index\.html$/, "/").replace(/\.html$/, "");
-    }
-    const defaultStatus = this.getDefaultStatusCode(routeData, pathname);
+    const resolvedOptions = {
+      addCookieHeader,
+      clientAddress,
+      prerenderedErrorPageFetch,
+      locals,
+      routeData,
+      waitUntil
+    };
     let response;
-    let session;
-    let cache;
     try {
-      const componentInstance = await this.pipeline.getComponentByRoute(routeData);
-      const renderContext = await this.createRenderContext({
-        pipeline: this.pipeline,
-        locals,
-        pathname,
-        request,
-        routeData,
-        status: defaultStatus,
-        clientAddress
-      });
-      session = renderContext.session;
-      cache = renderContext.cache;
-      if (this.pipeline.cacheProvider) {
-        const cacheProvider = await this.pipeline.getCacheProvider();
-        if (cacheProvider?.onRequest) {
-          response = await cacheProvider.onRequest(
-            {
-              request,
-              url: new URL(request.url),
-              waitUntil: resolvedRenderOptions.waitUntil
-            },
-            async () => {
-              const res = await renderContext.render(componentInstance);
-              applyCacheHeaders(cache, res);
-              return res;
-            }
-          );
-          response.headers.delete("CDN-Cache-Control");
-          response.headers.delete("Cache-Tag");
-        } else {
-          response = await renderContext.render(componentInstance);
-          applyCacheHeaders(cache, response);
-        }
+      if (this.#fetchHandler instanceof DefaultFetchHandler) {
+        Reflect.set(request, appSymbol, this);
+        response = await this.#fetchHandler.renderWithOptions(request, resolvedOptions);
       } else {
-        response = await renderContext.render(componentInstance);
+        setRenderOptions(request, resolvedOptions);
+        Reflect.set(request, appSymbol, this);
+        response = await this.#fetchHandler.fetch(request);
       }
-      const isRewrite = response.headers.has(REWRITE_DIRECTIVE_HEADER_KEY);
-      this.logThisRequest({
-        pathname,
-        method: request.method,
-        statusCode: response.status,
-        isRewrite,
-        timeStart
-      });
     } catch (err) {
-      this.logger.error(null, err.stack || err.message || String(err));
-      return this.renderError(request, {
-        ...resolvedRenderOptions,
-        status: 500,
-        error: err
-      });
-    } finally {
-      await session?.[PERSIST_SYMBOL]();
+      if (err instanceof MultiLevelEncodingError) {
+        return new Response("Bad Request", { status: 400 });
+      }
+      throw err;
     }
-    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") {
+    this.#warnMissingFeatures();
+    if (response.headers.get(ASTRO_ERROR_HEADER)) {
+      response.headers.delete(ASTRO_ERROR_HEADER);
       return this.renderError(request, {
-        ...resolvedRenderOptions,
+        addCookieHeader,
+        clientAddress,
+        prerenderedErrorPageFetch,
+        locals,
+        routeData,
+        waitUntil,
         response,
         status: response.status,
-        // We don't have an error to report here. Passing null means we pass nothing intentionally
-        // while undefined means there's no error
         error: response.status === 500 ? null : void 0
       });
     }
-    this.#prepareResponse(response, { addCookieHeader });
     return response;
   }
-  #prepareResponse(response, { addCookieHeader }) {
-    for (const headerName of [
-      REROUTE_DIRECTIVE_HEADER,
-      REWRITE_DIRECTIVE_HEADER_KEY,
-      NOOP_MIDDLEWARE_HEADER,
-      ROUTE_TYPE_HEADER
-    ]) {
-      if (response.headers.has(headerName)) {
-        response.headers.delete(headerName);
-      }
-    }
-    if (addCookieHeader) {
-      for (const setCookieHeaderValue of getSetCookiesFromResponse(response)) {
-        response.headers.append("set-cookie", setCookieHeaderValue);
-      }
-    }
-    this.logger.flush();
-    Reflect.set(response, responseSentSymbol, true);
-  }
   setCookieHeaders(response) {
     return getSetCookiesFromResponse(response);
   }
@@ -436,126 +288,50 @@ class BaseApp {
   static getSetCookieFromResponse = getSetCookiesFromResponse;
   /**
    * If it is a known error code, try sending the according page (e.g. 404.astro / 500.astro).
-   * This also handles pre-rendered /404 or /500 routes
+   * This also handles pre-rendered /404 or /500 routes.
+   *
+   * Delegates to the app's configured `ErrorHandler`. To customize behavior
+   * for a specific environment, override `createErrorHandler()` rather than
+   * this method.
    */
-  async renderError(request, {
-    status,
-    response: originalResponse,
-    skipMiddleware = false,
-    error,
-    ...resolvedRenderOptions
-  }) {
-    const errorRoutePath = `/${status}${this.manifest.trailingSlash === "always" ? "/" : ""}`;
-    const errorRouteData = matchRoute(errorRoutePath, this.manifestData);
-    const url = new URL(request.url);
-    if (errorRouteData) {
-      if (errorRouteData.prerender) {
-        const maybeDotHtml = errorRouteData.route.endsWith(`/${status}`) ? ".html" : "";
-        const statusURL = new URL(`${this.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 = this.mergeResponses(response2, originalResponse, override);
-          this.#prepareResponse(newResponse, resolvedRenderOptions);
-          return newResponse;
-        }
-      }
-      const mod = await this.pipeline.getComponentByRoute(errorRouteData);
-      let session;
-      try {
-        const renderContext = await this.createRenderContext({
-          locals: resolvedRenderOptions.locals,
-          pipeline: this.pipeline,
-          skipMiddleware,
-          pathname: this.getPathnameFromRequest(request),
-          request,
-          routeData: errorRouteData,
-          status,
-          props: { error },
-          clientAddress: resolvedRenderOptions.clientAddress
-        });
-        session = renderContext.session;
-        const response2 = await renderContext.render(mod);
-        const newResponse = this.mergeResponses(response2, originalResponse);
-        this.#prepareResponse(newResponse, resolvedRenderOptions);
-        return newResponse;
-      } catch {
-        if (skipMiddleware === false) {
-          return this.renderError(request, {
-            ...resolvedRenderOptions,
-            status,
-            response: originalResponse,
-            skipMiddleware: true
-          });
-        }
-      } finally {
-        await session?.[PERSIST_SYMBOL]();
-      }
-    }
-    const response = this.mergeResponses(new Response(null, { status }), originalResponse);
-    this.#prepareResponse(response, resolvedRenderOptions);
-    return response;
+  async renderError(request, options) {
+    return this.#errorHandler.renderError(request, options);
   }
-  mergeResponses(newResponse, originalResponse, override) {
-    let newResponseHeaders = newResponse.headers;
-    if (override?.removeContentEncodingHeaders) {
-      newResponseHeaders = new Headers(newResponseHeaders);
-      newResponseHeaders.delete("Content-Encoding");
-      newResponseHeaders.delete("Content-Length");
+  /**
+   * One-shot check: after the first request with a custom `src/app.ts`,
+   * compare `usedFeatures` against the manifest and warn about any
+   * configured features the user's pipeline doesn't call.
+   */
+  #warnMissingFeatures() {
+    if (this.#featureCheckDone || !this.#hasCustomFetchHandler) return;
+    this.#featureCheckDone = true;
+    const manifest = this.manifest;
+    const missing = [];
+    const used = this.pipeline.usedFeatures;
+    if (manifest.routes.some((r) => r.routeData.type === "redirect") && !(used & PipelineFeatures.redirects)) {
+      missing.push("redirects");
     }
-    if (!originalResponse) {
-      if (override !== void 0) {
-        return new Response(newResponse.body, {
-          status: override.status,
-          statusText: newResponse.statusText,
-          headers: newResponseHeaders
-        });
-      }
-      return newResponse;
+    if (manifest.sessionConfig && !(used & PipelineFeatures.sessions)) {
+      missing.push("sessions");
     }
-    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 {
+    if (manifest.actions && !(used & PipelineFeatures.actions)) {
+      missing.push("actions");
     }
-    const newHeaders = new Headers();
-    const seen = /* @__PURE__ */ new Set();
-    for (const [name, value] of originalResponse.headers) {
-      newHeaders.append(name, value);
-      seen.add(name.toLowerCase());
+    if (manifest.middleware && !(used & PipelineFeatures.middleware)) {
+      missing.push("middleware");
     }
-    for (const [name, value] of newResponseHeaders) {
-      if (!seen.has(name.toLowerCase())) {
-        newHeaders.append(name, value);
-      }
+    if (manifest.i18n && manifest.i18n.strategy !== "manual" && !(used & PipelineFeatures.i18n)) {
+      missing.push("i18n");
     }
-    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 AstroCookies.consume(newCookies)) {
-          originalResponse.headers.append("set-cookie", cookieValue);
-        }
-      }
-      attachCookiesToResponse(mergedResponse, originalCookies);
-    } else if (newCookies) {
-      attachCookiesToResponse(mergedResponse, newCookies);
+    if (manifest.cacheConfig && !(used & PipelineFeatures.cache)) {
+      missing.push("cache");
+    }
+    for (const feature of missing) {
+      this.logger.warn(
+        "router",
+        `Your project uses ${feature}, but your custom src/app.ts does not call the ${feature}() handler. This feature will not work unless you add it to your app.ts pipeline.`
+      );
     }
-    return mergedResponse;
   }
   getDefaultStatusCode(routeData, pathname) {
     if (!routeData.pattern.test(pathname)) {

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;
 }