cdk-nextjs 0.6.2 → 0.7.1

package/lib/runtime/dispatch.test.js

@@ -0,0 +1,853 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable import/no-extraneous-dependencies */
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const dispatch_1 = require("./dispatch");
+const public_files_1 = require("./public-files");
+const app_playground_base_path_json_1 = __importDefault(require("../adapter/__fixtures__/app-playground-base-path.json"));
+const app_playground_json_1 = __importDefault(require("../adapter/__fixtures__/app-playground.json"));
+const pages_i18n_json_1 = __importDefault(require("../adapter/__fixtures__/pages-i18n.json"));
+const build_outputs_1 = require("../adapter/build-outputs");
+/**
+ * Dispatch is tested against the manifests that step 1 produces from real
+ * `onBuildComplete` captures, rather than against hand-written manifests: the
+ * thing most likely to break is the correspondence between how the build keys
+ * `entrypoints` and how `resolveRoutes` reports `resolvedPathname`, and a
+ * hand-written manifest would assume that correspondence instead of proving it.
+ */
+function manifestOf(fixture) {
+    const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
+    try {
+        const ctx = structuredClone(fixture);
+        // The fixtures' project dirs are synthetic `/repo/…` paths, so the build cwd
+        // has to be stated; see `assertBuildCwd`.
+        return (0, build_outputs_1.buildAdapterManifest)(ctx, { buildCwd: ctx.projectDir }).manifest;
+    }
+    finally {
+        warn.mockRestore();
+    }
+}
+/**
+ * The fixture with `app/params/optional/[[...rest]]` moved to `app/[[...rest]]`,
+ * a root optional catch-all: a route every request not claimed earlier falls
+ * into, `/_next/image` included unless dispatch puts it ahead of them. No example
+ * app has one, and a capture would add a whole app to cover one route, so the
+ * route is moved rather than captured.
+ */
+function withRootCatchAll(fixture) {
+    return JSON.parse(JSON.stringify(fixture)
+        .split("/params/optional/[[...rest]]")
+        .join("/[[...rest]]")
+        .split("[/]?/params/optional(?:")
+        .join("[/]?(?:"));
+}
+const manifests = {
+    "app-playground": manifestOf(app_playground_json_1.default),
+    "app-playground-base-path": manifestOf(app_playground_base_path_json_1.default),
+    "app-playground-root-catch-all": manifestOf(withRootCatchAll(app_playground_json_1.default)),
+    "app-playground-base-path-root-catch-all": manifestOf(withRootCatchAll(app_playground_base_path_json_1.default)),
+    "pages-i18n": manifestOf(pages_i18n_json_1.default),
+};
+const ORIGIN = "https://example.test";
+function request(url, headers = {}) {
+    const result = {
+        method: "GET",
+        url: new URL(url, ORIGIN),
+        headers: new Headers({ host: "example.test", ...headers }),
+        // GET/HEAD have no body, but `resolveRoutes` requires a stream.
+        body: new ReadableStream({
+            start(controller) {
+                controller.close();
+            },
+        }),
+        // Middleware that lets every request through.
+        invokeMiddleware: async () => ({ response: new Response() }),
+    };
+    return result;
+}
+/** A Dispatcher over `name`, whose middleware, if given, answers `middleware()`. */
+function dispatcherFor(name, middleware) {
+    const dispatcher = new dispatch_1.Dispatcher({ manifest: manifests[name] });
+    return {
+        notFoundFor: dispatcher.notFoundFor,
+        dispatch: (req) => dispatcher.dispatch(middleware
+            ? {
+                ...req,
+                invokeMiddleware: async () => ({
+                    ...(await middleware()),
+                    response: new Response(),
+                }),
+            }
+            : req),
+    };
+}
+/** The 404 or 500 a request with no locale gets. */
+function statusTargetOf(manifest, status) {
+    return (0, dispatch_1.statusTargets)(manifest, status)(undefined);
+}
+describe("Dispatcher entrypoint resolution", () => {
+    it("resolves a dynamic App Router page to its template entrypoint", async () => {
+        const result = await dispatcherFor("app-playground").dispatch(request("/isr/1"));
+        expect(result.kind).toBe("entrypoint");
+        if (result.kind !== "entrypoint")
+            return;
+        // `resolvedPathname` is the template; `invocationTarget` is concrete. Both
+        // are needed: the first picks the module, the second is what it renders.
+        expect(result.resolvedPathname).toBe("/isr/[id]");
+        expect(result.invocationTarget).toEqual({
+            pathname: "/isr/1",
+            query: { nxtPid: "1" },
+        });
+        expect(result.entrypoint.filePath).toContain("isr/[id]/page.js");
+        expect(result.entrypoint.type).toBe("app-page");
+    });
+    it("resolves an App Router route handler", async () => {
+        const result = await dispatcherFor("app-playground").dispatch(request("/api/health"));
+        expect(result.kind).toBe("entrypoint");
+        if (result.kind !== "entrypoint")
+            return;
+        expect(result.entrypoint.type).toBe("app-route");
+        expect(result.resolvedPathname).toBe("/api/health");
+    });
+    it("matches basePath-prefixed entrypoint keys without normalization", async () => {
+        // Step 1 keyed `entrypoints` by the basePath-prefixed `output.pathname` and
+        // left open whether `resolvedPathname` comes back prefixed. It does — this
+        // test is what closes that question.
+        const dispatcher = dispatcherFor("app-playground-base-path");
+        const result = await dispatcher.dispatch(request("/prod/isr/1"));
+        expect(result.kind).toBe("entrypoint");
+        if (result.kind !== "entrypoint")
+            return;
+        expect(result.resolvedPathname).toBe("/prod/isr/[id]");
+        expect(result.invocationTarget.pathname).toBe("/prod/isr/1");
+        // The same path without the prefix is not the app's.
+        const unprefixed = await dispatcher.dispatch(request("/isr/1"));
+        expect(unprefixed.kind).toBe("not-found");
+    });
+    it("resolves a Pages Router page and API route", async () => {
+        const dispatcher = dispatcherFor("pages-i18n");
+        const page = await dispatcher.dispatch(request("/en-US/ssr"));
+        expect(page.kind).toBe("entrypoint");
+        if (page.kind === "entrypoint") {
+            expect(page.entrypoint.type).toBe("page");
+        }
+        const api = await dispatcher.dispatch(request("/api/hello"));
+        expect(api.kind).toBe("entrypoint");
+        if (api.kind === "entrypoint") {
+            expect(api.entrypoint.type).toBe("page-api");
+        }
+    });
+    it("resolves a Pages Router ISR data URL via its prerender template", async () => {
+        // This only works because `buildAdapterManifest` adds dynamic *prerender*
+        // templates to `pathnames`/`entrypoints`: `/_next/data/…/[slug].json` is
+        // not a route output, so without it this URL 404s while `next start` serves
+        // it.
+        const { buildId } = manifests["pages-i18n"];
+        const result = await dispatcherFor("pages-i18n").dispatch(request(`/_next/data/${buildId}/fr/blog/hello.json`));
+        expect(result.kind).toBe("entrypoint");
+        if (result.kind !== "entrypoint")
+            return;
+        expect(result.resolvedPathname).toBe(`/_next/data/${buildId}/fr/blog/[slug].json`);
+        expect(result.entrypoint.filePath).toContain("blog/[slug]");
+        expect(result.invocationTarget.query).toMatchObject({ nxtPslug: "hello" });
+    });
+    it("resolves the canonical trailing-slash URL of a `trailingSlash` app", async () => {
+        // The build's pathnames never carry the slash, but `trailingSlash: true`
+        // makes `/a/` the URL Next.js's own 308 sends browsers to, and
+        // `@next/routing` matches pathnames by exact equality. Measured against
+        // next.js's `test/e2e/app-dir/trailingslash`: without this, 6 of 8 cases
+        // failed, including `fetch('/api/revalidate')` getting the 404 page.
+        const withSlash = structuredClone(app_playground_json_1.default);
+        withSlash.config.trailingSlash = true;
+        // All three captures are from apps with the default `trailingSlash: false`,
+        // so their `beforeMiddleware` carries the *strip*-slash 308 (`/a/` → `/a`).
+        // Leaving it in would make the clone incoherent — that redirect is what a
+        // real `trailingSlash: true` build replaces with the add-slash one — and it
+        // fires before any pathname is matched, so nothing below would be reached.
+        const routing = withSlash.routing;
+        routing.beforeMiddleware = routing.beforeMiddleware.filter((route) => route.status !== 308);
+        const dispatcher = new dispatch_1.Dispatcher({
+            manifest: manifestOf(withSlash),
+        });
+        const page = await dispatcher.dispatch(request("/isr/1/"));
+        expect(page.kind).toBe("entrypoint");
+        if (page.kind !== "entrypoint")
+            return;
+        // Normalized on the way out, because `entrypoints` is keyed without the
+        // slash and the render has to land on its prerender's cache key.
+        expect(page.resolvedPathname).toBe("/isr/[id]");
+        expect(page.invocationTarget).toEqual({
+            pathname: "/isr/1",
+            query: { nxtPid: "1" },
+        });
+        const route = await dispatcher.dispatch(request("/api/health/"));
+        expect(route.kind).toBe("entrypoint");
+        if (route.kind === "entrypoint") {
+            expect(route.resolvedPathname).toBe("/api/health");
+        }
+        // A static file keeps its extension-bearing pathname: Next.js compiles the
+        // *opposite* redirect for those, and shadowing it would serve `/x.js/`.
+        const asset = await dispatcher.dispatch(request("/favicon.ico"));
+        expect(asset.kind).toBe("static-file");
+        expect(await dispatcher.dispatch(request("/favicon.ico/"))).toMatchObject({
+            kind: "not-found",
+        });
+    });
+    it("gives a param whose name prefixes another param's its own value", async () => {
+        // `@next/routing` expands `$nxtPid2` by replacing group names in insertion
+        // order, so the `$nxtPid` prefix wins and leaves a literal `2`: the route is
+        // invoked with `nxtPid2=a2`. `repairRouteParamQuery` corrects it from
+        // `routeMatches`. Measured against `test/e2e/app-dir/use-params`, whose
+        // fixture is `app/[id]/[id2]/page.tsx`; app-playground's
+        // `app/params/prefix/[id]/[id2]` is the same shape.
+        const result = await dispatcherFor("app-playground").dispatch(request("/params/prefix/a/b"));
+        expect(result.kind).toBe("entrypoint");
+        if (result.kind !== "entrypoint")
+            return;
+        expect(result.resolvedPathname).toBe("/params/prefix/[id]/[id2]");
+        expect(result.invocationTarget).toEqual({
+            pathname: "/params/prefix/a/b",
+            query: { nxtPid: "a", nxtPid2: "b" },
+        });
+        expect(result.invocationTarget.query).toEqual({
+            nxtPid: "a",
+            nxtPid2: "b",
+        });
+    });
+    it("applies a gated beforeFiles rewrite from next.config.ts once", async () => {
+        // app-playground's one config rewrite: `/e2e/rewrite/:path(.*)` with
+        // `has: query json=true`, to `/e2e/rewrite/echo?from=/:path`. Its output
+        // matches it again, which is what Next.js re-applies inside the entrypoint
+        // - the Dispatcher's half is resolving it exactly once.
+        const dispatcher = dispatcherFor("app-playground");
+        const rewritten = await dispatcher.dispatch(request("/e2e/rewrite/some/route?json=true"));
+        expect(rewritten.kind).toBe("entrypoint");
+        if (rewritten.kind !== "entrypoint")
+            return;
+        expect(rewritten.resolvedPathname).toBe("/e2e/rewrite/echo");
+        expect(rewritten.invocationTarget.query).toMatchObject({
+            from: "/some/route",
+            json: "true",
+        });
+        // Without the `has` condition the rule does not fire and nothing else
+        // serves the path.
+        expect(await dispatcher.dispatch(request("/e2e/rewrite/some/route"))).toMatchObject({ kind: "not-found" });
+    });
+});
+describe("Dispatcher public/ files", () => {
+    /**
+     * A real `public/` on disk, listed by the same `readPublicFiles` the runtime
+     * calls at cold start, so the spellings under test are the ones the lister
+     * and the routing table actually produce between them.
+     */
+    function publicDir(files) {
+        const dir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "cdk-nextjs-dispatch-public-"));
+        for (const file of files) {
+            (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)((0, node_path_1.join)(dir, file)), { recursive: true });
+            (0, node_fs_1.writeFileSync)((0, node_path_1.join)(dir, file), file);
+        }
+        return (0, public_files_1.readPublicFiles)(dir);
+    }
+    function dispatcherWithPublic(name, files) {
+        return new dispatch_1.Dispatcher({
+            manifest: manifests[name],
+            publicFiles: publicDir(files),
+        });
+    }
+    it.each([
+        // A space is encoded by every client, so the two spellings agree.
+        ["static/hello e2e.png", ["/static/hello%20e2e.png"]],
+        // These a browser sends as written, and `encodeURIComponent` does not.
+        ["images/logo@2x.png", ["/images/logo@2x.png", "/images/logo%402x.png"]],
+        ["c++.svg", ["/c++.svg", "/c%2B%2B.svg"]],
+        ["icon[1].png", ["/icon[1].png", "/icon%5B1%5D.png"]],
+        ["Q&A.pdf", ["/Q&A.pdf", "/Q%26A.pdf"]],
+        // A literal `%` can only be requested escaped.
+        ["100%.png", ["/100%25.png"]],
+        ["фото/a.jpg", ["/%D1%84%D0%BE%D1%82%D0%BE/a.jpg"]],
+    ])("serves public/%s under every spelling a link can have", async (file, urls) => {
+        const dispatcher = dispatcherWithPublic("app-playground", [file]);
+        for (const url of urls) {
+            expect(await dispatcher.dispatch(request(url))).toMatchObject({
+                kind: "static-file",
+                source: "public",
+                filePath: `app-playground/public/${file}`,
+            });
+        }
+    });
+    it("serves public/ ahead of an app route at the same pathname", async () => {
+        // `app/favicon.ico` is a build output here; `next start` checks public/
+        // before app and page routes, so a leftover `public/favicon.ico` wins.
+        const result = await dispatcherWithPublic("app-playground", [
+            "favicon.ico",
+        ]).dispatch(request("/favicon.ico"));
+        expect(result).toMatchObject({
+            kind: "static-file",
+            filePath: "app-playground/public/favicon.ico",
+        });
+    });
+    it("still serves the build output when public/ has no file there", async () => {
+        const result = await dispatcherWithPublic("app-playground", []).dispatch(request("/favicon.ico"));
+        expect(result).toMatchObject({ kind: "static-file", source: "server" });
+    });
+    it("serves public/ under basePath", async () => {
+        const dispatcher = dispatcherWithPublic("app-playground-base-path", [
+            "test.txt",
+        ]);
+        expect(await dispatcher.dispatch(request("/prod/test.txt"))).toMatchObject({
+            kind: "static-file",
+            filePath: "app-playground/public/test.txt",
+        });
+        expect((await dispatcher.dispatch(request("/test.txt"))).kind).not.toBe("static-file");
+    });
+    it("serves public/ in an i18n app, bare and under a default locale only", async () => {
+        // `resolveRoutes` prefixes the locale before it matches, so `/test.txt` is
+        // looked up as `/en-US/test.txt`. `next start` strips the default locale,
+        // and each domain's, off a public/ request - `fr` is example.fr's - and no
+        // other.
+        const dispatcher = dispatcherWithPublic("pages-i18n", ["test.txt"]);
+        for (const url of ["/test.txt", "/en-US/test.txt", "/fr/test.txt"]) {
+            expect(await dispatcher.dispatch(request(url))).toMatchObject({
+                kind: "static-file",
+                filePath: "pages-i18n/public/test.txt",
+            });
+        }
+        expect((await dispatcher.dispatch(request("/nl-NL/test.txt"))).kind).not.toBe("static-file");
+    });
+    it("knows nothing of public/ when the deployment has none", async () => {
+        // The Lambda types: CloudFront or API Gateway answers public/ from S3, the
+        // package does not carry it, and a request that got through anyway takes
+        // the ordinary not-found path, middleware request headers and all.
+        expect(await dispatcherFor("app-playground").dispatch(request("/test.txt"))).toMatchObject({ kind: "not-found" });
+    });
+});
+describe("Dispatcher build-output spellings", () => {
+    it("serves a _next/static file whose name the HTML percent-encodes", async () => {
+        // webpack names an App Router chunk after its route segment, brackets and
+        // all, and Next.js reports the pathname unencoded; the `<script>` tag in
+        // the HTML asks for `%5Bid%5D`.
+        const base = manifests["app-playground"];
+        const pathname = "/_next/static/chunks/app/isr/[id]/page-0123abcd.js";
+        const filePath = "app-playground/.next/static/chunks/app/isr/[id]/page-0123abcd.js";
+        const manifest = {
+            ...base,
+            staticFiles: { ...base.staticFiles, [pathname]: filePath },
+            pathnames: [...base.pathnames, pathname],
+        };
+        const dispatcher = new dispatch_1.Dispatcher({
+            manifest,
+        });
+        for (const url of [
+            "/_next/static/chunks/app/isr/%5Bid%5D/page-0123abcd.js",
+            pathname,
+        ]) {
+            expect(await dispatcher.dispatch(request(url))).toMatchObject({
+                kind: "static-file",
+                source: "next-static",
+                filePath,
+            });
+        }
+    });
+});
+describe("Dispatcher non-entrypoint outcomes", () => {
+    it("serves a build asset as a static file with its immutable cache header", async () => {
+        const manifest = manifests["app-playground"];
+        const pathname = Object.keys(manifest.staticFiles).find((file) => file.startsWith("/_next/static/"));
+        const result = await dispatcherFor("app-playground").dispatch(request(pathname));
+        expect(result.kind).toBe("static-file");
+        if (result.kind !== "static-file")
+            return;
+        expect(result.pathname).toBe(pathname);
+        expect(result.responseHeaders.get("cache-control")).toBe("public,max-age=31536000,immutable");
+    });
+    it("routes /_next/image to the optimizer, basePath included", async () => {
+        const query = "?url=%2Ffoo.png&w=640&q=75";
+        const plain = await dispatcherFor("app-playground").dispatch(request(`/_next/image${query}`));
+        expect(plain.kind).toBe("image-optimization");
+        const prefixed = await dispatcherFor("app-playground-base-path").dispatch(request(`/prod/_next/image${query}`));
+        expect(prefixed.kind).toBe("image-optimization");
+        if (prefixed.kind !== "image-optimization")
+            return;
+        expect(prefixed.url.searchParams.get("url")).toBe("/foo.png");
+    });
+    it("routes /_next/image to the optimizer ahead of a root catch-all", async () => {
+        const query = "?url=%2Ffoo.png&w=640&q=75";
+        const catchAll = dispatcherFor("app-playground-root-catch-all");
+        const image = await catchAll.dispatch(request(`/_next/image${query}`));
+        expect(image.kind).toBe("image-optimization");
+        if (image.kind !== "image-optimization")
+            return;
+        expect(image.url.searchParams.get("url")).toBe("/foo.png");
+        // The catch-all itself still takes everything else.
+        const page = await catchAll.dispatch(request("/a/b"));
+        expect(page.kind).toBe("entrypoint");
+        if (page.kind !== "entrypoint")
+            return;
+        expect(page.resolvedPathname).toBe("/[[...rest]]");
+        const prefixedCatchAll = dispatcherFor("app-playground-base-path-root-catch-all");
+        const prefixed = await prefixedCatchAll.dispatch(request(`/prod/_next/image${query}`));
+        expect(prefixed.kind).toBe("image-optimization");
+        // Without which the image assertion would pass on a fixture with no
+        // catch-all at all.
+        const prefixedPage = await prefixedCatchAll.dispatch(request("/prod/a/b"));
+        expect(prefixedPage.kind).toBe("entrypoint");
+        if (prefixedPage.kind !== "entrypoint")
+            return;
+        expect(prefixedPage.resolvedPathname).toBe("/prod/[[...rest]]");
+    });
+    it("optimizes the destination of a next.config rewrite onto /_next/image", async () => {
+        const manifest = manifests["app-playground-root-catch-all"];
+        const routing = manifest.routing;
+        const result = await new dispatch_1.Dispatcher({
+            manifest: {
+                ...manifest,
+                routing: {
+                    ...routing,
+                    beforeFiles: [
+                        {
+                            source: "/avatar/:id",
+                            sourceRegex: "^\\/avatar(?:\\/([^\\/]+?))(?:\\/)?$",
+                            destination: "/_next/image?url=%2Favatars%2F$1.png&w=64&q=75",
+                        },
+                        ...routing.beforeFiles,
+                    ],
+                },
+            },
+        }).dispatch(request("/avatar/42"));
+        expect(result.kind).toBe("image-optimization");
+        if (result.kind !== "image-optimization")
+            return;
+        expect(result.url.pathname).toBe("/_next/image");
+        expect(result.url.searchParams.get("url")).toBe("/avatars/42.png");
+        expect(result.url.searchParams.get("w")).toBe("64");
+    });
+    it("redirects a trailing slash", async () => {
+        const result = await dispatcherFor("app-playground").dispatch(request("/isr/1/"));
+        expect(result).toMatchObject({
+            kind: "redirect",
+            status: 308,
+            location: "/isr/1",
+        });
+    });
+    it("serves the app's root in the default locale, with no redirect at all", async () => {
+        // `resolveRoutes` prefixes the locale as `${basePath}/${locale}${pathname}`,
+        // which turns the root into `/en-US/`, and the slash-stripping 308 every
+        // build compiles then answered `GET /` with a redirect no `next start`
+        // sends. Measured against `test/e2e/i18n-support-catchall`, whose `/` is a
+        // 200. See `Dispatcher.withRootLocale`.
+        const result = await dispatcherFor("pages-i18n").dispatch(request("/"));
+        expect(result).toMatchObject({ kind: "static-file", pathname: "/en-US" });
+    });
+    it("redirects the root to the locale the request asked for", async () => {
+        const result = await dispatcherFor("pages-i18n").dispatch(request("/", { "accept-language": "nl-NL" }));
+        // 307 and not 308, because the next request may detect a different locale.
+        // Relative and without the trailing slash `resolveRoutes` puts in the
+        // location it builds (`https://example.test/nl-NL/`), which is what
+        // `next start` sends and what a test asserting `headers.location` reads.
+        expect(result).toMatchObject({
+            kind: "redirect",
+            status: 307,
+            location: "/nl-NL",
+        });
+    });
+    it("keeps a redirect to another locale's domain absolute", async () => {
+        // The fixture maps `fr` onto example.fr, and an absolute location is the
+        // only way to leave the origin.
+        const result = await dispatcherFor("pages-i18n").dispatch(request("/", { cookie: "NEXT_LOCALE=fr" }));
+        expect(result).toMatchObject({
+            kind: "redirect",
+            status: 307,
+            location: "https://example.fr/",
+        });
+    });
+    it("serves the root of a `trailingSlash` i18n app with no redirect", async () => {
+        // With `trailingSlash: true`, `next build` compiles the slash-*adding* 308
+        // (`load-custom-routes`' `/:notfile(...)` → `/:notfile/`, `locale: false`)
+        // in place of the stripping one, and prefixing the root as `/en-US` made
+        // that rule answer `GET /` with a 308 to `/en-US/`, where `next start`
+        // answers 200.
+        const withSlash = structuredClone(pages_i18n_json_1.default);
+        withSlash.config.trailingSlash = true;
+        const routing = withSlash.routing;
+        routing.beforeMiddleware = [
+            {
+                source: "/:notfile((?!\\.well-known(?:/.*)?)(?:[^/]+/)*[^/\\.]+)",
+                sourceRegex: "^(?:\\/((?!\\.well-known(?:\\/.*)?)(?:[^\\/]+\\/)*[^\\/\\.]+))$",
+                headers: { Location: "/$1/" },
+                status: 308,
+                priority: true,
+            },
+            ...routing.beforeMiddleware.filter((route) => route.status !== 308),
+        ];
+        const dispatcher = new dispatch_1.Dispatcher({ manifest: manifestOf(withSlash) });
+        expect(await dispatcher.dispatch(request("/"))).toMatchObject({
+            kind: "static-file",
+            pathname: "/en-US",
+        });
+        // The rule itself is live: the slashless locale root still gets it.
+        expect(await dispatcher.dispatch(request("/en-US"))).toMatchObject({
+            kind: "redirect",
+            status: 308,
+            location: "/en-US/",
+        });
+    });
+    it("still strips a trailing slash the request itself carried", async () => {
+        const result = await dispatcherFor("pages-i18n").dispatch(request("/nl-NL/"));
+        expect(result).toMatchObject({
+            kind: "redirect",
+            status: 308,
+            location: "/nl-NL",
+        });
+    });
+    it("returns a direct response for a route that forces a status", async () => {
+        const base = manifests["app-playground"];
+        const manifest = {
+            ...base,
+            middleware: null,
+            routing: {
+                ...base.routing,
+                beforeFiles: [
+                    {
+                        sourceRegex: "^/blocked$",
+                        status: 403,
+                        headers: { "x-why": "no" },
+                    },
+                ],
+            },
+        };
+        const result = await new dispatch_1.Dispatcher({ manifest }).dispatch(request("/blocked"));
+        expect(result).toMatchObject({ kind: "response", status: 403 });
+        expect(result.responseHeaders.get("x-why")).toBe("no");
+    });
+    it("reports an unknown path as not found", async () => {
+        const result = await dispatcherFor("app-playground").dispatch(request("/definitely-not-a-route"));
+        expect(result.kind).toBe("not-found");
+        if (result.kind !== "not-found")
+            return;
+        expect(result.pathname).toBe("/definitely-not-a-route");
+    });
+    it("resolves the 404 target per router flavor", () => {
+        expect(statusTargetOf(manifests["app-playground"], 404)).toMatchObject({
+            kind: "entrypoint",
+            pathname: "/_not-found",
+        });
+        expect(statusTargetOf(manifests["app-playground-base-path"], 404)).toMatchObject({
+            kind: "entrypoint",
+            pathname: "/prod/_not-found",
+        });
+        // Pages Router has no `/_not-found`, and `next build` prerenders its 404 —
+        // one per locale — which `next start` serves ahead of `/_error`.
+        expect(statusTargetOf(manifests["pages-i18n"], 404)).toEqual({
+            kind: "static-file",
+            pathname: "/en-US/404",
+            filePath: manifests["pages-i18n"].staticFiles["/en-US/404"],
+        });
+    });
+    it("serves the prerendered 404 of the request's locale", () => {
+        // Every Pages build has `/_error`, so checking it first made the
+        // prerendered 404 — the app's `pages/404.js` — dead code; and under i18n
+        // the prerender is only ever keyed by locale, never as a bare `/404`.
+        const dispatcher = dispatcherFor("pages-i18n");
+        const { staticFiles } = manifests["pages-i18n"];
+        const at = (url) => dispatcher.notFoundFor(new URL(url, ORIGIN));
+        expect(at("/fr/nope")).toMatchObject({ filePath: staticFiles["/fr/404"] });
+        expect(at("/NL-nl/nope")).toMatchObject({
+            filePath: staticFiles["/nl-NL/404"],
+        });
+        expect(at("/nope")).toMatchObject({ filePath: staticFiles["/en-US/404"] });
+        // No locale in the path: the domain's default, as `next start` renders it.
+        expect(at("https://example.fr/nope")).toMatchObject({
+            filePath: staticFiles["/fr/404"],
+        });
+    });
+    it("falls back to /_error when no 404 was prerendered", () => {
+        // What a `pages/_app.js` with `getInitialProps` builds without a
+        // `pages/404.js`: `next build` then prerenders no 404 at all.
+        const base = manifests["pages-i18n"];
+        const without404 = Object.fromEntries(Object.entries(base.staticFiles).filter(([key]) => !key.endsWith("/404")));
+        expect(statusTargetOf({ ...base, staticFiles: without404 }, 404)).toMatchObject({ kind: "entrypoint", pathname: "/_error" });
+    });
+    it("prefers an invocable custom /404 over /_error", () => {
+        // What `pages/404.js` plus a `pages/_app.js` with `getInitialProps` builds:
+        // the 404 cannot be prerendered, so it arrives as an entrypoint beside
+        // `/_error`. Serving `/_error` there means the built-in "404: This page
+        // could not be found" replaces the app's own — `test/e2e/404-page-app`.
+        const base = manifests["pages-i18n"];
+        const withCustom404 = {
+            ...base,
+            entrypoints: {
+                ...base.entrypoints,
+                "/404": { ...base.entrypoints["/_error"], id: "/404" },
+            },
+        };
+        expect(statusTargetOf(withCustom404, 404)).toMatchObject({
+            kind: "entrypoint",
+            pathname: "/404",
+        });
+        // App Router still wins over both: `/_not-found` is what next looks for
+        // first, and an app with both routers has all three.
+        expect(statusTargetOf({
+            ...withCustom404,
+            entrypoints: {
+                ...withCustom404.entrypoints,
+                "/_not-found": {
+                    ...base.entrypoints["/_error"],
+                    id: "/_not-found",
+                },
+            },
+        }, 404)).toMatchObject({ kind: "entrypoint", pathname: "/_not-found" });
+    });
+    it("falls back to a prerendered 404, then to nothing", () => {
+        const base = manifests["app-playground"];
+        const withoutEntrypoints = {
+            ...base,
+            entrypoints: {},
+            middleware: null,
+        };
+        expect(statusTargetOf(withoutEntrypoints, 404)).toEqual({
+            kind: "static-file",
+            pathname: "/404",
+            filePath: base.staticFiles["/404"],
+        });
+        expect(statusTargetOf({ ...withoutEntrypoints, staticFiles: {} }, 404)).toEqual({ kind: "none" });
+    });
+});
+describe("the 500 ladder", () => {
+    it("prefers the prerendered /500 next emits by default", () => {
+        const base = manifests["app-playground"];
+        expect(statusTargetOf(base, 500)).toEqual({
+            kind: "static-file",
+            pathname: "/500",
+            filePath: base.staticFiles["/500"],
+        });
+    });
+    it("prefers an invocable /500 over the prerendered one", () => {
+        // What a `pages/500.js` that cannot be static-optimized builds.
+        const base = manifests["pages-i18n"];
+        expect(statusTargetOf({
+            ...base,
+            entrypoints: {
+                ...base.entrypoints,
+                "/500": { ...base.entrypoints["/_error"], id: "/500" },
+            },
+        }, 500)).toMatchObject({ kind: "entrypoint", pathname: "/500" });
+    });
+    it("falls back to /_error, then to nothing", () => {
+        // `/_error` is where a custom error page lands when it has
+        // `getInitialProps` — the case `test/e2e/async-modules` measures.
+        const base = manifests["pages-i18n"];
+        expect(statusTargetOf({ ...base, staticFiles: {} }, 500)).toMatchObject({
+            kind: "entrypoint",
+            pathname: "/_error",
+        });
+        expect(statusTargetOf({ ...base, staticFiles: {}, entrypoints: {} }, 500)).toEqual({ kind: "none" });
+    });
+    it("serves the prerendered 500 of the request's locale", () => {
+        // Under i18n the prerendered 500 is keyed only by locale, never as a bare
+        // `/500`, so looking up `/500` alone always fell through to `/_error`.
+        const base = manifests["pages-i18n"];
+        const errorTargetFor = (0, dispatch_1.statusTargets)(base, 500);
+        const at = (url) => errorTargetFor(new URL(url, ORIGIN));
+        expect(at("/fr/ssr")).toEqual({
+            kind: "static-file",
+            pathname: "/fr/500",
+            filePath: base.staticFiles["/fr/500"],
+        });
+        expect(at("/ssr")).toMatchObject({ pathname: "/en-US/500" });
+        // No locale in the path: the domain's default, as `next start` renders it.
+        expect(at("https://example.fr/ssr")).toMatchObject({
+            pathname: "/fr/500",
+        });
+        // A request whose URL could not be parsed gets the default locale's.
+        expect(errorTargetFor(undefined)).toMatchObject({
+            pathname: "/en-US/500",
+        });
+        expect(statusTargetOf(base, 500)).toMatchObject({ pathname: "/en-US/500" });
+    });
+    it("looks for the error page under the app's basePath", () => {
+        const base = manifests["app-playground-base-path"];
+        expect(statusTargetOf(base, 500)).toMatchObject({ pathname: "/prod/500" });
+    });
+});
+describe("toRedirect", () => {
+    it("prefers the documented redirect field", () => {
+        // `resolveRoutes` does not populate `ResolveRoutesResult.redirect` in
+        // next 16.3.5 — every redirect arrives as bare status + `location` — so this
+        // is the only coverage that branch can have until it does.
+        expect((0, dispatch_1.toRedirect)({ redirect: { url: new URL("https://e.test/x"), status: 301 } }, new Headers())).toEqual({ location: "https://e.test/x", status: 301 });
+    });
+    it("ignores a location header on a non-3xx status", () => {
+        const headers = new Headers({ location: "/x" });
+        expect((0, dispatch_1.toRedirect)({ status: 200 }, headers)).toBeUndefined();
+        expect((0, dispatch_1.toRedirect)({ status: 403 }, headers)).toBeUndefined();
+        expect((0, dispatch_1.toRedirect)({}, headers)).toBeUndefined();
+        expect((0, dispatch_1.toRedirect)({ status: 308 }, new Headers())).toBeUndefined();
+    });
+});
+describe("Dispatcher middleware handling", () => {
+    it("reports a middleware response without resolving a route", async () => {
+        const result = await dispatcherFor("app-playground", async () => ({
+            bodySent: true,
+            responseHeaders: new Headers({ "x-mw": "responded" }),
+        })).dispatch(request("/isr/1"));
+        expect(result.kind).toBe("middleware-responded");
+    });
+    it("sends next.config headers() with a response middleware wrote", async () => {
+        // `app-playground`'s `headers()` sets this on `/api/echo`; `next start`
+        // sends it with a middleware 401 there too.
+        const result = await dispatcherFor("app-playground", async () => ({
+            bodySent: true,
+        })).dispatch(request("/api/echo"));
+        expect(result.kind).toBe("middleware-responded");
+        expect(result.responseHeaders.get("x-e2e-config-header")).toBe("from-next-config");
+        const other = await dispatcherFor("app-playground", async () => ({
+            bodySent: true,
+        })).dispatch(request("/isr/1"));
+        expect(other.responseHeaders.has("x-e2e-config-header")).toBe(false);
+    });
+    it("normalizes a middleware redirect to a same-origin path", async () => {
+        const result = await dispatcherFor("app-playground", async () => ({
+            redirect: { url: new URL("/login", ORIGIN), status: 307 },
+        })).dispatch(request("/isr/1"));
+        expect(result).toMatchObject({
+            kind: "redirect",
+            status: 307,
+            // `NextResponse.redirect(new URL("/login", request.url))` is how every
+            // middleware spells this, and Next.js sends the path: `@next/routing`'s
+            // own `getRelativeURL` does it for the header it sets, and only the
+            // `redirect.url` field this path reads keeps the absolute form.
+            location: "/login",
+        });
+    });
+    it("follows an internal middleware rewrite to the rewritten entrypoint", async () => {
+        const result = await dispatcherFor("app-playground", async () => ({
+            rewrite: new URL("/api/health", ORIGIN),
+        })).dispatch(request("/isr/1"));
+        expect(result.kind).toBe("entrypoint");
+        if (result.kind !== "entrypoint")
+            return;
+        expect(result.resolvedPathname).toBe("/api/health");
+    });
+    it("routes /_next/image when middleware is what put the request on it", async () => {
+        // The API Gateway examples' middleware rewrites `/x` to `/<stage>/x` so the
+        // build's `basePath` lines up. `resolveRoutes` never reports the rewritten
+        // URL back, so optimizing the URL as received would lose the rewrite.
+        const query = "?url=%2Ffoo.png&w=640&q=75";
+        const result = await dispatcherFor("app-playground-base-path", async () => ({ rewrite: new URL(`/prod/_next/image${query}`, ORIGIN) })).dispatch(request(`/_next/image${query}`));
+        expect(result.kind).toBe("image-optimization");
+        if (result.kind !== "image-optimization")
+            return;
+        expect(result.url.searchParams.get("url")).toBe("/foo.png");
+    });
+    it("does not leak the internal rewrite header it consumed", async () => {
+        const result = await dispatcherFor("app-playground", async () => ({
+            rewrite: new URL("/api/health", ORIGIN),
+            responseHeaders: new Headers({ "x-middleware-rewrite": "/api/health" }),
+        })).dispatch(request("/isr/1"));
+        expect(result.responseHeaders.has("x-middleware-rewrite")).toBe(false);
+    });
+    it("reports an external middleware rewrite as a proxy target", async () => {
+        const result = await dispatcherFor("app-playground", async () => ({
+            rewrite: new URL("https://upstream.test/x"),
+        })).dispatch(request("/isr/1"));
+        expect(result.kind).toBe("external-rewrite");
+        if (result.kind !== "external-rewrite")
+            return;
+        expect(result.url.href).toBe("https://upstream.test/x");
+    });
+    it("carries middleware request headers forward and response headers back", async () => {
+        // `resolveRoutes` drops `MiddlewareResult.requestHeaders`: it neither
+        // returns them nor mutates the `headers` it was given. Dispatch captures
+        // them from the callback, which is what keeps
+        // `NextResponse.next({ request: { headers } })` working.
+        const result = await dispatcherFor("app-playground", async () => ({
+            requestHeaders: new Headers({ host: "example.test", "x-user": "42" }),
+            responseHeaders: new Headers({ "x-mw": "ran" }),
+        })).dispatch(request("/isr/1"));
+        expect(result.kind).toBe("entrypoint");
+        if (result.kind !== "entrypoint")
+            return;
+        expect(result.requestHeaders.get("x-user")).toBe("42");
+        expect(result.responseHeaders.get("x-mw")).toBe("ran");
+    });
+    it("passes the caller's request headers through when middleware adds none", async () => {
+        const result = await dispatcherFor("app-playground").dispatch(request("/isr/1", { "x-caller": "yes" }));
+        expect(result.kind).toBe("entrypoint");
+        if (result.kind !== "entrypoint")
+            return;
+        expect(result.requestHeaders.get("x-caller")).toBe("yes");
+    });
+});
+describe("repairRouteParamQuery", () => {
+    it("drops an optional catchall's param when the request filled none", () => {
+        // Measured from `resolveRoutes` for `/optional-catchall` against
+        // `app/optional-catchall/[[...params]]`: *both* sides carry the key with no
+        // value, which the `@next/routing` types do not admit. The key alone is what
+        // makes `prepare()` invent a param, so the key has to go.
+        expect((0, dispatch_1.repairRouteParamQuery)({ nxtPparams: undefined }, {
+            nxtPparams: undefined,
+        })).toEqual({});
+        // The same shape with "" for the value, which the expansion can also produce.
+        expect((0, dispatch_1.repairRouteParamQuery)({ nxtPparams: "" }, {})).toEqual({});
+        // A filled one is left alone, whichever source it came from.
+        expect((0, dispatch_1.repairRouteParamQuery)({ nxtPparams: "a/b" }, { nxtPparams: "a/b" })).toEqual({ nxtPparams: "a/b" });
+        // No route param can be legitimately empty - a required segment captures
+        // `[^/]+?`, a required catchall `.+?`, and an optional catchall that matched
+        // nothing has no group for `routeMatches` to report - so an empty value goes
+        // whether or not `routeMatches` echoes it.
+        expect((0, dispatch_1.repairRouteParamQuery)({ nxtPid: "" }, { nxtPid: "" })).toEqual({});
+        // Not a route param, so not ours to touch.
+        expect((0, dispatch_1.repairRouteParamQuery)({ q: "" }, {})).toEqual({ q: "" });
+    });
+    it("repairs and drops in one pass", () => {
+        // The prefix collision and the unset optional catchall in the same query:
+        // `nxtPid2` is wrong and `nxtPrest` was never requested.
+        expect((0, dispatch_1.repairRouteParamQuery)({ nxtPid: "a", nxtPid2: "a2", nxtPrest: "" }, { nxtPid: "a", nxtPid2: "b" })).toEqual({ nxtPid: "a", nxtPid2: "b" });
+    });
+});
+describe("outOfBandRouteParams", () => {
+    it("leaves a query the contract can carry alone", () => {
+        expect((0, dispatch_1.outOfBandRouteParams)({ nxtPrest: "a/b", q: "1" }, "/pages-cache/[...rest]")).toBeUndefined();
+        expect((0, dispatch_1.outOfBandRouteParams)({ nxtPid: "42" }, "/isr/[id]")).toBeUndefined();
+        // An encoded delimiter in something that is not a route param is not ours.
+        expect((0, dispatch_1.outOfBandRouteParams)({ q: "a%2Fb" }, "/pages-cache/[...rest]")).toBeUndefined();
+    });
+    it("restates a capture with an encoded delimiter as params, once decoded", () => {
+        // `test/e2e/incremental-cache-path-traversal`. Through the query contract
+        // this becomes three params and `normalizePagePath` throws on the pathname
+        // rebuilt from them; `next start` renders one param, which is this.
+        expect((0, dispatch_1.outOfBandRouteParams)({ nxtPrest: "..%2F..%2Fserver-reference-manifest" }, "/_next/data/BUILD_ID/pages-cache/[...rest].json")).toEqual({
+            params: { rest: ["../../server-reference-manifest"] },
+            query: {},
+        });
+    });
+    it("splits a repeat on real delimiters only, and keeps a single param whole", () => {
+        expect((0, dispatch_1.outOfBandRouteParams)({ nxtPrest: "a/b%2Fc/d" }, "/pages-cache/[[...rest]]")).toEqual({ params: { rest: ["a", "b/c", "d"] }, query: {} });
+        expect((0, dispatch_1.outOfBandRouteParams)({ nxtPid: "a%2Fb" }, "/isr/[id]")).toEqual({
+            params: { id: "a/b" },
+            query: {},
+        });
+    });
+    it("keeps everything that is not a route param in the query", () => {
+        expect((0, dispatch_1.outOfBandRouteParams)({ nxtPrest: "a%2Fb", from: "/x", page: "2" }, "/pages-cache/[...rest]")).toEqual({
+            params: { rest: ["a/b"] },
+            query: { from: "/x", page: "2" },
+        });
+    });
+    it("stays on the query contract when a param cannot be restated", () => {
+        // An optional catchall the request left unset. Half a param set is worse
+        // than none: `prepare` would interpolate a route with a missing segment.
+        expect((0, dispatch_1.outOfBandRouteParams)({ nxtPrest: "a%2Fb", nxtPoptional: "" }, "/pages-cache/[...rest]/[[...optional]]")).toBeUndefined();
+    });
+    it("tolerates a capture that is not valid percent-encoding", () => {
+        // `decodeQueryPathParameter` is a try/catch for the same reason: `%2F` makes
+        // this reachable while `%zz` makes `decodeURIComponent` throw.
+        expect((0, dispatch_1.outOfBandRouteParams)({ nxtPrest: "a%2F%zz" }, "/pages-cache/[...rest]")).toEqual({ params: { rest: ["a%2F%zz"] }, query: {} });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dispatch.test.js","sourceRoot":"","sources":["../../src/runtime/dispatch.test.ts"],"names":[],"mappings":";;;;;AAAA,sDAAsD;AACtD,qCAAgE;AAChE,qCAAiC;AACjC,yCAA0C;AAE1C,yCAOoB;AAEpB,iDAAiD;AACjD,0HAA0F;AAC1F,sGAAwE;AACxE,8FAAgE;AAChE,4DAGkC;AAElC;;;;;;GAMG;AACH,SAAS,UAAU,CAAC,OAAgB;IAClC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,kBAAkB,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;IACtE,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,eAAe,CAAC,OAAO,CAAyB,CAAC;QAC7D,6EAA6E;QAC7E,0CAA0C;QAC1C,OAAO,IAAA,oCAAoB,EAAC,GAAG,EAAE,EAAE,QAAQ,EAAE,GAAG,CAAC,UAAU,EAAE,CAAC,CAAC,QAAQ,CAAC;IAC1E,CAAC;YAAS,CAAC;QACT,IAAI,CAAC,WAAW,EAAE,CAAC;IACrB,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,SAAS,gBAAgB,CAAC,OAAgB;IACxC,OAAO,IAAI,CAAC,KAAK,CACf,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC;SACpB,KAAK,CAAC,8BAA8B,CAAC;SACrC,IAAI,CAAC,cAAc,CAAC;SACpB,KAAK,CAAC,yBAAyB,CAAC;SAChC,IAAI,CAAC,SAAS,CAAC,CACnB,CAAC;AACJ,CAAC;AAED,MAAM,SAAS,GAAG;IAChB,gBAAgB,EAAE,UAAU,CAAC,6BAAa,CAAC;IAC3C,0BAA0B,EAAE,UAAU,CAAC,uCAAqB,CAAC;IAC7D,+BAA+B,EAAE,UAAU,CAAC,gBAAgB,CAAC,6BAAa,CAAC,CAAC;IAC5E,yCAAyC,EAAE,UAAU,CACnD,gBAAgB,CAAC,uCAAqB,CAAC,CACxC;IACD,YAAY,EAAE,UAAU,CAAC,yBAAS,CAAC;CAC3B,CAAC;AAEX,MAAM,MAAM,GAAG,sBAAsB,CAAC;AAEtC,SAAS,OAAO,CAAC,GAAW,EAAE,UAAkC,EAAE;IAChE,MAAM,MAAM,GAAoB;QAC9B,MAAM,EAAE,KAAK;QACb,GAAG,EAAE,IAAI,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC;QACzB,OAAO,EAAE,IAAI,OAAO,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,GAAG,OAAO,EAAE,CAAC;QAC1D,gEAAgE;QAChE,IAAI,EAAE,IAAI,cAAc,CAAC;YACvB,KAAK,CAAC,UAAU;gBACd,UAAU,CAAC,KAAK,EAAE,CAAC;YACrB,CAAC;SACF,CAAC;QACF,8CAA8C;QAC9C,gBAAgB,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,QAAQ,EAAE,EAAE,CAAC;KAC7D,CAAC;IACF,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,oFAAoF;AACpF,SAAS,aAAa,CACpB,IAA4B,EAC5B,UAA4C;IAE5C,MAAM,UAAU,GAAG,IAAI,qBAAU,CAAC,EAAE,QAAQ,EAAE,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACjE,OAAO;QACL,WAAW,EAAE,UAAU,CAAC,WAAW;QACnC,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE,CAChB,UAAU,CAAC,QAAQ,CACjB,UAAU;YACR,CAAC,CAAC;gBACE,GAAG,GAAG;gBACN,gBAAgB,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC;oBAC7B,GAAG,CAAC,MAAM,UAAU,EAAE,CAAC;oBACvB,QAAQ,EAAE,IAAI,QAAQ,EAAE;iBACzB,CAAC;aACH;YACH,CAAC,CAAC,GAAG,CACR;KACJ,CAAC;AACJ,CAAC;AAED,oDAAoD;AACpD,SAAS,cAAc,CAAC,QAAyB,EAAE,MAAiB;IAClE,OAAO,IAAA,wBAAa,EAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,SAAS,CAAC,CAAC;AACpD,CAAC;AAED,QAAQ,CAAC,kCAAkC,EAAE,GAAG,EAAE;IAChD,EAAE,CAAC,+DAA+D,EAAE,KAAK,IAAI,EAAE;QAC7E,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,gBAAgB,CAAC,CAAC,QAAQ,CAC3D,OAAO,CAAC,QAAQ,CAAC,CAClB,CAAC;QACF,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACvC,IAAI,MAAM,CAAC,IAAI,KAAK,YAAY;YAAE,OAAO;QACzC,2EAA2E;QAC3E,yEAAyE;QACzE,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAClD,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,OAAO,CAAC;YACtC,QAAQ,EAAE,QAAQ;YAClB,KAAK,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE;SACvB,CAAC,CAAC;QACH,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,kBAAkB,CAAC,CAAC;QACjE,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAClD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,sCAAsC,EAAE,KAAK,IAAI,EAAE;QACpD,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,gBAAgB,CAAC,CAAC,QAAQ,CAC3D,OAAO,CAAC,aAAa,CAAC,CACvB,CAAC;QACF,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACvC,IAAI,MAAM,CAAC,IAAI,KAAK,YAAY;YAAE,OAAO;QACzC,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACjD,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACtD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,iEAAiE,EAAE,KAAK,IAAI,EAAE;QAC/E,4EAA4E;QAC5E,2EAA2E;QAC3E,qCAAqC;QACrC,MAAM,UAAU,GAAG,aAAa,CAAC,0BAA0B,CAAC,CAAC;QAC7D,MAAM,MAAM,GAAG,MAAM,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC;QACjE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACvC,IAAI,MAAM,CAAC,IAAI,KAAK,YAAY;YAAE,OAAO;QACzC,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;QACvD,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAE7D,qDAAqD;QACrD,MAAM,UAAU,GAAG,MAAM,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;QAChE,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAC5C,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,4CAA4C,EAAE,KAAK,IAAI,EAAE;QAC1D,MAAM,UAAU,GAAG,aAAa,CAAC,YAAY,CAAC,CAAC;QAC/C,MAAM,IAAI,GAAG,MAAM,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC;QAC9D,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACrC,IAAI,IAAI,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;YAC/B,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC5C,CAAC;QACD,MAAM,GAAG,GAAG,MAAM,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC;QAC7D,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACpC,IAAI,GAAG,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;YAC9B,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAC/C,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,iEAAiE,EAAE,KAAK,IAAI,EAAE;QAC/E,0EAA0E;QAC1E,yEAAyE;QACzE,4EAA4E;QAC5E,MAAM;QACN,MAAM,EAAE,OAAO,EAAE,GAAG,SAAS,CAAC,YAAY,CAAC,CAAC;QAC5C,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,YAAY,CAAC,CAAC,QAAQ,CACvD,OAAO,CAAC,eAAe,OAAO,qBAAqB,CAAC,CACrD,CAAC;QACF,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACvC,IAAI,MAAM,CAAC,IAAI,KAAK,YAAY;YAAE,OAAO;QACzC,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAClC,eAAe,OAAO,sBAAsB,CAC7C,CAAC;QACF,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;QAC5D,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,aAAa,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC;IAC7E,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,oEAAoE,EAAE,KAAK,IAAI,EAAE;QAClF,yEAAyE;QACzE,+DAA+D;QAC/D,wEAAwE;QACxE,yEAAyE;QACzE,qEAAqE;QACrE,MAAM,SAAS,GAAG,eAAe,CAC/B,6BAAwB,CACD,CAAC;QACzB,SAAS,CAAC,MAAqC,CAAC,aAAa,GAAG,IAAI,CAAC;QACtE,4EAA4E;QAC5E,4EAA4E;QAC5E,0EAA0E;QAC1E,4EAA4E;QAC5E,2EAA2E;QAC3E,MAAM,OAAO,GAAG,SAAS,CAAC,OAEzB,CAAC;QACF,OAAO,CAAC,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC,MAAM,CACxD,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,KAAK,GAAG,CAChC,CAAC;QACF,MAAM,UAAU,GAAG,IAAI,qBAAU,CAAC;YAChC,QAAQ,EAAE,UAAU,CAAC,SAAS,CAAC;SAChC,CAAC,CAAC;QAEH,MAAM,IAAI,GAAG,MAAM,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC;QAC3D,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACrC,IAAI,IAAI,CAAC,IAAI,KAAK,YAAY;YAAE,OAAO;QACvC,wEAAwE;QACxE,iEAAiE;QACjE,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAChD,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,OAAO,CAAC;YACpC,QAAQ,EAAE,QAAQ;YAClB,KAAK,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE;SACvB,CAAC,CAAC;QAEH,MAAM,KAAK,GAAG,MAAM,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC;QACjE,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACtC,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;YAChC,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QACrD,CAAC;QAED,2EAA2E;QAC3E,wEAAwE;QACxE,MAAM,KAAK,GAAG,MAAM,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC;QACjE,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QACvC,MAAM,CAAC,MAAM,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC;YACxE,IAAI,EAAE,WAAW;SAClB,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,iEAAiE,EAAE,KAAK,IAAI,EAAE;QAC/E,2EAA2E;QAC3E,6EAA6E;QAC7E,sEAAsE;QACtE,wEAAwE;QACxE,yDAAyD;QACzD,oDAAoD;QACpD,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,gBAAgB,CAAC,CAAC,QAAQ,CAC3D,OAAO,CAAC,oBAAoB,CAAC,CAC9B,CAAC;QACF,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACvC,IAAI,MAAM,CAAC,IAAI,KAAK,YAAY;YAAE,OAAO;QACzC,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,2BAA2B,CAAC,CAAC;QAClE,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,OAAO,CAAC;YACtC,QAAQ,EAAE,oBAAoB;YAC9B,KAAK,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE;SACrC,CAAC,CAAC;QACH,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC;YAC5C,MAAM,EAAE,GAAG;YACX,OAAO,EAAE,GAAG;SACb,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,8DAA8D,EAAE,KAAK,IAAI,EAAE;QAC5E,qEAAqE;QACrE,yEAAyE;QACzE,2EAA2E;QAC3E,wDAAwD;QACxD,MAAM,UAAU,GAAG,aAAa,CAAC,gBAAgB,CAAC,CAAC;QACnD,MAAM,SAAS,GAAG,MAAM,UAAU,CAAC,QAAQ,CACzC,OAAO,CAAC,mCAAmC,CAAC,CAC7C,CAAC;QACF,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAC1C,IAAI,SAAS,CAAC,IAAI,KAAK,YAAY;YAAE,OAAO;QAC5C,MAAM,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;QAC7D,MAAM,CAAC,SAAS,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,aAAa,CAAC;YACrD,IAAI,EAAE,aAAa;YACnB,IAAI,EAAE,MAAM;SACb,CAAC,CAAC;QAEH,sEAAsE;QACtE,mBAAmB;QACnB,MAAM,CACJ,MAAM,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,yBAAyB,CAAC,CAAC,CAC9D,CAAC,aAAa,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC;IACzC,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,0BAA0B,EAAE,GAAG,EAAE;IACxC;;;;OAIG;IACH,SAAS,SAAS,CAAC,KAAe;QAChC,MAAM,GAAG,GAAG,IAAA,qBAAW,EAAC,IAAA,gBAAI,EAAC,IAAA,gBAAM,GAAE,EAAE,6BAA6B,CAAC,CAAC,CAAC;QACvE,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,IAAA,mBAAS,EAAC,IAAA,mBAAO,EAAC,IAAA,gBAAI,EAAC,GAAG,EAAE,IAAI,CAAC,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;YACzD,IAAA,uBAAa,EAAC,IAAA,gBAAI,EAAC,GAAG,EAAE,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC;QACvC,CAAC;QACD,OAAO,IAAA,8BAAe,EAAC,GAAG,CAAC,CAAC;IAC9B,CAAC;IAED,SAAS,oBAAoB,CAC3B,IAA4B,EAC5B,KAAe;QAEf,OAAO,IAAI,qBAAU,CAAC;YACpB,QAAQ,EAAE,SAAS,CAAC,IAAI,CAAC;YACzB,WAAW,EAAE,SAAS,CAAC,KAAK,CAAC;SAC9B,CAAC,CAAC;IACL,CAAC;IAED,EAAE,CAAC,IAAI,CAAC;QACN,kEAAkE;QAClE,CAAC,sBAAsB,EAAE,CAAC,yBAAyB,CAAC,CAAC;QACrD,uEAAuE;QACvE,CAAC,oBAAoB,EAAE,CAAC,qBAAqB,EAAE,uBAAuB,CAAC,CAAC;QACxE,CAAC,SAAS,EAAE,CAAC,UAAU,EAAE,cAAc,CAAC,CAAC;QACzC,CAAC,aAAa,EAAE,CAAC,cAAc,EAAE,kBAAkB,CAAC,CAAC;QACrD,CAAC,SAAS,EAAE,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;QACvC,+CAA+C;QAC/C,CAAC,UAAU,EAAE,CAAC,aAAa,CAAC,CAAC;QAC7B,CAAC,YAAY,EAAE,CAAC,iCAAiC,CAAC,CAAC;KACpD,CAAC,CACA,uDAAuD,EACvD,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE;QACnB,MAAM,UAAU,GAAG,oBAAoB,CAAC,gBAAgB,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;QAClE,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;YACvB,MAAM,CAAC,MAAM,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC;gBAC5D,IAAI,EAAE,aAAa;gBACnB,MAAM,EAAE,QAAQ;gBAChB,QAAQ,EAAE,yBAAyB,IAAI,EAAE;aAC1C,CAAC,CAAC;QACL,CAAC;IACH,CAAC,CACF,CAAC;IAEF,EAAE,CAAC,2DAA2D,EAAE,KAAK,IAAI,EAAE;QACzE,wEAAwE;QACxE,uEAAuE;QACvE,MAAM,MAAM,GAAG,MAAM,oBAAoB,CAAC,gBAAgB,EAAE;YAC1D,aAAa;SACd,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC;QACrC,MAAM,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC;YAC3B,IAAI,EAAE,aAAa;YACnB,QAAQ,EAAE,mCAAmC;SAC9C,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,8DAA8D,EAAE,KAAK,IAAI,EAAE;QAC5E,MAAM,MAAM,GAAG,MAAM,oBAAoB,CAAC,gBAAgB,EAAE,EAAE,CAAC,CAAC,QAAQ,CACtE,OAAO,CAAC,cAAc,CAAC,CACxB,CAAC;QACF,MAAM,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;IAC1E,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,+BAA+B,EAAE,KAAK,IAAI,EAAE;QAC7C,MAAM,UAAU,GAAG,oBAAoB,CAAC,0BAA0B,EAAE;YAClE,UAAU;SACX,CAAC,CAAC;QACH,MAAM,CAAC,MAAM,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC;YACzE,IAAI,EAAE,aAAa;YACnB,QAAQ,EAAE,gCAAgC;SAC3C,CAAC,CAAC;QACH,MAAM,CAAC,CAAC,MAAM,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,CACrE,aAAa,CACd,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,qEAAqE,EAAE,KAAK,IAAI,EAAE;QACnF,2EAA2E;QAC3E,0EAA0E;QAC1E,2EAA2E;QAC3E,SAAS;QACT,MAAM,UAAU,GAAG,oBAAoB,CAAC,YAAY,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC;QACpE,KAAK,MAAM,GAAG,IAAI,CAAC,WAAW,EAAE,iBAAiB,EAAE,cAAc,CAAC,EAAE,CAAC;YACnE,MAAM,CAAC,MAAM,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC;gBAC5D,IAAI,EAAE,aAAa;gBACnB,QAAQ,EAAE,4BAA4B;aACvC,CAAC,CAAC;QACL,CAAC;QACD,MAAM,CACJ,CAAC,MAAM,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,IAAI,CAC7D,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IAC5B,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,uDAAuD,EAAE,KAAK,IAAI,EAAE;QACrE,2EAA2E;QAC3E,yEAAyE;QACzE,mEAAmE;QACnE,MAAM,CACJ,MAAM,aAAa,CAAC,gBAAgB,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CACrE,CAAC,aAAa,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC;IACzC,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,mCAAmC,EAAE,GAAG,EAAE;IACjD,EAAE,CAAC,gEAAgE,EAAE,KAAK,IAAI,EAAE;QAC9E,0EAA0E;QAC1E,yEAAyE;QACzE,gCAAgC;QAChC,MAAM,IAAI,GAAG,SAAS,CAAC,gBAAgB,CAAC,CAAC;QACzC,MAAM,QAAQ,GAAG,oDAAoD,CAAC;QACtE,MAAM,QAAQ,GACZ,kEAAkE,CAAC;QACrE,MAAM,QAAQ,GAAoB;YAChC,GAAG,IAAI;YACP,WAAW,EAAE,EAAE,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,EAAE,QAAQ,EAAE;YAC1D,SAAS,EAAE,CAAC,GAAG,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC;SACzC,CAAC;QACF,MAAM,UAAU,GAAG,IAAI,qBAAU,CAAC;YAChC,QAAQ;SACT,CAAC,CAAC;QACH,KAAK,MAAM,GAAG,IAAI;YAChB,wDAAwD;YACxD,QAAQ;SACT,EAAE,CAAC;YACF,MAAM,CAAC,MAAM,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC;gBAC5D,IAAI,EAAE,aAAa;gBACnB,MAAM,EAAE,aAAa;gBACrB,QAAQ;aACT,CAAC,CAAC;QACL,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,oCAAoC,EAAE,GAAG,EAAE;IAClD,EAAE,CAAC,uEAAuE,EAAE,KAAK,IAAI,EAAE;QACrF,MAAM,QAAQ,GAAG,SAAS,CAAC,gBAAgB,CAAC,CAAC;QAC7C,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAC/D,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,CACjC,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,gBAAgB,CAAC,CAAC,QAAQ,CAC3D,OAAO,CAAC,QAAQ,CAAC,CAClB,CAAC;QACF,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QACxC,IAAI,MAAM,CAAC,IAAI,KAAK,aAAa;YAAE,OAAO;QAC1C,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACvC,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,CACtD,mCAAmC,CACpC,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,yDAAyD,EAAE,KAAK,IAAI,EAAE;QACvE,MAAM,KAAK,GAAG,4BAA4B,CAAC;QAC3C,MAAM,KAAK,GAAG,MAAM,aAAa,CAAC,gBAAgB,CAAC,CAAC,QAAQ,CAC1D,OAAO,CAAC,eAAe,KAAK,EAAE,CAAC,CAChC,CAAC;QACF,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;QAE9C,MAAM,QAAQ,GAAG,MAAM,aAAa,CAAC,0BAA0B,CAAC,CAAC,QAAQ,CACvE,OAAO,CAAC,oBAAoB,KAAK,EAAE,CAAC,CACrC,CAAC;QACF,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;QACjD,IAAI,QAAQ,CAAC,IAAI,KAAK,oBAAoB;YAAE,OAAO;QACnD,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAChE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,gEAAgE,EAAE,KAAK,IAAI,EAAE;QAC9E,MAAM,KAAK,GAAG,4BAA4B,CAAC;QAC3C,MAAM,QAAQ,GAAG,aAAa,CAAC,+BAA+B,CAAC,CAAC;QAChE,MAAM,KAAK,GAAG,MAAM,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,eAAe,KAAK,EAAE,CAAC,CAAC,CAAC;QACvE,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;QAC9C,IAAI,KAAK,CAAC,IAAI,KAAK,oBAAoB;YAAE,OAAO;QAChD,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAE3D,oDAAoD;QACpD,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;QACtD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACrC,IAAI,IAAI,CAAC,IAAI,KAAK,YAAY;YAAE,OAAO;QACvC,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QAEnD,MAAM,gBAAgB,GAAG,aAAa,CACpC,yCAAyC,CAC1C,CAAC;QACF,MAAM,QAAQ,GAAG,MAAM,gBAAgB,CAAC,QAAQ,CAC9C,OAAO,CAAC,oBAAoB,KAAK,EAAE,CAAC,CACrC,CAAC;QACF,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;QACjD,oEAAoE;QACpE,oBAAoB;QACpB,MAAM,YAAY,GAAG,MAAM,gBAAgB,CAAC,QAAQ,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC;QAC3E,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAC7C,IAAI,YAAY,CAAC,IAAI,KAAK,YAAY;YAAE,OAAO;QAC/C,MAAM,CAAC,YAAY,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;IAClE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,sEAAsE,EAAE,KAAK,IAAI,EAAE;QACpF,MAAM,QAAQ,GAAG,SAAS,CAAC,+BAA+B,CAAC,CAAC;QAC5D,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAqC,CAAC;QAC/D,MAAM,MAAM,GAAG,MAAM,IAAI,qBAAU,CAAC;YAClC,QAAQ,EAAE;gBACR,GAAG,QAAQ;gBACX,OAAO,EAAE;oBACP,GAAG,OAAO;oBACV,WAAW,EAAE;wBACX;4BACE,MAAM,EAAE,aAAa;4BACrB,WAAW,EAAE,sCAAsC;4BACnD,WAAW,EAAE,gDAAgD;yBAC9D;wBACD,GAAG,OAAO,CAAC,WAAW;qBACvB;iBACF;aACF;SACF,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC;QACnC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;QAC/C,IAAI,MAAM,CAAC,IAAI,KAAK,oBAAoB;YAAE,OAAO;QACjD,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QACjD,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;QACnE,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACtD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,4BAA4B,EAAE,KAAK,IAAI,EAAE;QAC1C,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,gBAAgB,CAAC,CAAC,QAAQ,CAC3D,OAAO,CAAC,SAAS,CAAC,CACnB,CAAC;QACF,MAAM,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC;YAC3B,IAAI,EAAE,UAAU;YAChB,MAAM,EAAE,GAAG;YACX,QAAQ,EAAE,QAAQ;SACnB,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,sEAAsE,EAAE,KAAK,IAAI,EAAE;QACpF,6EAA6E;QAC7E,yEAAyE;QACzE,uEAAuE;QACvE,2EAA2E;QAC3E,wCAAwC;QACxC,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,YAAY,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;QACxE,MAAM,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,CAAC;IAC5E,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,wDAAwD,EAAE,KAAK,IAAI,EAAE;QACtE,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,YAAY,CAAC,CAAC,QAAQ,CACvD,OAAO,CAAC,GAAG,EAAE,EAAE,iBAAiB,EAAE,OAAO,EAAE,CAAC,CAC7C,CAAC;QACF,2EAA2E;QAC3E,sEAAsE;QACtE,oEAAoE;QACpE,yEAAyE;QACzE,MAAM,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC;YAC3B,IAAI,EAAE,UAAU;YAChB,MAAM,EAAE,GAAG;YACX,QAAQ,EAAE,QAAQ;SACnB,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,sDAAsD,EAAE,KAAK,IAAI,EAAE;QACpE,yEAAyE;QACzE,gCAAgC;QAChC,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,YAAY,CAAC,CAAC,QAAQ,CACvD,OAAO,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,gBAAgB,EAAE,CAAC,CAC3C,CAAC;QACF,MAAM,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC;YAC3B,IAAI,EAAE,UAAU;YAChB,MAAM,EAAE,GAAG;YACX,QAAQ,EAAE,qBAAqB;SAChC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,gEAAgE,EAAE,KAAK,IAAI,EAAE;QAC9E,2EAA2E;QAC3E,2EAA2E;QAC3E,yEAAyE;QACzE,uEAAuE;QACvE,eAAe;QACf,MAAM,SAAS,GAAG,eAAe,CAC/B,yBAAoB,CACG,CAAC;QACzB,SAAS,CAAC,MAAqC,CAAC,aAAa,GAAG,IAAI,CAAC;QACtE,MAAM,OAAO,GAAG,SAAS,CAAC,OAEzB,CAAC;QACF,OAAO,CAAC,gBAAgB,GAAG;YACzB;gBACE,MAAM,EAAE,yDAAyD;gBACjE,WAAW,EACT,iEAAiE;gBACnE,OAAO,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE;gBAC7B,MAAM,EAAE,GAAG;gBACX,QAAQ,EAAE,IAAI;aACf;YACD,GAAG,OAAO,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,KAAK,GAAG,CAAC;SACpE,CAAC;QACF,MAAM,UAAU,GAAG,IAAI,qBAAU,CAAC,EAAE,QAAQ,EAAE,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;QAEvE,MAAM,CAAC,MAAM,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC;YAC5D,IAAI,EAAE,aAAa;YACnB,QAAQ,EAAE,QAAQ;SACnB,CAAC,CAAC;QACH,oEAAoE;QACpE,MAAM,CAAC,MAAM,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC;YACjE,IAAI,EAAE,UAAU;YAChB,MAAM,EAAE,GAAG;YACX,QAAQ,EAAE,SAAS;SACpB,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,0DAA0D,EAAE,KAAK,IAAI,EAAE;QACxE,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,YAAY,CAAC,CAAC,QAAQ,CACvD,OAAO,CAAC,SAAS,CAAC,CACnB,CAAC;QACF,MAAM,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC;YAC3B,IAAI,EAAE,UAAU;YAChB,MAAM,EAAE,GAAG;YACX,QAAQ,EAAE,QAAQ;SACnB,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,4DAA4D,EAAE,KAAK,IAAI,EAAE;QAC1E,MAAM,IAAI,GAAG,SAAS,CAAC,gBAAgB,CAAC,CAAC;QACzC,MAAM,QAAQ,GAAoB;YAChC,GAAG,IAAI;YACP,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE;gBACP,GAAI,IAAI,CAAC,OAAmC;gBAC5C,WAAW,EAAE;oBACX;wBACE,WAAW,EAAE,YAAY;wBACzB,MAAM,EAAE,GAAG;wBACX,OAAO,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE;qBAC3B;iBACF;aACF;SACF,CAAC;QACF,MAAM,MAAM,GAAG,MAAM,IAAI,qBAAU,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,CACxD,OAAO,CAAC,UAAU,CAAC,CACpB,CAAC;QACF,MAAM,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC;QAChE,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACzD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,sCAAsC,EAAE,KAAK,IAAI,EAAE;QACpD,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,gBAAgB,CAAC,CAAC,QAAQ,CAC3D,OAAO,CAAC,yBAAyB,CAAC,CACnC,CAAC;QACF,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACtC,IAAI,MAAM,CAAC,IAAI,KAAK,WAAW;YAAE,OAAO;QACxC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,yBAAyB,CAAC,CAAC;IAC1D,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,2CAA2C,EAAE,GAAG,EAAE;QACnD,MAAM,CAAC,cAAc,CAAC,SAAS,CAAC,gBAAgB,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,aAAa,CAAC;YACrE,IAAI,EAAE,YAAY;YAClB,QAAQ,EAAE,aAAa;SACxB,CAAC,CAAC;QACH,MAAM,CACJ,cAAc,CAAC,SAAS,CAAC,0BAA0B,CAAC,EAAE,GAAG,CAAC,CAC3D,CAAC,aAAa,CAAC;YACd,IAAI,EAAE,YAAY;YAClB,QAAQ,EAAE,kBAAkB;SAC7B,CAAC,CAAC;QACH,2EAA2E;QAC3E,iEAAiE;QACjE,MAAM,CAAC,cAAc,CAAC,SAAS,CAAC,YAAY,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC;YAC3D,IAAI,EAAE,aAAa;YACnB,QAAQ,EAAE,YAAY;YACtB,QAAQ,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC,WAAW,CAAC,YAAY,CAAC;SAC5D,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,oDAAoD,EAAE,GAAG,EAAE;QAC5D,iEAAiE;QACjE,yEAAyE;QACzE,sEAAsE;QACtE,MAAM,UAAU,GAAG,aAAa,CAAC,YAAY,CAAC,CAAC;QAC/C,MAAM,EAAE,WAAW,EAAE,GAAG,SAAS,CAAC,YAAY,CAAC,CAAC;QAChD,MAAM,EAAE,GAAG,CAAC,GAAW,EAAE,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC,IAAI,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC;QAEzE,MAAM,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC,aAAa,CAAC,EAAE,QAAQ,EAAE,WAAW,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;QAC3E,MAAM,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC,CAAC,aAAa,CAAC;YACtC,QAAQ,EAAE,WAAW,CAAC,YAAY,CAAC;SACpC,CAAC,CAAC;QACH,MAAM,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,aAAa,CAAC,EAAE,QAAQ,EAAE,WAAW,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC;QAC3E,2EAA2E;QAC3E,MAAM,CAAC,EAAE,CAAC,yBAAyB,CAAC,CAAC,CAAC,aAAa,CAAC;YAClD,QAAQ,EAAE,WAAW,CAAC,SAAS,CAAC;SACjC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,mDAAmD,EAAE,GAAG,EAAE;QAC3D,iEAAiE;QACjE,8DAA8D;QAC9D,MAAM,IAAI,GAAG,SAAS,CAAC,YAAY,CAAC,CAAC;QACrC,MAAM,UAAU,GAAG,MAAM,CAAC,WAAW,CACnC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAC1E,CAAC;QACF,MAAM,CACJ,cAAc,CAAC,EAAE,GAAG,IAAI,EAAE,WAAW,EAAE,UAAU,EAAE,EAAE,GAAG,CAAC,CAC1D,CAAC,aAAa,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAC;IAC/D,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,+CAA+C,EAAE,GAAG,EAAE;QACvD,4EAA4E;QAC5E,uEAAuE;QACvE,wEAAwE;QACxE,wEAAwE;QACxE,MAAM,IAAI,GAAG,SAAS,CAAC,YAAY,CAAC,CAAC;QACrC,MAAM,aAAa,GAAoB;YACrC,GAAG,IAAI;YACP,WAAW,EAAE;gBACX,GAAG,IAAI,CAAC,WAAW;gBACnB,MAAM,EAAE,EAAE,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE;aACvD;SACF,CAAC;QACF,MAAM,CAAC,cAAc,CAAC,aAAa,EAAE,GAAG,CAAC,CAAC,CAAC,aAAa,CAAC;YACvD,IAAI,EAAE,YAAY;YAClB,QAAQ,EAAE,MAAM;SACjB,CAAC,CAAC;QACH,wEAAwE;QACxE,qDAAqD;QACrD,MAAM,CACJ,cAAc,CACZ;YACE,GAAG,aAAa;YAChB,WAAW,EAAE;gBACX,GAAG,aAAa,CAAC,WAAW;gBAC5B,aAAa,EAAE;oBACb,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;oBAC9B,EAAE,EAAE,aAAa;iBAClB;aACF;SACF,EACD,GAAG,CACJ,CACF,CAAC,aAAa,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,aAAa,EAAE,CAAC,CAAC;IACnE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,kDAAkD,EAAE,GAAG,EAAE;QAC1D,MAAM,IAAI,GAAG,SAAS,CAAC,gBAAgB,CAAC,CAAC;QACzC,MAAM,kBAAkB,GAAoB;YAC1C,GAAG,IAAI;YACP,WAAW,EAAE,EAAE;YACf,UAAU,EAAE,IAAI;SACjB,CAAC;QACF,MAAM,CAAC,cAAc,CAAC,kBAAkB,EAAE,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC;YACtD,IAAI,EAAE,aAAa;YACnB,QAAQ,EAAE,MAAM;YAChB,QAAQ,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC;SACnC,CAAC,CAAC;QACH,MAAM,CACJ,cAAc,CAAC,EAAE,GAAG,kBAAkB,EAAE,WAAW,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,CAChE,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC;IAC9B,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,gBAAgB,EAAE,GAAG,EAAE;IAC9B,EAAE,CAAC,oDAAoD,EAAE,GAAG,EAAE;QAC5D,MAAM,IAAI,GAAG,SAAS,CAAC,gBAAgB,CAAC,CAAC;QACzC,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC;YACxC,IAAI,EAAE,aAAa;YACnB,QAAQ,EAAE,MAAM;YAChB,QAAQ,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC;SACnC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,oDAAoD,EAAE,GAAG,EAAE;QAC5D,gEAAgE;QAChE,MAAM,IAAI,GAAG,SAAS,CAAC,YAAY,CAAC,CAAC;QACrC,MAAM,CACJ,cAAc,CACZ;YACE,GAAG,IAAI;YACP,WAAW,EAAE;gBACX,GAAG,IAAI,CAAC,WAAW;gBACnB,MAAM,EAAE,EAAE,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE;aACvD;SACF,EACD,GAAG,CACJ,CACF,CAAC,aAAa,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;IAC5D,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,wCAAwC,EAAE,GAAG,EAAE;QAChD,2DAA2D;QAC3D,kEAAkE;QAClE,MAAM,IAAI,GAAG,SAAS,CAAC,YAAY,CAAC,CAAC;QACrC,MAAM,CAAC,cAAc,CAAC,EAAE,GAAG,IAAI,EAAE,WAAW,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC,CAAC,aAAa,CAAC;YACtE,IAAI,EAAE,YAAY;YAClB,QAAQ,EAAE,SAAS;SACpB,CAAC,CAAC;QACH,MAAM,CACJ,cAAc,CAAC,EAAE,GAAG,IAAI,EAAE,WAAW,EAAE,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,CACnE,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC;IAC9B,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,oDAAoD,EAAE,GAAG,EAAE;QAC5D,0EAA0E;QAC1E,uEAAuE;QACvE,MAAM,IAAI,GAAG,SAAS,CAAC,YAAY,CAAC,CAAC;QACrC,MAAM,cAAc,GAAG,IAAA,wBAAa,EAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAChD,MAAM,EAAE,GAAG,CAAC,GAAW,EAAE,EAAE,CAAC,cAAc,CAAC,IAAI,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC;QAEjE,MAAM,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC;YAC5B,IAAI,EAAE,aAAa;YACnB,QAAQ,EAAE,SAAS;YACnB,QAAQ,EAAE,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;SACtC,CAAC,CAAC;QACH,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,aAAa,CAAC,EAAE,QAAQ,EAAE,YAAY,EAAE,CAAC,CAAC;QAC7D,2EAA2E;QAC3E,MAAM,CAAC,EAAE,CAAC,wBAAwB,CAAC,CAAC,CAAC,aAAa,CAAC;YACjD,QAAQ,EAAE,SAAS;SACpB,CAAC,CAAC;QACH,qEAAqE;QACrE,MAAM,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC,aAAa,CAAC;YAC9C,QAAQ,EAAE,YAAY;SACvB,CAAC,CAAC;QACH,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,aAAa,CAAC,EAAE,QAAQ,EAAE,YAAY,EAAE,CAAC,CAAC;IAC9E,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,mDAAmD,EAAE,GAAG,EAAE;QAC3D,MAAM,IAAI,GAAG,SAAS,CAAC,0BAA0B,CAAC,CAAC;QACnD,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,aAAa,CAAC,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAC,CAAC;IAC7E,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,YAAY,EAAE,GAAG,EAAE;IAC1B,EAAE,CAAC,uCAAuC,EAAE,GAAG,EAAE;QAC/C,sEAAsE;QACtE,6EAA6E;QAC7E,2DAA2D;QAC3D,MAAM,CACJ,IAAA,qBAAU,EACR,EAAE,QAAQ,EAAE,EAAE,GAAG,EAAE,IAAI,GAAG,CAAC,kBAAkB,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,EAC/D,IAAI,OAAO,EAAE,CACd,CACF,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC;IAC3D,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,+CAA+C,EAAE,GAAG,EAAE;QACvD,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;QAChD,MAAM,CAAC,IAAA,qBAAU,EAAC,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,OAAO,CAAC,CAAC,CAAC,aAAa,EAAE,CAAC;QAC7D,MAAM,CAAC,IAAA,qBAAU,EAAC,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,OAAO,CAAC,CAAC,CAAC,aAAa,EAAE,CAAC;QAC7D,MAAM,CAAC,IAAA,qBAAU,EAAC,EAAE,EAAE,OAAO,CAAC,CAAC,CAAC,aAAa,EAAE,CAAC;QAChD,MAAM,CAAC,IAAA,qBAAU,EAAC,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,IAAI,OAAO,EAAE,CAAC,CAAC,CAAC,aAAa,EAAE,CAAC;IACrE,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,gCAAgC,EAAE,GAAG,EAAE;IAC9C,EAAE,CAAC,yDAAyD,EAAE,KAAK,IAAI,EAAE;QACvE,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,gBAAgB,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC;YAChE,QAAQ,EAAE,IAAI;YACd,eAAe,EAAE,IAAI,OAAO,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;SACtD,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;QAChC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC;IACnD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,8DAA8D,EAAE,KAAK,IAAI,EAAE;QAC5E,wEAAwE;QACxE,4CAA4C;QAC5C,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,gBAAgB,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC;YAChE,QAAQ,EAAE,IAAI;SACf,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC;QACnC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC;QACjD,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC,CAAC,IAAI,CAC5D,kBAAkB,CACnB,CAAC;QAEF,MAAM,KAAK,GAAG,MAAM,aAAa,CAAC,gBAAgB,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC;YAC/D,QAAQ,EAAE,IAAI;SACf,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;QAChC,MAAM,CAAC,KAAK,CAAC,eAAe,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACvE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,wDAAwD,EAAE,KAAK,IAAI,EAAE;QACtE,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,gBAAgB,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC;YAChE,QAAQ,EAAE,EAAE,GAAG,EAAE,IAAI,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE;SAC1D,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;QAChC,MAAM,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC;YAC3B,IAAI,EAAE,UAAU;YAChB,MAAM,EAAE,GAAG;YACX,uEAAuE;YACvE,wEAAwE;YACxE,oEAAoE;YACpE,gEAAgE;YAChE,QAAQ,EAAE,QAAQ;SACnB,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,oEAAoE,EAAE,KAAK,IAAI,EAAE;QAClF,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,gBAAgB,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC;YAChE,OAAO,EAAE,IAAI,GAAG,CAAC,aAAa,EAAE,MAAM,CAAC;SACxC,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;QAChC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACvC,IAAI,MAAM,CAAC,IAAI,KAAK,YAAY;YAAE,OAAO;QACzC,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACtD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,mEAAmE,EAAE,KAAK,IAAI,EAAE;QACjF,4EAA4E;QAC5E,2EAA2E;QAC3E,sEAAsE;QACtE,MAAM,KAAK,GAAG,4BAA4B,CAAC;QAC3C,MAAM,MAAM,GAAG,MAAM,aAAa,CAChC,0BAA0B,EAC1B,KAAK,IAAI,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,GAAG,CAAC,oBAAoB,KAAK,EAAE,EAAE,MAAM,CAAC,EAAE,CAAC,CACxE,CAAC,QAAQ,CAAC,OAAO,CAAC,eAAe,KAAK,EAAE,CAAC,CAAC,CAAC;QAC5C,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;QAC/C,IAAI,MAAM,CAAC,IAAI,KAAK,oBAAoB;YAAE,OAAO;QACjD,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC9D,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,uDAAuD,EAAE,KAAK,IAAI,EAAE;QACrE,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,gBAAgB,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC;YAChE,OAAO,EAAE,IAAI,GAAG,CAAC,aAAa,EAAE,MAAM,CAAC;YACvC,eAAe,EAAE,IAAI,OAAO,CAAC,EAAE,sBAAsB,EAAE,aAAa,EAAE,CAAC;SACxE,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;QAChC,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,GAAG,CAAC,sBAAsB,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACzE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,0DAA0D,EAAE,KAAK,IAAI,EAAE;QACxE,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,gBAAgB,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC;YAChE,OAAO,EAAE,IAAI,GAAG,CAAC,yBAAyB,CAAC;SAC5C,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;QAChC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;QAC7C,IAAI,MAAM,CAAC,IAAI,KAAK,kBAAkB;YAAE,OAAO;QAC/C,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,yBAAyB,CAAC,CAAC;IAC1D,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,sEAAsE,EAAE,KAAK,IAAI,EAAE;QACpF,sEAAsE;QACtE,yEAAyE;QACzE,8CAA8C;QAC9C,yDAAyD;QACzD,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,gBAAgB,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC;YAChE,cAAc,EAAE,IAAI,OAAO,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;YACrE,eAAe,EAAE,IAAI,OAAO,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;SAChD,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;QAChC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACvC,IAAI,MAAM,CAAC,IAAI,KAAK,YAAY;YAAE,OAAO;QACzC,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACvD,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACzD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,uEAAuE,EAAE,KAAK,IAAI,EAAE;QACrF,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,gBAAgB,CAAC,CAAC,QAAQ,CAC3D,OAAO,CAAC,QAAQ,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CACzC,CAAC;QACF,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACvC,IAAI,MAAM,CAAC,IAAI,KAAK,YAAY;YAAE,OAAO;QACzC,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC5D,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,uBAAuB,EAAE,GAAG,EAAE;IACrC,EAAE,CAAC,iEAAiE,EAAE,GAAG,EAAE;QACzE,iEAAiE;QACjE,4EAA4E;QAC5E,6EAA6E;QAC7E,0DAA0D;QAC1D,MAAM,CACJ,IAAA,gCAAqB,EACnB,EAAE,UAAU,EAAE,SAAU,EAAE,EAC1B;YACE,UAAU,EAAE,SAAS;SACtB,CACF,CACF,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QACd,8EAA8E;QAC9E,MAAM,CAAC,IAAA,gCAAqB,EAAC,EAAE,UAAU,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QAClE,6DAA6D;QAC7D,MAAM,CACJ,IAAA,gCAAqB,EAAC,EAAE,UAAU,EAAE,KAAK,EAAE,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CACpE,CAAC,OAAO,CAAC,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC;QACjC,yEAAyE;QACzE,6EAA6E;QAC7E,6EAA6E;QAC7E,2CAA2C;QAC3C,MAAM,CAAC,IAAA,gCAAqB,EAAC,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QAC1E,2CAA2C;QAC3C,MAAM,CAAC,IAAA,gCAAqB,EAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;IAClE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,+BAA+B,EAAE,GAAG,EAAE;QACvC,0EAA0E;QAC1E,yDAAyD;QACzD,MAAM,CACJ,IAAA,gCAAqB,EACnB,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,EAC5C,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,CAC9B,CACF,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC;IAC3C,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,sBAAsB,EAAE,GAAG,EAAE;IACpC,EAAE,CAAC,6CAA6C,EAAE,GAAG,EAAE;QACrD,MAAM,CACJ,IAAA,+BAAoB,EAClB,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,EAC3B,wBAAwB,CACzB,CACF,CAAC,aAAa,EAAE,CAAC;QAClB,MAAM,CAAC,IAAA,+BAAoB,EAAC,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,WAAW,CAAC,CAAC,CAAC,aAAa,EAAE,CAAC;QAC5E,2EAA2E;QAC3E,MAAM,CACJ,IAAA,+BAAoB,EAAC,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,wBAAwB,CAAC,CAC/D,CAAC,aAAa,EAAE,CAAC;IACpB,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,sEAAsE,EAAE,GAAG,EAAE;QAC9E,0EAA0E;QAC1E,2EAA2E;QAC3E,oEAAoE;QACpE,MAAM,CACJ,IAAA,+BAAoB,EAClB,EAAE,QAAQ,EAAE,qCAAqC,EAAE,EACnD,iDAAiD,CAClD,CACF,CAAC,OAAO,CAAC;YACR,MAAM,EAAE,EAAE,IAAI,EAAE,CAAC,iCAAiC,CAAC,EAAE;YACrD,KAAK,EAAE,EAAE;SACV,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,yEAAyE,EAAE,GAAG,EAAE;QACjF,MAAM,CACJ,IAAA,+BAAoB,EAClB,EAAE,QAAQ,EAAE,WAAW,EAAE,EACzB,0BAA0B,CAC3B,CACF,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,CAAC,GAAG,EAAE,KAAK,EAAE,GAAG,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC;QAC9D,MAAM,CAAC,IAAA,+BAAoB,EAAC,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC;YACrE,MAAM,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE;YACrB,KAAK,EAAE,EAAE;SACV,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,yDAAyD,EAAE,GAAG,EAAE;QACjE,MAAM,CACJ,IAAA,+BAAoB,EAClB,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,EAC5C,wBAAwB,CACzB,CACF,CAAC,OAAO,CAAC;YACR,MAAM,EAAE,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,EAAE;YACzB,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE;SACjC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,6DAA6D,EAAE,GAAG,EAAE;QACrE,yEAAyE;QACzE,yEAAyE;QACzE,MAAM,CACJ,IAAA,+BAAoB,EAClB,EAAE,QAAQ,EAAE,OAAO,EAAE,YAAY,EAAE,EAAE,EAAE,EACvC,wCAAwC,CACzC,CACF,CAAC,aAAa,EAAE,CAAC;IACpB,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,wDAAwD,EAAE,GAAG,EAAE;QAChE,6EAA6E;QAC7E,+DAA+D;QAC/D,MAAM,CACJ,IAAA,+BAAoB,EAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,EAAE,wBAAwB,CAAC,CACxE,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,CAAC,SAAS,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC;IAC1D,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\nimport { mkdirSync, mkdtempSync, writeFileSync } from \"node:fs\";\nimport { tmpdir } from \"node:os\";\nimport { dirname, join } from \"node:path\";\nimport { MiddlewareResult } from \"@next/routing\";\nimport {\n  DispatchRequest,\n  Dispatcher,\n  outOfBandRouteParams,\n  repairRouteParamQuery,\n  statusTargets,\n  toRedirect,\n} from \"./dispatch\";\nimport { AdapterManifest } from \"./manifest\";\nimport { readPublicFiles } from \"./public-files\";\nimport appPlaygroundBasePath from \"../adapter/__fixtures__/app-playground-base-path.json\";\nimport appPlayground from \"../adapter/__fixtures__/app-playground.json\";\nimport pagesI18n from \"../adapter/__fixtures__/pages-i18n.json\";\nimport {\n  BuildCompleteContext,\n  buildAdapterManifest,\n} from \"../adapter/build-outputs\";\n\n/**\n * Dispatch is tested against the manifests that step 1 produces from real\n * `onBuildComplete` captures, rather than against hand-written manifests: the\n * thing most likely to break is the correspondence between how the build keys\n * `entrypoints` and how `resolveRoutes` reports `resolvedPathname`, and a\n * hand-written manifest would assume that correspondence instead of proving it.\n */\nfunction manifestOf(fixture: unknown): AdapterManifest {\n  const warn = jest.spyOn(console, \"warn\").mockImplementation(() => {});\n  try {\n    const ctx = structuredClone(fixture) as BuildCompleteContext;\n    // The fixtures' project dirs are synthetic `/repo/…` paths, so the build cwd\n    // has to be stated; see `assertBuildCwd`.\n    return buildAdapterManifest(ctx, { buildCwd: ctx.projectDir }).manifest;\n  } finally {\n    warn.mockRestore();\n  }\n}\n\n/**\n * The fixture with `app/params/optional/[[...rest]]` moved to `app/[[...rest]]`,\n * a root optional catch-all: a route every request not claimed earlier falls\n * into, `/_next/image` included unless dispatch puts it ahead of them. No example\n * app has one, and a capture would add a whole app to cover one route, so the\n * route is moved rather than captured.\n */\nfunction withRootCatchAll(fixture: unknown): unknown {\n  return JSON.parse(\n    JSON.stringify(fixture)\n      .split(\"/params/optional/[[...rest]]\")\n      .join(\"/[[...rest]]\")\n      .split(\"[/]?/params/optional(?:\")\n      .join(\"[/]?(?:\"),\n  );\n}\n\nconst manifests = {\n  \"app-playground\": manifestOf(appPlayground),\n  \"app-playground-base-path\": manifestOf(appPlaygroundBasePath),\n  \"app-playground-root-catch-all\": manifestOf(withRootCatchAll(appPlayground)),\n  \"app-playground-base-path-root-catch-all\": manifestOf(\n    withRootCatchAll(appPlaygroundBasePath),\n  ),\n  \"pages-i18n\": manifestOf(pagesI18n),\n} as const;\n\nconst ORIGIN = \"https://example.test\";\n\nfunction request(url: string, headers: Record<string, string> = {}) {\n  const result: DispatchRequest = {\n    method: \"GET\",\n    url: new URL(url, ORIGIN),\n    headers: new Headers({ host: \"example.test\", ...headers }),\n    // GET/HEAD have no body, but `resolveRoutes` requires a stream.\n    body: new ReadableStream({\n      start(controller) {\n        controller.close();\n      },\n    }),\n    // Middleware that lets every request through.\n    invokeMiddleware: async () => ({ response: new Response() }),\n  };\n  return result;\n}\n\n/** A Dispatcher over `name`, whose middleware, if given, answers `middleware()`. */\nfunction dispatcherFor(\n  name: keyof typeof manifests,\n  middleware?: () => Promise<MiddlewareResult>,\n): Pick<Dispatcher, \"dispatch\" | \"notFoundFor\"> {\n  const dispatcher = new Dispatcher({ manifest: manifests[name] });\n  return {\n    notFoundFor: dispatcher.notFoundFor,\n    dispatch: (req) =>\n      dispatcher.dispatch(\n        middleware\n          ? {\n              ...req,\n              invokeMiddleware: async () => ({\n                ...(await middleware()),\n                response: new Response(),\n              }),\n            }\n          : req,\n      ),\n  };\n}\n\n/** The 404 or 500 a request with no locale gets. */\nfunction statusTargetOf(manifest: AdapterManifest, status: 404 | 500) {\n  return statusTargets(manifest, status)(undefined);\n}\n\ndescribe(\"Dispatcher entrypoint resolution\", () => {\n  it(\"resolves a dynamic App Router page to its template entrypoint\", async () => {\n    const result = await dispatcherFor(\"app-playground\").dispatch(\n      request(\"/isr/1\"),\n    );\n    expect(result.kind).toBe(\"entrypoint\");\n    if (result.kind !== \"entrypoint\") return;\n    // `resolvedPathname` is the template; `invocationTarget` is concrete. Both\n    // are needed: the first picks the module, the second is what it renders.\n    expect(result.resolvedPathname).toBe(\"/isr/[id]\");\n    expect(result.invocationTarget).toEqual({\n      pathname: \"/isr/1\",\n      query: { nxtPid: \"1\" },\n    });\n    expect(result.entrypoint.filePath).toContain(\"isr/[id]/page.js\");\n    expect(result.entrypoint.type).toBe(\"app-page\");\n  });\n\n  it(\"resolves an App Router route handler\", async () => {\n    const result = await dispatcherFor(\"app-playground\").dispatch(\n      request(\"/api/health\"),\n    );\n    expect(result.kind).toBe(\"entrypoint\");\n    if (result.kind !== \"entrypoint\") return;\n    expect(result.entrypoint.type).toBe(\"app-route\");\n    expect(result.resolvedPathname).toBe(\"/api/health\");\n  });\n\n  it(\"matches basePath-prefixed entrypoint keys without normalization\", async () => {\n    // Step 1 keyed `entrypoints` by the basePath-prefixed `output.pathname` and\n    // left open whether `resolvedPathname` comes back prefixed. It does — this\n    // test is what closes that question.\n    const dispatcher = dispatcherFor(\"app-playground-base-path\");\n    const result = await dispatcher.dispatch(request(\"/prod/isr/1\"));\n    expect(result.kind).toBe(\"entrypoint\");\n    if (result.kind !== \"entrypoint\") return;\n    expect(result.resolvedPathname).toBe(\"/prod/isr/[id]\");\n    expect(result.invocationTarget.pathname).toBe(\"/prod/isr/1\");\n\n    // The same path without the prefix is not the app's.\n    const unprefixed = await dispatcher.dispatch(request(\"/isr/1\"));\n    expect(unprefixed.kind).toBe(\"not-found\");\n  });\n\n  it(\"resolves a Pages Router page and API route\", async () => {\n    const dispatcher = dispatcherFor(\"pages-i18n\");\n    const page = await dispatcher.dispatch(request(\"/en-US/ssr\"));\n    expect(page.kind).toBe(\"entrypoint\");\n    if (page.kind === \"entrypoint\") {\n      expect(page.entrypoint.type).toBe(\"page\");\n    }\n    const api = await dispatcher.dispatch(request(\"/api/hello\"));\n    expect(api.kind).toBe(\"entrypoint\");\n    if (api.kind === \"entrypoint\") {\n      expect(api.entrypoint.type).toBe(\"page-api\");\n    }\n  });\n\n  it(\"resolves a Pages Router ISR data URL via its prerender template\", async () => {\n    // This only works because `buildAdapterManifest` adds dynamic *prerender*\n    // templates to `pathnames`/`entrypoints`: `/_next/data/…/[slug].json` is\n    // not a route output, so without it this URL 404s while `next start` serves\n    // it.\n    const { buildId } = manifests[\"pages-i18n\"];\n    const result = await dispatcherFor(\"pages-i18n\").dispatch(\n      request(`/_next/data/${buildId}/fr/blog/hello.json`),\n    );\n    expect(result.kind).toBe(\"entrypoint\");\n    if (result.kind !== \"entrypoint\") return;\n    expect(result.resolvedPathname).toBe(\n      `/_next/data/${buildId}/fr/blog/[slug].json`,\n    );\n    expect(result.entrypoint.filePath).toContain(\"blog/[slug]\");\n    expect(result.invocationTarget.query).toMatchObject({ nxtPslug: \"hello\" });\n  });\n\n  it(\"resolves the canonical trailing-slash URL of a `trailingSlash` app\", async () => {\n    // The build's pathnames never carry the slash, but `trailingSlash: true`\n    // makes `/a/` the URL Next.js's own 308 sends browsers to, and\n    // `@next/routing` matches pathnames by exact equality. Measured against\n    // next.js's `test/e2e/app-dir/trailingslash`: without this, 6 of 8 cases\n    // failed, including `fetch('/api/revalidate')` getting the 404 page.\n    const withSlash = structuredClone(\n      appPlayground as unknown,\n    ) as BuildCompleteContext;\n    (withSlash.config as { trailingSlash: boolean }).trailingSlash = true;\n    // All three captures are from apps with the default `trailingSlash: false`,\n    // so their `beforeMiddleware` carries the *strip*-slash 308 (`/a/` → `/a`).\n    // Leaving it in would make the clone incoherent — that redirect is what a\n    // real `trailingSlash: true` build replaces with the add-slash one — and it\n    // fires before any pathname is matched, so nothing below would be reached.\n    const routing = withSlash.routing as {\n      beforeMiddleware: { status?: number }[];\n    };\n    routing.beforeMiddleware = routing.beforeMiddleware.filter(\n      (route) => route.status !== 308,\n    );\n    const dispatcher = new Dispatcher({\n      manifest: manifestOf(withSlash),\n    });\n\n    const page = await dispatcher.dispatch(request(\"/isr/1/\"));\n    expect(page.kind).toBe(\"entrypoint\");\n    if (page.kind !== \"entrypoint\") return;\n    // Normalized on the way out, because `entrypoints` is keyed without the\n    // slash and the render has to land on its prerender's cache key.\n    expect(page.resolvedPathname).toBe(\"/isr/[id]\");\n    expect(page.invocationTarget).toEqual({\n      pathname: \"/isr/1\",\n      query: { nxtPid: \"1\" },\n    });\n\n    const route = await dispatcher.dispatch(request(\"/api/health/\"));\n    expect(route.kind).toBe(\"entrypoint\");\n    if (route.kind === \"entrypoint\") {\n      expect(route.resolvedPathname).toBe(\"/api/health\");\n    }\n\n    // A static file keeps its extension-bearing pathname: Next.js compiles the\n    // *opposite* redirect for those, and shadowing it would serve `/x.js/`.\n    const asset = await dispatcher.dispatch(request(\"/favicon.ico\"));\n    expect(asset.kind).toBe(\"static-file\");\n    expect(await dispatcher.dispatch(request(\"/favicon.ico/\"))).toMatchObject({\n      kind: \"not-found\",\n    });\n  });\n\n  it(\"gives a param whose name prefixes another param's its own value\", async () => {\n    // `@next/routing` expands `$nxtPid2` by replacing group names in insertion\n    // order, so the `$nxtPid` prefix wins and leaves a literal `2`: the route is\n    // invoked with `nxtPid2=a2`. `repairRouteParamQuery` corrects it from\n    // `routeMatches`. Measured against `test/e2e/app-dir/use-params`, whose\n    // fixture is `app/[id]/[id2]/page.tsx`; app-playground's\n    // `app/params/prefix/[id]/[id2]` is the same shape.\n    const result = await dispatcherFor(\"app-playground\").dispatch(\n      request(\"/params/prefix/a/b\"),\n    );\n    expect(result.kind).toBe(\"entrypoint\");\n    if (result.kind !== \"entrypoint\") return;\n    expect(result.resolvedPathname).toBe(\"/params/prefix/[id]/[id2]\");\n    expect(result.invocationTarget).toEqual({\n      pathname: \"/params/prefix/a/b\",\n      query: { nxtPid: \"a\", nxtPid2: \"b\" },\n    });\n    expect(result.invocationTarget.query).toEqual({\n      nxtPid: \"a\",\n      nxtPid2: \"b\",\n    });\n  });\n\n  it(\"applies a gated beforeFiles rewrite from next.config.ts once\", async () => {\n    // app-playground's one config rewrite: `/e2e/rewrite/:path(.*)` with\n    // `has: query json=true`, to `/e2e/rewrite/echo?from=/:path`. Its output\n    // matches it again, which is what Next.js re-applies inside the entrypoint\n    // - the Dispatcher's half is resolving it exactly once.\n    const dispatcher = dispatcherFor(\"app-playground\");\n    const rewritten = await dispatcher.dispatch(\n      request(\"/e2e/rewrite/some/route?json=true\"),\n    );\n    expect(rewritten.kind).toBe(\"entrypoint\");\n    if (rewritten.kind !== \"entrypoint\") return;\n    expect(rewritten.resolvedPathname).toBe(\"/e2e/rewrite/echo\");\n    expect(rewritten.invocationTarget.query).toMatchObject({\n      from: \"/some/route\",\n      json: \"true\",\n    });\n\n    // Without the `has` condition the rule does not fire and nothing else\n    // serves the path.\n    expect(\n      await dispatcher.dispatch(request(\"/e2e/rewrite/some/route\")),\n    ).toMatchObject({ kind: \"not-found\" });\n  });\n});\n\ndescribe(\"Dispatcher public/ files\", () => {\n  /**\n   * A real `public/` on disk, listed by the same `readPublicFiles` the runtime\n   * calls at cold start, so the spellings under test are the ones the lister\n   * and the routing table actually produce between them.\n   */\n  function publicDir(files: string[]): readonly string[] {\n    const dir = mkdtempSync(join(tmpdir(), \"cdk-nextjs-dispatch-public-\"));\n    for (const file of files) {\n      mkdirSync(dirname(join(dir, file)), { recursive: true });\n      writeFileSync(join(dir, file), file);\n    }\n    return readPublicFiles(dir);\n  }\n\n  function dispatcherWithPublic(\n    name: keyof typeof manifests,\n    files: string[],\n  ): Dispatcher {\n    return new Dispatcher({\n      manifest: manifests[name],\n      publicFiles: publicDir(files),\n    });\n  }\n\n  it.each([\n    // A space is encoded by every client, so the two spellings agree.\n    [\"static/hello e2e.png\", [\"/static/hello%20e2e.png\"]],\n    // These a browser sends as written, and `encodeURIComponent` does not.\n    [\"images/logo@2x.png\", [\"/images/logo@2x.png\", \"/images/logo%402x.png\"]],\n    [\"c++.svg\", [\"/c++.svg\", \"/c%2B%2B.svg\"]],\n    [\"icon[1].png\", [\"/icon[1].png\", \"/icon%5B1%5D.png\"]],\n    [\"Q&A.pdf\", [\"/Q&A.pdf\", \"/Q%26A.pdf\"]],\n    // A literal `%` can only be requested escaped.\n    [\"100%.png\", [\"/100%25.png\"]],\n    [\"фото/a.jpg\", [\"/%D1%84%D0%BE%D1%82%D0%BE/a.jpg\"]],\n  ])(\n    \"serves public/%s under every spelling a link can have\",\n    async (file, urls) => {\n      const dispatcher = dispatcherWithPublic(\"app-playground\", [file]);\n      for (const url of urls) {\n        expect(await dispatcher.dispatch(request(url))).toMatchObject({\n          kind: \"static-file\",\n          source: \"public\",\n          filePath: `app-playground/public/${file}`,\n        });\n      }\n    },\n  );\n\n  it(\"serves public/ ahead of an app route at the same pathname\", async () => {\n    // `app/favicon.ico` is a build output here; `next start` checks public/\n    // before app and page routes, so a leftover `public/favicon.ico` wins.\n    const result = await dispatcherWithPublic(\"app-playground\", [\n      \"favicon.ico\",\n    ]).dispatch(request(\"/favicon.ico\"));\n    expect(result).toMatchObject({\n      kind: \"static-file\",\n      filePath: \"app-playground/public/favicon.ico\",\n    });\n  });\n\n  it(\"still serves the build output when public/ has no file there\", async () => {\n    const result = await dispatcherWithPublic(\"app-playground\", []).dispatch(\n      request(\"/favicon.ico\"),\n    );\n    expect(result).toMatchObject({ kind: \"static-file\", source: \"server\" });\n  });\n\n  it(\"serves public/ under basePath\", async () => {\n    const dispatcher = dispatcherWithPublic(\"app-playground-base-path\", [\n      \"test.txt\",\n    ]);\n    expect(await dispatcher.dispatch(request(\"/prod/test.txt\"))).toMatchObject({\n      kind: \"static-file\",\n      filePath: \"app-playground/public/test.txt\",\n    });\n    expect((await dispatcher.dispatch(request(\"/test.txt\"))).kind).not.toBe(\n      \"static-file\",\n    );\n  });\n\n  it(\"serves public/ in an i18n app, bare and under a default locale only\", async () => {\n    // `resolveRoutes` prefixes the locale before it matches, so `/test.txt` is\n    // looked up as `/en-US/test.txt`. `next start` strips the default locale,\n    // and each domain's, off a public/ request - `fr` is example.fr's - and no\n    // other.\n    const dispatcher = dispatcherWithPublic(\"pages-i18n\", [\"test.txt\"]);\n    for (const url of [\"/test.txt\", \"/en-US/test.txt\", \"/fr/test.txt\"]) {\n      expect(await dispatcher.dispatch(request(url))).toMatchObject({\n        kind: \"static-file\",\n        filePath: \"pages-i18n/public/test.txt\",\n      });\n    }\n    expect(\n      (await dispatcher.dispatch(request(\"/nl-NL/test.txt\"))).kind,\n    ).not.toBe(\"static-file\");\n  });\n\n  it(\"knows nothing of public/ when the deployment has none\", async () => {\n    // The Lambda types: CloudFront or API Gateway answers public/ from S3, the\n    // package does not carry it, and a request that got through anyway takes\n    // the ordinary not-found path, middleware request headers and all.\n    expect(\n      await dispatcherFor(\"app-playground\").dispatch(request(\"/test.txt\")),\n    ).toMatchObject({ kind: \"not-found\" });\n  });\n});\n\ndescribe(\"Dispatcher build-output spellings\", () => {\n  it(\"serves a _next/static file whose name the HTML percent-encodes\", async () => {\n    // webpack names an App Router chunk after its route segment, brackets and\n    // all, and Next.js reports the pathname unencoded; the `<script>` tag in\n    // the HTML asks for `%5Bid%5D`.\n    const base = manifests[\"app-playground\"];\n    const pathname = \"/_next/static/chunks/app/isr/[id]/page-0123abcd.js\";\n    const filePath =\n      \"app-playground/.next/static/chunks/app/isr/[id]/page-0123abcd.js\";\n    const manifest: AdapterManifest = {\n      ...base,\n      staticFiles: { ...base.staticFiles, [pathname]: filePath },\n      pathnames: [...base.pathnames, pathname],\n    };\n    const dispatcher = new Dispatcher({\n      manifest,\n    });\n    for (const url of [\n      \"/_next/static/chunks/app/isr/%5Bid%5D/page-0123abcd.js\",\n      pathname,\n    ]) {\n      expect(await dispatcher.dispatch(request(url))).toMatchObject({\n        kind: \"static-file\",\n        source: \"next-static\",\n        filePath,\n      });\n    }\n  });\n});\n\ndescribe(\"Dispatcher non-entrypoint outcomes\", () => {\n  it(\"serves a build asset as a static file with its immutable cache header\", async () => {\n    const manifest = manifests[\"app-playground\"];\n    const pathname = Object.keys(manifest.staticFiles).find((file) =>\n      file.startsWith(\"/_next/static/\"),\n    )!;\n    const result = await dispatcherFor(\"app-playground\").dispatch(\n      request(pathname),\n    );\n    expect(result.kind).toBe(\"static-file\");\n    if (result.kind !== \"static-file\") return;\n    expect(result.pathname).toBe(pathname);\n    expect(result.responseHeaders.get(\"cache-control\")).toBe(\n      \"public,max-age=31536000,immutable\",\n    );\n  });\n\n  it(\"routes /_next/image to the optimizer, basePath included\", async () => {\n    const query = \"?url=%2Ffoo.png&w=640&q=75\";\n    const plain = await dispatcherFor(\"app-playground\").dispatch(\n      request(`/_next/image${query}`),\n    );\n    expect(plain.kind).toBe(\"image-optimization\");\n\n    const prefixed = await dispatcherFor(\"app-playground-base-path\").dispatch(\n      request(`/prod/_next/image${query}`),\n    );\n    expect(prefixed.kind).toBe(\"image-optimization\");\n    if (prefixed.kind !== \"image-optimization\") return;\n    expect(prefixed.url.searchParams.get(\"url\")).toBe(\"/foo.png\");\n  });\n\n  it(\"routes /_next/image to the optimizer ahead of a root catch-all\", async () => {\n    const query = \"?url=%2Ffoo.png&w=640&q=75\";\n    const catchAll = dispatcherFor(\"app-playground-root-catch-all\");\n    const image = await catchAll.dispatch(request(`/_next/image${query}`));\n    expect(image.kind).toBe(\"image-optimization\");\n    if (image.kind !== \"image-optimization\") return;\n    expect(image.url.searchParams.get(\"url\")).toBe(\"/foo.png\");\n\n    // The catch-all itself still takes everything else.\n    const page = await catchAll.dispatch(request(\"/a/b\"));\n    expect(page.kind).toBe(\"entrypoint\");\n    if (page.kind !== \"entrypoint\") return;\n    expect(page.resolvedPathname).toBe(\"/[[...rest]]\");\n\n    const prefixedCatchAll = dispatcherFor(\n      \"app-playground-base-path-root-catch-all\",\n    );\n    const prefixed = await prefixedCatchAll.dispatch(\n      request(`/prod/_next/image${query}`),\n    );\n    expect(prefixed.kind).toBe(\"image-optimization\");\n    // Without which the image assertion would pass on a fixture with no\n    // catch-all at all.\n    const prefixedPage = await prefixedCatchAll.dispatch(request(\"/prod/a/b\"));\n    expect(prefixedPage.kind).toBe(\"entrypoint\");\n    if (prefixedPage.kind !== \"entrypoint\") return;\n    expect(prefixedPage.resolvedPathname).toBe(\"/prod/[[...rest]]\");\n  });\n\n  it(\"optimizes the destination of a next.config rewrite onto /_next/image\", async () => {\n    const manifest = manifests[\"app-playground-root-catch-all\"];\n    const routing = manifest.routing as { beforeFiles: unknown[] };\n    const result = await new Dispatcher({\n      manifest: {\n        ...manifest,\n        routing: {\n          ...routing,\n          beforeFiles: [\n            {\n              source: \"/avatar/:id\",\n              sourceRegex: \"^\\\\/avatar(?:\\\\/([^\\\\/]+?))(?:\\\\/)?$\",\n              destination: \"/_next/image?url=%2Favatars%2F$1.png&w=64&q=75\",\n            },\n            ...routing.beforeFiles,\n          ],\n        },\n      },\n    }).dispatch(request(\"/avatar/42\"));\n    expect(result.kind).toBe(\"image-optimization\");\n    if (result.kind !== \"image-optimization\") return;\n    expect(result.url.pathname).toBe(\"/_next/image\");\n    expect(result.url.searchParams.get(\"url\")).toBe(\"/avatars/42.png\");\n    expect(result.url.searchParams.get(\"w\")).toBe(\"64\");\n  });\n\n  it(\"redirects a trailing slash\", async () => {\n    const result = await dispatcherFor(\"app-playground\").dispatch(\n      request(\"/isr/1/\"),\n    );\n    expect(result).toMatchObject({\n      kind: \"redirect\",\n      status: 308,\n      location: \"/isr/1\",\n    });\n  });\n\n  it(\"serves the app's root in the default locale, with no redirect at all\", async () => {\n    // `resolveRoutes` prefixes the locale as `${basePath}/${locale}${pathname}`,\n    // which turns the root into `/en-US/`, and the slash-stripping 308 every\n    // build compiles then answered `GET /` with a redirect no `next start`\n    // sends. Measured against `test/e2e/i18n-support-catchall`, whose `/` is a\n    // 200. See `Dispatcher.withRootLocale`.\n    const result = await dispatcherFor(\"pages-i18n\").dispatch(request(\"/\"));\n    expect(result).toMatchObject({ kind: \"static-file\", pathname: \"/en-US\" });\n  });\n\n  it(\"redirects the root to the locale the request asked for\", async () => {\n    const result = await dispatcherFor(\"pages-i18n\").dispatch(\n      request(\"/\", { \"accept-language\": \"nl-NL\" }),\n    );\n    // 307 and not 308, because the next request may detect a different locale.\n    // Relative and without the trailing slash `resolveRoutes` puts in the\n    // location it builds (`https://example.test/nl-NL/`), which is what\n    // `next start` sends and what a test asserting `headers.location` reads.\n    expect(result).toMatchObject({\n      kind: \"redirect\",\n      status: 307,\n      location: \"/nl-NL\",\n    });\n  });\n\n  it(\"keeps a redirect to another locale's domain absolute\", async () => {\n    // The fixture maps `fr` onto example.fr, and an absolute location is the\n    // only way to leave the origin.\n    const result = await dispatcherFor(\"pages-i18n\").dispatch(\n      request(\"/\", { cookie: \"NEXT_LOCALE=fr\" }),\n    );\n    expect(result).toMatchObject({\n      kind: \"redirect\",\n      status: 307,\n      location: \"https://example.fr/\",\n    });\n  });\n\n  it(\"serves the root of a `trailingSlash` i18n app with no redirect\", async () => {\n    // With `trailingSlash: true`, `next build` compiles the slash-*adding* 308\n    // (`load-custom-routes`' `/:notfile(...)` → `/:notfile/`, `locale: false`)\n    // in place of the stripping one, and prefixing the root as `/en-US` made\n    // that rule answer `GET /` with a 308 to `/en-US/`, where `next start`\n    // answers 200.\n    const withSlash = structuredClone(\n      pagesI18n as unknown,\n    ) as BuildCompleteContext;\n    (withSlash.config as { trailingSlash: boolean }).trailingSlash = true;\n    const routing = withSlash.routing as {\n      beforeMiddleware: Record<string, unknown>[];\n    };\n    routing.beforeMiddleware = [\n      {\n        source: \"/:notfile((?!\\\\.well-known(?:/.*)?)(?:[^/]+/)*[^/\\\\.]+)\",\n        sourceRegex:\n          \"^(?:\\\\/((?!\\\\.well-known(?:\\\\/.*)?)(?:[^\\\\/]+\\\\/)*[^\\\\/\\\\.]+))$\",\n        headers: { Location: \"/$1/\" },\n        status: 308,\n        priority: true,\n      },\n      ...routing.beforeMiddleware.filter((route) => route.status !== 308),\n    ];\n    const dispatcher = new Dispatcher({ manifest: manifestOf(withSlash) });\n\n    expect(await dispatcher.dispatch(request(\"/\"))).toMatchObject({\n      kind: \"static-file\",\n      pathname: \"/en-US\",\n    });\n    // The rule itself is live: the slashless locale root still gets it.\n    expect(await dispatcher.dispatch(request(\"/en-US\"))).toMatchObject({\n      kind: \"redirect\",\n      status: 308,\n      location: \"/en-US/\",\n    });\n  });\n\n  it(\"still strips a trailing slash the request itself carried\", async () => {\n    const result = await dispatcherFor(\"pages-i18n\").dispatch(\n      request(\"/nl-NL/\"),\n    );\n    expect(result).toMatchObject({\n      kind: \"redirect\",\n      status: 308,\n      location: \"/nl-NL\",\n    });\n  });\n\n  it(\"returns a direct response for a route that forces a status\", async () => {\n    const base = manifests[\"app-playground\"];\n    const manifest: AdapterManifest = {\n      ...base,\n      middleware: null,\n      routing: {\n        ...(base.routing as Record<string, unknown>),\n        beforeFiles: [\n          {\n            sourceRegex: \"^/blocked$\",\n            status: 403,\n            headers: { \"x-why\": \"no\" },\n          },\n        ],\n      },\n    };\n    const result = await new Dispatcher({ manifest }).dispatch(\n      request(\"/blocked\"),\n    );\n    expect(result).toMatchObject({ kind: \"response\", status: 403 });\n    expect(result.responseHeaders.get(\"x-why\")).toBe(\"no\");\n  });\n\n  it(\"reports an unknown path as not found\", async () => {\n    const result = await dispatcherFor(\"app-playground\").dispatch(\n      request(\"/definitely-not-a-route\"),\n    );\n    expect(result.kind).toBe(\"not-found\");\n    if (result.kind !== \"not-found\") return;\n    expect(result.pathname).toBe(\"/definitely-not-a-route\");\n  });\n\n  it(\"resolves the 404 target per router flavor\", () => {\n    expect(statusTargetOf(manifests[\"app-playground\"], 404)).toMatchObject({\n      kind: \"entrypoint\",\n      pathname: \"/_not-found\",\n    });\n    expect(\n      statusTargetOf(manifests[\"app-playground-base-path\"], 404),\n    ).toMatchObject({\n      kind: \"entrypoint\",\n      pathname: \"/prod/_not-found\",\n    });\n    // Pages Router has no `/_not-found`, and `next build` prerenders its 404 —\n    // one per locale — which `next start` serves ahead of `/_error`.\n    expect(statusTargetOf(manifests[\"pages-i18n\"], 404)).toEqual({\n      kind: \"static-file\",\n      pathname: \"/en-US/404\",\n      filePath: manifests[\"pages-i18n\"].staticFiles[\"/en-US/404\"],\n    });\n  });\n\n  it(\"serves the prerendered 404 of the request's locale\", () => {\n    // Every Pages build has `/_error`, so checking it first made the\n    // prerendered 404 — the app's `pages/404.js` — dead code; and under i18n\n    // the prerender is only ever keyed by locale, never as a bare `/404`.\n    const dispatcher = dispatcherFor(\"pages-i18n\");\n    const { staticFiles } = manifests[\"pages-i18n\"];\n    const at = (url: string) => dispatcher.notFoundFor(new URL(url, ORIGIN));\n\n    expect(at(\"/fr/nope\")).toMatchObject({ filePath: staticFiles[\"/fr/404\"] });\n    expect(at(\"/NL-nl/nope\")).toMatchObject({\n      filePath: staticFiles[\"/nl-NL/404\"],\n    });\n    expect(at(\"/nope\")).toMatchObject({ filePath: staticFiles[\"/en-US/404\"] });\n    // No locale in the path: the domain's default, as `next start` renders it.\n    expect(at(\"https://example.fr/nope\")).toMatchObject({\n      filePath: staticFiles[\"/fr/404\"],\n    });\n  });\n\n  it(\"falls back to /_error when no 404 was prerendered\", () => {\n    // What a `pages/_app.js` with `getInitialProps` builds without a\n    // `pages/404.js`: `next build` then prerenders no 404 at all.\n    const base = manifests[\"pages-i18n\"];\n    const without404 = Object.fromEntries(\n      Object.entries(base.staticFiles).filter(([key]) => !key.endsWith(\"/404\")),\n    );\n    expect(\n      statusTargetOf({ ...base, staticFiles: without404 }, 404),\n    ).toMatchObject({ kind: \"entrypoint\", pathname: \"/_error\" });\n  });\n\n  it(\"prefers an invocable custom /404 over /_error\", () => {\n    // What `pages/404.js` plus a `pages/_app.js` with `getInitialProps` builds:\n    // the 404 cannot be prerendered, so it arrives as an entrypoint beside\n    // `/_error`. Serving `/_error` there means the built-in \"404: This page\n    // could not be found\" replaces the app's own — `test/e2e/404-page-app`.\n    const base = manifests[\"pages-i18n\"];\n    const withCustom404: AdapterManifest = {\n      ...base,\n      entrypoints: {\n        ...base.entrypoints,\n        \"/404\": { ...base.entrypoints[\"/_error\"], id: \"/404\" },\n      },\n    };\n    expect(statusTargetOf(withCustom404, 404)).toMatchObject({\n      kind: \"entrypoint\",\n      pathname: \"/404\",\n    });\n    // App Router still wins over both: `/_not-found` is what next looks for\n    // first, and an app with both routers has all three.\n    expect(\n      statusTargetOf(\n        {\n          ...withCustom404,\n          entrypoints: {\n            ...withCustom404.entrypoints,\n            \"/_not-found\": {\n              ...base.entrypoints[\"/_error\"],\n              id: \"/_not-found\",\n            },\n          },\n        },\n        404,\n      ),\n    ).toMatchObject({ kind: \"entrypoint\", pathname: \"/_not-found\" });\n  });\n\n  it(\"falls back to a prerendered 404, then to nothing\", () => {\n    const base = manifests[\"app-playground\"];\n    const withoutEntrypoints: AdapterManifest = {\n      ...base,\n      entrypoints: {},\n      middleware: null,\n    };\n    expect(statusTargetOf(withoutEntrypoints, 404)).toEqual({\n      kind: \"static-file\",\n      pathname: \"/404\",\n      filePath: base.staticFiles[\"/404\"],\n    });\n    expect(\n      statusTargetOf({ ...withoutEntrypoints, staticFiles: {} }, 404),\n    ).toEqual({ kind: \"none\" });\n  });\n});\n\ndescribe(\"the 500 ladder\", () => {\n  it(\"prefers the prerendered /500 next emits by default\", () => {\n    const base = manifests[\"app-playground\"];\n    expect(statusTargetOf(base, 500)).toEqual({\n      kind: \"static-file\",\n      pathname: \"/500\",\n      filePath: base.staticFiles[\"/500\"],\n    });\n  });\n\n  it(\"prefers an invocable /500 over the prerendered one\", () => {\n    // What a `pages/500.js` that cannot be static-optimized builds.\n    const base = manifests[\"pages-i18n\"];\n    expect(\n      statusTargetOf(\n        {\n          ...base,\n          entrypoints: {\n            ...base.entrypoints,\n            \"/500\": { ...base.entrypoints[\"/_error\"], id: \"/500\" },\n          },\n        },\n        500,\n      ),\n    ).toMatchObject({ kind: \"entrypoint\", pathname: \"/500\" });\n  });\n\n  it(\"falls back to /_error, then to nothing\", () => {\n    // `/_error` is where a custom error page lands when it has\n    // `getInitialProps` — the case `test/e2e/async-modules` measures.\n    const base = manifests[\"pages-i18n\"];\n    expect(statusTargetOf({ ...base, staticFiles: {} }, 500)).toMatchObject({\n      kind: \"entrypoint\",\n      pathname: \"/_error\",\n    });\n    expect(\n      statusTargetOf({ ...base, staticFiles: {}, entrypoints: {} }, 500),\n    ).toEqual({ kind: \"none\" });\n  });\n\n  it(\"serves the prerendered 500 of the request's locale\", () => {\n    // Under i18n the prerendered 500 is keyed only by locale, never as a bare\n    // `/500`, so looking up `/500` alone always fell through to `/_error`.\n    const base = manifests[\"pages-i18n\"];\n    const errorTargetFor = statusTargets(base, 500);\n    const at = (url: string) => errorTargetFor(new URL(url, ORIGIN));\n\n    expect(at(\"/fr/ssr\")).toEqual({\n      kind: \"static-file\",\n      pathname: \"/fr/500\",\n      filePath: base.staticFiles[\"/fr/500\"],\n    });\n    expect(at(\"/ssr\")).toMatchObject({ pathname: \"/en-US/500\" });\n    // No locale in the path: the domain's default, as `next start` renders it.\n    expect(at(\"https://example.fr/ssr\")).toMatchObject({\n      pathname: \"/fr/500\",\n    });\n    // A request whose URL could not be parsed gets the default locale's.\n    expect(errorTargetFor(undefined)).toMatchObject({\n      pathname: \"/en-US/500\",\n    });\n    expect(statusTargetOf(base, 500)).toMatchObject({ pathname: \"/en-US/500\" });\n  });\n\n  it(\"looks for the error page under the app's basePath\", () => {\n    const base = manifests[\"app-playground-base-path\"];\n    expect(statusTargetOf(base, 500)).toMatchObject({ pathname: \"/prod/500\" });\n  });\n});\n\ndescribe(\"toRedirect\", () => {\n  it(\"prefers the documented redirect field\", () => {\n    // `resolveRoutes` does not populate `ResolveRoutesResult.redirect` in\n    // next 16.3.5 — every redirect arrives as bare status + `location` — so this\n    // is the only coverage that branch can have until it does.\n    expect(\n      toRedirect(\n        { redirect: { url: new URL(\"https://e.test/x\"), status: 301 } },\n        new Headers(),\n      ),\n    ).toEqual({ location: \"https://e.test/x\", status: 301 });\n  });\n\n  it(\"ignores a location header on a non-3xx status\", () => {\n    const headers = new Headers({ location: \"/x\" });\n    expect(toRedirect({ status: 200 }, headers)).toBeUndefined();\n    expect(toRedirect({ status: 403 }, headers)).toBeUndefined();\n    expect(toRedirect({}, headers)).toBeUndefined();\n    expect(toRedirect({ status: 308 }, new Headers())).toBeUndefined();\n  });\n});\n\ndescribe(\"Dispatcher middleware handling\", () => {\n  it(\"reports a middleware response without resolving a route\", async () => {\n    const result = await dispatcherFor(\"app-playground\", async () => ({\n      bodySent: true,\n      responseHeaders: new Headers({ \"x-mw\": \"responded\" }),\n    })).dispatch(request(\"/isr/1\"));\n    expect(result.kind).toBe(\"middleware-responded\");\n  });\n\n  it(\"sends next.config headers() with a response middleware wrote\", async () => {\n    // `app-playground`'s `headers()` sets this on `/api/echo`; `next start`\n    // sends it with a middleware 401 there too.\n    const result = await dispatcherFor(\"app-playground\", async () => ({\n      bodySent: true,\n    })).dispatch(request(\"/api/echo\"));\n    expect(result.kind).toBe(\"middleware-responded\");\n    expect(result.responseHeaders.get(\"x-e2e-config-header\")).toBe(\n      \"from-next-config\",\n    );\n\n    const other = await dispatcherFor(\"app-playground\", async () => ({\n      bodySent: true,\n    })).dispatch(request(\"/isr/1\"));\n    expect(other.responseHeaders.has(\"x-e2e-config-header\")).toBe(false);\n  });\n\n  it(\"normalizes a middleware redirect to a same-origin path\", async () => {\n    const result = await dispatcherFor(\"app-playground\", async () => ({\n      redirect: { url: new URL(\"/login\", ORIGIN), status: 307 },\n    })).dispatch(request(\"/isr/1\"));\n    expect(result).toMatchObject({\n      kind: \"redirect\",\n      status: 307,\n      // `NextResponse.redirect(new URL(\"/login\", request.url))` is how every\n      // middleware spells this, and Next.js sends the path: `@next/routing`'s\n      // own `getRelativeURL` does it for the header it sets, and only the\n      // `redirect.url` field this path reads keeps the absolute form.\n      location: \"/login\",\n    });\n  });\n\n  it(\"follows an internal middleware rewrite to the rewritten entrypoint\", async () => {\n    const result = await dispatcherFor(\"app-playground\", async () => ({\n      rewrite: new URL(\"/api/health\", ORIGIN),\n    })).dispatch(request(\"/isr/1\"));\n    expect(result.kind).toBe(\"entrypoint\");\n    if (result.kind !== \"entrypoint\") return;\n    expect(result.resolvedPathname).toBe(\"/api/health\");\n  });\n\n  it(\"routes /_next/image when middleware is what put the request on it\", async () => {\n    // The API Gateway examples' middleware rewrites `/x` to `/<stage>/x` so the\n    // build's `basePath` lines up. `resolveRoutes` never reports the rewritten\n    // URL back, so optimizing the URL as received would lose the rewrite.\n    const query = \"?url=%2Ffoo.png&w=640&q=75\";\n    const result = await dispatcherFor(\n      \"app-playground-base-path\",\n      async () => ({ rewrite: new URL(`/prod/_next/image${query}`, ORIGIN) }),\n    ).dispatch(request(`/_next/image${query}`));\n    expect(result.kind).toBe(\"image-optimization\");\n    if (result.kind !== \"image-optimization\") return;\n    expect(result.url.searchParams.get(\"url\")).toBe(\"/foo.png\");\n  });\n\n  it(\"does not leak the internal rewrite header it consumed\", async () => {\n    const result = await dispatcherFor(\"app-playground\", async () => ({\n      rewrite: new URL(\"/api/health\", ORIGIN),\n      responseHeaders: new Headers({ \"x-middleware-rewrite\": \"/api/health\" }),\n    })).dispatch(request(\"/isr/1\"));\n    expect(result.responseHeaders.has(\"x-middleware-rewrite\")).toBe(false);\n  });\n\n  it(\"reports an external middleware rewrite as a proxy target\", async () => {\n    const result = await dispatcherFor(\"app-playground\", async () => ({\n      rewrite: new URL(\"https://upstream.test/x\"),\n    })).dispatch(request(\"/isr/1\"));\n    expect(result.kind).toBe(\"external-rewrite\");\n    if (result.kind !== \"external-rewrite\") return;\n    expect(result.url.href).toBe(\"https://upstream.test/x\");\n  });\n\n  it(\"carries middleware request headers forward and response headers back\", async () => {\n    // `resolveRoutes` drops `MiddlewareResult.requestHeaders`: it neither\n    // returns them nor mutates the `headers` it was given. Dispatch captures\n    // them from the callback, which is what keeps\n    // `NextResponse.next({ request: { headers } })` working.\n    const result = await dispatcherFor(\"app-playground\", async () => ({\n      requestHeaders: new Headers({ host: \"example.test\", \"x-user\": \"42\" }),\n      responseHeaders: new Headers({ \"x-mw\": \"ran\" }),\n    })).dispatch(request(\"/isr/1\"));\n    expect(result.kind).toBe(\"entrypoint\");\n    if (result.kind !== \"entrypoint\") return;\n    expect(result.requestHeaders.get(\"x-user\")).toBe(\"42\");\n    expect(result.responseHeaders.get(\"x-mw\")).toBe(\"ran\");\n  });\n\n  it(\"passes the caller's request headers through when middleware adds none\", async () => {\n    const result = await dispatcherFor(\"app-playground\").dispatch(\n      request(\"/isr/1\", { \"x-caller\": \"yes\" }),\n    );\n    expect(result.kind).toBe(\"entrypoint\");\n    if (result.kind !== \"entrypoint\") return;\n    expect(result.requestHeaders.get(\"x-caller\")).toBe(\"yes\");\n  });\n});\n\ndescribe(\"repairRouteParamQuery\", () => {\n  it(\"drops an optional catchall's param when the request filled none\", () => {\n    // Measured from `resolveRoutes` for `/optional-catchall` against\n    // `app/optional-catchall/[[...params]]`: *both* sides carry the key with no\n    // value, which the `@next/routing` types do not admit. The key alone is what\n    // makes `prepare()` invent a param, so the key has to go.\n    expect(\n      repairRouteParamQuery(\n        { nxtPparams: undefined! },\n        {\n          nxtPparams: undefined,\n        },\n      ),\n    ).toEqual({});\n    // The same shape with \"\" for the value, which the expansion can also produce.\n    expect(repairRouteParamQuery({ nxtPparams: \"\" }, {})).toEqual({});\n    // A filled one is left alone, whichever source it came from.\n    expect(\n      repairRouteParamQuery({ nxtPparams: \"a/b\" }, { nxtPparams: \"a/b\" }),\n    ).toEqual({ nxtPparams: \"a/b\" });\n    // No route param can be legitimately empty - a required segment captures\n    // `[^/]+?`, a required catchall `.+?`, and an optional catchall that matched\n    // nothing has no group for `routeMatches` to report - so an empty value goes\n    // whether or not `routeMatches` echoes it.\n    expect(repairRouteParamQuery({ nxtPid: \"\" }, { nxtPid: \"\" })).toEqual({});\n    // Not a route param, so not ours to touch.\n    expect(repairRouteParamQuery({ q: \"\" }, {})).toEqual({ q: \"\" });\n  });\n\n  it(\"repairs and drops in one pass\", () => {\n    // The prefix collision and the unset optional catchall in the same query:\n    // `nxtPid2` is wrong and `nxtPrest` was never requested.\n    expect(\n      repairRouteParamQuery(\n        { nxtPid: \"a\", nxtPid2: \"a2\", nxtPrest: \"\" },\n        { nxtPid: \"a\", nxtPid2: \"b\" },\n      ),\n    ).toEqual({ nxtPid: \"a\", nxtPid2: \"b\" });\n  });\n});\n\ndescribe(\"outOfBandRouteParams\", () => {\n  it(\"leaves a query the contract can carry alone\", () => {\n    expect(\n      outOfBandRouteParams(\n        { nxtPrest: \"a/b\", q: \"1\" },\n        \"/pages-cache/[...rest]\",\n      ),\n    ).toBeUndefined();\n    expect(outOfBandRouteParams({ nxtPid: \"42\" }, \"/isr/[id]\")).toBeUndefined();\n    // An encoded delimiter in something that is not a route param is not ours.\n    expect(\n      outOfBandRouteParams({ q: \"a%2Fb\" }, \"/pages-cache/[...rest]\"),\n    ).toBeUndefined();\n  });\n\n  it(\"restates a capture with an encoded delimiter as params, once decoded\", () => {\n    // `test/e2e/incremental-cache-path-traversal`. Through the query contract\n    // this becomes three params and `normalizePagePath` throws on the pathname\n    // rebuilt from them; `next start` renders one param, which is this.\n    expect(\n      outOfBandRouteParams(\n        { nxtPrest: \"..%2F..%2Fserver-reference-manifest\" },\n        \"/_next/data/BUILD_ID/pages-cache/[...rest].json\",\n      ),\n    ).toEqual({\n      params: { rest: [\"../../server-reference-manifest\"] },\n      query: {},\n    });\n  });\n\n  it(\"splits a repeat on real delimiters only, and keeps a single param whole\", () => {\n    expect(\n      outOfBandRouteParams(\n        { nxtPrest: \"a/b%2Fc/d\" },\n        \"/pages-cache/[[...rest]]\",\n      ),\n    ).toEqual({ params: { rest: [\"a\", \"b/c\", \"d\"] }, query: {} });\n    expect(outOfBandRouteParams({ nxtPid: \"a%2Fb\" }, \"/isr/[id]\")).toEqual({\n      params: { id: \"a/b\" },\n      query: {},\n    });\n  });\n\n  it(\"keeps everything that is not a route param in the query\", () => {\n    expect(\n      outOfBandRouteParams(\n        { nxtPrest: \"a%2Fb\", from: \"/x\", page: \"2\" },\n        \"/pages-cache/[...rest]\",\n      ),\n    ).toEqual({\n      params: { rest: [\"a/b\"] },\n      query: { from: \"/x\", page: \"2\" },\n    });\n  });\n\n  it(\"stays on the query contract when a param cannot be restated\", () => {\n    // An optional catchall the request left unset. Half a param set is worse\n    // than none: `prepare` would interpolate a route with a missing segment.\n    expect(\n      outOfBandRouteParams(\n        { nxtPrest: \"a%2Fb\", nxtPoptional: \"\" },\n        \"/pages-cache/[...rest]/[[...optional]]\",\n      ),\n    ).toBeUndefined();\n  });\n\n  it(\"tolerates a capture that is not valid percent-encoding\", () => {\n    // `decodeQueryPathParameter` is a try/catch for the same reason: `%2F` makes\n    // this reachable while `%zz` makes `decodeURIComponent` throw.\n    expect(\n      outOfBandRouteParams({ nxtPrest: \"a%2F%zz\" }, \"/pages-cache/[...rest]\"),\n    ).toEqual({ params: { rest: [\"a%2F%zz\"] }, query: {} });\n  });\n});\n"]}