cdk-nextjs 0.6.1 → 0.7.0

package/lib/adapter/build-outputs.js

@@ -0,0 +1,852 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeBuildOutputs = writeBuildOutputs;
+exports.buildAdapterManifest = buildAdapterManifest;
+/* eslint-disable import/no-extraneous-dependencies */
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_module_1 = require("node:module");
+const node_path_1 = require("node:path");
+const function_groups_1 = require("./function-groups");
+const constants_1 = require("../constants");
+const manifest_1 = require("../runtime/manifest");
+/**
+ * Env files `writeStandaloneDirectory` copies into the standalone tree and that
+ * `onBuildComplete` has no equivalent for. Dropping `output: "standalone"`
+ * silently drops these unless we stage them ourselves.
+ * @see https://nextjs.org/docs/app/api-reference/config/next-config-js/output
+ */
+const ENV_FILES = [".env", ".env.production"];
+/**
+ * `next` submodules the *runtime* requires that no app ever reaches, so
+ * `next build`'s own trace never covers them. They are required from the app's
+ * `next` rather than bundled, deliberately — see `src/runtime/next-modules.ts`
+ * — which makes staging their closure this module's job.
+ *
+ * `serve-static` is in every group: `serveStaticFile`
+ * (`src/runtime/static-files.ts`) serves prerendered and static results with it
+ * wherever they land.
+ */
+const RUNTIME_NEXT_MODULES = ["next/dist/server/serve-static.js"];
+/**
+ * next's image optimizer and the config helpers around it
+ * (`src/runtime/image.ts`), whose closure is what brings `sharp` in. Only the
+ * `default` group gets them: the edge sends every `/_next/image` request there.
+ */
+const IMAGE_NEXT_MODULES = [
+    "next/dist/server/config-shared.js",
+    "next/dist/shared/lib/image-config.js",
+    "next/dist/server/image-optimizer.js",
+];
+/**
+ * The file tracer `next build` itself uses, reached through the app's own `next`
+ * so that it is the version that matches the files being traced. Not a
+ * dependency of cdk-nextjs: bundling a second copy of `@vercel/nft` into the
+ * published adapter would add megabytes to every install to do the same job.
+ */
+const NEXT_FILE_TRACER = "next/dist/compiled/@vercel/nft";
+/**
+ * Build the manifest and staging plan, stage the files, and write the manifest.
+ * Called from `onBuildComplete`, which is the only place that holds the build
+ * outputs.
+ */
+async function writeBuildOutputs(ctx, options = {}) {
+    const adapterDir = (0, node_path_1.join)(ctx.distDir, manifest_1.ADAPTER_DIR_NAME);
+    const manifestPath = (0, node_path_1.join)(adapterDir, manifest_1.MANIFEST_FILE_NAME);
+    const { manifest, groups } = buildAdapterManifest(ctx, options);
+    // Traced once, here: the trace is async, which is why it cannot happen inside
+    // `buildAdapterManifest`. `runtimeClosure` is merged into every group, and
+    // `imageClosure` into `default` only, the one group `/_next/image` reaches.
+    const runtimeClosure = new Map();
+    const imageClosure = new Map();
+    await addRuntimeNextClosure(ctx, runtimeClosure, imageClosure);
+    addRequiredServerFiles(ctx, runtimeClosure);
+    // A previous build's tree is never additive with this one's: a removed route
+    // leaves behind an entrypoint the manifest no longer mentions, a renamed chunk
+    // leaves dead bytes inside the 250 MB budget, and a regrouped build leaves a
+    // whole deployment root nothing deploys.
+    await (0, promises_1.rm)(adapterDir, { recursive: true, force: true });
+    const stagedGroups = [];
+    for (const group of groups) {
+        const groupStaging = merged(merged(group.staging, runtimeClosure), group.name === function_groups_1.DEFAULT_FUNCTION_GROUP ? imageClosure : new Map());
+        const path = (0, node_path_1.join)(adapterDir, ...group.dirName.split("/"));
+        await (0, promises_1.mkdir)(path, { recursive: true });
+        await stageFiles(groupStaging, path);
+        stagedGroups.push({ name: group.name, path, fileCount: groupStaging.size });
+    }
+    await (0, promises_1.writeFile)(manifestPath, JSON.stringify(manifest, null, 2));
+    return {
+        manifest,
+        groups,
+        adapterDir,
+        manifestPath,
+        stagedGroups,
+    };
+}
+/** Left wins, as everywhere else in this module: first writer of a key keeps it. */
+function merged(base, additions) {
+    const result = new Map(base);
+    for (const [key, source] of additions) {
+        if (!result.has(key)) {
+            result.set(key, source);
+        }
+    }
+    return result;
+}
+/**
+ * The pure half of {@link writeBuildOutputs}: everything derived from the build
+ * outputs, with no writes. Split out so it can be unit tested against committed
+ * `onBuildComplete` fixtures.
+ *
+ * Throws on any non-Node output and on any staging key two outputs map to
+ * different content.
+ */
+function buildAdapterManifest(ctx, options = {}) {
+    const { outputs, repoRoot } = ctx;
+    const basePath = ctx.config.basePath || "";
+    assertBuildCwd(ctx, options.buildCwd ?? process.cwd());
+    const invocable = [
+        ...outputs.pages,
+        ...outputs.pagesApi,
+        ...outputs.appPages,
+        ...outputs.appRoutes,
+        ...(outputs.middleware ? [outputs.middleware] : []),
+    ];
+    assertNodeRuntimes(invocable, outputs.middleware);
+    warnOnDroppedRouteConfig(invocable);
+    const staticFiles = collectStaticFiles(ctx);
+    const entrypoints = {};
+    for (const { outputs: group, type } of [
+        { outputs: outputs.pages, type: "page" },
+        { outputs: outputs.pagesApi, type: "page-api" },
+        { outputs: outputs.appPages, type: "app-page" },
+        { outputs: outputs.appRoutes, type: "app-route" },
+    ]) {
+        for (const output of group) {
+            addEntrypoint(entrypoints, repoRoot, output, type, basePath);
+        }
+    }
+    addPrerenderPathnames(entrypoints, outputs.prerenders, ctx.routing.dynamicRoutes, basePath, `${basePath}/_next/data/${ctx.buildId}/`);
+    const pathnames = sortedUnique([
+        ...Object.keys(entrypoints),
+        ...Object.keys(staticFiles),
+    ]);
+    const functionGroups = options.functionGroups ??
+        (0, function_groups_1.parseFunctionGroupsEnv)(process.env[function_groups_1.FUNCTION_GROUPS_ENV_VAR]);
+    // i18n is checked first: it rejects the combination outright, and running it
+    // after the assignment meant an i18n app got the assignment's "pattern matches
+    // no route" error instead — true, but about the wrong thing, since a localized
+    // template never matches an unlocalized pattern.
+    if (functionGroups) {
+        (0, function_groups_1.assertNoI18nSplitting)(ctx.config.i18n ?? null);
+    }
+    const assignment = functionGroups
+        ? (0, function_groups_1.assignRoutesToGroups)(functionGroups, 
+        // Keyed on the file, not the output `id`: a Pages Router page and its
+        // `/_next/data/<buildId>/<page>.json` route are separate outputs with
+        // separate ids backed by one file, and only the page's template matches
+        // a group pattern.
+        Object.entries(entrypoints).map(([template, entrypoint]) => ({
+            template,
+            entrypointId: entrypoint.filePath,
+            type: entrypoint.type,
+        })), {
+            basePath: ctx.config.basePath || "",
+            buildId: ctx.buildId,
+            trailingSlash: ctx.config.trailingSlash === true,
+            routing: ctx.routing,
+        })
+        : undefined;
+    const manifest = {
+        version: manifest_1.ADAPTER_MANIFEST_VERSION,
+        buildId: ctx.buildId,
+        relativeProjectDir: toPosix((0, node_path_1.relative)(repoRoot, ctx.projectDir)),
+        config: {
+            basePath: ctx.config.basePath || "",
+            trailingSlash: ctx.config.trailingSlash === true,
+            assetPrefix: ctx.config.assetPrefix || "",
+            distDir: toPosix((0, node_path_1.relative)(ctx.projectDir, ctx.distDir)),
+            compress: ctx.config.compress !== false,
+            generateEtags: ctx.config.generateEtags !== false,
+            i18n: ctx.config.i18n ?? null,
+            deploymentId: (ctx.config.deploymentId ?? "").replace(/[^A-Za-z0-9_-]/g, "-"),
+        },
+        routing: ctx.routing,
+        pathnames,
+        entrypoints,
+        middleware: buildMiddleware(repoRoot, outputs.middleware),
+        staticFiles,
+        ...(assignment
+            ? {
+                groups: assignment.templates,
+                behaviors: assignment.behaviors,
+                functionGroups: functionGroups.map(({ name, routes }) => ({
+                    name,
+                    routes,
+                })),
+            }
+            : {}),
+    };
+    const groups = assignment
+        ? Object.entries(assignment.templates).map(([name, templates]) => ({
+            name,
+            dirName: (0, manifest_1.groupStagingDirName)(name),
+            staging: collectGroupStagingPlan(ctx, invocable, entrypoints, templates),
+        }))
+        : [
+            {
+                name: function_groups_1.DEFAULT_FUNCTION_GROUP,
+                dirName: (0, manifest_1.groupStagingDirName)(),
+                staging: servedStagingPlan(ctx, invocable),
+            },
+        ];
+    return { manifest, groups };
+}
+/**
+ * One group's slice of the staging plan: the assets of the outputs it owns, and
+ * nothing else.
+ *
+ * Middleware is in every group, not just the default one — it runs on every
+ * request wherever that request lands, so it is duplicated by design, as is the
+ * `next` closure the entrypoints share. The same goes for the static files the
+ * runtime serves itself (`404.html`, `favicon.ico.body`): any group can be asked
+ * for them. And so are the not-found and error pages: the runtime renders a
+ * 404 or a 500 with whichever of them the shared manifest names
+ * (`statusTargets` in `runtime/dispatch.ts`), in whichever group the
+ * request reached, so a group without them answered a URL under its own
+ * pattern that matches no route with "the deployment package is incomplete".
+ *
+ * Ownership is matched on the entrypoint's `filePath`, not its `id` or
+ * pathname: the manifest's entrypoints are keyed by *template*, an output may
+ * back several templates, and {@link addPrerenderPathnames} synthesizes
+ * entrypoints that carry the *prerender's* id, which no invocable output has (the
+ * root-params app: entrypoint `/en` with `id: "/en"` backed by the output
+ * `/[locale]`). The synthesized entrypoint's `filePath` is the owning output's.
+ */
+function collectGroupStagingPlan(ctx, invocable, entrypoints, templates) {
+    const basePath = ctx.config.basePath || "";
+    const ownedEntrypoints = [
+        ...templates,
+        ...manifest_1.ERROR_PAGE_SUFFIXES.map((suffix) => `${basePath}${suffix}`),
+    ]
+        .map((template) => entrypoints[template])
+        .filter((entry) => entry !== undefined);
+    const ownedFiles = new Set(ownedEntrypoints.map((entry) => entry.filePath));
+    const middleware = ctx.outputs.middleware;
+    const owned = invocable.filter((output) => ownedFiles.has(toPosix((0, node_path_1.relative)(ctx.repoRoot, output.filePath))) ||
+        output === middleware);
+    return servedStagingPlan(ctx, owned);
+}
+/** {@link collectStagingPlan} for `outputs`, plus the files the runtime serves. */
+function servedStagingPlan(ctx, outputs) {
+    const staging = collectStagingPlan(ctx, outputs);
+    stageServedStaticFiles(ctx, staging);
+    return staging;
+}
+/**
+ * Job 1: reject non-Node outputs, everywhere.
+ *
+ * `export const runtime = 'edge'` on a page or route handler lands in
+ * `appPages`/`appRoutes`/`pages`/`pagesApi` with `runtime: 'edge'`,
+ * `assets: {}`, and an `edgeRuntime` descriptor needing `globalThis._ENTRIES`
+ * and a sandbox. Guarding middleware alone would leave a silent failure mode
+ * for edge pages: an entrypoint we can't invoke and no assets to invoke it
+ * with.
+ */
+function assertNodeRuntimes(invocable, middleware) {
+    const offending = invocable.filter((output) => output.runtime !== "nodejs");
+    if (offending.length === 0) {
+        return;
+    }
+    // Middleware is reported separately from routes. Its `sourcePage` is `/`, so
+    // folding it in with the routes produces the actively misleading advice to
+    // remove `export const runtime = "edge"` from the home page - which is where
+    // the edge runtime is not, and may not even exist.
+    const offendingMiddleware = middleware && offending.includes(middleware);
+    // `.rsc` variants share a `sourcePage` with their HTML sibling, so dedupe.
+    const routes = sortedUnique(offending
+        .filter((output) => output !== middleware)
+        .map((output) => `${output.sourcePage} (runtime: "${output.runtime}")`));
+    const reasons = [];
+    if (routes.length > 0) {
+        reasons.push(`cdk-nextjs cannot deploy routes built for the edge runtime. ` +
+            `Remove \`export const runtime = "edge"\` from:\n` +
+            routes.map((route) => `  - ${route}`).join("\n"));
+    }
+    if (offendingMiddleware) {
+        reasons.push(`cdk-nextjs cannot deploy middleware built for the edge runtime ` +
+            `(${middleware.filePath}, runtime: "${middleware.runtime}"). ` +
+            `Rename it to \`proxy.ts\` (Next.js 16 runs proxy on the Node ` +
+            `runtime), or keep \`middleware.ts\` and add ` +
+            `\`export const config = { runtime: "nodejs" }\` to it — ` +
+            `\`middleware.ts\` defaults to the edge runtime, but does not require it.`);
+    }
+    throw new Error(`${constants_1.LOG_PREFIX} ${reasons.join("\n")}\n` +
+        `The edge runtime is deprecated in Next.js: ` +
+        `https://nextjs.org/docs/messages/edge-runtime-deprecated`);
+}
+/**
+ * Warn on route config cdk-nextjs does not honor. An author who set these asked
+ * for something explicitly, so say so rather than ignoring it silently; never
+ * throw, because route-level `maxDuration` is valid Next.js.
+ *
+ * `NextjsBuild` runs `next build` with `stdio: "inherit"`, so this reaches the
+ * user's terminal. See the plan's "Decisions" for why neither is honored.
+ */
+function warnOnDroppedRouteConfig(invocable) {
+    const dropped = {
+        maxDuration: [],
+        preferredRegion: [],
+    };
+    for (const output of invocable) {
+        if (output.config?.maxDuration !== undefined) {
+            dropped.maxDuration.push(output.sourcePage);
+        }
+        if (output.config?.preferredRegion !== undefined) {
+            dropped.preferredRegion.push(output.sourcePage);
+        }
+    }
+    const remedy = {
+        maxDuration: "Set the function timeout with the construct's `overrides` prop instead (e.g. `overrides: { nextjsFunctions: { functionProps: { timeout: Duration.seconds(30) } } }`); a Lambda timeout is per-function while `maxDuration` is per-route.",
+        preferredRegion: "Honoring it would require a multi-region deployment, which this construct does not model.",
+    };
+    for (const key of ["maxDuration", "preferredRegion"]) {
+        const routes = sortedUnique(dropped[key]);
+        if (routes.length === 0) {
+            continue;
+        }
+        console.warn(`${constants_1.LOG_PREFIX} \`${key}\` is not honored by cdk-nextjs. ` +
+            `${routes.length} route(s) set it, including: ${routes.slice(0, 5).join(", ")}` +
+            `${routes.length > 5 ? `, and ${routes.length - 5} more` : ""}. ` +
+            remedy[key]);
+    }
+}
+/**
+ * Jobs 2, 3 and 6: the deduped union of every shipped output's traced `assets`,
+ * plus each entrypoint file itself, plus the env files, with `assetsHashes` used
+ * as a conflict check.
+ *
+ * Dedup is by key: the traced `next` closure is merged into every output's
+ * `assets` (`getSharedNodeAssets` → `sharedNodeAssets`), so N outputs
+ * overwhelmingly repeat keys. What the hashes buy is detecting two outputs
+ * mapping the **same key to different content**, which is unpackageable into
+ * one Lambda — fail the build loudly rather than letting last-write-wins pick.
+ */
+function collectStagingPlan(ctx, invocable) {
+    const { repoRoot } = ctx;
+    const staging = new Map();
+    const hashes = new Map();
+    const add = (key, source, hash) => {
+        assertStagingKey(key, source);
+        const existingHash = hashes.get(key);
+        if (hash !== undefined &&
+            existingHash !== undefined &&
+            existingHash !== hash) {
+            throw new Error(`${constants_1.LOG_PREFIX} Two build outputs map "${key}" to different content ` +
+                `(hashes ${existingHash} and ${hash}). One deployment package cannot ` +
+                `hold both. This usually means two Next.js projects in the same repo ` +
+                `write the same repo-root-relative path.`);
+        }
+        if (hash !== undefined) {
+            hashes.set(key, hash);
+        }
+        if (!staging.has(key)) {
+            staging.set(key, source);
+        }
+    };
+    for (const output of invocable) {
+        for (const [key, source] of Object.entries(output.assets)) {
+            add(key, source, output.assetsHashes[key]);
+        }
+        // The entrypoint's own file is deliberately absent from its `assets` — the
+        // NFT trace covers the closure it requires, not itself. `assetsHashes` does
+        // carry it (keyed the same way), which is also what pins the key format.
+        const entryKey = toPosix((0, node_path_1.relative)(repoRoot, output.filePath));
+        add(entryKey, output.filePath, output.assetsHashes[entryKey]);
+    }
+    // Job 2, second half: `writeStandaloneDirectory` filters `loadedEnvFiles` to
+    // exactly these two and copies them; `build-complete.js` has no env-file
+    // handling at all, so they are not in any `assets` map.
+    for (const envFile of ENV_FILES) {
+        const source = (0, node_path_1.join)(ctx.projectDir, envFile);
+        if ((0, node_fs_1.existsSync)(source)) {
+            add(toPosix((0, node_path_1.relative)(repoRoot, source)), source);
+        }
+    }
+    return staging;
+}
+/**
+ * Job 2, third part: the static files the *runtime* has to serve, and their
+ * sources.
+ *
+ * `outputs.staticFiles` mixes two populations with the same `STATIC_FILE` type:
+ *
+ * - **`<distDir>/static/**` and `public/**`** — uploaded to S3 by
+ *   `NextjsStaticAssets`, and CloudFront / API Gateway answer them before the
+ *   request ever reaches the compute. Not staged: `public/` alone can be
+ *   hundreds of megabytes against a 250 MB unzipped Lambda cap, and it would be
+ *   a second copy of bytes already in S3. `public/` is not in
+ *   `outputs.staticFiles` at all — Next.js lists it only for `output: "export"`
+ *   — and it is deliberately not added here: the container runtime lists it off
+ *   disk at cold start instead, as `next start` does (`readPublicFiles` in
+ *   `src/runtime/public-files.ts`), because only the disk knows what an app's
+ *   `postbuild` wrote into it after this hook ran.
+ * - **everything else**, all of it under `<distDir>/server/` — `404.html`,
+ *   `500.html`, `favicon.ico.body`, and fully-static Pages Router HTML. Nothing
+ *   in front of the compute serves these, so they are staged. Bounded by route
+ *   count and small.
+ *
+ * The pathname → key map is returned for *all* of them, because dispatch has to
+ * resolve a pathname to "static file, not a 404" either way; the runtime 404s if
+ * the file turns out not to be in the package, which is only reachable when the
+ * distribution is misrouted.
+ *
+ * Staging is {@link stageServedStaticFiles}, applied once per deployment root.
+ */
+function collectStaticFiles(ctx) {
+    const { repoRoot } = ctx;
+    const basePath = ctx.config.basePath || "";
+    const staticFiles = new Map();
+    const pagesDir = (0, node_path_1.join)(ctx.distDir, "server", "pages") + node_path_1.sep;
+    for (const output of ctx.outputs.staticFiles) {
+        const key = toPosix((0, node_path_1.relative)(repoRoot, output.filePath));
+        const pathnames = routablePathnames(output.pathname, basePath, output.filePath.startsWith(pagesDir));
+        for (const pathname of pathnames) {
+            const existing = staticFiles.get(pathname);
+            if (existing !== undefined && existing !== key) {
+                throw new Error(`${constants_1.LOG_PREFIX} Two static files claim the pathname ` +
+                    `"${pathname}" ("${existing}" and "${key}"). Dispatch cannot ` +
+                    `choose between them.`);
+            }
+            staticFiles.set(pathname, key);
+        }
+    }
+    // Sorted because object keys keep insertion order, and a byte-stable
+    // `manifest.json` is what keeps it diffable and the CDK asset hash from
+    // churning.
+    return Object.fromEntries([...staticFiles].sort(([a], [b]) => (a < b ? -1 : 1)));
+}
+/**
+ * The pathnames an output answers, which for one shape is not the pathname
+ * `next build` reported.
+ *
+ * **A Pages Router home page arrives as `/index`.** The adapter hook derives every
+ * Pages pathname with `normalizePagePath(page)`, and `normalizePagePath("/")` is
+ * `"/index"` (`next/dist/shared/lib/page-path/normalize-page-path.js`) — for the
+ * `PAGES` output of an SSG or SSR home page and for the `STATIC_FILE` of a
+ * fully-static one alike. `/index` is not a URL anyone requests, and nothing else
+ * in the outputs carries `/` for that page, so without this the home page is in
+ * neither `manifest.pathnames` nor `manifest.entrypoints`/`staticFiles`, and every
+ * request to `/` 404s while every other page of the same app serves. Measured
+ * against next.js's `test/e2e/new-link-behavior` (`/` returned the built-in 404,
+ * the six other pages were fine) and `test/e2e/prerender-preview` (the one case
+ * that fetches `/` got the 404 page's HTML, the eight that hit API routes passed).
+ *
+ * Pages Router outputs only, which is what `fromPagesRouter` says. App Router
+ * reports its home page as `/` and only the RSC sibling as `/index.rsc`, so an
+ * App Router `/index` is `app/index/page.tsx` — a real route at `/index`, and
+ * mapping it to `/` made an app with both pages fail the build on a pathname
+ * collision, and an app with only the second serve it at `/`. The same goes for
+ * a `public/index` file.
+ *
+ * Both pathnames are registered. `/` because it is the real one; `/index` because
+ * next's own minimal mode — the mode our runtime runs in — accepts it, rewriting
+ * `req.url` and `x-matched-path` from `/index` to `/` before matching
+ * (`base-server.ts`, "in minimal mode"), so dropping it would be a divergence in
+ * the other direction.
+ *
+ * Unambiguous within the Pages Router despite the collision it looks like:
+ * `normalizePagePath("/index")` is `"/index/index"`, so a reported `/index` can
+ * only have come from the page `/`.
+ * The data route of the same page, `/_next/data/<buildId>/index.json`, and an App
+ * Router `/index.rsc` are both real URLs and are left alone by the exact match.
+ */
+function routablePathnames(pathname, basePath, fromPagesRouter) {
+    if (!fromPagesRouter || pathname !== `${basePath}/index`) {
+        return [pathname];
+    }
+    // `basePath || "/"`, not `${basePath}/`: with `basePath: "/prod"` the home page
+    // is `/prod`, which is how the App Router fixtures report theirs.
+    return [basePath || "/", pathname];
+}
+/**
+ * Add the static files the *runtime* serves to a staging plan — the "everything
+ * else" population described on {@link collectStaticFiles}, all of it under
+ * `<distDir>/server/`.
+ *
+ * Separate from building the manifest's `staticFiles` map because the map is the
+ * same for every group while the staging is applied once per deployment root:
+ * any group can be asked for `/404`, so every group ships these.
+ */
+function stageServedStaticFiles(ctx, staging) {
+    const { repoRoot, distDir } = ctx;
+    const clientStaticDir = (0, node_path_1.join)(distDir, "static") + node_path_1.sep;
+    for (const output of ctx.outputs.staticFiles) {
+        const servedByS3 = output.filePath.startsWith(clientStaticDir) ||
+            !output.filePath.startsWith(distDir + node_path_1.sep);
+        if (servedByS3) {
+            continue;
+        }
+        const key = toPosix((0, node_path_1.relative)(repoRoot, output.filePath));
+        assertStagingKey(key, output.filePath);
+        staging.set(key, output.filePath);
+    }
+}
+/**
+ * The invariant behind `manifest.relativeProjectDir`: `next build` must run from
+ * the project directory.
+ *
+ * Next inlines `relative(process.cwd(), projectDir)` into every entrypoint
+ * (`define-env.js`) and the built code resolves it against the *runtime*
+ * `process.cwd()`. Keeping build cwd and project dir equal makes that inlined
+ * value `""`, so the runtime only has to `chdir` to the staged project dir. A
+ * build run from elsewhere would inline a non-empty relative path — often one
+ * pointing outside the staging tree — and every entrypoint would fail to find
+ * `required-server-files.json` at runtime with no hint as to why.
+ */
+function assertBuildCwd(ctx, buildCwd) {
+    const cwd = (0, node_path_1.resolve)(buildCwd);
+    if (cwd === (0, node_path_1.resolve)(ctx.projectDir)) {
+        return;
+    }
+    throw new Error(`${constants_1.LOG_PREFIX} \`next build\` must run from the Next.js project ` +
+        `directory. It ran from "${cwd}" with the project at ` +
+        `"${ctx.projectDir}". Next.js bakes the relative path between those two ` +
+        `into every built entrypoint, and cdk-nextjs cannot reproduce that layout ` +
+        `in the deployment package. Change directory first (\`cd ` +
+        `${(0, node_path_1.relative)(cwd, ctx.projectDir) || "."} && next build\`) instead of ` +
+        `passing the directory as an argument; in a monorepo, run the app's own ` +
+        `build script from its directory (e.g. \`pnpm --filter <app> build\`, ` +
+        `which runs in the package directory).`);
+}
+function addEntrypoint(entrypoints, repoRoot, output, type, basePath) {
+    const filePath = toPosix((0, node_path_1.relative)(repoRoot, output.filePath));
+    const pathnames = routablePathnames(output.pathname, basePath, type === "page");
+    for (const pathname of pathnames) {
+        const existing = entrypoints[pathname];
+        if (existing && existing.filePath !== filePath) {
+            throw new Error(`${constants_1.LOG_PREFIX} Two build outputs claim the pathname "${pathname}" ` +
+                `("${existing.filePath}" and "${filePath}"). Dispatch cannot choose ` +
+                `between them.`);
+        }
+        entrypoints[pathname] = { id: output.id, filePath, type };
+    }
+}
+/**
+ * Add the *prerender* pathnames that no invocable output claims and that routing
+ * cannot otherwise reach.
+ *
+ * `resolveRoutes` can only match a pathname present in `manifest.pathnames`, and
+ * for a dynamic match it returns the **template** it matched. Routes and static
+ * files cover most of that; two shapes they miss:
+ *
+ * 1. **Templates.** A request for `/_next/data/<buildId>/fr/blog/hello.json` only
+ *    resolves if `/_next/data/<buildId>/fr/blog/[slug].json` is listed, and that
+ *    pathname exists solely as a `prerenders` entry.
+ * 1b. **A static `getStaticProps` page's data route.** `/_next/data/<buildId>/gsp.json`
+ *    has no template to match and no rule of its own: `next build` only emits a
+ *    `dynamicRoutes` rule for a data route when the page is dynamic *or* the app has
+ *    middleware (`build-complete.ts`, `needsMiddlewareResolveRoutes`, which is also
+ *    what `routing.shouldNormalizeNextData` reports). Without middleware Next.js
+ *    expects the platform to serve the data route as an output, by pathname — so a
+ *    concrete data-route prerender is registered whatever the rules say. Missing it
+ *    turned every client-side navigation into such a page into a full page load,
+ *    because the router's `.json` fetch 404'd: measured against
+ *    `test/e2e/no-page-props`. Only when no *ungated* rule matches, for the reason
+ *    below — a dynamic page's `/…/blog/hello.json` must keep resolving to its
+ *    `[slug].json` template, which is where `nxtPslug` comes from.
+ * 2. **Concrete pathnames whose dynamic route rule is gated.** A route whose params
+ *    can never be filled at request time — root params are the case that produced
+ *    this, `app/[locale]/page.tsx` with `generateStaticParams()` and no
+ *    `app/layout.tsx` — gets its `dynamicRoutes` rule emitted with a draft-mode
+ *    `has` on `__prerender_bypass`. Next.js is saying: invoke the function only in
+ *    draft mode, and otherwise serve the prerender you were handed. Vercel's CDN
+ *    does that from the output itself; we route the request to the owning
+ *    entrypoint, which answers it out of the seeded cache. Without this, `/en` is a
+ *    404 while `next start` renders it — and so is every `.rsc`/`.segments`
+ *    variant, which is why a client-side navigation into such an app never
+ *    completes.
+ *
+ * A concrete pathname is added only when a gated rule matches it and no ungated
+ * one does — the set that would 404 today *and* that routing can still produce.
+ * Adding them unconditionally was measured to be actively wrong twice over:
+ * `/isr/1` resolves to itself rather than to `/isr/[id]`, losing the `nxtPid`
+ * query param the route needs, and pathnames no rule matches at all (a static
+ * route's `.segments/…` outputs, which `resolveRoutes` never asks for) are dead
+ * manifest weight. Matching mirrors `resolveRoutes`, which is case-insensitive by
+ * default.
+ *
+ * The owning entrypoint comes from `prerender.route`, which is the unprefixed and
+ * unlocalized source route (`/blog/[slug]`), hence the basePath-then-bare ladder.
+ * Locale variants of one page share a `filePath`, so any locale's entrypoint is
+ * the right target. An RSC or segment-prefetch pathname prefers the route's `.rsc`
+ * entrypoint, because that is the key `resolveRoutes` resolves such a request to.
+ */
+function addPrerenderPathnames(entrypoints, prerenders, dynamicRoutes, basePath, dataRoutePrefix) {
+    const matchers = dynamicRoutes.map((route) => ({
+        regex: new RegExp(route.sourceRegex, "i"),
+        gated: Boolean(route.has?.length || route.missing?.length),
+    }));
+    const matchingRules = (pathname) => matchers.filter(({ regex }) => regex.test(pathname));
+    const onlyGatedRulesMatch = (pathname) => {
+        const matched = matchingRules(pathname);
+        return matched.length > 0 && matched.every(({ gated }) => gated);
+    };
+    /**
+     * Nothing reaches this pathname at request time: either no rule matches it or
+     * every rule that does is gated. The gated half is {@link onlyGatedRulesMatch};
+     * the "no rule at all" half only ever holds for a data route, because a page's
+     * own pathname is an output.
+     */
+    const nothingUngatedMatches = (pathname) => matchingRules(pathname).every(({ gated }) => gated);
+    const orphans = [];
+    for (const prerender of prerenders) {
+        const { pathname } = prerender;
+        if (entrypoints[pathname]) {
+            continue;
+        }
+        const isTemplate = pathname.includes("[");
+        const isDataRoute = pathname.startsWith(dataRoutePrefix) && pathname.endsWith(".json");
+        const reachable = isDataRoute
+            ? nothingUngatedMatches(pathname)
+            : onlyGatedRulesMatch(pathname);
+        if (!isTemplate && !reachable) {
+            continue;
+        }
+        const suffixes = pathname.endsWith(".rsc") ? [".rsc", ""] : [""];
+        const owner = suffixes
+            .flatMap((suffix) => [
+            `${basePath}${prerender.route}${suffix}`,
+            `${prerender.route}${suffix}`,
+        ])
+            .map((key) => entrypoints[key])
+            .find(Boolean);
+        if (!owner) {
+            orphans.push(`${pathname} (route: "${prerender.route}")`);
+            continue;
+        }
+        entrypoints[pathname] = {
+            id: prerender.id,
+            filePath: owner.filePath,
+            type: owner.type,
+        };
+    }
+    if (orphans.length > 0) {
+        // Warn rather than throw: an unmapped pathname degrades one URL shape to a
+        // 404, which is what would happen without this function at all. A throw
+        // would break the build outright on an output shape a future `next` minor
+        // might introduce.
+        console.warn(`${constants_1.LOG_PREFIX} ${orphans.length} prerender pathname(s) have no ` +
+            `matching route entrypoint and will 404: ` +
+            `${orphans.slice(0, 5).join(", ")}` +
+            `${orphans.length > 5 ? `, and ${orphans.length - 5} more` : ""}.`);
+    }
+}
+function buildMiddleware(repoRoot, middleware) {
+    if (!middleware) {
+        return null;
+    }
+    // `config.matchers` is deliberately not copied here: it arrives inside
+    // `ctx.routing.middlewareMatchers`, which `@next/routing` consumes directly.
+    return {
+        id: middleware.id,
+        filePath: toPosix((0, node_path_1.relative)(repoRoot, middleware.filePath)),
+    };
+}
+/**
+ * Copy the staging plan into `stagingDir`.
+ *
+ * **Symlinks are recreated as symlinks, not dereferenced**, which is what
+ * Next.js's own `copyTracedFiles` does (`next/dist/build/utils.js`: `readlink`
+ * then `symlink`, with a Windows junction fallback). Under pnpm a traced asset
+ * key is frequently a *directory* symlink into the store
+ * (`node_modules/.pnpm/next@…/node_modules/react` → `../../react@19.2.3/…`), so
+ * `copyFile` fails outright with `ENOTSUP`. Dereferencing instead would triple
+ * the tree — `examples/app-playground` measures 32 MB staged versus 96 MB with
+ * `du -shL`, against a 250 MB unzipped Lambda cap — because whole packages are
+ * reachable through several such links. The link targets are themselves staged
+ * keys, so relative links resolve inside the deployment root.
+ *
+ * Regular files are staged first so that a symlink whose path was already
+ * materialized as a real directory is skipped rather than clobbering it.
+ *
+ * Nothing may dereference them afterwards: the Functions zip keeps them as
+ * links (`zipDirectory`), and the Containers `COPY` does too.
+ */
+/** Bounded so a large app doesn't exhaust file descriptors. */
+const STAGING_CONCURRENCY = 32;
+async function stageFiles(staging, stagingDir) {
+    const planned = [...staging];
+    // Links land by plan index, so the pass below creates them in the plan's
+    // order whatever order the workers finished in.
+    const links = new Array(planned.length);
+    let nextEntry = 0;
+    const worker = async () => {
+        while (nextEntry < planned.length) {
+            const index = nextEntry++;
+            const [key, source] = planned[index];
+            const linkTarget = await (0, promises_1.readlink)(source).catch(() => null);
+            if (linkTarget !== null) {
+                links[index] = [key, source, linkTarget];
+                continue;
+            }
+            const dest = (0, node_path_1.join)(stagingDir, key);
+            await (0, promises_1.mkdir)((0, node_path_1.dirname)(dest), { recursive: true });
+            await (0, promises_1.copyFile)(source, dest);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(STAGING_CONCURRENCY, planned.length) }, worker));
+    for (const link of links) {
+        if (link === undefined) {
+            continue;
+        }
+        const [key, source, linkTarget] = link;
+        const dest = (0, node_path_1.join)(stagingDir, key);
+        if ((0, node_fs_1.existsSync)(dest)) {
+            // Already staged as real content by the pool above; the link would add
+            // nothing and would replace a directory we need.
+            continue;
+        }
+        await (0, promises_1.mkdir)((0, node_path_1.dirname)(dest), { recursive: true });
+        const resolved = (0, node_path_1.resolve)((0, node_path_1.dirname)(dest), linkTarget);
+        if (resolved === stagingDir || resolved.startsWith(stagingDir + node_path_1.sep)) {
+            await (0, promises_1.symlink)(linkTarget, dest);
+        }
+        else {
+            // Points outside the deployment root, so the link would dangle in Lambda.
+            // Absolute store paths are the realistic case here.
+            await (0, promises_1.cp)(source, dest, { recursive: true, dereference: true });
+        }
+    }
+}
+/**
+ * Adds {@link RUNTIME_NEXT_MODULES}, `@next/env`, and everything they require to
+ * `staging`, and {@link IMAGE_NEXT_MODULES} and theirs to `imageStaging`.
+ *
+ * Without this the deployment is complete for every route the app has and broken
+ * for `/_next/image`: the traced `assets` of a build output cover what the *app*
+ * reaches, and an app never reaches next's image optimizer, so
+ * `next/dist/server/image-optimizer.js` and its closure are simply absent and
+ * every image request 500s with a `MODULE_NOT_FOUND` from `nextModule`.
+ *
+ * Resolution is anchored inside `ctx.projectDir` for the same reason
+ * `useNextFrom` anchors there at runtime: it is the directory whose
+ * `node_modules` walk finds the app's `next`. A repo where that resolution fails
+ * is not a real `next build` — nothing else would have run — so it warns and
+ * continues rather than failing a build for a package it could not have needed.
+ * A missing *tracer* is different: `next` is right there and image optimization
+ * would silently 500 in production, so that throws.
+ */
+async function addRuntimeNextClosure(ctx, staging, imageStaging) {
+    // The anchor file needn't exist; `createRequire` only reads its directory.
+    const nextRequire = (0, node_module_1.createRequire)((0, node_path_1.join)(ctx.projectDir, "cdk-nextjs-next-resolver.cjs"));
+    let entries;
+    let imageEntries;
+    try {
+        entries = RUNTIME_NEXT_MODULES.map((specifier) => nextRequire.resolve(specifier));
+        imageEntries = IMAGE_NEXT_MODULES.map((specifier) => nextRequire.resolve(specifier));
+    }
+    catch (cause) {
+        console.warn(`${constants_1.LOG_PREFIX} Could not resolve next's image optimizer from ` +
+            `"${ctx.projectDir}" (${cause.message}). Requests to ` +
+            `/_next/image will fail at runtime.`);
+        return;
+    }
+    // `loadEnvFiles` (runtime `next-modules.ts`) loads the staged env files with
+    // `@next/env`, which is `next`'s dependency, so resolved from `next`'s dir.
+    // An app never requires it, so no output's trace has it either.
+    const nextPackage = nextRequire.resolve("next/package.json");
+    try {
+        entries.push((0, node_module_1.createRequire)(nextPackage).resolve("@next/env"));
+    }
+    catch (cause) {
+        throw new Error(`${constants_1.LOG_PREFIX} Could not resolve "@next/env" from the app's \`next\`, ` +
+            `which the cdk-nextjs runtime uses to load .env files.`, { cause });
+    }
+    let nodeFileTrace;
+    try {
+        ({ nodeFileTrace } = nextRequire(NEXT_FILE_TRACER));
+    }
+    catch (cause) {
+        throw new Error(`${constants_1.LOG_PREFIX} Could not load "${NEXT_FILE_TRACER}", which cdk-nextjs uses ` +
+            `to stage the \`next\` files its image optimizer requires. This Next.js ` +
+            `version may have moved it; please open an issue.`, { cause });
+    }
+    const add = (fileList, target) => {
+        for (const traced of fileList) {
+            const key = toPosix(traced);
+            if (target.has(key)) {
+                continue;
+            }
+            const source = (0, node_path_1.join)(ctx.repoRoot, traced);
+            assertStagingKey(key, source);
+            target.set(key, source);
+        }
+    };
+    add((await nodeFileTrace(imageEntries, { base: ctx.repoRoot })).fileList, imageStaging);
+    const { fileList } = await nodeFileTrace(entries, { base: ctx.repoRoot });
+    // The trace starts from `@next/env`'s real path, so under pnpm it never
+    // passes through the `.pnpm/next@…/node_modules/@next/env` link that `next`
+    // resolves it by. Without the link, every request fails at cold start with
+    // "Cannot find module '@next/env'".
+    const nextEnvLink = (0, node_path_1.join)((0, node_path_1.dirname)(nextPackage), "..", "@next", "env");
+    if ((0, node_fs_1.lstatSync)(nextEnvLink, { throwIfNoEntry: false })?.isSymbolicLink()) {
+        // `resolve` returns real paths, so relative to the real repo root.
+        fileList.add((0, node_path_1.relative)((0, node_fs_1.realpathSync)(ctx.repoRoot), nextEnvLink));
+    }
+    add(fileList, staging);
+}
+/**
+ * Add `<distDir>/required-server-files.json` to a plan every group is merged with.
+ *
+ * It reaches a group otherwise only as a traced `asset` of some invocable output,
+ * which is not a guarantee: a group whose templates are all assigned elsewhere
+ * owns no outputs at all. That is reachable — a Pages-Router-only app whose every
+ * page falls under the configured `functionGroups` leaves the *default* group
+ * template-empty, and the default group is still what serves `/_next/image`, the
+ * static files, and the distribution's catch-all.
+ *
+ * Its absence is not a partial failure: `loadRuntime` probes for exactly this file
+ * before it will serve anything, and `image.ts` reads the image config out of it,
+ * so the whole root answers "the deployment package is incomplete". Cheap to make
+ * unconditional, so make it unconditional.
+ *
+ * Not traced like {@link RUNTIME_NEXT_MODULES}, because it is data rather than a
+ * module: nothing `require`s it, so no file tracer can find it.
+ *
+ * Absence is left to `loadRuntime`, which names the file and the layout contract
+ * it belongs to. `next build` always writes it, so there is no build-time error
+ * worth inventing here for a file this step does not own.
+ */
+function addRequiredServerFiles(ctx, staging) {
+    const source = (0, node_path_1.join)(ctx.distDir, "required-server-files.json");
+    const key = toPosix((0, node_path_1.relative)(ctx.repoRoot, source));
+    if (staging.has(key) || !(0, node_fs_1.existsSync)(source)) {
+        return;
+    }
+    assertStagingKey(key, source);
+    staging.set(key, source);
+}
+/**
+ * Every staged path must land inside the staging tree and must not shadow the
+ * reserved directory cdk-nextjs copies its own runtime into at synth.
+ */
+function assertStagingKey(key, source) {
+    if (key === "" || key.startsWith("/") || key.startsWith("..")) {
+        throw new Error(`${constants_1.LOG_PREFIX} Build output asset "${source}" resolves to the staging key ` +
+            `"${key}", which is outside the deployment root. Set ` +
+            `\`outputFileTracingRoot\` so all traced files live under one root.`);
+    }
+    if (key === manifest_1.RUNTIME_DIR_NAME || key.startsWith(`${manifest_1.RUNTIME_DIR_NAME}/`)) {
+        throw new Error(`${constants_1.LOG_PREFIX} Build output asset "${source}" resolves to the staging key ` +
+            `"${key}", but "${manifest_1.RUNTIME_DIR_NAME}/" is reserved for cdk-nextjs's own ` +
+            `runtime files.`);
+    }
+}
+function toPosix(path) {
+    return node_path_1.sep === "/" ? path : path.split(node_path_1.sep).join("/");
+}
+function sortedUnique(values) {
+    return [...new Set(values)].sort();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"build-outputs.js","sourceRoot":"","sources":["../../src/adapter/build-outputs.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\nimport { existsSync, lstatSync, realpathSync } from \"node:fs\";\nimport {\n  copyFile,\n  cp,\n  mkdir,\n  readlink,\n  rm,\n  symlink,\n  writeFile,\n} from \"node:fs/promises\";\nimport { createRequire } from \"node:module\";\nimport { dirname, join, relative, resolve, sep } from \"node:path\";\nimport { NextAdapter } from \"next\";\nimport {\n  DEFAULT_FUNCTION_GROUP,\n  FUNCTION_GROUPS_ENV_VAR,\n  FunctionGroupSpec,\n  assertNoI18nSplitting,\n  assignRoutesToGroups,\n  parseFunctionGroupsEnv,\n} from \"./function-groups\";\nimport { LOG_PREFIX } from \"../constants\";\nimport {\n  ADAPTER_DIR_NAME,\n  ADAPTER_MANIFEST_VERSION,\n  AdapterEntrypoint,\n  AdapterEntrypointType,\n  AdapterManifest,\n  AdapterMiddleware,\n  ERROR_PAGE_SUFFIXES,\n  MANIFEST_FILE_NAME,\n  RUNTIME_DIR_NAME,\n  groupStagingDirName,\n} from \"../runtime/manifest\";\n\n/**\n * The `onBuildComplete` argument. Derived from the `next` typings rather than\n * restated so a `next` bump surfaces as a compile error here.\n */\nexport type BuildCompleteContext = Parameters<\n  NonNullable<NextAdapter[\"onBuildComplete\"]>\n>[0];\n\ntype AdapterOutputs = BuildCompleteContext[\"outputs\"];\n/** Any output that we invoke at request time, i.e. not a prerender/static file. */\ntype InvocableOutput =\n  | AdapterOutputs[\"pages\"][number]\n  | AdapterOutputs[\"pagesApi\"][number]\n  | AdapterOutputs[\"appPages\"][number]\n  | AdapterOutputs[\"appRoutes\"][number]\n  | NonNullable<AdapterOutputs[\"middleware\"]>;\n\n/**\n * Env files `writeStandaloneDirectory` copies into the standalone tree and that\n * `onBuildComplete` has no equivalent for. Dropping `output: \"standalone\"`\n * silently drops these unless we stage them ourselves.\n * @see https://nextjs.org/docs/app/api-reference/config/next-config-js/output\n */\nconst ENV_FILES = [\".env\", \".env.production\"];\n\n/**\n * `next` submodules the *runtime* requires that no app ever reaches, so\n * `next build`'s own trace never covers them. They are required from the app's\n * `next` rather than bundled, deliberately — see `src/runtime/next-modules.ts`\n * — which makes staging their closure this module's job.\n *\n * `serve-static` is in every group: `serveStaticFile`\n * (`src/runtime/static-files.ts`) serves prerendered and static results with it\n * wherever they land.\n */\nconst RUNTIME_NEXT_MODULES = [\"next/dist/server/serve-static.js\"];\n\n/**\n * next's image optimizer and the config helpers around it\n * (`src/runtime/image.ts`), whose closure is what brings `sharp` in. Only the\n * `default` group gets them: the edge sends every `/_next/image` request there.\n */\nconst IMAGE_NEXT_MODULES = [\n  \"next/dist/server/config-shared.js\",\n  \"next/dist/shared/lib/image-config.js\",\n  \"next/dist/server/image-optimizer.js\",\n];\n\n/**\n * The file tracer `next build` itself uses, reached through the app's own `next`\n * so that it is the version that matches the files being traced. Not a\n * dependency of cdk-nextjs: bundling a second copy of `@vercel/nft` into the\n * published adapter would add megabytes to every install to do the same job.\n */\nconst NEXT_FILE_TRACER = \"next/dist/compiled/@vercel/nft\";\n\n/** The subset of `nodeFileTrace` this module uses. */\ntype NodeFileTrace = (\n  files: string[],\n  options: { base: string },\n) => Promise<{ fileList: Set<string> }>;\n\n/**\n * Staging key (repo-root-relative POSIX) → absolute source path on the build\n * machine. The deduped union that replaces the standalone tree.\n */\nexport type StagingPlan = ReadonlyMap<string, string>;\n\nexport interface BuildOutputsOptions {\n  /**\n   * The directory `next build` was invoked from. Defaults to `process.cwd()`,\n   * which is the real answer inside `onBuildComplete`; a parameter only so the\n   * unit tests can drive the fixtures' synthetic project dirs.\n   */\n  readonly buildCwd?: string;\n  /**\n   * Resolved `functionGroups`. Defaults to {@link FUNCTION_GROUPS_ENV_VAR},\n   * which is how the constructs get them here: `onBuildComplete` runs inside\n   * `next build` and cannot read CDK props.\n   *\n   * `undefined` means one deployment root holding every route, which is the\n   * default and the only thing the Containers types ever do.\n   */\n  readonly functionGroups?: FunctionGroupSpec[];\n}\n\n/** One deployment root: the staging plan for it, and where it goes. */\nexport interface StagedGroup {\n  /**\n   * Group name, `default` for the implicit group. Always present — a build with\n   * no `functionGroups` produces exactly one {@link StagedGroup} named `default`,\n   * so callers never branch on \"is this split\".\n   */\n  readonly name: string;\n  /**\n   * Directory inside `cdk-nextjs-adapter`, POSIX: `app` when not splitting,\n   * `groups/<name>` when splitting.\n   */\n  readonly dirName: string;\n  readonly staging: StagingPlan;\n}\n\nexport interface BuildAdapterManifestResult {\n  readonly manifest: AdapterManifest;\n  /** One entry per deployment root to stage. Length 1 unless splitting. */\n  readonly groups: StagedGroup[];\n}\n\n/** A staged deployment root on disk. */\nexport interface StagedGroupResult {\n  readonly name: string;\n  /** Absolute path to the deployment root. */\n  readonly path: string;\n  readonly fileCount: number;\n}\n\nexport interface WriteBuildOutputsResult extends BuildAdapterManifestResult {\n  /** Absolute path to `<distDir>/cdk-nextjs-adapter`. */\n  readonly adapterDir: string;\n  /** Absolute path to the written manifest. */\n  readonly manifestPath: string;\n  /** One per deployment root, in the order they were staged. */\n  readonly stagedGroups: StagedGroupResult[];\n}\n\n/**\n * Build the manifest and staging plan, stage the files, and write the manifest.\n * Called from `onBuildComplete`, which is the only place that holds the build\n * outputs.\n */\nexport async function writeBuildOutputs(\n  ctx: BuildCompleteContext,\n  options: BuildOutputsOptions = {},\n): Promise<WriteBuildOutputsResult> {\n  const adapterDir = join(ctx.distDir, ADAPTER_DIR_NAME);\n  const manifestPath = join(adapterDir, MANIFEST_FILE_NAME);\n\n  const { manifest, groups } = buildAdapterManifest(ctx, options);\n\n  // Traced once, here: the trace is async, which is why it cannot happen inside\n  // `buildAdapterManifest`. `runtimeClosure` is merged into every group, and\n  // `imageClosure` into `default` only, the one group `/_next/image` reaches.\n  const runtimeClosure = new Map<string, string>();\n  const imageClosure = new Map<string, string>();\n  await addRuntimeNextClosure(ctx, runtimeClosure, imageClosure);\n  addRequiredServerFiles(ctx, runtimeClosure);\n\n  // A previous build's tree is never additive with this one's: a removed route\n  // leaves behind an entrypoint the manifest no longer mentions, a renamed chunk\n  // leaves dead bytes inside the 250 MB budget, and a regrouped build leaves a\n  // whole deployment root nothing deploys.\n  await rm(adapterDir, { recursive: true, force: true });\n\n  const stagedGroups: StagedGroupResult[] = [];\n  for (const group of groups) {\n    const groupStaging = merged(\n      merged(group.staging, runtimeClosure),\n      group.name === DEFAULT_FUNCTION_GROUP ? imageClosure : new Map(),\n    );\n    const path = join(adapterDir, ...group.dirName.split(\"/\"));\n    await mkdir(path, { recursive: true });\n    await stageFiles(groupStaging, path);\n    stagedGroups.push({ name: group.name, path, fileCount: groupStaging.size });\n  }\n\n  await writeFile(manifestPath, JSON.stringify(manifest, null, 2));\n\n  return {\n    manifest,\n    groups,\n    adapterDir,\n    manifestPath,\n    stagedGroups,\n  };\n}\n\n/** Left wins, as everywhere else in this module: first writer of a key keeps it. */\nfunction merged(\n  base: StagingPlan,\n  additions: ReadonlyMap<string, string>,\n): Map<string, string> {\n  const result = new Map(base);\n  for (const [key, source] of additions) {\n    if (!result.has(key)) {\n      result.set(key, source);\n    }\n  }\n  return result;\n}\n\n/**\n * The pure half of {@link writeBuildOutputs}: everything derived from the build\n * outputs, with no writes. Split out so it can be unit tested against committed\n * `onBuildComplete` fixtures.\n *\n * Throws on any non-Node output and on any staging key two outputs map to\n * different content.\n */\nexport function buildAdapterManifest(\n  ctx: BuildCompleteContext,\n  options: BuildOutputsOptions = {},\n): BuildAdapterManifestResult {\n  const { outputs, repoRoot } = ctx;\n  const basePath = ctx.config.basePath || \"\";\n  assertBuildCwd(ctx, options.buildCwd ?? process.cwd());\n  const invocable: InvocableOutput[] = [\n    ...outputs.pages,\n    ...outputs.pagesApi,\n    ...outputs.appPages,\n    ...outputs.appRoutes,\n    ...(outputs.middleware ? [outputs.middleware] : []),\n  ];\n\n  assertNodeRuntimes(invocable, outputs.middleware);\n  warnOnDroppedRouteConfig(invocable);\n\n  const staticFiles = collectStaticFiles(ctx);\n\n  const entrypoints: Record<string, AdapterEntrypoint> = {};\n  for (const { outputs: group, type } of [\n    { outputs: outputs.pages, type: \"page\" as const },\n    { outputs: outputs.pagesApi, type: \"page-api\" as const },\n    { outputs: outputs.appPages, type: \"app-page\" as const },\n    { outputs: outputs.appRoutes, type: \"app-route\" as const },\n  ]) {\n    for (const output of group) {\n      addEntrypoint(entrypoints, repoRoot, output, type, basePath);\n    }\n  }\n\n  addPrerenderPathnames(\n    entrypoints,\n    outputs.prerenders,\n    ctx.routing.dynamicRoutes,\n    basePath,\n    `${basePath}/_next/data/${ctx.buildId}/`,\n  );\n\n  const pathnames = sortedUnique([\n    ...Object.keys(entrypoints),\n    ...Object.keys(staticFiles),\n  ]);\n\n  const functionGroups =\n    options.functionGroups ??\n    parseFunctionGroupsEnv(process.env[FUNCTION_GROUPS_ENV_VAR]);\n  // i18n is checked first: it rejects the combination outright, and running it\n  // after the assignment meant an i18n app got the assignment's \"pattern matches\n  // no route\" error instead — true, but about the wrong thing, since a localized\n  // template never matches an unlocalized pattern.\n  if (functionGroups) {\n    assertNoI18nSplitting(ctx.config.i18n ?? null);\n  }\n  const assignment = functionGroups\n    ? assignRoutesToGroups(\n        functionGroups,\n        // Keyed on the file, not the output `id`: a Pages Router page and its\n        // `/_next/data/<buildId>/<page>.json` route are separate outputs with\n        // separate ids backed by one file, and only the page's template matches\n        // a group pattern.\n        Object.entries(entrypoints).map(([template, entrypoint]) => ({\n          template,\n          entrypointId: entrypoint.filePath,\n          type: entrypoint.type,\n        })),\n        {\n          basePath: ctx.config.basePath || \"\",\n          buildId: ctx.buildId,\n          trailingSlash: ctx.config.trailingSlash === true,\n          routing: ctx.routing,\n        },\n      )\n    : undefined;\n\n  const manifest: AdapterManifest = {\n    version: ADAPTER_MANIFEST_VERSION as 1,\n    buildId: ctx.buildId,\n    relativeProjectDir: toPosix(relative(repoRoot, ctx.projectDir)),\n    config: {\n      basePath: ctx.config.basePath || \"\",\n      trailingSlash: ctx.config.trailingSlash === true,\n      assetPrefix: ctx.config.assetPrefix || \"\",\n      distDir: toPosix(relative(ctx.projectDir, ctx.distDir)),\n      compress: ctx.config.compress !== false,\n      generateEtags: ctx.config.generateEtags !== false,\n      i18n: ctx.config.i18n ?? null,\n      deploymentId: (ctx.config.deploymentId ?? \"\").replace(\n        /[^A-Za-z0-9_-]/g,\n        \"-\",\n      ),\n    },\n    routing: ctx.routing,\n    pathnames,\n    entrypoints,\n    middleware: buildMiddleware(repoRoot, outputs.middleware),\n    staticFiles,\n    ...(assignment\n      ? {\n          groups: assignment.templates,\n          behaviors: assignment.behaviors,\n          functionGroups: functionGroups!.map(({ name, routes }) => ({\n            name,\n            routes,\n          })),\n        }\n      : {}),\n  };\n\n  const groups: StagedGroup[] = assignment\n    ? Object.entries(assignment.templates).map(([name, templates]) => ({\n        name,\n        dirName: groupStagingDirName(name),\n        staging: collectGroupStagingPlan(\n          ctx,\n          invocable,\n          entrypoints,\n          templates,\n        ),\n      }))\n    : [\n        {\n          name: DEFAULT_FUNCTION_GROUP,\n          dirName: groupStagingDirName(),\n          staging: servedStagingPlan(ctx, invocable),\n        },\n      ];\n\n  return { manifest, groups };\n}\n\n/**\n * One group's slice of the staging plan: the assets of the outputs it owns, and\n * nothing else.\n *\n * Middleware is in every group, not just the default one — it runs on every\n * request wherever that request lands, so it is duplicated by design, as is the\n * `next` closure the entrypoints share. The same goes for the static files the\n * runtime serves itself (`404.html`, `favicon.ico.body`): any group can be asked\n * for them. And so are the not-found and error pages: the runtime renders a\n * 404 or a 500 with whichever of them the shared manifest names\n * (`statusTargets` in `runtime/dispatch.ts`), in whichever group the\n * request reached, so a group without them answered a URL under its own\n * pattern that matches no route with \"the deployment package is incomplete\".\n *\n * Ownership is matched on the entrypoint's `filePath`, not its `id` or\n * pathname: the manifest's entrypoints are keyed by *template*, an output may\n * back several templates, and {@link addPrerenderPathnames} synthesizes\n * entrypoints that carry the *prerender's* id, which no invocable output has (the\n * root-params app: entrypoint `/en` with `id: \"/en\"` backed by the output\n * `/[locale]`). The synthesized entrypoint's `filePath` is the owning output's.\n */\nfunction collectGroupStagingPlan(\n  ctx: BuildCompleteContext,\n  invocable: InvocableOutput[],\n  entrypoints: Record<string, AdapterEntrypoint>,\n  templates: string[],\n): Map<string, string> {\n  const basePath = ctx.config.basePath || \"\";\n  const ownedEntrypoints = [\n    ...templates,\n    ...ERROR_PAGE_SUFFIXES.map((suffix) => `${basePath}${suffix}`),\n  ]\n    .map((template) => entrypoints[template])\n    .filter((entry): entry is AdapterEntrypoint => entry !== undefined);\n  const ownedFiles = new Set(ownedEntrypoints.map((entry) => entry.filePath));\n  const middleware = ctx.outputs.middleware;\n  const owned = invocable.filter(\n    (output) =>\n      ownedFiles.has(toPosix(relative(ctx.repoRoot, output.filePath))) ||\n      output === middleware,\n  );\n  return servedStagingPlan(ctx, owned);\n}\n\n/** {@link collectStagingPlan} for `outputs`, plus the files the runtime serves. */\nfunction servedStagingPlan(\n  ctx: BuildCompleteContext,\n  outputs: InvocableOutput[],\n): Map<string, string> {\n  const staging = collectStagingPlan(ctx, outputs);\n  stageServedStaticFiles(ctx, staging);\n  return staging;\n}\n\n/**\n * Job 1: reject non-Node outputs, everywhere.\n *\n * `export const runtime = 'edge'` on a page or route handler lands in\n * `appPages`/`appRoutes`/`pages`/`pagesApi` with `runtime: 'edge'`,\n * `assets: {}`, and an `edgeRuntime` descriptor needing `globalThis._ENTRIES`\n * and a sandbox. Guarding middleware alone would leave a silent failure mode\n * for edge pages: an entrypoint we can't invoke and no assets to invoke it\n * with.\n */\nfunction assertNodeRuntimes(\n  invocable: InvocableOutput[],\n  middleware: AdapterOutputs[\"middleware\"],\n): void {\n  const offending = invocable.filter((output) => output.runtime !== \"nodejs\");\n  if (offending.length === 0) {\n    return;\n  }\n\n  // Middleware is reported separately from routes. Its `sourcePage` is `/`, so\n  // folding it in with the routes produces the actively misleading advice to\n  // remove `export const runtime = \"edge\"` from the home page - which is where\n  // the edge runtime is not, and may not even exist.\n  const offendingMiddleware = middleware && offending.includes(middleware);\n  // `.rsc` variants share a `sourcePage` with their HTML sibling, so dedupe.\n  const routes = sortedUnique(\n    offending\n      .filter((output) => output !== middleware)\n      .map((output) => `${output.sourcePage} (runtime: \"${output.runtime}\")`),\n  );\n\n  const reasons: string[] = [];\n  if (routes.length > 0) {\n    reasons.push(\n      `cdk-nextjs cannot deploy routes built for the edge runtime. ` +\n        `Remove \\`export const runtime = \"edge\"\\` from:\\n` +\n        routes.map((route) => `  - ${route}`).join(\"\\n\"),\n    );\n  }\n  if (offendingMiddleware) {\n    reasons.push(\n      `cdk-nextjs cannot deploy middleware built for the edge runtime ` +\n        `(${middleware.filePath}, runtime: \"${middleware.runtime}\"). ` +\n        `Rename it to \\`proxy.ts\\` (Next.js 16 runs proxy on the Node ` +\n        `runtime), or keep \\`middleware.ts\\` and add ` +\n        `\\`export const config = { runtime: \"nodejs\" }\\` to it — ` +\n        `\\`middleware.ts\\` defaults to the edge runtime, but does not require it.`,\n    );\n  }\n\n  throw new Error(\n    `${LOG_PREFIX} ${reasons.join(\"\\n\")}\\n` +\n      `The edge runtime is deprecated in Next.js: ` +\n      `https://nextjs.org/docs/messages/edge-runtime-deprecated`,\n  );\n}\n\n/**\n * Warn on route config cdk-nextjs does not honor. An author who set these asked\n * for something explicitly, so say so rather than ignoring it silently; never\n * throw, because route-level `maxDuration` is valid Next.js.\n *\n * `NextjsBuild` runs `next build` with `stdio: \"inherit\"`, so this reaches the\n * user's terminal. See the plan's \"Decisions\" for why neither is honored.\n */\nfunction warnOnDroppedRouteConfig(invocable: InvocableOutput[]): void {\n  const dropped: Record<\"maxDuration\" | \"preferredRegion\", string[]> = {\n    maxDuration: [],\n    preferredRegion: [],\n  };\n  for (const output of invocable) {\n    if (output.config?.maxDuration !== undefined) {\n      dropped.maxDuration.push(output.sourcePage);\n    }\n    if (output.config?.preferredRegion !== undefined) {\n      dropped.preferredRegion.push(output.sourcePage);\n    }\n  }\n\n  const remedy: Record<\"maxDuration\" | \"preferredRegion\", string> = {\n    maxDuration:\n      \"Set the function timeout with the construct's `overrides` prop instead (e.g. `overrides: { nextjsFunctions: { functionProps: { timeout: Duration.seconds(30) } } }`); a Lambda timeout is per-function while `maxDuration` is per-route.\",\n    preferredRegion:\n      \"Honoring it would require a multi-region deployment, which this construct does not model.\",\n  };\n\n  for (const key of [\"maxDuration\", \"preferredRegion\"] as const) {\n    const routes = sortedUnique(dropped[key]);\n    if (routes.length === 0) {\n      continue;\n    }\n    console.warn(\n      `${LOG_PREFIX} \\`${key}\\` is not honored by cdk-nextjs. ` +\n        `${routes.length} route(s) set it, including: ${routes.slice(0, 5).join(\", \")}` +\n        `${routes.length > 5 ? `, and ${routes.length - 5} more` : \"\"}. ` +\n        remedy[key],\n    );\n  }\n}\n\n/**\n * Jobs 2, 3 and 6: the deduped union of every shipped output's traced `assets`,\n * plus each entrypoint file itself, plus the env files, with `assetsHashes` used\n * as a conflict check.\n *\n * Dedup is by key: the traced `next` closure is merged into every output's\n * `assets` (`getSharedNodeAssets` → `sharedNodeAssets`), so N outputs\n * overwhelmingly repeat keys. What the hashes buy is detecting two outputs\n * mapping the **same key to different content**, which is unpackageable into\n * one Lambda — fail the build loudly rather than letting last-write-wins pick.\n */\nfunction collectStagingPlan(\n  ctx: BuildCompleteContext,\n  invocable: InvocableOutput[],\n): Map<string, string> {\n  const { repoRoot } = ctx;\n  const staging = new Map<string, string>();\n  const hashes = new Map<string, string>();\n\n  const add = (key: string, source: string, hash?: string) => {\n    assertStagingKey(key, source);\n    const existingHash = hashes.get(key);\n    if (\n      hash !== undefined &&\n      existingHash !== undefined &&\n      existingHash !== hash\n    ) {\n      throw new Error(\n        `${LOG_PREFIX} Two build outputs map \"${key}\" to different content ` +\n          `(hashes ${existingHash} and ${hash}). One deployment package cannot ` +\n          `hold both. This usually means two Next.js projects in the same repo ` +\n          `write the same repo-root-relative path.`,\n      );\n    }\n    if (hash !== undefined) {\n      hashes.set(key, hash);\n    }\n    if (!staging.has(key)) {\n      staging.set(key, source);\n    }\n  };\n\n  for (const output of invocable) {\n    for (const [key, source] of Object.entries(output.assets)) {\n      add(key, source, output.assetsHashes[key]);\n    }\n    // The entrypoint's own file is deliberately absent from its `assets` — the\n    // NFT trace covers the closure it requires, not itself. `assetsHashes` does\n    // carry it (keyed the same way), which is also what pins the key format.\n    const entryKey = toPosix(relative(repoRoot, output.filePath));\n    add(entryKey, output.filePath, output.assetsHashes[entryKey]);\n  }\n\n  // Job 2, second half: `writeStandaloneDirectory` filters `loadedEnvFiles` to\n  // exactly these two and copies them; `build-complete.js` has no env-file\n  // handling at all, so they are not in any `assets` map.\n  for (const envFile of ENV_FILES) {\n    const source = join(ctx.projectDir, envFile);\n    if (existsSync(source)) {\n      add(toPosix(relative(repoRoot, source)), source);\n    }\n  }\n\n  return staging;\n}\n\n/**\n * Job 2, third part: the static files the *runtime* has to serve, and their\n * sources.\n *\n * `outputs.staticFiles` mixes two populations with the same `STATIC_FILE` type:\n *\n * - **`<distDir>/static/**` and `public/**`** — uploaded to S3 by\n *   `NextjsStaticAssets`, and CloudFront / API Gateway answer them before the\n *   request ever reaches the compute. Not staged: `public/` alone can be\n *   hundreds of megabytes against a 250 MB unzipped Lambda cap, and it would be\n *   a second copy of bytes already in S3. `public/` is not in\n *   `outputs.staticFiles` at all — Next.js lists it only for `output: \"export\"`\n *   — and it is deliberately not added here: the container runtime lists it off\n *   disk at cold start instead, as `next start` does (`readPublicFiles` in\n *   `src/runtime/public-files.ts`), because only the disk knows what an app's\n *   `postbuild` wrote into it after this hook ran.\n * - **everything else**, all of it under `<distDir>/server/` — `404.html`,\n *   `500.html`, `favicon.ico.body`, and fully-static Pages Router HTML. Nothing\n *   in front of the compute serves these, so they are staged. Bounded by route\n *   count and small.\n *\n * The pathname → key map is returned for *all* of them, because dispatch has to\n * resolve a pathname to \"static file, not a 404\" either way; the runtime 404s if\n * the file turns out not to be in the package, which is only reachable when the\n * distribution is misrouted.\n *\n * Staging is {@link stageServedStaticFiles}, applied once per deployment root.\n */\nfunction collectStaticFiles(ctx: BuildCompleteContext): Record<string, string> {\n  const { repoRoot } = ctx;\n  const basePath = ctx.config.basePath || \"\";\n  const staticFiles = new Map<string, string>();\n  const pagesDir = join(ctx.distDir, \"server\", \"pages\") + sep;\n\n  for (const output of ctx.outputs.staticFiles) {\n    const key = toPosix(relative(repoRoot, output.filePath));\n    const pathnames = routablePathnames(\n      output.pathname,\n      basePath,\n      output.filePath.startsWith(pagesDir),\n    );\n    for (const pathname of pathnames) {\n      const existing = staticFiles.get(pathname);\n      if (existing !== undefined && existing !== key) {\n        throw new Error(\n          `${LOG_PREFIX} Two static files claim the pathname ` +\n            `\"${pathname}\" (\"${existing}\" and \"${key}\"). Dispatch cannot ` +\n            `choose between them.`,\n        );\n      }\n      staticFiles.set(pathname, key);\n    }\n  }\n\n  // Sorted because object keys keep insertion order, and a byte-stable\n  // `manifest.json` is what keeps it diffable and the CDK asset hash from\n  // churning.\n  return Object.fromEntries(\n    [...staticFiles].sort(([a], [b]) => (a < b ? -1 : 1)),\n  );\n}\n\n/**\n * The pathnames an output answers, which for one shape is not the pathname\n * `next build` reported.\n *\n * **A Pages Router home page arrives as `/index`.** The adapter hook derives every\n * Pages pathname with `normalizePagePath(page)`, and `normalizePagePath(\"/\")` is\n * `\"/index\"` (`next/dist/shared/lib/page-path/normalize-page-path.js`) — for the\n * `PAGES` output of an SSG or SSR home page and for the `STATIC_FILE` of a\n * fully-static one alike. `/index` is not a URL anyone requests, and nothing else\n * in the outputs carries `/` for that page, so without this the home page is in\n * neither `manifest.pathnames` nor `manifest.entrypoints`/`staticFiles`, and every\n * request to `/` 404s while every other page of the same app serves. Measured\n * against next.js's `test/e2e/new-link-behavior` (`/` returned the built-in 404,\n * the six other pages were fine) and `test/e2e/prerender-preview` (the one case\n * that fetches `/` got the 404 page's HTML, the eight that hit API routes passed).\n *\n * Pages Router outputs only, which is what `fromPagesRouter` says. App Router\n * reports its home page as `/` and only the RSC sibling as `/index.rsc`, so an\n * App Router `/index` is `app/index/page.tsx` — a real route at `/index`, and\n * mapping it to `/` made an app with both pages fail the build on a pathname\n * collision, and an app with only the second serve it at `/`. The same goes for\n * a `public/index` file.\n *\n * Both pathnames are registered. `/` because it is the real one; `/index` because\n * next's own minimal mode — the mode our runtime runs in — accepts it, rewriting\n * `req.url` and `x-matched-path` from `/index` to `/` before matching\n * (`base-server.ts`, \"in minimal mode\"), so dropping it would be a divergence in\n * the other direction.\n *\n * Unambiguous within the Pages Router despite the collision it looks like:\n * `normalizePagePath(\"/index\")` is `\"/index/index\"`, so a reported `/index` can\n * only have come from the page `/`.\n * The data route of the same page, `/_next/data/<buildId>/index.json`, and an App\n * Router `/index.rsc` are both real URLs and are left alone by the exact match.\n */\nfunction routablePathnames(\n  pathname: string,\n  basePath: string,\n  fromPagesRouter: boolean,\n): string[] {\n  if (!fromPagesRouter || pathname !== `${basePath}/index`) {\n    return [pathname];\n  }\n  // `basePath || \"/\"`, not `${basePath}/`: with `basePath: \"/prod\"` the home page\n  // is `/prod`, which is how the App Router fixtures report theirs.\n  return [basePath || \"/\", pathname];\n}\n\n/**\n * Add the static files the *runtime* serves to a staging plan — the \"everything\n * else\" population described on {@link collectStaticFiles}, all of it under\n * `<distDir>/server/`.\n *\n * Separate from building the manifest's `staticFiles` map because the map is the\n * same for every group while the staging is applied once per deployment root:\n * any group can be asked for `/404`, so every group ships these.\n */\nfunction stageServedStaticFiles(\n  ctx: BuildCompleteContext,\n  staging: Map<string, string>,\n): void {\n  const { repoRoot, distDir } = ctx;\n  const clientStaticDir = join(distDir, \"static\") + sep;\n\n  for (const output of ctx.outputs.staticFiles) {\n    const servedByS3 =\n      output.filePath.startsWith(clientStaticDir) ||\n      !output.filePath.startsWith(distDir + sep);\n    if (servedByS3) {\n      continue;\n    }\n    const key = toPosix(relative(repoRoot, output.filePath));\n    assertStagingKey(key, output.filePath);\n    staging.set(key, output.filePath);\n  }\n}\n\n/**\n * The invariant behind `manifest.relativeProjectDir`: `next build` must run from\n * the project directory.\n *\n * Next inlines `relative(process.cwd(), projectDir)` into every entrypoint\n * (`define-env.js`) and the built code resolves it against the *runtime*\n * `process.cwd()`. Keeping build cwd and project dir equal makes that inlined\n * value `\"\"`, so the runtime only has to `chdir` to the staged project dir. A\n * build run from elsewhere would inline a non-empty relative path — often one\n * pointing outside the staging tree — and every entrypoint would fail to find\n * `required-server-files.json` at runtime with no hint as to why.\n */\nfunction assertBuildCwd(ctx: BuildCompleteContext, buildCwd: string): void {\n  const cwd = resolve(buildCwd);\n  if (cwd === resolve(ctx.projectDir)) {\n    return;\n  }\n  throw new Error(\n    `${LOG_PREFIX} \\`next build\\` must run from the Next.js project ` +\n      `directory. It ran from \"${cwd}\" with the project at ` +\n      `\"${ctx.projectDir}\". Next.js bakes the relative path between those two ` +\n      `into every built entrypoint, and cdk-nextjs cannot reproduce that layout ` +\n      `in the deployment package. Change directory first (\\`cd ` +\n      `${relative(cwd, ctx.projectDir) || \".\"} && next build\\`) instead of ` +\n      `passing the directory as an argument; in a monorepo, run the app's own ` +\n      `build script from its directory (e.g. \\`pnpm --filter <app> build\\`, ` +\n      `which runs in the package directory).`,\n  );\n}\n\nfunction addEntrypoint(\n  entrypoints: Record<string, AdapterEntrypoint>,\n  repoRoot: string,\n  output: { id: string; pathname: string; filePath: string },\n  type: AdapterEntrypointType,\n  basePath: string,\n): void {\n  const filePath = toPosix(relative(repoRoot, output.filePath));\n  const pathnames = routablePathnames(\n    output.pathname,\n    basePath,\n    type === \"page\",\n  );\n  for (const pathname of pathnames) {\n    const existing = entrypoints[pathname];\n    if (existing && existing.filePath !== filePath) {\n      throw new Error(\n        `${LOG_PREFIX} Two build outputs claim the pathname \"${pathname}\" ` +\n          `(\"${existing.filePath}\" and \"${filePath}\"). Dispatch cannot choose ` +\n          `between them.`,\n      );\n    }\n    entrypoints[pathname] = { id: output.id, filePath, type };\n  }\n}\n\n/**\n * Add the *prerender* pathnames that no invocable output claims and that routing\n * cannot otherwise reach.\n *\n * `resolveRoutes` can only match a pathname present in `manifest.pathnames`, and\n * for a dynamic match it returns the **template** it matched. Routes and static\n * files cover most of that; two shapes they miss:\n *\n * 1. **Templates.** A request for `/_next/data/<buildId>/fr/blog/hello.json` only\n *    resolves if `/_next/data/<buildId>/fr/blog/[slug].json` is listed, and that\n *    pathname exists solely as a `prerenders` entry.\n * 1b. **A static `getStaticProps` page's data route.** `/_next/data/<buildId>/gsp.json`\n *    has no template to match and no rule of its own: `next build` only emits a\n *    `dynamicRoutes` rule for a data route when the page is dynamic *or* the app has\n *    middleware (`build-complete.ts`, `needsMiddlewareResolveRoutes`, which is also\n *    what `routing.shouldNormalizeNextData` reports). Without middleware Next.js\n *    expects the platform to serve the data route as an output, by pathname — so a\n *    concrete data-route prerender is registered whatever the rules say. Missing it\n *    turned every client-side navigation into such a page into a full page load,\n *    because the router's `.json` fetch 404'd: measured against\n *    `test/e2e/no-page-props`. Only when no *ungated* rule matches, for the reason\n *    below — a dynamic page's `/…/blog/hello.json` must keep resolving to its\n *    `[slug].json` template, which is where `nxtPslug` comes from.\n * 2. **Concrete pathnames whose dynamic route rule is gated.** A route whose params\n *    can never be filled at request time — root params are the case that produced\n *    this, `app/[locale]/page.tsx` with `generateStaticParams()` and no\n *    `app/layout.tsx` — gets its `dynamicRoutes` rule emitted with a draft-mode\n *    `has` on `__prerender_bypass`. Next.js is saying: invoke the function only in\n *    draft mode, and otherwise serve the prerender you were handed. Vercel's CDN\n *    does that from the output itself; we route the request to the owning\n *    entrypoint, which answers it out of the seeded cache. Without this, `/en` is a\n *    404 while `next start` renders it — and so is every `.rsc`/`.segments`\n *    variant, which is why a client-side navigation into such an app never\n *    completes.\n *\n * A concrete pathname is added only when a gated rule matches it and no ungated\n * one does — the set that would 404 today *and* that routing can still produce.\n * Adding them unconditionally was measured to be actively wrong twice over:\n * `/isr/1` resolves to itself rather than to `/isr/[id]`, losing the `nxtPid`\n * query param the route needs, and pathnames no rule matches at all (a static\n * route's `.segments/…` outputs, which `resolveRoutes` never asks for) are dead\n * manifest weight. Matching mirrors `resolveRoutes`, which is case-insensitive by\n * default.\n *\n * The owning entrypoint comes from `prerender.route`, which is the unprefixed and\n * unlocalized source route (`/blog/[slug]`), hence the basePath-then-bare ladder.\n * Locale variants of one page share a `filePath`, so any locale's entrypoint is\n * the right target. An RSC or segment-prefetch pathname prefers the route's `.rsc`\n * entrypoint, because that is the key `resolveRoutes` resolves such a request to.\n */\nfunction addPrerenderPathnames(\n  entrypoints: Record<string, AdapterEntrypoint>,\n  prerenders: AdapterOutputs[\"prerenders\"],\n  dynamicRoutes: {\n    sourceRegex: string;\n    has?: unknown[];\n    missing?: unknown[];\n  }[],\n  basePath: string,\n  dataRoutePrefix: string,\n): void {\n  const matchers = dynamicRoutes.map((route) => ({\n    regex: new RegExp(route.sourceRegex, \"i\"),\n    gated: Boolean(route.has?.length || route.missing?.length),\n  }));\n  const matchingRules = (pathname: string) =>\n    matchers.filter(({ regex }) => regex.test(pathname));\n  const onlyGatedRulesMatch = (pathname: string): boolean => {\n    const matched = matchingRules(pathname);\n    return matched.length > 0 && matched.every(({ gated }) => gated);\n  };\n  /**\n   * Nothing reaches this pathname at request time: either no rule matches it or\n   * every rule that does is gated. The gated half is {@link onlyGatedRulesMatch};\n   * the \"no rule at all\" half only ever holds for a data route, because a page's\n   * own pathname is an output.\n   */\n  const nothingUngatedMatches = (pathname: string): boolean =>\n    matchingRules(pathname).every(({ gated }) => gated);\n\n  const orphans: string[] = [];\n  for (const prerender of prerenders) {\n    const { pathname } = prerender;\n    if (entrypoints[pathname]) {\n      continue;\n    }\n    const isTemplate = pathname.includes(\"[\");\n    const isDataRoute =\n      pathname.startsWith(dataRoutePrefix) && pathname.endsWith(\".json\");\n    const reachable = isDataRoute\n      ? nothingUngatedMatches(pathname)\n      : onlyGatedRulesMatch(pathname);\n    if (!isTemplate && !reachable) {\n      continue;\n    }\n    const suffixes = pathname.endsWith(\".rsc\") ? [\".rsc\", \"\"] : [\"\"];\n    const owner = suffixes\n      .flatMap((suffix) => [\n        `${basePath}${prerender.route}${suffix}`,\n        `${prerender.route}${suffix}`,\n      ])\n      .map((key) => entrypoints[key])\n      .find(Boolean);\n    if (!owner) {\n      orphans.push(`${pathname} (route: \"${prerender.route}\")`);\n      continue;\n    }\n    entrypoints[pathname] = {\n      id: prerender.id,\n      filePath: owner.filePath,\n      type: owner.type,\n    };\n  }\n\n  if (orphans.length > 0) {\n    // Warn rather than throw: an unmapped pathname degrades one URL shape to a\n    // 404, which is what would happen without this function at all. A throw\n    // would break the build outright on an output shape a future `next` minor\n    // might introduce.\n    console.warn(\n      `${LOG_PREFIX} ${orphans.length} prerender pathname(s) have no ` +\n        `matching route entrypoint and will 404: ` +\n        `${orphans.slice(0, 5).join(\", \")}` +\n        `${orphans.length > 5 ? `, and ${orphans.length - 5} more` : \"\"}.`,\n    );\n  }\n}\n\nfunction buildMiddleware(\n  repoRoot: string,\n  middleware: AdapterOutputs[\"middleware\"],\n): AdapterMiddleware | null {\n  if (!middleware) {\n    return null;\n  }\n  // `config.matchers` is deliberately not copied here: it arrives inside\n  // `ctx.routing.middlewareMatchers`, which `@next/routing` consumes directly.\n  return {\n    id: middleware.id,\n    filePath: toPosix(relative(repoRoot, middleware.filePath)),\n  };\n}\n\n/**\n * Copy the staging plan into `stagingDir`.\n *\n * **Symlinks are recreated as symlinks, not dereferenced**, which is what\n * Next.js's own `copyTracedFiles` does (`next/dist/build/utils.js`: `readlink`\n * then `symlink`, with a Windows junction fallback). Under pnpm a traced asset\n * key is frequently a *directory* symlink into the store\n * (`node_modules/.pnpm/next@…/node_modules/react` → `../../react@19.2.3/…`), so\n * `copyFile` fails outright with `ENOTSUP`. Dereferencing instead would triple\n * the tree — `examples/app-playground` measures 32 MB staged versus 96 MB with\n * `du -shL`, against a 250 MB unzipped Lambda cap — because whole packages are\n * reachable through several such links. The link targets are themselves staged\n * keys, so relative links resolve inside the deployment root.\n *\n * Regular files are staged first so that a symlink whose path was already\n * materialized as a real directory is skipped rather than clobbering it.\n *\n * Nothing may dereference them afterwards: the Functions zip keeps them as\n * links (`zipDirectory`), and the Containers `COPY` does too.\n */\n/** Bounded so a large app doesn't exhaust file descriptors. */\nconst STAGING_CONCURRENCY = 32;\n\nasync function stageFiles(\n  staging: StagingPlan,\n  stagingDir: string,\n): Promise<void> {\n  const planned = [...staging];\n  // Links land by plan index, so the pass below creates them in the plan's\n  // order whatever order the workers finished in.\n  const links: Array<[string, string, string] | undefined> = new Array(\n    planned.length,\n  );\n  let nextEntry = 0;\n  const worker = async () => {\n    while (nextEntry < planned.length) {\n      const index = nextEntry++;\n      const [key, source] = planned[index];\n      const linkTarget = await readlink(source).catch(() => null);\n      if (linkTarget !== null) {\n        links[index] = [key, source, linkTarget];\n        continue;\n      }\n      const dest = join(stagingDir, key);\n      await mkdir(dirname(dest), { recursive: true });\n      await copyFile(source, dest);\n    }\n  };\n  await Promise.all(\n    Array.from(\n      { length: Math.min(STAGING_CONCURRENCY, planned.length) },\n      worker,\n    ),\n  );\n\n  for (const link of links) {\n    if (link === undefined) {\n      continue;\n    }\n    const [key, source, linkTarget] = link;\n    const dest = join(stagingDir, key);\n    if (existsSync(dest)) {\n      // Already staged as real content by the pool above; the link would add\n      // nothing and would replace a directory we need.\n      continue;\n    }\n    await mkdir(dirname(dest), { recursive: true });\n    const resolved = resolve(dirname(dest), linkTarget);\n    if (resolved === stagingDir || resolved.startsWith(stagingDir + sep)) {\n      await symlink(linkTarget, dest);\n    } else {\n      // Points outside the deployment root, so the link would dangle in Lambda.\n      // Absolute store paths are the realistic case here.\n      await cp(source, dest, { recursive: true, dereference: true });\n    }\n  }\n}\n\n/**\n * Adds {@link RUNTIME_NEXT_MODULES}, `@next/env`, and everything they require to\n * `staging`, and {@link IMAGE_NEXT_MODULES} and theirs to `imageStaging`.\n *\n * Without this the deployment is complete for every route the app has and broken\n * for `/_next/image`: the traced `assets` of a build output cover what the *app*\n * reaches, and an app never reaches next's image optimizer, so\n * `next/dist/server/image-optimizer.js` and its closure are simply absent and\n * every image request 500s with a `MODULE_NOT_FOUND` from `nextModule`.\n *\n * Resolution is anchored inside `ctx.projectDir` for the same reason\n * `useNextFrom` anchors there at runtime: it is the directory whose\n * `node_modules` walk finds the app's `next`. A repo where that resolution fails\n * is not a real `next build` — nothing else would have run — so it warns and\n * continues rather than failing a build for a package it could not have needed.\n * A missing *tracer* is different: `next` is right there and image optimization\n * would silently 500 in production, so that throws.\n */\nasync function addRuntimeNextClosure(\n  ctx: BuildCompleteContext,\n  staging: Map<string, string>,\n  imageStaging: Map<string, string>,\n): Promise<void> {\n  // The anchor file needn't exist; `createRequire` only reads its directory.\n  const nextRequire = createRequire(\n    join(ctx.projectDir, \"cdk-nextjs-next-resolver.cjs\"),\n  );\n\n  let entries: string[];\n  let imageEntries: string[];\n  try {\n    entries = RUNTIME_NEXT_MODULES.map((specifier) =>\n      nextRequire.resolve(specifier),\n    );\n    imageEntries = IMAGE_NEXT_MODULES.map((specifier) =>\n      nextRequire.resolve(specifier),\n    );\n  } catch (cause) {\n    console.warn(\n      `${LOG_PREFIX} Could not resolve next's image optimizer from ` +\n        `\"${ctx.projectDir}\" (${(cause as Error).message}). Requests to ` +\n        `/_next/image will fail at runtime.`,\n    );\n    return;\n  }\n  // `loadEnvFiles` (runtime `next-modules.ts`) loads the staged env files with\n  // `@next/env`, which is `next`'s dependency, so resolved from `next`'s dir.\n  // An app never requires it, so no output's trace has it either.\n  const nextPackage = nextRequire.resolve(\"next/package.json\");\n  try {\n    entries.push(createRequire(nextPackage).resolve(\"@next/env\"));\n  } catch (cause) {\n    throw new Error(\n      `${LOG_PREFIX} Could not resolve \"@next/env\" from the app's \\`next\\`, ` +\n        `which the cdk-nextjs runtime uses to load .env files.`,\n      { cause },\n    );\n  }\n\n  let nodeFileTrace: NodeFileTrace;\n  try {\n    ({ nodeFileTrace } = nextRequire(NEXT_FILE_TRACER));\n  } catch (cause) {\n    throw new Error(\n      `${LOG_PREFIX} Could not load \"${NEXT_FILE_TRACER}\", which cdk-nextjs uses ` +\n        `to stage the \\`next\\` files its image optimizer requires. This Next.js ` +\n        `version may have moved it; please open an issue.`,\n      { cause },\n    );\n  }\n\n  const add = (fileList: Set<string>, target: Map<string, string>) => {\n    for (const traced of fileList) {\n      const key = toPosix(traced);\n      if (target.has(key)) {\n        continue;\n      }\n      const source = join(ctx.repoRoot, traced);\n      assertStagingKey(key, source);\n      target.set(key, source);\n    }\n  };\n  add(\n    (await nodeFileTrace(imageEntries, { base: ctx.repoRoot })).fileList,\n    imageStaging,\n  );\n  const { fileList } = await nodeFileTrace(entries, { base: ctx.repoRoot });\n  // The trace starts from `@next/env`'s real path, so under pnpm it never\n  // passes through the `.pnpm/next@…/node_modules/@next/env` link that `next`\n  // resolves it by. Without the link, every request fails at cold start with\n  // \"Cannot find module '@next/env'\".\n  const nextEnvLink = join(dirname(nextPackage), \"..\", \"@next\", \"env\");\n  if (lstatSync(nextEnvLink, { throwIfNoEntry: false })?.isSymbolicLink()) {\n    // `resolve` returns real paths, so relative to the real repo root.\n    fileList.add(relative(realpathSync(ctx.repoRoot), nextEnvLink));\n  }\n  add(fileList, staging);\n}\n\n/**\n * Add `<distDir>/required-server-files.json` to a plan every group is merged with.\n *\n * It reaches a group otherwise only as a traced `asset` of some invocable output,\n * which is not a guarantee: a group whose templates are all assigned elsewhere\n * owns no outputs at all. That is reachable — a Pages-Router-only app whose every\n * page falls under the configured `functionGroups` leaves the *default* group\n * template-empty, and the default group is still what serves `/_next/image`, the\n * static files, and the distribution's catch-all.\n *\n * Its absence is not a partial failure: `loadRuntime` probes for exactly this file\n * before it will serve anything, and `image.ts` reads the image config out of it,\n * so the whole root answers \"the deployment package is incomplete\". Cheap to make\n * unconditional, so make it unconditional.\n *\n * Not traced like {@link RUNTIME_NEXT_MODULES}, because it is data rather than a\n * module: nothing `require`s it, so no file tracer can find it.\n *\n * Absence is left to `loadRuntime`, which names the file and the layout contract\n * it belongs to. `next build` always writes it, so there is no build-time error\n * worth inventing here for a file this step does not own.\n */\nfunction addRequiredServerFiles(\n  ctx: BuildCompleteContext,\n  staging: Map<string, string>,\n): void {\n  const source = join(ctx.distDir, \"required-server-files.json\");\n  const key = toPosix(relative(ctx.repoRoot, source));\n  if (staging.has(key) || !existsSync(source)) {\n    return;\n  }\n  assertStagingKey(key, source);\n  staging.set(key, source);\n}\n\n/**\n * Every staged path must land inside the staging tree and must not shadow the\n * reserved directory cdk-nextjs copies its own runtime into at synth.\n */\nfunction assertStagingKey(key: string, source: string): void {\n  if (key === \"\" || key.startsWith(\"/\") || key.startsWith(\"..\")) {\n    throw new Error(\n      `${LOG_PREFIX} Build output asset \"${source}\" resolves to the staging key ` +\n        `\"${key}\", which is outside the deployment root. Set ` +\n        `\\`outputFileTracingRoot\\` so all traced files live under one root.`,\n    );\n  }\n  if (key === RUNTIME_DIR_NAME || key.startsWith(`${RUNTIME_DIR_NAME}/`)) {\n    throw new Error(\n      `${LOG_PREFIX} Build output asset \"${source}\" resolves to the staging key ` +\n        `\"${key}\", but \"${RUNTIME_DIR_NAME}/\" is reserved for cdk-nextjs's own ` +\n        `runtime files.`,\n    );\n  }\n}\n\nfunction toPosix(path: string): string {\n  return sep === \"/\" ? path : path.split(sep).join(\"/\");\n}\n\nfunction sortedUnique(values: string[]): string[] {\n  return [...new Set(values)].sort();\n}\n"]}