cdk-nextjs 0.6.1 → 0.7.0

package/lib/runtime/dispatch.js

@@ -0,0 +1,751 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dispatcher = void 0;
+exports.toRedirect = toRedirect;
+exports.repairRouteParamQuery = repairRouteParamQuery;
+exports.outOfBandRouteParams = outOfBandRouteParams;
+exports.statusTargets = statusTargets;
+/* eslint-disable import/no-extraneous-dependencies */
+/**
+ * Request dispatch: URL in, routing decision out.
+ *
+ * All route matching is delegated to `@next/routing`'s `resolveRoutes`, the
+ * first-party package `next start` was refactored to expose. Reimplementing
+ * redirects/rewrites/i18n/dynamic-route matching is what previous versions of
+ * this construct did, and it is the thing this rewrite exists to delete.
+ *
+ * This module is pure decision-making: it never touches the filesystem, never
+ * requires an entrypoint, and never builds a `Response`. It returns a
+ * {@link DispatchResult} and the caller (the runtime core, step 4) acts on it.
+ * That split is what makes it unit-testable against the committed
+ * `onBuildComplete` fixtures with no AWS and no Next.js server.
+ */
+const routing_1 = require("@next/routing");
+const manifest_1 = require("./manifest");
+const public_files_1 = require("./public-files");
+const util_1 = require("./util");
+/**
+ * `ctx.routing` is persisted into the manifest verbatim and typed `unknown`
+ * there, because the manifest must not depend on `@next/routing` (it is also
+ * read at synth by the CDK constructs). Dispatch is the one place that knows
+ * the real shape, so the cast lives here.
+ *
+ * `ctx.routing` is a superset of `ResolveRoutesParams["routes"]` — it also
+ * carries `rsc` — which is why this is a cast and not an assignment.
+ */
+function asRoutes(routing) {
+    return routing;
+}
+/**
+ * Likewise for `i18n`: `NextConfigComplete["i18n"]` is wider than
+ * `ResolveRoutesParams["i18n"]` (extra fields, and `localeDetection?: boolean`
+ * against `false`), and the manifest stores the config value as-is.
+ */
+function asI18n(i18n) {
+    return i18n ? i18n : undefined;
+}
+class Dispatcher {
+    options;
+    /** The 404 to render for a request to a URL; see {@link statusTargets}. */
+    notFoundFor;
+    routes;
+    i18n;
+    table;
+    imagePathname;
+    trailingSlash;
+    constructor(options) {
+        this.options = options;
+        const { manifest } = options;
+        this.routes = asRoutes(manifest.routing);
+        this.i18n = asI18n(manifest.config.i18n);
+        this.trailingSlash = manifest.config.trailingSlash;
+        this.table = buildRoutingTable(manifest, options.publicFiles ?? []);
+        this.imagePathname = `${manifest.config.basePath}/_next/image`;
+        this.notFoundFor = statusTargets(manifest, 404);
+    }
+    get manifest() {
+        return this.options.manifest;
+    }
+    /**
+     * Drop the `trailingSlash` slash a resolved pathname may carry, so it can be
+     * looked up in `entrypoints`/`staticFiles` and rendered under the same cache
+     * key as its prerender. A no-op unless the app sets `trailingSlash`.
+     */
+    normalizePathname(pathname) {
+        if (!this.trailingSlash || pathname === undefined)
+            return pathname;
+        return pathname.length > 1 && pathname.endsWith("/")
+            ? pathname.slice(0, -1)
+            : pathname;
+    }
+    /** The request path with `basePath` removed, which is what i18n applies to. */
+    withoutBasePath(pathname) {
+        return (0, util_1.withoutPathPrefix)(pathname, this.manifest.config.basePath);
+    }
+    /**
+     * Put the locale in front of a request for the app's root *here*, when the
+     * locale is the one the request is already in.
+     *
+     * `resolveRoutes` prefixes the locale itself, as `${basePath}/${locale}${pathname}`
+     * — which for the root turns `/` into `/en-US/`. The slash-stripping 308 that
+     * `next build` always compiles into `routing.beforeMiddleware` then matches it,
+     * so `GET /` came back as a redirect no `next start` sends: measured against
+     * `test/e2e/i18n-support-catchall`, where `/` answers 200. Next.js's own router
+     * special-cases exactly this (`resolve-routes.ts`: `pathname === '/' ?
+     * `/${defaultLocale}` : …`).
+     *
+     * With `trailingSlash`, the prefixed root keeps its slash (`/en-US/`): the
+     * slash-*adding* 308 that build compiles instead matches `/en-US` the same
+     * way, and `/en-US/` is the canonical URL `next start` serves with a 200.
+     *
+     * Only the root, and only when no redirect is owed: a request whose detected
+     * locale is *not* the default has to reach `resolveRoutes`, which answers it
+     * with the 307 Next.js sends — after middleware has had the request, which is
+     * the ordering that matters and the reason this does not redirect itself.
+     */
+    withRootLocale(url, headers) {
+        const i18n = this.i18n;
+        if (!i18n)
+            return url;
+        const pathname = this.withoutBasePath(url.pathname);
+        if (pathname !== "/")
+            return url;
+        const defaultLocale = (0, routing_1.detectDomainLocale)(i18n.domains, url.hostname)?.defaultLocale ??
+            i18n.defaultLocale;
+        const detected = (0, routing_1.detectLocale)({
+            pathname,
+            hostname: url.hostname,
+            cookieHeader: headers.get("cookie") ?? undefined,
+            acceptLanguageHeader: headers.get("accept-language") ?? undefined,
+            i18n,
+        });
+        if (detected.locale !== defaultLocale)
+            return url;
+        const prefixed = new URL(url.toString());
+        prefixed.pathname = `${this.manifest.config.basePath}/${defaultLocale}${this.trailingSlash ? "/" : ""}`;
+        return prefixed;
+    }
+    /**
+     * Repair the two things `resolveRoutes` gets wrong about a redirect it built
+     * from the locale-prefixed root — the same `${basePath}/${locale}${pathname}`
+     * concatenation as in {@link withRootLocale}, this time reported as a location:
+     *
+     * - the stray trailing slash (`/nl/`, where Next.js sends `/nl`), which
+     *   otherwise costs a second round trip to the 308 that strips it, and
+     * - the absolute URL, where Next.js sends a path. Both are legal, but a test
+     *   asserting `headers.location` sees the difference, and so does any client
+     *   comparing it to a link.
+     */
+    normalizeRedirectLocation(location, request) {
+        let resolved;
+        try {
+            resolved = new URL(location, request);
+        }
+        catch {
+            return location;
+        }
+        if (resolved.origin !== request.origin)
+            return location;
+        const target = this.withoutBasePath(resolved.pathname);
+        const isLocaleRoot = this.i18n !== undefined &&
+            !this.trailingSlash &&
+            this.withoutBasePath(request.pathname) === "/" &&
+            this.i18n.locales.some((locale) => target === `/${locale}/`);
+        if (isLocaleRoot) {
+            resolved.pathname = resolved.pathname.slice(0, -1);
+        }
+        return `${resolved.pathname}${resolved.search}${resolved.hash}`;
+    }
+    /**
+     * The `headers()` rules a request matched, for a response middleware wrote
+     * itself.
+     *
+     * They compile into `routing.beforeMiddleware`, and `resolveRoutes` applies
+     * them there, but when middleware answers it returns `{ middlewareResponded:
+     * true }` and nothing else, so they were lost: a middleware 401 went out
+     * without the app's HSTS and CSP. `next start` sends them with it (its
+     * `resolve-routes.js` sets them on the response before middleware runs). So
+     * that one phase is run again on its own — no middleware, no files, nothing
+     * after it — which leaves exactly the headers it set.
+     */
+    async beforeMiddlewareHeaders(url, headers) {
+        const result = await (0, routing_1.resolveRoutes)({
+            url,
+            buildId: this.manifest.buildId,
+            basePath: this.manifest.config.basePath,
+            headers,
+            requestBody: new Blob([]).stream(),
+            pathnames: [],
+            routes: {
+                ...this.routes,
+                middlewareMatchers: [],
+                beforeFiles: [],
+                afterFiles: [],
+                dynamicRoutes: [],
+                onMatch: [],
+                fallback: [],
+            },
+            i18n: this.i18n,
+            invokeMiddleware: async () => ({}),
+        });
+        const responseHeaders = new Headers(result.resolvedHeaders ?? undefined);
+        // A locale-detection redirect is decided after middleware, and middleware
+        // already answered, so its `location` is not owed.
+        if (result.redirect) {
+            responseHeaders.delete("location");
+        }
+        return responseHeaders;
+    }
+    /**
+     * The URL to optimize, once `/_next/image` has resolved: as middleware
+     * rewrote it, or as received — or, when a `next.config` rewrite is what put
+     * the request on the image path, rebuilt from the query `resolveRoutes`
+     * resolved, which is the only place that rewrite's destination query is.
+     */
+    imageUrl(result, received) {
+        if (received.pathname === this.imagePathname)
+            return received;
+        const url = new URL(received.toString());
+        url.pathname = this.imagePathname;
+        if (result.resolvedQuery) {
+            url.search = (0, util_1.toSearch)(result.resolvedQuery);
+        }
+        return url;
+    }
+    async dispatch(request) {
+        // Copied because `resolveRoutes` is free to mutate what it is handed, and
+        // the caller's headers object outlives this call.
+        const requestHeaders = new Headers(request.headers);
+        // A second copy, as the request reached `beforeMiddleware`, for
+        // {@link beforeMiddlewareHeaders}.
+        const receivedHeaders = new Headers(request.headers);
+        const url = this.withRootLocale(request.url, requestHeaders);
+        let middlewareRequestHeaders;
+        let middlewareRewrite;
+        let middlewareResponse;
+        const result = await (0, routing_1.resolveRoutes)({
+            url,
+            buildId: this.manifest.buildId,
+            basePath: this.manifest.config.basePath,
+            headers: requestHeaders,
+            requestBody: request.body,
+            pathnames: this.table.pathnames,
+            routes: this.routes,
+            i18n: this.i18n,
+            // Only called when a `middlewareMatchers` entry matches, which only a
+            // build with middleware has.
+            invokeMiddleware: async (ctx) => {
+                const { response, ...middleware } = await request.invokeMiddleware({
+                    ...ctx,
+                    method: request.method,
+                });
+                middlewareResponse = response;
+                // `resolveRoutes` drops `MiddlewareResult.requestHeaders` entirely: it
+                // neither returns them nor mutates the `headers` passed in. Capturing
+                // them here is what keeps `NextResponse.next({ request: { headers } })`
+                // working.
+                if (middleware.requestHeaders) {
+                    middlewareRequestHeaders = middleware.requestHeaders;
+                }
+                // Captured for the same reason: `resolveRoutes` routes the rewritten URL
+                // internally but never reports it back, and `/_next/image` is matched
+                // here rather than by `resolveRoutes` (see below), so this is the only
+                // way to see the path middleware actually asked for.
+                if (middleware.rewrite) {
+                    middlewareRewrite = middleware.rewrite;
+                }
+                return middleware;
+            },
+        });
+        const responseHeaders = new Headers(result.resolvedHeaders ?? undefined);
+        // `@next/routing` echoes the rewrite it followed into `resolvedHeaders`;
+        // Next.js's own router consumes that header rather than sending it, and so do
+        // we — it is an internal routing signal, and forwarding it would expose the
+        // app's post-middleware paths to clients.
+        responseHeaders.delete("x-middleware-rewrite");
+        const forwardedHeaders = middlewareRequestHeaders ?? requestHeaders;
+        const status = result.status;
+        if (result.middlewareResponded && middlewareResponse) {
+            return {
+                kind: "middleware-responded",
+                response: middlewareResponse,
+                responseHeaders: await this.beforeMiddlewareHeaders(url, receivedHeaders),
+                status,
+            };
+        }
+        if (result.externalRewrite) {
+            return {
+                kind: "external-rewrite",
+                url: result.externalRewrite,
+                requestHeaders: forwardedHeaders,
+                responseHeaders,
+                status,
+            };
+        }
+        const redirect = toRedirect(result, responseHeaders);
+        if (redirect) {
+            return {
+                kind: "redirect",
+                ...redirect,
+                location: this.normalizeRedirectLocation(redirect.location, request.url),
+                responseHeaders,
+            };
+        }
+        // Both are keys into `entrypoints`/`staticFiles`, which never carry a
+        // trailing slash; see {@link withTrailingSlashVariants}.
+        const resolvedPathname = this.normalizePathname(result.resolvedPathname);
+        // In `pathnames` (see {@link buildRoutingTable}), so it resolves in the
+        // filesystem phase: after middleware and `beforeFiles`, and before any
+        // dynamic route, which is `next start`'s order. Unlisted, a root catch-all
+        // (`app/[...slug]`) or any two-segment dynamic route took every image
+        // request as `slug: ["_next", "image"]`.
+        if (resolvedPathname === this.imagePathname) {
+            return {
+                kind: "image-optimization",
+                url: this.imageUrl(result, middlewareRewrite ?? request.url),
+                requestHeaders: forwardedHeaders,
+                responseHeaders,
+            };
+        }
+        if (resolvedPathname !== undefined) {
+            const staticFile = this.table.staticFiles.get(resolvedPathname);
+            const asStaticFile = (file) => ({
+                kind: "static-file",
+                pathname: resolvedPathname,
+                filePath: file.filePath,
+                source: file.source,
+                requestHeaders: forwardedHeaders,
+                responseHeaders,
+                status,
+            });
+            // Ahead of the entrypoints, which is `next start`'s order: its filesystem
+            // check tries `_next/static` and then `public/` before any app or page
+            // route, so `public/robots.txt` beats `app/robots.ts` and
+            // `public/favicon.ico` beats `app/favicon.ico`.
+            if (staticFile && staticFile.source !== "server") {
+                return asStaticFile(staticFile);
+            }
+            const entrypoint = this.manifest.entrypoints[resolvedPathname];
+            if (entrypoint) {
+                const query = repairRouteParamQuery(result.resolvedQuery ?? {}, result.routeMatches ?? {});
+                return {
+                    kind: "entrypoint",
+                    entrypoint,
+                    resolvedPathname,
+                    // `invocationTarget` is always present alongside `resolvedPathname` in
+                    // practice; the fallback keeps a `next` shape change from crashing.
+                    invocationTarget: {
+                        pathname: this.normalizePathname(result.invocationTarget?.pathname) ??
+                            resolvedPathname,
+                        query,
+                    },
+                    requestHeaders: forwardedHeaders,
+                    responseHeaders,
+                    status,
+                };
+            }
+            if (staticFile) {
+                return asStaticFile(staticFile);
+            }
+        }
+        if (status !== undefined) {
+            return { kind: "response", status, responseHeaders };
+        }
+        const resolvedUrl = middlewareRewrite ?? request.url;
+        return {
+            kind: "not-found",
+            pathname: resolvedPathname ?? resolvedUrl.pathname,
+            requestHeaders: forwardedHeaders,
+            responseHeaders,
+        };
+    }
+}
+exports.Dispatcher = Dispatcher;
+/**
+ * Build outputs first, then `public/` on top of them, except over
+ * `_next/static`: that is `next start`'s precedence (see
+ * {@link Dispatcher.dispatch}).
+ *
+ * A `public/` file is registered under its pathname with the default locale in
+ * front, too, for an i18n app. `resolveRoutes` puts a locale on every path
+ * outside `/_next/` and `/api/` before it matches, so `/test.txt` is looked up
+ * as `/en-US/test.txt` and never matched the bare key: no `public/` file
+ * resolved in an i18n app at all. `next start` strips the default locale — and
+ * each domain's — off a `public/` request and no other locale (filesystem.js:
+ * "legacy behavior allows visiting static assets under default locale but no
+ * other locale"), which these entries reproduce: `/en-US/test.txt` serves and
+ * `/fr/test.txt` does not.
+ */
+function buildRoutingTable(manifest, publicFiles) {
+    const { basePath, trailingSlash } = manifest.config;
+    const staticFiles = new Map();
+    const nextStaticPrefix = `${basePath}/_next/static/`;
+    for (const [pathname, filePath] of Object.entries(manifest.staticFiles)) {
+        const target = {
+            filePath,
+            source: pathname.startsWith(nextStaticPrefix) ? "next-static" : "server",
+        };
+        // The key as Next.js reported it, and then as a request spells it: a build
+        // output's pathname is the file's own name, unencoded, and the HTML that
+        // loads it percent-encodes it. `app/isr/[id]/page.tsx`'s webpack chunk is
+        // `/_next/static/chunks/app/isr/[id]/page-<hash>.js` in the outputs and
+        // `…/isr/%5Bid%5D/page-<hash>.js` in the `<script>` tag.
+        for (const spelling of [pathname, ...requestSpellings(pathname)]) {
+            if (!staticFiles.has(spelling)) {
+                staticFiles.set(spelling, target);
+            }
+        }
+    }
+    const publicDir = (0, public_files_1.publicDirKey)(manifest);
+    const i18n = asI18n(manifest.config.i18n);
+    const localePrefixes = [
+        "",
+        ...new Set(i18n
+            ? [
+                i18n.defaultLocale,
+                ...(i18n.domains ?? []).map((domain) => domain.defaultLocale),
+            ].map((locale) => `/${locale}`)
+            : []),
+    ];
+    for (const file of publicFiles) {
+        const target = {
+            filePath: `${publicDir}/${file}`,
+            source: "public",
+        };
+        for (const spelling of requestSpellings(`/${file}`)) {
+            for (const prefix of localePrefixes) {
+                const pathname = `${basePath}${prefix}${spelling}`;
+                if (staticFiles.get(pathname)?.source !== "next-static") {
+                    staticFiles.set(pathname, target);
+                }
+            }
+        }
+    }
+    // `/_next/image` is not an adapter output, but it is a filesystem route to
+    // `next start` (`filesystem.js` answers it as `nextImage`), and listing it is
+    // what lets it resolve ahead of the dynamic routes; see
+    // {@link Dispatcher.dispatch}.
+    const pathnames = [
+        ...new Set([
+            ...manifest.pathnames,
+            ...staticFiles.keys(),
+            `${basePath}/_next/image`,
+        ]),
+    ];
+    return {
+        pathnames: trailingSlash ? withTrailingSlashVariants(pathnames) : pathnames,
+        staticFiles,
+    };
+}
+/**
+ * The ways a request spells an unencoded path, for the exact match
+ * `@next/routing` does against `pathnames`.
+ *
+ * Two, because there are two ways to write a link to `public/images/logo@2x.png`
+ * and a browser sends each as written: `/images/logo@2x.png`, which the WHATWG
+ * URL parser leaves alone — it only encodes spaces, quotes, `#`, `?`, `<>`,
+ * `` ` ``, `{}` and non-ASCII in a path — and `/images/logo%402x.png`, which is
+ * `encodeURIComponent` a segment at a time and is how Next.js keys its own
+ * `public/` set (`encodeURIPath`). For most names the two are the same string;
+ * they differ for `@ + & , ; = $ : [ ]` and the like, and a key in only the
+ * second form 404'd every `logo@2x.png`, `c++.svg` and `icon[1].png`.
+ *
+ * `%` is encoded in both, since a literal `%` in a name can only be requested
+ * as `%25`; so are `?` and `#`, which would otherwise end the path, and `\`,
+ * which the parser turns into `/`.
+ */
+function requestSpellings(path) {
+    const segments = path.split("/");
+    const encoded = segments.map(encodeURIComponent).join("/");
+    const parsed = new URL(segments
+        .map((segment) => segment.replace(/[%?#\\]/g, encodeURIComponent))
+        .join("/"), "http://n").pathname;
+    return parsed === encoded ? [encoded] : [encoded, parsed];
+}
+/**
+ * Normalize the two shapes `resolveRoutes` reports a redirect in.
+ *
+ * `ResolveRoutesResult.redirect` is documented, and an i18n locale-detection 307
+ * arrives that way, but the rest — the slash-stripping 308, a middleware
+ * `NextResponse.redirect()` — arrive instead as a bare `status` with `location`
+ * in `resolvedHeaders`. `next.config` `redirects()` too: they compile to routes
+ * carrying `headers: { Location }` plus `status`. Both shapes are handled, and
+ * {@link Dispatcher.normalizeRedirectLocation} then puts the location itself in
+ * the form Next.js sends.
+ */
+function toRedirect(result, responseHeaders) {
+    if (result.redirect) {
+        return {
+            location: result.redirect.url.href,
+            status: result.redirect.status,
+        };
+    }
+    const location = responseHeaders.get("location");
+    if (location !== null &&
+        result.status !== undefined &&
+        result.status >= 300 &&
+        result.status < 400) {
+        return { location, status: result.status };
+    }
+    return undefined;
+}
+/**
+ * Add `<pathname>/` alongside every route pathname, for a `trailingSlash` app.
+ *
+ * `trailingSlash: true` makes `/a/` the canonical URL — Next.js compiles a
+ * `priority` 308 from `/a` to `/a/` into `routing.beforeMiddleware`, and that
+ * redirect is the *first* thing `resolveRoutes` applies. But the build's output
+ * pathnames have no trailing slash (`/a`, `/api/revalidate`), and
+ * `@next/routing` matches them by exact string equality with no normalization of
+ * its own. So every canonical URL in such an app resolved to nothing: browsers
+ * followed the 308 to `/a/` and got a 404, and `fetch('/api/revalidate')` got
+ * the 404 *page* — measured against next.js's `test/e2e/app-dir/trailingslash`,
+ * where 6 of 8 cases failed this way. Dynamic routes escaped it only because
+ * their `sourceRegex` happens to end in `(?:/)?`.
+ *
+ * Normalizing the request URL before `resolveRoutes` instead would be wrong: the
+ * add-slash redirect matches the *slashless* path, so a normalized `/a/` would
+ * come back as a 308 to `/a/` and loop. Teaching the match about the slash and
+ * normalizing it off the *result* ({@link Dispatcher.normalizePathname}) keeps
+ * the redirect exactly as Next.js compiled it.
+ *
+ * Pathnames whose last segment has an extension are skipped: those are static
+ * files, and Next.js compiles the opposite redirect for them (`/x.js/` → 308
+ * `/x.js`), which this must not shadow.
+ */
+function withTrailingSlashVariants(pathnames) {
+    const variants = [];
+    for (const pathname of pathnames) {
+        variants.push(pathname);
+        if (pathname !== "/" && !/\.[^/]+$/.test(pathname)) {
+            variants.push(`${pathname}/`);
+        }
+    }
+    return variants;
+}
+/**
+ * Correct the `nxtP` route params in a resolved query from `routeMatches`.
+ *
+ * `@next/routing` expands a dynamic route's destination
+ * (`/[id]/[id2]?nxtPid=$nxtPid&nxtPid2=$nxtPid2`) by looping over the source
+ * regex's named groups and doing one global string replace per group name. Group
+ * names are substituted in insertion order, so `$nxtPid` — a *prefix* of
+ * `$nxtPid2` — is replaced first and leaves the trailing `2` behind as a
+ * literal: `/a/b` resolves with `nxtPid2=a2` instead of `nxtPid2=b`. Next.js
+ * recovers `params` from exactly these query values (`RouteModule.prepare`), so
+ * the page renders `id2: "a2"` — measured against
+ * `test/e2e/app-dir/use-params`, whose fixture is `app/[id]/[id2]/page.tsx`.
+ *
+ * `routeMatches` is the raw capture map, before any destination expansion, so it
+ * is the authority for every param it names. Only keys the expansion already
+ * produced are overwritten: adding others would invent params for a rewrite that
+ * deliberately dropped them.
+ *
+ * The same prefix collision reaches positional placeholders (`$1` inside `$10`,
+ * so a route with ten or more captures), and `next.config` `rewrites()`
+ * destinations that interpolate their own query values. Those are not route
+ * params and are left alone — there is no second source of truth to repair them
+ * from.
+ *
+ * The second correction is the opposite shape: a param the route *has* but the
+ * request did not fill. An optional catchall's group is the only one a match can
+ * leave unset — `^/optional\-catchall(?:/(?<nxtPparams>.+?))?(?:/)?$` against
+ * `/optional-catchall` — and both `routeMatches` and the expanded query keep the
+ * key with no value: `{ nxtPparams: undefined }`, which the `@next/routing` types
+ * do not admit. The key is what matters, not the value. `RouteModule.prepare`
+ * recovers a param for every `nxtP` key it finds, so a layout reading `params`
+ * renders a segment that was never requested — as `["undefined"]`, because
+ * `URLSearchParams.append` stringifies — where `next start` gives it no `params`
+ * key at all. Measured against `test/e2e/app-dir/layout-params`, whose fixture is
+ * `app/optional-catchall/[[...params]]`. No other param shape can be legitimately
+ * unfilled — a required segment captures `[^/]+?` and a required catchall `.+?` —
+ * so an unfilled value `routeMatches` does not vouch for is always this.
+ */
+function repairRouteParamQuery(query, routeMatches) {
+    let repaired;
+    for (const [key, value] of Object.entries(routeMatches)) {
+        if (!key.startsWith("nxtP") || value === undefined)
+            continue;
+        if (!(key in query) || query[key] === value)
+            continue;
+        repaired ??= { ...query };
+        repaired[key] = value;
+    }
+    for (const [key, value] of Object.entries(repaired ?? query)) {
+        if (!key.startsWith("nxtP") || isFilledParam(value))
+            continue;
+        if (isFilledParam(routeMatches[key]))
+            continue;
+        repaired ??= { ...query };
+        delete repaired[key];
+    }
+    return repaired ?? query;
+}
+/**
+ * Route params to hand Next.js out-of-band, for the one request shape the `nxtP`
+ * query contract cannot carry: a capture containing an encoded `/`. `undefined`
+ * — the common case — means the contract is lossless and nothing special is
+ * needed.
+ *
+ * The contract normally is lossless, which is why {@link NextjsRuntime} passes
+ * route params as query values everywhere else. But `RouteModule.prepare`
+ * recovers them by running `normalizeQueryParams` — which calls
+ * `decodeQueryPathParameter`, a **second** `decodeURIComponent`, on every
+ * de-prefixed value because "when deployed to Vercel the value may be encoded" —
+ * and then `normalizeDynamicRouteParams`, which splits a string repeat param on
+ * `/` because "query values from the proxy aren't already split into arrays".
+ * Two decodes and a split: `nxtPrest=..%252F..%252Fserver-reference-manifest`
+ * (what the contract asks for, and what we send) arrives as the three params
+ * `['..', '..', 'server-reference-manifest']` rather than the one the client
+ * requested. The resolved pathname built back out of those is
+ * `/pages-cache/../../server-reference-manifest`, and `normalizePagePath` throws
+ * `Requested and resolved page mismatch` on it when the cache asks for a key —
+ * so a `_next/data` request for a catch-all whose segment contains `%2F` 500s.
+ * Measured against `test/e2e/incremental-cache-path-traversal`. No encoding can
+ * fix it from this side: whatever survives two decodes still gets split.
+ *
+ * `next start` never hits it because its `router-server` sets
+ * `requestMeta.params` instead, which `prepare` takes as-is
+ * (`route-module.ts`: `getRequestMeta(req, 'params')`) with no decode and no
+ * split. That is what this reproduces — narrowly, only for the affected
+ * requests, so that the documented query contract stays the path for everything
+ * else.
+ *
+ * The `nxtP` values have to leave the query as well as arrive in `params`.
+ * `prepare` prefers the query over `params` when both parse and are the same
+ * size, so leaving them in would just restore the split. Dropping them also
+ * matches `next start`, which has no `nxtP` query at all.
+ */
+function outOfBandRouteParams(query, resolvedPathname) {
+    const entries = Object.entries(query);
+    if (!entries.some(([key, value]) => key.startsWith("nxtP") &&
+        typeof value === "string" &&
+        ENCODED_PATH_DELIMITER.test(value))) {
+        return undefined;
+    }
+    // Which params are repeats — `[...rest]`, `[[...rest]]` — decides array versus
+    // string, the same distinction `normalizeDynamicRouteParams` makes from the
+    // route's own `groups`. `resolvedPathname` is the matched route, brackets and
+    // all.
+    const repeats = new Set();
+    for (const match of resolvedPathname.matchAll(/\[\[?\.\.\.([^\]]+?)\]\]?/g)) {
+        repeats.add(match[1]);
+    }
+    const params = {};
+    const remaining = {};
+    for (const [key, value] of entries) {
+        if (!key.startsWith("nxtP")) {
+            remaining[key] = value;
+            continue;
+        }
+        // Anything but a filled string is a param we cannot restate — an optional
+        // catchall the request left unset, or a repeated key. Rather than hand
+        // `prepare` a param set that is missing one, leave the whole request on the
+        // query contract.
+        if (typeof value !== "string" || value === "")
+            return undefined;
+        const name = key.slice("nxtP".length);
+        params[name] = repeats.has(name)
+            ? value.split("/").map(util_1.safeDecode)
+            : (0, util_1.safeDecode)(value);
+    }
+    return { params, query: remaining };
+}
+/** An encoded `/`: the delimiter the query contract's split would consume. */
+const ENCODED_PATH_DELIMITER = /%2f/i;
+/** Whether a route param carries a segment, as opposed to `""` or nothing. */
+function isFilledParam(value) {
+    return Array.isArray(value) ? value.length > 0 : Boolean(value);
+}
+/**
+ * The order next itself uses, in `base-server.ts`'s `renderErrorToResponse`:
+ * the status page's entrypoints, then its prerender, then `/_error`, which is
+ * the built-in error page unless the app wrote its own.
+ *
+ * For a 404 the entrypoints are App Router's `/_not-found`, then Pages
+ * Router's `/404`. `/404` has to come before `/_error` — it is the app's
+ * *custom* 404, and `/_error` is the built-in "404: This page could not be
+ * found". Measured against `test/e2e/404-page-app`, where every URL got the
+ * built-in page. For a 500 it is `/500`.
+ *
+ * The prerender is almost always there: `next build` emits `404.html` whenever
+ * `pages/_app` has no `getInitialProps` (`useStaticPages404`), from the app's
+ * `pages/404.js` or else from `_error`, and `pages/500.js` is a
+ * `STATIC_STATUS_PAGES` entry. So it reaches us as a static file — under i18n
+ * one per locale (`/en-US/404`), and never a bare `/404` — and `next start`
+ * serves it ahead of `/_error`, which every Pages build has. The page is an
+ * entrypoint only when something forces a per-request render, which a
+ * `getInitialProps` in `_app` does.
+ *
+ * A 500 is only rendered when an entrypoint *throws*. Next.js's page handlers
+ * deliberately rethrow ("rethrow so that we can handle serving error page",
+ * `pages-handler.ts`), leaving the error page to whatever is hosting them —
+ * measured against `test/e2e/async-modules`, whose `/make-error` throws in
+ * `getServerSideProps` and expects the app's `pages/_error`.
+ *
+ * Apps with none of these get nothing.
+ */
+function statusTarget(manifest, status, 
+/** Which locale's prerender to look for, in an i18n app. */
+locale) {
+    const { basePath } = manifest.config;
+    for (const suffix of manifest_1.STATUS_PAGE_SUFFIXES[status]) {
+        const pathname = `${basePath}${suffix}`;
+        const entrypoint = manifest.entrypoints[pathname];
+        if (entrypoint) {
+            return { kind: "entrypoint", pathname, entrypoint };
+        }
+    }
+    const prerendered = `${basePath}${locale ? `/${locale}` : ""}/${status}`;
+    const filePath = manifest.staticFiles[prerendered];
+    if (filePath !== undefined) {
+        return { kind: "static-file", pathname: prerendered, filePath };
+    }
+    const errorPathname = `${basePath}${manifest_1.STATUS_PAGE_SUFFIXES.fallback}`;
+    const errorEntrypoint = manifest.entrypoints[errorPathname];
+    if (errorEntrypoint) {
+        return {
+            kind: "entrypoint",
+            pathname: errorPathname,
+            entrypoint: errorEntrypoint,
+        };
+    }
+    return { kind: "none" };
+}
+/**
+ * {@link statusTarget} for every locale, resolved once, and a lookup of the
+ * request's: in an i18n app, the prerender of the locale the URL is in
+ * (`/fr/nope` gets `/fr/404`), and otherwise of the domain's default locale —
+ * which is how `next start` picks the locale it renders a status page in. A
+ * request whose URL could not be parsed, `undefined`, gets the default
+ * locale's.
+ */
+function statusTargets(manifest, status) {
+    const i18n = asI18n(manifest.config.i18n);
+    const fallback = statusTarget(manifest, status, i18n?.defaultLocale);
+    const byLocale = new Map((i18n?.locales ?? []).map((locale) => [
+        locale,
+        statusTarget(manifest, status, locale),
+    ]));
+    return (url) => {
+        const locale = url ? requestLocale(manifest, url) : undefined;
+        return (locale !== undefined && byLocale.get(locale)) || fallback;
+    };
+}
+/**
+ * The locale a request's status page renders in, the way `next start` picks it:
+ * the locale the URL's first segment names (case-insensitively, as
+ * `normalizeLocalePath` matches it), and otherwise the domain's default locale,
+ * then the app's. `undefined` without i18n.
+ */
+function requestLocale(manifest, url) {
+    const i18n = asI18n(manifest.config.i18n);
+    if (!i18n)
+        return undefined;
+    const pathname = (0, util_1.withoutPathPrefix)(url.pathname, manifest.config.basePath);
+    const segment = (pathname.split("/")[1] ?? "").toLowerCase();
+    return (i18n.locales.find((candidate) => candidate.toLowerCase() === segment) ??
+        (0, routing_1.detectDomainLocale)(i18n.domains, url.hostname)?.defaultLocale ??
+        i18n.defaultLocale);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dispatch.js","sourceRoot":"","sources":["../../src/runtime/dispatch.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\n/**\n * Request dispatch: URL in, routing decision out.\n *\n * All route matching is delegated to `@next/routing`'s `resolveRoutes`, the\n * first-party package `next start` was refactored to expose. Reimplementing\n * redirects/rewrites/i18n/dynamic-route matching is what previous versions of\n * this construct did, and it is the thing this rewrite exists to delete.\n *\n * This module is pure decision-making: it never touches the filesystem, never\n * requires an entrypoint, and never builds a `Response`. It returns a\n * {@link DispatchResult} and the caller (the runtime core, step 4) acts on it.\n * That split is what makes it unit-testable against the committed\n * `onBuildComplete` fixtures with no AWS and no Next.js server.\n */\nimport {\n  MiddlewareContext,\n  MiddlewareResult,\n  ResolveRoutesParams,\n  ResolveRoutesQuery,\n  ResolveRoutesQueryValue,\n  ResolveRoutesResult,\n  RouteInvocationTarget,\n  detectDomainLocale,\n  detectLocale,\n  resolveRoutes,\n} from \"@next/routing\";\nimport {\n  AdapterEntrypoint,\n  AdapterManifest,\n  STATUS_PAGE_SUFFIXES,\n} from \"./manifest\";\nimport { publicDirKey } from \"./public-files\";\nimport { safeDecode, toSearch, withoutPathPrefix } from \"./util\";\n\n/**\n * Runs the app's middleware for one request. Supplied by `MiddlewareRunner` in\n * `./middleware`.\n *\n * `MiddlewareContext` carries no method — `resolveRoutes` never needs one — but\n * middleware very much does (`if (request.method === \"POST\")`), so dispatch adds\n * it from the request it was given. The `Response` middleware returned comes\n * back beside the result, because `resolveRoutes` reports `middlewareResponded`\n * without it.\n */\nexport type MiddlewareInvoker = (\n  ctx: MiddlewareContext & { readonly method: string },\n) => Promise<MiddlewareResult & { readonly response: Response }>;\n\nexport interface DispatcherOptions {\n  readonly manifest: AdapterManifest;\n  /**\n   * The files under `public/`, from `readPublicFiles`: unencoded paths relative\n   * to it. Served ahead of every route, as `next start` serves them.\n   * @default - no `public/` files\n   */\n  readonly publicFiles?: readonly string[];\n}\n\nexport interface DispatchRequest {\n  readonly method: string;\n  readonly url: URL;\n  readonly headers: Headers;\n  /**\n   * Always a stream — `resolveRoutes` requires one because middleware may read\n   * the body. Use an already-closed stream for GET/HEAD.\n   */\n  readonly body: ReadableStream;\n  /**\n   * Required whenever `manifest.middleware` is non-null. `resolveRoutes` decides\n   * *whether* to call it from `routing.middlewareMatchers`; we only supply the\n   * how.\n   */\n  readonly invokeMiddleware?: MiddlewareInvoker;\n}\n\ninterface DispatchResultBase {\n  /**\n   * Headers to merge into the response: `headers()` rules, the immutable\n   * `cache-control` for `_next/static`, and anything middleware set via\n   * `NextResponse.next({ headers })`. Never request headers.\n   */\n  readonly responseHeaders: Headers;\n  /** Status forced by a matched route, if any. */\n  readonly status?: number;\n}\n\n/** A route we must invoke. */\nexport interface DispatchEntrypointResult extends DispatchResultBase {\n  readonly kind: \"entrypoint\";\n  readonly entrypoint: AdapterEntrypoint;\n  /** The matched template, i.e. the `manifest.entrypoints` key. */\n  readonly resolvedPathname: string;\n  /** The *concrete* pathname + query to invoke the route with. */\n  readonly invocationTarget: RouteInvocationTarget;\n  /** Request headers as middleware left them. */\n  readonly requestHeaders: Headers;\n}\n\n/** A file in `manifest.staticFiles` or `public/`: read off disk, not invoked. */\nexport interface DispatchStaticFileResult extends DispatchResultBase {\n  readonly kind: \"static-file\";\n  readonly pathname: string;\n  /** Repo-root-relative key inside the deployment root. */\n  readonly filePath: string;\n  readonly source: StaticFileSource;\n  /**\n   * Request headers as middleware left them, for the 404 the runtime renders\n   * when the file is not in the package after all.\n   */\n  readonly requestHeaders: Headers;\n}\n\n/**\n * Where a static file came from, which decides what else it is allowed to do.\n *\n * - `public` — a file in `public/`.\n * - `next-static` — `<distDir>/static`, the client bundles.\n * - `server` — a build output under `<distDir>/server`: prerendered HTML, a\n *   static metadata route's `.body`.\n *\n * The first two are what `next start` serves as plain files, with `send`, and\n * only to GET and HEAD (`router-server.js`, the `fsPath` branch); the third it\n * serves by invoking the route it came from.\n */\nexport type StaticFileSource = \"public\" | \"next-static\" | \"server\";\n\n/** `/_next/image`: our own optimizer, deliberately reached after middleware. */\nexport interface DispatchImageOptimizationResult extends DispatchResultBase {\n  readonly kind: \"image-optimization\";\n  readonly url: URL;\n  readonly requestHeaders: Headers;\n}\n\nexport interface DispatchRedirectResult extends DispatchResultBase {\n  readonly kind: \"redirect\";\n  readonly location: string;\n  readonly status: number;\n}\n\n/** A rewrite to another origin: proxy the request through. */\nexport interface DispatchExternalRewriteResult extends DispatchResultBase {\n  readonly kind: \"external-rewrite\";\n  readonly url: URL;\n  readonly requestHeaders: Headers;\n}\n\n/** Middleware returned its own response: send it. */\nexport interface DispatchMiddlewareRespondedResult extends DispatchResultBase {\n  readonly kind: \"middleware-responded\";\n  readonly response: Response;\n}\n\n/** A matched route forced a status with nothing to invoke. */\nexport interface DispatchDirectResponseResult extends DispatchResultBase {\n  readonly kind: \"response\";\n  readonly status: number;\n}\n\nexport interface DispatchNotFoundResult extends DispatchResultBase {\n  readonly kind: \"not-found\";\n  /** What failed to resolve. For logging. */\n  readonly pathname: string;\n  readonly requestHeaders: Headers;\n}\n\nexport type DispatchResult =\n  | DispatchEntrypointResult\n  | DispatchStaticFileResult\n  | DispatchImageOptimizationResult\n  | DispatchRedirectResult\n  | DispatchExternalRewriteResult\n  | DispatchMiddlewareRespondedResult\n  | DispatchDirectResponseResult\n  | DispatchNotFoundResult;\n\n/**\n * How to produce a 404 or 500 body. Resolved once per locale from the manifest\n * (see {@link statusTargets}); honoring `notFound()` from a route is the\n * runtime core's job, not dispatch's.\n */\nexport type StatusTarget =\n  | {\n      readonly kind: \"entrypoint\";\n      readonly pathname: string;\n      readonly entrypoint: AdapterEntrypoint;\n    }\n  | {\n      readonly kind: \"static-file\";\n      readonly pathname: string;\n      readonly filePath: string;\n    }\n  | { readonly kind: \"none\" };\n\n/**\n * `ctx.routing` is persisted into the manifest verbatim and typed `unknown`\n * there, because the manifest must not depend on `@next/routing` (it is also\n * read at synth by the CDK constructs). Dispatch is the one place that knows\n * the real shape, so the cast lives here.\n *\n * `ctx.routing` is a superset of `ResolveRoutesParams[\"routes\"]` — it also\n * carries `rsc` — which is why this is a cast and not an assignment.\n */\nfunction asRoutes(routing: unknown): ResolveRoutesParams[\"routes\"] {\n  return routing as ResolveRoutesParams[\"routes\"];\n}\n\n/**\n * Likewise for `i18n`: `NextConfigComplete[\"i18n\"]` is wider than\n * `ResolveRoutesParams[\"i18n\"]` (extra fields, and `localeDetection?: boolean`\n * against `false`), and the manifest stores the config value as-is.\n */\nfunction asI18n(i18n: unknown | null): ResolveRoutesParams[\"i18n\"] | undefined {\n  return i18n ? (i18n as ResolveRoutesParams[\"i18n\"]) : undefined;\n}\n\nexport class Dispatcher {\n  /** The 404 to render for a request to a URL; see {@link statusTargets}. */\n  public readonly notFoundFor: (url: URL) => StatusTarget;\n\n  private readonly routes: ResolveRoutesParams[\"routes\"];\n  private readonly i18n: ResolveRoutesParams[\"i18n\"] | undefined;\n  private readonly table: RoutingTable;\n  private readonly imagePathname: string;\n  private readonly trailingSlash: boolean;\n\n  public constructor(private readonly options: DispatcherOptions) {\n    const { manifest } = options;\n    this.routes = asRoutes(manifest.routing);\n    this.i18n = asI18n(manifest.config.i18n);\n    this.trailingSlash = manifest.config.trailingSlash;\n    this.table = buildRoutingTable(manifest, options.publicFiles ?? []);\n    this.imagePathname = `${manifest.config.basePath}/_next/image`;\n    this.notFoundFor = statusTargets(manifest, 404);\n  }\n\n  public get manifest(): AdapterManifest {\n    return this.options.manifest;\n  }\n\n  /**\n   * Drop the `trailingSlash` slash a resolved pathname may carry, so it can be\n   * looked up in `entrypoints`/`staticFiles` and rendered under the same cache\n   * key as its prerender. A no-op unless the app sets `trailingSlash`.\n   */\n  private normalizePathname(pathname: string | undefined): string | undefined {\n    if (!this.trailingSlash || pathname === undefined) return pathname;\n    return pathname.length > 1 && pathname.endsWith(\"/\")\n      ? pathname.slice(0, -1)\n      : pathname;\n  }\n\n  /** The request path with `basePath` removed, which is what i18n applies to. */\n  private withoutBasePath(pathname: string): string {\n    return withoutPathPrefix(pathname, this.manifest.config.basePath);\n  }\n\n  /**\n   * Put the locale in front of a request for the app's root *here*, when the\n   * locale is the one the request is already in.\n   *\n   * `resolveRoutes` prefixes the locale itself, as `${basePath}/${locale}${pathname}`\n   * — which for the root turns `/` into `/en-US/`. The slash-stripping 308 that\n   * `next build` always compiles into `routing.beforeMiddleware` then matches it,\n   * so `GET /` came back as a redirect no `next start` sends: measured against\n   * `test/e2e/i18n-support-catchall`, where `/` answers 200. Next.js's own router\n   * special-cases exactly this (`resolve-routes.ts`: `pathname === '/' ?\n   * `/${defaultLocale}` : …`).\n   *\n   * With `trailingSlash`, the prefixed root keeps its slash (`/en-US/`): the\n   * slash-*adding* 308 that build compiles instead matches `/en-US` the same\n   * way, and `/en-US/` is the canonical URL `next start` serves with a 200.\n   *\n   * Only the root, and only when no redirect is owed: a request whose detected\n   * locale is *not* the default has to reach `resolveRoutes`, which answers it\n   * with the 307 Next.js sends — after middleware has had the request, which is\n   * the ordering that matters and the reason this does not redirect itself.\n   */\n  private withRootLocale(url: URL, headers: Headers): URL {\n    const i18n = this.i18n;\n    if (!i18n) return url;\n    const pathname = this.withoutBasePath(url.pathname);\n    if (pathname !== \"/\") return url;\n\n    const defaultLocale =\n      detectDomainLocale(i18n.domains, url.hostname)?.defaultLocale ??\n      i18n.defaultLocale;\n    const detected = detectLocale({\n      pathname,\n      hostname: url.hostname,\n      cookieHeader: headers.get(\"cookie\") ?? undefined,\n      acceptLanguageHeader: headers.get(\"accept-language\") ?? undefined,\n      i18n,\n    });\n    if (detected.locale !== defaultLocale) return url;\n\n    const prefixed = new URL(url.toString());\n    prefixed.pathname = `${this.manifest.config.basePath}/${defaultLocale}${\n      this.trailingSlash ? \"/\" : \"\"\n    }`;\n    return prefixed;\n  }\n\n  /**\n   * Repair the two things `resolveRoutes` gets wrong about a redirect it built\n   * from the locale-prefixed root — the same `${basePath}/${locale}${pathname}`\n   * concatenation as in {@link withRootLocale}, this time reported as a location:\n   *\n   * - the stray trailing slash (`/nl/`, where Next.js sends `/nl`), which\n   *   otherwise costs a second round trip to the 308 that strips it, and\n   * - the absolute URL, where Next.js sends a path. Both are legal, but a test\n   *   asserting `headers.location` sees the difference, and so does any client\n   *   comparing it to a link.\n   */\n  private normalizeRedirectLocation(location: string, request: URL): string {\n    let resolved: URL;\n    try {\n      resolved = new URL(location, request);\n    } catch {\n      return location;\n    }\n    if (resolved.origin !== request.origin) return location;\n\n    const target = this.withoutBasePath(resolved.pathname);\n    const isLocaleRoot =\n      this.i18n !== undefined &&\n      !this.trailingSlash &&\n      this.withoutBasePath(request.pathname) === \"/\" &&\n      this.i18n.locales.some((locale) => target === `/${locale}/`);\n    if (isLocaleRoot) {\n      resolved.pathname = resolved.pathname.slice(0, -1);\n    }\n    return `${resolved.pathname}${resolved.search}${resolved.hash}`;\n  }\n\n  /**\n   * The `headers()` rules a request matched, for a response middleware wrote\n   * itself.\n   *\n   * They compile into `routing.beforeMiddleware`, and `resolveRoutes` applies\n   * them there, but when middleware answers it returns `{ middlewareResponded:\n   * true }` and nothing else, so they were lost: a middleware 401 went out\n   * without the app's HSTS and CSP. `next start` sends them with it (its\n   * `resolve-routes.js` sets them on the response before middleware runs). So\n   * that one phase is run again on its own — no middleware, no files, nothing\n   * after it — which leaves exactly the headers it set.\n   */\n  private async beforeMiddlewareHeaders(\n    url: URL,\n    headers: Headers,\n  ): Promise<Headers> {\n    const result = await resolveRoutes({\n      url,\n      buildId: this.manifest.buildId,\n      basePath: this.manifest.config.basePath,\n      headers,\n      requestBody: new Blob([]).stream(),\n      pathnames: [],\n      routes: {\n        ...this.routes,\n        middlewareMatchers: [],\n        beforeFiles: [],\n        afterFiles: [],\n        dynamicRoutes: [],\n        onMatch: [],\n        fallback: [],\n      },\n      i18n: this.i18n,\n      invokeMiddleware: async () => ({}),\n    });\n    const responseHeaders = new Headers(result.resolvedHeaders ?? undefined);\n    // A locale-detection redirect is decided after middleware, and middleware\n    // already answered, so its `location` is not owed.\n    if (result.redirect) {\n      responseHeaders.delete(\"location\");\n    }\n    return responseHeaders;\n  }\n\n  /**\n   * The URL to optimize, once `/_next/image` has resolved: as middleware\n   * rewrote it, or as received — or, when a `next.config` rewrite is what put\n   * the request on the image path, rebuilt from the query `resolveRoutes`\n   * resolved, which is the only place that rewrite's destination query is.\n   */\n  private imageUrl(result: ResolveRoutesResult, received: URL): URL {\n    if (received.pathname === this.imagePathname) return received;\n    const url = new URL(received.toString());\n    url.pathname = this.imagePathname;\n    if (result.resolvedQuery) {\n      url.search = toSearch(result.resolvedQuery);\n    }\n    return url;\n  }\n\n  public async dispatch(request: DispatchRequest): Promise<DispatchResult> {\n    // Copied because `resolveRoutes` is free to mutate what it is handed, and\n    // the caller's headers object outlives this call.\n    const requestHeaders = new Headers(request.headers);\n    // A second copy, as the request reached `beforeMiddleware`, for\n    // {@link beforeMiddlewareHeaders}.\n    const receivedHeaders = new Headers(request.headers);\n    const url = this.withRootLocale(request.url, requestHeaders);\n    let middlewareRequestHeaders: Headers | undefined;\n    let middlewareRewrite: URL | undefined;\n    let middlewareResponse: Response | undefined;\n\n    const result = await resolveRoutes({\n      url,\n      buildId: this.manifest.buildId,\n      basePath: this.manifest.config.basePath,\n      headers: requestHeaders,\n      requestBody: request.body,\n      pathnames: this.table.pathnames,\n      routes: this.routes,\n      i18n: this.i18n,\n      // Only called when a `middlewareMatchers` entry matches, which only a\n      // build with middleware has.\n      invokeMiddleware: async (ctx) => {\n        const { response, ...middleware } = await request.invokeMiddleware!({\n          ...ctx,\n          method: request.method,\n        });\n        middlewareResponse = response;\n        // `resolveRoutes` drops `MiddlewareResult.requestHeaders` entirely: it\n        // neither returns them nor mutates the `headers` passed in. Capturing\n        // them here is what keeps `NextResponse.next({ request: { headers } })`\n        // working.\n        if (middleware.requestHeaders) {\n          middlewareRequestHeaders = middleware.requestHeaders;\n        }\n        // Captured for the same reason: `resolveRoutes` routes the rewritten URL\n        // internally but never reports it back, and `/_next/image` is matched\n        // here rather than by `resolveRoutes` (see below), so this is the only\n        // way to see the path middleware actually asked for.\n        if (middleware.rewrite) {\n          middlewareRewrite = middleware.rewrite;\n        }\n        return middleware;\n      },\n    });\n\n    const responseHeaders = new Headers(result.resolvedHeaders ?? undefined);\n    // `@next/routing` echoes the rewrite it followed into `resolvedHeaders`;\n    // Next.js's own router consumes that header rather than sending it, and so do\n    // we — it is an internal routing signal, and forwarding it would expose the\n    // app's post-middleware paths to clients.\n    responseHeaders.delete(\"x-middleware-rewrite\");\n    const forwardedHeaders = middlewareRequestHeaders ?? requestHeaders;\n    const status = result.status;\n\n    if (result.middlewareResponded && middlewareResponse) {\n      return {\n        kind: \"middleware-responded\",\n        response: middlewareResponse,\n        responseHeaders: await this.beforeMiddlewareHeaders(\n          url,\n          receivedHeaders,\n        ),\n        status,\n      };\n    }\n\n    if (result.externalRewrite) {\n      return {\n        kind: \"external-rewrite\",\n        url: result.externalRewrite,\n        requestHeaders: forwardedHeaders,\n        responseHeaders,\n        status,\n      };\n    }\n\n    const redirect = toRedirect(result, responseHeaders);\n    if (redirect) {\n      return {\n        kind: \"redirect\",\n        ...redirect,\n        location: this.normalizeRedirectLocation(\n          redirect.location,\n          request.url,\n        ),\n        responseHeaders,\n      };\n    }\n\n    // Both are keys into `entrypoints`/`staticFiles`, which never carry a\n    // trailing slash; see {@link withTrailingSlashVariants}.\n    const resolvedPathname = this.normalizePathname(result.resolvedPathname);\n    // In `pathnames` (see {@link buildRoutingTable}), so it resolves in the\n    // filesystem phase: after middleware and `beforeFiles`, and before any\n    // dynamic route, which is `next start`'s order. Unlisted, a root catch-all\n    // (`app/[...slug]`) or any two-segment dynamic route took every image\n    // request as `slug: [\"_next\", \"image\"]`.\n    if (resolvedPathname === this.imagePathname) {\n      return {\n        kind: \"image-optimization\",\n        url: this.imageUrl(result, middlewareRewrite ?? request.url),\n        requestHeaders: forwardedHeaders,\n        responseHeaders,\n      };\n    }\n    if (resolvedPathname !== undefined) {\n      const staticFile = this.table.staticFiles.get(resolvedPathname);\n      const asStaticFile = (\n        file: StaticFileTarget,\n      ): DispatchStaticFileResult => ({\n        kind: \"static-file\",\n        pathname: resolvedPathname,\n        filePath: file.filePath,\n        source: file.source,\n        requestHeaders: forwardedHeaders,\n        responseHeaders,\n        status,\n      });\n      // Ahead of the entrypoints, which is `next start`'s order: its filesystem\n      // check tries `_next/static` and then `public/` before any app or page\n      // route, so `public/robots.txt` beats `app/robots.ts` and\n      // `public/favicon.ico` beats `app/favicon.ico`.\n      if (staticFile && staticFile.source !== \"server\") {\n        return asStaticFile(staticFile);\n      }\n      const entrypoint = this.manifest.entrypoints[resolvedPathname];\n      if (entrypoint) {\n        const query = repairRouteParamQuery(\n          result.resolvedQuery ?? {},\n          result.routeMatches ?? {},\n        );\n        return {\n          kind: \"entrypoint\",\n          entrypoint,\n          resolvedPathname,\n          // `invocationTarget` is always present alongside `resolvedPathname` in\n          // practice; the fallback keeps a `next` shape change from crashing.\n          invocationTarget: {\n            pathname:\n              this.normalizePathname(result.invocationTarget?.pathname) ??\n              resolvedPathname,\n            query,\n          },\n          requestHeaders: forwardedHeaders,\n          responseHeaders,\n          status,\n        };\n      }\n      if (staticFile) {\n        return asStaticFile(staticFile);\n      }\n    }\n\n    if (status !== undefined) {\n      return { kind: \"response\", status, responseHeaders };\n    }\n\n    const resolvedUrl = middlewareRewrite ?? request.url;\n    return {\n      kind: \"not-found\",\n      pathname: resolvedPathname ?? resolvedUrl.pathname,\n      requestHeaders: forwardedHeaders,\n      responseHeaders,\n    };\n  }\n}\n\n/** A static file, as dispatch resolves one. */\ninterface StaticFileTarget {\n  readonly filePath: string;\n  readonly source: StaticFileSource;\n}\n\n/**\n * What dispatch matches a request against, derived once from the manifest and\n * `public/`: with a few thousand `public/` files the derivation would be most\n * of the cost of a dispatch.\n */\ninterface RoutingTable {\n  /**\n   * Every pathname `resolveRoutes` may match: the manifest's, every spelling of\n   * every static file, and — for a `trailingSlash` app — the slash variants.\n   */\n  readonly pathnames: string[];\n  /** Every spelling a static file is requested by → the file. */\n  readonly staticFiles: ReadonlyMap<string, StaticFileTarget>;\n}\n\n/**\n * Build outputs first, then `public/` on top of them, except over\n * `_next/static`: that is `next start`'s precedence (see\n * {@link Dispatcher.dispatch}).\n *\n * A `public/` file is registered under its pathname with the default locale in\n * front, too, for an i18n app. `resolveRoutes` puts a locale on every path\n * outside `/_next/` and `/api/` before it matches, so `/test.txt` is looked up\n * as `/en-US/test.txt` and never matched the bare key: no `public/` file\n * resolved in an i18n app at all. `next start` strips the default locale — and\n * each domain's — off a `public/` request and no other locale (filesystem.js:\n * \"legacy behavior allows visiting static assets under default locale but no\n * other locale\"), which these entries reproduce: `/en-US/test.txt` serves and\n * `/fr/test.txt` does not.\n */\nfunction buildRoutingTable(\n  manifest: AdapterManifest,\n  publicFiles: readonly string[],\n): RoutingTable {\n  const { basePath, trailingSlash } = manifest.config;\n  const staticFiles = new Map<string, StaticFileTarget>();\n  const nextStaticPrefix = `${basePath}/_next/static/`;\n\n  for (const [pathname, filePath] of Object.entries(manifest.staticFiles)) {\n    const target: StaticFileTarget = {\n      filePath,\n      source: pathname.startsWith(nextStaticPrefix) ? \"next-static\" : \"server\",\n    };\n    // The key as Next.js reported it, and then as a request spells it: a build\n    // output's pathname is the file's own name, unencoded, and the HTML that\n    // loads it percent-encodes it. `app/isr/[id]/page.tsx`'s webpack chunk is\n    // `/_next/static/chunks/app/isr/[id]/page-<hash>.js` in the outputs and\n    // `…/isr/%5Bid%5D/page-<hash>.js` in the `<script>` tag.\n    for (const spelling of [pathname, ...requestSpellings(pathname)]) {\n      if (!staticFiles.has(spelling)) {\n        staticFiles.set(spelling, target);\n      }\n    }\n  }\n\n  const publicDir = publicDirKey(manifest);\n  const i18n = asI18n(manifest.config.i18n);\n  const localePrefixes = [\n    \"\",\n    ...new Set(\n      i18n\n        ? [\n            i18n.defaultLocale,\n            ...(i18n.domains ?? []).map((domain) => domain.defaultLocale),\n          ].map((locale) => `/${locale}`)\n        : [],\n    ),\n  ];\n  for (const file of publicFiles) {\n    const target: StaticFileTarget = {\n      filePath: `${publicDir}/${file}`,\n      source: \"public\",\n    };\n    for (const spelling of requestSpellings(`/${file}`)) {\n      for (const prefix of localePrefixes) {\n        const pathname = `${basePath}${prefix}${spelling}`;\n        if (staticFiles.get(pathname)?.source !== \"next-static\") {\n          staticFiles.set(pathname, target);\n        }\n      }\n    }\n  }\n\n  // `/_next/image` is not an adapter output, but it is a filesystem route to\n  // `next start` (`filesystem.js` answers it as `nextImage`), and listing it is\n  // what lets it resolve ahead of the dynamic routes; see\n  // {@link Dispatcher.dispatch}.\n  const pathnames = [\n    ...new Set([\n      ...manifest.pathnames,\n      ...staticFiles.keys(),\n      `${basePath}/_next/image`,\n    ]),\n  ];\n  return {\n    pathnames: trailingSlash ? withTrailingSlashVariants(pathnames) : pathnames,\n    staticFiles,\n  };\n}\n\n/**\n * The ways a request spells an unencoded path, for the exact match\n * `@next/routing` does against `pathnames`.\n *\n * Two, because there are two ways to write a link to `public/images/logo@2x.png`\n * and a browser sends each as written: `/images/logo@2x.png`, which the WHATWG\n * URL parser leaves alone — it only encodes spaces, quotes, `#`, `?`, `<>`,\n * `` ` ``, `{}` and non-ASCII in a path — and `/images/logo%402x.png`, which is\n * `encodeURIComponent` a segment at a time and is how Next.js keys its own\n * `public/` set (`encodeURIPath`). For most names the two are the same string;\n * they differ for `@ + & , ; = $ : [ ]` and the like, and a key in only the\n * second form 404'd every `logo@2x.png`, `c++.svg` and `icon[1].png`.\n *\n * `%` is encoded in both, since a literal `%` in a name can only be requested\n * as `%25`; so are `?` and `#`, which would otherwise end the path, and `\\`,\n * which the parser turns into `/`.\n */\nfunction requestSpellings(path: string): string[] {\n  const segments = path.split(\"/\");\n  const encoded = segments.map(encodeURIComponent).join(\"/\");\n  const parsed = new URL(\n    segments\n      .map((segment) => segment.replace(/[%?#\\\\]/g, encodeURIComponent))\n      .join(\"/\"),\n    \"http://n\",\n  ).pathname;\n  return parsed === encoded ? [encoded] : [encoded, parsed];\n}\n\n/**\n * Normalize the two shapes `resolveRoutes` reports a redirect in.\n *\n * `ResolveRoutesResult.redirect` is documented, and an i18n locale-detection 307\n * arrives that way, but the rest — the slash-stripping 308, a middleware\n * `NextResponse.redirect()` — arrive instead as a bare `status` with `location`\n * in `resolvedHeaders`. `next.config` `redirects()` too: they compile to routes\n * carrying `headers: { Location }` plus `status`. Both shapes are handled, and\n * {@link Dispatcher.normalizeRedirectLocation} then puts the location itself in\n * the form Next.js sends.\n */\nexport function toRedirect(\n  result: ResolveRoutesResult,\n  responseHeaders: Headers,\n): { location: string; status: number } | undefined {\n  if (result.redirect) {\n    return {\n      location: result.redirect.url.href,\n      status: result.redirect.status,\n    };\n  }\n  const location = responseHeaders.get(\"location\");\n  if (\n    location !== null &&\n    result.status !== undefined &&\n    result.status >= 300 &&\n    result.status < 400\n  ) {\n    return { location, status: result.status };\n  }\n  return undefined;\n}\n\n/**\n * Add `<pathname>/` alongside every route pathname, for a `trailingSlash` app.\n *\n * `trailingSlash: true` makes `/a/` the canonical URL — Next.js compiles a\n * `priority` 308 from `/a` to `/a/` into `routing.beforeMiddleware`, and that\n * redirect is the *first* thing `resolveRoutes` applies. But the build's output\n * pathnames have no trailing slash (`/a`, `/api/revalidate`), and\n * `@next/routing` matches them by exact string equality with no normalization of\n * its own. So every canonical URL in such an app resolved to nothing: browsers\n * followed the 308 to `/a/` and got a 404, and `fetch('/api/revalidate')` got\n * the 404 *page* — measured against next.js's `test/e2e/app-dir/trailingslash`,\n * where 6 of 8 cases failed this way. Dynamic routes escaped it only because\n * their `sourceRegex` happens to end in `(?:/)?`.\n *\n * Normalizing the request URL before `resolveRoutes` instead would be wrong: the\n * add-slash redirect matches the *slashless* path, so a normalized `/a/` would\n * come back as a 308 to `/a/` and loop. Teaching the match about the slash and\n * normalizing it off the *result* ({@link Dispatcher.normalizePathname}) keeps\n * the redirect exactly as Next.js compiled it.\n *\n * Pathnames whose last segment has an extension are skipped: those are static\n * files, and Next.js compiles the opposite redirect for them (`/x.js/` → 308\n * `/x.js`), which this must not shadow.\n */\nfunction withTrailingSlashVariants(pathnames: string[]): string[] {\n  const variants: string[] = [];\n  for (const pathname of pathnames) {\n    variants.push(pathname);\n    if (pathname !== \"/\" && !/\\.[^/]+$/.test(pathname)) {\n      variants.push(`${pathname}/`);\n    }\n  }\n  return variants;\n}\n\n/**\n * Correct the `nxtP` route params in a resolved query from `routeMatches`.\n *\n * `@next/routing` expands a dynamic route's destination\n * (`/[id]/[id2]?nxtPid=$nxtPid&nxtPid2=$nxtPid2`) by looping over the source\n * regex's named groups and doing one global string replace per group name. Group\n * names are substituted in insertion order, so `$nxtPid` — a *prefix* of\n * `$nxtPid2` — is replaced first and leaves the trailing `2` behind as a\n * literal: `/a/b` resolves with `nxtPid2=a2` instead of `nxtPid2=b`. Next.js\n * recovers `params` from exactly these query values (`RouteModule.prepare`), so\n * the page renders `id2: \"a2\"` — measured against\n * `test/e2e/app-dir/use-params`, whose fixture is `app/[id]/[id2]/page.tsx`.\n *\n * `routeMatches` is the raw capture map, before any destination expansion, so it\n * is the authority for every param it names. Only keys the expansion already\n * produced are overwritten: adding others would invent params for a rewrite that\n * deliberately dropped them.\n *\n * The same prefix collision reaches positional placeholders (`$1` inside `$10`,\n * so a route with ten or more captures), and `next.config` `rewrites()`\n * destinations that interpolate their own query values. Those are not route\n * params and are left alone — there is no second source of truth to repair them\n * from.\n *\n * The second correction is the opposite shape: a param the route *has* but the\n * request did not fill. An optional catchall's group is the only one a match can\n * leave unset — `^/optional\\-catchall(?:/(?<nxtPparams>.+?))?(?:/)?$` against\n * `/optional-catchall` — and both `routeMatches` and the expanded query keep the\n * key with no value: `{ nxtPparams: undefined }`, which the `@next/routing` types\n * do not admit. The key is what matters, not the value. `RouteModule.prepare`\n * recovers a param for every `nxtP` key it finds, so a layout reading `params`\n * renders a segment that was never requested — as `[\"undefined\"]`, because\n * `URLSearchParams.append` stringifies — where `next start` gives it no `params`\n * key at all. Measured against `test/e2e/app-dir/layout-params`, whose fixture is\n * `app/optional-catchall/[[...params]]`. No other param shape can be legitimately\n * unfilled — a required segment captures `[^/]+?` and a required catchall `.+?` —\n * so an unfilled value `routeMatches` does not vouch for is always this.\n */\nexport function repairRouteParamQuery(\n  query: ResolveRoutesQuery,\n  routeMatches: Record<string, string | undefined>,\n): ResolveRoutesQuery {\n  let repaired: ResolveRoutesQuery | undefined;\n  for (const [key, value] of Object.entries(routeMatches)) {\n    if (!key.startsWith(\"nxtP\") || value === undefined) continue;\n    if (!(key in query) || query[key] === value) continue;\n    repaired ??= { ...query };\n    repaired[key] = value;\n  }\n  for (const [key, value] of Object.entries(repaired ?? query)) {\n    if (!key.startsWith(\"nxtP\") || isFilledParam(value)) continue;\n    if (isFilledParam(routeMatches[key])) continue;\n    repaired ??= { ...query };\n    delete repaired[key];\n  }\n  return repaired ?? query;\n}\n\n/**\n * Route params to hand Next.js out-of-band, for the one request shape the `nxtP`\n * query contract cannot carry: a capture containing an encoded `/`. `undefined`\n * — the common case — means the contract is lossless and nothing special is\n * needed.\n *\n * The contract normally is lossless, which is why {@link NextjsRuntime} passes\n * route params as query values everywhere else. But `RouteModule.prepare`\n * recovers them by running `normalizeQueryParams` — which calls\n * `decodeQueryPathParameter`, a **second** `decodeURIComponent`, on every\n * de-prefixed value because \"when deployed to Vercel the value may be encoded\" —\n * and then `normalizeDynamicRouteParams`, which splits a string repeat param on\n * `/` because \"query values from the proxy aren't already split into arrays\".\n * Two decodes and a split: `nxtPrest=..%252F..%252Fserver-reference-manifest`\n * (what the contract asks for, and what we send) arrives as the three params\n * `['..', '..', 'server-reference-manifest']` rather than the one the client\n * requested. The resolved pathname built back out of those is\n * `/pages-cache/../../server-reference-manifest`, and `normalizePagePath` throws\n * `Requested and resolved page mismatch` on it when the cache asks for a key —\n * so a `_next/data` request for a catch-all whose segment contains `%2F` 500s.\n * Measured against `test/e2e/incremental-cache-path-traversal`. No encoding can\n * fix it from this side: whatever survives two decodes still gets split.\n *\n * `next start` never hits it because its `router-server` sets\n * `requestMeta.params` instead, which `prepare` takes as-is\n * (`route-module.ts`: `getRequestMeta(req, 'params')`) with no decode and no\n * split. That is what this reproduces — narrowly, only for the affected\n * requests, so that the documented query contract stays the path for everything\n * else.\n *\n * The `nxtP` values have to leave the query as well as arrive in `params`.\n * `prepare` prefers the query over `params` when both parse and are the same\n * size, so leaving them in would just restore the split. Dropping them also\n * matches `next start`, which has no `nxtP` query at all.\n */\nexport function outOfBandRouteParams(\n  query: ResolveRoutesQuery,\n  resolvedPathname: string,\n):\n  | { params: Record<string, string | string[]>; query: ResolveRoutesQuery }\n  | undefined {\n  const entries = Object.entries(query);\n  if (\n    !entries.some(\n      ([key, value]) =>\n        key.startsWith(\"nxtP\") &&\n        typeof value === \"string\" &&\n        ENCODED_PATH_DELIMITER.test(value),\n    )\n  ) {\n    return undefined;\n  }\n  // Which params are repeats — `[...rest]`, `[[...rest]]` — decides array versus\n  // string, the same distinction `normalizeDynamicRouteParams` makes from the\n  // route's own `groups`. `resolvedPathname` is the matched route, brackets and\n  // all.\n  const repeats = new Set<string>();\n  for (const match of resolvedPathname.matchAll(/\\[\\[?\\.\\.\\.([^\\]]+?)\\]\\]?/g)) {\n    repeats.add(match[1]);\n  }\n  const params: Record<string, string | string[]> = {};\n  const remaining: ResolveRoutesQuery = {};\n  for (const [key, value] of entries) {\n    if (!key.startsWith(\"nxtP\")) {\n      remaining[key] = value;\n      continue;\n    }\n    // Anything but a filled string is a param we cannot restate — an optional\n    // catchall the request left unset, or a repeated key. Rather than hand\n    // `prepare` a param set that is missing one, leave the whole request on the\n    // query contract.\n    if (typeof value !== \"string\" || value === \"\") return undefined;\n    const name = key.slice(\"nxtP\".length);\n    params[name] = repeats.has(name)\n      ? value.split(\"/\").map(safeDecode)\n      : safeDecode(value);\n  }\n  return { params, query: remaining };\n}\n\n/** An encoded `/`: the delimiter the query contract's split would consume. */\nconst ENCODED_PATH_DELIMITER = /%2f/i;\n\n/** Whether a route param carries a segment, as opposed to `\"\"` or nothing. */\nfunction isFilledParam(value: ResolveRoutesQueryValue | undefined): boolean {\n  return Array.isArray(value) ? value.length > 0 : Boolean(value);\n}\n\n/**\n * The order next itself uses, in `base-server.ts`'s `renderErrorToResponse`:\n * the status page's entrypoints, then its prerender, then `/_error`, which is\n * the built-in error page unless the app wrote its own.\n *\n * For a 404 the entrypoints are App Router's `/_not-found`, then Pages\n * Router's `/404`. `/404` has to come before `/_error` — it is the app's\n * *custom* 404, and `/_error` is the built-in \"404: This page could not be\n * found\". Measured against `test/e2e/404-page-app`, where every URL got the\n * built-in page. For a 500 it is `/500`.\n *\n * The prerender is almost always there: `next build` emits `404.html` whenever\n * `pages/_app` has no `getInitialProps` (`useStaticPages404`), from the app's\n * `pages/404.js` or else from `_error`, and `pages/500.js` is a\n * `STATIC_STATUS_PAGES` entry. So it reaches us as a static file — under i18n\n * one per locale (`/en-US/404`), and never a bare `/404` — and `next start`\n * serves it ahead of `/_error`, which every Pages build has. The page is an\n * entrypoint only when something forces a per-request render, which a\n * `getInitialProps` in `_app` does.\n *\n * A 500 is only rendered when an entrypoint *throws*. Next.js's page handlers\n * deliberately rethrow (\"rethrow so that we can handle serving error page\",\n * `pages-handler.ts`), leaving the error page to whatever is hosting them —\n * measured against `test/e2e/async-modules`, whose `/make-error` throws in\n * `getServerSideProps` and expects the app's `pages/_error`.\n *\n * Apps with none of these get nothing.\n */\nfunction statusTarget(\n  manifest: AdapterManifest,\n  status: 404 | 500,\n  /** Which locale's prerender to look for, in an i18n app. */\n  locale: string | undefined,\n): StatusTarget {\n  const { basePath } = manifest.config;\n  for (const suffix of STATUS_PAGE_SUFFIXES[status]) {\n    const pathname = `${basePath}${suffix}`;\n    const entrypoint = manifest.entrypoints[pathname];\n    if (entrypoint) {\n      return { kind: \"entrypoint\", pathname, entrypoint };\n    }\n  }\n  const prerendered = `${basePath}${locale ? `/${locale}` : \"\"}/${status}`;\n  const filePath = manifest.staticFiles[prerendered];\n  if (filePath !== undefined) {\n    return { kind: \"static-file\", pathname: prerendered, filePath };\n  }\n  const errorPathname = `${basePath}${STATUS_PAGE_SUFFIXES.fallback}`;\n  const errorEntrypoint = manifest.entrypoints[errorPathname];\n  if (errorEntrypoint) {\n    return {\n      kind: \"entrypoint\",\n      pathname: errorPathname,\n      entrypoint: errorEntrypoint,\n    };\n  }\n  return { kind: \"none\" };\n}\n\n/**\n * {@link statusTarget} for every locale, resolved once, and a lookup of the\n * request's: in an i18n app, the prerender of the locale the URL is in\n * (`/fr/nope` gets `/fr/404`), and otherwise of the domain's default locale —\n * which is how `next start` picks the locale it renders a status page in. A\n * request whose URL could not be parsed, `undefined`, gets the default\n * locale's.\n */\nexport function statusTargets(\n  manifest: AdapterManifest,\n  status: 404 | 500,\n): (url: URL | undefined) => StatusTarget {\n  const i18n = asI18n(manifest.config.i18n);\n  const fallback = statusTarget(manifest, status, i18n?.defaultLocale);\n  const byLocale = new Map(\n    (i18n?.locales ?? []).map((locale) => [\n      locale,\n      statusTarget(manifest, status, locale),\n    ]),\n  );\n  return (url) => {\n    const locale = url ? requestLocale(manifest, url) : undefined;\n    return (locale !== undefined && byLocale.get(locale)) || fallback;\n  };\n}\n\n/**\n * The locale a request's status page renders in, the way `next start` picks it:\n * the locale the URL's first segment names (case-insensitively, as\n * `normalizeLocalePath` matches it), and otherwise the domain's default locale,\n * then the app's. `undefined` without i18n.\n */\nfunction requestLocale(\n  manifest: AdapterManifest,\n  url: URL,\n): string | undefined {\n  const i18n = asI18n(manifest.config.i18n);\n  if (!i18n) return undefined;\n  const pathname = withoutPathPrefix(url.pathname, manifest.config.basePath);\n  const segment = (pathname.split(\"/\")[1] ?? \"\").toLowerCase();\n  return (\n    i18n.locales.find((candidate) => candidate.toLowerCase() === segment) ??\n    detectDomainLocale(i18n.domains, url.hostname)?.defaultLocale ??\n    i18n.defaultLocale\n  );\n}\n"]}