astro 7.2.2 → 7.2.4

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

@@ -1,125 +1,110 @@
+import { removeTrailingForwardSlash } from "@astrojs/internal-helpers/path";
+import { getEnvironment } from "../environment/index.js";
 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 { handleMiddleware } from "../middleware/astro-middleware.js";
+import { handlePages } from "../pages/handler.js";
 import { matchRoute } from "../routing/match.js";
+import { getRouteTable } from "../routing/route-table.js";
 import { provideSession } from "../session/provider.js";
 import { validateHost } from "../app/validate-headers.js";
 import { getErrorRoutePath } from "../../i18n/error-routes.js";
 import { getOutputFilename } from "../output-filename.js";
 import { rewroteToEmptyErrorResponse } from "./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, {
+async function renderDefaultError(manifest, request, {
+  status,
+  response: originalResponse,
+  skipMiddleware = false,
+  error,
+  pathname,
+  ...resolvedRenderOptions
+}) {
+  const resolvedPathname = pathname ?? new FetchState(manifest, request).pathname;
+  const routeTable = getRouteTable(manifest);
+  const errorRoutePath = getErrorRoutePath(
+    resolvedPathname,
     status,
-    response: originalResponse,
-    skipMiddleware = false,
-    error,
-    pathname,
-    ...resolvedRenderOptions
-  }) {
-    const app = this.#app;
-    const resolvedPathname = pathname ?? new FetchState(app.pipeline, request).pathname;
-    const errorRoutePath = getErrorRoutePath(
-      resolvedPathname,
-      status,
-      app.manifestData.routes,
-      app.manifest.i18n?.locales,
-      app.manifest.trailingSlash === "always"
-    );
-    const errorRouteData = matchRoute(errorRoutePath, app.manifestData);
-    const url = new URL(request.url);
-    if (errorRouteData) {
-      if (errorRouteData.prerender) {
-        const allowedDomains = app.manifest.allowedDomains;
-        const validatedHost = validateHost(url.host, url.protocol.replace(":", ""), allowedDomains);
-        const safeOrigin = validatedHost ? url.origin : `${url.protocol}//localhost`;
-        const statusURL = new URL(
-          `${app.baseWithoutTrailingSlash}${getOutputFilename(
-            app.manifest.buildFormat,
-            errorRouteData.route,
-            errorRouteData
-          )}`,
-          safeOrigin
-        );
-        if (statusURL.toString() !== request.url && resolvedRenderOptions.prerenderedErrorPageFetch) {
-          try {
-            const response2 = await resolvedRenderOptions.prerenderedErrorPageFetch(
-              statusURL.toString()
-            );
-            const override = { status, removeContentEncodingHeaders: true };
-            const newResponse = mergeResponses(response2, originalResponse, override);
-            prepareResponse(newResponse, resolvedRenderOptions);
-            return newResponse;
-          } catch {
-            const response2 = mergeResponses(new Response(null, { status }), originalResponse);
-            prepareResponse(response2, resolvedRenderOptions);
-            return response2;
-          }
+    routeTable.routes,
+    manifest.i18n?.locales,
+    manifest.trailingSlash === "always"
+  );
+  const errorRouteData = matchRoute(errorRoutePath, routeTable);
+  const url = new URL(request.url);
+  if (errorRouteData) {
+    if (errorRouteData.prerender) {
+      const allowedDomains = manifest.allowedDomains;
+      const validatedHost = validateHost(url.host, url.protocol.replace(":", ""), allowedDomains);
+      const safeOrigin = validatedHost ? url.origin : `${url.protocol}//localhost`;
+      const statusURL = new URL(
+        `${removeTrailingForwardSlash(manifest.base)}${getOutputFilename(
+          manifest.buildFormat,
+          errorRouteData.route,
+          errorRouteData
+        )}`,
+        safeOrigin
+      );
+      if (statusURL.toString() !== request.url && resolvedRenderOptions.prerenderedErrorPageFetch) {
+        try {
+          const response2 = await resolvedRenderOptions.prerenderedErrorPageFetch(
+            statusURL.toString()
+          );
+          const override = { status, removeContentEncodingHeaders: true };
+          const newResponse = mergeResponses(response2, originalResponse, override);
+          prepareResponse(newResponse, resolvedRenderOptions);
+          return newResponse;
+        } catch {
+          const response2 = mergeResponses(new Response(null, { status }), originalResponse);
+          prepareResponse(response2, resolvedRenderOptions);
+          return response2;
         }
       }
-      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)
-        );
-        if (rewroteToEmptyErrorResponse(
-          skipMiddleware,
-          errorRouteData,
-          errorState.routeData,
-          response2
-        )) {
-          return this.renderError(request, {
-            ...resolvedRenderOptions,
-            status,
-            error,
-            response: originalResponse,
-            skipMiddleware: true,
-            pathname: resolvedPathname
-          });
-        }
-        const newResponse = mergeResponses(response2, originalResponse);
-        prepareResponse(newResponse, resolvedRenderOptions);
-        return newResponse;
-      } catch {
-        if (skipMiddleware === false) {
-          return this.renderError(request, {
-            ...resolvedRenderOptions,
-            status,
-            error,
-            response: originalResponse,
-            skipMiddleware: true,
-            pathname: resolvedPathname
-          });
-        }
-      } finally {
-        await errorState.finalizeAll();
+    }
+    const mod = await getEnvironment(manifest).getComponentByRoute(manifest, errorRouteData);
+    const errorState = new FetchState(manifest, 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 handleMiddleware(errorState, handlePages);
+      if (rewroteToEmptyErrorResponse(skipMiddleware, errorRouteData, errorState.routeData, response2)) {
+        return renderDefaultError(manifest, request, {
+          ...resolvedRenderOptions,
+          status,
+          error,
+          response: originalResponse,
+          skipMiddleware: true,
+          pathname: resolvedPathname
+        });
+      }
+      const newResponse = mergeResponses(response2, originalResponse);
+      prepareResponse(newResponse, resolvedRenderOptions);
+      return newResponse;
+    } catch {
+      if (skipMiddleware === false) {
+        return renderDefaultError(manifest, request, {
+          ...resolvedRenderOptions,
+          status,
+          error,
+          response: originalResponse,
+          skipMiddleware: true,
+          pathname: resolvedPathname
+        });
       }
+    } finally {
+      await errorState.finalizeAll();
     }
-    const response = mergeResponses(new Response(null, { status }), originalResponse);
-    prepareResponse(response, resolvedRenderOptions);
-    return response;
   }
+  const response = mergeResponses(new Response(null, { status }), originalResponse);
+  prepareResponse(response, resolvedRenderOptions);
+  return response;
 }
 function mergeResponses(newResponse, originalResponse, override) {
   let newResponseHeaders = newResponse.headers;
@@ -180,5 +165,5 @@ function mergeResponses(newResponse, originalResponse, override) {
   return mergedResponse;
 }
 export {
-  DefaultErrorHandler
+  renderDefaultError
 };

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

@@ -1,6 +1,5 @@
-import type { BaseApp, RenderErrorOptions } from '../app/base.js';
-import type { Pipeline } from '../base-pipeline.js';
-import { type ErrorHandler } from './handler.js';
+import type { RenderErrorOptions } from '../app/base.js';
+import type { SSRManifest } from '../app/types.js';
 export interface DevErrorHandlerOptions {
     /**
      * Whether to inject CSP meta tags into the rendered error page response.
@@ -9,13 +8,10 @@ export interface DevErrorHandlerOptions {
     shouldInjectCspMetaTags: boolean;
 }
 /**
- * The dev-server error handler. Renders custom 404/500 routes if the user
+ * The dev-server error strategy. 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.
+ * the Vite dev server and the non-runnable dev pipeline; only
+ * `shouldInjectCspMetaTags` differs between them (carried by the
+ * environment record's `injectCspMetaTagsOnErrorPages` static).
  */
-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>;
-}
+export declare function renderDevError(manifest: SSRManifest, request: Request, { skipMiddleware, error, status, response: _response, pathname, ...resolvedRenderOptions }: RenderErrorOptions, { shouldInjectCspMetaTags }: DevErrorHandlerOptions): Promise<Response>;

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

@@ -1,92 +1,94 @@
+import { getEnvironment } from "../environment/index.js";
 import { FetchState } from "../fetch/fetch-state.js";
-import { AstroMiddleware } from "../middleware/astro-middleware.js";
-import { PagesHandler } from "../pages/handler.js";
+import { getLogger } from "../logger/manifest-logger.js";
+import { handleMiddleware } from "../middleware/astro-middleware.js";
+import { handlePages } from "../pages/handler.js";
 import { getCustom404Route, getCustom500Route } from "../routing/helpers.js";
+import { getRouteTable } from "../routing/route-table.js";
 import { isAstroError } from "./index.js";
 import { MiddlewareNoDataOrNextCalled, MiddlewareNotAResponse } from "./errors-data.js";
 import { rewroteToEmptyErrorResponse } from "./handler.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 function renderDevError(manifest, request, {
+  skipMiddleware = false,
+  error,
+  status,
+  response: _response,
+  pathname,
+  ...resolvedRenderOptions
+}, { shouldInjectCspMetaTags }) {
+  if (isAstroError(error) && [MiddlewareNoDataOrNextCalled.name, MiddlewareNotAResponse.name].includes(error.name)) {
+    throw error;
   }
-  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 (rewroteToEmptyErrorResponse(skipMiddleware, routeData, errorState.routeData, response)) {
-          return this.renderError(request, {
+  const resolvedPathname = pathname ?? new FetchState(manifest, request).pathname;
+  const renderRoute = async (routeData) => {
+    try {
+      const preloadedComponent = await getEnvironment(manifest).getComponentByRoute(
+        manifest,
+        routeData
+      );
+      const errorState = new FetchState(manifest, request);
+      errorState.skipMiddleware = skipMiddleware;
+      errorState.clientAddress = resolvedRenderOptions.clientAddress;
+      errorState.shouldInjectCspMetaTags = shouldInjectCspMetaTags ? !!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 handleMiddleware(errorState, handlePages);
+      if (rewroteToEmptyErrorResponse(skipMiddleware, routeData, errorState.routeData, response)) {
+        return renderDevError(
+          manifest,
+          request,
+          {
             ...resolvedRenderOptions,
             status,
             error,
             skipMiddleware: true,
             pathname: resolvedPathname
-          });
-        }
-        if (error) {
-          app.logger.error("router", error.stack || error.message);
-        }
-        return response;
-      } catch (_err) {
-        if (skipMiddleware === false) {
-          return this.renderError(request, {
+          },
+          { shouldInjectCspMetaTags }
+        );
+      }
+      if (error) {
+        getLogger(manifest).error(
+          "router",
+          error.stack || error.message
+        );
+      }
+      return response;
+    } catch (_err) {
+      if (skipMiddleware === false) {
+        return renderDevError(
+          manifest,
+          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);
+          },
+          { shouldInjectCspMetaTags }
+        );
       }
+      throw _err;
     }
-    const custom500 = getCustom500Route(app.manifestData);
-    if (!custom500) {
-      throw error;
-    } else {
-      return renderRoute(custom500);
+  };
+  if (status === 404) {
+    const custom404 = getCustom404Route(getRouteTable(manifest));
+    if (custom404) {
+      return renderRoute(custom404);
     }
   }
+  const custom500 = getCustom500Route(getRouteTable(manifest));
+  if (!custom500) {
+    throw error;
+  } else {
+    return renderRoute(custom500);
+  }
 }
 export {
-  DevErrorHandler
+  renderDevError
 };

package/dist/core/errors/errors-data.d.ts

@@ -1377,6 +1377,24 @@ export declare const LoggerConfigurationNotSerializable: {
     name: string;
     title: string;
 };
+/**
+ * @docs
+ * @description
+ * `new FetchState(request)` can only be used inside an Astro server — the built
+ * server output or the dev server — where Astro provides the manifest describing
+ * your site. This error means it was called somewhere else, for example in a
+ * plain Node script that imports `astro/fetch`.
+ *
+ * If this error occurs inside an Astro-built server, please [open an issue](https://astro.build/issues/).
+ * @message
+ * `new FetchState(request)` was called outside of an Astro server, so no manifest is available.
+ */
+export declare const NoManifestAvailable: {
+    name: string;
+    title: string;
+    message: string;
+    hint: string;
+};
 /**
  * @docs
  * @kind heading

package/dist/core/errors/errors-data.js

@@ -527,6 +527,12 @@ const LoggerConfigurationNotSerializable = {
   name: "LoggerConfigurationNotSerializable",
   title: "The configuration of the logger is not serializable."
 };
+const NoManifestAvailable = {
+  name: "NoManifestAvailableError",
+  title: "No manifest available.",
+  message: "`new FetchState(request)` was called outside of an Astro server, so no manifest is available.",
+  hint: "Make sure this code runs as part of your Astro app, such as its fetch entrypoint. If this error occurred inside an Astro-built server, please open an issue at https://github.com/withastro/astro/issues."
+};
 const UnknownCSSError = {
   name: "UnknownCSSError",
   title: "Unknown CSS error."
@@ -896,6 +902,7 @@ export {
   NoClientEntrypoint,
   NoClientOnlyHint,
   NoImageMetadata,
+  NoManifestAvailable,
   NoMatchingImport,
   NoMatchingRenderer,
   NoMatchingStaticPathFound,

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

@@ -1,13 +1,32 @@
 import type { RenderErrorOptions } from '../app/base.js';
 import type { RouteData } from '../../types/public/index.js';
+import type { SSRManifest } from '../app/types.js';
+import type { FetchState } from '../fetch/fetch-state.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.
+ * A strategy for rendering error responses (404, 500, etc.).
+ *
+ * Internal shape of `BaseApp`'s `#errorHandler` (whose default wraps
+ * {@link renderErrorPage}); external `BaseApp` subclasses may return their
+ * own implementation from the protected `createErrorHandler()`.
  */
 export interface ErrorHandler {
     renderError(request: Request, options: RenderErrorOptions): Promise<Response>;
 }
+/**
+ * Renders the error page (404.astro / 500.astro or a plain response) for a
+ * request, dispatching to the strategy the manifest's environment selects:
+ * production/container default, dev (overlay + custom error routes, with or
+ * without CSP meta-tag injection), or build (500s throw so the build fails).
+ */
+export declare function renderErrorPage(manifest: SSRManifest, request: Request, options: RenderErrorOptions): Promise<Response>;
+/**
+ * Dispatches an internal error render for a request flowing through the
+ * handler chain: through the facade's late-bound `renderError` hook when the
+ * state was built by `BaseApp.render`'s fast path (preserving instance
+ * overrides/reassignments, e.g. cloudflare's prerender-error propagation),
+ * else through the environment's strategy via {@link renderErrorPage}.
+ */
+export declare function renderErrorFromState(state: FetchState, request: Request, options: RenderErrorOptions): Promise<Response>;
 /**
  * Whether a middleware rewrite (`ctx.rewrite()` / `next(payload)`) issued while
  * rendering the error page dead-ended in another empty reroutable (404/500)

package/dist/core/errors/handler.js

@@ -1,7 +1,32 @@
 import { REROUTABLE_STATUS_CODES } from "../constants.js";
+import { getEnvironment } from "../environment/index.js";
+import { renderBuildError } from "./build-handler.js";
+import { renderDefaultError } from "./default-handler.js";
+import { renderDevError } from "./dev-handler.js";
+function renderErrorPage(manifest, request, options) {
+  const env = getEnvironment(manifest);
+  switch (env.errorStrategy) {
+    case "dev":
+      return renderDevError(manifest, request, options, {
+        shouldInjectCspMetaTags: env.injectCspMetaTagsOnErrorPages
+      });
+    case "build":
+      return renderBuildError(manifest, request, options);
+    case "default":
+      return renderDefaultError(manifest, request, options);
+  }
+}
+function renderErrorFromState(state, request, options) {
+  if (state.renderError) {
+    return state.renderError(request, options);
+  }
+  return renderErrorPage(state.manifest, request, options);
+}
 function rewroteToEmptyErrorResponse(skipMiddleware, errorRouteData, renderedRouteData, response) {
   return skipMiddleware === false && renderedRouteData !== errorRouteData && response.body === null && REROUTABLE_STATUS_CODES.includes(response.status);
 }
 export {
+  renderErrorFromState,
+  renderErrorPage,
   rewroteToEmptyErrorResponse
 };

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

@@ -1,17 +1,24 @@
-import type { BaseApp, ResolvedRenderOptions } from '../app/base.js';
-import type { Pipeline } from '../base-pipeline.js';
+import type { SSRManifest } from '../app/types.js';
 import type { FetchHandler } from './types.js';
 /**
- * The default request handler for `BaseApp`. Builds the per-request
- * `FetchState` and delegates to an `AstroHandler`.
+ * The default request handler for `BaseApp`. Stateless: builds the
+ * per-request `FetchState` from the manifest and delegates to
+ * `handleRequest`.
+ *
+ * The export path (`astro/app/fetch/default-handler`), the class name, and
+ * no-arg constructibility are baked into generated builds
+ * (`core/fetch/vite-plugin.ts` emits `new DefaultFetchHandler()`), so all
+ * three survive.
  */
 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.
+     * `BaseApp` passes itself so states resolve that app's manifest ahead of
+     * the ambient one; generated builds construct the handler with no
+     * arguments and use the ambient manifest.
      */
-    renderWithOptions(request: Request, options: ResolvedRenderOptions): Promise<Response>;
+    constructor(app?: {
+        manifest: SSRManifest;
+    });
     fetch: FetchHandler;
 }

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

@@ -1,43 +1,21 @@
+import { getAmbientManifest } from "../manifest/ambient.js";
+import { getRenderOptions } from "../app/render-options.js";
+import { handleRequest } from "../routing/handler.js";
 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;
-  }
+  #manifest;
   /**
-   * Fast path: called directly by `BaseApp.render()` with pre-resolved
-   * options, avoiding the `Reflect.set/get` round-trip through the request.
+   * `BaseApp` passes itself so states resolve that app's manifest ahead of
+   * the ambient one; generated builds construct the handler with no
+   * arguments and use the ambient manifest.
    */
-  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);
+  constructor(app) {
+    this.#manifest = app?.manifest;
   }
   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);
+    const options = getRenderOptions(request);
+    const manifest = this.#manifest ?? getAmbientManifest();
+    return handleRequest(new FetchState(manifest, request, options));
   };
 }
 export {

package/dist/core/fetch/features.d.ts

@@ -0,0 +1,23 @@
+import type { SSRManifest } from '../app/types.js';
+/**
+ * Bit flags for features that handler functions register as "used" when a
+ * custom `src/fetch.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
+ * fetch handler.
+ */
+export declare const FetchFeatures: {
+    readonly redirects: number;
+    readonly sessions: number;
+    readonly actions: number;
+    readonly middleware: number;
+    readonly i18n: number;
+    readonly cache: number;
+};
+/** All feature bits ORed together. Keep next to `FetchFeatures` so
+ *  new flags are hard to forget. */
+export declare const ALL_FETCH_FEATURES: number;
+/** ORs a feature bit into the manifest's used-features bitmask. */
+export declare function markFeatureUsed(manifest: SSRManifest, feature: number): void;
+/** The used-features bitmask for a manifest; `0` when nothing was marked. */
+export declare function getUsedFeatures(manifest: SSRManifest): number;