cdk-nextjs 0.6.2 → 0.7.1

package/lib/adapter/build-outputs.test.js

@@ -0,0 +1,863 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const app_playground_base_path_json_1 = __importDefault(require("./__fixtures__/app-playground-base-path.json"));
+const app_playground_json_1 = __importDefault(require("./__fixtures__/app-playground.json"));
+const pages_i18n_json_1 = __importDefault(require("./__fixtures__/pages-i18n.json"));
+const build_outputs_1 = require("./build-outputs");
+const manifest_1 = require("../runtime/manifest");
+/**
+ * The fixtures are real `onBuildComplete` contexts captured by
+ * `scripts/capture-adapter-fixture.mjs`, with absolute paths rewritten to a
+ * `/repo` placeholder. Regenerate them when `next` is upgraded.
+ */
+const fixtures = {
+    "app-playground": app_playground_json_1.default,
+    "app-playground-base-path": app_playground_base_path_json_1.default,
+    "pages-i18n": pages_i18n_json_1.default,
+};
+/** Fixtures are JSON, so the structural cast is the point of the cast. */
+const asContext = (fixture) => structuredClone(fixture);
+/**
+ * `buildAdapterManifest` requires the build cwd to be the project dir — see
+ * `assertBuildCwd`. The fixtures' project dirs are synthetic `/repo/…` paths, so
+ * every call supplies it rather than letting it default to `process.cwd()`. The
+ * assertion itself is covered separately below.
+ */
+const build = (ctx) => (0, build_outputs_1.buildAdapterManifest)(ctx, { buildCwd: ctx.projectDir });
+const write = (ctx) => (0, build_outputs_1.writeBuildOutputs)(ctx, { buildCwd: ctx.projectDir });
+/**
+ * The one deployment root an unsplit build stages. Asserted rather than indexed
+ * so a regression that starts splitting unasked fails here instead of silently
+ * checking group 0.
+ */
+const soleRoot = (result) => {
+    expect(result.stagedGroups).toHaveLength(1);
+    return result.stagedGroups[0].path;
+};
+beforeEach(() => {
+    // `maxDuration` warnings are expected from the pages-i18n fixture.
+    jest.spyOn(console, "warn").mockImplementation(() => { });
+});
+afterEach(() => {
+    jest.restoreAllMocks();
+});
+describe.each(Object.keys(fixtures))("buildAdapterManifest(%s)", (name) => {
+    const ctx = asContext(fixtures[name]);
+    const { manifest, groups: [{ staging }], } = build(ctx);
+    it("stamps the manifest version and build identity", () => {
+        expect(manifest.version).toBe(1);
+        expect(manifest.buildId).toBe(ctx.buildId);
+        expect(manifest.relativeProjectDir).toBe(name.startsWith("pages-i18n") ? "pages-i18n" : "app-playground");
+    });
+    it("copies the config fields the runtime router needs", () => {
+        expect(manifest.config).toEqual({
+            basePath: ctx.config.basePath ?? "",
+            trailingSlash: ctx.config.trailingSlash === true,
+            assetPrefix: ctx.config.assetPrefix ?? "",
+            distDir: ".next",
+            compress: true,
+            generateEtags: true,
+            i18n: ctx.config.i18n ?? null,
+            deploymentId: "",
+        });
+    });
+    it("persists ctx.routing verbatim", () => {
+        // `@next/routing`'s `resolveRoutes` consumes this whole object; anything we
+        // reshape here is a behavior difference from `next start`.
+        expect(manifest.routing).toEqual(ctx.routing);
+        expect(manifest.routing).toHaveProperty("middlewareMatchers");
+    });
+    it("maps every invocable output pathname to an entrypoint", () => {
+        const expected = [
+            ...ctx.outputs.pages,
+            ...ctx.outputs.pagesApi,
+            ...ctx.outputs.appPages,
+            ...ctx.outputs.appRoutes,
+        ].map((o) => o.pathname);
+        // Plus dynamic prerender templates, which `addPrerenderPathnames` maps to
+        // the entrypoint of the route that owns them. None of these fixtures has a
+        // gated dynamic route, so no *concrete* prerender pathname is added - see
+        // the root-params test below.
+        const templates = ctx.outputs.prerenders
+            .filter((o) => o.pathname.includes("["))
+            .map((o) => o.pathname);
+        expect(Object.keys(manifest.entrypoints).sort()).toEqual([...new Set([...expected, ...templates])].sort());
+        for (const [pathname, entry] of Object.entries(manifest.entrypoints)) {
+            expect(entry.filePath).toMatch(/^[^/]/);
+            expect(entry.filePath).not.toContain("\\");
+            expect(staging.has(entry.filePath)).toBe(true);
+            expect(entry.id).toBeTruthy();
+            expect(["app-page", "app-route", "page", "page-api"]).toContain(entry.type);
+            expect(pathname).toBeTruthy();
+        }
+    });
+    it("lists pathnames as the sorted union of entrypoints and static files", () => {
+        expect(manifest.pathnames).toEqual([...manifest.pathnames].sort());
+        expect(new Set(manifest.pathnames).size).toBe(manifest.pathnames.length);
+        for (const key of Object.keys(manifest.entrypoints)) {
+            expect(manifest.pathnames).toContain(key);
+        }
+        for (const file of ctx.outputs.staticFiles) {
+            expect(manifest.pathnames).toContain(file.pathname);
+        }
+        // One reported pathname can produce two keys - a `/index` static file is
+        // also served at `/`, see the static-home-page tests below. None of these
+        // fixtures has one, so here the two sets coincide.
+        expect(Object.keys(manifest.staticFiles)).toEqual([...new Set(ctx.outputs.staticFiles.map((f) => f.pathname))].sort());
+    });
+    it("maps each static file to a repo-root-relative key", () => {
+        for (const [pathname, key] of Object.entries(manifest.staticFiles)) {
+            const output = ctx.outputs.staticFiles.find((f) => f.pathname === pathname);
+            expect(key).toBe(output.filePath.replace("/repo/", ""));
+            expect(key.startsWith("/")).toBe(false);
+        }
+    });
+    it("stages the static files nothing in front of the compute serves", () => {
+        // `<distDir>/static` goes to S3; `<distDir>/server/**` (404.html,
+        // favicon.ico.body, fully-static Pages Router HTML) does not, so the
+        // runtime must be able to read it off disk.
+        for (const [pathname, key] of Object.entries(manifest.staticFiles)) {
+            const servedByS3 = pathname.includes("/_next/static/");
+            expect(staging.has(key)).toBe(!servedByS3);
+        }
+    });
+    it("stages only keys that land inside the deployment root", () => {
+        expect(staging.size).toBeGreaterThan(0);
+        for (const key of staging.keys()) {
+            expect(key).not.toBe("");
+            expect(key.startsWith("/")).toBe(false);
+            expect(key.startsWith("..")).toBe(false);
+            expect(key.startsWith(`${manifest_1.RUNTIME_DIR_NAME}/`)).toBe(false);
+        }
+        // The traced `next` closure is merged into every output, so staging is far
+        // smaller than the sum of the per-output `assets` maps.
+        expect(staging.size).toBeLessThan(ctx.outputs.appPages.length * 100 +
+            ctx.outputs.pages.length * 100 +
+            1000);
+    });
+});
+describe("buildAdapterManifest edge cases", () => {
+    it("throws when `next build` ran from outside the project directory", () => {
+        const ctx = asContext(app_playground_json_1.default);
+        expect(() => (0, build_outputs_1.buildAdapterManifest)(ctx, { buildCwd: "/repo" })).toThrow(/must run from the Next.js project directory/);
+    });
+    it("defaults the build cwd to process.cwd()", () => {
+        // Which is this package's root, never a fixture's `/repo/…` project dir, so
+        // the assertion fires — proving the default is wired and not just the option.
+        expect(() => (0, build_outputs_1.buildAdapterManifest)(asContext(app_playground_json_1.default))).toThrow(/must run from the Next.js project directory/);
+    });
+    it("records the deploymentId, reduced to what a cache key prefix can hold", () => {
+        // `NextjsBuild` suffixes its `buildId` with it: next pins the build ID
+        // itself once `deploymentId` is set.
+        const ctx = asContext(app_playground_json_1.default);
+        const { manifest } = build({
+            ...ctx,
+            config: { ...ctx.config, deploymentId: "v1.2/main" },
+        });
+        expect(manifest.config.deploymentId).toBe("v1-2-main");
+    });
+    it("keys locale variants of one page to the same entrypoint file", () => {
+        const { manifest } = build(asContext(pages_i18n_json_1.default));
+        // i18n fans one page out into one output per locale, plus a
+        // `/_next/data/<buildId>/…json` sibling each. They share `filePath` and
+        // `type`; `id` stays per-pathname (locale-prefixed), so it is not a dedup key.
+        const ssr = [
+            "/ssr",
+            "/en-US/ssr",
+            "/fr/ssr",
+            "/nl-NL/ssr",
+            `/_next/data/${manifest.buildId}/fr/ssr.json`,
+        ];
+        for (const pathname of ssr) {
+            expect(manifest.entrypoints[pathname]).toMatchObject({
+                filePath: manifest.entrypoints["/ssr"].filePath,
+                type: "page",
+            });
+            expect(manifest.entrypoints[pathname].id).toBe(pathname);
+        }
+        expect(manifest.entrypoints["/ssr"].type).toBe("page");
+        expect(manifest.entrypoints["/api/hello"].type).toBe("page-api");
+    });
+    it("carries basePath in pathnames but not in entrypoint ids", () => {
+        // `output.pathname` is basePath-prefixed while `output.id` is not. Dispatch
+        // keys off the pathname, so the prefix has to stay.
+        const { manifest } = build(asContext(app_playground_base_path_json_1.default));
+        expect(manifest.config.basePath).toBe("/prod");
+        expect(manifest.entrypoints["/prod/api/health"]).toBeDefined();
+        expect(manifest.entrypoints["/prod/api/health"].id).toBe("/api/health");
+        expect(manifest.entrypoints["/api/health"]).toBeUndefined();
+    });
+    /**
+     * A Pages Router home page reaches us as `/index`, whichever population it lands
+     * in: `normalizePagePath("/")` is `"/index"`, and the adapter hook uses it for a
+     * fully-static page's `STATIC_FILE` and for an SSG/SSR page's `PAGES` output
+     * alike. Nothing else in the outputs carries `/`, so the mapping under test is
+     * the only thing that makes the home page routable.
+     */
+    function withHomePage(basePath, kind) {
+        const ctx = asContext(pages_i18n_json_1.default);
+        ctx.config.i18n = null;
+        ctx.config.basePath = basePath;
+        ctx.outputs.staticFiles = [];
+        ctx.outputs.prerenders = [];
+        const page = ctx.outputs.pages.find((o) => o.pathname === "/ssr");
+        ctx.outputs.pages =
+            kind === "invocable"
+                ? [{ ...page, id: "/index", pathname: `${basePath}/index` }]
+                : [];
+        if (kind === "static") {
+            ctx.outputs.staticFiles = [
+                {
+                    id: "/",
+                    pathname: `${basePath}/index`,
+                    type: "STATIC_FILE",
+                    filePath: "/repo/pages-i18n/.next/server/pages/index.html",
+                },
+            ];
+        }
+        return build(ctx);
+    }
+    it("routes a fully-static Pages Router home page at `/`, not `/index`", () => {
+        const { manifest } = withHomePage("", "static");
+        const html = "pages-i18n/.next/server/pages/index.html";
+        expect(manifest.staticFiles["/"]).toBe(html);
+        expect(manifest.pathnames).toContain("/");
+        // Kept as well as `/`: next's minimal mode rewrites `/index` to `/` before
+        // matching, so it answers there too.
+        expect(manifest.staticFiles["/index"]).toBe(html);
+    });
+    it("routes an SSG or SSR home page's entrypoint at `/` as well", () => {
+        const { manifest } = withHomePage("", "invocable");
+        expect(manifest.entrypoints["/"]).toEqual(manifest.entrypoints["/index"]);
+        expect(manifest.pathnames).toContain("/");
+        // The output's own `id` is what next reported, and only names the entrypoint
+        // in diagnostics and group ownership - it is not a key into anything.
+        expect(manifest.entrypoints["/"].id).toBe("/index");
+    });
+    it("routes that home page under basePath at the basePath itself", () => {
+        // `/prod`, not `/prod/` — which is how the App Router fixture reports its own
+        // home page.
+        const { manifest } = withHomePage("/prod", "static");
+        expect(Object.keys(manifest.staticFiles)).toEqual(["/prod", "/prod/index"]);
+    });
+    it("leaves an App Router `/index` route at `/index`", () => {
+        // `app/index/page.tsx` is a real route. Only the Pages Router reports its
+        // home page as `/index`.
+        const ctx = asContext(app_playground_json_1.default);
+        const home = ctx.outputs.appPages.find((o) => o.pathname === "/");
+        const indexFile = home.filePath.replace(/page\.js$/, "index/page.js");
+        ctx.outputs.appPages.push({
+            ...home,
+            id: "/index",
+            pathname: "/index",
+            filePath: indexFile,
+        });
+        const { manifest } = build(ctx);
+        expect(manifest.entrypoints["/"].filePath).not.toBe(manifest.entrypoints["/index"].filePath);
+        expect(manifest.entrypoints["/index"].filePath).toMatch(/index\/page\.js$/);
+    });
+    it("records middleware without duplicating its matchers", () => {
+        const { manifest, groups: [{ staging }], } = build(asContext(app_playground_json_1.default));
+        expect(manifest.middleware).not.toBeNull();
+        expect(manifest.middleware.filePath).toMatch(/^[^/]/);
+        expect(staging.has(manifest.middleware.filePath)).toBe(true);
+        expect(manifest.middleware).not.toHaveProperty("matchers");
+        const { manifest: noMiddleware } = build(asContext(pages_i18n_json_1.default));
+        expect(noMiddleware.middleware).toBeNull();
+    });
+    it("maps a Pages Router data-route template to its owning route", () => {
+        // `/_next/data/<buildId>/<locale>/blog/[slug].json` exists only as a
+        // prerender. Without it, the ISR data URLs `next start` serves would 404.
+        const { manifest } = build(asContext(pages_i18n_json_1.default));
+        const dataTemplate = `/_next/data/${manifest.buildId}/fr/blog/[slug].json`;
+        expect(manifest.entrypoints[dataTemplate]).toEqual({
+            id: dataTemplate,
+            filePath: manifest.entrypoints["/fr/blog/[slug]"].filePath,
+            type: "page",
+        });
+        expect(manifest.pathnames).toContain(dataTemplate);
+    });
+    it("registers a static getStaticProps page's data route, which no rule reaches", () => {
+        // `test/e2e/no-page-props`: `/_next/data/<buildId>/gsp.json` 404'd while
+        // `next start` serves it 200, so every client-side navigation into the page
+        // fell back to a full page load. `next build` emits a `dynamicRoutes` rule for
+        // a data route only when the page is dynamic or the app has middleware, so
+        // without middleware a *static* page's data route arrives as a concrete
+        // prerender pathname with nothing to match it. Reproduced on `pages-i18n`,
+        // whose captured prerenders are all dynamic, by renaming one.
+        const ctx = asContext(pages_i18n_json_1.default);
+        const dataRoute = `/_next/data/${ctx.buildId}/en-US/gsp.json`;
+        const concrete = ctx.outputs.prerenders.find((it) => it.pathname.endsWith("hello.json"));
+        concrete.pathname = dataRoute;
+        concrete.id = dataRoute;
+        const { manifest } = build(ctx);
+        expect(manifest.entrypoints[dataRoute]).toEqual({
+            id: dataRoute,
+            filePath: manifest.entrypoints["/en-US/blog/[slug]"].filePath,
+            type: "page",
+        });
+        // And the dynamic page's own concrete data pathname stays out: the ungated
+        // `…/blog/[slug].json` rule already reaches it, and that rule is where the
+        // `nxtPslug` param comes from — resolving the request to itself would drop it.
+        const { manifest: captured } = build(asContext(pages_i18n_json_1.default));
+        expect(captured.entrypoints[`/_next/data/${captured.buildId}/en-US/blog/hello.json`]).toBeUndefined();
+    });
+    it("leaves an App Router fallback template on its own entrypoint", () => {
+        // `/isr/[id]` is a prerender *and* an appPages output. The output wins, so
+        // `id` stays the route's own rather than being rewritten.
+        const { manifest } = build(asContext(app_playground_json_1.default));
+        expect(manifest.entrypoints["/isr/[id]"].id).toBe("/isr/[id]");
+        expect(manifest.entrypoints["/isr/[id].rsc"]).toBeDefined();
+    });
+    it("adds a concrete prerender pathname when only a gated rule matches it", () => {
+        // What a root-params app produces: `app/[locale]/page.tsx` with
+        // `generateStaticParams()` and no `app/layout.tsx`. The params can never be
+        // filled at request time, so `next build` emits the `dynamicRoutes` rule with a
+        // draft-mode `has` and expects the platform to serve `/en` from the prerender.
+        // Measured against `test/e2e/app-dir/parallel-routes-root-param-dynamic-child`,
+        // where every URL of the app 404'd. Reproduced here by gating
+        // `app-playground`'s `/isr/[id]` rules, which no committed capture does.
+        const ctx = asContext(app_playground_json_1.default);
+        for (const route of ctx.routing.dynamicRoutes) {
+            if (route.sourceRegex.includes("isr")) {
+                route.has = [
+                    { type: "cookie", key: "__prerender_bypass", value: "secret" },
+                ];
+            }
+        }
+        const { manifest } = build(ctx);
+        expect(manifest.entrypoints["/isr/1"]).toEqual({
+            id: "/isr/1",
+            filePath: manifest.entrypoints["/isr/[id]"].filePath,
+            type: "app-page",
+        });
+        // The RSC and segment-prefetch variants too: they are the URLs a client-side
+        // navigation asks for, so without them the app renders and never hydrates.
+        expect(manifest.entrypoints["/isr/1.rsc"]).toBeDefined();
+        expect(manifest.entrypoints["/isr/1.segments/isr/$d$id/__PAGE__.segment.rsc"]).toBeDefined();
+        // Unmutated, the same pathnames stay out: the ungated rule already reaches
+        // `/isr/[id]`, which is where the `nxtPid` param comes from.
+        const { manifest: ungated } = build(asContext(app_playground_json_1.default));
+        expect(ungated.entrypoints["/isr/1"]).toBeUndefined();
+        expect(ungated.entrypoints["/isr/1.rsc"]).toBeUndefined();
+        // And a pathname no rule matches at all stays out either way: `resolveRoutes`
+        // never resolves a static route's segment outputs, so listing them is weight.
+        expect(manifest.entrypoints["/index.segments/_tree.segment.rsc"]).toBeUndefined();
+    });
+    it("leaves public/ out of the manifest and the staging plan", async () => {
+        // The container runtime lists `public/` off disk at cold start
+        // (`readPublicFiles`), because only the disk has what a `postbuild` wrote
+        // into it after this hook ran; and the Lambda types never serve it.
+        const repoRoot = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "cdk-nextjs-public-"));
+        // Every path in the fixture, rebased from `/repo` onto a real directory.
+        const ctx = asContext(JSON.parse(JSON.stringify(app_playground_base_path_json_1.default).replaceAll('"/repo', `"${repoRoot}`)));
+        await (0, promises_1.mkdir)((0, node_path_1.join)(ctx.projectDir, "public"), { recursive: true });
+        await (0, promises_1.writeFile)((0, node_path_1.join)(ctx.projectDir, "public", "test.txt"), "hello");
+        const { manifest, groups: [{ staging }], } = build(ctx);
+        expect(Object.values(manifest.staticFiles).filter((key) => key.includes("/public/"))).toEqual([]);
+        expect(manifest.pathnames).not.toContain("/prod/test.txt");
+        expect([...staging.keys()].filter((key) => key.includes("/public/"))).toEqual([]);
+    });
+    it("warns instead of throwing when a template has no owning route", () => {
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
+        const ctx = asContext(pages_i18n_json_1.default);
+        ctx.outputs.prerenders[0].route = "/gone/[slug]";
+        ctx.outputs.prerenders[0].pathname = "/gone/[slug]";
+        const { manifest } = build(ctx);
+        expect(manifest.entrypoints["/gone/[slug]"]).toBeUndefined();
+        expect(warn.mock.calls
+            .map((call) => String(call[0]))
+            .filter((message) => message.includes("will 404"))).toEqual([
+            expect.stringContaining('/gone/[slug] (route: "/gone/[slug]")'),
+        ]);
+    });
+    it("warns once per unsupported route config key", () => {
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
+        build(asContext(pages_i18n_json_1.default));
+        const messages = warn.mock.calls.map((call) => String(call[0]));
+        expect(messages.filter((m) => m.includes("`maxDuration`"))).toHaveLength(1);
+        expect(messages[0]).toContain("ssr");
+        expect(messages[0]).toContain("overrides");
+        expect(messages.some((m) => m.includes("`preferredRegion`"))).toBe(false);
+    });
+    it("throws on an edge-runtime output", () => {
+        const ctx = asContext(app_playground_json_1.default);
+        ctx.outputs.appRoutes[0].runtime = "edge";
+        expect(() => build(ctx)).toThrow(/cannot deploy routes built for the edge runtime/);
+        expect(() => build(ctx)).toThrow(ctx.outputs.appRoutes[0].sourcePage);
+    });
+    it("blames middleware, not `/`, for edge-runtime middleware", () => {
+        const ctx = asContext(app_playground_json_1.default);
+        const middleware = ctx.outputs.middleware;
+        if (!middleware) {
+            throw new Error("fixture has no middleware output");
+        }
+        // What a legacy `middleware.ts` builds to. Its `sourcePage` is `/`, so the
+        // regression guarded here is the message telling an author to edit the home
+        // page.
+        middleware.runtime = "edge";
+        expect(() => build(ctx)).toThrow(/cannot deploy middleware built for the edge runtime/);
+        expect(() => build(ctx)).toThrow(middleware.filePath);
+        // Both ways out: `middleware.ts` only defaults to edge.
+        expect(() => build(ctx)).toThrow(/runtime: "nodejs"/);
+        expect(() => build(ctx)).toThrow(/proxy\.ts/);
+        expect(() => build(ctx)).not.toThrow(/edge-only/);
+        expect(() => build(ctx)).not.toThrow(/cannot deploy routes built for the edge runtime/);
+    });
+    it("throws when two outputs map one key to different content", () => {
+        const ctx = asContext(app_playground_json_1.default);
+        const [first, second] = ctx.outputs.appPages;
+        const key = Object.keys(first.assets)[0];
+        first.assetsHashes[key] = "hash-a";
+        second.assets[key] = first.assets[key];
+        second.assetsHashes[key] = "hash-b";
+        expect(() => build(ctx)).toThrow(/map "[^"]+" to different content/);
+    });
+    it("throws on an asset key outside the deployment root", () => {
+        const ctx = asContext(app_playground_json_1.default);
+        ctx.outputs.appPages[0].assets["../escape.js"] = "/elsewhere/escape.js";
+        expect(() => build(ctx)).toThrow(/outside the deployment root/);
+    });
+    it("throws on an asset key shadowing the reserved runtime directory", () => {
+        const ctx = asContext(app_playground_json_1.default);
+        ctx.outputs.appPages[0].assets[`${manifest_1.RUNTIME_DIR_NAME}/lambda.mjs`] =
+            "/repo/whatever.mjs";
+        expect(() => build(ctx)).toThrow(new RegExp(`"${manifest_1.RUNTIME_DIR_NAME}/" is reserved`));
+    });
+    it("throws when two outputs claim one pathname from different files", () => {
+        const ctx = asContext(app_playground_json_1.default);
+        ctx.outputs.appRoutes[0].pathname = ctx.outputs.appPages[0].pathname;
+        expect(() => build(ctx)).toThrow(/claim the pathname "[^"]+"/);
+    });
+});
+describe("writeBuildOutputs", () => {
+    /**
+     * Builds a throwaway repo on disk so staging can be exercised for real:
+     * fixture sources are `/repo` placeholders and cannot be copied.
+     */
+    /**
+     * A `next` install just real enough for {@link addRuntimeNextClosure}: the
+     * modules `src/runtime/image.ts` requires, one file only the trace reaches, and
+     * a stand-in for next's vendored `@vercel/nft` that reports them. Tracing for
+     * real is next's job, not ours; what is under test is that the closure is
+     * resolved from the project dir and staged under repo-root-relative keys.
+     */
+    async function installFakeNext(repoRoot, options = {}) {
+        // Under pnpm, `next` lives in the virtual store behind a link, and its own
+        // dependencies are links beside it.
+        const storeModules = (0, node_path_1.join)(repoRoot, "node_modules", ".pnpm", "next@1.0.0", "node_modules");
+        const nextRoot = options.pnpm
+            ? (0, node_path_1.join)(storeModules, "next")
+            : (0, node_path_1.join)(repoRoot, "node_modules", "next");
+        if (options.pnpm) {
+            const nextEnv = (0, node_path_1.join)(repoRoot, "node_modules", ".pnpm", "@next+env@1.0.0", "node_modules", "@next", "env");
+            await (0, promises_1.mkdir)(nextEnv, { recursive: true });
+            await (0, promises_1.writeFile)((0, node_path_1.join)(nextEnv, "index.js"), "// @next/env\n");
+            await (0, promises_1.writeFile)((0, node_path_1.join)(nextEnv, "package.json"), JSON.stringify({ name: "@next/env", main: "index.js" }));
+            await (0, promises_1.mkdir)((0, node_path_1.join)(storeModules, "@next"), { recursive: true });
+            await (0, promises_1.symlink)("../../../@next+env@1.0.0/node_modules/@next/env", (0, node_path_1.join)(storeModules, "@next", "env"));
+            await (0, promises_1.mkdir)(nextRoot, { recursive: true });
+            await (0, promises_1.symlink)(".pnpm/next@1.0.0/node_modules/next", (0, node_path_1.join)(repoRoot, "node_modules", "next"));
+        }
+        const files = [
+            "dist/server/config-shared.js",
+            "dist/shared/lib/image-config.js",
+            "dist/server/image-optimizer.js",
+            "dist/server/serve-static.js",
+            "dist/server/lib/router-utils/instrumentation-globals.external.js",
+            // Reached only through the trace, i.e. the reason tracing is needed.
+            "dist/shared/lib/match-remote-pattern.js",
+        ];
+        for (const file of files) {
+            const path = (0, node_path_1.join)(nextRoot, file);
+            await (0, promises_1.mkdir)((0, node_path_1.dirname)(path), { recursive: true });
+            await (0, promises_1.writeFile)(path, `// ${file}\n`);
+        }
+        // No `exports` field: `next/dist/**` is required by path.
+        await (0, promises_1.writeFile)((0, node_path_1.join)(nextRoot, "package.json"), JSON.stringify({ name: "next", version: "0.0.0-test" }));
+        const tracer = (0, node_path_1.join)(nextRoot, "dist", "compiled", "@vercel", "nft");
+        await (0, promises_1.mkdir)(tracer, { recursive: true });
+        await (0, promises_1.writeFile)((0, node_path_1.join)(tracer, "package.json"), JSON.stringify({ name: "@vercel/nft", main: "index.js" }));
+        await (0, promises_1.writeFile)((0, node_path_1.join)(tracer, "index.js"), 
+        // Real nft returns paths relative to `base`, which is the repo root the
+        // adapter passes.
+        `const prefix = ${JSON.stringify((0, node_path_1.relative)(repoRoot, nextRoot).split(node_path_1.sep).join("/"))};\n` +
+            "const { realpathSync } = require('node:fs');\n" +
+            "const { relative } = require('node:path');\n" +
+            "exports.nodeFileTrace = async (entries, { base }) => {\n" +
+            // Like real nft, the entries themselves are in the list.
+            "  const traced = entries\n" +
+            "    .map((e) => relative(realpathSync(base), e))\n" +
+            "    .filter((e) => !e.startsWith('..'));\n" +
+            "  if (traced.some((e) => e.endsWith('image-optimizer.js'))) {\n" +
+            "    traced.push(`${prefix}/dist/shared/lib/match-remote-pattern.js`);\n" +
+            "  }\n" +
+            "  return { fileList: new Set(traced) };\n" +
+            "};\n");
+    }
+    async function makeRepo(options = {}) {
+        const repoRoot = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "cdk-nextjs-staging-"));
+        if (options.withNext || options.pnpmNext) {
+            await installFakeNext(repoRoot, { pnpm: options.pnpmNext });
+        }
+        const projectDir = (0, node_path_1.join)(repoRoot, "app");
+        const distDir = (0, node_path_1.join)(projectDir, ".next");
+        const entry = (0, node_path_1.join)(distDir, "server", "app", "page.js");
+        const dep = (0, node_path_1.join)(projectDir, "node_modules", "dep");
+        const store = (0, node_path_1.join)(repoRoot, "store", "pkg");
+        // pnpm's virtual store: one package reachable only from inside it, and one
+        // that also has a logical path (`app/node_modules/dep`).
+        const virtualStore = (0, node_path_1.join)(repoRoot, "node_modules", ".pnpm");
+        const hidden = (0, node_path_1.join)(virtualStore, "helpers@1.0.0", "node_modules", "@scope", "helpers");
+        const depInStore = (0, node_path_1.join)(virtualStore, "dep@1.0.0", "node_modules", "dep");
+        // The shape that makes a store package reachable from another store
+        // package: a link between two store directories, no files of its own.
+        const hiddenLink = (0, node_path_1.join)(virtualStore, "dep@1.0.0", "node_modules", "@scope", "helpers");
+        await (0, promises_1.mkdir)((0, node_path_1.join)(distDir, "server", "app"), { recursive: true });
+        // Every deployment root needs this, and `loadRuntime` refuses to serve
+        // without it, so the staging plan carries it independently of any output's
+        // traced assets.
+        await (0, promises_1.writeFile)((0, node_path_1.join)(distDir, "required-server-files.json"), "{}\n");
+        await (0, promises_1.mkdir)(dep, { recursive: true });
+        await (0, promises_1.mkdir)(store, { recursive: true });
+        await (0, promises_1.mkdir)(hidden, { recursive: true });
+        await (0, promises_1.mkdir)(depInStore, { recursive: true });
+        await (0, promises_1.writeFile)(entry, "module.exports = {};\n");
+        await (0, promises_1.writeFile)((0, node_path_1.join)(dep, "index.js"), "// dep\n");
+        await (0, promises_1.writeFile)((0, node_path_1.join)(store, "index.js"), "// store\n");
+        await (0, promises_1.writeFile)((0, node_path_1.join)(hidden, "index.js"), "// helpers\n");
+        await (0, promises_1.writeFile)((0, node_path_1.join)(depInStore, "index.js"), "// dep\n");
+        await (0, promises_1.mkdir)((0, node_path_1.dirname)(hiddenLink), { recursive: true });
+        await (0, promises_1.symlink)((0, node_path_1.join)("..", "..", "..", "helpers@1.0.0", "node_modules", "@scope", "helpers"), hiddenLink);
+        await (0, promises_1.writeFile)((0, node_path_1.join)(projectDir, ".env"), "SHARED=1\n");
+        await (0, promises_1.writeFile)((0, node_path_1.join)(projectDir, ".env.production"), "PROD=1\n");
+        // A relative link whose target is itself staged: pnpm's common shape.
+        await (0, promises_1.symlink)("dep", (0, node_path_1.join)(projectDir, "node_modules", "rel-link"));
+        // An absolute link out of the tree: staging must materialize it instead.
+        await (0, promises_1.symlink)(store, (0, node_path_1.join)(projectDir, "node_modules", "abs-link"));
+        const output = {
+            id: "/",
+            pathname: "/",
+            sourcePage: "/page",
+            filePath: entry,
+            runtime: "nodejs",
+            config: {},
+            assets: {
+                "app/node_modules/dep/index.js": (0, node_path_1.join)(dep, "index.js"),
+                "app/node_modules/rel-link": (0, node_path_1.join)(projectDir, "node_modules", "rel-link"),
+                "app/node_modules/abs-link": (0, node_path_1.join)(projectDir, "node_modules", "abs-link"),
+                "node_modules/.pnpm/helpers@1.0.0/node_modules/@scope/helpers/index.js": (0, node_path_1.join)(hidden, "index.js"),
+                "node_modules/.pnpm/dep@1.0.0/node_modules/dep/index.js": (0, node_path_1.join)(depInStore, "index.js"),
+                "node_modules/.pnpm/dep@1.0.0/node_modules/@scope/helpers": hiddenLink,
+            },
+            assetsHashes: {},
+        };
+        const ctx = {
+            repoRoot,
+            projectDir,
+            distDir,
+            buildId: "test-build",
+            nextVersion: "16.3.5",
+            config: {
+                basePath: "",
+                trailingSlash: false,
+                assetPrefix: "",
+                i18n: null,
+            },
+            routing: { dynamicRoutes: [] },
+            outputs: {
+                pages: [],
+                pagesApi: [],
+                appPages: [output],
+                appRoutes: [],
+                prerenders: [],
+                staticFiles: [],
+                middleware: undefined,
+            },
+        };
+        return { ctx, repoRoot };
+    }
+    it("stages the tree, preserves symlinks, and writes the manifest", async () => {
+        const { ctx } = await makeRepo();
+        const result = await write(ctx);
+        expect(soleRoot(result)).toBe((0, node_path_1.join)(ctx.distDir, "cdk-nextjs-adapter", "app"));
+        const staged = (...parts) => (0, node_path_1.join)(soleRoot(result), ...parts);
+        await expect((0, promises_1.readFile)(staged("app", ".next", "server", "app", "page.js"), "utf8")).resolves.toContain("module.exports");
+        await expect((0, promises_1.readFile)(staged("app", "node_modules", "dep", "index.js"), "utf8")).resolves.toContain("dep");
+        // `copyFile` fails outright on a directory symlink, and dereferencing the
+        // pnpm store triples the tree against the 250 MB unzipped Lambda limit.
+        await expect((0, promises_1.lstat)(staged("app", "node_modules", "rel-link")).then((s) => s.isSymbolicLink())).resolves.toBe(true);
+        // Points outside the deployment root, so it would dangle in Lambda.
+        await expect((0, promises_1.lstat)(staged("app", "node_modules", "abs-link")).then((s) => s.isSymbolicLink())).resolves.toBe(false);
+        await expect((0, promises_1.readFile)(staged("app", "node_modules", "abs-link", "index.js"), "utf8")).resolves.toContain("store");
+        // `writeStandaloneDirectory` copies these; `onBuildComplete` has no
+        // equivalent, so dropping `output: "standalone"` drops them silently.
+        await expect((0, promises_1.readFile)(staged("app", ".env"), "utf8")).resolves.toContain("SHARED=1");
+        await expect((0, promises_1.readFile)(staged("app", ".env.production"), "utf8")).resolves.toContain("PROD=1");
+        const written = JSON.parse(await (0, promises_1.readFile)(result.manifestPath, "utf8"));
+        expect(written).toEqual(JSON.parse(JSON.stringify(result.manifest)));
+        expect(written.relativeProjectDir).toBe("app");
+    });
+    it("leaves store-only packages in the store, behind their links", async () => {
+        const { ctx } = await makeRepo();
+        const result = await write(ctx);
+        const staged = (...parts) => (0, node_path_1.join)(soleRoot(result), ...parts);
+        // Node resolves `@scope/helpers` from `dep` through the store link, as it
+        // does in the workspace, so long as nothing dereferences the tree (the
+        // Functions zip keeps links as links). A copy at the root is dead weight.
+        await expect((0, promises_1.lstat)(staged("node_modules", "@scope", "helpers"))).rejects.toThrow(/ENOENT/);
+        await expect((0, promises_1.lstat)(staged("node_modules", ".pnpm", "dep@1.0.0", "node_modules", "@scope", "helpers")).then((s) => s.isSymbolicLink())).resolves.toBe(true);
+        await expect((0, promises_1.readFile)(staged("node_modules", ".pnpm", "dep@1.0.0", "node_modules", "@scope", "helpers", "index.js"), "utf8")).resolves.toContain("helpers");
+    });
+    it("stages the next closure the runtime's image optimizer requires", async () => {
+        // `next build` traces what the *app* reaches, and no app reaches next's
+        // image optimizer, so without this every /_next/image request 500s on a
+        // MODULE_NOT_FOUND that nothing in the build warned about.
+        const { ctx } = await makeRepo({ withNext: true });
+        const result = await write(ctx);
+        const staged = (...parts) => (0, node_path_1.join)(soleRoot(result), ...parts);
+        await expect((0, promises_1.readFile)(staged("node_modules", "next", "dist", "server", "image-optimizer.js"), "utf8")).resolves.toContain("image-optimizer");
+        await expect((0, promises_1.readFile)(staged("node_modules", "next", "dist", "shared", "lib", "match-remote-pattern.js"), "utf8")).resolves.toContain("match-remote-pattern");
+    });
+    it("stages the link next resolves @next/env through under pnpm", async () => {
+        // The trace starts at `@next/env`'s real path and so never records the
+        // link beside `next`; without it every cold start threw "Cannot find
+        // module '@next/env'".
+        const { ctx } = await makeRepo({ pnpmNext: true });
+        const result = await write(ctx);
+        const link = (0, node_path_1.join)(soleRoot(result), "node_modules", ".pnpm", "next@1.0.0", "node_modules", "@next", "env");
+        expect((await (0, promises_1.lstat)(link)).isSymbolicLink()).toBe(true);
+        await expect((0, promises_1.readFile)((0, node_path_1.join)(link, "index.js"), "utf8")).resolves.toContain("@next/env");
+    });
+    it("warns instead of failing when next cannot be resolved for tracing", async () => {
+        const { ctx } = await makeRepo();
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
+        await expect(write(ctx)).resolves.toBeDefined();
+        expect(warn).toHaveBeenCalledWith(expect.stringContaining("/_next/image will fail at runtime"));
+    });
+    it("removes a previous build's tree before staging", async () => {
+        const { ctx } = await makeRepo();
+        const first = await write(ctx);
+        const stale = (0, node_path_1.join)(soleRoot(first), "app", "stale.js");
+        await (0, promises_1.writeFile)(stale, "// removed route\n");
+        await write(ctx);
+        await expect((0, promises_1.lstat)(stale)).rejects.toThrow(/ENOENT/);
+    });
+    describe("with functionGroups", () => {
+        /**
+         * Two routes with one asset each, so "the group's tree holds its own route
+         * and not the other's" is checkable by file. Deliberately not `makeRepo`'s
+         * repo: its single output cannot be split.
+         */
+        async function makeSplittableRepo(options = {}) {
+            const repoRoot = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "cdk-nextjs-groups-"));
+            if (options.withNext) {
+                await installFakeNext(repoRoot);
+            }
+            const projectDir = (0, node_path_1.join)(repoRoot, "app");
+            const distDir = (0, node_path_1.join)(projectDir, ".next");
+            await (0, promises_1.mkdir)((0, node_path_1.join)(distDir, "server", "app"), { recursive: true });
+            await (0, promises_1.writeFile)((0, node_path_1.join)(distDir, "required-server-files.json"), "{}\n");
+            const outputFor = async (name, pathname) => {
+                const entry = (0, node_path_1.join)(distDir, "server", "app", `${name}.js`);
+                const asset = (0, node_path_1.join)(projectDir, "node_modules", name, "index.js");
+                await (0, promises_1.mkdir)((0, node_path_1.dirname)(asset), { recursive: true });
+                await (0, promises_1.writeFile)(entry, `// ${name}\n`);
+                await (0, promises_1.writeFile)(asset, `// ${name} dep\n`);
+                return {
+                    id: pathname,
+                    pathname,
+                    sourcePage: pathname,
+                    filePath: entry,
+                    runtime: "nodejs",
+                    config: {},
+                    assets: { [`app/node_modules/${name}/index.js`]: asset },
+                    assetsHashes: {},
+                };
+            };
+            const ctx = {
+                repoRoot,
+                projectDir,
+                distDir,
+                buildId: "test-build",
+                nextVersion: "16.3.5",
+                config: {
+                    basePath: "",
+                    trailingSlash: false,
+                    assetPrefix: "",
+                    i18n: null,
+                },
+                routing: { dynamicRoutes: [] },
+                outputs: {
+                    pages: options.withPagesSsr
+                        ? await (async () => {
+                            const page = await outputFor("ssr", "/ssr");
+                            // A separate output, with its own id, backed by the same file.
+                            const dataRoute = "/_next/data/test-build/ssr.json";
+                            return [page, { ...page, id: dataRoute, pathname: dataRoute }];
+                        })()
+                        : [],
+                    pagesApi: [],
+                    appPages: [
+                        await outputFor("home", "/"),
+                        ...(options.withNotFound
+                            ? [await outputFor("not-found", "/_not-found")]
+                            : []),
+                    ],
+                    appRoutes: [await outputFor("reports", "/api/reports/[id]")],
+                    prerenders: [],
+                    staticFiles: [],
+                    middleware: undefined,
+                },
+            };
+            return { ctx };
+        }
+        const groups = [{ name: "reports", routes: ["/api/reports/**"] }];
+        it("records the assignment in the manifest every group shares", async () => {
+            const { ctx } = await makeSplittableRepo();
+            const { manifest } = (0, build_outputs_1.buildAdapterManifest)(ctx, {
+                buildCwd: ctx.projectDir,
+                functionGroups: groups,
+            });
+            expect(manifest.groups).toEqual({
+                default: ["/"],
+                reports: ["/api/reports/[id]"],
+            });
+            // What synth compares its own props with, to catch a stale build.
+            expect(manifest.functionGroups).toEqual(groups);
+            // And what it deploys, as the assignment checked it.
+            expect(manifest.behaviors).toEqual([
+                {
+                    group: "reports",
+                    route: "/api/reports/**",
+                    pattern: "api/reports/*",
+                },
+            ]);
+        });
+        it("stages one tree per group, each holding only its own routes", async () => {
+            const { ctx } = await makeSplittableRepo();
+            const result = await (0, build_outputs_1.writeBuildOutputs)(ctx, {
+                buildCwd: ctx.projectDir,
+                functionGroups: groups,
+            });
+            expect(result.stagedGroups.map((group) => group.name).sort()).toEqual([
+                "default",
+                "reports",
+            ]);
+            const pathOf = (name) => {
+                const group = result.stagedGroups.find((it) => it.name === name);
+                if (!group) {
+                    throw new Error(`No staged group "${name}"`);
+                }
+                return group.path;
+            };
+            // Under `groups/<name>/`, so neither can collide with the unsplit layout.
+            expect(pathOf("reports")).toBe((0, node_path_1.join)(ctx.distDir, "cdk-nextjs-adapter", "groups", "reports"));
+            expect(pathOf("default")).toBe((0, node_path_1.join)(ctx.distDir, "cdk-nextjs-adapter", "groups", "default"));
+            const has = (name, ...parts) => (0, promises_1.lstat)((0, node_path_1.join)(pathOf(name), ...parts)).then(() => true, () => false);
+            await expect(has("reports", "app", ".next", "server", "app", "reports.js")).resolves.toBe(true);
+            await expect(has("reports", "app", "node_modules", "reports", "index.js")).resolves.toBe(true);
+            // The point of splitting: the other group's route is absent.
+            await expect(has("reports", "app", ".next", "server", "app", "home.js")).resolves.toBe(false);
+            await expect(has("default", "app", ".next", "server", "app", "home.js")).resolves.toBe(true);
+            await expect(has("default", "app", ".next", "server", "app", "reports.js")).resolves.toBe(false);
+            // The manifest is written once, above the groups; `NextjsBuild` copies it
+            // and the runtime shell into each group's reserved runtime dir afterwards,
+            // so no group's staged tree may contain that directory yet.
+            expect(result.manifestPath).toBe((0, node_path_1.join)(ctx.distDir, "cdk-nextjs-adapter", "manifest.json"));
+            for (const name of ["default", "reports"]) {
+                await expect(has(name, manifest_1.RUNTIME_DIR_NAME)).resolves.toBe(false);
+            }
+            // `required-server-files.json` is not any output's traced asset, so a
+            // group that reaches it only through the outputs it owns does not get it -
+            // and `loadRuntime` probes for it before serving anything, so the whole
+            // root answers "the deployment package is incomplete" without it.
+            for (const name of ["default", "reports"]) {
+                await expect(has(name, "app", ".next", "required-server-files.json")).resolves.toBe(true);
+            }
+        });
+        it("stages the image optimizer into default only, serve-static into every group", async () => {
+            // Only `default` answers `/_next/image`, and the optimizer is what pulls
+            // `sharp` in; prerendered and static results are served with
+            // `serve-static` in whichever group they land.
+            const { ctx } = await makeSplittableRepo({ withNext: true });
+            const result = await (0, build_outputs_1.writeBuildOutputs)(ctx, {
+                buildCwd: ctx.projectDir,
+                functionGroups: groups,
+            });
+            const has = (name, file) => (0, promises_1.lstat)((0, node_path_1.join)(result.stagedGroups.find((it) => it.name === name).path, "node_modules", "next", "dist", file)).then(() => true, () => false);
+            for (const file of [
+                "server/image-optimizer.js",
+                "shared/lib/image-config.js",
+                "server/config-shared.js",
+                "shared/lib/match-remote-pattern.js",
+            ]) {
+                await expect(has("default", file)).resolves.toBe(true);
+                await expect(has("reports", file)).resolves.toBe(false);
+            }
+            for (const name of ["default", "reports"]) {
+                await expect(has(name, "server/serve-static.js")).resolves.toBe(true);
+                await expect(has(name, "server/lib/router-utils/instrumentation-globals.external.js")).resolves.toBe(true);
+            }
+        });
+        it("stages the not-found page into every group, not only its owner", async () => {
+            // The runtime renders a 404 with the manifest's `/_not-found` wherever the
+            // request landed, so `/api/reports/nope` needs it in the reports group.
+            const { ctx } = await makeSplittableRepo({ withNotFound: true });
+            const { groups: staged, manifest } = (0, build_outputs_1.buildAdapterManifest)(ctx, {
+                buildCwd: ctx.projectDir,
+                functionGroups: groups,
+            });
+            expect(manifest.groups?.default).toContain("/_not-found");
+            expect(staged.map((group) => group.name).sort()).toEqual([
+                "default",
+                "reports",
+            ]);
+            for (const group of staged) {
+                expect([...group.staging.keys()]).toContain("app/.next/server/app/not-found.js");
+            }
+        });
+        it("keeps a Pages Router page's data route in the page's group", async () => {
+            const { ctx } = await makeSplittableRepo({ withPagesSsr: true });
+            const { groups: staged, manifest } = (0, build_outputs_1.buildAdapterManifest)(ctx, {
+                buildCwd: ctx.projectDir,
+                functionGroups: [{ name: "ssr", routes: ["/ssr"] }],
+            });
+            expect(manifest.groups?.ssr).toEqual([
+                "/_next/data/test-build/ssr.json",
+                "/ssr",
+            ]);
+            const defaultGroup = staged.find((group) => group.name === "default");
+            // Otherwise the page and its trace ship in the default zip as well.
+            expect([...defaultGroup.staging.keys()]).not.toContain("app/.next/server/app/ssr.js");
+        });
+        it("refuses to split an i18n app, whose routes are locale-prefixed", async () => {
+            const { ctx } = await makeSplittableRepo();
+            const i18nCtx = {
+                ...ctx,
+                config: {
+                    ...ctx.config,
+                    i18n: { locales: ["en"], defaultLocale: "en" },
+                },
+            };
+            expect(() => (0, build_outputs_1.buildAdapterManifest)(i18nCtx, {
+                buildCwd: ctx.projectDir,
+                functionGroups: groups,
+            })).toThrow(/cannot be combined with `i18n`/);
+        });
+        it("throws on a pattern that matches nothing, rather than silently not splitting", async () => {
+            const { ctx } = await makeSplittableRepo();
+            expect(() => (0, build_outputs_1.buildAdapterManifest)(ctx, {
+                buildCwd: ctx.projectDir,
+                functionGroups: [{ name: "typo", routes: ["/api/report/**"] }],
+            })).toThrow(/matches no route in this build/);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"build-outputs.test.js","sourceRoot":"","sources":["../../src/adapter/build-outputs.test.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  lstat,\n  mkdir,\n  mkdtemp,\n  readFile,\n  symlink,\n  writeFile,\n} from \"node:fs/promises\";\nimport { tmpdir } from \"node:os\";\nimport { dirname, join, relative, sep } from \"node:path\";\nimport appPlaygroundBasePath from \"./__fixtures__/app-playground-base-path.json\";\nimport appPlayground from \"./__fixtures__/app-playground.json\";\nimport pagesI18n from \"./__fixtures__/pages-i18n.json\";\nimport {\n  BuildCompleteContext,\n  buildAdapterManifest,\n  writeBuildOutputs,\n} from \"./build-outputs\";\nimport { RUNTIME_DIR_NAME } from \"../runtime/manifest\";\n\n/**\n * The fixtures are real `onBuildComplete` contexts captured by\n * `scripts/capture-adapter-fixture.mjs`, with absolute paths rewritten to a\n * `/repo` placeholder. Regenerate them when `next` is upgraded.\n */\nconst fixtures = {\n  \"app-playground\": appPlayground,\n  \"app-playground-base-path\": appPlaygroundBasePath,\n  \"pages-i18n\": pagesI18n,\n} as const;\n\n/** Fixtures are JSON, so the structural cast is the point of the cast. */\nconst asContext = (fixture: unknown): BuildCompleteContext =>\n  structuredClone(fixture) as BuildCompleteContext;\n\n/**\n * `buildAdapterManifest` requires the build cwd to be the project dir — see\n * `assertBuildCwd`. The fixtures' project dirs are synthetic `/repo/…` paths, so\n * every call supplies it rather than letting it default to `process.cwd()`. The\n * assertion itself is covered separately below.\n */\nconst build = (ctx: BuildCompleteContext) =>\n  buildAdapterManifest(ctx, { buildCwd: ctx.projectDir });\nconst write = (ctx: BuildCompleteContext) =>\n  writeBuildOutputs(ctx, { buildCwd: ctx.projectDir });\n\n/**\n * The one deployment root an unsplit build stages. Asserted rather than indexed\n * so a regression that starts splitting unasked fails here instead of silently\n * checking group 0.\n */\nconst soleRoot = (result: { stagedGroups: Array<{ path: string }> }) => {\n  expect(result.stagedGroups).toHaveLength(1);\n  return result.stagedGroups[0].path;\n};\n\nbeforeEach(() => {\n  // `maxDuration` warnings are expected from the pages-i18n fixture.\n  jest.spyOn(console, \"warn\").mockImplementation(() => {});\n});\n\nafterEach(() => {\n  jest.restoreAllMocks();\n});\n\ndescribe.each(Object.keys(fixtures) as Array<keyof typeof fixtures>)(\n  \"buildAdapterManifest(%s)\",\n  (name) => {\n    const ctx = asContext(fixtures[name]);\n    const {\n      manifest,\n      groups: [{ staging }],\n    } = build(ctx);\n\n    it(\"stamps the manifest version and build identity\", () => {\n      expect(manifest.version).toBe(1);\n      expect(manifest.buildId).toBe(ctx.buildId);\n      expect(manifest.relativeProjectDir).toBe(\n        name.startsWith(\"pages-i18n\") ? \"pages-i18n\" : \"app-playground\",\n      );\n    });\n\n    it(\"copies the config fields the runtime router needs\", () => {\n      expect(manifest.config).toEqual({\n        basePath: ctx.config.basePath ?? \"\",\n        trailingSlash: ctx.config.trailingSlash === true,\n        assetPrefix: ctx.config.assetPrefix ?? \"\",\n        distDir: \".next\",\n        compress: true,\n        generateEtags: true,\n        i18n: ctx.config.i18n ?? null,\n        deploymentId: \"\",\n      });\n    });\n\n    it(\"persists ctx.routing verbatim\", () => {\n      // `@next/routing`'s `resolveRoutes` consumes this whole object; anything we\n      // reshape here is a behavior difference from `next start`.\n      expect(manifest.routing).toEqual(ctx.routing);\n      expect(manifest.routing).toHaveProperty(\"middlewareMatchers\");\n    });\n\n    it(\"maps every invocable output pathname to an entrypoint\", () => {\n      const expected = [\n        ...ctx.outputs.pages,\n        ...ctx.outputs.pagesApi,\n        ...ctx.outputs.appPages,\n        ...ctx.outputs.appRoutes,\n      ].map((o) => o.pathname);\n      // Plus dynamic prerender templates, which `addPrerenderPathnames` maps to\n      // the entrypoint of the route that owns them. None of these fixtures has a\n      // gated dynamic route, so no *concrete* prerender pathname is added - see\n      // the root-params test below.\n      const templates = ctx.outputs.prerenders\n        .filter((o) => o.pathname.includes(\"[\"))\n        .map((o) => o.pathname);\n      expect(Object.keys(manifest.entrypoints).sort()).toEqual(\n        [...new Set([...expected, ...templates])].sort(),\n      );\n      for (const [pathname, entry] of Object.entries(manifest.entrypoints)) {\n        expect(entry.filePath).toMatch(/^[^/]/);\n        expect(entry.filePath).not.toContain(\"\\\\\");\n        expect(staging.has(entry.filePath)).toBe(true);\n        expect(entry.id).toBeTruthy();\n        expect([\"app-page\", \"app-route\", \"page\", \"page-api\"]).toContain(\n          entry.type,\n        );\n        expect(pathname).toBeTruthy();\n      }\n    });\n\n    it(\"lists pathnames as the sorted union of entrypoints and static files\", () => {\n      expect(manifest.pathnames).toEqual([...manifest.pathnames].sort());\n      expect(new Set(manifest.pathnames).size).toBe(manifest.pathnames.length);\n      for (const key of Object.keys(manifest.entrypoints)) {\n        expect(manifest.pathnames).toContain(key);\n      }\n      for (const file of ctx.outputs.staticFiles) {\n        expect(manifest.pathnames).toContain(file.pathname);\n      }\n      // One reported pathname can produce two keys - a `/index` static file is\n      // also served at `/`, see the static-home-page tests below. None of these\n      // fixtures has one, so here the two sets coincide.\n      expect(Object.keys(manifest.staticFiles)).toEqual(\n        [...new Set(ctx.outputs.staticFiles.map((f) => f.pathname))].sort(),\n      );\n    });\n\n    it(\"maps each static file to a repo-root-relative key\", () => {\n      for (const [pathname, key] of Object.entries(manifest.staticFiles)) {\n        const output = ctx.outputs.staticFiles.find(\n          (f) => f.pathname === pathname,\n        )!;\n        expect(key).toBe(output.filePath.replace(\"/repo/\", \"\"));\n        expect(key.startsWith(\"/\")).toBe(false);\n      }\n    });\n\n    it(\"stages the static files nothing in front of the compute serves\", () => {\n      // `<distDir>/static` goes to S3; `<distDir>/server/**` (404.html,\n      // favicon.ico.body, fully-static Pages Router HTML) does not, so the\n      // runtime must be able to read it off disk.\n      for (const [pathname, key] of Object.entries(manifest.staticFiles)) {\n        const servedByS3 = pathname.includes(\"/_next/static/\");\n        expect(staging.has(key)).toBe(!servedByS3);\n      }\n    });\n\n    it(\"stages only keys that land inside the deployment root\", () => {\n      expect(staging.size).toBeGreaterThan(0);\n      for (const key of staging.keys()) {\n        expect(key).not.toBe(\"\");\n        expect(key.startsWith(\"/\")).toBe(false);\n        expect(key.startsWith(\"..\")).toBe(false);\n        expect(key.startsWith(`${RUNTIME_DIR_NAME}/`)).toBe(false);\n      }\n      // The traced `next` closure is merged into every output, so staging is far\n      // smaller than the sum of the per-output `assets` maps.\n      expect(staging.size).toBeLessThan(\n        ctx.outputs.appPages.length * 100 +\n          ctx.outputs.pages.length * 100 +\n          1000,\n      );\n    });\n  },\n);\n\ndescribe(\"buildAdapterManifest edge cases\", () => {\n  it(\"throws when `next build` ran from outside the project directory\", () => {\n    const ctx = asContext(appPlayground);\n    expect(() => buildAdapterManifest(ctx, { buildCwd: \"/repo\" })).toThrow(\n      /must run from the Next.js project directory/,\n    );\n  });\n\n  it(\"defaults the build cwd to process.cwd()\", () => {\n    // Which is this package's root, never a fixture's `/repo/…` project dir, so\n    // the assertion fires — proving the default is wired and not just the option.\n    expect(() => buildAdapterManifest(asContext(appPlayground))).toThrow(\n      /must run from the Next.js project directory/,\n    );\n  });\n\n  it(\"records the deploymentId, reduced to what a cache key prefix can hold\", () => {\n    // `NextjsBuild` suffixes its `buildId` with it: next pins the build ID\n    // itself once `deploymentId` is set.\n    const ctx = asContext(appPlayground);\n    const { manifest } = build({\n      ...ctx,\n      config: { ...ctx.config, deploymentId: \"v1.2/main\" },\n    });\n    expect(manifest.config.deploymentId).toBe(\"v1-2-main\");\n  });\n\n  it(\"keys locale variants of one page to the same entrypoint file\", () => {\n    const { manifest } = build(asContext(pagesI18n));\n    // i18n fans one page out into one output per locale, plus a\n    // `/_next/data/<buildId>/…json` sibling each. They share `filePath` and\n    // `type`; `id` stays per-pathname (locale-prefixed), so it is not a dedup key.\n    const ssr = [\n      \"/ssr\",\n      \"/en-US/ssr\",\n      \"/fr/ssr\",\n      \"/nl-NL/ssr\",\n      `/_next/data/${manifest.buildId}/fr/ssr.json`,\n    ];\n    for (const pathname of ssr) {\n      expect(manifest.entrypoints[pathname]).toMatchObject({\n        filePath: manifest.entrypoints[\"/ssr\"].filePath,\n        type: \"page\",\n      });\n      expect(manifest.entrypoints[pathname].id).toBe(pathname);\n    }\n    expect(manifest.entrypoints[\"/ssr\"].type).toBe(\"page\");\n    expect(manifest.entrypoints[\"/api/hello\"].type).toBe(\"page-api\");\n  });\n\n  it(\"carries basePath in pathnames but not in entrypoint ids\", () => {\n    // `output.pathname` is basePath-prefixed while `output.id` is not. Dispatch\n    // keys off the pathname, so the prefix has to stay.\n    const { manifest } = build(asContext(appPlaygroundBasePath));\n    expect(manifest.config.basePath).toBe(\"/prod\");\n    expect(manifest.entrypoints[\"/prod/api/health\"]).toBeDefined();\n    expect(manifest.entrypoints[\"/prod/api/health\"].id).toBe(\"/api/health\");\n    expect(manifest.entrypoints[\"/api/health\"]).toBeUndefined();\n  });\n\n  /**\n   * A Pages Router home page reaches us as `/index`, whichever population it lands\n   * in: `normalizePagePath(\"/\")` is `\"/index\"`, and the adapter hook uses it for a\n   * fully-static page's `STATIC_FILE` and for an SSG/SSR page's `PAGES` output\n   * alike. Nothing else in the outputs carries `/`, so the mapping under test is\n   * the only thing that makes the home page routable.\n   */\n  function withHomePage(\n    basePath: string,\n    kind: \"static\" | \"invocable\",\n  ): ReturnType<typeof build> {\n    const ctx = asContext(pagesI18n);\n    ctx.config.i18n = null;\n    ctx.config.basePath = basePath;\n    ctx.outputs.staticFiles = [];\n    ctx.outputs.prerenders = [];\n    const page = ctx.outputs.pages.find((o) => o.pathname === \"/ssr\")!;\n    ctx.outputs.pages =\n      kind === \"invocable\"\n        ? [{ ...page, id: \"/index\", pathname: `${basePath}/index` }]\n        : [];\n    if (kind === \"static\") {\n      ctx.outputs.staticFiles = [\n        {\n          id: \"/\",\n          pathname: `${basePath}/index`,\n          type: \"STATIC_FILE\",\n          filePath: \"/repo/pages-i18n/.next/server/pages/index.html\",\n        },\n      ] as typeof ctx.outputs.staticFiles;\n    }\n    return build(ctx);\n  }\n\n  it(\"routes a fully-static Pages Router home page at `/`, not `/index`\", () => {\n    const { manifest } = withHomePage(\"\", \"static\");\n    const html = \"pages-i18n/.next/server/pages/index.html\";\n\n    expect(manifest.staticFiles[\"/\"]).toBe(html);\n    expect(manifest.pathnames).toContain(\"/\");\n    // Kept as well as `/`: next's minimal mode rewrites `/index` to `/` before\n    // matching, so it answers there too.\n    expect(manifest.staticFiles[\"/index\"]).toBe(html);\n  });\n\n  it(\"routes an SSG or SSR home page's entrypoint at `/` as well\", () => {\n    const { manifest } = withHomePage(\"\", \"invocable\");\n    expect(manifest.entrypoints[\"/\"]).toEqual(manifest.entrypoints[\"/index\"]);\n    expect(manifest.pathnames).toContain(\"/\");\n    // The output's own `id` is what next reported, and only names the entrypoint\n    // in diagnostics and group ownership - it is not a key into anything.\n    expect(manifest.entrypoints[\"/\"].id).toBe(\"/index\");\n  });\n\n  it(\"routes that home page under basePath at the basePath itself\", () => {\n    // `/prod`, not `/prod/` — which is how the App Router fixture reports its own\n    // home page.\n    const { manifest } = withHomePage(\"/prod\", \"static\");\n    expect(Object.keys(manifest.staticFiles)).toEqual([\"/prod\", \"/prod/index\"]);\n  });\n\n  it(\"leaves an App Router `/index` route at `/index`\", () => {\n    // `app/index/page.tsx` is a real route. Only the Pages Router reports its\n    // home page as `/index`.\n    const ctx = asContext(appPlayground);\n    const home = ctx.outputs.appPages.find((o) => o.pathname === \"/\")!;\n    const indexFile = home.filePath.replace(/page\\.js$/, \"index/page.js\");\n    ctx.outputs.appPages.push({\n      ...home,\n      id: \"/index\",\n      pathname: \"/index\",\n      filePath: indexFile,\n    });\n    const { manifest } = build(ctx);\n    expect(manifest.entrypoints[\"/\"].filePath).not.toBe(\n      manifest.entrypoints[\"/index\"].filePath,\n    );\n    expect(manifest.entrypoints[\"/index\"].filePath).toMatch(/index\\/page\\.js$/);\n  });\n\n  it(\"records middleware without duplicating its matchers\", () => {\n    const {\n      manifest,\n      groups: [{ staging }],\n    } = build(asContext(appPlayground));\n    expect(manifest.middleware).not.toBeNull();\n    expect(manifest.middleware!.filePath).toMatch(/^[^/]/);\n    expect(staging.has(manifest.middleware!.filePath)).toBe(true);\n    expect(manifest.middleware).not.toHaveProperty(\"matchers\");\n\n    const { manifest: noMiddleware } = build(asContext(pagesI18n));\n    expect(noMiddleware.middleware).toBeNull();\n  });\n\n  it(\"maps a Pages Router data-route template to its owning route\", () => {\n    // `/_next/data/<buildId>/<locale>/blog/[slug].json` exists only as a\n    // prerender. Without it, the ISR data URLs `next start` serves would 404.\n    const { manifest } = build(asContext(pagesI18n));\n    const dataTemplate = `/_next/data/${manifest.buildId}/fr/blog/[slug].json`;\n    expect(manifest.entrypoints[dataTemplate]).toEqual({\n      id: dataTemplate,\n      filePath: manifest.entrypoints[\"/fr/blog/[slug]\"].filePath,\n      type: \"page\",\n    });\n    expect(manifest.pathnames).toContain(dataTemplate);\n  });\n\n  it(\"registers a static getStaticProps page's data route, which no rule reaches\", () => {\n    // `test/e2e/no-page-props`: `/_next/data/<buildId>/gsp.json` 404'd while\n    // `next start` serves it 200, so every client-side navigation into the page\n    // fell back to a full page load. `next build` emits a `dynamicRoutes` rule for\n    // a data route only when the page is dynamic or the app has middleware, so\n    // without middleware a *static* page's data route arrives as a concrete\n    // prerender pathname with nothing to match it. Reproduced on `pages-i18n`,\n    // whose captured prerenders are all dynamic, by renaming one.\n    const ctx = asContext(pagesI18n);\n    const dataRoute = `/_next/data/${ctx.buildId}/en-US/gsp.json`;\n    const concrete = ctx.outputs.prerenders.find((it) =>\n      it.pathname.endsWith(\"hello.json\"),\n    )!;\n    concrete.pathname = dataRoute;\n    concrete.id = dataRoute;\n    const { manifest } = build(ctx);\n    expect(manifest.entrypoints[dataRoute]).toEqual({\n      id: dataRoute,\n      filePath: manifest.entrypoints[\"/en-US/blog/[slug]\"].filePath,\n      type: \"page\",\n    });\n\n    // And the dynamic page's own concrete data pathname stays out: the ungated\n    // `…/blog/[slug].json` rule already reaches it, and that rule is where the\n    // `nxtPslug` param comes from — resolving the request to itself would drop it.\n    const { manifest: captured } = build(asContext(pagesI18n));\n    expect(\n      captured.entrypoints[\n        `/_next/data/${captured.buildId}/en-US/blog/hello.json`\n      ],\n    ).toBeUndefined();\n  });\n\n  it(\"leaves an App Router fallback template on its own entrypoint\", () => {\n    // `/isr/[id]` is a prerender *and* an appPages output. The output wins, so\n    // `id` stays the route's own rather than being rewritten.\n    const { manifest } = build(asContext(appPlayground));\n    expect(manifest.entrypoints[\"/isr/[id]\"].id).toBe(\"/isr/[id]\");\n    expect(manifest.entrypoints[\"/isr/[id].rsc\"]).toBeDefined();\n  });\n\n  it(\"adds a concrete prerender pathname when only a gated rule matches it\", () => {\n    // What a root-params app produces: `app/[locale]/page.tsx` with\n    // `generateStaticParams()` and no `app/layout.tsx`. The params can never be\n    // filled at request time, so `next build` emits the `dynamicRoutes` rule with a\n    // draft-mode `has` and expects the platform to serve `/en` from the prerender.\n    // Measured against `test/e2e/app-dir/parallel-routes-root-param-dynamic-child`,\n    // where every URL of the app 404'd. Reproduced here by gating\n    // `app-playground`'s `/isr/[id]` rules, which no committed capture does.\n    const ctx = asContext(appPlayground);\n    for (const route of ctx.routing.dynamicRoutes) {\n      if (route.sourceRegex.includes(\"isr\")) {\n        route.has = [\n          { type: \"cookie\", key: \"__prerender_bypass\", value: \"secret\" },\n        ];\n      }\n    }\n    const { manifest } = build(ctx);\n    expect(manifest.entrypoints[\"/isr/1\"]).toEqual({\n      id: \"/isr/1\",\n      filePath: manifest.entrypoints[\"/isr/[id]\"].filePath,\n      type: \"app-page\",\n    });\n    // The RSC and segment-prefetch variants too: they are the URLs a client-side\n    // navigation asks for, so without them the app renders and never hydrates.\n    expect(manifest.entrypoints[\"/isr/1.rsc\"]).toBeDefined();\n    expect(\n      manifest.entrypoints[\"/isr/1.segments/isr/$d$id/__PAGE__.segment.rsc\"],\n    ).toBeDefined();\n    // Unmutated, the same pathnames stay out: the ungated rule already reaches\n    // `/isr/[id]`, which is where the `nxtPid` param comes from.\n    const { manifest: ungated } = build(asContext(appPlayground));\n    expect(ungated.entrypoints[\"/isr/1\"]).toBeUndefined();\n    expect(ungated.entrypoints[\"/isr/1.rsc\"]).toBeUndefined();\n    // And a pathname no rule matches at all stays out either way: `resolveRoutes`\n    // never resolves a static route's segment outputs, so listing them is weight.\n    expect(\n      manifest.entrypoints[\"/index.segments/_tree.segment.rsc\"],\n    ).toBeUndefined();\n  });\n\n  it(\"leaves public/ out of the manifest and the staging plan\", async () => {\n    // The container runtime lists `public/` off disk at cold start\n    // (`readPublicFiles`), because only the disk has what a `postbuild` wrote\n    // into it after this hook ran; and the Lambda types never serve it.\n    const repoRoot = await mkdtemp(join(tmpdir(), \"cdk-nextjs-public-\"));\n    // Every path in the fixture, rebased from `/repo` onto a real directory.\n    const ctx = asContext(\n      JSON.parse(\n        JSON.stringify(appPlaygroundBasePath).replaceAll(\n          '\"/repo',\n          `\"${repoRoot}`,\n        ),\n      ),\n    );\n    await mkdir(join(ctx.projectDir, \"public\"), { recursive: true });\n    await writeFile(join(ctx.projectDir, \"public\", \"test.txt\"), \"hello\");\n\n    const {\n      manifest,\n      groups: [{ staging }],\n    } = build(ctx);\n    expect(\n      Object.values(manifest.staticFiles).filter((key) =>\n        key.includes(\"/public/\"),\n      ),\n    ).toEqual([]);\n    expect(manifest.pathnames).not.toContain(\"/prod/test.txt\");\n    expect(\n      [...staging.keys()].filter((key) => key.includes(\"/public/\")),\n    ).toEqual([]);\n  });\n\n  it(\"warns instead of throwing when a template has no owning route\", () => {\n    const warn = jest.spyOn(console, \"warn\").mockImplementation(() => {});\n    const ctx = asContext(pagesI18n);\n    ctx.outputs.prerenders[0].route = \"/gone/[slug]\";\n    ctx.outputs.prerenders[0].pathname = \"/gone/[slug]\";\n    const { manifest } = build(ctx);\n    expect(manifest.entrypoints[\"/gone/[slug]\"]).toBeUndefined();\n    expect(\n      warn.mock.calls\n        .map((call) => String(call[0]))\n        .filter((message) => message.includes(\"will 404\")),\n    ).toEqual([\n      expect.stringContaining('/gone/[slug] (route: \"/gone/[slug]\")'),\n    ]);\n  });\n\n  it(\"warns once per unsupported route config key\", () => {\n    const warn = jest.spyOn(console, \"warn\").mockImplementation(() => {});\n    build(asContext(pagesI18n));\n    const messages = warn.mock.calls.map((call) => String(call[0]));\n    expect(messages.filter((m) => m.includes(\"`maxDuration`\"))).toHaveLength(1);\n    expect(messages[0]).toContain(\"ssr\");\n    expect(messages[0]).toContain(\"overrides\");\n    expect(messages.some((m) => m.includes(\"`preferredRegion`\"))).toBe(false);\n  });\n\n  it(\"throws on an edge-runtime output\", () => {\n    const ctx = asContext(appPlayground);\n    ctx.outputs.appRoutes[0].runtime = \"edge\";\n    expect(() => build(ctx)).toThrow(\n      /cannot deploy routes built for the edge runtime/,\n    );\n    expect(() => build(ctx)).toThrow(ctx.outputs.appRoutes[0].sourcePage);\n  });\n\n  it(\"blames middleware, not `/`, for edge-runtime middleware\", () => {\n    const ctx = asContext(appPlayground);\n    const middleware = ctx.outputs.middleware;\n    if (!middleware) {\n      throw new Error(\"fixture has no middleware output\");\n    }\n    // What a legacy `middleware.ts` builds to. Its `sourcePage` is `/`, so the\n    // regression guarded here is the message telling an author to edit the home\n    // page.\n    middleware.runtime = \"edge\";\n\n    expect(() => build(ctx)).toThrow(\n      /cannot deploy middleware built for the edge runtime/,\n    );\n    expect(() => build(ctx)).toThrow(middleware.filePath);\n    // Both ways out: `middleware.ts` only defaults to edge.\n    expect(() => build(ctx)).toThrow(/runtime: \"nodejs\"/);\n    expect(() => build(ctx)).toThrow(/proxy\\.ts/);\n    expect(() => build(ctx)).not.toThrow(/edge-only/);\n    expect(() => build(ctx)).not.toThrow(\n      /cannot deploy routes built for the edge runtime/,\n    );\n  });\n\n  it(\"throws when two outputs map one key to different content\", () => {\n    const ctx = asContext(appPlayground);\n    const [first, second] = ctx.outputs.appPages;\n    const key = Object.keys(first.assets)[0];\n    first.assetsHashes[key] = \"hash-a\";\n    second.assets[key] = first.assets[key];\n    second.assetsHashes[key] = \"hash-b\";\n    expect(() => build(ctx)).toThrow(/map \"[^\"]+\" to different content/);\n  });\n\n  it(\"throws on an asset key outside the deployment root\", () => {\n    const ctx = asContext(appPlayground);\n    ctx.outputs.appPages[0].assets[\"../escape.js\"] = \"/elsewhere/escape.js\";\n    expect(() => build(ctx)).toThrow(/outside the deployment root/);\n  });\n\n  it(\"throws on an asset key shadowing the reserved runtime directory\", () => {\n    const ctx = asContext(appPlayground);\n    ctx.outputs.appPages[0].assets[`${RUNTIME_DIR_NAME}/lambda.mjs`] =\n      \"/repo/whatever.mjs\";\n    expect(() => build(ctx)).toThrow(\n      new RegExp(`\"${RUNTIME_DIR_NAME}/\" is reserved`),\n    );\n  });\n\n  it(\"throws when two outputs claim one pathname from different files\", () => {\n    const ctx = asContext(appPlayground);\n    ctx.outputs.appRoutes[0].pathname = ctx.outputs.appPages[0].pathname;\n    expect(() => build(ctx)).toThrow(/claim the pathname \"[^\"]+\"/);\n  });\n});\n\ndescribe(\"writeBuildOutputs\", () => {\n  /**\n   * Builds a throwaway repo on disk so staging can be exercised for real:\n   * fixture sources are `/repo` placeholders and cannot be copied.\n   */\n  /**\n   * A `next` install just real enough for {@link addRuntimeNextClosure}: the\n   * modules `src/runtime/image.ts` requires, one file only the trace reaches, and\n   * a stand-in for next's vendored `@vercel/nft` that reports them. Tracing for\n   * real is next's job, not ours; what is under test is that the closure is\n   * resolved from the project dir and staged under repo-root-relative keys.\n   */\n  async function installFakeNext(\n    repoRoot: string,\n    options: { pnpm?: boolean } = {},\n  ) {\n    // Under pnpm, `next` lives in the virtual store behind a link, and its own\n    // dependencies are links beside it.\n    const storeModules = join(\n      repoRoot,\n      \"node_modules\",\n      \".pnpm\",\n      \"next@1.0.0\",\n      \"node_modules\",\n    );\n    const nextRoot = options.pnpm\n      ? join(storeModules, \"next\")\n      : join(repoRoot, \"node_modules\", \"next\");\n    if (options.pnpm) {\n      const nextEnv = join(\n        repoRoot,\n        \"node_modules\",\n        \".pnpm\",\n        \"@next+env@1.0.0\",\n        \"node_modules\",\n        \"@next\",\n        \"env\",\n      );\n      await mkdir(nextEnv, { recursive: true });\n      await writeFile(join(nextEnv, \"index.js\"), \"// @next/env\\n\");\n      await writeFile(\n        join(nextEnv, \"package.json\"),\n        JSON.stringify({ name: \"@next/env\", main: \"index.js\" }),\n      );\n      await mkdir(join(storeModules, \"@next\"), { recursive: true });\n      await symlink(\n        \"../../../@next+env@1.0.0/node_modules/@next/env\",\n        join(storeModules, \"@next\", \"env\"),\n      );\n      await mkdir(nextRoot, { recursive: true });\n      await symlink(\n        \".pnpm/next@1.0.0/node_modules/next\",\n        join(repoRoot, \"node_modules\", \"next\"),\n      );\n    }\n    const files = [\n      \"dist/server/config-shared.js\",\n      \"dist/shared/lib/image-config.js\",\n      \"dist/server/image-optimizer.js\",\n      \"dist/server/serve-static.js\",\n      \"dist/server/lib/router-utils/instrumentation-globals.external.js\",\n      // Reached only through the trace, i.e. the reason tracing is needed.\n      \"dist/shared/lib/match-remote-pattern.js\",\n    ];\n    for (const file of files) {\n      const path = join(nextRoot, file);\n      await mkdir(dirname(path), { recursive: true });\n      await writeFile(path, `// ${file}\\n`);\n    }\n    // No `exports` field: `next/dist/**` is required by path.\n    await writeFile(\n      join(nextRoot, \"package.json\"),\n      JSON.stringify({ name: \"next\", version: \"0.0.0-test\" }),\n    );\n\n    const tracer = join(nextRoot, \"dist\", \"compiled\", \"@vercel\", \"nft\");\n    await mkdir(tracer, { recursive: true });\n    await writeFile(\n      join(tracer, \"package.json\"),\n      JSON.stringify({ name: \"@vercel/nft\", main: \"index.js\" }),\n    );\n    await writeFile(\n      join(tracer, \"index.js\"),\n      // Real nft returns paths relative to `base`, which is the repo root the\n      // adapter passes.\n      `const prefix = ${JSON.stringify(relative(repoRoot, nextRoot).split(sep).join(\"/\"))};\\n` +\n        \"const { realpathSync } = require('node:fs');\\n\" +\n        \"const { relative } = require('node:path');\\n\" +\n        \"exports.nodeFileTrace = async (entries, { base }) => {\\n\" +\n        // Like real nft, the entries themselves are in the list.\n        \"  const traced = entries\\n\" +\n        \"    .map((e) => relative(realpathSync(base), e))\\n\" +\n        \"    .filter((e) => !e.startsWith('..'));\\n\" +\n        \"  if (traced.some((e) => e.endsWith('image-optimizer.js'))) {\\n\" +\n        \"    traced.push(`${prefix}/dist/shared/lib/match-remote-pattern.js`);\\n\" +\n        \"  }\\n\" +\n        \"  return { fileList: new Set(traced) };\\n\" +\n        \"};\\n\",\n    );\n  }\n\n  async function makeRepo(\n    options: { withNext?: boolean; pnpmNext?: boolean } = {},\n  ) {\n    const repoRoot = await mkdtemp(join(tmpdir(), \"cdk-nextjs-staging-\"));\n    if (options.withNext || options.pnpmNext) {\n      await installFakeNext(repoRoot, { pnpm: options.pnpmNext });\n    }\n    const projectDir = join(repoRoot, \"app\");\n    const distDir = join(projectDir, \".next\");\n    const entry = join(distDir, \"server\", \"app\", \"page.js\");\n    const dep = join(projectDir, \"node_modules\", \"dep\");\n    const store = join(repoRoot, \"store\", \"pkg\");\n    // pnpm's virtual store: one package reachable only from inside it, and one\n    // that also has a logical path (`app/node_modules/dep`).\n    const virtualStore = join(repoRoot, \"node_modules\", \".pnpm\");\n    const hidden = join(\n      virtualStore,\n      \"helpers@1.0.0\",\n      \"node_modules\",\n      \"@scope\",\n      \"helpers\",\n    );\n    const depInStore = join(virtualStore, \"dep@1.0.0\", \"node_modules\", \"dep\");\n    // The shape that makes a store package reachable from another store\n    // package: a link between two store directories, no files of its own.\n    const hiddenLink = join(\n      virtualStore,\n      \"dep@1.0.0\",\n      \"node_modules\",\n      \"@scope\",\n      \"helpers\",\n    );\n\n    await mkdir(join(distDir, \"server\", \"app\"), { recursive: true });\n    // Every deployment root needs this, and `loadRuntime` refuses to serve\n    // without it, so the staging plan carries it independently of any output's\n    // traced assets.\n    await writeFile(join(distDir, \"required-server-files.json\"), \"{}\\n\");\n    await mkdir(dep, { recursive: true });\n    await mkdir(store, { recursive: true });\n    await mkdir(hidden, { recursive: true });\n    await mkdir(depInStore, { recursive: true });\n    await writeFile(entry, \"module.exports = {};\\n\");\n    await writeFile(join(dep, \"index.js\"), \"// dep\\n\");\n    await writeFile(join(store, \"index.js\"), \"// store\\n\");\n    await writeFile(join(hidden, \"index.js\"), \"// helpers\\n\");\n    await writeFile(join(depInStore, \"index.js\"), \"// dep\\n\");\n    await mkdir(dirname(hiddenLink), { recursive: true });\n    await symlink(\n      join(\n        \"..\",\n        \"..\",\n        \"..\",\n        \"helpers@1.0.0\",\n        \"node_modules\",\n        \"@scope\",\n        \"helpers\",\n      ),\n      hiddenLink,\n    );\n    await writeFile(join(projectDir, \".env\"), \"SHARED=1\\n\");\n    await writeFile(join(projectDir, \".env.production\"), \"PROD=1\\n\");\n    // A relative link whose target is itself staged: pnpm's common shape.\n    await symlink(\"dep\", join(projectDir, \"node_modules\", \"rel-link\"));\n    // An absolute link out of the tree: staging must materialize it instead.\n    await symlink(store, join(projectDir, \"node_modules\", \"abs-link\"));\n\n    const output = {\n      id: \"/\",\n      pathname: \"/\",\n      sourcePage: \"/page\",\n      filePath: entry,\n      runtime: \"nodejs\",\n      config: {},\n      assets: {\n        \"app/node_modules/dep/index.js\": join(dep, \"index.js\"),\n        \"app/node_modules/rel-link\": join(\n          projectDir,\n          \"node_modules\",\n          \"rel-link\",\n        ),\n        \"app/node_modules/abs-link\": join(\n          projectDir,\n          \"node_modules\",\n          \"abs-link\",\n        ),\n        \"node_modules/.pnpm/helpers@1.0.0/node_modules/@scope/helpers/index.js\":\n          join(hidden, \"index.js\"),\n        \"node_modules/.pnpm/dep@1.0.0/node_modules/dep/index.js\": join(\n          depInStore,\n          \"index.js\",\n        ),\n        \"node_modules/.pnpm/dep@1.0.0/node_modules/@scope/helpers\": hiddenLink,\n      },\n      assetsHashes: {},\n    };\n\n    const ctx = {\n      repoRoot,\n      projectDir,\n      distDir,\n      buildId: \"test-build\",\n      nextVersion: \"16.3.5\",\n      config: {\n        basePath: \"\",\n        trailingSlash: false,\n        assetPrefix: \"\",\n        i18n: null,\n      },\n      routing: { dynamicRoutes: [] },\n      outputs: {\n        pages: [],\n        pagesApi: [],\n        appPages: [output],\n        appRoutes: [],\n        prerenders: [],\n        staticFiles: [],\n        middleware: undefined,\n      },\n    } as unknown as BuildCompleteContext;\n\n    return { ctx, repoRoot };\n  }\n\n  it(\"stages the tree, preserves symlinks, and writes the manifest\", async () => {\n    const { ctx } = await makeRepo();\n    const result = await write(ctx);\n\n    expect(soleRoot(result)).toBe(\n      join(ctx.distDir, \"cdk-nextjs-adapter\", \"app\"),\n    );\n\n    const staged = (...parts: string[]) => join(soleRoot(result), ...parts);\n    await expect(\n      readFile(staged(\"app\", \".next\", \"server\", \"app\", \"page.js\"), \"utf8\"),\n    ).resolves.toContain(\"module.exports\");\n    await expect(\n      readFile(staged(\"app\", \"node_modules\", \"dep\", \"index.js\"), \"utf8\"),\n    ).resolves.toContain(\"dep\");\n\n    // `copyFile` fails outright on a directory symlink, and dereferencing the\n    // pnpm store triples the tree against the 250 MB unzipped Lambda limit.\n    await expect(\n      lstat(staged(\"app\", \"node_modules\", \"rel-link\")).then((s) =>\n        s.isSymbolicLink(),\n      ),\n    ).resolves.toBe(true);\n    // Points outside the deployment root, so it would dangle in Lambda.\n    await expect(\n      lstat(staged(\"app\", \"node_modules\", \"abs-link\")).then((s) =>\n        s.isSymbolicLink(),\n      ),\n    ).resolves.toBe(false);\n    await expect(\n      readFile(staged(\"app\", \"node_modules\", \"abs-link\", \"index.js\"), \"utf8\"),\n    ).resolves.toContain(\"store\");\n\n    // `writeStandaloneDirectory` copies these; `onBuildComplete` has no\n    // equivalent, so dropping `output: \"standalone\"` drops them silently.\n    await expect(readFile(staged(\"app\", \".env\"), \"utf8\")).resolves.toContain(\n      \"SHARED=1\",\n    );\n    await expect(\n      readFile(staged(\"app\", \".env.production\"), \"utf8\"),\n    ).resolves.toContain(\"PROD=1\");\n\n    const written = JSON.parse(await readFile(result.manifestPath, \"utf8\"));\n    expect(written).toEqual(JSON.parse(JSON.stringify(result.manifest)));\n    expect(written.relativeProjectDir).toBe(\"app\");\n  });\n\n  it(\"leaves store-only packages in the store, behind their links\", async () => {\n    const { ctx } = await makeRepo();\n    const result = await write(ctx);\n    const staged = (...parts: string[]) => join(soleRoot(result), ...parts);\n\n    // Node resolves `@scope/helpers` from `dep` through the store link, as it\n    // does in the workspace, so long as nothing dereferences the tree (the\n    // Functions zip keeps links as links). A copy at the root is dead weight.\n    await expect(\n      lstat(staged(\"node_modules\", \"@scope\", \"helpers\")),\n    ).rejects.toThrow(/ENOENT/);\n    await expect(\n      lstat(\n        staged(\n          \"node_modules\",\n          \".pnpm\",\n          \"dep@1.0.0\",\n          \"node_modules\",\n          \"@scope\",\n          \"helpers\",\n        ),\n      ).then((s) => s.isSymbolicLink()),\n    ).resolves.toBe(true);\n    await expect(\n      readFile(\n        staged(\n          \"node_modules\",\n          \".pnpm\",\n          \"dep@1.0.0\",\n          \"node_modules\",\n          \"@scope\",\n          \"helpers\",\n          \"index.js\",\n        ),\n        \"utf8\",\n      ),\n    ).resolves.toContain(\"helpers\");\n  });\n\n  it(\"stages the next closure the runtime's image optimizer requires\", async () => {\n    // `next build` traces what the *app* reaches, and no app reaches next's\n    // image optimizer, so without this every /_next/image request 500s on a\n    // MODULE_NOT_FOUND that nothing in the build warned about.\n    const { ctx } = await makeRepo({ withNext: true });\n    const result = await write(ctx);\n    const staged = (...parts: string[]) => join(soleRoot(result), ...parts);\n\n    await expect(\n      readFile(\n        staged(\"node_modules\", \"next\", \"dist\", \"server\", \"image-optimizer.js\"),\n        \"utf8\",\n      ),\n    ).resolves.toContain(\"image-optimizer\");\n    await expect(\n      readFile(\n        staged(\n          \"node_modules\",\n          \"next\",\n          \"dist\",\n          \"shared\",\n          \"lib\",\n          \"match-remote-pattern.js\",\n        ),\n        \"utf8\",\n      ),\n    ).resolves.toContain(\"match-remote-pattern\");\n  });\n\n  it(\"stages the link next resolves @next/env through under pnpm\", async () => {\n    // The trace starts at `@next/env`'s real path and so never records the\n    // link beside `next`; without it every cold start threw \"Cannot find\n    // module '@next/env'\".\n    const { ctx } = await makeRepo({ pnpmNext: true });\n    const result = await write(ctx);\n    const link = join(\n      soleRoot(result),\n      \"node_modules\",\n      \".pnpm\",\n      \"next@1.0.0\",\n      \"node_modules\",\n      \"@next\",\n      \"env\",\n    );\n    expect((await lstat(link)).isSymbolicLink()).toBe(true);\n    await expect(readFile(join(link, \"index.js\"), \"utf8\")).resolves.toContain(\n      \"@next/env\",\n    );\n  });\n\n  it(\"warns instead of failing when next cannot be resolved for tracing\", async () => {\n    const { ctx } = await makeRepo();\n    const warn = jest.spyOn(console, \"warn\").mockImplementation(() => {});\n    await expect(write(ctx)).resolves.toBeDefined();\n    expect(warn).toHaveBeenCalledWith(\n      expect.stringContaining(\"/_next/image will fail at runtime\"),\n    );\n  });\n\n  it(\"removes a previous build's tree before staging\", async () => {\n    const { ctx } = await makeRepo();\n    const first = await write(ctx);\n    const stale = join(soleRoot(first), \"app\", \"stale.js\");\n    await writeFile(stale, \"// removed route\\n\");\n\n    await write(ctx);\n    await expect(lstat(stale)).rejects.toThrow(/ENOENT/);\n  });\n\n  describe(\"with functionGroups\", () => {\n    /**\n     * Two routes with one asset each, so \"the group's tree holds its own route\n     * and not the other's\" is checkable by file. Deliberately not `makeRepo`'s\n     * repo: its single output cannot be split.\n     */\n    async function makeSplittableRepo(\n      options: {\n        withNotFound?: boolean;\n        withPagesSsr?: boolean;\n        withNext?: boolean;\n      } = {},\n    ) {\n      const repoRoot = await mkdtemp(join(tmpdir(), \"cdk-nextjs-groups-\"));\n      if (options.withNext) {\n        await installFakeNext(repoRoot);\n      }\n      const projectDir = join(repoRoot, \"app\");\n      const distDir = join(projectDir, \".next\");\n      await mkdir(join(distDir, \"server\", \"app\"), { recursive: true });\n      await writeFile(join(distDir, \"required-server-files.json\"), \"{}\\n\");\n\n      const outputFor = async (name: string, pathname: string) => {\n        const entry = join(distDir, \"server\", \"app\", `${name}.js`);\n        const asset = join(projectDir, \"node_modules\", name, \"index.js\");\n        await mkdir(dirname(asset), { recursive: true });\n        await writeFile(entry, `// ${name}\\n`);\n        await writeFile(asset, `// ${name} dep\\n`);\n        return {\n          id: pathname,\n          pathname,\n          sourcePage: pathname,\n          filePath: entry,\n          runtime: \"nodejs\",\n          config: {},\n          assets: { [`app/node_modules/${name}/index.js`]: asset },\n          assetsHashes: {},\n        };\n      };\n\n      const ctx = {\n        repoRoot,\n        projectDir,\n        distDir,\n        buildId: \"test-build\",\n        nextVersion: \"16.3.5\",\n        config: {\n          basePath: \"\",\n          trailingSlash: false,\n          assetPrefix: \"\",\n          i18n: null,\n        },\n        routing: { dynamicRoutes: [] },\n        outputs: {\n          pages: options.withPagesSsr\n            ? await (async () => {\n                const page = await outputFor(\"ssr\", \"/ssr\");\n                // A separate output, with its own id, backed by the same file.\n                const dataRoute = \"/_next/data/test-build/ssr.json\";\n                return [page, { ...page, id: dataRoute, pathname: dataRoute }];\n              })()\n            : [],\n          pagesApi: [],\n          appPages: [\n            await outputFor(\"home\", \"/\"),\n            ...(options.withNotFound\n              ? [await outputFor(\"not-found\", \"/_not-found\")]\n              : []),\n          ],\n          appRoutes: [await outputFor(\"reports\", \"/api/reports/[id]\")],\n          prerenders: [],\n          staticFiles: [],\n          middleware: undefined,\n        },\n      } as unknown as BuildCompleteContext;\n      return { ctx };\n    }\n\n    const groups = [{ name: \"reports\", routes: [\"/api/reports/**\"] }];\n\n    it(\"records the assignment in the manifest every group shares\", async () => {\n      const { ctx } = await makeSplittableRepo();\n      const { manifest } = buildAdapterManifest(ctx, {\n        buildCwd: ctx.projectDir,\n        functionGroups: groups,\n      });\n      expect(manifest.groups).toEqual({\n        default: [\"/\"],\n        reports: [\"/api/reports/[id]\"],\n      });\n      // What synth compares its own props with, to catch a stale build.\n      expect(manifest.functionGroups).toEqual(groups);\n      // And what it deploys, as the assignment checked it.\n      expect(manifest.behaviors).toEqual([\n        {\n          group: \"reports\",\n          route: \"/api/reports/**\",\n          pattern: \"api/reports/*\",\n        },\n      ]);\n    });\n\n    it(\"stages one tree per group, each holding only its own routes\", async () => {\n      const { ctx } = await makeSplittableRepo();\n      const result = await writeBuildOutputs(ctx, {\n        buildCwd: ctx.projectDir,\n        functionGroups: groups,\n      });\n\n      expect(result.stagedGroups.map((group) => group.name).sort()).toEqual([\n        \"default\",\n        \"reports\",\n      ]);\n      const pathOf = (name: string) => {\n        const group = result.stagedGroups.find((it) => it.name === name);\n        if (!group) {\n          throw new Error(`No staged group \"${name}\"`);\n        }\n        return group.path;\n      };\n      // Under `groups/<name>/`, so neither can collide with the unsplit layout.\n      expect(pathOf(\"reports\")).toBe(\n        join(ctx.distDir, \"cdk-nextjs-adapter\", \"groups\", \"reports\"),\n      );\n      expect(pathOf(\"default\")).toBe(\n        join(ctx.distDir, \"cdk-nextjs-adapter\", \"groups\", \"default\"),\n      );\n\n      const has = (name: string, ...parts: string[]) =>\n        lstat(join(pathOf(name), ...parts)).then(\n          () => true,\n          () => false,\n        );\n      await expect(\n        has(\"reports\", \"app\", \".next\", \"server\", \"app\", \"reports.js\"),\n      ).resolves.toBe(true);\n      await expect(\n        has(\"reports\", \"app\", \"node_modules\", \"reports\", \"index.js\"),\n      ).resolves.toBe(true);\n      // The point of splitting: the other group's route is absent.\n      await expect(\n        has(\"reports\", \"app\", \".next\", \"server\", \"app\", \"home.js\"),\n      ).resolves.toBe(false);\n      await expect(\n        has(\"default\", \"app\", \".next\", \"server\", \"app\", \"home.js\"),\n      ).resolves.toBe(true);\n      await expect(\n        has(\"default\", \"app\", \".next\", \"server\", \"app\", \"reports.js\"),\n      ).resolves.toBe(false);\n      // The manifest is written once, above the groups; `NextjsBuild` copies it\n      // and the runtime shell into each group's reserved runtime dir afterwards,\n      // so no group's staged tree may contain that directory yet.\n      expect(result.manifestPath).toBe(\n        join(ctx.distDir, \"cdk-nextjs-adapter\", \"manifest.json\"),\n      );\n      for (const name of [\"default\", \"reports\"]) {\n        await expect(has(name, RUNTIME_DIR_NAME)).resolves.toBe(false);\n      }\n      // `required-server-files.json` is not any output's traced asset, so a\n      // group that reaches it only through the outputs it owns does not get it -\n      // and `loadRuntime` probes for it before serving anything, so the whole\n      // root answers \"the deployment package is incomplete\" without it.\n      for (const name of [\"default\", \"reports\"]) {\n        await expect(\n          has(name, \"app\", \".next\", \"required-server-files.json\"),\n        ).resolves.toBe(true);\n      }\n    });\n\n    it(\"stages the image optimizer into default only, serve-static into every group\", async () => {\n      // Only `default` answers `/_next/image`, and the optimizer is what pulls\n      // `sharp` in; prerendered and static results are served with\n      // `serve-static` in whichever group they land.\n      const { ctx } = await makeSplittableRepo({ withNext: true });\n      const result = await writeBuildOutputs(ctx, {\n        buildCwd: ctx.projectDir,\n        functionGroups: groups,\n      });\n      const has = (name: string, file: string) =>\n        lstat(\n          join(\n            result.stagedGroups.find((it) => it.name === name)!.path,\n            \"node_modules\",\n            \"next\",\n            \"dist\",\n            file,\n          ),\n        ).then(\n          () => true,\n          () => false,\n        );\n      for (const file of [\n        \"server/image-optimizer.js\",\n        \"shared/lib/image-config.js\",\n        \"server/config-shared.js\",\n        \"shared/lib/match-remote-pattern.js\",\n      ]) {\n        await expect(has(\"default\", file)).resolves.toBe(true);\n        await expect(has(\"reports\", file)).resolves.toBe(false);\n      }\n      for (const name of [\"default\", \"reports\"]) {\n        await expect(has(name, \"server/serve-static.js\")).resolves.toBe(true);\n        await expect(\n          has(\n            name,\n            \"server/lib/router-utils/instrumentation-globals.external.js\",\n          ),\n        ).resolves.toBe(true);\n      }\n    });\n\n    it(\"stages the not-found page into every group, not only its owner\", async () => {\n      // The runtime renders a 404 with the manifest's `/_not-found` wherever the\n      // request landed, so `/api/reports/nope` needs it in the reports group.\n      const { ctx } = await makeSplittableRepo({ withNotFound: true });\n      const { groups: staged, manifest } = buildAdapterManifest(ctx, {\n        buildCwd: ctx.projectDir,\n        functionGroups: groups,\n      });\n      expect(manifest.groups?.default).toContain(\"/_not-found\");\n      expect(staged.map((group) => group.name).sort()).toEqual([\n        \"default\",\n        \"reports\",\n      ]);\n      for (const group of staged) {\n        expect([...group.staging.keys()]).toContain(\n          \"app/.next/server/app/not-found.js\",\n        );\n      }\n    });\n\n    it(\"keeps a Pages Router page's data route in the page's group\", async () => {\n      const { ctx } = await makeSplittableRepo({ withPagesSsr: true });\n      const { groups: staged, manifest } = buildAdapterManifest(ctx, {\n        buildCwd: ctx.projectDir,\n        functionGroups: [{ name: \"ssr\", routes: [\"/ssr\"] }],\n      });\n      expect(manifest.groups?.ssr).toEqual([\n        \"/_next/data/test-build/ssr.json\",\n        \"/ssr\",\n      ]);\n      const defaultGroup = staged.find((group) => group.name === \"default\")!;\n      // Otherwise the page and its trace ship in the default zip as well.\n      expect([...defaultGroup.staging.keys()]).not.toContain(\n        \"app/.next/server/app/ssr.js\",\n      );\n    });\n\n    it(\"refuses to split an i18n app, whose routes are locale-prefixed\", async () => {\n      const { ctx } = await makeSplittableRepo();\n      const i18nCtx = {\n        ...ctx,\n        config: {\n          ...ctx.config,\n          i18n: { locales: [\"en\"], defaultLocale: \"en\" },\n        },\n      } as unknown as BuildCompleteContext;\n      expect(() =>\n        buildAdapterManifest(i18nCtx, {\n          buildCwd: ctx.projectDir,\n          functionGroups: groups,\n        }),\n      ).toThrow(/cannot be combined with `i18n`/);\n    });\n\n    it(\"throws on a pattern that matches nothing, rather than silently not splitting\", async () => {\n      const { ctx } = await makeSplittableRepo();\n      expect(() =>\n        buildAdapterManifest(ctx, {\n          buildCwd: ctx.projectDir,\n          functionGroups: [{ name: \"typo\", routes: [\"/api/report/**\"] }],\n        }),\n      ).toThrow(/matches no route in this build/);\n    });\n  });\n});\n"]}