astro 6.2.2 → 6.3.0

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

@@ -1,9 +1,10 @@
 import type { RoutesList } from '../../types/astro.js';
 import type { RemotePattern, RouteData } from '../../types/public/index.js';
-import type { Pipeline } from '../base-pipeline.js';
+import { type Pipeline } from '../base-pipeline.js';
 import { getSetCookiesFromResponse } from '../cookies/index.js';
 import { AstroIntegrationLogger, type AstroLogger } from '../logger/core.js';
-import { type CreateRenderContext, RenderContext } from '../render-context.js';
+import type { FetchHandler } from '../fetch/types.js';
+import type { ErrorHandler } from '../errors/handler.js';
 import type { WaitUntilHook } from '../wait-until.js';
 import type { AppPipeline } from './pipeline.js';
 import type { SSRManifest } from './types.js';
@@ -60,7 +61,7 @@ export interface RenderOptions {
     routeData?: RouteData;
 }
 type RequiredRenderOptions = Required<RenderOptions>;
-interface ResolvedRenderOptions {
+export interface ResolvedRenderOptions {
     addCookieHeader: RequiredRenderOptions['addCookieHeader'];
     clientAddress: RequiredRenderOptions['clientAddress'] | undefined;
     prerenderedErrorPageFetch: RequiredRenderOptions['prerenderedErrorPageFetch'] | undefined;
@@ -79,20 +80,38 @@ export interface RenderErrorOptions extends ResolvedRenderOptions {
      * Allows passing an error to 500.astro. It will be available through `Astro.props.error`.
      */
     error?: unknown;
+    /**
+     * The pathname to use for the error page render context. If omitted, the
+     * error handler computes it from `request` via a short-lived `FetchState`.
+     */
+    pathname?: string;
 }
 type ErrorPagePath = `${string}/404` | `${string}/500` | `${string}/404/` | `${string}/500/` | `${string}404.html` | `${string}500.html`;
 export declare abstract class BaseApp<P extends Pipeline = AppPipeline> {
     #private;
     manifest: SSRManifest;
-    manifestData: RoutesList;
+    manifestData: {
+        routes: RouteData[];
+    };
     pipeline: P;
     baseWithoutTrailingSlash: string;
     get logger(): AstroLogger;
     get adapterLogger(): AstroIntegrationLogger;
     constructor(manifest: SSRManifest, streaming?: boolean, ...args: any[]);
+    /**
+     * 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: {
+        fetch: FetchHandler;
+    }): void;
+    /**
+     * Returns the error handler strategy used by this app. Override to
+     * provide environment-specific behavior (dev overlay, build-time throws, etc.).
+     */
+    protected createErrorHandler(): ErrorHandler;
     abstract isDev(): boolean;
-    createRenderContext(payload: CreateRenderContext): Promise<RenderContext>;
-    getAdapterLogger(): AstroIntegrationLogger;
     /**
      * Resets the cached adapter logger so it picks up a new logger instance.
      * Used by BuildApp when the logger is replaced via setOptions().
@@ -113,10 +132,8 @@ export declare abstract class BaseApp<P extends Pipeline = AppPipeline> {
     set setManifestData(newManifestData: RoutesList);
     removeBase(pathname: string): string;
     /**
-     * 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
+     * Extracts the base-stripped, decoded pathname from a request.
+     * Used by adapters to compute the pathname for dev-mode route matching.
      */
     getPathnameFromRequest(request: Request): string;
     /**
@@ -128,7 +145,6 @@ export declare abstract class BaseApp<P extends Pipeline = AppPipeline> {
      * @param allowPrerenderedRoutes
      */
     match(request: Request, allowPrerenderedRoutes?: boolean): RouteData | undefined;
-    private createRouter;
     /**
      * A matching route function to use in the development server.
      * Contrary to the `.match` function, this function resolves props and params, returning the correct
@@ -137,7 +153,6 @@ export declare abstract class BaseApp<P extends Pipeline = AppPipeline> {
      */
     devMatch(pathname?: string): Promise<DevMatch | undefined> | undefined;
     private computePathnameFromDomain;
-    private redirectTrailingSlash;
     render(request: Request, { addCookieHeader, clientAddress, locals, prerenderedErrorPageFetch, routeData, waitUntil, }?: RenderOptions): Promise<Response>;
     setCookieHeaders(response: Response): Generator<string, string[], any>;
     /**
@@ -154,10 +169,13 @@ export declare abstract class BaseApp<P extends Pipeline = AppPipeline> {
     static getSetCookieFromResponse: typeof 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.
      */
-    renderError(request: Request, { status, response: originalResponse, skipMiddleware, error, ...resolvedRenderOptions }: RenderErrorOptions): Promise<Response>;
-    private mergeResponses;
+    renderError(request: Request, options: RenderErrorOptions): Promise<Response>;
     getDefaultStatusCode(routeData: RouteData, pathname: string): number;
     getManifest(): SSRManifest;
     logThisRequest({ pathname, method, statusCode, isRewrite, timeStart, }: {

package/dist/core/app/base.js

@@ -1,48 +1,46 @@
 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 { 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";
 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 +55,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 +105,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,10 +116,8 @@ 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
+   * 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);
@@ -118,7 +125,7 @@ class BaseApp {
     try {
       return decodeURI(pathname);
     } catch (e) {
-      this.getAdapterLogger().error(e.toString());
+      this.adapterLogger.error(e.toString());
       return pathname;
     }
   }
@@ -137,23 +144,16 @@ 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(decodeURI(pathname));
+    if (!routeData) return void 0;
     if (allowPrerenderedRoutes) {
       return routeData;
-    } else if (routeData.prerender) {
+    }
+    if (routeData.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
@@ -215,26 +215,6 @@ class BaseApp {
     }
     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;
-  }
   async render(request, {
     addCookieHeader = false,
     clientAddress = Reflect.get(request, clientAddressSymbol),
@@ -244,28 +224,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 +233,64 @@ 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(decodeURI(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,
+    if (this.#fetchHandler instanceof DefaultFetchHandler) {
+      Reflect.set(request, appSymbol, this);
+      response = await this.#fetchHandler.renderWithOptions(request, resolvedOptions);
+    } else {
+      setRenderOptions(request, resolvedOptions);
+      Reflect.set(request, appSymbol, this);
+      response = await this.#fetchHandler.fetch(request);
+    }
+    this.#warnMissingFeatures();
+    if (response.headers.get(ASTRO_ERROR_HEADER)) {
+      response.headers.delete(ASTRO_ERROR_HEADER);
+      return this.renderError(request, {
+        addCookieHeader,
+        clientAddress,
+        prerenderedErrorPageFetch,
         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);
-        }
-      } else {
-        response = await renderContext.render(componentInstance);
-      }
-      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 (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") {
-      return this.renderError(request, {
-        ...resolvedRenderOptions,
+        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 +308,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)) {