cdk-nextjs 0.6.2 → 0.7.1

package/lib/adapter/function-groups.test.js

@@ -0,0 +1,743 @@
+"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 route_regex_1 = require("next/dist/shared/lib/router/utils/route-regex");
+const sorted_routes_1 = require("next/dist/shared/lib/router/utils/sorted-routes");
+const app_playground_json_1 = __importDefault(require("./__fixtures__/app-playground.json"));
+const pages_i18n_json_1 = __importDefault(require("./__fixtures__/pages-i18n.json"));
+const build_outputs_1 = require("./build-outputs");
+const function_groups_1 = require("./function-groups");
+/** One entrypoint per template unless a test says otherwise. */
+const routes = (...templates) => templates.map((template) => ({ template, entrypointId: template }));
+const BUILD_ID = "abc123";
+/**
+ * `ctx.routing.dynamicRoutes` as `next build` derives it from `entries`: Next's
+ * own route sort and regexes, data URLs included.
+ */
+function nextRouting(entries, basePath) {
+    const dataPrefix = `${basePath}/_next/data/${BUILD_ID}/`;
+    const dynamic = [...new Set(entries.map((entry) => entry.template))].filter((template) => template.includes("[") &&
+        !template.endsWith(".rsc") &&
+        !/\(\.{1,3}\)/.test(template));
+    const route = (template) => ({
+        sourceRegex: (0, route_regex_1.getNamedRouteRegex)(template, {
+            prefixRouteKeys: true,
+            includeSuffix: true,
+        }).namedRegex,
+        destination: template,
+    });
+    return {
+        dynamicRoutes: [
+            // Sorted by the page they name: Next's sort reads `[slug].json` as static.
+            ...(0, sorted_routes_1.getSortedRouteObjects)(dynamic.filter((template) => template.startsWith(dataPrefix)), (template) => `/${template.slice(dataPrefix.length, -".json".length)}`).map(route),
+            ...(0, sorted_routes_1.getSortedRoutes)(dynamic.filter((template) => !template.startsWith(dataPrefix))).map(route),
+        ],
+    };
+}
+const assignment = (groups, entries, basePath = "", options = {}) => (0, function_groups_1.assignRoutesToGroups)(groups, entries, {
+    basePath,
+    buildId: BUILD_ID,
+    ...options,
+    routing: { ...nextRouting(entries, basePath), ...options.routing },
+});
+const assign = (...args) => assignment(...args).templates;
+/** The path patterns of the behaviors the assignment returns, in order. */
+const patternsOf = (...args) => assignment(...args).behaviors.map(({ pattern }) => pattern);
+/**
+ * A captured `onBuildComplete` fixture's routes, exactly as `buildAdapterManifest`
+ * hands them to the assignment, plus the rest of what it passes.
+ */
+function fixtureRoutes(fixture) {
+    const ctx = structuredClone(fixture);
+    const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
+    const { manifest } = (0, build_outputs_1.buildAdapterManifest)(ctx, { buildCwd: ctx.projectDir });
+    warn.mockRestore();
+    const entries = Object.entries(manifest.entrypoints).map(([template, entrypoint]) => ({
+        template,
+        entrypointId: entrypoint.filePath,
+        type: entrypoint.type,
+    }));
+    return {
+        entries,
+        options: {
+            basePath: ctx.config.basePath || "",
+            buildId: ctx.buildId,
+            trailingSlash: ctx.config.trailingSlash === true,
+            routing: ctx.routing,
+        },
+    };
+}
+describe("validateFunctionGroups", () => {
+    it("rejects an empty array rather than treating it as no splitting", () => {
+        expect(() => (0, function_groups_1.validateFunctionGroups)([])).toThrow(/Omit the prop entirely/);
+    });
+    it("reserves the default group name", () => {
+        expect(() => (0, function_groups_1.validateFunctionGroups)([{ name: "default", routes: ["/a"] }])).toThrow(/reserved group name/);
+    });
+    it.each([["has space"], ["under_score"], ["dots.here"], [""]])("rejects group name %p, which has to be a construct id", (name) => {
+        expect(() => (0, function_groups_1.validateFunctionGroups)([{ name, routes: ["/a"] }])).toThrow(/must match/);
+    });
+    it("rejects two groups with the same name", () => {
+        expect(() => (0, function_groups_1.validateFunctionGroups)([
+            { name: "api", routes: ["/a"] },
+            { name: "api", routes: ["/b"] },
+        ])).toThrow(/both named "api"/);
+    });
+    it("rejects a group that owns no routes", () => {
+        expect(() => (0, function_groups_1.validateFunctionGroups)([{ name: "api", routes: [] }])).toThrow(/owns no routes/);
+    });
+    it("rejects the same pattern in two groups", () => {
+        expect(() => (0, function_groups_1.validateFunctionGroups)([
+            { name: "a", routes: ["/api/**"] },
+            { name: "b", routes: ["/api/**"] },
+        ])).toThrow(/appears in both group "a" and group "b"/);
+    });
+    it("allows overlapping-but-different patterns, which resolve longest-first", () => {
+        expect(() => (0, function_groups_1.validateFunctionGroups)([
+            { name: "a", routes: ["/api/**"] },
+            { name: "b", routes: ["/api/reports/**"] },
+        ])).not.toThrow();
+    });
+    it("requires a leading slash", () => {
+        expect(() => (0, function_groups_1.validateFunctionGroups)([{ name: "a", routes: ["api/**"] }])).toThrow(/must start with "\/"/);
+    });
+    it.each([["/dashboard/[id]"], ["/blog/[...slug]"], ["/shop/[[...slug]]"]])("rejects the dynamic segment in %p, which CloudFront cannot express", (route) => {
+        expect(() => (0, function_groups_1.validateFunctionGroups)([{ name: "a", routes: [route] }])).toThrow(/contains a dynamic segment/);
+    });
+    it("rejects a route group segment, which never appears in a URL", () => {
+        expect(() => (0, function_groups_1.validateFunctionGroups)([{ name: "a", routes: ["/(marketing)/about"] }])).toThrow(/route group segment/);
+    });
+    it.each([["/api/*"], ["/api/**/x"], ["/api/repo?ts"], ["/*"]])("rejects the wildcard placement in %p", (route) => {
+        expect(() => (0, function_groups_1.validateFunctionGroups)([{ name: "a", routes: [route] }])).toThrow(/wildcard somewhere other than a trailing/);
+    });
+    it("rejects a pattern that would own everything", () => {
+        expect(() => (0, function_groups_1.validateFunctionGroups)([{ name: "a", routes: ["/**"] }])).toThrow(/would own every route/);
+    });
+    it("rejects the root, which no CloudFront path pattern can match alone", () => {
+        expect(() => (0, function_groups_1.validateFunctionGroups)([{ name: "a", routes: ["/"] }])).toThrow(/cannot be routed/);
+    });
+    it("accepts /index, which is a real App Router route", () => {
+        // `app/index/page.tsx` is served at `/index`, apart from `/`. Only the
+        // assignment knows which router `/index` came from; it rejects the Pages
+        // Router home page, which is the same file as `/`.
+        expect(() => (0, function_groups_1.validateFunctionGroups)([{ name: "a", routes: ["/index"] }])).not.toThrow();
+    });
+    it.each(["/_next", "/_next/**", "/_next/data/**"])("rejects %s, which Next.js reserves", (route) => {
+        // A data route follows its page into the page's group; a `_next/*`
+        // behavior would compete with the static-asset and image behaviors.
+        expect(() => (0, function_groups_1.validateFunctionGroups)([{ name: "a", routes: [route] }])).toThrow(/under "\/_next"/);
+    });
+    it("rejects an empty path segment", () => {
+        expect(() => (0, function_groups_1.validateFunctionGroups)([{ name: "a", routes: ["/api//x"] }])).toThrow(/empty path segment/);
+    });
+    it.each([
+        ["/über", '"ü"'],
+        ["/a b", '" "'],
+        ["/shop/a,b/**", '","'],
+        ["/100%25", '"%"'],
+    ])("rejects %p, which holds a character no CloudFront path pattern can", (route, char) => {
+        // `pathPatternsFor` copies the route verbatim into a behavior path
+        // pattern, so without this it failed at deploy naming neither the group
+        // nor the route.
+        expect(() => (0, function_groups_1.validateFunctionGroups)([{ name: "a", routes: [route] }])).toThrow(`contains ${char}, which a CloudFront behavior path pattern`);
+    });
+    it("accepts every literal in CloudFront's path pattern alphabet", () => {
+        expect(() => (0, function_groups_1.validateFunctionGroups)([
+            {
+                name: "a",
+                routes: [`/AZaz09_-.$~"'@:+&/**`],
+            },
+        ])).not.toThrow();
+    });
+});
+describe("assignRoutesToGroups", () => {
+    it("puts unassigned routes in the default group, which always exists", () => {
+        const assigned = assign([{ name: "api", routes: ["/api/**"] }], routes("/", "/pricing", "/api/health"));
+        expect(assigned).toEqual({
+            [function_groups_1.DEFAULT_FUNCTION_GROUP]: ["/", "/pricing"],
+            api: ["/api/health"],
+        });
+    });
+    it("matches an exact pattern only exactly", () => {
+        const assigned = assign([{ name: "p", routes: ["/pricing"] }], routes("/pricing", "/pricing/enterprise"));
+        expect(assigned.p).toEqual(["/pricing"]);
+        expect(assigned[function_groups_1.DEFAULT_FUNCTION_GROUP]).toEqual(["/pricing/enterprise"]);
+    });
+    it("matches a subtree against the dynamic routes under it", () => {
+        const assigned = assign([{ name: "blog", routes: ["/blog/**"] }], routes("/blog/[slug]", "/blog/[slug]/comments", "/blogroll"));
+        expect(assigned.blog).toEqual(["/blog/[slug]", "/blog/[slug]/comments"]);
+        expect(assigned[function_groups_1.DEFAULT_FUNCTION_GROUP]).toEqual(["/blogroll"]);
+    });
+    it("does not let a subtree claim its own root, because the behavior would not", () => {
+        // `/api/reports/**` deploys as CloudFront `api/reports/*`, which does not
+        // match `/api/reports`. Claiming it here would package the route into a
+        // function the edge never routes it to.
+        expect(() => assign([{ name: "r", routes: ["/api/reports/**"] }], routes("/api/reports"))).toThrow(/matches no route in this build/);
+    });
+    it("gives the longest matching pattern the route", () => {
+        const assigned = assign([
+            { name: "api", routes: ["/api/**"] },
+            { name: "reports", routes: ["/api/reports/**"] },
+        ], routes("/api/health", "/api/reports/[id]"));
+        expect(assigned.api).toEqual(["/api/health"]);
+        expect(assigned.reports).toEqual(["/api/reports/[id]"]);
+    });
+    it("ranks by segment count before string length", () => {
+        // "/a/b" is deeper than "/alongname" even though it is shorter.
+        const assigned = assign([
+            { name: "deep", routes: ["/a/b/**"] },
+            { name: "long", routes: ["/a/**"] },
+        ], routes("/a/b/c", "/a/x"));
+        expect(assigned.deep).toEqual(["/a/b/c"]);
+        expect(assigned.long).toEqual(["/a/x"]);
+    });
+    it("throws on a pattern that matches nothing, because the typo is invisible", () => {
+        expect(() => assign([{ name: "api", routes: ["/api/**", "/apy/**"] }], routes("/api/x"))).toThrow(/pattern "\/apy\/\*\*" matches no route/);
+    });
+    it("accepts a pattern every match of which a narrower pattern also claims", () => {
+        // `/api/**` never wins a route here, because every API route this build has
+        // is under `/api/reports/`. Recording only the *winning* pattern made it look
+        // like a typo and threw - rejecting the exact layout the duplicate-pattern
+        // error documents as supported. The group is legitimately empty: it is the
+        // consumer's choice to keep it for the routes it will own later.
+        const assigned = assign([
+            { name: "api", routes: ["/api/**"] },
+            { name: "reports", routes: ["/api/reports/**"] },
+        ], routes("/api/reports/[id]", "/api/reports/summary"));
+        expect(assigned.api).toEqual([]);
+        expect(assigned.reports).toEqual([
+            "/api/reports/[id]",
+            "/api/reports/summary",
+        ]);
+    });
+    it("gives a shared entrypoint to its most specific match, not its last one", () => {
+        // Two templates, one file, two groups whose patterns both match - one
+        // narrowly, one broadly. Ownership used to be last-write-wins over `entries`,
+        // so the same build grouped differently depending on manifest key order.
+        const entries = [
+            // Matched only by the broad pattern.
+            { template: "/api/health", entrypointId: "shared" },
+            // Matched by both; the narrow one wins.
+            { template: "/api/reports/summary", entrypointId: "shared" },
+        ];
+        const groups = [
+            { name: "api", routes: ["/api/**"] },
+            { name: "reports", routes: ["/api/reports/**"] },
+        ];
+        // `/api/reports/**` is the most specific claim any of the entrypoint's
+        // templates has, so it takes the whole entrypoint — and then the edge still
+        // sends `/api/health` to the api group, which lacks the file. That used to
+        // deploy and 500; it is the coverage check's to reject, identically in both
+        // orders.
+        const message = /"\/api\/health" to group "api" \(its pattern "\/api\/\*\*"\)/;
+        expect(() => assign(groups, entries)).toThrow(message);
+        expect(() => assign(groups, [...entries].reverse())).toThrow(message);
+        expect(() => assign(groups, entries)).toThrow(/Add "\/api\/health" to group "reports"'s routes/);
+        // Which is the fix: the exact pattern beats the api subtree at the edge.
+        const fixed = assign([
+            groups[0],
+            { name: "reports", routes: ["/api/reports/**", "/api/health"] },
+        ], entries);
+        expect(fixed.reports).toEqual(["/api/health", "/api/reports/summary"]);
+        expect(fixed.api).toEqual([]);
+    });
+    it("prefixes basePath before matching, since manifest templates carry it", () => {
+        const assigned = assign([{ name: "api", routes: ["/api/**"] }], routes("/prod/api/health", "/prod/pricing"), "/prod");
+        expect(assigned.api).toEqual(["/prod/api/health"]);
+        expect(assigned[function_groups_1.DEFAULT_FUNCTION_GROUP]).toEqual(["/prod/pricing"]);
+    });
+    it("keeps two templates sharing one entrypoint in the same group", () => {
+        // A Pages Router page and its `/_next/data/<buildId>/…json` sibling are one
+        // file; splitting them would stage it twice and misroute one of them.
+        const assigned = assign([{ name: "blog", routes: ["/blog/**"] }], [
+            {
+                template: "/blog/[slug]",
+                entrypointId: "pages/blog/[slug]",
+                type: "page",
+            },
+            {
+                template: "/_next/data/abc123/blog/[slug].json",
+                entrypointId: "pages/blog/[slug]",
+                type: "page",
+            },
+            { template: "/", entrypointId: "pages/index", type: "page" },
+        ]);
+        expect(assigned.blog).toEqual([
+            "/_next/data/abc123/blog/[slug].json",
+            "/blog/[slug]",
+        ]);
+        expect(assigned[function_groups_1.DEFAULT_FUNCTION_GROUP]).toEqual(["/"]);
+    });
+    it("returns every group even when a group ends up with only the default's leftovers", () => {
+        const assigned = assign([{ name: "api", routes: ["/api/**"] }], routes("/api/health"));
+        expect(Object.keys(assigned).sort()).toEqual(["api", "default"]);
+        expect(assigned[function_groups_1.DEFAULT_FUNCTION_GROUP]).toEqual([]);
+    });
+    it("sorts each group's templates so the manifest is byte-stable", () => {
+        const assigned = assign([{ name: "api", routes: ["/api/**"] }], routes("/api/z", "/api/a", "/z", "/a"));
+        expect(assigned.api).toEqual(["/api/a", "/api/z"]);
+        expect(assigned[function_groups_1.DEFAULT_FUNCTION_GROUP]).toEqual(["/a", "/z"]);
+    });
+});
+describe("the behaviors the assignment returns", () => {
+    it("orders overlapping group patterns most specific first", () => {
+        // CloudFront stops at the first matching behavior, so `api/*` ahead of
+        // `api/reports/*` would send every report request to the wrong function.
+        expect(patternsOf([
+            { name: "api", routes: ["/api/**"] },
+            { name: "reports", routes: ["/api/reports/**"] },
+        ], routes("/api/[x]", "/api/reports/[id]"))).toEqual(["api/reports/*", "api/*"]);
+    });
+    it("ranks by segment count before string length", () => {
+        expect(patternsOf([
+            { name: "a", routes: ["/a/b/**"] },
+            { name: "b", routes: ["/averyverylongsegment/**"] },
+        ], routes("/a/b/[x]", "/averyverylongsegment/[x]"))).toEqual(["a/b/*", "averyverylongsegment/*"]);
+    });
+    it("puts an exact pattern ahead of a wildcard of the same depth", () => {
+        // `a/*` and `a/b` are the same length and segment count; `a/*` first
+        // swallows `a/b`, sending group b's only route to group a's function.
+        expect(patternsOf([
+            { name: "a", routes: ["/a/**"] },
+            { name: "b", routes: ["/a/b"] },
+        ], routes("/a/b", "/a/[x]"))).toEqual(["a/b", "a/*"]);
+    });
+    it("adds data-URL behaviors only for the groups that own a Pages Router page", () => {
+        // One legacy page must not double every group's behaviors.
+        expect(patternsOf([
+            { name: "blog", routes: ["/blog/**"] },
+            { name: "docs", routes: ["/docs/**"] },
+        ], [
+            {
+                template: "/blog/[slug]",
+                entrypointId: "pages/blog/[slug].js",
+                type: "page",
+            },
+            { template: "/docs/[page]", entrypointId: "app/docs/[page]/page.js" },
+        ])).toEqual(["_next/data/abc123/blog/*", "blog/*", "docs/*"]);
+    });
+});
+describe("what the edge routes, checked against what was packaged", () => {
+    describe("Pages Router data URLs (A)", () => {
+        it("keeps a nested page's data URL in its own group", () => {
+            // With `_next/data/*/blog/*`, CloudFront sent the docs group's
+            // `/_next/data/<id>/docs/blog/intro.json` to the blog function.
+            const page = (template, file) => [
+                { template, entrypointId: file, type: "page" },
+                {
+                    template: `/_next/data/${BUILD_ID}${template}.json`,
+                    entrypointId: file,
+                    type: "page",
+                },
+            ];
+            const assigned = assign([
+                { name: "blog", routes: ["/blog/**"] },
+                { name: "docs", routes: ["/docs/**"] },
+            ], [
+                ...page("/blog/[slug]", "pages/blog/[slug].js"),
+                ...page("/docs/blog/[slug]", "pages/docs/blog/[slug].js"),
+            ]);
+            expect(assigned.docs).toEqual([
+                "/_next/data/abc123/docs/blog/[slug].json",
+                "/docs/blog/[slug]",
+            ]);
+        });
+        it("routes the pages-i18n fixture's page and data URLs together", () => {
+            // Splitting refuses i18n, so drop the locale-prefixed copies and keep the
+            // shape the fixture has without them: a dynamic SSG page, an SSR page with
+            // its data output, two API routes.
+            const { entries, options } = fixtureRoutes(pages_i18n_json_1.default);
+            const locale = /^\/(?:_next\/data\/[^/]+\/)?(?:en-US|fr|nl-NL)(?:\/|$)/;
+            const unlocalized = entries.filter((entry) => !locale.test(entry.template));
+            const { templates, behaviors } = (0, function_groups_1.assignRoutesToGroups)([
+                { name: "blog", routes: ["/blog/**"] },
+                { name: "ssr", routes: ["/ssr"] },
+            ], unlocalized, options);
+            expect(templates.blog).toEqual(["/blog/[slug]"]);
+            expect(templates.ssr).toEqual([
+                `/_next/data/${options.buildId}/ssr.json`,
+                "/ssr",
+            ]);
+            expect(behaviors.filter(({ pattern }) => pattern.startsWith("_next/data/"))).toEqual([
+                {
+                    group: "ssr",
+                    route: "/ssr",
+                    pattern: `_next/data/${options.buildId}/ssr.json`,
+                },
+                {
+                    group: "blog",
+                    route: "/blog/**",
+                    pattern: `_next/data/${options.buildId}/blog/*`,
+                },
+            ]);
+        });
+    });
+    describe("an optional catch-all's parent (B)", () => {
+        it("routes the parent URL with the subtree that moved the file", () => {
+            const { entries, options } = fixtureRoutes(app_playground_json_1.default);
+            const groups = [{ name: "params", routes: ["/params/optional/**"] }];
+            const { templates, behaviors } = (0, function_groups_1.assignRoutesToGroups)(groups, entries, options);
+            expect(templates.params).toContain("/params/optional/[[...rest]]");
+            // `params/optional/*` does not match `/params/optional`, which the same
+            // file serves, so it gets an exact behavior of its own.
+            expect(behaviors).toEqual([
+                {
+                    group: "params",
+                    route: "/params/optional",
+                    pattern: "params/optional",
+                },
+                {
+                    group: "params",
+                    route: "/params/optional/**",
+                    pattern: "params/optional/*",
+                },
+            ]);
+        });
+        it("points the old exact-pattern workaround at the subtree", () => {
+            const { entries, options } = fixtureRoutes(app_playground_json_1.default);
+            expect(() => (0, function_groups_1.assignRoutesToGroups)([{ name: "params", routes: ["/params/optional"] }], entries, options)).toThrow(/served by the optional catch-all "\/params\/optional\/\[\[\.\.\.rest\]\]", whose subtree pattern "\/params\/optional\/\*\*" routes "\/params\/optional" as well/);
+        });
+        it("works under a basePath too", () => {
+            const assigned = assign([{ name: "shop", routes: ["/shop/**"] }], routes("/base/shop/[[...slug]]", "/base"), "/base");
+            expect(assigned.shop).toEqual(["/base/shop/[[...slug]]"]);
+            expect((0, function_groups_1.routedPatterns)(["/shop/**"], assigned.shop, "base")).toEqual([
+                "/shop/**",
+                "/shop",
+            ]);
+        });
+        it("routes a Pages Router optional catch-all's parent data URL", () => {
+            // `/_next/data/<id>/shop.json` belongs to the same file, and the exact
+            // `/shop` pattern `routedPatterns` adds carries it.
+            const assigned = assign([{ name: "shop", routes: ["/shop/**"] }], [
+                {
+                    template: "/shop/[[...slug]]",
+                    entrypointId: "pages/shop/[[...slug]].js",
+                    type: "page",
+                },
+            ]);
+            expect(assigned.shop).toEqual(["/shop/[[...slug]]"]);
+        });
+    });
+    describe("one file behind several templates (C)", () => {
+        // `app/[locale]/page.tsx` with root params: `/en` and `/de` are synthesized
+        // from one output, alongside its own `/[locale]` template.
+        const rootParams = [
+            "/[locale]",
+            "/[locale].rsc",
+            "/en",
+            "/en.rsc",
+            "/de",
+            "/de.rsc",
+        ].map((template) => ({
+            template,
+            entrypointId: "app/[locale]/page.js",
+            type: "app-page",
+        }));
+        it("rejects a pattern that moves the file for one of its URLs", () => {
+            // Only `en` got a behavior, so `/de` reached the default function, which
+            // no longer had the file.
+            expect(() => assign([{ name: "intl", routes: ["/en"] }], rootParams)).toThrow(/"app\/\[locale\]\/page\.js" is packaged into group "intl", but CloudFront would send "\/\[locale\]" to the "default" group, "\/de" to the "default" group/);
+            // And says the file cannot be grouped at all: `/[locale]` would need `/**`.
+            expect(() => assign([{ name: "intl", routes: ["/en", "/de"] }], rootParams)).toThrow(/"\/\[locale\]" cannot be routed to any group/);
+        });
+        it("suggests the pattern that covers a static template it left behind", () => {
+            const shared = [
+                { template: "/about", entrypointId: "shared.js" },
+                { template: "/team", entrypointId: "shared.js" },
+            ];
+            expect(() => assign([{ name: "m", routes: ["/about"] }], shared)).toThrow(/Add "\/team" to group "m"'s routes/);
+            expect(assign([{ name: "m", routes: ["/about", "/team"] }], shared).m).toEqual(["/about", "/team"]);
+        });
+        it("checks the trailingSlash form, which exact patterns route", () => {
+            const assigned = assign([{ name: "p", routes: ["/pricing"] }], routes("/pricing"), "", { trailingSlash: true });
+            expect(assigned.p).toEqual(["/pricing"]);
+        });
+        it("puts an exact trailingSlash form ahead of a subtree it sits at the base of", () => {
+            // `a/b/` and `a/b/*` have the same literal depth; were the subtree first
+            // it would take `/a/b/` from group x.
+            const assigned = assign([
+                { name: "x", routes: ["/a/b"] },
+                { name: "y", routes: ["/a/b/**"] },
+            ], routes("/", "/a/b", "/a/b/[id]"), "", { trailingSlash: true });
+            expect(assigned.x).toEqual(["/a/b"]);
+            expect(assigned.y).toEqual(["/a/b/[id]"]);
+        });
+        it("gives a group without Pages Router routes no data URL behaviors", () => {
+            // An App Router `/index` next to a Pages Router home page: a data behavior
+            // for the group, `_next/data/<id>/index.json`, would be the home page's
+            // data URL. The group owns no page, so it gets none.
+            expect(assign([{ name: "idx", routes: ["/index"] }], [
+                { template: "/", entrypointId: "pages/index.js", type: "page" },
+                {
+                    template: "/index",
+                    entrypointId: "app/index/page.js",
+                    type: "app-page",
+                },
+            ]).idx).toEqual(["/index"]);
+        });
+        it("rejects a group pattern claiming a data URL of a file left in default", () => {
+            // The same collision in a group that does own a page.
+            expect(() => assign([{ name: "idx", routes: ["/index", "/legacy"] }], [
+                { template: "/", entrypointId: "pages/index.js", type: "page" },
+                {
+                    template: "/index",
+                    entrypointId: "app/index/page.js",
+                    type: "app-page",
+                },
+                {
+                    template: "/legacy",
+                    entrypointId: "pages/legacy.js",
+                    type: "page",
+                },
+            ])).toThrow(/"pages\/index\.js" is packaged into the "default" group, but CloudFront would send "\/_next\/data\/abc123\/index\.json" to group "idx"/);
+        });
+    });
+    describe("interception routes (D)", () => {
+        const photoApp = () => [
+            { template: "/feed", entrypointId: "app/feed/page.js", type: "app-page" },
+            {
+                template: "/feed/(..)photo/[id]",
+                entrypointId: "app/feed/(..)photo/[id]/page.js",
+                type: "app-page",
+            },
+            {
+                template: "/feed/(..)photo/[id].rsc",
+                entrypointId: "app/feed/(..)photo/[id]/page.js",
+                type: "app-page",
+            },
+            {
+                template: "/photo/[id]",
+                entrypointId: "app/photo/[id]/page.js",
+                type: "app-page",
+            },
+        ];
+        it("packages an intercepting file with the URL it intercepts", () => {
+            // The soft navigation requests `/photo/1`, which CloudFront sends to the
+            // default function; Next.js rewrites it there to the intercepting file.
+            const assigned = assign([{ name: "feed", routes: ["/feed/**"] }], [
+                ...photoApp(),
+                { template: "/feed/[post]", entrypointId: "app/feed/[post]/page.js" },
+            ]);
+            expect(assigned.feed).toEqual(["/feed/[post]"]);
+            expect(assigned[function_groups_1.DEFAULT_FUNCTION_GROUP]).toContain("/feed/(..)photo/[id]");
+            expect(assigned[function_groups_1.DEFAULT_FUNCTION_GROUP]).toContain("/feed/(..)photo/[id].rsc");
+        });
+        it("follows the intercepted route into its group", () => {
+            const assigned = assign([{ name: "photos", routes: ["/photo/**"] }], photoApp());
+            expect(assigned.photos).toEqual([
+                "/feed/(..)photo/[id]",
+                "/feed/(..)photo/[id].rsc",
+                "/photo/[id]",
+            ]);
+        });
+        it("throws when the intercepted URL space is split between groups", () => {
+            expect(() => assign([{ name: "one", routes: ["/photo/1"] }], [
+                ...photoApp(),
+                { template: "/photo/1", entrypointId: "app/photo/1/page.js" },
+            ])).toThrow(/interception route "\/feed\/\(\.\.\)photo\/\[id\]".*group "one"'s pattern "\/photo\/1" claims part of it/s);
+        });
+        it.each([
+            ["/feed/(..)photo/[id]", "/photo/[id]"],
+            ["/feed/(.)photo/[id]", "/feed/photo/[id]"],
+            ["/(.)photo/[id]", "/photo/[id]"],
+            ["/a/b/(..)(..)photo", "/photo"],
+            ["/a/b/(...)photo", "/photo"],
+            ["/photo/[id]", undefined],
+        ])("resolves %p to the route it intercepts, %p", (path, expected) => {
+            expect((0, function_groups_1.interceptedRoute)(path)).toBe(expected);
+        });
+    });
+    describe("next.config rewrites (D)", () => {
+        it("rejects a rewrite whose source and destination land in different groups", () => {
+            // app-playground rewrites `/e2e/rewrite/:path(.*)` to `/e2e/rewrite/echo`.
+            // Grouping only the destination leaves the source on the default
+            // function, which then rewrites to a file it does not have.
+            const { entries, options } = fixtureRoutes(app_playground_json_1.default);
+            expect(() => (0, function_groups_1.assignRoutesToGroups)([{ name: "echo", routes: ["/e2e/rewrite/echo"] }], entries, options)).toThrow(/rewrite from "\/e2e\/rewrite\/:path\(\.\*\)" to "\/e2e\/rewrite\/echo\?.*" crosses groups: CloudFront sends "\/e2e\/rewrite\/\[path\]" to the "default" group, and Next\.js then serves it with ".*echo\/page\.js", which is packaged into group "echo"/);
+            // Both ends in one group is fine.
+            expect((0, function_groups_1.assignRoutesToGroups)([{ name: "e2e", routes: ["/e2e/rewrite/**"] }], entries, options).templates.e2e).toContain("/e2e/rewrite/echo");
+        });
+        it("resolves a destination through Next.js's dynamic route rules", () => {
+            const routing = {
+                beforeFiles: [{ source: "/old", destination: "/blog/hello" }],
+                dynamicRoutes: [
+                    {
+                        sourceRegex: "^/blog/([^/]+?)(?:/)?$",
+                        destination: "/blog/[slug]",
+                    },
+                ],
+            };
+            expect(() => assign([{ name: "blog", routes: ["/blog/**"] }], routes("/blog/[slug]"), "", {
+                routing,
+            })).toThrow(/CloudFront sends "\/old" to the "default" group/);
+        });
+        it("skips an afterFiles source a route already serves, and parameterized destinations", () => {
+            const routing = {
+                // Never applied: `/pricing` is a route, and afterFiles yields to it.
+                afterFiles: [{ source: "/pricing", destination: "/blog/x" }],
+                // Not resolvable at synth.
+                beforeFiles: [{ source: "/b/:slug", destination: "/blog/:slug" }],
+            };
+            expect(() => assign([{ name: "blog", routes: ["/blog/**"] }], routes("/blog/x", "/pricing"), "", { routing })).not.toThrow();
+        });
+        it("checks the path an optional parameter leaves", () => {
+            const routing = {
+                beforeFiles: [{ source: "/docs/:path*", destination: "/docs-app" }],
+            };
+            expect(() => assign([{ name: "docs", routes: ["/docs/**", "/docs-app"] }], routes("/docs-app", "/docs/[page]"), "", { routing })).toThrow(/CloudFront sends "\/docs" to the "default" group/);
+        });
+    });
+    describe("a dynamic route's URL space (E)", () => {
+        it("rejects a subtree capturing URLs a default-group catch-all serves", () => {
+            // `/blog/[slug]` only matches one segment, so `/blog/a/b` reaches the
+            // blog function via `blog/*` and resolves there to `/[...slug]`, which
+            // the blog zip lacks. The template text itself never matched `blog/*`.
+            expect(() => assign([{ name: "blog", routes: ["/blog/**"] }], routes("/", "/[...slug]", "/blog/[slug]"))).toThrow(/"\/\[\.\.\.slug\]" is packaged into the "default" group, but CloudFront would send "\/blog\/_\/_" to group "blog" \(its pattern "\/blog\/\*\*"\).*dynamic route "\/\[\.\.\.slug\]"/s);
+        });
+        it("checks under a basePath too", () => {
+            expect(() => assign([{ name: "blog", routes: ["/blog/**"] }], routes("/base", "/base/[...slug]", "/base/blog/[slug]"), "/base")).toThrow(/CloudFront would send "\/base\/blog\/_\/_" to group "blog"/);
+        });
+        it("accepts the capture when the group's own routes shadow every URL of it", () => {
+            // A more specific route in the capturing group wins inside Next.js, so
+            // with `/blog/[...rest]` there nothing under `/blog/` resolves to the
+            // root catch-all.
+            const assigned = assign([{ name: "blog", routes: ["/blog/**"] }], routes("/", "/[...slug]", "/blog/[slug]", "/blog/[...rest]"));
+            expect(assigned[function_groups_1.DEFAULT_FUNCTION_GROUP]).toEqual(["/", "/[...slug]"]);
+            expect(assigned.blog).toEqual(["/blog/[...rest]", "/blog/[slug]"]);
+        });
+        it("accepts a single-segment root param, which never reaches under a subtree", () => {
+            const assigned = assign([{ name: "blog", routes: ["/blog/**"] }], routes("/", "/[slug]", "/blog/[slug]"));
+            expect(assigned[function_groups_1.DEFAULT_FUNCTION_GROUP]).toEqual(["/", "/[slug]"]);
+        });
+        it("rejects the trailingSlash form of a subtree's base that a root param serves", () => {
+            // `/blog/` matches `blog/*`, and with no `/blog` page Next.js serves it
+            // with `/[slug]`.
+            expect(() => assign([{ name: "blog", routes: ["/blog/**"] }], routes("/", "/[slug]", "/blog/[slug]"), "", { trailingSlash: true })).toThrow(/CloudFront would send "\/blog\/" to group "blog"/);
+        });
+        it("lets a static first segment in the group outrank a param in a later one", () => {
+            // `/blog/settings` reaches the blog function; `/blog/[slug]` beats
+            // `/[team]/settings` there, static first segment before dynamic.
+            expect(() => assign([{ name: "blog", routes: ["/blog/**"] }], routes("/", "/[team]/settings", "/blog/[slug]"))).not.toThrow();
+            // Without it, `/[team]/settings` is what Next.js resolves it to.
+            expect(() => assign([{ name: "blog", routes: ["/blog/**"] }], routes("/", "/[team]/settings", "/blog/x"))).toThrow(/"\/blog\/settings" to group "blog"/);
+        });
+        it("checks a root optional catch-all against subtree and exact patterns", () => {
+            expect(() => assign([{ name: "docs", routes: ["/docs/**"] }], routes("/[[...slug]]", "/docs/[page]"))).toThrow(/"\/docs\/_\/_" to group "docs"/);
+            // An exact pattern owns a static route, which Next.js prefers.
+            expect(assign([{ name: "about", routes: ["/about"] }], routes("/[[...slug]]", "/about")).about).toEqual(["/about"]);
+        });
+        it("checks a grouped catch-all against a narrower group's subtree", () => {
+            // `/api/reports/1/2` reaches the reports function, which only has
+            // `/api/reports/[id]`; Next.js resolves it to `/api/[...rest]`.
+            expect(() => assign([
+                { name: "api", routes: ["/api/**"] },
+                { name: "reports", routes: ["/api/reports/**"] },
+            ], routes("/api/[...rest]", "/api/reports/[id]"))).toThrow(/"\/api\/\[\.\.\.rest\]" is packaged into group "api", but CloudFront would send "\/api\/reports\/_\/_" to group "reports"/);
+        });
+        it("checks a Pages Router catch-all's data URLs", () => {
+            const page = (template, file) => [
+                { template, entrypointId: file, type: "page" },
+                {
+                    template: `/_next/data/${BUILD_ID}${template}.json`,
+                    entrypointId: file,
+                    type: "page",
+                },
+            ];
+            expect(() => assign([{ name: "blog", routes: ["/blog/**"] }], [
+                ...page("/[...slug]", "pages/[...slug].js"),
+                ...page("/blog/[slug]", "pages/blog/[slug].js"),
+            ])).toThrow(/"\/_next\/data\/abc123\/blog\/_\/_\.json" to group "blog"/);
+        });
+    });
+    describe("/index (G)", () => {
+        it("groups an App Router /index, a route of its own", () => {
+            const assigned = assign([{ name: "idx", routes: ["/index"] }], [
+                { template: "/", entrypointId: "app/page.js", type: "app-page" },
+                {
+                    template: "/index.rsc",
+                    entrypointId: "app/page.js",
+                    type: "app-page",
+                },
+                {
+                    template: "/index",
+                    entrypointId: "app/index/page.js",
+                    type: "app-page",
+                },
+            ]);
+            expect(assigned.idx).toEqual(["/index"]);
+        });
+        it("rejects the Pages Router home page, which is also /", () => {
+            expect(() => assign([{ name: "idx", routes: ["/index"] }], ["/", "/index", `/_next/data/${BUILD_ID}/index.json`].map((template) => ({
+                template,
+                entrypointId: "pages/index.js",
+                type: "page",
+            })))).toThrow(/"\/" cannot be routed to any group.*"\/index": one file/s);
+        });
+    });
+});
+describe("routedPatterns", () => {
+    it("adds nothing for a group without an optional catch-all at a subtree's base", () => {
+        expect((0, function_groups_1.routedPatterns)(["/blog/**", "/pricing"], ["/blog/[slug]", "/blog/x/[[...rest]]", "/pricing"], "")).toEqual(["/blog/**", "/pricing"]);
+    });
+    it("does not repeat a parent the group already declares", () => {
+        expect((0, function_groups_1.routedPatterns)(["/shop/**", "/shop"], ["/shop/[[...slug]]"], "")).toEqual(["/shop/**", "/shop"]);
+    });
+});
+describe("pathPatternsFor", () => {
+    it("drops the leading slash, because the distribution adds basePath itself", () => {
+        expect((0, function_groups_1.pathPatternsFor)("/pricing", { hasDataRoutes: false })).toEqual([
+            "pricing",
+        ]);
+    });
+    it("turns a subtree into a single trailing wildcard", () => {
+        expect((0, function_groups_1.pathPatternsFor)("/api/reports/**", { hasDataRoutes: false })).toEqual(["api/reports/*"]);
+    });
+    it("adds the `_next/data` URL space for Pages Router groups, on the literal build ID", () => {
+        // A `*` for the build ID also matches `/`, so `_next/data/*/blog/*` claimed
+        // `/_next/data/<id>/docs/blog/x.json`, a page of another group.
+        const options = { hasDataRoutes: true, buildId: BUILD_ID };
+        expect((0, function_groups_1.pathPatternsFor)("/blog/**", options)).toEqual([
+            "blog/*",
+            "_next/data/abc123/blog/*",
+        ]);
+        expect((0, function_groups_1.pathPatternsFor)("/pricing", options)).toEqual([
+            "pricing",
+            "_next/data/abc123/pricing.json",
+        ]);
+    });
+    it("refuses to route data URLs without the build ID", () => {
+        expect(() => (0, function_groups_1.pathPatternsFor)("/blog/**", { hasDataRoutes: true })).toThrow(/needs its build ID/);
+    });
+    it("refuses a build ID a path pattern cannot hold", () => {
+        // `generateBuildId` can return anything.
+        expect(() => (0, function_groups_1.pathPatternsFor)("/blog/**", { hasDataRoutes: true, buildId: "v1/2 3" })).toThrow(/The build ID "v1\/2 3" contains "\/", " "/);
+    });
+    it("adds the trailing-slash form for a trailingSlash app", async () => {
+        // With `trailingSlash: true` the canonical URL is `/pricing/`, and that is
+        // what every link in the app points at. A behavior on `pricing` alone does
+        // not match it, so the request fell through to the default function - which
+        // does not have the route packaged.
+        expect((0, function_groups_1.pathPatternsFor)("/pricing", { hasDataRoutes: false })).toEqual([
+            "pricing",
+        ]);
+        expect((0, function_groups_1.pathPatternsFor)("/pricing", {
+            hasDataRoutes: false,
+            trailingSlash: true,
+        })).toEqual(["pricing", "pricing/"]);
+    });
+    it("leaves a subtree pattern alone, which already matches both forms", () => {
+        expect((0, function_groups_1.pathPatternsFor)("/api/reports/**", {
+            hasDataRoutes: false,
+            trailingSlash: true,
+        })).toEqual(["api/reports/*"]);
+    });
+});
+describe("parseFunctionGroupsEnv", () => {
+    it("returns undefined when unset", () => {
+        expect((0, function_groups_1.parseFunctionGroupsEnv)(undefined)).toBeUndefined();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"function-groups.test.js","sourceRoot":"","sources":["../../src/adapter/function-groups.test.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\nimport { getNamedRouteRegex } from \"next/dist/shared/lib/router/utils/route-regex\";\nimport {\n  getSortedRouteObjects,\n  getSortedRoutes,\n} from \"next/dist/shared/lib/router/utils/sorted-routes\";\nimport appPlayground from \"./__fixtures__/app-playground.json\";\nimport pagesI18n from \"./__fixtures__/pages-i18n.json\";\nimport { BuildCompleteContext, buildAdapterManifest } from \"./build-outputs\";\nimport {\n  AssignRoutesOptions,\n  DEFAULT_FUNCTION_GROUP,\n  FunctionGroupSpec,\n  RouteEntry,\n  RoutingRules,\n  assignRoutesToGroups,\n  interceptedRoute,\n  parseFunctionGroupsEnv,\n  pathPatternsFor,\n  routedPatterns,\n  validateFunctionGroups,\n} from \"./function-groups\";\n\n/** One entrypoint per template unless a test says otherwise. */\nconst routes = (...templates: string[]): RouteEntry[] =>\n  templates.map((template) => ({ template, entrypointId: template }));\n\nconst BUILD_ID = \"abc123\";\n\n/**\n * `ctx.routing.dynamicRoutes` as `next build` derives it from `entries`: Next's\n * own route sort and regexes, data URLs included.\n */\nfunction nextRouting(entries: RouteEntry[], basePath: string): RoutingRules {\n  const dataPrefix = `${basePath}/_next/data/${BUILD_ID}/`;\n  const dynamic = [...new Set(entries.map((entry) => entry.template))].filter(\n    (template) =>\n      template.includes(\"[\") &&\n      !template.endsWith(\".rsc\") &&\n      !/\\(\\.{1,3}\\)/.test(template),\n  );\n  const route = (template: string) => ({\n    sourceRegex: getNamedRouteRegex(template, {\n      prefixRouteKeys: true,\n      includeSuffix: true,\n    }).namedRegex,\n    destination: template,\n  });\n  return {\n    dynamicRoutes: [\n      // Sorted by the page they name: Next's sort reads `[slug].json` as static.\n      ...getSortedRouteObjects(\n        dynamic.filter((template) => template.startsWith(dataPrefix)),\n        (template) => `/${template.slice(dataPrefix.length, -\".json\".length)}`,\n      ).map(route),\n      ...getSortedRoutes(\n        dynamic.filter((template) => !template.startsWith(dataPrefix)),\n      ).map(route),\n    ],\n  };\n}\n\nconst assignment = (\n  groups: FunctionGroupSpec[],\n  entries: RouteEntry[],\n  basePath = \"\",\n  options: Partial<AssignRoutesOptions> = {},\n) =>\n  assignRoutesToGroups(groups, entries, {\n    basePath,\n    buildId: BUILD_ID,\n    ...options,\n    routing: { ...nextRouting(entries, basePath), ...options.routing },\n  });\n\nconst assign = (...args: Parameters<typeof assignment>) =>\n  assignment(...args).templates;\n\n/** The path patterns of the behaviors the assignment returns, in order. */\nconst patternsOf = (...args: Parameters<typeof assignment>) =>\n  assignment(...args).behaviors.map(({ pattern }) => pattern);\n\n/**\n * A captured `onBuildComplete` fixture's routes, exactly as `buildAdapterManifest`\n * hands them to the assignment, plus the rest of what it passes.\n */\nfunction fixtureRoutes(fixture: unknown) {\n  const ctx = structuredClone(fixture) as BuildCompleteContext;\n  const warn = jest.spyOn(console, \"warn\").mockImplementation(() => {});\n  const { manifest } = buildAdapterManifest(ctx, { buildCwd: ctx.projectDir });\n  warn.mockRestore();\n  const entries: RouteEntry[] = Object.entries(manifest.entrypoints).map(\n    ([template, entrypoint]) => ({\n      template,\n      entrypointId: entrypoint.filePath,\n      type: entrypoint.type,\n    }),\n  );\n  return {\n    entries,\n    options: {\n      basePath: ctx.config.basePath || \"\",\n      buildId: ctx.buildId,\n      trailingSlash: ctx.config.trailingSlash === true,\n      routing: ctx.routing,\n    } as AssignRoutesOptions,\n  };\n}\n\ndescribe(\"validateFunctionGroups\", () => {\n  it(\"rejects an empty array rather than treating it as no splitting\", () => {\n    expect(() => validateFunctionGroups([])).toThrow(/Omit the prop entirely/);\n  });\n\n  it(\"reserves the default group name\", () => {\n    expect(() =>\n      validateFunctionGroups([{ name: \"default\", routes: [\"/a\"] }]),\n    ).toThrow(/reserved group name/);\n  });\n\n  it.each([[\"has space\"], [\"under_score\"], [\"dots.here\"], [\"\"]])(\n    \"rejects group name %p, which has to be a construct id\",\n    (name) => {\n      expect(() => validateFunctionGroups([{ name, routes: [\"/a\"] }])).toThrow(\n        /must match/,\n      );\n    },\n  );\n\n  it(\"rejects two groups with the same name\", () => {\n    expect(() =>\n      validateFunctionGroups([\n        { name: \"api\", routes: [\"/a\"] },\n        { name: \"api\", routes: [\"/b\"] },\n      ]),\n    ).toThrow(/both named \"api\"/);\n  });\n\n  it(\"rejects a group that owns no routes\", () => {\n    expect(() => validateFunctionGroups([{ name: \"api\", routes: [] }])).toThrow(\n      /owns no routes/,\n    );\n  });\n\n  it(\"rejects the same pattern in two groups\", () => {\n    expect(() =>\n      validateFunctionGroups([\n        { name: \"a\", routes: [\"/api/**\"] },\n        { name: \"b\", routes: [\"/api/**\"] },\n      ]),\n    ).toThrow(/appears in both group \"a\" and group \"b\"/);\n  });\n\n  it(\"allows overlapping-but-different patterns, which resolve longest-first\", () => {\n    expect(() =>\n      validateFunctionGroups([\n        { name: \"a\", routes: [\"/api/**\"] },\n        { name: \"b\", routes: [\"/api/reports/**\"] },\n      ]),\n    ).not.toThrow();\n  });\n\n  it(\"requires a leading slash\", () => {\n    expect(() =>\n      validateFunctionGroups([{ name: \"a\", routes: [\"api/**\"] }]),\n    ).toThrow(/must start with \"\\/\"/);\n  });\n\n  it.each([[\"/dashboard/[id]\"], [\"/blog/[...slug]\"], [\"/shop/[[...slug]]\"]])(\n    \"rejects the dynamic segment in %p, which CloudFront cannot express\",\n    (route) => {\n      expect(() =>\n        validateFunctionGroups([{ name: \"a\", routes: [route] }]),\n      ).toThrow(/contains a dynamic segment/);\n    },\n  );\n\n  it(\"rejects a route group segment, which never appears in a URL\", () => {\n    expect(() =>\n      validateFunctionGroups([{ name: \"a\", routes: [\"/(marketing)/about\"] }]),\n    ).toThrow(/route group segment/);\n  });\n\n  it.each([[\"/api/*\"], [\"/api/**/x\"], [\"/api/repo?ts\"], [\"/*\"]])(\n    \"rejects the wildcard placement in %p\",\n    (route) => {\n      expect(() =>\n        validateFunctionGroups([{ name: \"a\", routes: [route] }]),\n      ).toThrow(/wildcard somewhere other than a trailing/);\n    },\n  );\n\n  it(\"rejects a pattern that would own everything\", () => {\n    expect(() =>\n      validateFunctionGroups([{ name: \"a\", routes: [\"/**\"] }]),\n    ).toThrow(/would own every route/);\n  });\n\n  it(\"rejects the root, which no CloudFront path pattern can match alone\", () => {\n    expect(() =>\n      validateFunctionGroups([{ name: \"a\", routes: [\"/\"] }]),\n    ).toThrow(/cannot be routed/);\n  });\n\n  it(\"accepts /index, which is a real App Router route\", () => {\n    // `app/index/page.tsx` is served at `/index`, apart from `/`. Only the\n    // assignment knows which router `/index` came from; it rejects the Pages\n    // Router home page, which is the same file as `/`.\n    expect(() =>\n      validateFunctionGroups([{ name: \"a\", routes: [\"/index\"] }]),\n    ).not.toThrow();\n  });\n\n  it.each([\"/_next\", \"/_next/**\", \"/_next/data/**\"])(\n    \"rejects %s, which Next.js reserves\",\n    (route) => {\n      // A data route follows its page into the page's group; a `_next/*`\n      // behavior would compete with the static-asset and image behaviors.\n      expect(() =>\n        validateFunctionGroups([{ name: \"a\", routes: [route] }]),\n      ).toThrow(/under \"\\/_next\"/);\n    },\n  );\n\n  it(\"rejects an empty path segment\", () => {\n    expect(() =>\n      validateFunctionGroups([{ name: \"a\", routes: [\"/api//x\"] }]),\n    ).toThrow(/empty path segment/);\n  });\n\n  it.each([\n    [\"/über\", '\"ü\"'],\n    [\"/a b\", '\" \"'],\n    [\"/shop/a,b/**\", '\",\"'],\n    [\"/100%25\", '\"%\"'],\n  ])(\n    \"rejects %p, which holds a character no CloudFront path pattern can\",\n    (route, char) => {\n      // `pathPatternsFor` copies the route verbatim into a behavior path\n      // pattern, so without this it failed at deploy naming neither the group\n      // nor the route.\n      expect(() =>\n        validateFunctionGroups([{ name: \"a\", routes: [route] }]),\n      ).toThrow(`contains ${char}, which a CloudFront behavior path pattern`);\n    },\n  );\n\n  it(\"accepts every literal in CloudFront's path pattern alphabet\", () => {\n    expect(() =>\n      validateFunctionGroups([\n        {\n          name: \"a\",\n          routes: [`/AZaz09_-.$~\"'@:+&/**`],\n        },\n      ]),\n    ).not.toThrow();\n  });\n});\n\ndescribe(\"assignRoutesToGroups\", () => {\n  it(\"puts unassigned routes in the default group, which always exists\", () => {\n    const assigned = assign(\n      [{ name: \"api\", routes: [\"/api/**\"] }],\n      routes(\"/\", \"/pricing\", \"/api/health\"),\n    );\n    expect(assigned).toEqual({\n      [DEFAULT_FUNCTION_GROUP]: [\"/\", \"/pricing\"],\n      api: [\"/api/health\"],\n    });\n  });\n\n  it(\"matches an exact pattern only exactly\", () => {\n    const assigned = assign(\n      [{ name: \"p\", routes: [\"/pricing\"] }],\n      routes(\"/pricing\", \"/pricing/enterprise\"),\n    );\n    expect(assigned.p).toEqual([\"/pricing\"]);\n    expect(assigned[DEFAULT_FUNCTION_GROUP]).toEqual([\"/pricing/enterprise\"]);\n  });\n\n  it(\"matches a subtree against the dynamic routes under it\", () => {\n    const assigned = assign(\n      [{ name: \"blog\", routes: [\"/blog/**\"] }],\n      routes(\"/blog/[slug]\", \"/blog/[slug]/comments\", \"/blogroll\"),\n    );\n    expect(assigned.blog).toEqual([\"/blog/[slug]\", \"/blog/[slug]/comments\"]);\n    expect(assigned[DEFAULT_FUNCTION_GROUP]).toEqual([\"/blogroll\"]);\n  });\n\n  it(\"does not let a subtree claim its own root, because the behavior would not\", () => {\n    // `/api/reports/**` deploys as CloudFront `api/reports/*`, which does not\n    // match `/api/reports`. Claiming it here would package the route into a\n    // function the edge never routes it to.\n    expect(() =>\n      assign(\n        [{ name: \"r\", routes: [\"/api/reports/**\"] }],\n        routes(\"/api/reports\"),\n      ),\n    ).toThrow(/matches no route in this build/);\n  });\n\n  it(\"gives the longest matching pattern the route\", () => {\n    const assigned = assign(\n      [\n        { name: \"api\", routes: [\"/api/**\"] },\n        { name: \"reports\", routes: [\"/api/reports/**\"] },\n      ],\n      routes(\"/api/health\", \"/api/reports/[id]\"),\n    );\n    expect(assigned.api).toEqual([\"/api/health\"]);\n    expect(assigned.reports).toEqual([\"/api/reports/[id]\"]);\n  });\n\n  it(\"ranks by segment count before string length\", () => {\n    // \"/a/b\" is deeper than \"/alongname\" even though it is shorter.\n    const assigned = assign(\n      [\n        { name: \"deep\", routes: [\"/a/b/**\"] },\n        { name: \"long\", routes: [\"/a/**\"] },\n      ],\n      routes(\"/a/b/c\", \"/a/x\"),\n    );\n    expect(assigned.deep).toEqual([\"/a/b/c\"]);\n    expect(assigned.long).toEqual([\"/a/x\"]);\n  });\n\n  it(\"throws on a pattern that matches nothing, because the typo is invisible\", () => {\n    expect(() =>\n      assign(\n        [{ name: \"api\", routes: [\"/api/**\", \"/apy/**\"] }],\n        routes(\"/api/x\"),\n      ),\n    ).toThrow(/pattern \"\\/apy\\/\\*\\*\" matches no route/);\n  });\n\n  it(\"accepts a pattern every match of which a narrower pattern also claims\", () => {\n    // `/api/**` never wins a route here, because every API route this build has\n    // is under `/api/reports/`. Recording only the *winning* pattern made it look\n    // like a typo and threw - rejecting the exact layout the duplicate-pattern\n    // error documents as supported. The group is legitimately empty: it is the\n    // consumer's choice to keep it for the routes it will own later.\n    const assigned = assign(\n      [\n        { name: \"api\", routes: [\"/api/**\"] },\n        { name: \"reports\", routes: [\"/api/reports/**\"] },\n      ],\n      routes(\"/api/reports/[id]\", \"/api/reports/summary\"),\n    );\n    expect(assigned.api).toEqual([]);\n    expect(assigned.reports).toEqual([\n      \"/api/reports/[id]\",\n      \"/api/reports/summary\",\n    ]);\n  });\n\n  it(\"gives a shared entrypoint to its most specific match, not its last one\", () => {\n    // Two templates, one file, two groups whose patterns both match - one\n    // narrowly, one broadly. Ownership used to be last-write-wins over `entries`,\n    // so the same build grouped differently depending on manifest key order.\n    const entries: RouteEntry[] = [\n      // Matched only by the broad pattern.\n      { template: \"/api/health\", entrypointId: \"shared\" },\n      // Matched by both; the narrow one wins.\n      { template: \"/api/reports/summary\", entrypointId: \"shared\" },\n    ];\n    const groups: FunctionGroupSpec[] = [\n      { name: \"api\", routes: [\"/api/**\"] },\n      { name: \"reports\", routes: [\"/api/reports/**\"] },\n    ];\n    // `/api/reports/**` is the most specific claim any of the entrypoint's\n    // templates has, so it takes the whole entrypoint — and then the edge still\n    // sends `/api/health` to the api group, which lacks the file. That used to\n    // deploy and 500; it is the coverage check's to reject, identically in both\n    // orders.\n    const message =\n      /\"\\/api\\/health\" to group \"api\" \\(its pattern \"\\/api\\/\\*\\*\"\\)/;\n    expect(() => assign(groups, entries)).toThrow(message);\n    expect(() => assign(groups, [...entries].reverse())).toThrow(message);\n    expect(() => assign(groups, entries)).toThrow(\n      /Add \"\\/api\\/health\" to group \"reports\"'s routes/,\n    );\n    // Which is the fix: the exact pattern beats the api subtree at the edge.\n    const fixed = assign(\n      [\n        groups[0],\n        { name: \"reports\", routes: [\"/api/reports/**\", \"/api/health\"] },\n      ],\n      entries,\n    );\n    expect(fixed.reports).toEqual([\"/api/health\", \"/api/reports/summary\"]);\n    expect(fixed.api).toEqual([]);\n  });\n\n  it(\"prefixes basePath before matching, since manifest templates carry it\", () => {\n    const assigned = assign(\n      [{ name: \"api\", routes: [\"/api/**\"] }],\n      routes(\"/prod/api/health\", \"/prod/pricing\"),\n      \"/prod\",\n    );\n    expect(assigned.api).toEqual([\"/prod/api/health\"]);\n    expect(assigned[DEFAULT_FUNCTION_GROUP]).toEqual([\"/prod/pricing\"]);\n  });\n\n  it(\"keeps two templates sharing one entrypoint in the same group\", () => {\n    // A Pages Router page and its `/_next/data/<buildId>/…json` sibling are one\n    // file; splitting them would stage it twice and misroute one of them.\n    const assigned = assign(\n      [{ name: \"blog\", routes: [\"/blog/**\"] }],\n      [\n        {\n          template: \"/blog/[slug]\",\n          entrypointId: \"pages/blog/[slug]\",\n          type: \"page\",\n        },\n        {\n          template: \"/_next/data/abc123/blog/[slug].json\",\n          entrypointId: \"pages/blog/[slug]\",\n          type: \"page\",\n        },\n        { template: \"/\", entrypointId: \"pages/index\", type: \"page\" },\n      ],\n    );\n    expect(assigned.blog).toEqual([\n      \"/_next/data/abc123/blog/[slug].json\",\n      \"/blog/[slug]\",\n    ]);\n    expect(assigned[DEFAULT_FUNCTION_GROUP]).toEqual([\"/\"]);\n  });\n\n  it(\"returns every group even when a group ends up with only the default's leftovers\", () => {\n    const assigned = assign(\n      [{ name: \"api\", routes: [\"/api/**\"] }],\n      routes(\"/api/health\"),\n    );\n    expect(Object.keys(assigned).sort()).toEqual([\"api\", \"default\"]);\n    expect(assigned[DEFAULT_FUNCTION_GROUP]).toEqual([]);\n  });\n\n  it(\"sorts each group's templates so the manifest is byte-stable\", () => {\n    const assigned = assign(\n      [{ name: \"api\", routes: [\"/api/**\"] }],\n      routes(\"/api/z\", \"/api/a\", \"/z\", \"/a\"),\n    );\n    expect(assigned.api).toEqual([\"/api/a\", \"/api/z\"]);\n    expect(assigned[DEFAULT_FUNCTION_GROUP]).toEqual([\"/a\", \"/z\"]);\n  });\n});\n\ndescribe(\"the behaviors the assignment returns\", () => {\n  it(\"orders overlapping group patterns most specific first\", () => {\n    // CloudFront stops at the first matching behavior, so `api/*` ahead of\n    // `api/reports/*` would send every report request to the wrong function.\n    expect(\n      patternsOf(\n        [\n          { name: \"api\", routes: [\"/api/**\"] },\n          { name: \"reports\", routes: [\"/api/reports/**\"] },\n        ],\n        routes(\"/api/[x]\", \"/api/reports/[id]\"),\n      ),\n    ).toEqual([\"api/reports/*\", \"api/*\"]);\n  });\n\n  it(\"ranks by segment count before string length\", () => {\n    expect(\n      patternsOf(\n        [\n          { name: \"a\", routes: [\"/a/b/**\"] },\n          { name: \"b\", routes: [\"/averyverylongsegment/**\"] },\n        ],\n        routes(\"/a/b/[x]\", \"/averyverylongsegment/[x]\"),\n      ),\n    ).toEqual([\"a/b/*\", \"averyverylongsegment/*\"]);\n  });\n\n  it(\"puts an exact pattern ahead of a wildcard of the same depth\", () => {\n    // `a/*` and `a/b` are the same length and segment count; `a/*` first\n    // swallows `a/b`, sending group b's only route to group a's function.\n    expect(\n      patternsOf(\n        [\n          { name: \"a\", routes: [\"/a/**\"] },\n          { name: \"b\", routes: [\"/a/b\"] },\n        ],\n        routes(\"/a/b\", \"/a/[x]\"),\n      ),\n    ).toEqual([\"a/b\", \"a/*\"]);\n  });\n\n  it(\"adds data-URL behaviors only for the groups that own a Pages Router page\", () => {\n    // One legacy page must not double every group's behaviors.\n    expect(\n      patternsOf(\n        [\n          { name: \"blog\", routes: [\"/blog/**\"] },\n          { name: \"docs\", routes: [\"/docs/**\"] },\n        ],\n        [\n          {\n            template: \"/blog/[slug]\",\n            entrypointId: \"pages/blog/[slug].js\",\n            type: \"page\",\n          },\n          { template: \"/docs/[page]\", entrypointId: \"app/docs/[page]/page.js\" },\n        ],\n      ),\n    ).toEqual([\"_next/data/abc123/blog/*\", \"blog/*\", \"docs/*\"]);\n  });\n});\n\ndescribe(\"what the edge routes, checked against what was packaged\", () => {\n  describe(\"Pages Router data URLs (A)\", () => {\n    it(\"keeps a nested page's data URL in its own group\", () => {\n      // With `_next/data/*/blog/*`, CloudFront sent the docs group's\n      // `/_next/data/<id>/docs/blog/intro.json` to the blog function.\n      const page = (template: string, file: string): RouteEntry[] => [\n        { template, entrypointId: file, type: \"page\" },\n        {\n          template: `/_next/data/${BUILD_ID}${template}.json`,\n          entrypointId: file,\n          type: \"page\",\n        },\n      ];\n      const assigned = assign(\n        [\n          { name: \"blog\", routes: [\"/blog/**\"] },\n          { name: \"docs\", routes: [\"/docs/**\"] },\n        ],\n        [\n          ...page(\"/blog/[slug]\", \"pages/blog/[slug].js\"),\n          ...page(\"/docs/blog/[slug]\", \"pages/docs/blog/[slug].js\"),\n        ],\n      );\n      expect(assigned.docs).toEqual([\n        \"/_next/data/abc123/docs/blog/[slug].json\",\n        \"/docs/blog/[slug]\",\n      ]);\n    });\n\n    it(\"routes the pages-i18n fixture's page and data URLs together\", () => {\n      // Splitting refuses i18n, so drop the locale-prefixed copies and keep the\n      // shape the fixture has without them: a dynamic SSG page, an SSR page with\n      // its data output, two API routes.\n      const { entries, options } = fixtureRoutes(pagesI18n);\n      const locale = /^\\/(?:_next\\/data\\/[^/]+\\/)?(?:en-US|fr|nl-NL)(?:\\/|$)/;\n      const unlocalized = entries.filter(\n        (entry) => !locale.test(entry.template),\n      );\n      const { templates, behaviors } = assignRoutesToGroups(\n        [\n          { name: \"blog\", routes: [\"/blog/**\"] },\n          { name: \"ssr\", routes: [\"/ssr\"] },\n        ],\n        unlocalized,\n        options,\n      );\n      expect(templates.blog).toEqual([\"/blog/[slug]\"]);\n      expect(templates.ssr).toEqual([\n        `/_next/data/${options.buildId}/ssr.json`,\n        \"/ssr\",\n      ]);\n      expect(\n        behaviors.filter(({ pattern }) => pattern.startsWith(\"_next/data/\")),\n      ).toEqual([\n        {\n          group: \"ssr\",\n          route: \"/ssr\",\n          pattern: `_next/data/${options.buildId}/ssr.json`,\n        },\n        {\n          group: \"blog\",\n          route: \"/blog/**\",\n          pattern: `_next/data/${options.buildId}/blog/*`,\n        },\n      ]);\n    });\n  });\n\n  describe(\"an optional catch-all's parent (B)\", () => {\n    it(\"routes the parent URL with the subtree that moved the file\", () => {\n      const { entries, options } = fixtureRoutes(appPlayground);\n      const groups = [{ name: \"params\", routes: [\"/params/optional/**\"] }];\n      const { templates, behaviors } = assignRoutesToGroups(\n        groups,\n        entries,\n        options,\n      );\n      expect(templates.params).toContain(\"/params/optional/[[...rest]]\");\n      // `params/optional/*` does not match `/params/optional`, which the same\n      // file serves, so it gets an exact behavior of its own.\n      expect(behaviors).toEqual([\n        {\n          group: \"params\",\n          route: \"/params/optional\",\n          pattern: \"params/optional\",\n        },\n        {\n          group: \"params\",\n          route: \"/params/optional/**\",\n          pattern: \"params/optional/*\",\n        },\n      ]);\n    });\n\n    it(\"points the old exact-pattern workaround at the subtree\", () => {\n      const { entries, options } = fixtureRoutes(appPlayground);\n      expect(() =>\n        assignRoutesToGroups(\n          [{ name: \"params\", routes: [\"/params/optional\"] }],\n          entries,\n          options,\n        ),\n      ).toThrow(\n        /served by the optional catch-all \"\\/params\\/optional\\/\\[\\[\\.\\.\\.rest\\]\\]\", whose subtree pattern \"\\/params\\/optional\\/\\*\\*\" routes \"\\/params\\/optional\" as well/,\n      );\n    });\n\n    it(\"works under a basePath too\", () => {\n      const assigned = assign(\n        [{ name: \"shop\", routes: [\"/shop/**\"] }],\n        routes(\"/base/shop/[[...slug]]\", \"/base\"),\n        \"/base\",\n      );\n      expect(assigned.shop).toEqual([\"/base/shop/[[...slug]]\"]);\n      expect(routedPatterns([\"/shop/**\"], assigned.shop, \"base\")).toEqual([\n        \"/shop/**\",\n        \"/shop\",\n      ]);\n    });\n\n    it(\"routes a Pages Router optional catch-all's parent data URL\", () => {\n      // `/_next/data/<id>/shop.json` belongs to the same file, and the exact\n      // `/shop` pattern `routedPatterns` adds carries it.\n      const assigned = assign(\n        [{ name: \"shop\", routes: [\"/shop/**\"] }],\n        [\n          {\n            template: \"/shop/[[...slug]]\",\n            entrypointId: \"pages/shop/[[...slug]].js\",\n            type: \"page\",\n          },\n        ],\n      );\n      expect(assigned.shop).toEqual([\"/shop/[[...slug]]\"]);\n    });\n  });\n\n  describe(\"one file behind several templates (C)\", () => {\n    // `app/[locale]/page.tsx` with root params: `/en` and `/de` are synthesized\n    // from one output, alongside its own `/[locale]` template.\n    const rootParams: RouteEntry[] = [\n      \"/[locale]\",\n      \"/[locale].rsc\",\n      \"/en\",\n      \"/en.rsc\",\n      \"/de\",\n      \"/de.rsc\",\n    ].map((template) => ({\n      template,\n      entrypointId: \"app/[locale]/page.js\",\n      type: \"app-page\",\n    }));\n\n    it(\"rejects a pattern that moves the file for one of its URLs\", () => {\n      // Only `en` got a behavior, so `/de` reached the default function, which\n      // no longer had the file.\n      expect(() =>\n        assign([{ name: \"intl\", routes: [\"/en\"] }], rootParams),\n      ).toThrow(\n        /\"app\\/\\[locale\\]\\/page\\.js\" is packaged into group \"intl\", but CloudFront would send \"\\/\\[locale\\]\" to the \"default\" group, \"\\/de\" to the \"default\" group/,\n      );\n      // And says the file cannot be grouped at all: `/[locale]` would need `/**`.\n      expect(() =>\n        assign([{ name: \"intl\", routes: [\"/en\", \"/de\"] }], rootParams),\n      ).toThrow(/\"\\/\\[locale\\]\" cannot be routed to any group/);\n    });\n\n    it(\"suggests the pattern that covers a static template it left behind\", () => {\n      const shared: RouteEntry[] = [\n        { template: \"/about\", entrypointId: \"shared.js\" },\n        { template: \"/team\", entrypointId: \"shared.js\" },\n      ];\n      expect(() => assign([{ name: \"m\", routes: [\"/about\"] }], shared)).toThrow(\n        /Add \"\\/team\" to group \"m\"'s routes/,\n      );\n      expect(\n        assign([{ name: \"m\", routes: [\"/about\", \"/team\"] }], shared).m,\n      ).toEqual([\"/about\", \"/team\"]);\n    });\n\n    it(\"checks the trailingSlash form, which exact patterns route\", () => {\n      const assigned = assign(\n        [{ name: \"p\", routes: [\"/pricing\"] }],\n        routes(\"/pricing\"),\n        \"\",\n        { trailingSlash: true },\n      );\n      expect(assigned.p).toEqual([\"/pricing\"]);\n    });\n\n    it(\"puts an exact trailingSlash form ahead of a subtree it sits at the base of\", () => {\n      // `a/b/` and `a/b/*` have the same literal depth; were the subtree first\n      // it would take `/a/b/` from group x.\n      const assigned = assign(\n        [\n          { name: \"x\", routes: [\"/a/b\"] },\n          { name: \"y\", routes: [\"/a/b/**\"] },\n        ],\n        routes(\"/\", \"/a/b\", \"/a/b/[id]\"),\n        \"\",\n        { trailingSlash: true },\n      );\n      expect(assigned.x).toEqual([\"/a/b\"]);\n      expect(assigned.y).toEqual([\"/a/b/[id]\"]);\n    });\n\n    it(\"gives a group without Pages Router routes no data URL behaviors\", () => {\n      // An App Router `/index` next to a Pages Router home page: a data behavior\n      // for the group, `_next/data/<id>/index.json`, would be the home page's\n      // data URL. The group owns no page, so it gets none.\n      expect(\n        assign(\n          [{ name: \"idx\", routes: [\"/index\"] }],\n          [\n            { template: \"/\", entrypointId: \"pages/index.js\", type: \"page\" },\n            {\n              template: \"/index\",\n              entrypointId: \"app/index/page.js\",\n              type: \"app-page\",\n            },\n          ],\n        ).idx,\n      ).toEqual([\"/index\"]);\n    });\n\n    it(\"rejects a group pattern claiming a data URL of a file left in default\", () => {\n      // The same collision in a group that does own a page.\n      expect(() =>\n        assign(\n          [{ name: \"idx\", routes: [\"/index\", \"/legacy\"] }],\n          [\n            { template: \"/\", entrypointId: \"pages/index.js\", type: \"page\" },\n            {\n              template: \"/index\",\n              entrypointId: \"app/index/page.js\",\n              type: \"app-page\",\n            },\n            {\n              template: \"/legacy\",\n              entrypointId: \"pages/legacy.js\",\n              type: \"page\",\n            },\n          ],\n        ),\n      ).toThrow(\n        /\"pages\\/index\\.js\" is packaged into the \"default\" group, but CloudFront would send \"\\/_next\\/data\\/abc123\\/index\\.json\" to group \"idx\"/,\n      );\n    });\n  });\n\n  describe(\"interception routes (D)\", () => {\n    const photoApp = (): RouteEntry[] => [\n      { template: \"/feed\", entrypointId: \"app/feed/page.js\", type: \"app-page\" },\n      {\n        template: \"/feed/(..)photo/[id]\",\n        entrypointId: \"app/feed/(..)photo/[id]/page.js\",\n        type: \"app-page\",\n      },\n      {\n        template: \"/feed/(..)photo/[id].rsc\",\n        entrypointId: \"app/feed/(..)photo/[id]/page.js\",\n        type: \"app-page\",\n      },\n      {\n        template: \"/photo/[id]\",\n        entrypointId: \"app/photo/[id]/page.js\",\n        type: \"app-page\",\n      },\n    ];\n\n    it(\"packages an intercepting file with the URL it intercepts\", () => {\n      // The soft navigation requests `/photo/1`, which CloudFront sends to the\n      // default function; Next.js rewrites it there to the intercepting file.\n      const assigned = assign(\n        [{ name: \"feed\", routes: [\"/feed/**\"] }],\n        [\n          ...photoApp(),\n          { template: \"/feed/[post]\", entrypointId: \"app/feed/[post]/page.js\" },\n        ],\n      );\n      expect(assigned.feed).toEqual([\"/feed/[post]\"]);\n      expect(assigned[DEFAULT_FUNCTION_GROUP]).toContain(\n        \"/feed/(..)photo/[id]\",\n      );\n      expect(assigned[DEFAULT_FUNCTION_GROUP]).toContain(\n        \"/feed/(..)photo/[id].rsc\",\n      );\n    });\n\n    it(\"follows the intercepted route into its group\", () => {\n      const assigned = assign(\n        [{ name: \"photos\", routes: [\"/photo/**\"] }],\n        photoApp(),\n      );\n      expect(assigned.photos).toEqual([\n        \"/feed/(..)photo/[id]\",\n        \"/feed/(..)photo/[id].rsc\",\n        \"/photo/[id]\",\n      ]);\n    });\n\n    it(\"throws when the intercepted URL space is split between groups\", () => {\n      expect(() =>\n        assign(\n          [{ name: \"one\", routes: [\"/photo/1\"] }],\n          [\n            ...photoApp(),\n            { template: \"/photo/1\", entrypointId: \"app/photo/1/page.js\" },\n          ],\n        ),\n      ).toThrow(\n        /interception route \"\\/feed\\/\\(\\.\\.\\)photo\\/\\[id\\]\".*group \"one\"'s pattern \"\\/photo\\/1\" claims part of it/s,\n      );\n    });\n\n    it.each([\n      [\"/feed/(..)photo/[id]\", \"/photo/[id]\"],\n      [\"/feed/(.)photo/[id]\", \"/feed/photo/[id]\"],\n      [\"/(.)photo/[id]\", \"/photo/[id]\"],\n      [\"/a/b/(..)(..)photo\", \"/photo\"],\n      [\"/a/b/(...)photo\", \"/photo\"],\n      [\"/photo/[id]\", undefined],\n    ])(\"resolves %p to the route it intercepts, %p\", (path, expected) => {\n      expect(interceptedRoute(path)).toBe(expected);\n    });\n  });\n\n  describe(\"next.config rewrites (D)\", () => {\n    it(\"rejects a rewrite whose source and destination land in different groups\", () => {\n      // app-playground rewrites `/e2e/rewrite/:path(.*)` to `/e2e/rewrite/echo`.\n      // Grouping only the destination leaves the source on the default\n      // function, which then rewrites to a file it does not have.\n      const { entries, options } = fixtureRoutes(appPlayground);\n      expect(() =>\n        assignRoutesToGroups(\n          [{ name: \"echo\", routes: [\"/e2e/rewrite/echo\"] }],\n          entries,\n          options,\n        ),\n      ).toThrow(\n        /rewrite from \"\\/e2e\\/rewrite\\/:path\\(\\.\\*\\)\" to \"\\/e2e\\/rewrite\\/echo\\?.*\" crosses groups: CloudFront sends \"\\/e2e\\/rewrite\\/\\[path\\]\" to the \"default\" group, and Next\\.js then serves it with \".*echo\\/page\\.js\", which is packaged into group \"echo\"/,\n      );\n      // Both ends in one group is fine.\n      expect(\n        assignRoutesToGroups(\n          [{ name: \"e2e\", routes: [\"/e2e/rewrite/**\"] }],\n          entries,\n          options,\n        ).templates.e2e,\n      ).toContain(\"/e2e/rewrite/echo\");\n    });\n\n    it(\"resolves a destination through Next.js's dynamic route rules\", () => {\n      const routing = {\n        beforeFiles: [{ source: \"/old\", destination: \"/blog/hello\" }],\n        dynamicRoutes: [\n          {\n            sourceRegex: \"^/blog/([^/]+?)(?:/)?$\",\n            destination: \"/blog/[slug]\",\n          },\n        ],\n      };\n      expect(() =>\n        assign(\n          [{ name: \"blog\", routes: [\"/blog/**\"] }],\n          routes(\"/blog/[slug]\"),\n          \"\",\n          {\n            routing,\n          },\n        ),\n      ).toThrow(/CloudFront sends \"\\/old\" to the \"default\" group/);\n    });\n\n    it(\"skips an afterFiles source a route already serves, and parameterized destinations\", () => {\n      const routing = {\n        // Never applied: `/pricing` is a route, and afterFiles yields to it.\n        afterFiles: [{ source: \"/pricing\", destination: \"/blog/x\" }],\n        // Not resolvable at synth.\n        beforeFiles: [{ source: \"/b/:slug\", destination: \"/blog/:slug\" }],\n      };\n      expect(() =>\n        assign(\n          [{ name: \"blog\", routes: [\"/blog/**\"] }],\n          routes(\"/blog/x\", \"/pricing\"),\n          \"\",\n          { routing },\n        ),\n      ).not.toThrow();\n    });\n\n    it(\"checks the path an optional parameter leaves\", () => {\n      const routing = {\n        beforeFiles: [{ source: \"/docs/:path*\", destination: \"/docs-app\" }],\n      };\n      expect(() =>\n        assign(\n          [{ name: \"docs\", routes: [\"/docs/**\", \"/docs-app\"] }],\n          routes(\"/docs-app\", \"/docs/[page]\"),\n          \"\",\n          { routing },\n        ),\n      ).toThrow(/CloudFront sends \"\\/docs\" to the \"default\" group/);\n    });\n  });\n\n  describe(\"a dynamic route's URL space (E)\", () => {\n    it(\"rejects a subtree capturing URLs a default-group catch-all serves\", () => {\n      // `/blog/[slug]` only matches one segment, so `/blog/a/b` reaches the\n      // blog function via `blog/*` and resolves there to `/[...slug]`, which\n      // the blog zip lacks. The template text itself never matched `blog/*`.\n      expect(() =>\n        assign(\n          [{ name: \"blog\", routes: [\"/blog/**\"] }],\n          routes(\"/\", \"/[...slug]\", \"/blog/[slug]\"),\n        ),\n      ).toThrow(\n        /\"\\/\\[\\.\\.\\.slug\\]\" is packaged into the \"default\" group, but CloudFront would send \"\\/blog\\/_\\/_\" to group \"blog\" \\(its pattern \"\\/blog\\/\\*\\*\"\\).*dynamic route \"\\/\\[\\.\\.\\.slug\\]\"/s,\n      );\n    });\n\n    it(\"checks under a basePath too\", () => {\n      expect(() =>\n        assign(\n          [{ name: \"blog\", routes: [\"/blog/**\"] }],\n          routes(\"/base\", \"/base/[...slug]\", \"/base/blog/[slug]\"),\n          \"/base\",\n        ),\n      ).toThrow(/CloudFront would send \"\\/base\\/blog\\/_\\/_\" to group \"blog\"/);\n    });\n\n    it(\"accepts the capture when the group's own routes shadow every URL of it\", () => {\n      // A more specific route in the capturing group wins inside Next.js, so\n      // with `/blog/[...rest]` there nothing under `/blog/` resolves to the\n      // root catch-all.\n      const assigned = assign(\n        [{ name: \"blog\", routes: [\"/blog/**\"] }],\n        routes(\"/\", \"/[...slug]\", \"/blog/[slug]\", \"/blog/[...rest]\"),\n      );\n      expect(assigned[DEFAULT_FUNCTION_GROUP]).toEqual([\"/\", \"/[...slug]\"]);\n      expect(assigned.blog).toEqual([\"/blog/[...rest]\", \"/blog/[slug]\"]);\n    });\n\n    it(\"accepts a single-segment root param, which never reaches under a subtree\", () => {\n      const assigned = assign(\n        [{ name: \"blog\", routes: [\"/blog/**\"] }],\n        routes(\"/\", \"/[slug]\", \"/blog/[slug]\"),\n      );\n      expect(assigned[DEFAULT_FUNCTION_GROUP]).toEqual([\"/\", \"/[slug]\"]);\n    });\n\n    it(\"rejects the trailingSlash form of a subtree's base that a root param serves\", () => {\n      // `/blog/` matches `blog/*`, and with no `/blog` page Next.js serves it\n      // with `/[slug]`.\n      expect(() =>\n        assign(\n          [{ name: \"blog\", routes: [\"/blog/**\"] }],\n          routes(\"/\", \"/[slug]\", \"/blog/[slug]\"),\n          \"\",\n          { trailingSlash: true },\n        ),\n      ).toThrow(/CloudFront would send \"\\/blog\\/\" to group \"blog\"/);\n    });\n\n    it(\"lets a static first segment in the group outrank a param in a later one\", () => {\n      // `/blog/settings` reaches the blog function; `/blog/[slug]` beats\n      // `/[team]/settings` there, static first segment before dynamic.\n      expect(() =>\n        assign(\n          [{ name: \"blog\", routes: [\"/blog/**\"] }],\n          routes(\"/\", \"/[team]/settings\", \"/blog/[slug]\"),\n        ),\n      ).not.toThrow();\n      // Without it, `/[team]/settings` is what Next.js resolves it to.\n      expect(() =>\n        assign(\n          [{ name: \"blog\", routes: [\"/blog/**\"] }],\n          routes(\"/\", \"/[team]/settings\", \"/blog/x\"),\n        ),\n      ).toThrow(/\"\\/blog\\/settings\" to group \"blog\"/);\n    });\n\n    it(\"checks a root optional catch-all against subtree and exact patterns\", () => {\n      expect(() =>\n        assign(\n          [{ name: \"docs\", routes: [\"/docs/**\"] }],\n          routes(\"/[[...slug]]\", \"/docs/[page]\"),\n        ),\n      ).toThrow(/\"\\/docs\\/_\\/_\" to group \"docs\"/);\n      // An exact pattern owns a static route, which Next.js prefers.\n      expect(\n        assign(\n          [{ name: \"about\", routes: [\"/about\"] }],\n          routes(\"/[[...slug]]\", \"/about\"),\n        ).about,\n      ).toEqual([\"/about\"]);\n    });\n\n    it(\"checks a grouped catch-all against a narrower group's subtree\", () => {\n      // `/api/reports/1/2` reaches the reports function, which only has\n      // `/api/reports/[id]`; Next.js resolves it to `/api/[...rest]`.\n      expect(() =>\n        assign(\n          [\n            { name: \"api\", routes: [\"/api/**\"] },\n            { name: \"reports\", routes: [\"/api/reports/**\"] },\n          ],\n          routes(\"/api/[...rest]\", \"/api/reports/[id]\"),\n        ),\n      ).toThrow(\n        /\"\\/api\\/\\[\\.\\.\\.rest\\]\" is packaged into group \"api\", but CloudFront would send \"\\/api\\/reports\\/_\\/_\" to group \"reports\"/,\n      );\n    });\n\n    it(\"checks a Pages Router catch-all's data URLs\", () => {\n      const page = (template: string, file: string): RouteEntry[] => [\n        { template, entrypointId: file, type: \"page\" },\n        {\n          template: `/_next/data/${BUILD_ID}${template}.json`,\n          entrypointId: file,\n          type: \"page\",\n        },\n      ];\n      expect(() =>\n        assign(\n          [{ name: \"blog\", routes: [\"/blog/**\"] }],\n          [\n            ...page(\"/[...slug]\", \"pages/[...slug].js\"),\n            ...page(\"/blog/[slug]\", \"pages/blog/[slug].js\"),\n          ],\n        ),\n      ).toThrow(/\"\\/_next\\/data\\/abc123\\/blog\\/_\\/_\\.json\" to group \"blog\"/);\n    });\n  });\n\n  describe(\"/index (G)\", () => {\n    it(\"groups an App Router /index, a route of its own\", () => {\n      const assigned = assign(\n        [{ name: \"idx\", routes: [\"/index\"] }],\n        [\n          { template: \"/\", entrypointId: \"app/page.js\", type: \"app-page\" },\n          {\n            template: \"/index.rsc\",\n            entrypointId: \"app/page.js\",\n            type: \"app-page\",\n          },\n          {\n            template: \"/index\",\n            entrypointId: \"app/index/page.js\",\n            type: \"app-page\",\n          },\n        ],\n      );\n      expect(assigned.idx).toEqual([\"/index\"]);\n    });\n\n    it(\"rejects the Pages Router home page, which is also /\", () => {\n      expect(() =>\n        assign(\n          [{ name: \"idx\", routes: [\"/index\"] }],\n          [\"/\", \"/index\", `/_next/data/${BUILD_ID}/index.json`].map(\n            (template) => ({\n              template,\n              entrypointId: \"pages/index.js\",\n              type: \"page\",\n            }),\n          ),\n        ),\n      ).toThrow(/\"\\/\" cannot be routed to any group.*\"\\/index\": one file/s);\n    });\n  });\n});\n\ndescribe(\"routedPatterns\", () => {\n  it(\"adds nothing for a group without an optional catch-all at a subtree's base\", () => {\n    expect(\n      routedPatterns(\n        [\"/blog/**\", \"/pricing\"],\n        [\"/blog/[slug]\", \"/blog/x/[[...rest]]\", \"/pricing\"],\n        \"\",\n      ),\n    ).toEqual([\"/blog/**\", \"/pricing\"]);\n  });\n\n  it(\"does not repeat a parent the group already declares\", () => {\n    expect(\n      routedPatterns([\"/shop/**\", \"/shop\"], [\"/shop/[[...slug]]\"], \"\"),\n    ).toEqual([\"/shop/**\", \"/shop\"]);\n  });\n});\n\ndescribe(\"pathPatternsFor\", () => {\n  it(\"drops the leading slash, because the distribution adds basePath itself\", () => {\n    expect(pathPatternsFor(\"/pricing\", { hasDataRoutes: false })).toEqual([\n      \"pricing\",\n    ]);\n  });\n\n  it(\"turns a subtree into a single trailing wildcard\", () => {\n    expect(\n      pathPatternsFor(\"/api/reports/**\", { hasDataRoutes: false }),\n    ).toEqual([\"api/reports/*\"]);\n  });\n\n  it(\"adds the `_next/data` URL space for Pages Router groups, on the literal build ID\", () => {\n    // A `*` for the build ID also matches `/`, so `_next/data/*/blog/*` claimed\n    // `/_next/data/<id>/docs/blog/x.json`, a page of another group.\n    const options = { hasDataRoutes: true, buildId: BUILD_ID };\n    expect(pathPatternsFor(\"/blog/**\", options)).toEqual([\n      \"blog/*\",\n      \"_next/data/abc123/blog/*\",\n    ]);\n    expect(pathPatternsFor(\"/pricing\", options)).toEqual([\n      \"pricing\",\n      \"_next/data/abc123/pricing.json\",\n    ]);\n  });\n\n  it(\"refuses to route data URLs without the build ID\", () => {\n    expect(() => pathPatternsFor(\"/blog/**\", { hasDataRoutes: true })).toThrow(\n      /needs its build ID/,\n    );\n  });\n\n  it(\"refuses a build ID a path pattern cannot hold\", () => {\n    // `generateBuildId` can return anything.\n    expect(() =>\n      pathPatternsFor(\"/blog/**\", { hasDataRoutes: true, buildId: \"v1/2 3\" }),\n    ).toThrow(/The build ID \"v1\\/2 3\" contains \"\\/\", \" \"/);\n  });\n\n  it(\"adds the trailing-slash form for a trailingSlash app\", async () => {\n    // With `trailingSlash: true` the canonical URL is `/pricing/`, and that is\n    // what every link in the app points at. A behavior on `pricing` alone does\n    // not match it, so the request fell through to the default function - which\n    // does not have the route packaged.\n    expect(pathPatternsFor(\"/pricing\", { hasDataRoutes: false })).toEqual([\n      \"pricing\",\n    ]);\n    expect(\n      pathPatternsFor(\"/pricing\", {\n        hasDataRoutes: false,\n        trailingSlash: true,\n      }),\n    ).toEqual([\"pricing\", \"pricing/\"]);\n  });\n\n  it(\"leaves a subtree pattern alone, which already matches both forms\", () => {\n    expect(\n      pathPatternsFor(\"/api/reports/**\", {\n        hasDataRoutes: false,\n        trailingSlash: true,\n      }),\n    ).toEqual([\"api/reports/*\"]);\n  });\n});\n\ndescribe(\"parseFunctionGroupsEnv\", () => {\n  it(\"returns undefined when unset\", () => {\n    expect(parseFunctionGroupsEnv(undefined)).toBeUndefined();\n  });\n});\n"]}