cdk-nextjs 0.6.2 → 0.7.1

package/lib/adapter/function-groups.js

@@ -0,0 +1,1099 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PATH_PATTERN_LITERAL = exports.FUNCTION_GROUPS_ENV_VAR = exports.DEFAULT_FUNCTION_GROUP = void 0;
+exports.parseFunctionGroupsEnv = parseFunctionGroupsEnv;
+exports.assertNoI18nSplitting = assertNoI18nSplitting;
+exports.validateFunctionGroups = validateFunctionGroups;
+exports.assignRoutesToGroups = assignRoutesToGroups;
+exports.routedPatterns = routedPatterns;
+exports.pathPatternsFor = pathPatternsFor;
+exports.interceptedRoute = interceptedRoute;
+exports.cloudFrontPatternRegex = cloudFrontPatternRegex;
+/**
+ * `functionGroups` resolution: the rules shared by `next build` and synth.
+ *
+ * Splitting spans two processes. `onBuildComplete` stages one deployment tree
+ * per group while `next build` is still running; the constructs turn the groups
+ * into CloudFront behaviors or API Gateway resources at synth. If the two
+ * disagree, CloudFront sends a request to a function whose zip lacks its
+ * entrypoint — so the build decides both, here, and records the behaviors it
+ * checked in the manifest for synth to deploy as they are. Synth still runs
+ * {@link validateFunctionGroups}, to fail before a `next build` it would
+ * otherwise pay for.
+ *
+ * Nothing in this file imports `aws-cdk-lib`: it is bundled into the adapter by
+ * esbuild. The public JSII struct consumers actually write (`NextjsFunctionGroup`,
+ * which adds per-group `overrides`) is in `src/nextjs-compute/nextjs-functions.ts`
+ * and is structurally assignable to {@link FunctionGroupSpec}.
+ */
+const constants_1 = require("../constants");
+const manifest_1 = require("../runtime/manifest");
+const base_path_1 = require("../utils/base-path");
+/**
+ * The implicit group every unassigned route falls into. Reserved as a group
+ * name: it is also the construct id suffix and the function whose URL backs the
+ * distribution's default behavior.
+ */
+exports.DEFAULT_FUNCTION_GROUP = "default";
+/**
+ * How the resolved groups reach `onBuildComplete`, which cannot read CDK props —
+ * it runs inside `next build`. `CDK_NEXTJS_INIT_CACHE_DIR` is the precedent.
+ */
+exports.FUNCTION_GROUPS_ENV_VAR = "CDK_NEXTJS_FUNCTION_GROUPS";
+const ERROR_PREFIX = `${constants_1.LOG_PREFIX} \`functionGroups\`: `;
+const NAME_PATTERN = /^[a-zA-Z0-9-]+$/;
+const SUBTREE_SUFFIX = "/**";
+/**
+ * The literal characters a CloudFront path pattern may contain: its alphabet
+ * (`A-Z a-z 0-9 _ - . * $ / ~ " ' @ : +` and `&`) less the two wildcards, which
+ * `validateRoutePattern` only accepts as a trailing `/**`. `nextjs-distribution.ts`
+ * adds the wildcards back to encode `public/` names.
+ *
+ * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/DownloadDistValuesCacheBehavior.html#DownloadDistValuesPathPattern
+ */
+exports.PATH_PATTERN_LITERAL = /[a-zA-Z0-9_\-.$/~"'@:+&]/;
+/**
+ * Read {@link FUNCTION_GROUPS_ENV_VAR}. `undefined` — not the empty array — when
+ * unset, because "no splitting" and "split into nothing" are different requests
+ * and only the first is valid.
+ */
+function parseFunctionGroupsEnv(value) {
+    return value ? JSON.parse(value) : undefined;
+}
+/**
+ * Splitting and `i18n` are mutually exclusive, and it is a CloudFront limit
+ * again.
+ *
+ * With `i18n` configured, every route template is locale-prefixed
+ * (`/en/pricing`, `/de/pricing`), so honoring a `/pricing` group would take one
+ * behavior *per locale per pattern* — a budget of 75 behaviors spent in a handful
+ * of routes. The alternative, a `*` in the locale position, matches any first
+ * segment and would capture routes belonging to other groups. Neither is
+ * something to do silently, so refuse instead.
+ */
+function assertNoI18nSplitting(i18n) {
+    if (i18n === null || i18n === undefined) {
+        return;
+    }
+    throw new Error(`${ERROR_PREFIX}\`functionGroups\` cannot be combined with \`i18n\`. ` +
+        `With i18n every route is locale-prefixed, so routing a group at the edge ` +
+        `would need one CloudFront behavior per locale per pattern, against a ` +
+        `quota of 75 for the whole distribution. Deploy one function for every ` +
+        `route (omit \`functionGroups\`), or drop \`i18n\`.`);
+}
+/**
+ * Reject everything that cannot be honored, at the earliest of the two sides to
+ * see it. Called from both, because either can be the first: `next build` runs
+ * before synth reads the manifest, but a `skipBuild: true` consumer inverts that.
+ */
+function validateFunctionGroups(groups) {
+    if (groups.length === 0) {
+        throw new Error(`${ERROR_PREFIX}\`functionGroups\` is an empty array. Omit the prop ` +
+            `entirely to deploy one function for every route, which is the default.`);
+    }
+    const seenNames = new Set();
+    const patternOwner = new Map();
+    for (const group of groups) {
+        if (group.name === exports.DEFAULT_FUNCTION_GROUP) {
+            throw new Error(`${ERROR_PREFIX}"${exports.DEFAULT_FUNCTION_GROUP}" is a reserved group name: ` +
+                `it is the implicit group every unassigned route falls into.`);
+        }
+        if (!NAME_PATTERN.test(group.name)) {
+            throw new Error(`${ERROR_PREFIX}Group name "${group.name}" must match ` +
+                `${NAME_PATTERN} — it becomes a construct id and part of a Lambda ` +
+                `function name.`);
+        }
+        if (seenNames.has(group.name)) {
+            throw new Error(`${ERROR_PREFIX}Two groups are both named "${group.name}".`);
+        }
+        seenNames.add(group.name);
+        if (group.routes.length === 0) {
+            throw new Error(`${ERROR_PREFIX}Group "${group.name}" owns no routes. Every group is a ` +
+                `Lambda function, so an empty one would deploy and never be reached.`);
+        }
+        for (const route of group.routes) {
+            validateRoutePattern(route, group.name);
+            const owner = patternOwner.get(route);
+            if (owner !== undefined) {
+                throw new Error(`${ERROR_PREFIX}Pattern "${route}" appears in both group "${owner}" ` +
+                    `and group "${group.name}". A route can only be packaged into one ` +
+                    `function. (Overlapping-but-different patterns are fine: "/api/**" ` +
+                    `in one group and "/api/reports/**" in another resolves ` +
+                    `longest-first.)`);
+            }
+            patternOwner.set(route, group.name);
+        }
+    }
+}
+/**
+ * A pattern is an exact static path (`/pricing`) or a subtree (`/api/reports/**`).
+ *
+ * **Dynamic segments are rejected**, and the reason is CloudFront rather than
+ * anything about Next.js. Patterns become behavior path patterns, and CloudFront
+ * supports only `*` and `?`, so `/dashboard/[id]` could only ever deploy as
+ * `/dashboard/*` — which also matches `/dashboard/settings` and
+ * `/dashboard/a/b/c`. If those are in another group, CloudFront routes them to a
+ * function whose zip lacks their entrypoint: a crash on a route the consumer
+ * explicitly assigned elsewhere. Accepting a syntax whose granularity cannot be
+ * honored would be worse than rejecting it.
+ *
+ * The restriction costs nothing that was achievable anyway. `/dashboard/**` →
+ * `/dashboard/*` is the same URL space exactly, and isolating one heavy dynamic
+ * route still works as a subtree: `/api/report/**` covers `/api/report/[id]`.
+ *
+ * `NextjsRegionalFunctions` gets the same restriction even though API Gateway
+ * REST could express `/{id}` precisely — so that switching deployment type (to
+ * Regional for GovCloud, say) never silently changes how routes are grouped.
+ * That one is a consistency choice, not a technical limit.
+ */
+function validateRoutePattern(route, groupName) {
+    const where = `Group "${groupName}" pattern "${route}"`;
+    if (!route.startsWith("/")) {
+        throw new Error(`${ERROR_PREFIX}${where} must start with "/". Patterns are URL paths as ` +
+            `the browser requests them.`);
+    }
+    // `/index` is deliberately allowed. For the App Router it is a real route of
+    // its own (`app/index/page.tsx`), which `routablePathnames` keeps apart from
+    // `/`. For the Pages Router it is the home page under the name `next build`
+    // reports it by, one entrypoint registered under `/` as well — and grouping
+    // that would leave `/` on the default behavior with a function that lacks the
+    // file. Only the assignment can tell the two apart, and its coverage check
+    // (`assertEdgeReachesEveryFile`) rejects the second.
+    if (route === "/") {
+        throw new Error(`${ERROR_PREFIX}${where} cannot be routed. CloudFront has no path ` +
+            `pattern that matches only "/" — the default behavior serves it — so the ` +
+            `home page always belongs to the "${exports.DEFAULT_FUNCTION_GROUP}" group. ` +
+            `Group the routes around it instead.`);
+    }
+    // `/_next/…` is Next's own URL space — build assets, `/_next/image`, and the
+    // Pages Router data routes — and each has its behavior already: the data route
+    // of a grouped page follows it (see `pathPatternsFor`), and a `_next/*` behavior
+    // would compete with the static-asset and image ones for everything else.
+    if (route === "/_next" || route.startsWith("/_next/")) {
+        throw new Error(`${ERROR_PREFIX}${where} is under "/_next", which Next.js reserves for ` +
+            `build assets, image optimization and data routes. A Pages Router ` +
+            `page's "/_next/data/…" route follows the page into its group, so ` +
+            `group the page itself instead.`);
+    }
+    if (route === SUBTREE_SUFFIX) {
+        throw new Error(`${ERROR_PREFIX}${where} would own every route, leaving the default ` +
+            `group empty. Splitting exists to divide routes between functions; ` +
+            `omit \`functionGroups\` to deploy them all in one.`);
+    }
+    if (/[[\]]/.test(route)) {
+        throw new Error(`${ERROR_PREFIX}${where} contains a dynamic segment. Patterns become ` +
+            `CloudFront behavior path patterns, which support only "*" and "?", so ` +
+            `"${route}" could only deploy as a wildcard that also captures its ` +
+            `siblings. Use a subtree instead: "/blog/**" owns "/blog/[slug]".`);
+    }
+    if (/\((.*)\)/.test(route)) {
+        throw new Error(`${ERROR_PREFIX}${where} contains a route group segment. Route groups ` +
+            `like "(marketing)" organize files and never appear in a URL, so they ` +
+            `cannot be routed on. Use the URL path the route is served at.`);
+    }
+    const withoutSubtree = route.endsWith(SUBTREE_SUFFIX)
+        ? route.slice(0, -SUBTREE_SUFFIX.length)
+        : route;
+    if (/[*?]/.test(withoutSubtree)) {
+        throw new Error(`${ERROR_PREFIX}${where} contains a wildcard somewhere other than a ` +
+            `trailing "/**". The only two forms are an exact path ("/pricing") and ` +
+            `a subtree ("/api/reports/**").`);
+    }
+    if (route.includes("//")) {
+        throw new Error(`${ERROR_PREFIX}${where} contains an empty path segment.`);
+    }
+    // A route Next.js serves can still hold a character no path pattern can:
+    // `app/über/page.tsx`, `app/a b/page.tsx`, `app/a,b/page.tsx` all build, and
+    // the pattern passes every check above. `pathPatternsFor` copies it verbatim,
+    // so it reached `addBehavior` untouched and was left for CloudFront to reject,
+    // in an error naming neither the group nor the route. The `public/`
+    // workaround, one `?` per UTF-8 byte, is not available here: `?` matches *any*
+    // byte, so `/über` would deploy as `/??ber` and also send `/xyber` to this
+    // group's function, whose zip lacks its entrypoint. That is the sibling capture
+    // dynamic segments are rejected for, so the same answer applies.
+    const invalid = [...new Set(withoutSubtree)].filter((char) => !exports.PATH_PATTERN_LITERAL.test(char));
+    if (invalid.length > 0) {
+        throw new Error(`${ERROR_PREFIX}${where} contains ` +
+            `${invalid.map((char) => JSON.stringify(char)).join(", ")}, which a ` +
+            `CloudFront behavior path pattern cannot contain (allowed: A-Z a-z 0-9 ` +
+            `_ - . $ / ~ " ' @ : + &). Escaping it with "?" would also match other ` +
+            `routes of the same length. Use a subtree on a parent segment whose ` +
+            `name is plain ASCII instead: "/intl/**" owns "/intl/über".`);
+    }
+}
+/**
+ * Split every route template across the groups, longest matching pattern first,
+ * then prove that the edge routes every URL each file serves to the group that
+ * file was packaged into.
+ *
+ * Its `templates` are keyed by group name and always contain
+ * {@link DEFAULT_FUNCTION_GROUP}, so callers can iterate them as the complete set
+ * of functions to deploy. The default group is allowed to be empty of *templates*
+ * — it still serves `/_next/image`, any static file, and anything the
+ * distribution's catch-all behavior sends it.
+ *
+ * `basePath` is prepended to each pattern before matching, because manifest
+ * templates are basePath-prefixed and consumers write the routes their app
+ * declares.
+ *
+ * Packaging matches patterns against *templates*, but CloudFront routes *URLs*,
+ * and a file answers URLs none of its templates spells: an optional catch-all's
+ * parent, the `trailingSlash` form, a Pages Router data URL, every other
+ * template it shares (root params synthesize `/en` and `/de` from one
+ * `[locale]` page). An interception route is worse: it is never requested at its
+ * own path at all. So after matching, intercepting files move to the group of
+ * the URL they intercept ({@link reassignInterceptingFiles}), and the result is
+ * replayed through the same behaviors `NextjsDistribution` deploys
+ * ({@link assertEdgeReachesEveryFile}, {@link assertRewritesStayInGroup}). A URL
+ * that would reach a function without its file throws here, during `next build`,
+ * rather than answering 404 once deployed.
+ */
+function assignRoutesToGroups(groups, entries, options) {
+    validateFunctionGroups(groups);
+    const basePath = (0, base_path_1.basePathPrefix)(options.basePath);
+    // Matched with the very behaviors `NextjsDistribution` deploys for the
+    // declared patterns, most specific first, so packaging and the edge share one
+    // routing model and the first match is the winner. Data routes are left out:
+    // no template is under `/_next`, and which groups have them is decided by
+    // this assignment.
+    const edgeBase = {
+        basePath,
+        buildId: options.buildId,
+        trailingSlash: options.trailingSlash ?? false,
+    };
+    const patterns = edgeBehaviors(groups, {}, { ...edgeBase, dataRouteGroups: new Set() });
+    const matchedPatterns = new Set();
+    // An entrypoint is a *file*; two templates can share one (a Pages Router page
+    // and its `/_next/data/<buildId>/…json` sibling). Splitting them across zips
+    // would stage the same file twice and route one of them to a function that
+    // has it by accident, so ownership is recorded per entrypoint and reused.
+    const groupOfEntrypoint = new Map();
+    // Which `patterns` index won the entrypoint. `patterns` is sorted
+    // most-specific-first, so a lower index is the better claim, and keeping it
+    // stops a second template that shares the entrypoint from taking it over with
+    // a *broader* pattern. Without it the owner was whichever of the two templates
+    // `entries` happened to visit last — the same build grouped differently
+    // depending on manifest key order.
+    const winningIndexOfEntrypoint = new Map();
+    for (const entry of entries) {
+        let winner;
+        for (const [index, pattern] of patterns.entries()) {
+            if (!pattern.regex.test(entry.template)) {
+                continue;
+            }
+            // Every match is recorded, not only the winning one. A pattern fully
+            // shadowed by a narrower pattern in another group never wins anything —
+            // "/api/**" against an app whose only API routes are under
+            // "/api/reports/**" — so recording just the winner left it looking like a
+            // typo and threw below, rejecting the very layout the duplicate-pattern
+            // error a few lines up documents as supported.
+            matchedPatterns.add(`${pattern.group}\u0000${pattern.route}`);
+            winner ??= index;
+        }
+        // An intercepting file's own template (`/feed/(..)photo/[id]`) is not a URL
+        // anyone requests, so it does not decide the file's group; the URL it
+        // intercepts does, below. Its match still counts against the typo check.
+        if (winner === undefined || isInterceptionTemplate(entry.template)) {
+            continue;
+        }
+        const incumbent = winningIndexOfEntrypoint.get(entry.entrypointId);
+        if (incumbent === undefined || winner < incumbent) {
+            winningIndexOfEntrypoint.set(entry.entrypointId, winner);
+            groupOfEntrypoint.set(entry.entrypointId, patterns[winner].group);
+        }
+    }
+    // A pattern matching nothing is a typo, and a typo here is invisible: the
+    // route stays in the default group and the split silently does less than it
+    // was asked to. Cheap to catch, so catch it.
+    for (const group of groups) {
+        for (const route of group.routes) {
+            if (!matchedPatterns.has(`${group.name}\u0000${route}`)) {
+                throw new Error(`${ERROR_PREFIX}Group "${group.name}" pattern "${route}" matches no ` +
+                    `route in this build. ` +
+                    optionalCatchAllParentHint(route, entries, basePath) +
+                    `Patterns match route templates as Next.js declares them (e.g. ` +
+                    `"/blog/[slug]" is matched by "/blog/**"), and prerendered pages and ` +
+                    `static assets are served from S3 and need no group.`);
+            }
+        }
+    }
+    const edge = {
+        ...edgeBase,
+        // Only a group that owns a Pages Router page has data URLs to route. Read
+        // before interception moves files: those are App Router, never pages.
+        dataRouteGroups: new Set(entries
+            .filter((entry) => entry.type === "page")
+            .map((entry) => groupOfEntrypoint.get(entry.entrypointId) ?? exports.DEFAULT_FUNCTION_GROUP)),
+    };
+    reassignInterceptingFiles(entries, groupOfEntrypoint, edgeBehaviors(groups, templatesByGroup(groups, entries, groupOfEntrypoint), edge), edge);
+    const assigned = templatesByGroup(groups, entries, groupOfEntrypoint);
+    // Rebuilt rather than reused: an intercepting file never adds an optional
+    // catch-all parent, so this is the same list, but only by that argument.
+    const behaviors = edgeBehaviors(groups, assigned, edge);
+    const router = {
+        fileOfTemplate: fileOfTemplate(entries),
+        routing: options.routing,
+    };
+    assertEdgeReachesEveryFile(entries, groupOfEntrypoint, behaviors, edge, router);
+    assertRewritesStayInGroup(groupOfEntrypoint, behaviors, router);
+    for (const key of Object.keys(assigned)) {
+        assigned[key] = [...assigned[key]].sort();
+    }
+    return {
+        templates: assigned,
+        behaviors: behaviors.map(({ group, route, pattern }) => ({
+            group,
+            route,
+            pattern,
+        })),
+    };
+}
+/**
+ * The patterns a group is *routed* on: the ones it declares, plus the parent
+ * path of every optional catch-all a subtree pattern moved into it.
+ *
+ * `/blog/[[...slug]]` serves `/blog` as well as everything under it, and
+ * `/blog/**` moves the whole file — but deploys as `blog/*`, which does not
+ * match `/blog`. So the parent is routed automatically, as an exact pattern of
+ * its own; declaring `/blog` by hand is a pattern with no route of its own and
+ * is rejected as a typo, with a hint pointing here. Nothing else a subtree owns
+ * needs this: a file whose parent URL is its subtree's base can only be an
+ * optional catch-all, since Next.js rejects `app/blog/page.tsx` next to it.
+ *
+ * @param ownedTemplates the templates assigned to the group, basePath-prefixed
+ *   as `manifest.groups` records them
+ */
+function routedPatterns(routes, ownedTemplates, basePath) {
+    const result = [...routes];
+    for (const route of routes) {
+        if (!route.endsWith(SUBTREE_SUFFIX)) {
+            continue;
+        }
+        const parent = route.slice(0, -SUBTREE_SUFFIX.length);
+        const prefix = `${prefixBasePath(parent, basePath)}/`;
+        const ownsOptionalCatchAll = ownedTemplates.some((template) => template.startsWith(prefix) &&
+            OPTIONAL_CATCH_ALL_SEGMENT.test(template.slice(prefix.length)));
+        if (ownsOptionalCatchAll && !result.includes(parent)) {
+            result.push(parent);
+        }
+    }
+    return result;
+}
+/**
+ * CloudFront path patterns for one group pattern, without a leading slash —
+ * the form `NextjsDistribution.getPathPattern` expects, so the basePath is
+ * added there rather than here.
+ *
+ * Two patterns come back when the group owns a Pages Router route: its RSC-era
+ * equivalent is a second URL space, `/_next/data/<buildId>/<route>.json`, which
+ * the default behavior would otherwise send to the default group.
+ *
+ * A third comes back for an exact route in a `trailingSlash` app, where the
+ * canonical URL is `/pricing/` rather than `/pricing`: the bare pattern does not
+ * match it, so without this every request for the route the user actually links to
+ * falls through to the default group's function — which, for a Pages Router API
+ * route, has no entrypoint for it at all. Subtree patterns need no variant
+ * (`pricing/*` already matches `/pricing/`), and neither do the data URLs, which
+ * never carry the slash.
+ */
+function pathPatternsFor(route, options) {
+    const isSubtree = route.endsWith(SUBTREE_SUFFIX);
+    const base = isSubtree ? route.slice(0, -SUBTREE_SUFFIX.length) : route;
+    const bare = base.replace(/^\//, "");
+    const patterns = [isSubtree ? `${bare}/*` : bare];
+    if (!isSubtree && options.trailingSlash && bare) {
+        patterns.push(`${bare}/`);
+    }
+    if (options.hasDataRoutes) {
+        // The literal build ID, not a `*` for it. CloudFront's `*` also matches
+        // `/`, so `_next/data/*/blog/*` claimed `/_next/data/<id>/docs/blog/x.json`
+        // too — another group's page, sent to a function without it. Every other
+        // pattern is anchored at the start of the path; this one now is as well.
+        //
+        // It makes these behaviors change whenever the build ID does, which is every
+        // deploy unless `deploymentId` pins it. A client still holding the previous
+        // build requests `/_next/data/<old id>/…`, which no behavior matches, so it
+        // reaches the default function. That is correct rather than merely
+        // harmless: `next start` 404s a data request for another build ID
+        // (`handleNextDataRequest` in `next/dist/server/base-server.js`) and so does
+        // the runtime, which has no pathname for it, and the Pages Router client
+        // treats a data 404 as an asset error and hard-navigates to the page
+        // (`fetchNextData` → `markAssetError` → `handleRouteInfoError` in
+        // `next/dist/shared/lib/router/router.js`), which gets the new build.
+        patterns.push(isSubtree
+            ? `_next/data/${dataBuildId(options.buildId)}/${bare}/*`
+            : `_next/data/${dataBuildId(options.buildId)}/${bare}.json`);
+    }
+    return patterns;
+}
+/**
+ * Rank a CloudFront path pattern so the most specific is added first: literal
+ * segments before the first `*` dominate, then an exact pattern before a
+ * wildcard one, then total segments, then length. {@link edgeBehaviors} sorts
+ * on it.
+ *
+ * Ranking on the leading literal is what a CloudFront wildcard forces, because
+ * it matches across `/` rather than within one segment: an exact `a/b` has to
+ * precede the subtree `a/*` that would otherwise swallow it, though the two are
+ * the same length and depth. At equal literal depth the exact one still goes
+ * first, since a trailingSlash `a/b/` is otherwise outranked by the subtree
+ * `a/b/*`, one segment longer, that matches it. Since the data patterns carry
+ * the literal build ID, no pattern has a wildcard anywhere but at its end.
+ */
+function behaviorSpecificity(pattern) {
+    const segments = pattern.split("/").filter(Boolean);
+    const firstWildcard = segments.findIndex((segment) => segment.includes("*"));
+    const literalDepth = firstWildcard === -1 ? segments.length : firstWildcard;
+    const exact = firstWildcard === -1 ? 1 : 0;
+    return ((literalDepth * 2 + exact) * 1000000 +
+        segments.length * 10000 +
+        pattern.length);
+}
+/**
+ * The build ID as it goes into a path pattern. A custom `generateBuildId` can
+ * return anything, and a character CloudFront cannot spell would otherwise fail
+ * the deploy naming neither the build ID nor the group.
+ */
+function dataBuildId(buildId) {
+    if (!buildId) {
+        throw new Error(`${ERROR_PREFIX}Routing a Pages Router app's "/_next/data/<buildId>/…" ` +
+            `URLs needs its build ID, and none was passed. This is a cdk-nextjs ` +
+            `bug: the build ID comes from the adapter manifest.`);
+    }
+    const invalid = [...new Set(buildId)].filter((char) => !exports.PATH_PATTERN_LITERAL.test(char) || char === "/");
+    if (invalid.length > 0) {
+        throw new Error(`${ERROR_PREFIX}The build ID "${buildId}" contains ` +
+            `${invalid.map((char) => JSON.stringify(char)).join(", ")}, which a ` +
+            `CloudFront path pattern cannot hold, so its "/_next/data" URLs cannot ` +
+            `be routed to a group. Make \`generateBuildId\` return only A-Z a-z ` +
+            `0-9 _ - . characters.`);
+    }
+    return buildId;
+}
+/**
+ * The typo check's hint for the one exact pattern that was the documented
+ * workaround: the parent of an optional catch-all, which has no template.
+ */
+function optionalCatchAllParentHint(route, entries, basePath) {
+    if (route.endsWith(SUBTREE_SUFFIX)) {
+        return "";
+    }
+    const prefix = `${prefixBasePath(route, basePath)}/`;
+    const catchAll = entries.find((entry) => entry.template.startsWith(prefix) &&
+        OPTIONAL_CATCH_ALL_SEGMENT.test(entry.template.slice(prefix.length)));
+    if (!catchAll) {
+        return "";
+    }
+    return (`"${route}" is served by the optional catch-all "${catchAll.template}", ` +
+        `whose subtree pattern "${route}${SUBTREE_SUFFIX}" routes "${route}" as ` +
+        `well — use that instead. `);
+}
+/** `/blog/[[...slug]]`'s last segment. */
+const OPTIONAL_CATCH_ALL_SEGMENT = /^\[\[\.\.\.[^\]/]+\]\]$/;
+/**
+ * Next.js's interception markers, longest-overlapping first, exactly as
+ * `INTERCEPTION_ROUTE_MARKERS` in
+ * `next/dist/shared/lib/router/utils/interception-routes.js` orders them.
+ */
+const INTERCEPTION_MARKERS = ["(..)(..)", "(.)", "(..)", "(...)"];
+function interceptionMarkerOf(path) {
+    for (const segment of path.split("/")) {
+        const marker = INTERCEPTION_MARKERS.find((it) => segment.startsWith(it));
+        if (marker) {
+            return marker;
+        }
+    }
+    return undefined;
+}
+function isInterceptionTemplate(template) {
+    return interceptionMarkerOf(template) !== undefined;
+}
+/**
+ * The route an interception route intercepts: `/feed/(..)photo/[id]` →
+ * `/photo/[id]`. `extractInterceptionRouteInformation` from
+ * `next/dist/shared/lib/router/utils/interception-routes.js`, restated because
+ * this file is bundled without `next`. The template is already a normalized app
+ * path (no route groups, no `@slot`s), so none of its normalization is needed.
+ * Next.js's interception rewrite matches exactly this path, and only with a
+ * `Next-Url` header — which CloudFront does not route on.
+ */
+function interceptedRoute(path) {
+    const marker = interceptionMarkerOf(path);
+    if (marker === undefined) {
+        return undefined;
+    }
+    const at = path.indexOf(marker);
+    const intercepting = path.slice(0, at).split("/").filter(Boolean);
+    const rest = path
+        .slice(at + marker.length)
+        .split("/")
+        .filter(Boolean);
+    const parent = marker === "(.)"
+        ? intercepting
+        : marker === "(..)"
+            ? intercepting.slice(0, -1)
+            : marker === "(..)(..)"
+                ? intercepting.slice(0, -2)
+                : [];
+    return `/${[...parent, ...rest].join("/")}`;
+}
+/**
+ * Templates that name what a request is *rewritten* to inside Next.js, never
+ * what the browser asks for: the RSC payload (`/pricing.rsc`) and segment
+ * prefetches (`/pricing.segments/…`) are requested as `/pricing` with an `RSC`
+ * header, which is why `pricing` alone has always routed them.
+ */
+function isInternalTemplate(path) {
+    return path.endsWith(".rsc") || path.includes(".segments/");
+}
+/**
+ * Every group behavior, most specific first: the order CloudFront has to see
+ * them in, since it stops at the first match. The assignment returns this list
+ * and the constructs deploy it as it is.
+ */
+function edgeBehaviors(groups, assigned, edge) {
+    return groups
+        .flatMap((group) => routedPatterns(group.routes, assigned[group.name] ?? [], edge.basePath).flatMap((route) => pathPatternsFor(route, {
+        trailingSlash: edge.trailingSlash,
+        buildId: edge.buildId,
+        hasDataRoutes: edge.dataRouteGroups.has(group.name),
+    }).map((pattern) => ({
+        group: group.name,
+        route,
+        pattern,
+        regex: cloudFrontPatternRegex(`${edge.basePath}/${pattern}`),
+    }))))
+        .sort((a, b) => behaviorSpecificity(b.pattern) - behaviorSpecificity(a.pattern));
+}
+/**
+ * CloudFront path pattern matching: anchored at both ends, `*` for any run of
+ * characters `/` included, `?` for exactly one, case-sensitive. `pattern` has to
+ * carry the leading slash CloudFront implies.
+ *
+ * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/DownloadDistValuesCacheBehavior.html#DownloadDistValuesPathPattern
+ */
+function cloudFrontPatternRegex(pattern) {
+    const source = [...pattern]
+        .map((char) => char === "*"
+        ? ".*"
+        : char === "?"
+            ? "."
+            : char.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+        .join("");
+    return new RegExp(`^${source}$`);
+}
+/** The behavior CloudFront would pick for `url`, `undefined` for the default one. */
+function edgeBehaviorFor(behaviors, url) {
+    return behaviors.find((behavior) => behavior.regex.test(url));
+}
+function templatesByGroup(groups, entries, groupOfEntrypoint) {
+    const assigned = {
+        [exports.DEFAULT_FUNCTION_GROUP]: [],
+    };
+    for (const group of groups) {
+        assigned[group.name] = [];
+    }
+    for (const entry of entries) {
+        const group = groupOfEntrypoint.get(entry.entrypointId) ?? exports.DEFAULT_FUNCTION_GROUP;
+        assigned[group].push(entry.template);
+    }
+    return assigned;
+}
+/**
+ * Put each intercepting file in the group of the URL it intercepts.
+ *
+ * With `/feed/**` grouped, `app/feed/(..)photo/[id]/page.tsx` matched it and
+ * moved to the feed group. But the soft navigation it exists for requests
+ * `/photo/1` with a `Next-Url: /feed` header; CloudFront routes on the URL alone,
+ * so the request reaches whichever function owns `/photo/*`, where Next.js's
+ * interception rewrite (a `beforeFiles` rule on that header) resolves it to the
+ * intercepting file — which that function did not have.
+ *
+ * Moving the file there is always possible unless the intercepted URL space is
+ * itself split: `/photo/[id]` in the default group with `/photo/1` grouped
+ * elsewhere would need the file in both. That throws.
+ */
+function reassignInterceptingFiles(entries, groupOfEntrypoint, behaviors, edge) {
+    for (const entry of entries) {
+        const path = stripBasePath(entry.template, edge.basePath);
+        if (path === undefined || isInternalTemplate(path)) {
+            continue;
+        }
+        const target = interceptedRoute(path);
+        if (target === undefined) {
+            continue;
+        }
+        const url = withBasePath(target, edge.basePath);
+        const group = edgeBehaviorFor(behaviors, url)?.group ?? exports.DEFAULT_FUNCTION_GROUP;
+        const intercepted = templateRegex(url);
+        const split = behaviors.find((behavior) => behavior.group !== group &&
+            !behavior.pattern.startsWith("_next/data/") &&
+            sampleUrl(behavior.route, edge.basePath).some((it) => intercepted.test(it)));
+        if (split) {
+            throw new Error(`${ERROR_PREFIX}"${entry.entrypointId}" is the interception route ` +
+                `"${entry.template}", which Next.js reaches by rewriting a request for ` +
+                `"${url}" inside whichever function CloudFront sent it to — so it is ` +
+                `packaged with the group that owns "${url}". That URL space is split, ` +
+                `though: most of it reaches ${groupLabel(group)}, but group ` +
+                `"${split.group}"'s pattern "${split.route}" claims part of it, and ` +
+                `one file cannot be in both. Route all of "${target}" to one group.`);
+        }
+        groupOfEntrypoint.set(entry.entrypointId, group);
+    }
+}
+/** A URL a group pattern routes, to test against another route's URL space. */
+function sampleUrl(route, basePath) {
+    return route.endsWith(SUBTREE_SUFFIX)
+        ? [`${basePath}${route.slice(0, -SUBTREE_SUFFIX.length)}/_`]
+        : [`${basePath}${route}`];
+}
+/** The URLs a template stands for, as a regex: `[id]` is one segment, and so on. */
+function templateRegex(template) {
+    const source = template
+        .split("/")
+        .filter(Boolean)
+        .map((segment) => [
+        `/${segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`,
+        "/[^/]+",
+        "/.+",
+        "(?:/.+)?",
+    ][segmentKind(segment)])
+        .join("");
+    return new RegExp(`^${source || "/"}$`);
+}
+/**
+ * Throw unless every URL each file serves reaches the group holding it.
+ *
+ * Checked for every file, the default group's included: the invariant is "the
+ * edge never sends a request to a function without its file", and a group
+ * pattern can break it by claiming a URL of a file left in the default group as
+ * easily as by leaving one behind. A dynamic template stands for a URL space,
+ * not one URL, so it is also checked against the part of that space other
+ * groups' patterns capture ({@link capturedDynamicUrls}): a `/[...slug]` left in
+ * the default group answers `/blog/a/b` too, which `/blog/**` sends elsewhere.
+ *
+ * Only the URLs as Next.js spells them are replayed, and that is a known gap
+ * rather than an oversight: CloudFront path patterns and API Gateway resources
+ * both match case-sensitively, while `@next/routing` matches templates
+ * case-insensitively. `/API/reports/1` therefore misses a `/api/reports/**`
+ * group and reaches the default function, which resolves it to a template it
+ * does not have. Neither edge can be told to fold case, and lowercasing at the
+ * edge would break the case-sensitive S3 keys behind `public/`, so there is
+ * nothing to check here that could pass; the runtime answers such a request
+ * itself (see `ownedRouteError`).
+ */
+function assertEdgeReachesEveryFile(entries, groupOfEntrypoint, behaviors, edge, router) {
+    const files = new Map();
+    for (const entry of entries) {
+        const list = files.get(entry.entrypointId) ?? [];
+        list.push(entry);
+        files.set(entry.entrypointId, list);
+    }
+    // Deep enough for a sample to get past every template a capturing group
+    // could shadow it with.
+    const deepest = Math.max(0, ...entries.map((entry) => {
+        const path = stripBasePath(entry.template, edge.basePath);
+        return path !== undefined && isRoutablePath(path)
+            ? path.split("/").filter(Boolean).length
+            : 0;
+    })) + 1;
+    for (const [file, fileEntries] of files) {
+        const owner = groupOfEntrypoint.get(file) ?? exports.DEFAULT_FUNCTION_GROUP;
+        const misrouted = [];
+        for (const entry of fileEntries) {
+            for (const url of servedUrls(entry.template, entry.type, edge)) {
+                const behavior = edgeBehaviorFor(behaviors, url);
+                const group = behavior?.group ?? exports.DEFAULT_FUNCTION_GROUP;
+                if (group !== owner && !misrouted.some((it) => it.url === url)) {
+                    misrouted.push({ url, group, route: behavior?.route });
+                }
+            }
+            for (const it of capturedDynamicUrls(entry, owner, deepest, behaviors, edge, router)) {
+                if (!misrouted.some((known) => known.url === it.url)) {
+                    misrouted.push(it);
+                }
+            }
+        }
+        if (misrouted.length > 0) {
+            throw new Error(misroutedFileMessage(file, owner, misrouted, edge));
+        }
+    }
+}
+/**
+ * Stands in for "any value" of a dynamic segment in a sample URL. A literal
+ * template of that exact name would shadow it, which can only hide a misroute,
+ * never invent one.
+ */
+const ANY_SEGMENT = "_";
+/**
+ * Whether a request can resolve to `path` (basePath stripped) directly: not an
+ * RSC or segment rewrite, an interception route, or a data-URL alias (a data URL
+ * resolves to the page it names).
+ */
+function isRoutablePath(path) {
+    return (!isInternalTemplate(path) &&
+        !isInterceptionTemplate(path) &&
+        !path.startsWith("/_next/data/"));
+}
+/** 0 static, 1 `[param]`, 2 `[...catchAll]`, 3 `[[...optional]]`. */
+function segmentKind(segment) {
+    if (OPTIONAL_CATCH_ALL_SEGMENT.test(segment)) {
+        return 3;
+    }
+    if (/^\[\.\.\.[^\]]+\]$/.test(segment)) {
+        return 2;
+    }
+    return /^\[[^\]]+\]$/.test(segment) ? 1 : 0;
+}
+/**
+ * The URLs of a *dynamic* template's space that another group's behavior
+ * captures, and that Next.js — running in that group's function — still
+ * resolves to this template's file.
+ *
+ * `servedUrls` replays the template as spelled, which is exact for a static
+ * route but not for `/[...slug]`: the text `/[...slug]` never matches `blog/*`,
+ * yet `/blog/a/b` does, reaches the blog function, and resolves there to
+ * `/[...slug]`, which the blog zip lacks. So each other group's behavior is
+ * intersected with the template's URL space, one sample URL per shape
+ * ({@link sampleTemplatePaths}), and each sample is resolved the way Next.js
+ * resolves it ({@link resolveFile}). A more specific template in the capturing
+ * group legitimately shadows the sample (`/blog/[slug]` answers `/blog/_`, so
+ * only `/blog/_/_` is a misroute); anything it does not shadow is flagged.
+ */
+function capturedDynamicUrls(entry, owner, deepest, behaviors, edge, router) {
+    const path = stripBasePath(entry.template, edge.basePath);
+    if (path === undefined ||
+        !path.includes("[") ||
+        manifest_1.ERROR_PAGE_SUFFIXES.includes(path) ||
+        !isRoutablePath(path)) {
+        return [];
+    }
+    const segments = path.split("/").filter(Boolean);
+    const samples = new Set();
+    for (const behavior of behaviors) {
+        if (behavior.group === owner ||
+            behavior.pattern.startsWith("_next/data/")) {
+            continue;
+        }
+        const bare = behavior.pattern.replace(/\/$/, "");
+        const isSubtree = bare.endsWith("/*");
+        const prefix = (isSubtree ? bare.slice(0, -2) : bare)
+            .split("/")
+            .filter(Boolean);
+        for (const sample of sampleTemplatePaths(segments, prefix, isSubtree, Math.max(deepest, prefix.length + 1))) {
+            samples.add(sample);
+        }
+    }
+    const misrouted = [];
+    // `resolved` is `url` as Next.js matches it: without the trailing slash.
+    const check = (url, resolved) => {
+        const behavior = edgeBehaviorFor(behaviors, url);
+        const group = behavior?.group ?? exports.DEFAULT_FUNCTION_GROUP;
+        if (group === owner || misrouted.some((it) => it.url === url)) {
+            return;
+        }
+        if (resolveFile(resolved, router) === entry.entrypointId) {
+            misrouted.push({
+                url,
+                group,
+                route: behavior?.route,
+                servedAs: entry.template,
+            });
+        }
+    };
+    for (const sample of samples) {
+        for (const { url, resolved } of urlVariants(sample, entry.type, edge)) {
+            check(url, resolved);
+        }
+    }
+    return misrouted;
+}
+/**
+ * Sample paths in both a template's URL space and a behavior's: for a subtree
+ * `prefix/*`, every way the template's segments can line up with `prefix` and
+ * continue past it, one sample per resulting length up to `maxDepth`, with
+ * {@link ANY_SEGMENT} for each dynamic value beyond the prefix. For an exact
+ * pattern, the pattern's own path if the template matches it.
+ */
+function sampleTemplatePaths(template, prefix, isSubtree, maxDepth) {
+    if (!isSubtree) {
+        const path = `/${prefix.join("/")}`;
+        return templateRegex(`/${template.join("/")}`).test(path) ? [path] : [];
+    }
+    const valueAt = (at) => at < prefix.length ? prefix[at] : ANY_SEGMENT;
+    const results = [];
+    const walk = (index, acc) => {
+        if (index === template.length) {
+            // Exactly the prefix is kept too: `prefix/*` matches its trailing-slash
+            // form, which `check` adds for a `trailingSlash` app.
+            if (acc.length >= prefix.length) {
+                results.push(`/${acc.join("/")}`);
+            }
+            return;
+        }
+        const segment = template[index];
+        const at = acc.length;
+        const kind = segmentKind(segment);
+        if (kind === 0) {
+            if (at >= prefix.length || prefix[at] === segment) {
+                walk(index + 1, [...acc, segment]);
+            }
+            return;
+        }
+        if (kind === 1) {
+            walk(index + 1, [...acc, valueAt(at)]);
+            return;
+        }
+        for (let count = kind === 2 ? 1 : 0; at + count <= maxDepth; count++) {
+            const taken = Array.from({ length: count }, (_, i) => valueAt(at + i));
+            walk(index + 1, [...acc, ...taken]);
+        }
+    };
+    walk(0, []);
+    return results;
+}
+/**
+ * The URLs one template's file answers at the edge.
+ *
+ * Nothing for the error pages (every group stages them), the RSC and
+ * segment-prefetch rewrites (requested at the page's own URL), and interception
+ * routes (reached only through the intercepted URL's rewrite). Otherwise the
+ * template itself, an optional catch-all's parent, and for each of those the
+ * `trailingSlash` form and a Pages Router page's data URL. Only the slash-less
+ * data URL: the client never adds one.
+ */
+function servedUrls(template, type, edge) {
+    const path = stripBasePath(template, edge.basePath);
+    if (path === undefined ||
+        manifest_1.ERROR_PAGE_SUFFIXES.includes(path) ||
+        isInternalTemplate(path) ||
+        isInterceptionTemplate(path)) {
+        return [];
+    }
+    if (path.startsWith("/_next/data/")) {
+        return [template];
+    }
+    const paths = [path];
+    const optional = /^(.*)\/(\[\[\.\.\.[^\]/]+\]\])$/.exec(path);
+    if (optional) {
+        paths.push(optional[1] || "/");
+    }
+    return paths.flatMap((it) => urlVariants(it, type, edge).map(({ url }) => url));
+}
+/**
+ * A path's URL, its `trailingSlash` form and a Pages Router page's data URL,
+ * each with `resolved`: the URL as Next.js matches it, without the trailing slash.
+ */
+function urlVariants(path, type, edge) {
+    const url = withBasePath(path, edge.basePath);
+    const variants = [{ url, resolved: url }];
+    if (edge.trailingSlash && path !== "/") {
+        variants.push({ url: `${url}/`, resolved: url });
+    }
+    if (type === "page" && edge.buildId) {
+        const data = `${edge.basePath}/_next/data/${edge.buildId}${path === "/" ? "/index" : path}.json`;
+        variants.push({ url: data, resolved: data });
+    }
+    return variants;
+}
+function misroutedFileMessage(file, owner, misrouted, edge) {
+    const where = misrouted
+        .map((it) => `"${it.url}" to ${groupLabel(it.group)}` +
+        (it.route ? ` (its pattern "${it.route}")` : ""))
+        .join(", ");
+    const head = `${ERROR_PREFIX}"${file}" is packaged into ${groupLabel(owner)}, but ` +
+        `CloudFront would send ${where}, whose function does not have it: a 404 on ` +
+        `every such request. Every URL one file serves has to reach the group that ` +
+        `holds the file.`;
+    const captured = misrouted.filter((it) => it.servedAs !== undefined);
+    if (captured.length > 0) {
+        const templates = [...new Set(captured.map((it) => `"${it.servedAs}"`))];
+        return (`${head} Those URLs are part of the dynamic route ` +
+            `${templates.join(", ")} ("${ANY_SEGMENT}" stands for any segment ` +
+            `value): the pattern captures them at the edge, and no route packaged ` +
+            `into the capturing group is more specific, so Next.js still resolves ` +
+            `them to this file. Give that group a route that answers them (a ` +
+            `catch-all under its pattern, say), or narrow the pattern.`);
+    }
+    if (owner === exports.DEFAULT_FUNCTION_GROUP) {
+        return (`${head} A pattern claims a URL of a file that no pattern moved: narrow ` +
+            `it, or give the group the file's other routes too.`);
+    }
+    const unroutable = misrouted.filter((it) => suggestedPattern(it.url, edge) === undefined);
+    if (unroutable.length > 0) {
+        return (`${head} ${unroutable.map((it) => `"${it.url}"`).join(", ")} cannot be ` +
+            `routed to any group — CloudFront has no pattern for the home page alone, ` +
+            `and a dynamic first segment would need "/**" — so this file can only be ` +
+            `served by the "${exports.DEFAULT_FUNCTION_GROUP}" group. Remove the pattern that ` +
+            `moved it. (A Pages Router home page is also "/index": one file.)`);
+    }
+    const suggestions = [
+        ...new Set(misrouted.map((it) => suggestedPattern(it.url, edge))),
+    ];
+    return (`${head} Add ${suggestions.map((it) => `"${it}"`).join(", ")} to group ` +
+        `"${owner}"'s routes.`);
+}
+/**
+ * The group pattern that would route `url`, `undefined` when none can: a static
+ * path routes as itself, a dynamic one as the subtree above its first dynamic
+ * segment, and a data URL or `trailingSlash` form as the page it belongs to.
+ */
+function suggestedPattern(url, edge) {
+    let path = stripBasePath(url, edge.basePath) ?? url;
+    const dataPrefix = `/_next/data/${edge.buildId}/`;
+    if (path.startsWith(dataPrefix) && path.endsWith(".json")) {
+        path = `/${path.slice(dataPrefix.length, -".json".length)}`;
+        path = path === "/index" ? "/" : path;
+    }
+    if (path.length > 1 && path.endsWith("/")) {
+        path = path.slice(0, -1);
+    }
+    const segments = path.split("/").filter(Boolean);
+    const firstDynamic = segments.findIndex((segment) => segment.startsWith("["));
+    if (segments.length === 0 || firstDynamic === 0) {
+        return undefined;
+    }
+    return firstDynamic === -1
+        ? path
+        : `/${segments.slice(0, firstDynamic).join("/")}${SUBTREE_SUFFIX}`;
+}
+/**
+ * Throw on a `next.config` rewrite whose source reaches one group and whose
+ * destination is packaged into another.
+ *
+ * A rewrite runs inside the function that received the request, so
+ * `/old/:path*` → `/new` with `/new/**` grouped and `/old` not sends `/old/x` to
+ * the default function, which rewrites it to a file it lacks.
+ *
+ * Only the rewrites whose destination is a literal path can be resolved to a
+ * file here; one built from the source's parameters (`/blog/:slug` →
+ * `/posts/:slug`) is skipped, as are external ones. The source is checked at the
+ * granularity of its literal prefix: each parameter stands in as a dynamic
+ * segment. Rewrites done by middleware (`NextResponse.rewrite`) are code, not
+ * config, and cannot be checked at all.
+ */
+function assertRewritesStayInGroup(groupOfEntrypoint, behaviors, router) {
+    const { routing } = router;
+    const phases = [
+        [routing.beforeFiles, false],
+        // `afterFiles` and `fallback` only apply when no file matched the URL, so a
+        // source that is itself a route never reaches the destination.
+        [routing.afterFiles, true],
+        [routing.fallback, true],
+    ];
+    for (const [rules, yieldsToFiles] of phases) {
+        for (const rule of rules ?? []) {
+            const destination = literalDestination(rule.destination);
+            // Next.js's own interception rewrites are here too, on `Next-Url`;
+            // `reassignInterceptingFiles` has already put their files in place.
+            if (destination === undefined || isInterceptionTemplate(destination)) {
+                continue;
+            }
+            const file = resolveFile(destination, router);
+            if (file === undefined) {
+                continue;
+            }
+            const target = groupOfEntrypoint.get(file) ?? exports.DEFAULT_FUNCTION_GROUP;
+            for (const url of rewriteSourceUrls(rule.source)) {
+                if (yieldsToFiles && router.fileOfTemplate.has(url)) {
+                    continue;
+                }
+                const behavior = edgeBehaviorFor(behaviors, url);
+                const group = behavior?.group ?? exports.DEFAULT_FUNCTION_GROUP;
+                if (group === target) {
+                    continue;
+                }
+                throw new Error(`${ERROR_PREFIX}The next.config rewrite from "${rule.source}" to ` +
+                    `"${rule.destination}" crosses groups: CloudFront sends "${url}" to ` +
+                    `${groupLabel(group)}` +
+                    (behavior ? ` (its pattern "${behavior.route}")` : "") +
+                    `, and Next.js then serves it with "${file}", which is packaged ` +
+                    `into ${groupLabel(target)}. A rewrite is applied inside the ` +
+                    `function that received the request, so its source and its ` +
+                    `destination have to be routed to the same group.`);
+            }
+        }
+    }
+}
+/** A rewrite destination's pathname, `undefined` unless it is a literal local path. */
+function literalDestination(destination) {
+    if (!destination?.startsWith("/")) {
+        return undefined;
+    }
+    const pathname = destination.split(/[?#]/)[0];
+    if (/[$:]/.test(pathname)) {
+        return undefined;
+    }
+    return pathname.length > 1 ? pathname.replace(/\/$/, "") : pathname;
+}
+function fileOfTemplate(entries) {
+    return new Map(entries
+        .filter((entry) => !isInternalTemplate(entry.template))
+        .map((entry) => [entry.template, entry.entrypointId]));
+}
+/**
+ * The file Next.js serves `pathname` with: a template of that exact name, or
+ * else the first of Next.js's own dynamic route rules that matches — matched
+ * case-insensitively, as `resolveRoutes` does. `dynamicRoutes` is in Next.js's
+ * priority order (static segment before `[param]` before `[...catchAll]`
+ * before `[[...optional]]`), Pages Router data URLs included.
+ */
+function resolveFile(pathname, { fileOfTemplate: files, routing }) {
+    const exact = files.get(pathname);
+    if (exact !== undefined) {
+        return exact;
+    }
+    for (const route of routing.dynamicRoutes ?? []) {
+        if (new RegExp(route.sourceRegex, "i").test(pathname)) {
+            const template = route.destination?.split("?")[0];
+            return template === undefined ? undefined : files.get(template);
+        }
+    }
+    return undefined;
+}
+/**
+ * The URL shapes a path-to-regexp rewrite source matches, as template-like
+ * paths: each literal segment kept, each parameter replaced by `[name]`, and —
+ * when the last one is optional (`:path*`, `:slug?`) — the path without it too.
+ */
+function rewriteSourceUrls(source) {
+    if (!source?.startsWith("/")) {
+        return [];
+    }
+    const segments = [];
+    let optionalFrom;
+    for (const segment of source.split("/").slice(1)) {
+        if (!/[:()*?+{}[\]]/.test(segment)) {
+            segments.push(segment);
+            continue;
+        }
+        optionalFrom = /^:\w+[*?]$/.test(segment) ? segments.length : undefined;
+        segments.push(`[${/:(\w+)/.exec(segment)?.[1] ?? "param"}]`);
+    }
+    const urls = [`/${segments.join("/")}`];
+    if (optionalFrom !== undefined) {
+        urls.push(`/${segments.slice(0, optionalFrom).join("/")}`);
+    }
+    return urls;
+}
+function groupLabel(group) {
+    return group === exports.DEFAULT_FUNCTION_GROUP
+        ? `the "${exports.DEFAULT_FUNCTION_GROUP}" group`
+        : `group "${group}"`;
+}
+function prefixBasePath(route, basePath) {
+    return `${(0, base_path_1.basePathPrefix)(basePath)}${route}`;
+}
+/** `template` without `basePath` (`/` for the base itself), `undefined` if outside it. */
+function stripBasePath(template, basePath) {
+    if (!basePath) {
+        return template;
+    }
+    return (0, base_path_1.hasPathPrefix)(template, basePath)
+        ? template.slice(basePath.length) || "/"
+        : undefined;
+}
+function withBasePath(path, basePath) {
+    return path === "/" ? basePath || "/" : `${basePath}${path}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"function-groups.js","sourceRoot":"","sources":["../../src/adapter/function-groups.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `functionGroups` resolution: the rules shared by `next build` and synth.\n *\n * Splitting spans two processes. `onBuildComplete` stages one deployment tree\n * per group while `next build` is still running; the constructs turn the groups\n * into CloudFront behaviors or API Gateway resources at synth. If the two\n * disagree, CloudFront sends a request to a function whose zip lacks its\n * entrypoint — so the build decides both, here, and records the behaviors it\n * checked in the manifest for synth to deploy as they are. Synth still runs\n * {@link validateFunctionGroups}, to fail before a `next build` it would\n * otherwise pay for.\n *\n * Nothing in this file imports `aws-cdk-lib`: it is bundled into the adapter by\n * esbuild. The public JSII struct consumers actually write (`NextjsFunctionGroup`,\n * which adds per-group `overrides`) is in `src/nextjs-compute/nextjs-functions.ts`\n * and is structurally assignable to {@link FunctionGroupSpec}.\n */\nimport { LOG_PREFIX } from \"../constants\";\nimport { ERROR_PAGE_SUFFIXES } from \"../runtime/manifest\";\nimport { basePathPrefix, hasPathPrefix } from \"../utils/base-path\";\n\n/**\n * The implicit group every unassigned route falls into. Reserved as a group\n * name: it is also the construct id suffix and the function whose URL backs the\n * distribution's default behavior.\n */\nexport const DEFAULT_FUNCTION_GROUP = \"default\";\n\n/**\n * How the resolved groups reach `onBuildComplete`, which cannot read CDK props —\n * it runs inside `next build`. `CDK_NEXTJS_INIT_CACHE_DIR` is the precedent.\n */\nexport const FUNCTION_GROUPS_ENV_VAR = \"CDK_NEXTJS_FUNCTION_GROUPS\";\n\n/** The part of a group the build side needs. */\nexport interface FunctionGroupSpec {\n  readonly name: string;\n  readonly routes: string[];\n}\n\n/** One route template and the entrypoint it invokes. */\nexport interface RouteEntry {\n  /** Basepath-prefixed route template, exactly as `manifest.entrypoints` keys it. */\n  readonly template: string;\n  /**\n   * What identifies the entrypoint: the build side passes its `filePath`, since\n   * that is what gets staged. Two templates sharing one are never split apart.\n   */\n  readonly entrypointId: string;\n  /**\n   * The entrypoint's `AdapterEntrypointType`. Only `\"page\"` changes anything: a\n   * Pages Router page is also requested at `/_next/data/<buildId>/<page>.json`,\n   * so that URL has to reach the page's group too.\n   */\n  readonly type?: string;\n}\n\n/**\n * One behavior the edge routes a group on. The Functions root constructs deploy\n * exactly these, in order: a CloudFront behavior each, or the API Gateway\n * resources for each distinct `route`.\n */\nexport interface GroupBehavior {\n  readonly group: string;\n  /**\n   * The group pattern (`/blog/**`) the behavior was generated from, or the\n   * optional catch-all parent {@link routedPatterns} added.\n   */\n  readonly route: string;\n  /**\n   * The CloudFront path pattern, before basePath and without a leading slash\n   * (`blog/*`, `_next/data/<buildId>/blog/*`).\n   */\n  readonly pattern: string;\n}\n\n/** What {@link assignRoutesToGroups} decided. */\nexport interface GroupAssignment {\n  /** Group name → the templates packaged into it, `default` included. */\n  readonly templates: Record<string, string[]>;\n  /**\n   * Every group behavior, most specific first: the order CloudFront has to see\n   * them in, since it stops at the first match. Recorded rather than\n   * recomputed at synth, so the behaviors deployed are the ones this\n   * assignment was checked against.\n   */\n  readonly behaviors: GroupBehavior[];\n}\n\n/** What {@link assignRoutesToGroups} needs to know besides the routes. */\nexport interface AssignRoutesOptions {\n  /** `next.config` `basePath`, which every manifest template carries. */\n  readonly basePath: string;\n  /**\n   * Next.js's build ID — the segment in `/_next/data/<buildId>/…` URLs, which is\n   * `ctx.buildId` and `.next/BUILD_ID`, not cdk-nextjs's deployment-suffixed\n   * one. Required when any entry is a Pages Router page.\n   */\n  readonly buildId?: string;\n  /** `next.config` `trailingSlash`. */\n  readonly trailingSlash?: boolean;\n  /**\n   * `ctx.routing`: the `next.config` rewrites whose source and destination\n   * have to land in one group, and Next.js's own dynamic route order, which\n   * decides the template a URL resolves to.\n   */\n  readonly routing: RoutingRules;\n}\n\n/** One `ctx.routing` rewrite, reduced to the fields read here. */\nexport interface RewriteRule {\n  /** The path-to-regexp source, basePath included (`/old/:path*`). */\n  readonly source?: string;\n  readonly destination?: string;\n}\n\n/** The part of `ctx.routing` {@link assignRoutesToGroups} reads. */\nexport interface RoutingRules {\n  readonly beforeFiles?: readonly RewriteRule[];\n  readonly afterFiles?: readonly RewriteRule[];\n  readonly fallback?: readonly RewriteRule[];\n  /** Next.js's own template matchers, used to resolve a rewrite's destination. */\n  readonly dynamicRoutes?: readonly {\n    readonly sourceRegex: string;\n    readonly destination?: string;\n  }[];\n}\n\nconst ERROR_PREFIX = `${LOG_PREFIX} \\`functionGroups\\`: `;\nconst NAME_PATTERN = /^[a-zA-Z0-9-]+$/;\nconst SUBTREE_SUFFIX = \"/**\";\n/**\n * The literal characters a CloudFront path pattern may contain: its alphabet\n * (`A-Z a-z 0-9 _ - . * $ / ~ \" ' @ : +` and `&`) less the two wildcards, which\n * `validateRoutePattern` only accepts as a trailing `/**`. `nextjs-distribution.ts`\n * adds the wildcards back to encode `public/` names.\n *\n * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/DownloadDistValuesCacheBehavior.html#DownloadDistValuesPathPattern\n */\nexport const PATH_PATTERN_LITERAL = /[a-zA-Z0-9_\\-.$/~\"'@:+&]/;\n\n/**\n * Read {@link FUNCTION_GROUPS_ENV_VAR}. `undefined` — not the empty array — when\n * unset, because \"no splitting\" and \"split into nothing\" are different requests\n * and only the first is valid.\n */\nexport function parseFunctionGroupsEnv(\n  value: string | undefined,\n): FunctionGroupSpec[] | undefined {\n  return value ? JSON.parse(value) : undefined;\n}\n\n/**\n * Splitting and `i18n` are mutually exclusive, and it is a CloudFront limit\n * again.\n *\n * With `i18n` configured, every route template is locale-prefixed\n * (`/en/pricing`, `/de/pricing`), so honoring a `/pricing` group would take one\n * behavior *per locale per pattern* — a budget of 75 behaviors spent in a handful\n * of routes. The alternative, a `*` in the locale position, matches any first\n * segment and would capture routes belonging to other groups. Neither is\n * something to do silently, so refuse instead.\n */\nexport function assertNoI18nSplitting(i18n: unknown): void {\n  if (i18n === null || i18n === undefined) {\n    return;\n  }\n  throw new Error(\n    `${ERROR_PREFIX}\\`functionGroups\\` cannot be combined with \\`i18n\\`. ` +\n      `With i18n every route is locale-prefixed, so routing a group at the edge ` +\n      `would need one CloudFront behavior per locale per pattern, against a ` +\n      `quota of 75 for the whole distribution. Deploy one function for every ` +\n      `route (omit \\`functionGroups\\`), or drop \\`i18n\\`.`,\n  );\n}\n\n/**\n * Reject everything that cannot be honored, at the earliest of the two sides to\n * see it. Called from both, because either can be the first: `next build` runs\n * before synth reads the manifest, but a `skipBuild: true` consumer inverts that.\n */\nexport function validateFunctionGroups(\n  groups: readonly FunctionGroupSpec[],\n): void {\n  if (groups.length === 0) {\n    throw new Error(\n      `${ERROR_PREFIX}\\`functionGroups\\` is an empty array. Omit the prop ` +\n        `entirely to deploy one function for every route, which is the default.`,\n    );\n  }\n\n  const seenNames = new Set<string>();\n  const patternOwner = new Map<string, string>();\n\n  for (const group of groups) {\n    if (group.name === DEFAULT_FUNCTION_GROUP) {\n      throw new Error(\n        `${ERROR_PREFIX}\"${DEFAULT_FUNCTION_GROUP}\" is a reserved group name: ` +\n          `it is the implicit group every unassigned route falls into.`,\n      );\n    }\n    if (!NAME_PATTERN.test(group.name)) {\n      throw new Error(\n        `${ERROR_PREFIX}Group name \"${group.name}\" must match ` +\n          `${NAME_PATTERN} — it becomes a construct id and part of a Lambda ` +\n          `function name.`,\n      );\n    }\n    if (seenNames.has(group.name)) {\n      throw new Error(\n        `${ERROR_PREFIX}Two groups are both named \"${group.name}\".`,\n      );\n    }\n    seenNames.add(group.name);\n\n    if (group.routes.length === 0) {\n      throw new Error(\n        `${ERROR_PREFIX}Group \"${group.name}\" owns no routes. Every group is a ` +\n          `Lambda function, so an empty one would deploy and never be reached.`,\n      );\n    }\n    for (const route of group.routes) {\n      validateRoutePattern(route, group.name);\n      const owner = patternOwner.get(route);\n      if (owner !== undefined) {\n        throw new Error(\n          `${ERROR_PREFIX}Pattern \"${route}\" appears in both group \"${owner}\" ` +\n            `and group \"${group.name}\". A route can only be packaged into one ` +\n            `function. (Overlapping-but-different patterns are fine: \"/api/**\" ` +\n            `in one group and \"/api/reports/**\" in another resolves ` +\n            `longest-first.)`,\n        );\n      }\n      patternOwner.set(route, group.name);\n    }\n  }\n}\n\n/**\n * A pattern is an exact static path (`/pricing`) or a subtree (`/api/reports/**`).\n *\n * **Dynamic segments are rejected**, and the reason is CloudFront rather than\n * anything about Next.js. Patterns become behavior path patterns, and CloudFront\n * supports only `*` and `?`, so `/dashboard/[id]` could only ever deploy as\n * `/dashboard/*` — which also matches `/dashboard/settings` and\n * `/dashboard/a/b/c`. If those are in another group, CloudFront routes them to a\n * function whose zip lacks their entrypoint: a crash on a route the consumer\n * explicitly assigned elsewhere. Accepting a syntax whose granularity cannot be\n * honored would be worse than rejecting it.\n *\n * The restriction costs nothing that was achievable anyway. `/dashboard/**` →\n * `/dashboard/*` is the same URL space exactly, and isolating one heavy dynamic\n * route still works as a subtree: `/api/report/**` covers `/api/report/[id]`.\n *\n * `NextjsRegionalFunctions` gets the same restriction even though API Gateway\n * REST could express `/{id}` precisely — so that switching deployment type (to\n * Regional for GovCloud, say) never silently changes how routes are grouped.\n * That one is a consistency choice, not a technical limit.\n */\nfunction validateRoutePattern(route: string, groupName: string): void {\n  const where = `Group \"${groupName}\" pattern \"${route}\"`;\n  if (!route.startsWith(\"/\")) {\n    throw new Error(\n      `${ERROR_PREFIX}${where} must start with \"/\". Patterns are URL paths as ` +\n        `the browser requests them.`,\n    );\n  }\n  // `/index` is deliberately allowed. For the App Router it is a real route of\n  // its own (`app/index/page.tsx`), which `routablePathnames` keeps apart from\n  // `/`. For the Pages Router it is the home page under the name `next build`\n  // reports it by, one entrypoint registered under `/` as well — and grouping\n  // that would leave `/` on the default behavior with a function that lacks the\n  // file. Only the assignment can tell the two apart, and its coverage check\n  // (`assertEdgeReachesEveryFile`) rejects the second.\n  if (route === \"/\") {\n    throw new Error(\n      `${ERROR_PREFIX}${where} cannot be routed. CloudFront has no path ` +\n        `pattern that matches only \"/\" — the default behavior serves it — so the ` +\n        `home page always belongs to the \"${DEFAULT_FUNCTION_GROUP}\" group. ` +\n        `Group the routes around it instead.`,\n    );\n  }\n  // `/_next/…` is Next's own URL space — build assets, `/_next/image`, and the\n  // Pages Router data routes — and each has its behavior already: the data route\n  // of a grouped page follows it (see `pathPatternsFor`), and a `_next/*` behavior\n  // would compete with the static-asset and image ones for everything else.\n  if (route === \"/_next\" || route.startsWith(\"/_next/\")) {\n    throw new Error(\n      `${ERROR_PREFIX}${where} is under \"/_next\", which Next.js reserves for ` +\n        `build assets, image optimization and data routes. A Pages Router ` +\n        `page's \"/_next/data/…\" route follows the page into its group, so ` +\n        `group the page itself instead.`,\n    );\n  }\n  if (route === SUBTREE_SUFFIX) {\n    throw new Error(\n      `${ERROR_PREFIX}${where} would own every route, leaving the default ` +\n        `group empty. Splitting exists to divide routes between functions; ` +\n        `omit \\`functionGroups\\` to deploy them all in one.`,\n    );\n  }\n  if (/[[\\]]/.test(route)) {\n    throw new Error(\n      `${ERROR_PREFIX}${where} contains a dynamic segment. Patterns become ` +\n        `CloudFront behavior path patterns, which support only \"*\" and \"?\", so ` +\n        `\"${route}\" could only deploy as a wildcard that also captures its ` +\n        `siblings. Use a subtree instead: \"/blog/**\" owns \"/blog/[slug]\".`,\n    );\n  }\n  if (/\\((.*)\\)/.test(route)) {\n    throw new Error(\n      `${ERROR_PREFIX}${where} contains a route group segment. Route groups ` +\n        `like \"(marketing)\" organize files and never appear in a URL, so they ` +\n        `cannot be routed on. Use the URL path the route is served at.`,\n    );\n  }\n  const withoutSubtree = route.endsWith(SUBTREE_SUFFIX)\n    ? route.slice(0, -SUBTREE_SUFFIX.length)\n    : route;\n  if (/[*?]/.test(withoutSubtree)) {\n    throw new Error(\n      `${ERROR_PREFIX}${where} contains a wildcard somewhere other than a ` +\n        `trailing \"/**\". The only two forms are an exact path (\"/pricing\") and ` +\n        `a subtree (\"/api/reports/**\").`,\n    );\n  }\n  if (route.includes(\"//\")) {\n    throw new Error(`${ERROR_PREFIX}${where} contains an empty path segment.`);\n  }\n  // A route Next.js serves can still hold a character no path pattern can:\n  // `app/über/page.tsx`, `app/a b/page.tsx`, `app/a,b/page.tsx` all build, and\n  // the pattern passes every check above. `pathPatternsFor` copies it verbatim,\n  // so it reached `addBehavior` untouched and was left for CloudFront to reject,\n  // in an error naming neither the group nor the route. The `public/`\n  // workaround, one `?` per UTF-8 byte, is not available here: `?` matches *any*\n  // byte, so `/über` would deploy as `/??ber` and also send `/xyber` to this\n  // group's function, whose zip lacks its entrypoint. That is the sibling capture\n  // dynamic segments are rejected for, so the same answer applies.\n  const invalid = [...new Set(withoutSubtree)].filter(\n    (char) => !PATH_PATTERN_LITERAL.test(char),\n  );\n  if (invalid.length > 0) {\n    throw new Error(\n      `${ERROR_PREFIX}${where} contains ` +\n        `${invalid.map((char) => JSON.stringify(char)).join(\", \")}, which a ` +\n        `CloudFront behavior path pattern cannot contain (allowed: A-Z a-z 0-9 ` +\n        `_ - . $ / ~ \" ' @ : + &). Escaping it with \"?\" would also match other ` +\n        `routes of the same length. Use a subtree on a parent segment whose ` +\n        `name is plain ASCII instead: \"/intl/**\" owns \"/intl/über\".`,\n    );\n  }\n}\n\n/**\n * Split every route template across the groups, longest matching pattern first,\n * then prove that the edge routes every URL each file serves to the group that\n * file was packaged into.\n *\n * Its `templates` are keyed by group name and always contain\n * {@link DEFAULT_FUNCTION_GROUP}, so callers can iterate them as the complete set\n * of functions to deploy. The default group is allowed to be empty of *templates*\n * — it still serves `/_next/image`, any static file, and anything the\n * distribution's catch-all behavior sends it.\n *\n * `basePath` is prepended to each pattern before matching, because manifest\n * templates are basePath-prefixed and consumers write the routes their app\n * declares.\n *\n * Packaging matches patterns against *templates*, but CloudFront routes *URLs*,\n * and a file answers URLs none of its templates spells: an optional catch-all's\n * parent, the `trailingSlash` form, a Pages Router data URL, every other\n * template it shares (root params synthesize `/en` and `/de` from one\n * `[locale]` page). An interception route is worse: it is never requested at its\n * own path at all. So after matching, intercepting files move to the group of\n * the URL they intercept ({@link reassignInterceptingFiles}), and the result is\n * replayed through the same behaviors `NextjsDistribution` deploys\n * ({@link assertEdgeReachesEveryFile}, {@link assertRewritesStayInGroup}). A URL\n * that would reach a function without its file throws here, during `next build`,\n * rather than answering 404 once deployed.\n */\nexport function assignRoutesToGroups(\n  groups: readonly FunctionGroupSpec[],\n  entries: readonly RouteEntry[],\n  options: AssignRoutesOptions,\n): GroupAssignment {\n  validateFunctionGroups(groups);\n  const basePath = basePathPrefix(options.basePath);\n\n  // Matched with the very behaviors `NextjsDistribution` deploys for the\n  // declared patterns, most specific first, so packaging and the edge share one\n  // routing model and the first match is the winner. Data routes are left out:\n  // no template is under `/_next`, and which groups have them is decided by\n  // this assignment.\n  const edgeBase = {\n    basePath,\n    buildId: options.buildId,\n    trailingSlash: options.trailingSlash ?? false,\n  };\n  const patterns = edgeBehaviors(\n    groups,\n    {},\n    { ...edgeBase, dataRouteGroups: new Set() },\n  );\n\n  const matchedPatterns = new Set<string>();\n  // An entrypoint is a *file*; two templates can share one (a Pages Router page\n  // and its `/_next/data/<buildId>/…json` sibling). Splitting them across zips\n  // would stage the same file twice and route one of them to a function that\n  // has it by accident, so ownership is recorded per entrypoint and reused.\n  const groupOfEntrypoint = new Map<string, string>();\n  // Which `patterns` index won the entrypoint. `patterns` is sorted\n  // most-specific-first, so a lower index is the better claim, and keeping it\n  // stops a second template that shares the entrypoint from taking it over with\n  // a *broader* pattern. Without it the owner was whichever of the two templates\n  // `entries` happened to visit last — the same build grouped differently\n  // depending on manifest key order.\n  const winningIndexOfEntrypoint = new Map<string, number>();\n\n  for (const entry of entries) {\n    let winner: number | undefined;\n    for (const [index, pattern] of patterns.entries()) {\n      if (!pattern.regex.test(entry.template)) {\n        continue;\n      }\n      // Every match is recorded, not only the winning one. A pattern fully\n      // shadowed by a narrower pattern in another group never wins anything —\n      // \"/api/**\" against an app whose only API routes are under\n      // \"/api/reports/**\" — so recording just the winner left it looking like a\n      // typo and threw below, rejecting the very layout the duplicate-pattern\n      // error a few lines up documents as supported.\n      matchedPatterns.add(`${pattern.group}\\u0000${pattern.route}`);\n      winner ??= index;\n    }\n    // An intercepting file's own template (`/feed/(..)photo/[id]`) is not a URL\n    // anyone requests, so it does not decide the file's group; the URL it\n    // intercepts does, below. Its match still counts against the typo check.\n    if (winner === undefined || isInterceptionTemplate(entry.template)) {\n      continue;\n    }\n    const incumbent = winningIndexOfEntrypoint.get(entry.entrypointId);\n    if (incumbent === undefined || winner < incumbent) {\n      winningIndexOfEntrypoint.set(entry.entrypointId, winner);\n      groupOfEntrypoint.set(entry.entrypointId, patterns[winner].group);\n    }\n  }\n\n  // A pattern matching nothing is a typo, and a typo here is invisible: the\n  // route stays in the default group and the split silently does less than it\n  // was asked to. Cheap to catch, so catch it.\n  for (const group of groups) {\n    for (const route of group.routes) {\n      if (!matchedPatterns.has(`${group.name}\\u0000${route}`)) {\n        throw new Error(\n          `${ERROR_PREFIX}Group \"${group.name}\" pattern \"${route}\" matches no ` +\n            `route in this build. ` +\n            optionalCatchAllParentHint(route, entries, basePath) +\n            `Patterns match route templates as Next.js declares them (e.g. ` +\n            `\"/blog/[slug]\" is matched by \"/blog/**\"), and prerendered pages and ` +\n            `static assets are served from S3 and need no group.`,\n        );\n      }\n    }\n  }\n\n  const edge: EdgeOptions = {\n    ...edgeBase,\n    // Only a group that owns a Pages Router page has data URLs to route. Read\n    // before interception moves files: those are App Router, never pages.\n    dataRouteGroups: new Set(\n      entries\n        .filter((entry) => entry.type === \"page\")\n        .map(\n          (entry) =>\n            groupOfEntrypoint.get(entry.entrypointId) ?? DEFAULT_FUNCTION_GROUP,\n        ),\n    ),\n  };\n  reassignInterceptingFiles(\n    entries,\n    groupOfEntrypoint,\n    edgeBehaviors(\n      groups,\n      templatesByGroup(groups, entries, groupOfEntrypoint),\n      edge,\n    ),\n    edge,\n  );\n  const assigned = templatesByGroup(groups, entries, groupOfEntrypoint);\n  // Rebuilt rather than reused: an intercepting file never adds an optional\n  // catch-all parent, so this is the same list, but only by that argument.\n  const behaviors = edgeBehaviors(groups, assigned, edge);\n  const router: Router = {\n    fileOfTemplate: fileOfTemplate(entries),\n    routing: options.routing,\n  };\n  assertEdgeReachesEveryFile(\n    entries,\n    groupOfEntrypoint,\n    behaviors,\n    edge,\n    router,\n  );\n  assertRewritesStayInGroup(groupOfEntrypoint, behaviors, router);\n\n  for (const key of Object.keys(assigned)) {\n    assigned[key] = [...assigned[key]].sort();\n  }\n  return {\n    templates: assigned,\n    behaviors: behaviors.map(({ group, route, pattern }) => ({\n      group,\n      route,\n      pattern,\n    })),\n  };\n}\n\n/**\n * The patterns a group is *routed* on: the ones it declares, plus the parent\n * path of every optional catch-all a subtree pattern moved into it.\n *\n * `/blog/[[...slug]]` serves `/blog` as well as everything under it, and\n * `/blog/**` moves the whole file — but deploys as `blog/*`, which does not\n * match `/blog`. So the parent is routed automatically, as an exact pattern of\n * its own; declaring `/blog` by hand is a pattern with no route of its own and\n * is rejected as a typo, with a hint pointing here. Nothing else a subtree owns\n * needs this: a file whose parent URL is its subtree's base can only be an\n * optional catch-all, since Next.js rejects `app/blog/page.tsx` next to it.\n *\n * @param ownedTemplates the templates assigned to the group, basePath-prefixed\n *   as `manifest.groups` records them\n */\nexport function routedPatterns(\n  routes: readonly string[],\n  ownedTemplates: readonly string[],\n  basePath: string,\n): string[] {\n  const result = [...routes];\n  for (const route of routes) {\n    if (!route.endsWith(SUBTREE_SUFFIX)) {\n      continue;\n    }\n    const parent = route.slice(0, -SUBTREE_SUFFIX.length);\n    const prefix = `${prefixBasePath(parent, basePath)}/`;\n    const ownsOptionalCatchAll = ownedTemplates.some(\n      (template) =>\n        template.startsWith(prefix) &&\n        OPTIONAL_CATCH_ALL_SEGMENT.test(template.slice(prefix.length)),\n    );\n    if (ownsOptionalCatchAll && !result.includes(parent)) {\n      result.push(parent);\n    }\n  }\n  return result;\n}\n\n/**\n * CloudFront path patterns for one group pattern, without a leading slash —\n * the form `NextjsDistribution.getPathPattern` expects, so the basePath is\n * added there rather than here.\n *\n * Two patterns come back when the group owns a Pages Router route: its RSC-era\n * equivalent is a second URL space, `/_next/data/<buildId>/<route>.json`, which\n * the default behavior would otherwise send to the default group.\n *\n * A third comes back for an exact route in a `trailingSlash` app, where the\n * canonical URL is `/pricing/` rather than `/pricing`: the bare pattern does not\n * match it, so without this every request for the route the user actually links to\n * falls through to the default group's function — which, for a Pages Router API\n * route, has no entrypoint for it at all. Subtree patterns need no variant\n * (`pricing/*` already matches `/pricing/`), and neither do the data URLs, which\n * never carry the slash.\n */\nexport function pathPatternsFor(\n  route: string,\n  options: {\n    hasDataRoutes: boolean;\n    trailingSlash?: boolean;\n    buildId?: string;\n  },\n): string[] {\n  const isSubtree = route.endsWith(SUBTREE_SUFFIX);\n  const base = isSubtree ? route.slice(0, -SUBTREE_SUFFIX.length) : route;\n  const bare = base.replace(/^\\//, \"\");\n  const patterns = [isSubtree ? `${bare}/*` : bare];\n  if (!isSubtree && options.trailingSlash && bare) {\n    patterns.push(`${bare}/`);\n  }\n  if (options.hasDataRoutes) {\n    // The literal build ID, not a `*` for it. CloudFront's `*` also matches\n    // `/`, so `_next/data/*/blog/*` claimed `/_next/data/<id>/docs/blog/x.json`\n    // too — another group's page, sent to a function without it. Every other\n    // pattern is anchored at the start of the path; this one now is as well.\n    //\n    // It makes these behaviors change whenever the build ID does, which is every\n    // deploy unless `deploymentId` pins it. A client still holding the previous\n    // build requests `/_next/data/<old id>/…`, which no behavior matches, so it\n    // reaches the default function. That is correct rather than merely\n    // harmless: `next start` 404s a data request for another build ID\n    // (`handleNextDataRequest` in `next/dist/server/base-server.js`) and so does\n    // the runtime, which has no pathname for it, and the Pages Router client\n    // treats a data 404 as an asset error and hard-navigates to the page\n    // (`fetchNextData` → `markAssetError` → `handleRouteInfoError` in\n    // `next/dist/shared/lib/router/router.js`), which gets the new build.\n    patterns.push(\n      isSubtree\n        ? `_next/data/${dataBuildId(options.buildId)}/${bare}/*`\n        : `_next/data/${dataBuildId(options.buildId)}/${bare}.json`,\n    );\n  }\n  return patterns;\n}\n\n/**\n * Rank a CloudFront path pattern so the most specific is added first: literal\n * segments before the first `*` dominate, then an exact pattern before a\n * wildcard one, then total segments, then length. {@link edgeBehaviors} sorts\n * on it.\n *\n * Ranking on the leading literal is what a CloudFront wildcard forces, because\n * it matches across `/` rather than within one segment: an exact `a/b` has to\n * precede the subtree `a/*` that would otherwise swallow it, though the two are\n * the same length and depth. At equal literal depth the exact one still goes\n * first, since a trailingSlash `a/b/` is otherwise outranked by the subtree\n * `a/b/*`, one segment longer, that matches it. Since the data patterns carry\n * the literal build ID, no pattern has a wildcard anywhere but at its end.\n */\nfunction behaviorSpecificity(pattern: string): number {\n  const segments = pattern.split(\"/\").filter(Boolean);\n  const firstWildcard = segments.findIndex((segment) => segment.includes(\"*\"));\n  const literalDepth = firstWildcard === -1 ? segments.length : firstWildcard;\n  const exact = firstWildcard === -1 ? 1 : 0;\n  return (\n    (literalDepth * 2 + exact) * 1000000 +\n    segments.length * 10000 +\n    pattern.length\n  );\n}\n\n/**\n * The build ID as it goes into a path pattern. A custom `generateBuildId` can\n * return anything, and a character CloudFront cannot spell would otherwise fail\n * the deploy naming neither the build ID nor the group.\n */\nfunction dataBuildId(buildId: string | undefined): string {\n  if (!buildId) {\n    throw new Error(\n      `${ERROR_PREFIX}Routing a Pages Router app's \"/_next/data/<buildId>/…\" ` +\n        `URLs needs its build ID, and none was passed. This is a cdk-nextjs ` +\n        `bug: the build ID comes from the adapter manifest.`,\n    );\n  }\n  const invalid = [...new Set(buildId)].filter(\n    (char) => !PATH_PATTERN_LITERAL.test(char) || char === \"/\",\n  );\n  if (invalid.length > 0) {\n    throw new Error(\n      `${ERROR_PREFIX}The build ID \"${buildId}\" contains ` +\n        `${invalid.map((char) => JSON.stringify(char)).join(\", \")}, which a ` +\n        `CloudFront path pattern cannot hold, so its \"/_next/data\" URLs cannot ` +\n        `be routed to a group. Make \\`generateBuildId\\` return only A-Z a-z ` +\n        `0-9 _ - . characters.`,\n    );\n  }\n  return buildId;\n}\n\n/**\n * The typo check's hint for the one exact pattern that was the documented\n * workaround: the parent of an optional catch-all, which has no template.\n */\nfunction optionalCatchAllParentHint(\n  route: string,\n  entries: readonly RouteEntry[],\n  basePath: string,\n): string {\n  if (route.endsWith(SUBTREE_SUFFIX)) {\n    return \"\";\n  }\n  const prefix = `${prefixBasePath(route, basePath)}/`;\n  const catchAll = entries.find(\n    (entry) =>\n      entry.template.startsWith(prefix) &&\n      OPTIONAL_CATCH_ALL_SEGMENT.test(entry.template.slice(prefix.length)),\n  );\n  if (!catchAll) {\n    return \"\";\n  }\n  return (\n    `\"${route}\" is served by the optional catch-all \"${catchAll.template}\", ` +\n    `whose subtree pattern \"${route}${SUBTREE_SUFFIX}\" routes \"${route}\" as ` +\n    `well — use that instead. `\n  );\n}\n\n/** `/blog/[[...slug]]`'s last segment. */\nconst OPTIONAL_CATCH_ALL_SEGMENT = /^\\[\\[\\.\\.\\.[^\\]/]+\\]\\]$/;\n\n/**\n * Next.js's interception markers, longest-overlapping first, exactly as\n * `INTERCEPTION_ROUTE_MARKERS` in\n * `next/dist/shared/lib/router/utils/interception-routes.js` orders them.\n */\nconst INTERCEPTION_MARKERS = [\"(..)(..)\", \"(.)\", \"(..)\", \"(...)\"];\n\nfunction interceptionMarkerOf(path: string): string | undefined {\n  for (const segment of path.split(\"/\")) {\n    const marker = INTERCEPTION_MARKERS.find((it) => segment.startsWith(it));\n    if (marker) {\n      return marker;\n    }\n  }\n  return undefined;\n}\n\nfunction isInterceptionTemplate(template: string): boolean {\n  return interceptionMarkerOf(template) !== undefined;\n}\n\n/**\n * The route an interception route intercepts: `/feed/(..)photo/[id]` →\n * `/photo/[id]`. `extractInterceptionRouteInformation` from\n * `next/dist/shared/lib/router/utils/interception-routes.js`, restated because\n * this file is bundled without `next`. The template is already a normalized app\n * path (no route groups, no `@slot`s), so none of its normalization is needed.\n * Next.js's interception rewrite matches exactly this path, and only with a\n * `Next-Url` header — which CloudFront does not route on.\n */\nexport function interceptedRoute(path: string): string | undefined {\n  const marker = interceptionMarkerOf(path);\n  if (marker === undefined) {\n    return undefined;\n  }\n  const at = path.indexOf(marker);\n  const intercepting = path.slice(0, at).split(\"/\").filter(Boolean);\n  const rest = path\n    .slice(at + marker.length)\n    .split(\"/\")\n    .filter(Boolean);\n  const parent =\n    marker === \"(.)\"\n      ? intercepting\n      : marker === \"(..)\"\n        ? intercepting.slice(0, -1)\n        : marker === \"(..)(..)\"\n          ? intercepting.slice(0, -2)\n          : [];\n  return `/${[...parent, ...rest].join(\"/\")}`;\n}\n\n/**\n * Templates that name what a request is *rewritten* to inside Next.js, never\n * what the browser asks for: the RSC payload (`/pricing.rsc`) and segment\n * prefetches (`/pricing.segments/…`) are requested as `/pricing` with an `RSC`\n * header, which is why `pricing` alone has always routed them.\n */\nfunction isInternalTemplate(path: string): boolean {\n  return path.endsWith(\".rsc\") || path.includes(\".segments/\");\n}\n\n/** What the edge routes on. */\ninterface EdgeOptions {\n  /** With a leading slash, `\"\"` for none. */\n  readonly basePath: string;\n  readonly buildId?: string;\n  readonly trailingSlash: boolean;\n  /** The groups that own a Pages Router page, and so have data URLs. */\n  readonly dataRouteGroups: ReadonlySet<string>;\n}\n\n/** A {@link GroupBehavior}, with the regex CloudFront matches it as. */\ninterface EdgeBehavior extends GroupBehavior {\n  readonly regex: RegExp;\n}\n\n/**\n * Every group behavior, most specific first: the order CloudFront has to see\n * them in, since it stops at the first match. The assignment returns this list\n * and the constructs deploy it as it is.\n */\nfunction edgeBehaviors(\n  groups: readonly FunctionGroupSpec[],\n  assigned: Record<string, string[]>,\n  edge: EdgeOptions,\n): EdgeBehavior[] {\n  return groups\n    .flatMap((group) =>\n      routedPatterns(\n        group.routes,\n        assigned[group.name] ?? [],\n        edge.basePath,\n      ).flatMap((route) =>\n        pathPatternsFor(route, {\n          trailingSlash: edge.trailingSlash,\n          buildId: edge.buildId,\n          hasDataRoutes: edge.dataRouteGroups.has(group.name),\n        }).map((pattern) => ({\n          group: group.name,\n          route,\n          pattern,\n          regex: cloudFrontPatternRegex(`${edge.basePath}/${pattern}`),\n        })),\n      ),\n    )\n    .sort(\n      (a, b) => behaviorSpecificity(b.pattern) - behaviorSpecificity(a.pattern),\n    );\n}\n\n/**\n * CloudFront path pattern matching: anchored at both ends, `*` for any run of\n * characters `/` included, `?` for exactly one, case-sensitive. `pattern` has to\n * carry the leading slash CloudFront implies.\n *\n * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/DownloadDistValuesCacheBehavior.html#DownloadDistValuesPathPattern\n */\nexport function cloudFrontPatternRegex(pattern: string): RegExp {\n  const source = [...pattern]\n    .map((char) =>\n      char === \"*\"\n        ? \".*\"\n        : char === \"?\"\n          ? \".\"\n          : char.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\"),\n    )\n    .join(\"\");\n  return new RegExp(`^${source}$`);\n}\n\n/** The behavior CloudFront would pick for `url`, `undefined` for the default one. */\nfunction edgeBehaviorFor(\n  behaviors: readonly EdgeBehavior[],\n  url: string,\n): EdgeBehavior | undefined {\n  return behaviors.find((behavior) => behavior.regex.test(url));\n}\n\nfunction templatesByGroup(\n  groups: readonly FunctionGroupSpec[],\n  entries: readonly RouteEntry[],\n  groupOfEntrypoint: ReadonlyMap<string, string>,\n): Record<string, string[]> {\n  const assigned: Record<string, string[]> = {\n    [DEFAULT_FUNCTION_GROUP]: [],\n  };\n  for (const group of groups) {\n    assigned[group.name] = [];\n  }\n  for (const entry of entries) {\n    const group =\n      groupOfEntrypoint.get(entry.entrypointId) ?? DEFAULT_FUNCTION_GROUP;\n    assigned[group].push(entry.template);\n  }\n  return assigned;\n}\n\n/**\n * Put each intercepting file in the group of the URL it intercepts.\n *\n * With `/feed/**` grouped, `app/feed/(..)photo/[id]/page.tsx` matched it and\n * moved to the feed group. But the soft navigation it exists for requests\n * `/photo/1` with a `Next-Url: /feed` header; CloudFront routes on the URL alone,\n * so the request reaches whichever function owns `/photo/*`, where Next.js's\n * interception rewrite (a `beforeFiles` rule on that header) resolves it to the\n * intercepting file — which that function did not have.\n *\n * Moving the file there is always possible unless the intercepted URL space is\n * itself split: `/photo/[id]` in the default group with `/photo/1` grouped\n * elsewhere would need the file in both. That throws.\n */\nfunction reassignInterceptingFiles(\n  entries: readonly RouteEntry[],\n  groupOfEntrypoint: Map<string, string>,\n  behaviors: readonly EdgeBehavior[],\n  edge: EdgeOptions,\n): void {\n  for (const entry of entries) {\n    const path = stripBasePath(entry.template, edge.basePath);\n    if (path === undefined || isInternalTemplate(path)) {\n      continue;\n    }\n    const target = interceptedRoute(path);\n    if (target === undefined) {\n      continue;\n    }\n    const url = withBasePath(target, edge.basePath);\n    const group =\n      edgeBehaviorFor(behaviors, url)?.group ?? DEFAULT_FUNCTION_GROUP;\n    const intercepted = templateRegex(url);\n    const split = behaviors.find(\n      (behavior) =>\n        behavior.group !== group &&\n        !behavior.pattern.startsWith(\"_next/data/\") &&\n        sampleUrl(behavior.route, edge.basePath).some((it) =>\n          intercepted.test(it),\n        ),\n    );\n    if (split) {\n      throw new Error(\n        `${ERROR_PREFIX}\"${entry.entrypointId}\" is the interception route ` +\n          `\"${entry.template}\", which Next.js reaches by rewriting a request for ` +\n          `\"${url}\" inside whichever function CloudFront sent it to — so it is ` +\n          `packaged with the group that owns \"${url}\". That URL space is split, ` +\n          `though: most of it reaches ${groupLabel(group)}, but group ` +\n          `\"${split.group}\"'s pattern \"${split.route}\" claims part of it, and ` +\n          `one file cannot be in both. Route all of \"${target}\" to one group.`,\n      );\n    }\n    groupOfEntrypoint.set(entry.entrypointId, group);\n  }\n}\n\n/** A URL a group pattern routes, to test against another route's URL space. */\nfunction sampleUrl(route: string, basePath: string): string[] {\n  return route.endsWith(SUBTREE_SUFFIX)\n    ? [`${basePath}${route.slice(0, -SUBTREE_SUFFIX.length)}/_`]\n    : [`${basePath}${route}`];\n}\n\n/** The URLs a template stands for, as a regex: `[id]` is one segment, and so on. */\nfunction templateRegex(template: string): RegExp {\n  const source = template\n    .split(\"/\")\n    .filter(Boolean)\n    .map(\n      (segment) =>\n        [\n          `/${segment.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\")}`,\n          \"/[^/]+\",\n          \"/.+\",\n          \"(?:/.+)?\",\n        ][segmentKind(segment)],\n    )\n    .join(\"\");\n  return new RegExp(`^${source || \"/\"}$`);\n}\n\n/**\n * Throw unless every URL each file serves reaches the group holding it.\n *\n * Checked for every file, the default group's included: the invariant is \"the\n * edge never sends a request to a function without its file\", and a group\n * pattern can break it by claiming a URL of a file left in the default group as\n * easily as by leaving one behind. A dynamic template stands for a URL space,\n * not one URL, so it is also checked against the part of that space other\n * groups' patterns capture ({@link capturedDynamicUrls}): a `/[...slug]` left in\n * the default group answers `/blog/a/b` too, which `/blog/**` sends elsewhere.\n *\n * Only the URLs as Next.js spells them are replayed, and that is a known gap\n * rather than an oversight: CloudFront path patterns and API Gateway resources\n * both match case-sensitively, while `@next/routing` matches templates\n * case-insensitively. `/API/reports/1` therefore misses a `/api/reports/**`\n * group and reaches the default function, which resolves it to a template it\n * does not have. Neither edge can be told to fold case, and lowercasing at the\n * edge would break the case-sensitive S3 keys behind `public/`, so there is\n * nothing to check here that could pass; the runtime answers such a request\n * itself (see `ownedRouteError`).\n */\nfunction assertEdgeReachesEveryFile(\n  entries: readonly RouteEntry[],\n  groupOfEntrypoint: ReadonlyMap<string, string>,\n  behaviors: readonly EdgeBehavior[],\n  edge: EdgeOptions,\n  router: Router,\n): void {\n  const files = new Map<string, RouteEntry[]>();\n  for (const entry of entries) {\n    const list = files.get(entry.entrypointId) ?? [];\n    list.push(entry);\n    files.set(entry.entrypointId, list);\n  }\n  // Deep enough for a sample to get past every template a capturing group\n  // could shadow it with.\n  const deepest =\n    Math.max(\n      0,\n      ...entries.map((entry) => {\n        const path = stripBasePath(entry.template, edge.basePath);\n        return path !== undefined && isRoutablePath(path)\n          ? path.split(\"/\").filter(Boolean).length\n          : 0;\n      }),\n    ) + 1;\n  for (const [file, fileEntries] of files) {\n    const owner = groupOfEntrypoint.get(file) ?? DEFAULT_FUNCTION_GROUP;\n    const misrouted: Misroute[] = [];\n    for (const entry of fileEntries) {\n      for (const url of servedUrls(entry.template, entry.type, edge)) {\n        const behavior = edgeBehaviorFor(behaviors, url);\n        const group = behavior?.group ?? DEFAULT_FUNCTION_GROUP;\n        if (group !== owner && !misrouted.some((it) => it.url === url)) {\n          misrouted.push({ url, group, route: behavior?.route });\n        }\n      }\n      for (const it of capturedDynamicUrls(\n        entry,\n        owner,\n        deepest,\n        behaviors,\n        edge,\n        router,\n      )) {\n        if (!misrouted.some((known) => known.url === it.url)) {\n          misrouted.push(it);\n        }\n      }\n    }\n    if (misrouted.length > 0) {\n      throw new Error(misroutedFileMessage(file, owner, misrouted, edge));\n    }\n  }\n}\n\ninterface Misroute {\n  readonly url: string;\n  /** Where CloudFront sends it. */\n  readonly group: string;\n  /** The pattern that sent it there, `undefined` for the default behavior. */\n  readonly route?: string;\n  /**\n   * Set when `url` is a sample of a dynamic template's URL space rather than\n   * a URL the template spells: the template Next.js resolves it to there.\n   */\n  readonly servedAs?: string;\n}\n\n/**\n * Stands in for \"any value\" of a dynamic segment in a sample URL. A literal\n * template of that exact name would shadow it, which can only hide a misroute,\n * never invent one.\n */\nconst ANY_SEGMENT = \"_\";\n\n/**\n * Whether a request can resolve to `path` (basePath stripped) directly: not an\n * RSC or segment rewrite, an interception route, or a data-URL alias (a data URL\n * resolves to the page it names).\n */\nfunction isRoutablePath(path: string): boolean {\n  return (\n    !isInternalTemplate(path) &&\n    !isInterceptionTemplate(path) &&\n    !path.startsWith(\"/_next/data/\")\n  );\n}\n\n/** 0 static, 1 `[param]`, 2 `[...catchAll]`, 3 `[[...optional]]`. */\nfunction segmentKind(segment: string): number {\n  if (OPTIONAL_CATCH_ALL_SEGMENT.test(segment)) {\n    return 3;\n  }\n  if (/^\\[\\.\\.\\.[^\\]]+\\]$/.test(segment)) {\n    return 2;\n  }\n  return /^\\[[^\\]]+\\]$/.test(segment) ? 1 : 0;\n}\n\n/**\n * The URLs of a *dynamic* template's space that another group's behavior\n * captures, and that Next.js — running in that group's function — still\n * resolves to this template's file.\n *\n * `servedUrls` replays the template as spelled, which is exact for a static\n * route but not for `/[...slug]`: the text `/[...slug]` never matches `blog/*`,\n * yet `/blog/a/b` does, reaches the blog function, and resolves there to\n * `/[...slug]`, which the blog zip lacks. So each other group's behavior is\n * intersected with the template's URL space, one sample URL per shape\n * ({@link sampleTemplatePaths}), and each sample is resolved the way Next.js\n * resolves it ({@link resolveFile}). A more specific template in the capturing\n * group legitimately shadows the sample (`/blog/[slug]` answers `/blog/_`, so\n * only `/blog/_/_` is a misroute); anything it does not shadow is flagged.\n */\nfunction capturedDynamicUrls(\n  entry: RouteEntry,\n  owner: string,\n  deepest: number,\n  behaviors: readonly EdgeBehavior[],\n  edge: EdgeOptions,\n  router: Router,\n): Misroute[] {\n  const path = stripBasePath(entry.template, edge.basePath);\n  if (\n    path === undefined ||\n    !path.includes(\"[\") ||\n    ERROR_PAGE_SUFFIXES.includes(path) ||\n    !isRoutablePath(path)\n  ) {\n    return [];\n  }\n  const segments = path.split(\"/\").filter(Boolean);\n  const samples = new Set<string>();\n  for (const behavior of behaviors) {\n    if (\n      behavior.group === owner ||\n      behavior.pattern.startsWith(\"_next/data/\")\n    ) {\n      continue;\n    }\n    const bare = behavior.pattern.replace(/\\/$/, \"\");\n    const isSubtree = bare.endsWith(\"/*\");\n    const prefix = (isSubtree ? bare.slice(0, -2) : bare)\n      .split(\"/\")\n      .filter(Boolean);\n    for (const sample of sampleTemplatePaths(\n      segments,\n      prefix,\n      isSubtree,\n      Math.max(deepest, prefix.length + 1),\n    )) {\n      samples.add(sample);\n    }\n  }\n  const misrouted: Misroute[] = [];\n  // `resolved` is `url` as Next.js matches it: without the trailing slash.\n  const check = (url: string, resolved: string) => {\n    const behavior = edgeBehaviorFor(behaviors, url);\n    const group = behavior?.group ?? DEFAULT_FUNCTION_GROUP;\n    if (group === owner || misrouted.some((it) => it.url === url)) {\n      return;\n    }\n    if (resolveFile(resolved, router) === entry.entrypointId) {\n      misrouted.push({\n        url,\n        group,\n        route: behavior?.route,\n        servedAs: entry.template,\n      });\n    }\n  };\n  for (const sample of samples) {\n    for (const { url, resolved } of urlVariants(sample, entry.type, edge)) {\n      check(url, resolved);\n    }\n  }\n  return misrouted;\n}\n\n/**\n * Sample paths in both a template's URL space and a behavior's: for a subtree\n * `prefix/*`, every way the template's segments can line up with `prefix` and\n * continue past it, one sample per resulting length up to `maxDepth`, with\n * {@link ANY_SEGMENT} for each dynamic value beyond the prefix. For an exact\n * pattern, the pattern's own path if the template matches it.\n */\nfunction sampleTemplatePaths(\n  template: readonly string[],\n  prefix: readonly string[],\n  isSubtree: boolean,\n  maxDepth: number,\n): string[] {\n  if (!isSubtree) {\n    const path = `/${prefix.join(\"/\")}`;\n    return templateRegex(`/${template.join(\"/\")}`).test(path) ? [path] : [];\n  }\n  const valueAt = (at: number) =>\n    at < prefix.length ? prefix[at] : ANY_SEGMENT;\n  const results: string[] = [];\n  const walk = (index: number, acc: readonly string[]): void => {\n    if (index === template.length) {\n      // Exactly the prefix is kept too: `prefix/*` matches its trailing-slash\n      // form, which `check` adds for a `trailingSlash` app.\n      if (acc.length >= prefix.length) {\n        results.push(`/${acc.join(\"/\")}`);\n      }\n      return;\n    }\n    const segment = template[index];\n    const at = acc.length;\n    const kind = segmentKind(segment);\n    if (kind === 0) {\n      if (at >= prefix.length || prefix[at] === segment) {\n        walk(index + 1, [...acc, segment]);\n      }\n      return;\n    }\n    if (kind === 1) {\n      walk(index + 1, [...acc, valueAt(at)]);\n      return;\n    }\n    for (let count = kind === 2 ? 1 : 0; at + count <= maxDepth; count++) {\n      const taken = Array.from({ length: count }, (_, i) => valueAt(at + i));\n      walk(index + 1, [...acc, ...taken]);\n    }\n  };\n  walk(0, []);\n  return results;\n}\n\n/**\n * The URLs one template's file answers at the edge.\n *\n * Nothing for the error pages (every group stages them), the RSC and\n * segment-prefetch rewrites (requested at the page's own URL), and interception\n * routes (reached only through the intercepted URL's rewrite). Otherwise the\n * template itself, an optional catch-all's parent, and for each of those the\n * `trailingSlash` form and a Pages Router page's data URL. Only the slash-less\n * data URL: the client never adds one.\n */\nfunction servedUrls(\n  template: string,\n  type: string | undefined,\n  edge: EdgeOptions,\n): string[] {\n  const path = stripBasePath(template, edge.basePath);\n  if (\n    path === undefined ||\n    ERROR_PAGE_SUFFIXES.includes(path) ||\n    isInternalTemplate(path) ||\n    isInterceptionTemplate(path)\n  ) {\n    return [];\n  }\n  if (path.startsWith(\"/_next/data/\")) {\n    return [template];\n  }\n  const paths = [path];\n  const optional = /^(.*)\\/(\\[\\[\\.\\.\\.[^\\]/]+\\]\\])$/.exec(path);\n  if (optional) {\n    paths.push(optional[1] || \"/\");\n  }\n  return paths.flatMap((it) =>\n    urlVariants(it, type, edge).map(({ url }) => url),\n  );\n}\n\n/**\n * A path's URL, its `trailingSlash` form and a Pages Router page's data URL,\n * each with `resolved`: the URL as Next.js matches it, without the trailing slash.\n */\nfunction urlVariants(\n  path: string,\n  type: string | undefined,\n  edge: EdgeOptions,\n): { url: string; resolved: string }[] {\n  const url = withBasePath(path, edge.basePath);\n  const variants = [{ url, resolved: url }];\n  if (edge.trailingSlash && path !== \"/\") {\n    variants.push({ url: `${url}/`, resolved: url });\n  }\n  if (type === \"page\" && edge.buildId) {\n    const data = `${edge.basePath}/_next/data/${edge.buildId}${path === \"/\" ? \"/index\" : path}.json`;\n    variants.push({ url: data, resolved: data });\n  }\n  return variants;\n}\n\nfunction misroutedFileMessage(\n  file: string,\n  owner: string,\n  misrouted: readonly Misroute[],\n  edge: EdgeOptions,\n): string {\n  const where = misrouted\n    .map(\n      (it) =>\n        `\"${it.url}\" to ${groupLabel(it.group)}` +\n        (it.route ? ` (its pattern \"${it.route}\")` : \"\"),\n    )\n    .join(\", \");\n  const head =\n    `${ERROR_PREFIX}\"${file}\" is packaged into ${groupLabel(owner)}, but ` +\n    `CloudFront would send ${where}, whose function does not have it: a 404 on ` +\n    `every such request. Every URL one file serves has to reach the group that ` +\n    `holds the file.`;\n  const captured = misrouted.filter((it) => it.servedAs !== undefined);\n  if (captured.length > 0) {\n    const templates = [...new Set(captured.map((it) => `\"${it.servedAs}\"`))];\n    return (\n      `${head} Those URLs are part of the dynamic route ` +\n      `${templates.join(\", \")} (\"${ANY_SEGMENT}\" stands for any segment ` +\n      `value): the pattern captures them at the edge, and no route packaged ` +\n      `into the capturing group is more specific, so Next.js still resolves ` +\n      `them to this file. Give that group a route that answers them (a ` +\n      `catch-all under its pattern, say), or narrow the pattern.`\n    );\n  }\n  if (owner === DEFAULT_FUNCTION_GROUP) {\n    return (\n      `${head} A pattern claims a URL of a file that no pattern moved: narrow ` +\n      `it, or give the group the file's other routes too.`\n    );\n  }\n  const unroutable = misrouted.filter(\n    (it) => suggestedPattern(it.url, edge) === undefined,\n  );\n  if (unroutable.length > 0) {\n    return (\n      `${head} ${unroutable.map((it) => `\"${it.url}\"`).join(\", \")} cannot be ` +\n      `routed to any group — CloudFront has no pattern for the home page alone, ` +\n      `and a dynamic first segment would need \"/**\" — so this file can only be ` +\n      `served by the \"${DEFAULT_FUNCTION_GROUP}\" group. Remove the pattern that ` +\n      `moved it. (A Pages Router home page is also \"/index\": one file.)`\n    );\n  }\n  const suggestions = [\n    ...new Set(misrouted.map((it) => suggestedPattern(it.url, edge)!)),\n  ];\n  return (\n    `${head} Add ${suggestions.map((it) => `\"${it}\"`).join(\", \")} to group ` +\n    `\"${owner}\"'s routes.`\n  );\n}\n\n/**\n * The group pattern that would route `url`, `undefined` when none can: a static\n * path routes as itself, a dynamic one as the subtree above its first dynamic\n * segment, and a data URL or `trailingSlash` form as the page it belongs to.\n */\nfunction suggestedPattern(url: string, edge: EdgeOptions): string | undefined {\n  let path = stripBasePath(url, edge.basePath) ?? url;\n  const dataPrefix = `/_next/data/${edge.buildId}/`;\n  if (path.startsWith(dataPrefix) && path.endsWith(\".json\")) {\n    path = `/${path.slice(dataPrefix.length, -\".json\".length)}`;\n    path = path === \"/index\" ? \"/\" : path;\n  }\n  if (path.length > 1 && path.endsWith(\"/\")) {\n    path = path.slice(0, -1);\n  }\n  const segments = path.split(\"/\").filter(Boolean);\n  const firstDynamic = segments.findIndex((segment) => segment.startsWith(\"[\"));\n  if (segments.length === 0 || firstDynamic === 0) {\n    return undefined;\n  }\n  return firstDynamic === -1\n    ? path\n    : `/${segments.slice(0, firstDynamic).join(\"/\")}${SUBTREE_SUFFIX}`;\n}\n\n/**\n * Throw on a `next.config` rewrite whose source reaches one group and whose\n * destination is packaged into another.\n *\n * A rewrite runs inside the function that received the request, so\n * `/old/:path*` → `/new` with `/new/**` grouped and `/old` not sends `/old/x` to\n * the default function, which rewrites it to a file it lacks.\n *\n * Only the rewrites whose destination is a literal path can be resolved to a\n * file here; one built from the source's parameters (`/blog/:slug` →\n * `/posts/:slug`) is skipped, as are external ones. The source is checked at the\n * granularity of its literal prefix: each parameter stands in as a dynamic\n * segment. Rewrites done by middleware (`NextResponse.rewrite`) are code, not\n * config, and cannot be checked at all.\n */\nfunction assertRewritesStayInGroup(\n  groupOfEntrypoint: ReadonlyMap<string, string>,\n  behaviors: readonly EdgeBehavior[],\n  router: Router,\n): void {\n  const { routing } = router;\n  const phases: [readonly RewriteRule[] | undefined, boolean][] = [\n    [routing.beforeFiles, false],\n    // `afterFiles` and `fallback` only apply when no file matched the URL, so a\n    // source that is itself a route never reaches the destination.\n    [routing.afterFiles, true],\n    [routing.fallback, true],\n  ];\n  for (const [rules, yieldsToFiles] of phases) {\n    for (const rule of rules ?? []) {\n      const destination = literalDestination(rule.destination);\n      // Next.js's own interception rewrites are here too, on `Next-Url`;\n      // `reassignInterceptingFiles` has already put their files in place.\n      if (destination === undefined || isInterceptionTemplate(destination)) {\n        continue;\n      }\n      const file = resolveFile(destination, router);\n      if (file === undefined) {\n        continue;\n      }\n      const target = groupOfEntrypoint.get(file) ?? DEFAULT_FUNCTION_GROUP;\n      for (const url of rewriteSourceUrls(rule.source)) {\n        if (yieldsToFiles && router.fileOfTemplate.has(url)) {\n          continue;\n        }\n        const behavior = edgeBehaviorFor(behaviors, url);\n        const group = behavior?.group ?? DEFAULT_FUNCTION_GROUP;\n        if (group === target) {\n          continue;\n        }\n        throw new Error(\n          `${ERROR_PREFIX}The next.config rewrite from \"${rule.source}\" to ` +\n            `\"${rule.destination}\" crosses groups: CloudFront sends \"${url}\" to ` +\n            `${groupLabel(group)}` +\n            (behavior ? ` (its pattern \"${behavior.route}\")` : \"\") +\n            `, and Next.js then serves it with \"${file}\", which is packaged ` +\n            `into ${groupLabel(target)}. A rewrite is applied inside the ` +\n            `function that received the request, so its source and its ` +\n            `destination have to be routed to the same group.`,\n        );\n      }\n    }\n  }\n}\n\n/** A rewrite destination's pathname, `undefined` unless it is a literal local path. */\nfunction literalDestination(\n  destination: string | undefined,\n): string | undefined {\n  if (!destination?.startsWith(\"/\")) {\n    return undefined;\n  }\n  const pathname = destination.split(/[?#]/)[0];\n  if (/[$:]/.test(pathname)) {\n    return undefined;\n  }\n  return pathname.length > 1 ? pathname.replace(/\\/$/, \"\") : pathname;\n}\n\n/** What {@link resolveFile} resolves against. */\ninterface Router {\n  /** Template → the file behind it, less the RSC and segment rewrites. */\n  readonly fileOfTemplate: ReadonlyMap<string, string>;\n  readonly routing: RoutingRules;\n}\n\nfunction fileOfTemplate(entries: readonly RouteEntry[]): Map<string, string> {\n  return new Map(\n    entries\n      .filter((entry) => !isInternalTemplate(entry.template))\n      .map((entry) => [entry.template, entry.entrypointId]),\n  );\n}\n\n/**\n * The file Next.js serves `pathname` with: a template of that exact name, or\n * else the first of Next.js's own dynamic route rules that matches — matched\n * case-insensitively, as `resolveRoutes` does. `dynamicRoutes` is in Next.js's\n * priority order (static segment before `[param]` before `[...catchAll]`\n * before `[[...optional]]`), Pages Router data URLs included.\n */\nfunction resolveFile(\n  pathname: string,\n  { fileOfTemplate: files, routing }: Router,\n): string | undefined {\n  const exact = files.get(pathname);\n  if (exact !== undefined) {\n    return exact;\n  }\n  for (const route of routing.dynamicRoutes ?? []) {\n    if (new RegExp(route.sourceRegex, \"i\").test(pathname)) {\n      const template = route.destination?.split(\"?\")[0];\n      return template === undefined ? undefined : files.get(template);\n    }\n  }\n  return undefined;\n}\n\n/**\n * The URL shapes a path-to-regexp rewrite source matches, as template-like\n * paths: each literal segment kept, each parameter replaced by `[name]`, and —\n * when the last one is optional (`:path*`, `:slug?`) — the path without it too.\n */\nfunction rewriteSourceUrls(source: string | undefined): string[] {\n  if (!source?.startsWith(\"/\")) {\n    return [];\n  }\n  const segments: string[] = [];\n  let optionalFrom: number | undefined;\n  for (const segment of source.split(\"/\").slice(1)) {\n    if (!/[:()*?+{}[\\]]/.test(segment)) {\n      segments.push(segment);\n      continue;\n    }\n    optionalFrom = /^:\\w+[*?]$/.test(segment) ? segments.length : undefined;\n    segments.push(`[${/:(\\w+)/.exec(segment)?.[1] ?? \"param\"}]`);\n  }\n  const urls = [`/${segments.join(\"/\")}`];\n  if (optionalFrom !== undefined) {\n    urls.push(`/${segments.slice(0, optionalFrom).join(\"/\")}`);\n  }\n  return urls;\n}\n\nfunction groupLabel(group: string): string {\n  return group === DEFAULT_FUNCTION_GROUP\n    ? `the \"${DEFAULT_FUNCTION_GROUP}\" group`\n    : `group \"${group}\"`;\n}\n\nfunction prefixBasePath(route: string, basePath: string): string {\n  return `${basePathPrefix(basePath)}${route}`;\n}\n\n/** `template` without `basePath` (`/` for the base itself), `undefined` if outside it. */\nfunction stripBasePath(template: string, basePath: string): string | undefined {\n  if (!basePath) {\n    return template;\n  }\n  return hasPathPrefix(template, basePath)\n    ? template.slice(basePath.length) || \"/\"\n    : undefined;\n}\n\nfunction withBasePath(path: string, basePath: string): string {\n  return path === \"/\" ? basePath || \"/\" : `${basePath}${path}`;\n}\n"]}