cdk-nextjs 0.6.2 → 0.7.1

package/lib/runtime/core.test.js

@@ -0,0 +1,1686 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable import/no-extraneous-dependencies */
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_stream_1 = require("node:stream");
+const node_zlib_1 = require("node:zlib");
+const client_s3_1 = require("@aws-sdk/client-s3");
+const core_1 = require("./core");
+const build_outputs_1 = require("../adapter/build-outputs");
+const request_1 = require("./http/request");
+const manifest_1 = require("./manifest");
+const app_playground_json_1 = __importDefault(require("../adapter/__fixtures__/app-playground.json"));
+/**
+ * Every entrypoint in the staged tree is this module. It reports back what the
+ * runtime handed it — the rewritten `req.url`, the `requestMeta` fields Next.js
+ * reads, the cwd — which is the whole contract between the runtime and a real
+ * built entrypoint, and it is otherwise only observable by running Next.js.
+ */
+const ENTRYPOINT_STUB = `
+const { writeFileSync } = require("node:fs");
+exports.handler = async (req, res, ctx) => {
+  const url = new URL(req.url, "https://stub.test");
+  if (url.searchParams.has("boomEverywhere")) {
+    throw new Error("the error page exploded too");
+  }
+  // Same recursion guard as \`render404\` below: the error page is rendered for
+  // the URL that was asked for, so an unguarded throw would repeat forever.
+  if (url.searchParams.has("boom") && !__filename.includes("_error")) {
+    // A render that described its body before it threw.
+    res.setHeader("Content-Length", "1234");
+    res.setHeader("ETag", '"stale"');
+    // What \`getServerSideProps\` (or a \`headers()\` rule) can leave behind.
+    res.setHeader("Cache-Control", "s-maxage=60");
+    throw new Error("route exploded");
+  }
+  // What both routers do for \`notFound()\` they cannot render themselves. Only
+  // the route that gave up does it: the runtime renders the 404 against the
+  // *same* URL, so the not-found module reaching here again would recurse.
+  if (url.searchParams.has("render404") && !__filename.includes("_not-found")) {
+    await ctx.requestMeta.render404();
+    return;
+  }
+  // \`res.revalidate(target)\` from a Pages API route, spelled out: the runtime
+  // supplies \`requestMeta.revalidate\`, and what comes back is either nothing or
+  // the \`Invalid response <status>\` this reports.
+  if (url.searchParams.has("revalidate")) {
+    let error = null;
+    try {
+      await ctx.requestMeta.revalidate({
+        urlPath: url.searchParams.get("revalidate"),
+        headers: { "x-prerender-revalidate": "preview-id" },
+        opts: { unstable_onlyGenerated: url.searchParams.has("onlyGenerated") },
+      });
+    } catch (err) {
+      error = err.message;
+    }
+    res.end(JSON.stringify({ revalidated: error === null, error }));
+    return;
+  }
+  // Lets a test see the request a revalidation rendered, whose response the
+  // runtime discards.
+  if (url.searchParams.has("recordOrigin")) {
+    writeFileSync(process.env.CDK_NEXTJS_TEST_MARKER, ctx.requestMeta.initURL);
+  }
+  // Lets a revalidation target answer something other than 200.
+  if (url.searchParams.has("status")) {
+    res.statusCode = Number(url.searchParams.get("status"));
+  }
+  // What a prerendered \`/_not-found\` does: it sends the Cache-Control of its
+  // own cache entry, a year for one that never revalidates — but only when the
+  // response has none yet, as \`sendRenderResult\` and \`pages-handler.js\` do.
+  if (url.searchParams.has("cacheControl") && !res.getHeader("Cache-Control")) {
+    res.setHeader("Cache-Control", url.searchParams.get("cacheControl"));
+  }
+  // A route that reads its request body, reporting what arrived.
+  if (url.searchParams.has("readBody")) {
+    let length = 0;
+    for await (const chunk of req) length += chunk.length;
+    res.end(JSON.stringify({ bodyLength: length }));
+    return;
+  }
+  // A Pages API route that returns before it is done writing: what
+  // \`stream.pipe(res)\` and a callback-style \`res.json()\` both look like.
+  if (url.searchParams.has("endLater")) {
+    res.setHeader("Content-Type", "text/plain; charset=utf-8");
+    res.write("first,");
+    setTimeout(() => res.end("second"), 10);
+    return;
+  }
+  // What Next's \`AfterContext\` does: work registered with \`waitUntil\` after
+  // the response, from inside work that was itself registered with it.
+  if (url.searchParams.has("lateWaitUntil")) {
+    ctx.waitUntil(
+      new Promise((resolve) =>
+        setTimeout(() => {
+          ctx.waitUntil(
+            new Promise((resolveLate) =>
+              setTimeout(() => {
+                writeFileSync(process.env.CDK_NEXTJS_TEST_MARKER, "late");
+                resolveLate();
+              }, 10),
+            ),
+          );
+          resolve();
+        }, 10),
+      ),
+    );
+  }
+  if (url.searchParams.has("waitUntil")) {
+    ctx.waitUntil(
+      new Promise((resolve) =>
+        setTimeout(() => {
+          writeFileSync(process.env.CDK_NEXTJS_TEST_MARKER, "done");
+          resolve();
+        }, 10),
+      ),
+    );
+  }
+  res.setHeader("Content-Type", "text/html; charset=utf-8");
+  res.end(
+    JSON.stringify({
+      file: __filename,
+      url: req.url,
+      initURL: ctx.requestMeta && ctx.requestMeta.initURL,
+      hostname: ctx.requestMeta && ctx.requestMeta.hostname,
+      query: ctx.requestMeta && ctx.requestMeta.query,
+      params: (ctx.requestMeta && ctx.requestMeta.params) || null,
+      hasRender404: Boolean(ctx.requestMeta && ctx.requestMeta.render404),
+      waitUntil: typeof ctx.waitUntil,
+      cwd: process.cwd(),
+      header: req.headers["x-from-middleware"] || null,
+      nextResume: req.headers["next-resume"] || null,
+      matchedPath: req.headers["x-matched-path"] || null,
+      cookie: req.headers.cookie || null,
+    }),
+  );
+};
+`;
+/**
+ * `NextResponse.next({ request: { headers } })`, spelled out in the wire protocol
+ * Next.js uses: `x-middleware-override-headers` lists *every* request header the
+ * route should see — dropping one here is how a real app loses `accept-encoding`.
+ */
+const MIDDLEWARE_STUB = `
+exports.handler = async (request) => {
+  const headers = new Headers({ "x-middleware-next": "1" });
+  const names = [];
+  request.headers.forEach((value, name) => {
+    names.push(name);
+    headers.set("x-middleware-request-" + name, value);
+  });
+  names.push("x-from-middleware");
+  headers.set("x-middleware-request-x-from-middleware", "yes");
+  headers.set("x-middleware-override-headers", names.join(","));
+  return new Response(null, { headers });
+};
+`;
+class CollectingSink {
+    padEmptyBody;
+    head;
+    chunks = [];
+    constructor(padEmptyBody = false) {
+        this.padEmptyBody = padEmptyBody;
+    }
+    begin(head) {
+        this.head = head;
+        const chunks = this.chunks;
+        return new node_stream_1.Writable({
+            write(chunk, _encoding, callback) {
+                chunks.push(Buffer.from(chunk));
+                callback();
+            },
+        });
+    }
+    get body() {
+        return Buffer.concat(this.chunks);
+    }
+}
+function write(path, contents) {
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(path), { recursive: true });
+    (0, node_fs_1.writeFileSync)(path, contents);
+}
+const FAVICON = Buffer.from("00000100-fake-icon", "utf-8");
+const NOT_FOUND_HTML = "<html><body>prerendered 404</body></html>";
+const ERROR_HTML = "<html><body>prerendered 500</body></html>";
+/**
+ * What a container image copies into `public/`. Names `send` and the exact
+ * match in `@next/routing` each got wrong: a `%` that is not an escape, one that
+ * looks like one next to the file it decodes to, and an `@` a browser leaves
+ * alone.
+ */
+const PUBLIC_FILES = {
+    "test.txt": "hello from public",
+    "100%.png": "a literal percent",
+    "a%20b.txt": "the file named with a percent",
+    "a b.txt": "the file named with a space",
+    "images/logo@2x.png": "at sign",
+};
+/**
+ * Materializes the tree a deployment stages: the manifest under
+ * `cdk-nextjs-runtime/`, a stub at every entrypoint `filePath`, the static files
+ * the manifest points at, and the `required-server-files.json` `loadRuntime`
+ * probes for.
+ */
+function stageDeployment(middlewareSource = MIDDLEWARE_STUB, transformManifest = (it) => it) {
+    // The fixture is a real captured context, as JSON: the structural cast is the
+    // point of the cast (see `build-outputs.test.ts`).
+    const ctx = structuredClone(app_playground_json_1.default);
+    const manifest = transformManifest((0, build_outputs_1.buildAdapterManifest)(ctx, { buildCwd: ctx.projectDir }).manifest);
+    // Realpath because `loadRuntime` chdirs, and macOS's /var is a symlink to
+    // /private/var: the cwd the entrypoints report would not match otherwise.
+    const root = (0, node_fs_1.realpathSync)((0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "cdk-nextjs-core-")));
+    write((0, manifest_1.deployedManifestPath)(root), JSON.stringify(manifest));
+    write((0, node_path_1.join)(root, manifest.relativeProjectDir, ".next/required-server-files.json"), JSON.stringify({ version: 1, config: {} }));
+    // A deployed tree carries the `next` closure `next build` traced, under the
+    // *project* dir rather than next to the runtime shell — which is the whole
+    // reason `next-modules.ts` exists. Linking this repo's own `node_modules` in
+    // reproduces that, so `serveStatic` here resolves by the same walk it does in
+    // Lambda instead of the test quietly exercising a different lookup.
+    (0, node_fs_1.symlinkSync)((0, node_path_1.join)(__dirname, "../../node_modules"), (0, node_path_1.join)(root, manifest.relativeProjectDir, "node_modules"));
+    for (const entrypoint of Object.values(manifest.entrypoints)) {
+        write((0, node_path_1.join)(root, entrypoint.filePath), ENTRYPOINT_STUB);
+    }
+    write((0, node_path_1.join)(root, manifest.middleware.filePath), middlewareSource);
+    write((0, node_path_1.join)(root, manifest.staticFiles["/favicon.ico"]), FAVICON);
+    // Absent in the deployments the Pages 404 and error-page ladder tests stage.
+    if (manifest.staticFiles["/404"]) {
+        write((0, node_path_1.join)(root, manifest.staticFiles["/404"]), NOT_FOUND_HTML);
+    }
+    if (manifest.staticFiles["/500"]) {
+        write((0, node_path_1.join)(root, manifest.staticFiles["/500"]), ERROR_HTML);
+    }
+    for (const [file, contents] of Object.entries(PUBLIC_FILES)) {
+        write((0, node_path_1.join)(root, manifest.relativeProjectDir, "public", file), contents);
+    }
+    // Async on purpose: `loadRuntime` has to await `register()`, not just call it.
+    write((0, node_path_1.join)(root, manifest.relativeProjectDir, ".next/server/instrumentation.js"), "exports.register = () => new Promise((resolve) => setTimeout(() => {" +
+        " process.env.CDK_NEXTJS_TEST_REGISTERED = 'yes'; resolve(); }, 10));\n");
+    // `.env` rather than `.env.production`: `@next/env` picks the mode from
+    // NODE_ENV, which jest sets to "test".
+    write((0, node_path_1.join)(root, manifest.relativeProjectDir, ".env"), "CDK_NEXTJS_TEST_FROM_ENV_FILE=from-file\nCDK_NEXTJS_TEST_SET_BY_LAMBDA=from-file\n");
+    return root;
+}
+let root;
+let runtime;
+const originalCwd = process.cwd();
+beforeAll(async () => {
+    jest.spyOn(console, "warn").mockImplementation(() => { });
+    process.env.CDK_NEXTJS_TEST_SET_BY_LAMBDA = "from-lambda";
+    root = stageDeployment();
+    // `loadRuntime` chdirs, which is the point of it.
+    runtime = await (0, core_1.loadRuntime)(root);
+});
+afterAll(() => {
+    process.chdir(originalCwd);
+    jest.restoreAllMocks();
+});
+/** One request through the real `handle`, with the response collected. */
+async function send(request, padEmptyBody = false) {
+    const sink = new CollectingSink(padEmptyBody);
+    await runtime.handle({
+        method: "GET",
+        headers: { host: "shop.example.test" },
+        ...request,
+    }, sink);
+    return sink;
+}
+/** The JSON an entrypoint stub answers with. */
+function stubBody(sink) {
+    const encoding = sink.head?.headers["content-encoding"];
+    const body = encoding === "gzip" ? (0, node_zlib_1.gunzipSync)(sink.body) : sink.body;
+    return JSON.parse(body.toString("utf-8"));
+}
+describe("loadRuntime", () => {
+    it("chdirs to the staged project dir, because entrypoints resolve against cwd", () => {
+        expect(process.cwd()).toBe((0, node_path_1.join)(root, "app-playground"));
+    });
+    it("loads the staged env files the way next start does, without overriding the function's environment", () => {
+        expect(process.env.CDK_NEXTJS_TEST_FROM_ENV_FILE).toBe("from-file");
+        expect(process.env.CDK_NEXTJS_TEST_SET_BY_LAMBDA).toBe("from-lambda");
+    });
+    it("awaits instrumentation register() before any entrypoint or middleware loads, as next start does", () => {
+        // Module-scope code in middleware and entrypoints reads what `register()`
+        // sets (#279), and nothing is loaded until `loadRuntime` has returned.
+        expect(process.env.CDK_NEXTJS_TEST_REGISTERED).toBe("yes");
+    });
+    it("explains a deployment package with no manifest", async () => {
+        const empty = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "cdk-nextjs-empty-"));
+        await expect((0, core_1.loadRuntime)(empty)).rejects.toThrow(/Could not read the cdk-nextjs adapter manifest/);
+    });
+    it("explains a deployment package missing the staged project", async () => {
+        const partial = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "cdk-nextjs-partial-"));
+        write((0, manifest_1.deployedManifestPath)(partial), (0, node_fs_1.readFileSync)((0, manifest_1.deployedManifestPath)(root), "utf-8"));
+        await expect((0, core_1.loadRuntime)(partial)).rejects.toThrow(/does not contain the staged Next.js project/);
+    });
+});
+describe("NextjsRuntime.handle", () => {
+    it("invokes the matched entrypoint with the requestMeta Next.js reads", async () => {
+        const sink = await send({ url: "/" });
+        expect(sink.head?.statusCode).toBe(200);
+        const body = stubBody(sink);
+        expect(body.file).toBe((0, node_path_1.join)(root, "app-playground/.next/server/app/page.js"));
+        expect(body.url).toBe("/");
+        // Without `initURL`, `RouteModule.prepare` falls back to `http://localhost`.
+        expect(body.initURL).toBe("https://shop.example.test/");
+        expect(body.hostname).toBe("shop.example.test");
+        expect(body.hasRender404).toBe(true);
+        expect(body.waitUntil).toBe("function");
+        expect(body.cwd).toBe((0, node_path_1.join)(root, "app-playground"));
+    });
+    it("trusts x-forwarded-host over the host CloudFront rewrote, when the shell says to", async () => {
+        const sink = await send({
+            url: "/",
+            headers: {
+                host: "origin.cloudfront.internal",
+                "x-forwarded-host": "www.example.test",
+            },
+            trustForwardedHost: true,
+        });
+        expect(stubBody(sink).initURL).toBe("https://www.example.test/");
+    });
+    // Only the CloudFront function in front of *function* compute overwrites this
+    // header, so on Containers and the Regional types it arrives from the client:
+    // honoring it let `X-Forwarded-Host: evil.example` point every absolute URL
+    // the app built, a password-reset link say, at evil.example.
+    it("ignores x-forwarded-host unless the shell trusts it, like next start", async () => {
+        const sink = await send({
+            url: "/",
+            headers: {
+                host: "shop.example.test",
+                "x-forwarded-host": "evil.example",
+            },
+        });
+        expect(stubBody(sink).initURL).toBe("https://shop.example.test/");
+        expect(stubBody(sink).hostname).toBe("shop.example.test");
+    });
+    // A value that cannot be a URL authority made `new URL` throw, and on the
+    // Lambda shells — whose handlers wrap nothing — that is an invocation error and
+    // a 502 rather than a response.
+    it.each([
+        ["a space", "exa mple.test"],
+        ["a scheme", "https://www.example.test"],
+        ["a path", "www.example.test/evil"],
+        ["credentials", "user@www.example.test"],
+        ["nothing", ""],
+    ])("ignores an x-forwarded-host containing %s and falls back to host", async (_label, forwarded) => {
+        const sink = await send({
+            url: "/",
+            headers: {
+                host: "shop.example.test",
+                "x-forwarded-host": forwarded,
+            },
+            trustForwardedHost: true,
+        });
+        expect(sink.head?.statusCode).toBe(200);
+        expect(stubBody(sink).initURL).toBe("https://shop.example.test/");
+    });
+    // Multiple proxies each append, and only the first value is this hop's.
+    it("takes the first value of a comma-joined x-forwarded-host", async () => {
+        const sink = await send({
+            url: "/",
+            headers: {
+                host: "origin.cloudfront.internal",
+                "x-forwarded-host": "www.example.test, inner.example.test",
+            },
+            trustForwardedHost: true,
+        });
+        expect(stubBody(sink).initURL).toBe("https://www.example.test/");
+    });
+    it("ignores an x-forwarded-proto that is not http or https", async () => {
+        const sink = await send({
+            url: "/",
+            headers: {
+                host: "shop.example.test",
+                "x-forwarded-proto": "javascript",
+            },
+        });
+        expect(stubBody(sink).initURL).toBe("https://shop.example.test/");
+    });
+    it("hands a dynamic route its params as nxtP query values", async () => {
+        const sink = await send({ url: "/isr/42" });
+        const body = stubBody(sink);
+        expect(body.file).toBe((0, node_path_1.join)(root, "app-playground/.next/server/app/isr/[id]/page.js"));
+        // The documented deployed-proxy contract: `prepare()` recovers `params`
+        // from these, which is why `requestMeta.params` is left unset.
+        expect(body.url).toBe("/isr/42?nxtPid=42");
+        expect(body.query).toEqual({ nxtPid: "42" });
+        expect(body.params).toBeNull();
+    });
+    it("hands over a capture with an encoded delimiter as requestMeta.params", async () => {
+        // The one exception to the contract above, because two decodes and a split
+        // would turn this into three params and make `normalizePagePath` throw; see
+        // `outOfBandRouteParams`. The `nxtP` value has to *leave* the query — and
+        // therefore the URL — or `prepare` prefers it and the split is back.
+        const sink = await send({ url: "/isr/a%2Fb" });
+        const body = stubBody(sink);
+        expect(body.url).toBe("/isr/a%2Fb");
+        expect(body.query).toEqual({});
+        expect(body.params).toEqual({ id: "a/b" });
+    });
+    it("runs middleware and applies the request headers it overrode", async () => {
+        const sink = await send({ url: "/" });
+        expect(stubBody(sink).header).toBe("yes");
+    });
+    it("serves a static file out of the staged tree", async () => {
+        const sink = await send({ url: "/favicon.ico" });
+        expect(sink.head?.statusCode).toBe(200);
+        expect(sink.body).toEqual(FAVICON);
+        // Typed from the route's extension, not the file's: a static metadata route
+        // is staged as `favicon.ico.body`, and `.body` is not a media type. See
+        // `setBodyFileContentType` in static-files.ts.
+        expect(sink.head?.headers["content-type"]).toBe("image/x-icon");
+    });
+    it("serves public/ off disk, under the name the file actually has", async () => {
+        const body = async (url) => {
+            const sink = await send({ url });
+            expect(sink.head?.statusCode).toBe(200);
+            return sink.body.toString("utf-8");
+        };
+        expect(await body("/test.txt")).toBe("hello from public");
+        // `send` decodes the path it is given, so a raw filesystem path failed to
+        // decode (`100%.png`, an empty 400) or decoded to another file.
+        expect(await body("/100%25.png")).toBe("a literal percent");
+        expect(await body("/a%2520b.txt")).toBe("the file named with a percent");
+        expect(await body("/a%20b.txt")).toBe("the file named with a space");
+        // Both ways a link can spell it.
+        expect(await body("/images/logo@2x.png")).toBe("at sign");
+        expect(await body("/images/logo%402x.png")).toBe("at sign");
+    });
+    it("answers 405 to a public/ file requested with a method other than GET", async () => {
+        // `send` serves any method; `next start` does not.
+        const sink = await send({ url: "/test.txt", method: "DELETE" });
+        expect(sink.head?.statusCode).toBe(405);
+        expect(sink.head?.headers.allow).toBe("GET, HEAD");
+        expect(sink.body.toString("utf-8")).not.toContain("hello from public");
+    });
+    it("answers an unknown path through the /_not-found entrypoint", async () => {
+        const sink = await send({ url: "/nope?q=1" });
+        expect(sink.head?.statusCode).toBe(404);
+        expect(stubBody(sink).file).toBe((0, node_path_1.join)(root, "app-playground/.next/server/app/_not-found/page.js"));
+        // The requested path, not `/_not-found`: the App Router puts this in the RSC
+        // payload as the canonical URL, so rendering the module against its own
+        // pathname would hand the client the wrong `usePathname()` and history entry.
+        expect(stubBody(sink).url).toBe("/nope?q=1");
+    });
+    it("answers an unknown path no-store, whatever the /_not-found entry sends", async () => {
+        // A prerendered `/_not-found` is a cache HIT with a year-long `s-maxage`,
+        // and the CDN would keep this 404 for that long — past the deploy that adds
+        // the route. `next start` answers an unmatched path no-store.
+        const sink = await send({
+            url: `/nope?cacheControl=${encodeURIComponent("s-maxage=31536000")}`,
+        });
+        expect(sink.head?.statusCode).toBe(404);
+        expect(sink.head?.headers["cache-control"]).toBe("private, no-cache, no-store, max-age=0, must-revalidate");
+    });
+    it("renders the 404 page when a route calls requestMeta.render404()", async () => {
+        const sink = await send({ url: "/?render404=1" });
+        expect(sink.head?.statusCode).toBe(404);
+        // Whatever the route that gave up was rendering, for the same reason.
+        expect(stubBody(sink).url).toBe("/?render404=1");
+    });
+    it("leaves a render404() 404 the Cache-Control its route gave it", async () => {
+        // `notFound()` from an ISR page is a cacheable result of that page, kept for
+        // its revalidate period, so the no-store for unmatched paths must not
+        // reach it.
+        const sink = await send({
+            url: `/?render404=1&cacheControl=${encodeURIComponent("s-maxage=60")}`,
+        });
+        expect(sink.head?.statusCode).toBe(404);
+        expect(sink.head?.headers["cache-control"]).toBe("s-maxage=60");
+    });
+    it("runs requestMeta.revalidate() against itself, not over the network", async () => {
+        const sink = await send({ url: "/?revalidate=%2F" });
+        expect(sink.head?.statusCode).toBe(200);
+        expect(stubBody(sink)).toEqual({ revalidated: true, error: null });
+    });
+    it("renders a revalidation for the public origin the caller was served on", async () => {
+        const marker = (0, node_path_1.join)(root, "revalidate-origin-marker");
+        process.env.CDK_NEXTJS_TEST_MARKER = marker;
+        try {
+            await send({
+                url: "/?revalidate=%2F%3FrecordOrigin%3D1",
+                headers: {
+                    host: "abc123.lambda-url.us-east-1.on.aws",
+                    "x-forwarded-host": "shop.example.test",
+                    "x-forwarded-proto": "https",
+                },
+                trustForwardedHost: true,
+            });
+            expect((0, node_fs_1.readFileSync)(marker, "utf-8")).toBe("https://shop.example.test/?recordOrigin=1");
+        }
+        finally {
+            delete process.env.CDK_NEXTJS_TEST_MARKER;
+        }
+    });
+    it("fails a revalidation whose target did not answer 200", async () => {
+        const sink = await send({ url: "/?revalidate=%2F%3Fstatus%3D500" });
+        expect(stubBody(sink)).toEqual({
+            revalidated: false,
+            error: "Invalid response 500",
+        });
+    });
+    describe("invalidating the CDN copy of a revalidated page", () => {
+        const hookKey = manifest_1.REVALIDATED_PAGE_HOOK;
+        const globals = globalThis;
+        afterEach(() => {
+            delete globals[hookKey];
+        });
+        it("hands the cache handler's hook the page and its _next/data route", async () => {
+            const hook = jest.fn(async () => { });
+            globals[hookKey] = hook;
+            await send({ url: "/?revalidate=%2Fisr%2F42" });
+            expect(hook).toHaveBeenCalledTimes(1);
+            expect(hook).toHaveBeenCalledWith([
+                "/isr/42",
+                `/_next/data/${runtime.manifest.buildId}/isr/42.json`,
+            ]);
+        });
+        it("names the root's data route index.json", async () => {
+            const hook = jest.fn(async () => { });
+            globals[hookKey] = hook;
+            await send({ url: "/?revalidate=%2F" });
+            expect(hook).toHaveBeenCalledWith([
+                "/",
+                `/_next/data/${runtime.manifest.buildId}/index.json`,
+            ]);
+        });
+        it("invalidates nothing when the revalidation failed", async () => {
+            const hook = jest.fn(async () => { });
+            globals[hookKey] = hook;
+            await send({ url: "/?revalidate=%2F%3Fstatus%3D500" });
+            expect(hook).not.toHaveBeenCalled();
+        });
+        it("still reports success when the invalidation fails", async () => {
+            const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
+            globals[hookKey] = async () => {
+                throw new Error("TooManyInvalidationsInProgress");
+            };
+            const sink = await send({ url: "/?revalidate=%2F" });
+            expect(stubBody(sink)).toEqual({ revalidated: true, error: null });
+            warn.mockRestore();
+        });
+    });
+    it("strips the internal headers next start does not honor from a client", async () => {
+        const sink = await send({
+            url: "/",
+            headers: {
+                host: "shop.example.test",
+                "next-resume": "1",
+                "x-matched-path": "/admin",
+            },
+        });
+        expect(stubBody(sink)).toMatchObject({
+            nextResume: null,
+            matchedPath: null,
+        });
+    });
+    const images = () => runtime.images;
+    it("fetches an image source from a route handler, in process and without cookies", async () => {
+        const viewer = new request_1.ShimIncomingMessage({
+            method: "GET",
+            url: "/_next/image?url=%2Fapi%2Fhealth%3Favatar%3D42&w=64&q=75",
+            headers: { host: "shop.example.test", cookie: "session=secret" },
+        });
+        const response = await images().options.fetchInternal("/api/health?avatar=42", viewer, Infinity);
+        expect(response.statusCode).toBe(200);
+        const body = JSON.parse(response.body.toString("utf-8"));
+        expect(body.file).toContain("api/health");
+        expect(body.url).toBe("/api/health?avatar=42");
+        expect(body.initURL).toBe("https://shop.example.test/api/health?avatar=42");
+        expect(body.cookie).toBeNull();
+    });
+    // `images.maximumResponseBody`: a route streaming a large body must not be
+    // buffered whole, as `next start`'s `fetchInternalImage` does not.
+    it("stops reading an image source route past maximumResponseBody", async () => {
+        const error = jest.spyOn(console, "error").mockImplementation(() => { });
+        try {
+            const response = await images().options.fetchInternal("/api/health?avatar=42", new request_1.ShimIncomingMessage({
+                method: "GET",
+                url: "/_next/image?url=%2Fapi%2Fhealth%3Favatar%3D42&w=64&q=75",
+                headers: { host: "shop.example.test" },
+            }), 10);
+            expect(response.tooLarge).toBe(true);
+            expect(response.body.length).toBe(0);
+        }
+        finally {
+            error.mockRestore();
+        }
+    });
+    it("redirects a trailing slash, with the Refresh fallback for a 308", async () => {
+        const sink = await send({ url: "/isr/42/" });
+        expect(sink.head?.statusCode).toBe(308);
+        expect(sink.head?.headers.location).toBe("/isr/42");
+        expect(sink.head?.headers.refresh).toBe("0;url=/isr/42");
+        expect(sink.body.toString("utf-8")).toBe("/isr/42");
+    });
+    it("gzips a streamed HTML response for a client that accepts it", async () => {
+        const sink = await send({
+            url: "/",
+            headers: { host: "shop.example.test", "accept-encoding": "gzip" },
+        });
+        expect(sink.head?.headers["content-encoding"]).toBe("gzip");
+        expect((0, node_zlib_1.gunzipSync)(sink.body).toString("utf-8")).toContain("initURL");
+    });
+    it("awaits waitUntil work before resolving, since Lambda freezes on return", async () => {
+        const marker = (0, node_path_1.join)(root, "waituntil-marker");
+        process.env.CDK_NEXTJS_TEST_MARKER = marker;
+        try {
+            await send({ url: "/?waitUntil=1" });
+            // Written by a timer the entrypoint registered, after the response ended.
+            expect((0, node_fs_1.readFileSync)(marker, "utf-8")).toBe("done");
+        }
+        finally {
+            delete process.env.CDK_NEXTJS_TEST_MARKER;
+        }
+    });
+    it("serves the prerendered 500 when an entrypoint throws before sending a head", async () => {
+        const error = jest.spyOn(console, "error").mockImplementation(() => { });
+        const sink = await send({ url: "/?boom=1" });
+        expect(sink.head?.statusCode).toBe(500);
+        expect(sink.body.toString("utf-8")).toBe(ERROR_HTML);
+        // A `Cache-Control` the render that threw had already set would otherwise
+        // stay on the response and get the 500 cached at the edge.
+        expect(sink.head?.headers["cache-control"]).toBe("private, no-cache, no-store, max-age=0, must-revalidate");
+        expect(error).toHaveBeenCalledWith("Unhandled error while handling the request:", expect.objectContaining({ message: expect.stringContaining("exploded") }));
+        error.mockRestore();
+    });
+    it("streams middleware's own Response when it answers the request", async () => {
+        // A second deployment, because the middleware module is memoized per runtime.
+        const responding = await (0, core_1.loadRuntime)(stageDeployment(`
+exports.handler = async () =>
+  new Response("denied", {
+    status: 401,
+    statusText: "Unauthorized",
+    headers: [
+      ["content-type", "text/plain"],
+      ["set-cookie", "sid=; Path=/; expires=Thu, 01 Jan 1970 00:00:00 GMT"],
+      ["set-cookie", "flag=1; Path=/"],
+    ],
+  });
+`));
+        const sink = new CollectingSink();
+        await responding.handle({ method: "GET", url: "/", headers: { host: "shop.example.test" } }, sink);
+        // `resolveRoutes` only reports that middleware responded; the body comes
+        // back from the invoker, on the `middleware-responded` result.
+        expect(sink.head?.statusCode).toBe(401);
+        expect(sink.head?.statusMessage).toBe("Unauthorized");
+        expect(sink.head?.cookies).toEqual([
+            "sid=; Path=/; expires=Thu, 01 Jan 1970 00:00:00 GMT",
+            "flag=1; Path=/",
+        ]);
+        expect(sink.body.toString("utf-8")).toBe("denied");
+    });
+    it("answers a missing build asset no-store, not under its immutable rule", async () => {
+        // In the manifest but not on disk — `stageDeployment` writes no chunks, the
+        // way a Lambda package ships none (they are on S3 behind CloudFront).
+        const sink = await send({ url: "/_next/static/chunks/0-qsb3zz6f4c7.js" });
+        expect(sink.head?.statusCode).toBe(404);
+        expect(sink.head?.headers["cache-control"]).toBe("private, no-cache, no-store, max-age=0, must-revalidate");
+    });
+    // `next start` answers these without rendering the 404 page (`router-server.js`,
+    // the "404 case"): nothing would display it, and rendering is the cost.
+    it.each([
+        ["a missing build asset", "/_next/static/chunks/0-qsb3zz6f4c7.js"],
+        ["a build asset no deploy produced", "/_next/static/chunks/stale-0000.js"],
+    ])("answers %s with a plain-text Not Found", async (_name, url) => {
+        const sink = await send({ url });
+        expect(sink.head?.statusCode).toBe(404);
+        expect(sink.head?.headers["content-type"]).toBe("text/plain; charset=utf-8");
+        expect(sink.head?.headers["cache-control"]).toBe("private, no-cache, no-store, max-age=0, must-revalidate");
+        expect(sink.body.toString("utf-8")).toBe("Not Found");
+    });
+    it.each(["image", "script", "font", "style"])("answers an unknown path fetched as a %s subresource with a plain-text Not Found", async (dest) => {
+        const sink = await send({
+            url: "/nope.png",
+            headers: { host: "shop.example.test", "sec-fetch-dest": dest },
+        });
+        expect(sink.head?.statusCode).toBe(404);
+        expect(sink.head?.headers["cache-control"]).toBe("private, no-cache, no-store, max-age=0, must-revalidate");
+        expect(sink.body.toString("utf-8")).toBe("Not Found");
+    });
+    it.each([
+        // A navigation, and `fetch()` — which is how an RSC request goes.
+        ["a document", "GET", "document"],
+        ["a fetch", "GET", "empty"],
+        // `next start` only short-circuits GET and HEAD.
+        ["an image POST", "POST", "image"],
+    ])("still renders the 404 page for %s", async (_name, method, dest) => {
+        const sink = await send({
+            url: "/nope",
+            method,
+            headers: { host: "shop.example.test", "sec-fetch-dest": dest },
+        });
+        expect(sink.head?.statusCode).toBe(404);
+        expect(stubBody(sink).file).toContain("_not-found");
+    });
+    it("settles and destroys the response when the sink cannot take the head", async () => {
+        const error = jest.spyOn(console, "error").mockImplementation(() => { });
+        // What the Lambda sink's `writeHead` does with a header value it rejects.
+        const handled = runtime.handle({ method: "GET", url: "/", headers: { host: "shop.example.test" } }, {
+            begin() {
+                throw new TypeError("Invalid character in header content");
+            },
+        });
+        await expect(handled).resolves.toBeUndefined();
+        expect(error).toHaveBeenCalledWith("The response stream did not complete:", expect.objectContaining({ message: expect.stringContaining("header") }));
+        error.mockRestore();
+    });
+    it("streams an upload through middleware to the route intact", async () => {
+        const chunk = Buffer.alloc(64 * 1024, 1);
+        const sink = await send({
+            url: "/?readBody=1",
+            method: "POST",
+            body: node_stream_1.Readable.from(Array.from({ length: 32 }, () => chunk)),
+        });
+        expect(stubBody(sink)).toEqual({ bodyLength: 32 * chunk.length });
+    });
+    // The Lambda shell's body: already in memory, as a Buffer.
+    it("passes a Buffer upload through middleware to the route intact", async () => {
+        const body = Buffer.alloc(1024 * 1024, 1);
+        const sink = await send({ url: "/?readBody=1", method: "POST", body });
+        expect(stubBody(sink)).toEqual({ bodyLength: body.length });
+    });
+    it("reads middleware's body only as fast as the client takes it", async () => {
+        const pulls = { count: 0 };
+        globalThis.__cdkNextjsPulls = pulls;
+        const streaming = await (0, core_1.loadRuntime)(stageDeployment(`
+exports.handler = async () =>
+  new Response(
+    new ReadableStream({
+      pull(controller) {
+        const pulls = globalThis.__cdkNextjsPulls;
+        pulls.count += 1;
+        if (pulls.count > 1000) controller.close();
+        else controller.enqueue(new Uint8Array(16 * 1024));
+      },
+    }),
+  );
+`));
+        // A client that takes nothing until released.
+        let release;
+        const blocked = new Promise((resolve) => (release = resolve));
+        const sink = {
+            begin: () => new node_stream_1.Writable({
+                write(_chunk, _encoding, callback) {
+                    void blocked.then(() => callback());
+                },
+            }),
+        };
+        const handled = streaming.handle({ method: "GET", url: "/", headers: { host: "shop.example.test" } }, sink);
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        // 1000 chunks are 16 MiB; a few highWaterMarks' worth is all that may be
+        // buffered for a client that is not reading.
+        expect(pulls.count).toBeLessThan(50);
+        release();
+        await handled;
+        expect(pulls.count).toBe(1001);
+    });
+    it("pads an empty body when the shell asks, so API Gateway does not 502", async () => {
+        const sink = await send({
+            url: "/",
+            headers: { host: "shop.example.test", "if-none-match": "x" },
+        }, true);
+        // A real 304 is not reachable through a stub entrypoint, so this only
+        // asserts the padding does not corrupt a normal body.
+        expect(sink.body.length).toBeGreaterThan(1);
+    });
+    it("emits each cookie middleware set exactly once", async () => {
+        // `Headers.entries()` yields `set-cookie` once per cookie, so appending the
+        // whole `getSetCookie()` array per entry emitted N² of them: two cookies
+        // arrived at the browser as a=1, b=2, a=1, b=2. A duplicated `Set-Cookie` is
+        // not harmless either - a session cookie and its own copy race.
+        const continuing = await (0, core_1.loadRuntime)(stageDeployment(`
+exports.handler = async () =>
+  new Response(null, {
+    headers: [
+      ["x-middleware-next", "1"],
+      ["set-cookie", "a=1; Path=/"],
+      ["set-cookie", "b=2; Path=/"],
+    ],
+  });
+`));
+        const sink = new CollectingSink();
+        await continuing.handle({ method: "GET", url: "/", headers: { host: "shop.example.test" } }, sink);
+        expect(sink.head?.cookies).toEqual(["a=1; Path=/", "b=2; Path=/"]);
+    });
+});
+/**
+ * Next.js's page handlers report an error and then rethrow, leaving the error page
+ * to whatever hosts them, so this ladder is the only thing that makes a
+ * `pages/_error` reachable. `test/e2e/async-modules` is the measurement:
+ * `/make-error` throws in `getServerSideProps` and expects "hello error".
+ */
+describe("a Pages API route", () => {
+    it("is left to end its own response, as next start leaves it", async () => {
+        const pagesApi = await (0, core_1.loadRuntime)(stageDeployment(MIDDLEWARE_STUB, (manifest) => ({
+            ...manifest,
+            entrypoints: {
+                ...manifest.entrypoints,
+                "/api/health": {
+                    ...manifest.entrypoints["/api/health"],
+                    type: "page-api",
+                },
+            },
+        })));
+        const sink = new CollectingSink();
+        await pagesApi.handle({
+            method: "GET",
+            url: "/api/health?endLater=1",
+            headers: { host: "shop.example.test" },
+        }, sink);
+        expect(sink.body.toString("utf-8")).toBe("first,second");
+    });
+    it("is still ended for a route of any other kind", async () => {
+        const sink = await send({ url: "/api/health?endLater=1" });
+        expect(sink.body.toString("utf-8")).toBe("first,");
+    });
+});
+describe("res.revalidate() across functionGroups", () => {
+    // The other group's page renders as a 404, which `unstable_onlyGenerated`
+    // alone would accept as "not generated".
+    it.each([
+        ["", "/?revalidate=%2Fisr%2F1"],
+        [" with unstable_onlyGenerated", "/?revalidate=%2Fisr%2F1&onlyGenerated=1"],
+    ])("says which group owns a page it cannot render%s", async (_, url) => {
+        let missing = "";
+        const staged = stageDeployment(MIDDLEWARE_STUB, (manifest) => {
+            missing = manifest.entrypoints["/isr/[id]"].filePath;
+            return {
+                ...manifest,
+                groups: {
+                    default: Object.keys(manifest.entrypoints).filter((template) => template !== "/isr/[id]"),
+                    blog: ["/isr/[id]"],
+                },
+            };
+        });
+        (0, node_fs_1.rmSync)((0, node_path_1.join)(staged, missing));
+        const grouped = await (0, core_1.loadRuntime)(staged);
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
+        process.env.CDK_NEXTJS_FUNCTION_GROUP = "default";
+        try {
+            const sink = new CollectingSink();
+            await grouped.handle({
+                method: "GET",
+                url,
+                headers: { host: "shop.example.test" },
+            }, sink);
+            const { error } = JSON.parse(sink.body.toString("utf-8"));
+            expect(error).toMatch(/^Invalid response 404: /);
+            expect(error).toContain('group "blog"');
+            expect(error).toContain('("default")');
+            // The error explains it; the misrouted-request warning would not.
+            expect(warn).not.toHaveBeenCalled();
+        }
+        finally {
+            delete process.env.CDK_NEXTJS_FUNCTION_GROUP;
+            warn.mockRestore();
+        }
+    });
+});
+describe("withoutInternalHeaders", () => {
+    it("drops every header on Next's internal list", () => {
+        expect((0, core_1.withoutInternalHeaders)({
+            host: "a.test",
+            "next-resume": "1",
+            "x-middleware-rewrite": "/x",
+            "x-nextjs-data": "1",
+        }, "/blog", "")).toEqual({ host: "a.test" });
+    });
+    it("marks a _next/data request as one, as next start's router does", () => {
+        expect((0, core_1.withoutInternalHeaders)({}, "/base/_next/data/abc/blog.json?x=1", "/base")).toEqual({ "x-nextjs-data": "1" });
+        expect((0, core_1.withoutInternalHeaders)({}, "/_next/data/abc/blog", "")).toEqual({});
+    });
+});
+describe("the error page ladder", () => {
+    /**
+     * An app with a custom `pages/_error` that cannot be prerendered — one with
+     * `getInitialProps`, or a `pages/_app` that has it. The fixture is App Router,
+     * so both halves have to be arranged: drop the prerendered `/500` next emits by
+     * default, and add the entrypoint.
+     */
+    const withErrorPage = (manifest) => {
+        const { "/500": _prerendered, ...staticFiles } = manifest.staticFiles;
+        return {
+            ...manifest,
+            staticFiles,
+            entrypoints: {
+                ...manifest.entrypoints,
+                "/_error": {
+                    ...manifest.entrypoints["/_not-found"],
+                    id: "/_error",
+                    filePath: (0, node_path_1.join)(manifest.relativeProjectDir, ".next/server/pages/_error.js"),
+                },
+            },
+        };
+    };
+    async function sendTo(withLadder, url) {
+        const sink = new CollectingSink();
+        await withLadder.handle({ method: "GET", url, headers: { host: "shop.example.test" } }, sink);
+        return sink;
+    }
+    it("invokes /_error when the build has no prerendered /500", async () => {
+        const error = jest.spyOn(console, "error").mockImplementation(() => { });
+        const rendering = await (0, core_1.loadRuntime)(stageDeployment(MIDDLEWARE_STUB, withErrorPage));
+        const sink = await sendTo(rendering, "/?boom=1");
+        expect(sink.head?.statusCode).toBe(500);
+        // Rendered for the URL that was asked for, and with the status already set:
+        // `_error`'s `getInitialProps` reads `res.statusCode` to get its own prop.
+        expect(stubBody(sink).file).toContain("pages/_error.js");
+        expect(stubBody(sink).url).toBe("/?boom=1");
+        expect(sink.head?.headers["content-length"]).toBeUndefined();
+        expect(sink.head?.headers.etag).toBeUndefined();
+        // Not the throwing render's `s-maxage=60`: a cached 500 at CloudFront.
+        expect(sink.head?.headers["cache-control"]).toMatch(/no-store/);
+        error.mockRestore();
+    });
+    it("drops the failed render's Content-Length and ETag from a prerendered /500", async () => {
+        const error = jest.spyOn(console, "error").mockImplementation(() => { });
+        const sink = await send({ url: "/?boom=1" });
+        expect(sink.head?.statusCode).toBe(500);
+        expect(sink.body.toString("utf-8")).toBe(ERROR_HTML);
+        expect(sink.head?.headers["content-length"]).toBeUndefined();
+        expect(sink.head?.headers.etag).toBeUndefined();
+        error.mockRestore();
+    });
+    it("falls back to plain text when the error page throws too", async () => {
+        const error = jest.spyOn(console, "error").mockImplementation(() => { });
+        const rendering = await (0, core_1.loadRuntime)(stageDeployment(MIDDLEWARE_STUB, withErrorPage));
+        const sink = await sendTo(rendering, "/?boomEverywhere=1");
+        expect(sink.head?.statusCode).toBe(500);
+        expect(sink.body.toString("utf-8")).toBe("Internal Server Error");
+        expect(sink.head?.headers["cache-control"]).toBe("private, no-cache, no-store, max-age=0, must-revalidate");
+        expect(error).toHaveBeenCalledWith("The error page itself failed to render:", expect.objectContaining({ message: expect.stringContaining("too") }));
+        error.mockRestore();
+    });
+    it("answers plain text for an app with no error page at all", async () => {
+        const error = jest.spyOn(console, "error").mockImplementation(() => { });
+        const bare = await (0, core_1.loadRuntime)(stageDeployment(MIDDLEWARE_STUB, (manifest) => {
+            const { "/500": _prerendered, ...staticFiles } = manifest.staticFiles;
+            return { ...manifest, staticFiles };
+        }));
+        const sink = await sendTo(bare, "/?boom=1");
+        expect(sink.head?.statusCode).toBe(500);
+        expect(sink.body.toString("utf-8")).toBe("Internal Server Error");
+        error.mockRestore();
+    });
+});
+describe("a Pages Router 404", () => {
+    /** The fixture is App Router: without `/_not-found`, a 404 is the Pages one. */
+    const withoutNotFound = (manifest) => {
+        const { "/_not-found": _appRouter, ...entrypoints } = manifest.entrypoints;
+        return { ...manifest, entrypoints };
+    };
+    async function sendTo(pages, url) {
+        const sink = new CollectingSink();
+        await pages.handle({ method: "GET", url, headers: { host: "shop.example.test" } }, sink);
+        return sink;
+    }
+    it("serves the prerendered 404.html for an unknown path and for render404()", async () => {
+        const pages = await (0, core_1.loadRuntime)(stageDeployment(MIDDLEWARE_STUB, withoutNotFound));
+        for (const url of ["/nope", "/?render404=1"]) {
+            const sink = await sendTo(pages, url);
+            expect(sink.head?.statusCode).toBe(404);
+            expect(sink.head?.headers["content-type"]).toBe("text/html; charset=utf-8");
+            expect(sink.body.toString("utf-8")).toBe(NOT_FOUND_HTML);
+        }
+    });
+    it("renders a pages/404 entrypoint for the path that was asked for", async () => {
+        // What a `getInitialProps` in `pages/_app` makes of `pages/404.js`.
+        const pages = await (0, core_1.loadRuntime)(stageDeployment(MIDDLEWARE_STUB, (manifest) => {
+            const withoutApp = withoutNotFound(manifest);
+            return {
+                ...withoutApp,
+                entrypoints: {
+                    ...withoutApp.entrypoints,
+                    "/404": {
+                        ...manifest.entrypoints["/_not-found"],
+                        id: "/404",
+                        filePath: (0, node_path_1.join)(manifest.relativeProjectDir, ".next/server/pages/404.js"),
+                    },
+                },
+            };
+        }));
+        const sink = await sendTo(pages, "/nope?q=1");
+        expect(sink.head?.statusCode).toBe(404);
+        expect(stubBody(sink).file).toContain("pages/404.js");
+        expect(stubBody(sink).url).toBe("/nope?q=1");
+    });
+    it("answers plain text when the app has no 404 page at all", async () => {
+        const bare = await (0, core_1.loadRuntime)(stageDeployment(MIDDLEWARE_STUB, (manifest) => {
+            const { "/404": _prerendered, ...staticFiles } = manifest.staticFiles;
+            return { ...withoutNotFound(manifest), staticFiles };
+        }));
+        const sink = await sendTo(bare, "/?render404=1");
+        expect(sink.head?.statusCode).toBe(404);
+        expect(sink.body.toString("utf-8")).toBe("This page could not be found.");
+    });
+});
+describe("/_next/image with images turned off", () => {
+    it("answers the app's 404, no-store, instead of optimizing", async () => {
+        // `images.unoptimized`, as `next start` reads it from
+        // `required-server-files.json`.
+        const staged = stageDeployment();
+        const manifest = JSON.parse((0, node_fs_1.readFileSync)((0, manifest_1.deployedManifestPath)(staged), "utf-8"));
+        write((0, node_path_1.join)(staged, manifest.relativeProjectDir, ".next/required-server-files.json"), JSON.stringify({
+            version: 1,
+            config: { experimental: {}, images: { unoptimized: true } },
+        }));
+        const unoptimized = await (0, core_1.loadRuntime)(staged);
+        const sink = new CollectingSink();
+        await unoptimized.handle({
+            method: "GET",
+            url: "/_next/image?url=%2Ffavicon.ico&w=64&q=75",
+            headers: { host: "shop.example.test" },
+        }, sink);
+        expect(sink.head?.statusCode).toBe(404);
+        expect(sink.head?.headers["cache-control"]).toBe("private, no-cache, no-store, max-age=0, must-revalidate");
+        expect(stubBody(sink).file).toContain("_not-found/page.js");
+        expect(stubBody(sink).url).toBe("/_next/image?url=%2Ffavicon.ico&w=64&q=75");
+    });
+});
+describe("an external rewrite", () => {
+    /**
+     * `NextResponse.rewrite("https://…")`: an absolute destination makes
+     * `resolveRoutes` report an `externalRewrite`, which the runtime proxies with
+     * `fetch` instead of routing to an entrypoint.
+     */
+    const EXTERNAL_REWRITE_MIDDLEWARE = `
+exports.handler = async () =>
+  new Response(null, {
+    headers: { "x-middleware-rewrite": "https://upstream.test/from-origin" },
+  });
+`;
+    const ORIGIN_BODY = "<html>from the origin</html>";
+    /**
+     * What undici hands back for a gzip origin, which is the whole point of these
+     * tests: `fetch` decodes the body and leaves both `content-encoding` and the
+     * *encoded* `content-length` behind, describing bytes it already discarded.
+     */
+    function gzipLabelledPlaintext() {
+        return new Response(ORIGIN_BODY, {
+            status: 200,
+            headers: {
+                "content-type": "text/html; charset=utf-8",
+                "content-encoding": "gzip",
+                "content-length": String((0, node_zlib_1.gzipSync)(ORIGIN_BODY).byteLength),
+            },
+        });
+    }
+    let proxying;
+    let fetchMock;
+    beforeAll(async () => {
+        proxying = await (0, core_1.loadRuntime)(stageDeployment(EXTERNAL_REWRITE_MIDDLEWARE));
+    });
+    beforeEach(() => {
+        fetchMock = jest
+            .spyOn(globalThis, "fetch")
+            .mockResolvedValue(gzipLabelledPlaintext());
+    });
+    afterEach(() => {
+        fetchMock.mockRestore();
+    });
+    async function proxy(headers = {}, trustForwardedHost = false) {
+        const sink = new CollectingSink();
+        await proxying.handle({
+            method: "GET",
+            url: "/anything",
+            headers: { host: "shop.example.test", ...headers },
+            trustForwardedHost,
+        }, sink);
+        return sink;
+    }
+    const SIGNED = {
+        authorization: "AWS4-HMAC-SHA256 Credential=AKIA/20260928/us-east-1/lambda/aws4_request",
+        "x-amz-date": "20260928T000000Z",
+        "x-amz-content-sha256": "UNSIGNED-PAYLOAD",
+        "x-amz-security-token": "token",
+    };
+    // Forwarded, OAC's signature would let the upstream replay the request
+    // against the Function URL.
+    it("does not forward the SigV4 headers of an IAM-verified request", async () => {
+        await proxy(SIGNED, true);
+        const headers = fetchMock.mock.calls[0][1]
+            .headers;
+        for (const name of Object.keys(SIGNED)) {
+            expect(headers.has(name)).toBe(false);
+        }
+    });
+    // Anywhere else they are the client's own, which `next start` forwards.
+    it("forwards the client's own Authorization and x-amz-* headers", async () => {
+        await proxy(SIGNED);
+        const headers = fetchMock.mock.calls[0][1]
+            .headers;
+        for (const [name, value] of Object.entries(SIGNED)) {
+            expect(headers.get(name)).toBe(value);
+        }
+    });
+    it("proxies the request to the rewritten origin", async () => {
+        const sink = await proxy();
+        expect(String(fetchMock.mock.calls[0][0])).toBe("https://upstream.test/from-origin");
+        expect(sink.head?.statusCode).toBe(200);
+        expect(sink.head?.headers["content-type"]).toBe("text/html; charset=utf-8");
+    });
+    // undici throws on these (`expect: 100-continue` from curl for a large POST,
+    // `keep-alive` from an HTTP/1.0 client), which answered the request with a 500.
+    it("does not forward the headers that describe the client's connection", async () => {
+        await proxy({
+            expect: "100-continue",
+            "keep-alive": "timeout=5",
+            upgrade: "websocket",
+            connection: "keep-alive, upgrade",
+            "x-kept": "yes",
+        });
+        const headers = fetchMock.mock.calls[0][1]
+            .headers;
+        for (const name of [
+            "host",
+            "expect",
+            "keep-alive",
+            "upgrade",
+            "connection",
+        ]) {
+            expect(headers.has(name)).toBe(false);
+        }
+        expect(headers.get("x-kept")).toBe("yes");
+    });
+    // The request body is forwarded as received, so its encoding has to go with
+    // it: a gzip upload arriving unlabelled is garbage to the upstream.
+    it("forwards the request's content-encoding with its body", async () => {
+        await proxy({ "content-encoding": "gzip" });
+        const headers = fetchMock.mock.calls[0][1]
+            .headers;
+        expect(headers.get("content-encoding")).toBe("gzip");
+    });
+    // Forwarding the origin's `content-encoding` over a body `fetch` already
+    // decoded fails the whole response in the browser with
+    // ERR_CONTENT_DECODING_FAILED, under a `Content-Length` that describes the
+    // compressed bytes. Nothing downstream repairs it either: `shouldGzip`
+    // declines as soon as `content-encoding` is set.
+    it("drops the content-encoding and length fetch already consumed", async () => {
+        const sink = await proxy();
+        expect(sink.head?.headers["content-encoding"]).toBeUndefined();
+        expect(sink.head?.headers["content-length"]).toBeUndefined();
+        expect(sink.body.toString("utf-8")).toBe(ORIGIN_BODY);
+    });
+    // The other half of it: with the stale label gone, the sink is free to
+    // compress the plaintext itself — and now the encoding it advertises is the
+    // one the bytes actually carry.
+    it("re-compresses the decoded body when the client accepts gzip", async () => {
+        const sink = await proxy({ "accept-encoding": "gzip" });
+        expect(sink.head?.headers["content-encoding"]).toBe("gzip");
+        expect((0, node_zlib_1.gunzipSync)(sink.body).toString("utf-8")).toBe(ORIGIN_BODY);
+    });
+});
+describe("a streamed external rewrite", () => {
+    const EXTERNAL_REWRITE_MIDDLEWARE = `
+exports.handler = async () =>
+  new Response(null, {
+    headers: { "x-middleware-rewrite": "https://upstream.test/events" },
+  });
+`;
+    let proxying;
+    beforeAll(async () => {
+        proxying = await (0, core_1.loadRuntime)(stageDeployment(EXTERNAL_REWRITE_MIDDLEWARE));
+    });
+    // Server-sent events through a rewrite, gzipped because `text/event-stream`
+    // is `text/*`: without a flush per chunk, the first event sat in zlib's
+    // buffer until the origin closed the stream.
+    it("flushes each chunk through the compressor as it arrives", async () => {
+        let release;
+        const held = new Promise((resolve) => (release = resolve));
+        const fetchMock = jest.spyOn(globalThis, "fetch").mockResolvedValue(new Response(new ReadableStream({
+            async start(controller) {
+                controller.enqueue(new TextEncoder().encode("data: first\n\n"));
+                await held;
+                controller.enqueue(new TextEncoder().encode("data: second\n\n"));
+                controller.close();
+            },
+        }), { headers: { "content-type": "text/event-stream" } }));
+        try {
+            const sink = new CollectingSink();
+            const handled = proxying.handle({
+                method: "GET",
+                url: "/events",
+                headers: { host: "shop.example.test", "accept-encoding": "gzip" },
+            }, sink);
+            // Poll rather than sleep a fixed time: the first event has to reach the
+            // sink while the origin is still holding the stream open.
+            const soFar = () => (0, node_zlib_1.gunzipSync)(sink.body, {
+                finishFlush: node_zlib_1.constants.Z_SYNC_FLUSH,
+            }).toString("utf-8");
+            for (let i = 0; i < 50 && !soFar(); i++) {
+                await new Promise((resolve) => setTimeout(resolve, 10));
+            }
+            expect(sink.head?.headers["content-encoding"]).toBe("gzip");
+            expect(soFar()).toBe("data: first\n\n");
+            release();
+            await handled;
+            expect((0, node_zlib_1.gunzipSync)(sink.body).toString("utf-8")).toBe("data: first\n\ndata: second\n\n");
+        }
+        finally {
+            release();
+            fetchMock.mockRestore();
+        }
+    });
+});
+describe("a Response middleware answers with itself", () => {
+    const MIDDLEWARE_BODY = "<html>from middleware</html>";
+    /**
+     * `return fetch(upstream)` from `proxy.ts`, as the runtime sees it: middleware
+     * runs in process, so its `fetch` is undici, which decoded a gzip upstream
+     * and kept the upstream's `content-encoding` and encoded `content-length`.
+     */
+    const FETCHED_RESPONSE_MIDDLEWARE = `
+const { gzipSync } = require("node:zlib");
+const body = ${JSON.stringify(MIDDLEWARE_BODY)};
+exports.handler = async () =>
+  new Response(body, {
+    headers: {
+      "content-type": "text/html; charset=utf-8",
+      "content-encoding": "gzip",
+      "content-length": String(gzipSync(body).byteLength),
+      "transfer-encoding": "chunked",
+      "x-from-upstream": "yes",
+    },
+  });
+`;
+    let responding;
+    beforeAll(async () => {
+        responding = await (0, core_1.loadRuntime)(stageDeployment(FETCHED_RESPONSE_MIDDLEWARE));
+    });
+    // What `next start` does too: the sandbox deletes these three
+    // (`FORBIDDEN_HEADERS`) from every middleware response.
+    it("drops the framing headers that described the upstream's bytes", async () => {
+        const sink = new CollectingSink();
+        await responding.handle({ method: "GET", url: "/", headers: { host: "shop.example.test" } }, sink);
+        expect(sink.head?.headers["content-encoding"]).toBeUndefined();
+        expect(sink.head?.headers["content-length"]).toBeUndefined();
+        expect(sink.head?.headers["transfer-encoding"]).toBeUndefined();
+        expect(sink.head?.headers["x-from-upstream"]).toBe("yes");
+        expect(sink.body.toString("utf-8")).toBe(MIDDLEWARE_BODY);
+    });
+});
+/**
+ * Last in the file, because `loadRuntime` chdirs: the tests above assert on the
+ * cwd the shared deployment set.
+ */
+describe("the resolved query a rewrite produced", () => {
+    /**
+     * `test/e2e/link-with-api-rewrite`'s rule, as it lands in the manifest: a
+     * `beforeFiles` rewrite whose condition is a query param the destination keeps.
+     */
+    const withSelfMatchingRewrite = (manifest) => ({
+        ...manifest,
+        routing: {
+            ...manifest.routing,
+            beforeFiles: [
+                {
+                    source: "/:path(.*)",
+                    sourceRegex: "^(?:\\/(.*))(?:\\/)?$",
+                    destination: "/?from=%2F$1",
+                    has: [{ type: "query", key: "json", value: "true" }],
+                },
+            ],
+        },
+    });
+    /**
+     * `RouteModule.prepare` re-runs the config's rewrites against `req.url`
+     * unconditionally, and `req.url` is the target the rewrite already produced -
+     * so a rule that still matches its own output gets applied twice. Here that
+     * turned `from=/some/route/for` into `from=/`, which is what made
+     * `test/e2e/link-with-api-rewrite` answer `{"from":"/api/json"}` where
+     * `next start` answers `{"from":"/some/route/for"}`. Stating the resolved query
+     * as `requestMeta.query` is what `prepare` prefers over anything it re-derives,
+     * so the route sees the first pass rather than the second.
+     */
+    it("is handed over as requestMeta.query, not left to be re-derived", async () => {
+        const rewriting = await (0, core_1.loadRuntime)(stageDeployment(MIDDLEWARE_STUB, withSelfMatchingRewrite));
+        const sink = new CollectingSink();
+        await rewriting.handle({
+            method: "GET",
+            url: "/some/route/for?json=true",
+            headers: { host: "shop.example.test" },
+        }, sink);
+        const body = stubBody(sink);
+        // Its own staged tree, so not `root`: the rewrite is the point.
+        expect(body.file).toContain(".next/server/app/page.js");
+        expect(body.query).toEqual({ json: "true", from: "/some/route/for" });
+    });
+});
+/**
+ * `next start` answers `//` with `308 -> /` and `/api//json` with
+ * `308 -> /api/json`; this runtime used to answer 500 and 404. The 500 is the
+ * reason the check runs before anything parses the target: `new URL("//", base)`
+ * reads a leading `//` as protocol-relative and takes the first path segment for
+ * the host. Found by `test/e2e/hydration`, which requests exactly `//`, and by
+ * `test/e2e/i18n-ignore-redirect-source-locale/redirects-with-basepath`, whose
+ * locale list includes `''` and so asks for `/basepath//to-sv`.
+ */
+describe("a path with repeated slashes or a backslash", () => {
+    it.each([
+        ["//", "/"],
+        ["///", "/"],
+        ["/api//json", "/api/json"],
+        ["/basepath//to-sv", "/basepath/to-sv"],
+        ["/a\\b", "/a/b"],
+        // The query is carried across untouched, repeated slashes and all.
+        ["//some/route?json=true&next=//x", "/some/route?json=true&next=//x"],
+    ])("redirects %s to %s with a 308", async (from, to) => {
+        const sink = await send({ url: from });
+        expect(sink.head?.statusCode).toBe(308);
+        expect(sink.head?.headers.location).toBe(to);
+        // Next.js sends the destination as the body too.
+        expect(sink.body.toString("utf-8")).toBe(to);
+    });
+    /** `%5C` is a character in a segment, not a separator - as in Next.js. */
+    it("leaves an encoded backslash alone", async () => {
+        const sink = await send({ url: "/a%5Cb" });
+        expect(sink.head?.statusCode).not.toBe(308);
+    });
+});
+describe("splitBody", () => {
+    const CHUNK = Buffer.alloc(16 * 1024, 7);
+    const upload = () => node_stream_1.Readable.from(Array.from({ length: 8 }, () => CHUNK), { objectMode: false });
+    async function drain(stream) {
+        let length = 0;
+        for await (const chunk of stream) {
+            length += chunk.length;
+        }
+        return length;
+    }
+    // A tee buffers for the branch that is behind, so the middleware branch that
+    // nothing reads would otherwise hold every byte the route streams.
+    it("cancels the middleware copy once dispatch is done with it", async () => {
+        const body = (0, core_1.splitBody)(upload(), true);
+        body.releaseUnread(false);
+        const reader = body.forDispatch.getReader();
+        expect(await reader.read()).toEqual({ done: true, value: undefined });
+        expect(await drain(body.forRequest)).toBe(8 * CHUNK.length);
+    });
+    it("leaves the middleware copy alone when middleware is reading it", async () => {
+        const body = (0, core_1.splitBody)(upload(), true);
+        const reading = drain(body.forDispatch);
+        body.releaseUnread(false);
+        expect(await reading).toBe(8 * CHUNK.length);
+    });
+    // Middleware answered, possibly with the upload as its own body; `req` is
+    // never read, so its copy is the one that would pile up.
+    it("releases the route's copy when middleware answered", async () => {
+        const body = (0, core_1.splitBody)(upload(), true);
+        body.releaseUnread(true);
+        expect(body.forRequest.destroyed).toBe(true);
+        expect(await drain(body.forDispatch)).toBe(8 * CHUNK.length);
+    });
+    // Every Lambda request with a body: the shell hands the runtime a Buffer.
+    it("reads a Buffer body twice, whole each time", async () => {
+        const source = Buffer.from("x".repeat(100_000));
+        const body = (0, core_1.splitBody)(source, true);
+        body.releaseUnread(false);
+        expect(await drain(body.forDispatch)).toBe(source.length);
+        expect(body.forRequest.length).toBe(source.length);
+    });
+    it("does not split at all without middleware", () => {
+        const source = upload();
+        const body = (0, core_1.splitBody)(source, false);
+        expect(body.forRequest).toBe(source);
+        body.releaseUnread(false);
+        expect(source.destroyed).toBe(false);
+    });
+});
+describe("waitUntil", () => {
+    it("awaits work registered after the first batch settled", async () => {
+        const marker = (0, node_path_1.join)(root, "late-wait-until-marker");
+        process.env.CDK_NEXTJS_TEST_MARKER = marker;
+        try {
+            await send({ url: "/?lateWaitUntil=1" });
+            expect((0, node_fs_1.readFileSync)(marker, "utf-8")).toBe("late");
+        }
+        finally {
+            delete process.env.CDK_NEXTJS_TEST_MARKER;
+        }
+    });
+});
+describe("a prerendered status page, requested directly", () => {
+    it("answers /404 with a 404, as next start does", async () => {
+        const sink = await send({ url: "/404" });
+        expect(sink.head?.statusCode).toBe(404);
+        expect(sink.body.toString("utf-8")).toBe(NOT_FOUND_HTML);
+    });
+    it("answers /500 with a 500", async () => {
+        const sink = await send({ url: "/500" });
+        expect(sink.head?.statusCode).toBe(500);
+        expect(sink.body.toString("utf-8")).toBe(ERROR_HTML);
+    });
+    it("still serves them to a POST, which next start does not 405", async () => {
+        const sink = await send({ url: "/404", method: "POST" });
+        expect(sink.head?.statusCode).toBe(404);
+    });
+});
+describe("an auto-exported Pages Router page", () => {
+    const ABOUT_HTML = "<html><body>about</body></html>";
+    let pages;
+    beforeAll(async () => {
+        let aboutFile = "";
+        const staged = stageDeployment(MIDDLEWARE_STUB, (manifest) => {
+            aboutFile = `${manifest.relativeProjectDir}/.next/server/pages/about.html`;
+            return {
+                ...manifest,
+                staticFiles: { ...manifest.staticFiles, "/about": aboutFile },
+            };
+        });
+        write((0, node_path_1.join)(staged, aboutFile), ABOUT_HTML);
+        pages = await (0, core_1.loadRuntime)(staged);
+    });
+    async function sendTo(method) {
+        const sink = new CollectingSink();
+        await pages.handle({ method, url: "/about", headers: { host: "shop.example.test" } }, sink);
+        return sink;
+    }
+    it("is served to a GET", async () => {
+        const sink = await sendTo("GET");
+        expect(sink.head?.statusCode).toBe(200);
+        expect(sink.body.toString("utf-8")).toBe(ABOUT_HTML);
+    });
+    it("answers any other method with a 405, as next start does", async () => {
+        const sink = await sendTo("POST");
+        expect(sink.head?.statusCode).toBe(405);
+        expect(sink.head?.headers.allow).toBe("GET, HEAD");
+    });
+});
+describe("a route packaged into another functionGroups group", () => {
+    let grouped;
+    beforeAll(async () => {
+        let missing = "";
+        const staged = stageDeployment(MIDDLEWARE_STUB, (manifest) => {
+            missing = manifest.entrypoints["/isr/[id]"].filePath;
+            return {
+                ...manifest,
+                groups: {
+                    default: Object.keys(manifest.entrypoints).filter((template) => template !== "/isr/[id]"),
+                    blog: ["/isr/[id]"],
+                },
+            };
+        });
+        (0, node_fs_1.rmSync)((0, node_path_1.join)(staged, missing));
+        grouped = await (0, core_1.loadRuntime)(staged);
+    });
+    async function get(url) {
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
+        process.env.CDK_NEXTJS_FUNCTION_GROUP = "default";
+        try {
+            const sink = new CollectingSink();
+            await grouped.handle({ method: "GET", url, headers: { host: "shop.example.test" } }, sink);
+            return sink;
+        }
+        finally {
+            delete process.env.CDK_NEXTJS_FUNCTION_GROUP;
+            warn.mockRestore();
+        }
+    }
+    // The edge matches case-sensitively and Next.js doesn't: `/ISR/1` missed the
+    // `blog` group's behavior only because of its case.
+    it("redirects a URL that differs only in case to its canonical spelling", async () => {
+        const sink = await get("/ISR/1?x=1");
+        expect(sink.head?.statusCode).toBe(308);
+        expect(sink.head?.headers.location).toBe("/isr/1?x=1");
+    });
+    it("keeps the case of a dynamic segment's value", async () => {
+        const sink = await get("/ISR/AbC");
+        expect(sink.head?.statusCode).toBe(308);
+        expect(sink.head?.headers.location).toBe("/isr/AbC");
+    });
+    // `/_next/image` runs in the default group and renders a source that is not
+    // a file in process: for one served by another group, that rendered the 404
+    // page and handed its HTML to the optimizer as the image.
+    it("reports an image source in another group rather than fetching its 404 page", async () => {
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
+        process.env.CDK_NEXTJS_FUNCTION_GROUP = "default";
+        try {
+            const fetchInternal = grouped.fetchInternal.bind(grouped);
+            const response = await fetchInternal("/isr/1", new request_1.ShimIncomingMessage({
+                method: "GET",
+                url: "/_next/image?url=%2Fisr%2F1&w=64&q=75",
+                headers: { host: "shop.example.test" },
+            }));
+            expect(response).toMatchObject({ otherGroup: "blog" });
+            expect(response.body.length).toBe(0);
+        }
+        finally {
+            delete process.env.CDK_NEXTJS_FUNCTION_GROUP;
+            warn.mockRestore();
+        }
+    });
+    it("is a 404, not a 500, when case is not the difference", async () => {
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
+        process.env.CDK_NEXTJS_FUNCTION_GROUP = "default";
+        try {
+            const sink = new CollectingSink();
+            await grouped.handle({
+                method: "GET",
+                url: "/isr/1",
+                headers: { host: "shop.example.test" },
+            }, sink);
+            expect(sink.head?.statusCode).toBe(404);
+            expect(sink.head?.headers["cache-control"]).toMatch(/no-store/);
+            expect(String(warn.mock.calls[0]?.[0])).toContain('group "blog"');
+        }
+        finally {
+            delete process.env.CDK_NEXTJS_FUNCTION_GROUP;
+            warn.mockRestore();
+        }
+    });
+});
+describe("public/ on the Lambda types", () => {
+    let lambda;
+    const send$ = jest.spyOn(client_s3_1.S3Client.prototype, "send");
+    beforeAll(async () => {
+        const staged = stageDeployment();
+        const manifest = JSON.parse((0, node_fs_1.readFileSync)((0, manifest_1.deployedManifestPath)(staged), "utf-8"));
+        // What a Lambda zip carries: the list, not the files.
+        (0, node_fs_1.rmSync)((0, node_path_1.join)(staged, manifest.relativeProjectDir, "public"), {
+            recursive: true,
+        });
+        write((0, node_path_1.join)(staged, manifest_1.RUNTIME_DIR_NAME, manifest_1.PUBLIC_FILES_FILE_NAME), JSON.stringify(["feed.xml", "images/logo@2x.png"]));
+        lambda = new core_1.NextjsRuntime({
+            deploymentRoot: staged,
+            manifest,
+            bucket: "assets",
+            bucketKeyPrefix: "base",
+        });
+    });
+    afterEach(() => send$.mockReset());
+    afterAll(() => send$.mockRestore());
+    async function get(url, headers = {}) {
+        const sink = new CollectingSink();
+        await lambda.handle({
+            method: "GET",
+            url,
+            headers: { host: "shop.example.test", ...headers },
+        }, sink);
+        return sink;
+    }
+    it("streams a listed file from the assets bucket, under its key prefix", async () => {
+        send$.mockImplementation((async () => ({
+            Body: node_stream_1.Readable.from([Buffer.from("<rss/>")]),
+            ContentType: "application/rss+xml",
+            ContentLength: 6,
+            ETag: '"e1"',
+            LastModified: new Date("2026-01-02T03:04:05Z"),
+        })));
+        const sink = await get("/feed.xml");
+        expect(sink.head?.statusCode).toBe(200);
+        expect(sink.body.toString("utf-8")).toBe("<rss/>");
+        expect(sink.head?.headers["content-type"]).toBe("application/rss+xml");
+        expect(sink.head?.headers.etag).toBe('"e1"');
+        expect(sink.head?.headers["cache-control"]).toBe("public, max-age=0");
+        const command = send$.mock.calls[0][0];
+        expect(command.input).toMatchObject({
+            Bucket: "assets",
+            Key: "base/feed.xml",
+        });
+    });
+    it("uses the file's real name as the key", async () => {
+        send$.mockImplementation((async () => ({
+            Body: node_stream_1.Readable.from([Buffer.from("png")]),
+        })));
+        await get("/images/logo@2x.png");
+        const command = send$.mock.calls[0][0];
+        expect(command.input.Key).toBe("base/images/logo@2x.png");
+    });
+    it("answers a matching If-None-Match with the 304 S3 gave", async () => {
+        send$.mockImplementation((async () => {
+            throw Object.assign(new Error("Not Modified"), {
+                name: "NotModified",
+                $metadata: { httpStatusCode: 304 },
+            });
+        }));
+        const sink = await get("/feed.xml", { "if-none-match": '"e1"' });
+        expect(sink.head?.statusCode).toBe(304);
+        expect(sink.body.length).toBe(0);
+    });
+    it("falls through to the 404 when the object is gone", async () => {
+        send$.mockImplementation((async () => {
+            throw Object.assign(new Error("NoSuchKey"), {
+                name: "NoSuchKey",
+                $metadata: { httpStatusCode: 404 },
+            });
+        }));
+        const sink = await get("/feed.xml");
+        expect(sink.head?.statusCode).toBe(404);
+    });
+    it("forwards a Range and answers S3's 206", async () => {
+        send$.mockImplementation((async () => ({
+            Body: node_stream_1.Readable.from([Buffer.from("rss")]),
+            ContentLength: 3,
+            ContentRange: "bytes 1-3/6",
+            AcceptRanges: "bytes",
+        })));
+        const sink = await get("/feed.xml", { range: "bytes=1-3" });
+        expect(sink.head?.statusCode).toBe(206);
+        expect(sink.head?.headers["content-range"]).toBe("bytes 1-3/6");
+        expect(sink.head?.headers["accept-ranges"]).toBe("bytes");
+        expect(sink.body.toString("utf-8")).toBe("rss");
+        const command = send$.mock.calls[0][0];
+        expect(command.input.Range).toBe("bytes=1-3");
+    });
+    it("answers an unsatisfiable Range with a 416", async () => {
+        send$.mockImplementation((async () => {
+            throw Object.assign(new Error("InvalidRange"), {
+                name: "InvalidRange",
+                $metadata: { httpStatusCode: 416 },
+            });
+        }));
+        const sink = await get("/feed.xml", { range: "bytes=999-" });
+        expect(sink.head?.statusCode).toBe(416);
+        expect(sink.body.length).toBe(0);
+    });
+    // S3 can't evaluate If-Range, and ignoring Range is always allowed.
+    it("drops the Range when If-Range is present", async () => {
+        send$.mockImplementation((async () => ({
+            Body: node_stream_1.Readable.from([Buffer.from("<rss/>")]),
+        })));
+        const sink = await get("/feed.xml", {
+            range: "bytes=1-3",
+            "if-range": '"e1"',
+        });
+        expect(sink.head?.statusCode).toBe(200);
+        const command = send$.mock.calls[0][0];
+        expect(command.input.Range).toBeUndefined();
+    });
+    it("uses the object's own Cache-Control, as the edge serves it", async () => {
+        send$.mockImplementation((async () => ({
+            Body: node_stream_1.Readable.from([Buffer.from("<rss/>")]),
+            CacheControl: "public, max-age=3600",
+        })));
+        const sink = await get("/feed.xml");
+        expect(sink.head?.headers["cache-control"]).toBe("public, max-age=3600");
+    });
+    it("leaves an unlisted path to the app", async () => {
+        await get("/test.txt");
+        expect(send$).not.toHaveBeenCalled();
+    });
+});
+describe("revalidatedPageRoutes", () => {
+    const manifest = (i18n) => ({ buildId: "b1", config: { i18n } });
+    const i18n = { locales: ["en", "fr"], defaultLocale: "en" };
+    it("is the route and its data route without i18n", () => {
+        expect((0, core_1.revalidatedPageRoutes)("/blog", manifest(null))).toEqual([
+            ["/blog", "/_next/data/b1/blog.json"],
+        ]);
+        expect((0, core_1.revalidatedPageRoutes)("/", manifest(null))).toEqual([
+            ["/", "/_next/data/b1/index.json"],
+        ]);
+    });
+    // The Next client puts the locale in every data href, the default included.
+    it("puts the default locale in the data route, and invalidates both HTML spellings", () => {
+        expect((0, core_1.revalidatedPageRoutes)("/blog", manifest(i18n))).toEqual([
+            ["/blog", "/_next/data/b1/en/blog.json"],
+            ["/en/blog", "/_next/data/b1/en/blog.json"],
+        ]);
+        expect((0, core_1.revalidatedPageRoutes)("/en/blog", manifest(i18n))).toEqual([
+            ["/blog", "/_next/data/b1/en/blog.json"],
+            ["/en/blog", "/_next/data/b1/en/blog.json"],
+        ]);
+    });
+    it("names the root's data route after the locale", () => {
+        expect((0, core_1.revalidatedPageRoutes)("/", manifest(i18n))).toEqual([
+            ["/", "/_next/data/b1/en.json"],
+            ["/en", "/_next/data/b1/en.json"],
+        ]);
+        expect((0, core_1.revalidatedPageRoutes)("/fr", manifest(i18n))).toEqual([
+            ["/fr", "/_next/data/b1/fr.json"],
+        ]);
+    });
+    it("keeps another locale's page to its own prefix", () => {
+        expect((0, core_1.revalidatedPageRoutes)("/fr/blog", manifest(i18n))).toEqual([
+            ["/fr/blog", "/_next/data/b1/fr/blog.json"],
+        ]);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"core.test.js","sourceRoot":"","sources":["../../src/runtime/core.test.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\nimport {\n  mkdirSync,\n  mkdtempSync,\n  readFileSync,\n  realpathSync,\n  rmSync,\n  symlinkSync,\n  writeFileSync,\n} from \"node:fs\";\nimport { tmpdir } from \"node:os\";\nimport { dirname, join } from \"node:path\";\nimport { Readable, Writable } from \"node:stream\";\nimport { constants as zlibConstants, gunzipSync, gzipSync } from \"node:zlib\";\nimport { S3Client } from \"@aws-sdk/client-s3\";\nimport {\n  loadRuntime,\n  NextjsRuntime,\n  revalidatedPageRoutes,\n  RuntimeRequest,\n  splitBody,\n  withoutInternalHeaders,\n} from \"./core\";\nimport {\n  BuildCompleteContext,\n  buildAdapterManifest,\n} from \"../adapter/build-outputs\";\nimport { ShimIncomingMessage } from \"./http/request\";\nimport { ResponseHead } from \"./http/response\";\nimport { ResponseSink } from \"./http/sink\";\nimport {\n  AdapterManifest,\n  deployedManifestPath,\n  PUBLIC_FILES_FILE_NAME,\n  REVALIDATED_PAGE_HOOK,\n  RUNTIME_DIR_NAME,\n} from \"./manifest\";\nimport appPlayground from \"../adapter/__fixtures__/app-playground.json\";\n\n/**\n * Every entrypoint in the staged tree is this module. It reports back what the\n * runtime handed it — the rewritten `req.url`, the `requestMeta` fields Next.js\n * reads, the cwd — which is the whole contract between the runtime and a real\n * built entrypoint, and it is otherwise only observable by running Next.js.\n */\nconst ENTRYPOINT_STUB = `\nconst { writeFileSync } = require(\"node:fs\");\nexports.handler = async (req, res, ctx) => {\n  const url = new URL(req.url, \"https://stub.test\");\n  if (url.searchParams.has(\"boomEverywhere\")) {\n    throw new Error(\"the error page exploded too\");\n  }\n  // Same recursion guard as \\`render404\\` below: the error page is rendered for\n  // the URL that was asked for, so an unguarded throw would repeat forever.\n  if (url.searchParams.has(\"boom\") && !__filename.includes(\"_error\")) {\n    // A render that described its body before it threw.\n    res.setHeader(\"Content-Length\", \"1234\");\n    res.setHeader(\"ETag\", '\"stale\"');\n    // What \\`getServerSideProps\\` (or a \\`headers()\\` rule) can leave behind.\n    res.setHeader(\"Cache-Control\", \"s-maxage=60\");\n    throw new Error(\"route exploded\");\n  }\n  // What both routers do for \\`notFound()\\` they cannot render themselves. Only\n  // the route that gave up does it: the runtime renders the 404 against the\n  // *same* URL, so the not-found module reaching here again would recurse.\n  if (url.searchParams.has(\"render404\") && !__filename.includes(\"_not-found\")) {\n    await ctx.requestMeta.render404();\n    return;\n  }\n  // \\`res.revalidate(target)\\` from a Pages API route, spelled out: the runtime\n  // supplies \\`requestMeta.revalidate\\`, and what comes back is either nothing or\n  // the \\`Invalid response <status>\\` this reports.\n  if (url.searchParams.has(\"revalidate\")) {\n    let error = null;\n    try {\n      await ctx.requestMeta.revalidate({\n        urlPath: url.searchParams.get(\"revalidate\"),\n        headers: { \"x-prerender-revalidate\": \"preview-id\" },\n        opts: { unstable_onlyGenerated: url.searchParams.has(\"onlyGenerated\") },\n      });\n    } catch (err) {\n      error = err.message;\n    }\n    res.end(JSON.stringify({ revalidated: error === null, error }));\n    return;\n  }\n  // Lets a test see the request a revalidation rendered, whose response the\n  // runtime discards.\n  if (url.searchParams.has(\"recordOrigin\")) {\n    writeFileSync(process.env.CDK_NEXTJS_TEST_MARKER, ctx.requestMeta.initURL);\n  }\n  // Lets a revalidation target answer something other than 200.\n  if (url.searchParams.has(\"status\")) {\n    res.statusCode = Number(url.searchParams.get(\"status\"));\n  }\n  // What a prerendered \\`/_not-found\\` does: it sends the Cache-Control of its\n  // own cache entry, a year for one that never revalidates — but only when the\n  // response has none yet, as \\`sendRenderResult\\` and \\`pages-handler.js\\` do.\n  if (url.searchParams.has(\"cacheControl\") && !res.getHeader(\"Cache-Control\")) {\n    res.setHeader(\"Cache-Control\", url.searchParams.get(\"cacheControl\"));\n  }\n  // A route that reads its request body, reporting what arrived.\n  if (url.searchParams.has(\"readBody\")) {\n    let length = 0;\n    for await (const chunk of req) length += chunk.length;\n    res.end(JSON.stringify({ bodyLength: length }));\n    return;\n  }\n  // A Pages API route that returns before it is done writing: what\n  // \\`stream.pipe(res)\\` and a callback-style \\`res.json()\\` both look like.\n  if (url.searchParams.has(\"endLater\")) {\n    res.setHeader(\"Content-Type\", \"text/plain; charset=utf-8\");\n    res.write(\"first,\");\n    setTimeout(() => res.end(\"second\"), 10);\n    return;\n  }\n  // What Next's \\`AfterContext\\` does: work registered with \\`waitUntil\\` after\n  // the response, from inside work that was itself registered with it.\n  if (url.searchParams.has(\"lateWaitUntil\")) {\n    ctx.waitUntil(\n      new Promise((resolve) =>\n        setTimeout(() => {\n          ctx.waitUntil(\n            new Promise((resolveLate) =>\n              setTimeout(() => {\n                writeFileSync(process.env.CDK_NEXTJS_TEST_MARKER, \"late\");\n                resolveLate();\n              }, 10),\n            ),\n          );\n          resolve();\n        }, 10),\n      ),\n    );\n  }\n  if (url.searchParams.has(\"waitUntil\")) {\n    ctx.waitUntil(\n      new Promise((resolve) =>\n        setTimeout(() => {\n          writeFileSync(process.env.CDK_NEXTJS_TEST_MARKER, \"done\");\n          resolve();\n        }, 10),\n      ),\n    );\n  }\n  res.setHeader(\"Content-Type\", \"text/html; charset=utf-8\");\n  res.end(\n    JSON.stringify({\n      file: __filename,\n      url: req.url,\n      initURL: ctx.requestMeta && ctx.requestMeta.initURL,\n      hostname: ctx.requestMeta && ctx.requestMeta.hostname,\n      query: ctx.requestMeta && ctx.requestMeta.query,\n      params: (ctx.requestMeta && ctx.requestMeta.params) || null,\n      hasRender404: Boolean(ctx.requestMeta && ctx.requestMeta.render404),\n      waitUntil: typeof ctx.waitUntil,\n      cwd: process.cwd(),\n      header: req.headers[\"x-from-middleware\"] || null,\n      nextResume: req.headers[\"next-resume\"] || null,\n      matchedPath: req.headers[\"x-matched-path\"] || null,\n      cookie: req.headers.cookie || null,\n    }),\n  );\n};\n`;\n\n/**\n * `NextResponse.next({ request: { headers } })`, spelled out in the wire protocol\n * Next.js uses: `x-middleware-override-headers` lists *every* request header the\n * route should see — dropping one here is how a real app loses `accept-encoding`.\n */\nconst MIDDLEWARE_STUB = `\nexports.handler = async (request) => {\n  const headers = new Headers({ \"x-middleware-next\": \"1\" });\n  const names = [];\n  request.headers.forEach((value, name) => {\n    names.push(name);\n    headers.set(\"x-middleware-request-\" + name, value);\n  });\n  names.push(\"x-from-middleware\");\n  headers.set(\"x-middleware-request-x-from-middleware\", \"yes\");\n  headers.set(\"x-middleware-override-headers\", names.join(\",\"));\n  return new Response(null, { headers });\n};\n`;\n\nclass CollectingSink implements ResponseSink {\n  public head?: ResponseHead;\n  public readonly chunks: Buffer[] = [];\n\n  public constructor(public readonly padEmptyBody = false) {}\n\n  public begin(head: ResponseHead): Writable {\n    this.head = head;\n    const chunks = this.chunks;\n    return new Writable({\n      write(chunk, _encoding, callback) {\n        chunks.push(Buffer.from(chunk));\n        callback();\n      },\n    });\n  }\n\n  public get body(): Buffer {\n    return Buffer.concat(this.chunks);\n  }\n}\n\nfunction write(path: string, contents: string | Buffer): void {\n  mkdirSync(dirname(path), { recursive: true });\n  writeFileSync(path, contents);\n}\n\nconst FAVICON = Buffer.from(\"00000100-fake-icon\", \"utf-8\");\nconst NOT_FOUND_HTML = \"<html><body>prerendered 404</body></html>\";\nconst ERROR_HTML = \"<html><body>prerendered 500</body></html>\";\n/**\n * What a container image copies into `public/`. Names `send` and the exact\n * match in `@next/routing` each got wrong: a `%` that is not an escape, one that\n * looks like one next to the file it decodes to, and an `@` a browser leaves\n * alone.\n */\nconst PUBLIC_FILES: Record<string, string> = {\n  \"test.txt\": \"hello from public\",\n  \"100%.png\": \"a literal percent\",\n  \"a%20b.txt\": \"the file named with a percent\",\n  \"a b.txt\": \"the file named with a space\",\n  \"images/logo@2x.png\": \"at sign\",\n};\n\n/**\n * Materializes the tree a deployment stages: the manifest under\n * `cdk-nextjs-runtime/`, a stub at every entrypoint `filePath`, the static files\n * the manifest points at, and the `required-server-files.json` `loadRuntime`\n * probes for.\n */\nfunction stageDeployment(\n  middlewareSource = MIDDLEWARE_STUB,\n  transformManifest: (manifest: AdapterManifest) => AdapterManifest = (it) =>\n    it,\n): string {\n  // The fixture is a real captured context, as JSON: the structural cast is the\n  // point of the cast (see `build-outputs.test.ts`).\n  const ctx = structuredClone(appPlayground) as unknown as BuildCompleteContext;\n  const manifest = transformManifest(\n    buildAdapterManifest(ctx, { buildCwd: ctx.projectDir }).manifest,\n  );\n  // Realpath because `loadRuntime` chdirs, and macOS's /var is a symlink to\n  // /private/var: the cwd the entrypoints report would not match otherwise.\n  const root = realpathSync(mkdtempSync(join(tmpdir(), \"cdk-nextjs-core-\")));\n\n  write(deployedManifestPath(root), JSON.stringify(manifest));\n  write(\n    join(root, manifest.relativeProjectDir, \".next/required-server-files.json\"),\n    JSON.stringify({ version: 1, config: {} }),\n  );\n  // A deployed tree carries the `next` closure `next build` traced, under the\n  // *project* dir rather than next to the runtime shell — which is the whole\n  // reason `next-modules.ts` exists. Linking this repo's own `node_modules` in\n  // reproduces that, so `serveStatic` here resolves by the same walk it does in\n  // Lambda instead of the test quietly exercising a different lookup.\n  symlinkSync(\n    join(__dirname, \"../../node_modules\"),\n    join(root, manifest.relativeProjectDir, \"node_modules\"),\n  );\n\n  for (const entrypoint of Object.values(manifest.entrypoints)) {\n    write(join(root, entrypoint.filePath), ENTRYPOINT_STUB);\n  }\n  write(join(root, manifest.middleware!.filePath), middlewareSource);\n\n  write(join(root, manifest.staticFiles[\"/favicon.ico\"]), FAVICON);\n  // Absent in the deployments the Pages 404 and error-page ladder tests stage.\n  if (manifest.staticFiles[\"/404\"]) {\n    write(join(root, manifest.staticFiles[\"/404\"]), NOT_FOUND_HTML);\n  }\n  if (manifest.staticFiles[\"/500\"]) {\n    write(join(root, manifest.staticFiles[\"/500\"]), ERROR_HTML);\n  }\n  for (const [file, contents] of Object.entries(PUBLIC_FILES)) {\n    write(join(root, manifest.relativeProjectDir, \"public\", file), contents);\n  }\n  // Async on purpose: `loadRuntime` has to await `register()`, not just call it.\n  write(\n    join(root, manifest.relativeProjectDir, \".next/server/instrumentation.js\"),\n    \"exports.register = () => new Promise((resolve) => setTimeout(() => {\" +\n      \" process.env.CDK_NEXTJS_TEST_REGISTERED = 'yes'; resolve(); }, 10));\\n\",\n  );\n  // `.env` rather than `.env.production`: `@next/env` picks the mode from\n  // NODE_ENV, which jest sets to \"test\".\n  write(\n    join(root, manifest.relativeProjectDir, \".env\"),\n    \"CDK_NEXTJS_TEST_FROM_ENV_FILE=from-file\\nCDK_NEXTJS_TEST_SET_BY_LAMBDA=from-file\\n\",\n  );\n  return root;\n}\n\nlet root: string;\nlet runtime: NextjsRuntime;\nconst originalCwd = process.cwd();\n\nbeforeAll(async () => {\n  jest.spyOn(console, \"warn\").mockImplementation(() => {});\n  process.env.CDK_NEXTJS_TEST_SET_BY_LAMBDA = \"from-lambda\";\n  root = stageDeployment();\n  // `loadRuntime` chdirs, which is the point of it.\n  runtime = await loadRuntime(root);\n});\n\nafterAll(() => {\n  process.chdir(originalCwd);\n  jest.restoreAllMocks();\n});\n\n/** One request through the real `handle`, with the response collected. */\nasync function send(\n  request: Partial<RuntimeRequest> & { url: string },\n  padEmptyBody = false,\n): Promise<CollectingSink> {\n  const sink = new CollectingSink(padEmptyBody);\n  await runtime.handle(\n    {\n      method: \"GET\",\n      headers: { host: \"shop.example.test\" },\n      ...request,\n    },\n    sink,\n  );\n  return sink;\n}\n\n/** The JSON an entrypoint stub answers with. */\nfunction stubBody(sink: CollectingSink): Record<string, unknown> {\n  const encoding = sink.head?.headers[\"content-encoding\"];\n  const body = encoding === \"gzip\" ? gunzipSync(sink.body) : sink.body;\n  return JSON.parse(body.toString(\"utf-8\"));\n}\n\ndescribe(\"loadRuntime\", () => {\n  it(\"chdirs to the staged project dir, because entrypoints resolve against cwd\", () => {\n    expect(process.cwd()).toBe(join(root, \"app-playground\"));\n  });\n\n  it(\"loads the staged env files the way next start does, without overriding the function's environment\", () => {\n    expect(process.env.CDK_NEXTJS_TEST_FROM_ENV_FILE).toBe(\"from-file\");\n    expect(process.env.CDK_NEXTJS_TEST_SET_BY_LAMBDA).toBe(\"from-lambda\");\n  });\n\n  it(\"awaits instrumentation register() before any entrypoint or middleware loads, as next start does\", () => {\n    // Module-scope code in middleware and entrypoints reads what `register()`\n    // sets (#279), and nothing is loaded until `loadRuntime` has returned.\n    expect(process.env.CDK_NEXTJS_TEST_REGISTERED).toBe(\"yes\");\n  });\n\n  it(\"explains a deployment package with no manifest\", async () => {\n    const empty = mkdtempSync(join(tmpdir(), \"cdk-nextjs-empty-\"));\n    await expect(loadRuntime(empty)).rejects.toThrow(\n      /Could not read the cdk-nextjs adapter manifest/,\n    );\n  });\n\n  it(\"explains a deployment package missing the staged project\", async () => {\n    const partial = mkdtempSync(join(tmpdir(), \"cdk-nextjs-partial-\"));\n    write(\n      deployedManifestPath(partial),\n      readFileSync(deployedManifestPath(root), \"utf-8\"),\n    );\n    await expect(loadRuntime(partial)).rejects.toThrow(\n      /does not contain the staged Next.js project/,\n    );\n  });\n});\n\ndescribe(\"NextjsRuntime.handle\", () => {\n  it(\"invokes the matched entrypoint with the requestMeta Next.js reads\", async () => {\n    const sink = await send({ url: \"/\" });\n    expect(sink.head?.statusCode).toBe(200);\n    const body = stubBody(sink);\n    expect(body.file).toBe(\n      join(root, \"app-playground/.next/server/app/page.js\"),\n    );\n    expect(body.url).toBe(\"/\");\n    // Without `initURL`, `RouteModule.prepare` falls back to `http://localhost`.\n    expect(body.initURL).toBe(\"https://shop.example.test/\");\n    expect(body.hostname).toBe(\"shop.example.test\");\n    expect(body.hasRender404).toBe(true);\n    expect(body.waitUntil).toBe(\"function\");\n    expect(body.cwd).toBe(join(root, \"app-playground\"));\n  });\n\n  it(\"trusts x-forwarded-host over the host CloudFront rewrote, when the shell says to\", async () => {\n    const sink = await send({\n      url: \"/\",\n      headers: {\n        host: \"origin.cloudfront.internal\",\n        \"x-forwarded-host\": \"www.example.test\",\n      },\n      trustForwardedHost: true,\n    });\n    expect(stubBody(sink).initURL).toBe(\"https://www.example.test/\");\n  });\n\n  // Only the CloudFront function in front of *function* compute overwrites this\n  // header, so on Containers and the Regional types it arrives from the client:\n  // honoring it let `X-Forwarded-Host: evil.example` point every absolute URL\n  // the app built, a password-reset link say, at evil.example.\n  it(\"ignores x-forwarded-host unless the shell trusts it, like next start\", async () => {\n    const sink = await send({\n      url: \"/\",\n      headers: {\n        host: \"shop.example.test\",\n        \"x-forwarded-host\": \"evil.example\",\n      },\n    });\n    expect(stubBody(sink).initURL).toBe(\"https://shop.example.test/\");\n    expect(stubBody(sink).hostname).toBe(\"shop.example.test\");\n  });\n\n  // A value that cannot be a URL authority made `new URL` throw, and on the\n  // Lambda shells — whose handlers wrap nothing — that is an invocation error and\n  // a 502 rather than a response.\n  it.each([\n    [\"a space\", \"exa mple.test\"],\n    [\"a scheme\", \"https://www.example.test\"],\n    [\"a path\", \"www.example.test/evil\"],\n    [\"credentials\", \"user@www.example.test\"],\n    [\"nothing\", \"\"],\n  ])(\n    \"ignores an x-forwarded-host containing %s and falls back to host\",\n    async (_label, forwarded) => {\n      const sink = await send({\n        url: \"/\",\n        headers: {\n          host: \"shop.example.test\",\n          \"x-forwarded-host\": forwarded,\n        },\n        trustForwardedHost: true,\n      });\n      expect(sink.head?.statusCode).toBe(200);\n      expect(stubBody(sink).initURL).toBe(\"https://shop.example.test/\");\n    },\n  );\n\n  // Multiple proxies each append, and only the first value is this hop's.\n  it(\"takes the first value of a comma-joined x-forwarded-host\", async () => {\n    const sink = await send({\n      url: \"/\",\n      headers: {\n        host: \"origin.cloudfront.internal\",\n        \"x-forwarded-host\": \"www.example.test, inner.example.test\",\n      },\n      trustForwardedHost: true,\n    });\n    expect(stubBody(sink).initURL).toBe(\"https://www.example.test/\");\n  });\n\n  it(\"ignores an x-forwarded-proto that is not http or https\", async () => {\n    const sink = await send({\n      url: \"/\",\n      headers: {\n        host: \"shop.example.test\",\n        \"x-forwarded-proto\": \"javascript\",\n      },\n    });\n    expect(stubBody(sink).initURL).toBe(\"https://shop.example.test/\");\n  });\n\n  it(\"hands a dynamic route its params as nxtP query values\", async () => {\n    const sink = await send({ url: \"/isr/42\" });\n    const body = stubBody(sink);\n    expect(body.file).toBe(\n      join(root, \"app-playground/.next/server/app/isr/[id]/page.js\"),\n    );\n    // The documented deployed-proxy contract: `prepare()` recovers `params`\n    // from these, which is why `requestMeta.params` is left unset.\n    expect(body.url).toBe(\"/isr/42?nxtPid=42\");\n    expect(body.query).toEqual({ nxtPid: \"42\" });\n    expect(body.params).toBeNull();\n  });\n\n  it(\"hands over a capture with an encoded delimiter as requestMeta.params\", async () => {\n    // The one exception to the contract above, because two decodes and a split\n    // would turn this into three params and make `normalizePagePath` throw; see\n    // `outOfBandRouteParams`. The `nxtP` value has to *leave* the query — and\n    // therefore the URL — or `prepare` prefers it and the split is back.\n    const sink = await send({ url: \"/isr/a%2Fb\" });\n    const body = stubBody(sink);\n    expect(body.url).toBe(\"/isr/a%2Fb\");\n    expect(body.query).toEqual({});\n    expect(body.params).toEqual({ id: \"a/b\" });\n  });\n\n  it(\"runs middleware and applies the request headers it overrode\", async () => {\n    const sink = await send({ url: \"/\" });\n    expect(stubBody(sink).header).toBe(\"yes\");\n  });\n\n  it(\"serves a static file out of the staged tree\", async () => {\n    const sink = await send({ url: \"/favicon.ico\" });\n    expect(sink.head?.statusCode).toBe(200);\n    expect(sink.body).toEqual(FAVICON);\n    // Typed from the route's extension, not the file's: a static metadata route\n    // is staged as `favicon.ico.body`, and `.body` is not a media type. See\n    // `setBodyFileContentType` in static-files.ts.\n    expect(sink.head?.headers[\"content-type\"]).toBe(\"image/x-icon\");\n  });\n\n  it(\"serves public/ off disk, under the name the file actually has\", async () => {\n    const body = async (url: string) => {\n      const sink = await send({ url });\n      expect(sink.head?.statusCode).toBe(200);\n      return sink.body.toString(\"utf-8\");\n    };\n    expect(await body(\"/test.txt\")).toBe(\"hello from public\");\n    // `send` decodes the path it is given, so a raw filesystem path failed to\n    // decode (`100%.png`, an empty 400) or decoded to another file.\n    expect(await body(\"/100%25.png\")).toBe(\"a literal percent\");\n    expect(await body(\"/a%2520b.txt\")).toBe(\"the file named with a percent\");\n    expect(await body(\"/a%20b.txt\")).toBe(\"the file named with a space\");\n    // Both ways a link can spell it.\n    expect(await body(\"/images/logo@2x.png\")).toBe(\"at sign\");\n    expect(await body(\"/images/logo%402x.png\")).toBe(\"at sign\");\n  });\n\n  it(\"answers 405 to a public/ file requested with a method other than GET\", async () => {\n    // `send` serves any method; `next start` does not.\n    const sink = await send({ url: \"/test.txt\", method: \"DELETE\" });\n    expect(sink.head?.statusCode).toBe(405);\n    expect(sink.head?.headers.allow).toBe(\"GET, HEAD\");\n    expect(sink.body.toString(\"utf-8\")).not.toContain(\"hello from public\");\n  });\n\n  it(\"answers an unknown path through the /_not-found entrypoint\", async () => {\n    const sink = await send({ url: \"/nope?q=1\" });\n    expect(sink.head?.statusCode).toBe(404);\n    expect(stubBody(sink).file).toBe(\n      join(root, \"app-playground/.next/server/app/_not-found/page.js\"),\n    );\n    // The requested path, not `/_not-found`: the App Router puts this in the RSC\n    // payload as the canonical URL, so rendering the module against its own\n    // pathname would hand the client the wrong `usePathname()` and history entry.\n    expect(stubBody(sink).url).toBe(\"/nope?q=1\");\n  });\n\n  it(\"answers an unknown path no-store, whatever the /_not-found entry sends\", async () => {\n    // A prerendered `/_not-found` is a cache HIT with a year-long `s-maxage`,\n    // and the CDN would keep this 404 for that long — past the deploy that adds\n    // the route. `next start` answers an unmatched path no-store.\n    const sink = await send({\n      url: `/nope?cacheControl=${encodeURIComponent(\"s-maxage=31536000\")}`,\n    });\n    expect(sink.head?.statusCode).toBe(404);\n    expect(sink.head?.headers[\"cache-control\"]).toBe(\n      \"private, no-cache, no-store, max-age=0, must-revalidate\",\n    );\n  });\n\n  it(\"renders the 404 page when a route calls requestMeta.render404()\", async () => {\n    const sink = await send({ url: \"/?render404=1\" });\n    expect(sink.head?.statusCode).toBe(404);\n    // Whatever the route that gave up was rendering, for the same reason.\n    expect(stubBody(sink).url).toBe(\"/?render404=1\");\n  });\n\n  it(\"leaves a render404() 404 the Cache-Control its route gave it\", async () => {\n    // `notFound()` from an ISR page is a cacheable result of that page, kept for\n    // its revalidate period, so the no-store for unmatched paths must not\n    // reach it.\n    const sink = await send({\n      url: `/?render404=1&cacheControl=${encodeURIComponent(\"s-maxage=60\")}`,\n    });\n    expect(sink.head?.statusCode).toBe(404);\n    expect(sink.head?.headers[\"cache-control\"]).toBe(\"s-maxage=60\");\n  });\n\n  it(\"runs requestMeta.revalidate() against itself, not over the network\", async () => {\n    const sink = await send({ url: \"/?revalidate=%2F\" });\n    expect(sink.head?.statusCode).toBe(200);\n    expect(stubBody(sink)).toEqual({ revalidated: true, error: null });\n  });\n\n  it(\"renders a revalidation for the public origin the caller was served on\", async () => {\n    const marker = join(root, \"revalidate-origin-marker\");\n    process.env.CDK_NEXTJS_TEST_MARKER = marker;\n    try {\n      await send({\n        url: \"/?revalidate=%2F%3FrecordOrigin%3D1\",\n        headers: {\n          host: \"abc123.lambda-url.us-east-1.on.aws\",\n          \"x-forwarded-host\": \"shop.example.test\",\n          \"x-forwarded-proto\": \"https\",\n        },\n        trustForwardedHost: true,\n      });\n      expect(readFileSync(marker, \"utf-8\")).toBe(\n        \"https://shop.example.test/?recordOrigin=1\",\n      );\n    } finally {\n      delete process.env.CDK_NEXTJS_TEST_MARKER;\n    }\n  });\n\n  it(\"fails a revalidation whose target did not answer 200\", async () => {\n    const sink = await send({ url: \"/?revalidate=%2F%3Fstatus%3D500\" });\n    expect(stubBody(sink)).toEqual({\n      revalidated: false,\n      error: \"Invalid response 500\",\n    });\n  });\n\n  describe(\"invalidating the CDN copy of a revalidated page\", () => {\n    const hookKey = REVALIDATED_PAGE_HOOK;\n    const globals = globalThis as Record<symbol, unknown>;\n    afterEach(() => {\n      delete globals[hookKey];\n    });\n\n    it(\"hands the cache handler's hook the page and its _next/data route\", async () => {\n      const hook = jest.fn(async () => {});\n      globals[hookKey] = hook;\n      await send({ url: \"/?revalidate=%2Fisr%2F42\" });\n      expect(hook).toHaveBeenCalledTimes(1);\n      expect(hook).toHaveBeenCalledWith([\n        \"/isr/42\",\n        `/_next/data/${runtime.manifest.buildId}/isr/42.json`,\n      ]);\n    });\n\n    it(\"names the root's data route index.json\", async () => {\n      const hook = jest.fn(async () => {});\n      globals[hookKey] = hook;\n      await send({ url: \"/?revalidate=%2F\" });\n      expect(hook).toHaveBeenCalledWith([\n        \"/\",\n        `/_next/data/${runtime.manifest.buildId}/index.json`,\n      ]);\n    });\n\n    it(\"invalidates nothing when the revalidation failed\", async () => {\n      const hook = jest.fn(async () => {});\n      globals[hookKey] = hook;\n      await send({ url: \"/?revalidate=%2F%3Fstatus%3D500\" });\n      expect(hook).not.toHaveBeenCalled();\n    });\n\n    it(\"still reports success when the invalidation fails\", async () => {\n      const warn = jest.spyOn(console, \"warn\").mockImplementation(() => {});\n      globals[hookKey] = async () => {\n        throw new Error(\"TooManyInvalidationsInProgress\");\n      };\n      const sink = await send({ url: \"/?revalidate=%2F\" });\n      expect(stubBody(sink)).toEqual({ revalidated: true, error: null });\n      warn.mockRestore();\n    });\n  });\n\n  it(\"strips the internal headers next start does not honor from a client\", async () => {\n    const sink = await send({\n      url: \"/\",\n      headers: {\n        host: \"shop.example.test\",\n        \"next-resume\": \"1\",\n        \"x-matched-path\": \"/admin\",\n      },\n    });\n    expect(stubBody(sink)).toMatchObject({\n      nextResume: null,\n      matchedPath: null,\n    });\n  });\n\n  const images = () =>\n    (\n      runtime as unknown as {\n        images: {\n          options: {\n            fetchInternal: (\n              href: string,\n              req: ShimIncomingMessage,\n              maximumBody: number,\n            ) => Promise<{\n              statusCode: number;\n              headers: Record<string, unknown>;\n              body: Buffer;\n              tooLarge?: boolean;\n            }>;\n          };\n        };\n      }\n    ).images;\n\n  it(\"fetches an image source from a route handler, in process and without cookies\", async () => {\n    const viewer = new ShimIncomingMessage({\n      method: \"GET\",\n      url: \"/_next/image?url=%2Fapi%2Fhealth%3Favatar%3D42&w=64&q=75\",\n      headers: { host: \"shop.example.test\", cookie: \"session=secret\" },\n    });\n    const response = await images().options.fetchInternal(\n      \"/api/health?avatar=42\",\n      viewer,\n      Infinity,\n    );\n    expect(response.statusCode).toBe(200);\n    const body = JSON.parse(response.body.toString(\"utf-8\"));\n    expect(body.file).toContain(\"api/health\");\n    expect(body.url).toBe(\"/api/health?avatar=42\");\n    expect(body.initURL).toBe(\"https://shop.example.test/api/health?avatar=42\");\n    expect(body.cookie).toBeNull();\n  });\n\n  // `images.maximumResponseBody`: a route streaming a large body must not be\n  // buffered whole, as `next start`'s `fetchInternalImage` does not.\n  it(\"stops reading an image source route past maximumResponseBody\", async () => {\n    const error = jest.spyOn(console, \"error\").mockImplementation(() => {});\n    try {\n      const response = await images().options.fetchInternal(\n        \"/api/health?avatar=42\",\n        new ShimIncomingMessage({\n          method: \"GET\",\n          url: \"/_next/image?url=%2Fapi%2Fhealth%3Favatar%3D42&w=64&q=75\",\n          headers: { host: \"shop.example.test\" },\n        }),\n        10,\n      );\n      expect(response.tooLarge).toBe(true);\n      expect(response.body.length).toBe(0);\n    } finally {\n      error.mockRestore();\n    }\n  });\n\n  it(\"redirects a trailing slash, with the Refresh fallback for a 308\", async () => {\n    const sink = await send({ url: \"/isr/42/\" });\n    expect(sink.head?.statusCode).toBe(308);\n    expect(sink.head?.headers.location).toBe(\"/isr/42\");\n    expect(sink.head?.headers.refresh).toBe(\"0;url=/isr/42\");\n    expect(sink.body.toString(\"utf-8\")).toBe(\"/isr/42\");\n  });\n\n  it(\"gzips a streamed HTML response for a client that accepts it\", async () => {\n    const sink = await send({\n      url: \"/\",\n      headers: { host: \"shop.example.test\", \"accept-encoding\": \"gzip\" },\n    });\n    expect(sink.head?.headers[\"content-encoding\"]).toBe(\"gzip\");\n    expect(gunzipSync(sink.body).toString(\"utf-8\")).toContain(\"initURL\");\n  });\n\n  it(\"awaits waitUntil work before resolving, since Lambda freezes on return\", async () => {\n    const marker = join(root, \"waituntil-marker\");\n    process.env.CDK_NEXTJS_TEST_MARKER = marker;\n    try {\n      await send({ url: \"/?waitUntil=1\" });\n      // Written by a timer the entrypoint registered, after the response ended.\n      expect(readFileSync(marker, \"utf-8\")).toBe(\"done\");\n    } finally {\n      delete process.env.CDK_NEXTJS_TEST_MARKER;\n    }\n  });\n\n  it(\"serves the prerendered 500 when an entrypoint throws before sending a head\", async () => {\n    const error = jest.spyOn(console, \"error\").mockImplementation(() => {});\n    const sink = await send({ url: \"/?boom=1\" });\n    expect(sink.head?.statusCode).toBe(500);\n    expect(sink.body.toString(\"utf-8\")).toBe(ERROR_HTML);\n    // A `Cache-Control` the render that threw had already set would otherwise\n    // stay on the response and get the 500 cached at the edge.\n    expect(sink.head?.headers[\"cache-control\"]).toBe(\n      \"private, no-cache, no-store, max-age=0, must-revalidate\",\n    );\n    expect(error).toHaveBeenCalledWith(\n      \"Unhandled error while handling the request:\",\n      expect.objectContaining({ message: expect.stringContaining(\"exploded\") }),\n    );\n    error.mockRestore();\n  });\n\n  it(\"streams middleware's own Response when it answers the request\", async () => {\n    // A second deployment, because the middleware module is memoized per runtime.\n    const responding = await loadRuntime(\n      stageDeployment(`\nexports.handler = async () =>\n  new Response(\"denied\", {\n    status: 401,\n    statusText: \"Unauthorized\",\n    headers: [\n      [\"content-type\", \"text/plain\"],\n      [\"set-cookie\", \"sid=; Path=/; expires=Thu, 01 Jan 1970 00:00:00 GMT\"],\n      [\"set-cookie\", \"flag=1; Path=/\"],\n    ],\n  });\n`),\n    );\n    const sink = new CollectingSink();\n    await responding.handle(\n      { method: \"GET\", url: \"/\", headers: { host: \"shop.example.test\" } },\n      sink,\n    );\n    // `resolveRoutes` only reports that middleware responded; the body comes\n    // back from the invoker, on the `middleware-responded` result.\n    expect(sink.head?.statusCode).toBe(401);\n    expect(sink.head?.statusMessage).toBe(\"Unauthorized\");\n    expect(sink.head?.cookies).toEqual([\n      \"sid=; Path=/; expires=Thu, 01 Jan 1970 00:00:00 GMT\",\n      \"flag=1; Path=/\",\n    ]);\n    expect(sink.body.toString(\"utf-8\")).toBe(\"denied\");\n  });\n\n  it(\"answers a missing build asset no-store, not under its immutable rule\", async () => {\n    // In the manifest but not on disk — `stageDeployment` writes no chunks, the\n    // way a Lambda package ships none (they are on S3 behind CloudFront).\n    const sink = await send({ url: \"/_next/static/chunks/0-qsb3zz6f4c7.js\" });\n    expect(sink.head?.statusCode).toBe(404);\n    expect(sink.head?.headers[\"cache-control\"]).toBe(\n      \"private, no-cache, no-store, max-age=0, must-revalidate\",\n    );\n  });\n\n  // `next start` answers these without rendering the 404 page (`router-server.js`,\n  // the \"404 case\"): nothing would display it, and rendering is the cost.\n  it.each([\n    [\"a missing build asset\", \"/_next/static/chunks/0-qsb3zz6f4c7.js\"],\n    [\"a build asset no deploy produced\", \"/_next/static/chunks/stale-0000.js\"],\n  ])(\"answers %s with a plain-text Not Found\", async (_name, url) => {\n    const sink = await send({ url });\n    expect(sink.head?.statusCode).toBe(404);\n    expect(sink.head?.headers[\"content-type\"]).toBe(\n      \"text/plain; charset=utf-8\",\n    );\n    expect(sink.head?.headers[\"cache-control\"]).toBe(\n      \"private, no-cache, no-store, max-age=0, must-revalidate\",\n    );\n    expect(sink.body.toString(\"utf-8\")).toBe(\"Not Found\");\n  });\n\n  it.each([\"image\", \"script\", \"font\", \"style\"])(\n    \"answers an unknown path fetched as a %s subresource with a plain-text Not Found\",\n    async (dest) => {\n      const sink = await send({\n        url: \"/nope.png\",\n        headers: { host: \"shop.example.test\", \"sec-fetch-dest\": dest },\n      });\n      expect(sink.head?.statusCode).toBe(404);\n      expect(sink.head?.headers[\"cache-control\"]).toBe(\n        \"private, no-cache, no-store, max-age=0, must-revalidate\",\n      );\n      expect(sink.body.toString(\"utf-8\")).toBe(\"Not Found\");\n    },\n  );\n\n  it.each([\n    // A navigation, and `fetch()` — which is how an RSC request goes.\n    [\"a document\", \"GET\", \"document\"],\n    [\"a fetch\", \"GET\", \"empty\"],\n    // `next start` only short-circuits GET and HEAD.\n    [\"an image POST\", \"POST\", \"image\"],\n  ])(\"still renders the 404 page for %s\", async (_name, method, dest) => {\n    const sink = await send({\n      url: \"/nope\",\n      method,\n      headers: { host: \"shop.example.test\", \"sec-fetch-dest\": dest },\n    });\n    expect(sink.head?.statusCode).toBe(404);\n    expect(stubBody(sink).file).toContain(\"_not-found\");\n  });\n\n  it(\"settles and destroys the response when the sink cannot take the head\", async () => {\n    const error = jest.spyOn(console, \"error\").mockImplementation(() => {});\n    // What the Lambda sink's `writeHead` does with a header value it rejects.\n    const handled = runtime.handle(\n      { method: \"GET\", url: \"/\", headers: { host: \"shop.example.test\" } },\n      {\n        begin() {\n          throw new TypeError(\"Invalid character in header content\");\n        },\n      },\n    );\n    await expect(handled).resolves.toBeUndefined();\n    expect(error).toHaveBeenCalledWith(\n      \"The response stream did not complete:\",\n      expect.objectContaining({ message: expect.stringContaining(\"header\") }),\n    );\n    error.mockRestore();\n  });\n\n  it(\"streams an upload through middleware to the route intact\", async () => {\n    const chunk = Buffer.alloc(64 * 1024, 1);\n    const sink = await send({\n      url: \"/?readBody=1\",\n      method: \"POST\",\n      body: Readable.from(Array.from({ length: 32 }, () => chunk)),\n    });\n    expect(stubBody(sink)).toEqual({ bodyLength: 32 * chunk.length });\n  });\n\n  // The Lambda shell's body: already in memory, as a Buffer.\n  it(\"passes a Buffer upload through middleware to the route intact\", async () => {\n    const body = Buffer.alloc(1024 * 1024, 1);\n    const sink = await send({ url: \"/?readBody=1\", method: \"POST\", body });\n    expect(stubBody(sink)).toEqual({ bodyLength: body.length });\n  });\n\n  it(\"reads middleware's body only as fast as the client takes it\", async () => {\n    const pulls = { count: 0 };\n    (globalThis as Record<string, unknown>).__cdkNextjsPulls = pulls;\n    const streaming = await loadRuntime(\n      stageDeployment(`\nexports.handler = async () =>\n  new Response(\n    new ReadableStream({\n      pull(controller) {\n        const pulls = globalThis.__cdkNextjsPulls;\n        pulls.count += 1;\n        if (pulls.count > 1000) controller.close();\n        else controller.enqueue(new Uint8Array(16 * 1024));\n      },\n    }),\n  );\n`),\n    );\n    // A client that takes nothing until released.\n    let release: (() => void) | undefined;\n    const blocked = new Promise<void>((resolve) => (release = resolve));\n    const sink: ResponseSink = {\n      begin: () =>\n        new Writable({\n          write(_chunk, _encoding, callback) {\n            void blocked.then(() => callback());\n          },\n        }),\n    };\n    const handled = streaming.handle(\n      { method: \"GET\", url: \"/\", headers: { host: \"shop.example.test\" } },\n      sink,\n    );\n    await new Promise((resolve) => setTimeout(resolve, 100));\n    // 1000 chunks are 16 MiB; a few highWaterMarks' worth is all that may be\n    // buffered for a client that is not reading.\n    expect(pulls.count).toBeLessThan(50);\n    release!();\n    await handled;\n    expect(pulls.count).toBe(1001);\n  });\n\n  it(\"pads an empty body when the shell asks, so API Gateway does not 502\", async () => {\n    const sink = await send(\n      {\n        url: \"/\",\n        headers: { host: \"shop.example.test\", \"if-none-match\": \"x\" },\n      },\n      true,\n    );\n    // A real 304 is not reachable through a stub entrypoint, so this only\n    // asserts the padding does not corrupt a normal body.\n    expect(sink.body.length).toBeGreaterThan(1);\n  });\n\n  it(\"emits each cookie middleware set exactly once\", async () => {\n    // `Headers.entries()` yields `set-cookie` once per cookie, so appending the\n    // whole `getSetCookie()` array per entry emitted N² of them: two cookies\n    // arrived at the browser as a=1, b=2, a=1, b=2. A duplicated `Set-Cookie` is\n    // not harmless either - a session cookie and its own copy race.\n    const continuing = await loadRuntime(\n      stageDeployment(`\nexports.handler = async () =>\n  new Response(null, {\n    headers: [\n      [\"x-middleware-next\", \"1\"],\n      [\"set-cookie\", \"a=1; Path=/\"],\n      [\"set-cookie\", \"b=2; Path=/\"],\n    ],\n  });\n`),\n    );\n    const sink = new CollectingSink();\n    await continuing.handle(\n      { method: \"GET\", url: \"/\", headers: { host: \"shop.example.test\" } },\n      sink,\n    );\n    expect(sink.head?.cookies).toEqual([\"a=1; Path=/\", \"b=2; Path=/\"]);\n  });\n});\n\n/**\n * Next.js's page handlers report an error and then rethrow, leaving the error page\n * to whatever hosts them, so this ladder is the only thing that makes a\n * `pages/_error` reachable. `test/e2e/async-modules` is the measurement:\n * `/make-error` throws in `getServerSideProps` and expects \"hello error\".\n */\ndescribe(\"a Pages API route\", () => {\n  it(\"is left to end its own response, as next start leaves it\", async () => {\n    const pagesApi = await loadRuntime(\n      stageDeployment(MIDDLEWARE_STUB, (manifest) => ({\n        ...manifest,\n        entrypoints: {\n          ...manifest.entrypoints,\n          \"/api/health\": {\n            ...manifest.entrypoints[\"/api/health\"],\n            type: \"page-api\",\n          },\n        },\n      })),\n    );\n    const sink = new CollectingSink();\n    await pagesApi.handle(\n      {\n        method: \"GET\",\n        url: \"/api/health?endLater=1\",\n        headers: { host: \"shop.example.test\" },\n      },\n      sink,\n    );\n    expect(sink.body.toString(\"utf-8\")).toBe(\"first,second\");\n  });\n\n  it(\"is still ended for a route of any other kind\", async () => {\n    const sink = await send({ url: \"/api/health?endLater=1\" });\n    expect(sink.body.toString(\"utf-8\")).toBe(\"first,\");\n  });\n});\n\ndescribe(\"res.revalidate() across functionGroups\", () => {\n  // The other group's page renders as a 404, which `unstable_onlyGenerated`\n  // alone would accept as \"not generated\".\n  it.each([\n    [\"\", \"/?revalidate=%2Fisr%2F1\"],\n    [\" with unstable_onlyGenerated\", \"/?revalidate=%2Fisr%2F1&onlyGenerated=1\"],\n  ])(\"says which group owns a page it cannot render%s\", async (_, url) => {\n    let missing = \"\";\n    const staged = stageDeployment(MIDDLEWARE_STUB, (manifest) => {\n      missing = manifest.entrypoints[\"/isr/[id]\"].filePath;\n      return {\n        ...manifest,\n        groups: {\n          default: Object.keys(manifest.entrypoints).filter(\n            (template) => template !== \"/isr/[id]\",\n          ),\n          blog: [\"/isr/[id]\"],\n        },\n      };\n    });\n    rmSync(join(staged, missing));\n    const grouped = await loadRuntime(staged);\n    const warn = jest.spyOn(console, \"warn\").mockImplementation(() => {});\n    process.env.CDK_NEXTJS_FUNCTION_GROUP = \"default\";\n    try {\n      const sink = new CollectingSink();\n      await grouped.handle(\n        {\n          method: \"GET\",\n          url,\n          headers: { host: \"shop.example.test\" },\n        },\n        sink,\n      );\n      const { error } = JSON.parse(sink.body.toString(\"utf-8\"));\n      expect(error).toMatch(/^Invalid response 404: /);\n      expect(error).toContain('group \"blog\"');\n      expect(error).toContain('(\"default\")');\n      // The error explains it; the misrouted-request warning would not.\n      expect(warn).not.toHaveBeenCalled();\n    } finally {\n      delete process.env.CDK_NEXTJS_FUNCTION_GROUP;\n      warn.mockRestore();\n    }\n  });\n});\n\ndescribe(\"withoutInternalHeaders\", () => {\n  it(\"drops every header on Next's internal list\", () => {\n    expect(\n      withoutInternalHeaders(\n        {\n          host: \"a.test\",\n          \"next-resume\": \"1\",\n          \"x-middleware-rewrite\": \"/x\",\n          \"x-nextjs-data\": \"1\",\n        },\n        \"/blog\",\n        \"\",\n      ),\n    ).toEqual({ host: \"a.test\" });\n  });\n\n  it(\"marks a _next/data request as one, as next start's router does\", () => {\n    expect(\n      withoutInternalHeaders({}, \"/base/_next/data/abc/blog.json?x=1\", \"/base\"),\n    ).toEqual({ \"x-nextjs-data\": \"1\" });\n    expect(withoutInternalHeaders({}, \"/_next/data/abc/blog\", \"\")).toEqual({});\n  });\n});\n\ndescribe(\"the error page ladder\", () => {\n  /**\n   * An app with a custom `pages/_error` that cannot be prerendered — one with\n   * `getInitialProps`, or a `pages/_app` that has it. The fixture is App Router,\n   * so both halves have to be arranged: drop the prerendered `/500` next emits by\n   * default, and add the entrypoint.\n   */\n  const withErrorPage = (manifest: AdapterManifest): AdapterManifest => {\n    const { \"/500\": _prerendered, ...staticFiles } = manifest.staticFiles;\n    return {\n      ...manifest,\n      staticFiles,\n      entrypoints: {\n        ...manifest.entrypoints,\n        \"/_error\": {\n          ...manifest.entrypoints[\"/_not-found\"],\n          id: \"/_error\",\n          filePath: join(\n            manifest.relativeProjectDir,\n            \".next/server/pages/_error.js\",\n          ),\n        },\n      },\n    };\n  };\n\n  async function sendTo(\n    withLadder: NextjsRuntime,\n    url: string,\n  ): Promise<CollectingSink> {\n    const sink = new CollectingSink();\n    await withLadder.handle(\n      { method: \"GET\", url, headers: { host: \"shop.example.test\" } },\n      sink,\n    );\n    return sink;\n  }\n\n  it(\"invokes /_error when the build has no prerendered /500\", async () => {\n    const error = jest.spyOn(console, \"error\").mockImplementation(() => {});\n    const rendering = await loadRuntime(\n      stageDeployment(MIDDLEWARE_STUB, withErrorPage),\n    );\n    const sink = await sendTo(rendering, \"/?boom=1\");\n    expect(sink.head?.statusCode).toBe(500);\n    // Rendered for the URL that was asked for, and with the status already set:\n    // `_error`'s `getInitialProps` reads `res.statusCode` to get its own prop.\n    expect(stubBody(sink).file).toContain(\"pages/_error.js\");\n    expect(stubBody(sink).url).toBe(\"/?boom=1\");\n    expect(sink.head?.headers[\"content-length\"]).toBeUndefined();\n    expect(sink.head?.headers.etag).toBeUndefined();\n    // Not the throwing render's `s-maxage=60`: a cached 500 at CloudFront.\n    expect(sink.head?.headers[\"cache-control\"]).toMatch(/no-store/);\n    error.mockRestore();\n  });\n\n  it(\"drops the failed render's Content-Length and ETag from a prerendered /500\", async () => {\n    const error = jest.spyOn(console, \"error\").mockImplementation(() => {});\n    const sink = await send({ url: \"/?boom=1\" });\n    expect(sink.head?.statusCode).toBe(500);\n    expect(sink.body.toString(\"utf-8\")).toBe(ERROR_HTML);\n    expect(sink.head?.headers[\"content-length\"]).toBeUndefined();\n    expect(sink.head?.headers.etag).toBeUndefined();\n    error.mockRestore();\n  });\n\n  it(\"falls back to plain text when the error page throws too\", async () => {\n    const error = jest.spyOn(console, \"error\").mockImplementation(() => {});\n    const rendering = await loadRuntime(\n      stageDeployment(MIDDLEWARE_STUB, withErrorPage),\n    );\n    const sink = await sendTo(rendering, \"/?boomEverywhere=1\");\n    expect(sink.head?.statusCode).toBe(500);\n    expect(sink.body.toString(\"utf-8\")).toBe(\"Internal Server Error\");\n    expect(sink.head?.headers[\"cache-control\"]).toBe(\n      \"private, no-cache, no-store, max-age=0, must-revalidate\",\n    );\n    expect(error).toHaveBeenCalledWith(\n      \"The error page itself failed to render:\",\n      expect.objectContaining({ message: expect.stringContaining(\"too\") }),\n    );\n    error.mockRestore();\n  });\n\n  it(\"answers plain text for an app with no error page at all\", async () => {\n    const error = jest.spyOn(console, \"error\").mockImplementation(() => {});\n    const bare = await loadRuntime(\n      stageDeployment(MIDDLEWARE_STUB, (manifest) => {\n        const { \"/500\": _prerendered, ...staticFiles } = manifest.staticFiles;\n        return { ...manifest, staticFiles };\n      }),\n    );\n    const sink = await sendTo(bare, \"/?boom=1\");\n    expect(sink.head?.statusCode).toBe(500);\n    expect(sink.body.toString(\"utf-8\")).toBe(\"Internal Server Error\");\n    error.mockRestore();\n  });\n});\n\ndescribe(\"a Pages Router 404\", () => {\n  /** The fixture is App Router: without `/_not-found`, a 404 is the Pages one. */\n  const withoutNotFound = (manifest: AdapterManifest): AdapterManifest => {\n    const { \"/_not-found\": _appRouter, ...entrypoints } = manifest.entrypoints;\n    return { ...manifest, entrypoints };\n  };\n\n  async function sendTo(\n    pages: NextjsRuntime,\n    url: string,\n  ): Promise<CollectingSink> {\n    const sink = new CollectingSink();\n    await pages.handle(\n      { method: \"GET\", url, headers: { host: \"shop.example.test\" } },\n      sink,\n    );\n    return sink;\n  }\n\n  it(\"serves the prerendered 404.html for an unknown path and for render404()\", async () => {\n    const pages = await loadRuntime(\n      stageDeployment(MIDDLEWARE_STUB, withoutNotFound),\n    );\n    for (const url of [\"/nope\", \"/?render404=1\"]) {\n      const sink = await sendTo(pages, url);\n      expect(sink.head?.statusCode).toBe(404);\n      expect(sink.head?.headers[\"content-type\"]).toBe(\n        \"text/html; charset=utf-8\",\n      );\n      expect(sink.body.toString(\"utf-8\")).toBe(NOT_FOUND_HTML);\n    }\n  });\n\n  it(\"renders a pages/404 entrypoint for the path that was asked for\", async () => {\n    // What a `getInitialProps` in `pages/_app` makes of `pages/404.js`.\n    const pages = await loadRuntime(\n      stageDeployment(MIDDLEWARE_STUB, (manifest) => {\n        const withoutApp = withoutNotFound(manifest);\n        return {\n          ...withoutApp,\n          entrypoints: {\n            ...withoutApp.entrypoints,\n            \"/404\": {\n              ...manifest.entrypoints[\"/_not-found\"],\n              id: \"/404\",\n              filePath: join(\n                manifest.relativeProjectDir,\n                \".next/server/pages/404.js\",\n              ),\n            },\n          },\n        };\n      }),\n    );\n    const sink = await sendTo(pages, \"/nope?q=1\");\n    expect(sink.head?.statusCode).toBe(404);\n    expect(stubBody(sink).file).toContain(\"pages/404.js\");\n    expect(stubBody(sink).url).toBe(\"/nope?q=1\");\n  });\n\n  it(\"answers plain text when the app has no 404 page at all\", async () => {\n    const bare = await loadRuntime(\n      stageDeployment(MIDDLEWARE_STUB, (manifest) => {\n        const { \"/404\": _prerendered, ...staticFiles } = manifest.staticFiles;\n        return { ...withoutNotFound(manifest), staticFiles };\n      }),\n    );\n    const sink = await sendTo(bare, \"/?render404=1\");\n    expect(sink.head?.statusCode).toBe(404);\n    expect(sink.body.toString(\"utf-8\")).toBe(\"This page could not be found.\");\n  });\n});\n\ndescribe(\"/_next/image with images turned off\", () => {\n  it(\"answers the app's 404, no-store, instead of optimizing\", async () => {\n    // `images.unoptimized`, as `next start` reads it from\n    // `required-server-files.json`.\n    const staged = stageDeployment();\n    const manifest: AdapterManifest = JSON.parse(\n      readFileSync(deployedManifestPath(staged), \"utf-8\"),\n    );\n    write(\n      join(\n        staged,\n        manifest.relativeProjectDir,\n        \".next/required-server-files.json\",\n      ),\n      JSON.stringify({\n        version: 1,\n        config: { experimental: {}, images: { unoptimized: true } },\n      }),\n    );\n    const unoptimized = await loadRuntime(staged);\n    const sink = new CollectingSink();\n    await unoptimized.handle(\n      {\n        method: \"GET\",\n        url: \"/_next/image?url=%2Ffavicon.ico&w=64&q=75\",\n        headers: { host: \"shop.example.test\" },\n      },\n      sink,\n    );\n    expect(sink.head?.statusCode).toBe(404);\n    expect(sink.head?.headers[\"cache-control\"]).toBe(\n      \"private, no-cache, no-store, max-age=0, must-revalidate\",\n    );\n    expect(stubBody(sink).file).toContain(\"_not-found/page.js\");\n    expect(stubBody(sink).url).toBe(\n      \"/_next/image?url=%2Ffavicon.ico&w=64&q=75\",\n    );\n  });\n});\n\ndescribe(\"an external rewrite\", () => {\n  /**\n   * `NextResponse.rewrite(\"https://…\")`: an absolute destination makes\n   * `resolveRoutes` report an `externalRewrite`, which the runtime proxies with\n   * `fetch` instead of routing to an entrypoint.\n   */\n  const EXTERNAL_REWRITE_MIDDLEWARE = `\nexports.handler = async () =>\n  new Response(null, {\n    headers: { \"x-middleware-rewrite\": \"https://upstream.test/from-origin\" },\n  });\n`;\n\n  const ORIGIN_BODY = \"<html>from the origin</html>\";\n\n  /**\n   * What undici hands back for a gzip origin, which is the whole point of these\n   * tests: `fetch` decodes the body and leaves both `content-encoding` and the\n   * *encoded* `content-length` behind, describing bytes it already discarded.\n   */\n  function gzipLabelledPlaintext(): Response {\n    return new Response(ORIGIN_BODY, {\n      status: 200,\n      headers: {\n        \"content-type\": \"text/html; charset=utf-8\",\n        \"content-encoding\": \"gzip\",\n        \"content-length\": String(gzipSync(ORIGIN_BODY).byteLength),\n      },\n    });\n  }\n\n  let proxying: NextjsRuntime;\n  let fetchMock: jest.SpyInstance;\n\n  beforeAll(async () => {\n    proxying = await loadRuntime(stageDeployment(EXTERNAL_REWRITE_MIDDLEWARE));\n  });\n\n  beforeEach(() => {\n    fetchMock = jest\n      .spyOn(globalThis, \"fetch\")\n      .mockResolvedValue(gzipLabelledPlaintext());\n  });\n\n  afterEach(() => {\n    fetchMock.mockRestore();\n  });\n\n  async function proxy(\n    headers: Record<string, string> = {},\n    trustForwardedHost = false,\n  ): Promise<CollectingSink> {\n    const sink = new CollectingSink();\n    await proxying.handle(\n      {\n        method: \"GET\",\n        url: \"/anything\",\n        headers: { host: \"shop.example.test\", ...headers },\n        trustForwardedHost,\n      },\n      sink,\n    );\n    return sink;\n  }\n\n  const SIGNED = {\n    authorization:\n      \"AWS4-HMAC-SHA256 Credential=AKIA/20260928/us-east-1/lambda/aws4_request\",\n    \"x-amz-date\": \"20260928T000000Z\",\n    \"x-amz-content-sha256\": \"UNSIGNED-PAYLOAD\",\n    \"x-amz-security-token\": \"token\",\n  };\n\n  // Forwarded, OAC's signature would let the upstream replay the request\n  // against the Function URL.\n  it(\"does not forward the SigV4 headers of an IAM-verified request\", async () => {\n    await proxy(SIGNED, true);\n\n    const headers = (fetchMock.mock.calls[0][1] as RequestInit)\n      .headers as Headers;\n    for (const name of Object.keys(SIGNED)) {\n      expect(headers.has(name)).toBe(false);\n    }\n  });\n\n  // Anywhere else they are the client's own, which `next start` forwards.\n  it(\"forwards the client's own Authorization and x-amz-* headers\", async () => {\n    await proxy(SIGNED);\n\n    const headers = (fetchMock.mock.calls[0][1] as RequestInit)\n      .headers as Headers;\n    for (const [name, value] of Object.entries(SIGNED)) {\n      expect(headers.get(name)).toBe(value);\n    }\n  });\n\n  it(\"proxies the request to the rewritten origin\", async () => {\n    const sink = await proxy();\n\n    expect(String(fetchMock.mock.calls[0][0])).toBe(\n      \"https://upstream.test/from-origin\",\n    );\n    expect(sink.head?.statusCode).toBe(200);\n    expect(sink.head?.headers[\"content-type\"]).toBe(\"text/html; charset=utf-8\");\n  });\n\n  // undici throws on these (`expect: 100-continue` from curl for a large POST,\n  // `keep-alive` from an HTTP/1.0 client), which answered the request with a 500.\n  it(\"does not forward the headers that describe the client's connection\", async () => {\n    await proxy({\n      expect: \"100-continue\",\n      \"keep-alive\": \"timeout=5\",\n      upgrade: \"websocket\",\n      connection: \"keep-alive, upgrade\",\n      \"x-kept\": \"yes\",\n    });\n\n    const headers = (fetchMock.mock.calls[0][1] as RequestInit)\n      .headers as Headers;\n    for (const name of [\n      \"host\",\n      \"expect\",\n      \"keep-alive\",\n      \"upgrade\",\n      \"connection\",\n    ]) {\n      expect(headers.has(name)).toBe(false);\n    }\n    expect(headers.get(\"x-kept\")).toBe(\"yes\");\n  });\n\n  // The request body is forwarded as received, so its encoding has to go with\n  // it: a gzip upload arriving unlabelled is garbage to the upstream.\n  it(\"forwards the request's content-encoding with its body\", async () => {\n    await proxy({ \"content-encoding\": \"gzip\" });\n\n    const headers = (fetchMock.mock.calls[0][1] as RequestInit)\n      .headers as Headers;\n    expect(headers.get(\"content-encoding\")).toBe(\"gzip\");\n  });\n\n  // Forwarding the origin's `content-encoding` over a body `fetch` already\n  // decoded fails the whole response in the browser with\n  // ERR_CONTENT_DECODING_FAILED, under a `Content-Length` that describes the\n  // compressed bytes. Nothing downstream repairs it either: `shouldGzip`\n  // declines as soon as `content-encoding` is set.\n  it(\"drops the content-encoding and length fetch already consumed\", async () => {\n    const sink = await proxy();\n\n    expect(sink.head?.headers[\"content-encoding\"]).toBeUndefined();\n    expect(sink.head?.headers[\"content-length\"]).toBeUndefined();\n    expect(sink.body.toString(\"utf-8\")).toBe(ORIGIN_BODY);\n  });\n\n  // The other half of it: with the stale label gone, the sink is free to\n  // compress the plaintext itself — and now the encoding it advertises is the\n  // one the bytes actually carry.\n  it(\"re-compresses the decoded body when the client accepts gzip\", async () => {\n    const sink = await proxy({ \"accept-encoding\": \"gzip\" });\n\n    expect(sink.head?.headers[\"content-encoding\"]).toBe(\"gzip\");\n    expect(gunzipSync(sink.body).toString(\"utf-8\")).toBe(ORIGIN_BODY);\n  });\n});\n\ndescribe(\"a streamed external rewrite\", () => {\n  const EXTERNAL_REWRITE_MIDDLEWARE = `\nexports.handler = async () =>\n  new Response(null, {\n    headers: { \"x-middleware-rewrite\": \"https://upstream.test/events\" },\n  });\n`;\n\n  let proxying: NextjsRuntime;\n\n  beforeAll(async () => {\n    proxying = await loadRuntime(stageDeployment(EXTERNAL_REWRITE_MIDDLEWARE));\n  });\n\n  // Server-sent events through a rewrite, gzipped because `text/event-stream`\n  // is `text/*`: without a flush per chunk, the first event sat in zlib's\n  // buffer until the origin closed the stream.\n  it(\"flushes each chunk through the compressor as it arrives\", async () => {\n    let release!: () => void;\n    const held = new Promise<void>((resolve) => (release = resolve));\n    const fetchMock = jest.spyOn(globalThis, \"fetch\").mockResolvedValue(\n      new Response(\n        new ReadableStream<Uint8Array>({\n          async start(controller) {\n            controller.enqueue(new TextEncoder().encode(\"data: first\\n\\n\"));\n            await held;\n            controller.enqueue(new TextEncoder().encode(\"data: second\\n\\n\"));\n            controller.close();\n          },\n        }),\n        { headers: { \"content-type\": \"text/event-stream\" } },\n      ),\n    );\n    try {\n      const sink = new CollectingSink();\n      const handled = proxying.handle(\n        {\n          method: \"GET\",\n          url: \"/events\",\n          headers: { host: \"shop.example.test\", \"accept-encoding\": \"gzip\" },\n        },\n        sink,\n      );\n      // Poll rather than sleep a fixed time: the first event has to reach the\n      // sink while the origin is still holding the stream open.\n      const soFar = (): string =>\n        gunzipSync(sink.body, {\n          finishFlush: zlibConstants.Z_SYNC_FLUSH,\n        }).toString(\"utf-8\");\n      for (let i = 0; i < 50 && !soFar(); i++) {\n        await new Promise((resolve) => setTimeout(resolve, 10));\n      }\n      expect(sink.head?.headers[\"content-encoding\"]).toBe(\"gzip\");\n      expect(soFar()).toBe(\"data: first\\n\\n\");\n      release();\n      await handled;\n      expect(gunzipSync(sink.body).toString(\"utf-8\")).toBe(\n        \"data: first\\n\\ndata: second\\n\\n\",\n      );\n    } finally {\n      release();\n      fetchMock.mockRestore();\n    }\n  });\n});\n\ndescribe(\"a Response middleware answers with itself\", () => {\n  const MIDDLEWARE_BODY = \"<html>from middleware</html>\";\n\n  /**\n   * `return fetch(upstream)` from `proxy.ts`, as the runtime sees it: middleware\n   * runs in process, so its `fetch` is undici, which decoded a gzip upstream\n   * and kept the upstream's `content-encoding` and encoded `content-length`.\n   */\n  const FETCHED_RESPONSE_MIDDLEWARE = `\nconst { gzipSync } = require(\"node:zlib\");\nconst body = ${JSON.stringify(MIDDLEWARE_BODY)};\nexports.handler = async () =>\n  new Response(body, {\n    headers: {\n      \"content-type\": \"text/html; charset=utf-8\",\n      \"content-encoding\": \"gzip\",\n      \"content-length\": String(gzipSync(body).byteLength),\n      \"transfer-encoding\": \"chunked\",\n      \"x-from-upstream\": \"yes\",\n    },\n  });\n`;\n\n  let responding: NextjsRuntime;\n\n  beforeAll(async () => {\n    responding = await loadRuntime(\n      stageDeployment(FETCHED_RESPONSE_MIDDLEWARE),\n    );\n  });\n\n  // What `next start` does too: the sandbox deletes these three\n  // (`FORBIDDEN_HEADERS`) from every middleware response.\n  it(\"drops the framing headers that described the upstream's bytes\", async () => {\n    const sink = new CollectingSink();\n    await responding.handle(\n      { method: \"GET\", url: \"/\", headers: { host: \"shop.example.test\" } },\n      sink,\n    );\n\n    expect(sink.head?.headers[\"content-encoding\"]).toBeUndefined();\n    expect(sink.head?.headers[\"content-length\"]).toBeUndefined();\n    expect(sink.head?.headers[\"transfer-encoding\"]).toBeUndefined();\n    expect(sink.head?.headers[\"x-from-upstream\"]).toBe(\"yes\");\n    expect(sink.body.toString(\"utf-8\")).toBe(MIDDLEWARE_BODY);\n  });\n});\n\n/**\n * Last in the file, because `loadRuntime` chdirs: the tests above assert on the\n * cwd the shared deployment set.\n */\ndescribe(\"the resolved query a rewrite produced\", () => {\n  /**\n   * `test/e2e/link-with-api-rewrite`'s rule, as it lands in the manifest: a\n   * `beforeFiles` rewrite whose condition is a query param the destination keeps.\n   */\n  const withSelfMatchingRewrite = (\n    manifest: AdapterManifest,\n  ): AdapterManifest =>\n    ({\n      ...manifest,\n      routing: {\n        ...(manifest.routing as Record<string, unknown>),\n        beforeFiles: [\n          {\n            source: \"/:path(.*)\",\n            sourceRegex: \"^(?:\\\\/(.*))(?:\\\\/)?$\",\n            destination: \"/?from=%2F$1\",\n            has: [{ type: \"query\", key: \"json\", value: \"true\" }],\n          },\n        ],\n      },\n    }) as AdapterManifest;\n\n  /**\n   * `RouteModule.prepare` re-runs the config's rewrites against `req.url`\n   * unconditionally, and `req.url` is the target the rewrite already produced -\n   * so a rule that still matches its own output gets applied twice. Here that\n   * turned `from=/some/route/for` into `from=/`, which is what made\n   * `test/e2e/link-with-api-rewrite` answer `{\"from\":\"/api/json\"}` where\n   * `next start` answers `{\"from\":\"/some/route/for\"}`. Stating the resolved query\n   * as `requestMeta.query` is what `prepare` prefers over anything it re-derives,\n   * so the route sees the first pass rather than the second.\n   */\n  it(\"is handed over as requestMeta.query, not left to be re-derived\", async () => {\n    const rewriting = await loadRuntime(\n      stageDeployment(MIDDLEWARE_STUB, withSelfMatchingRewrite),\n    );\n    const sink = new CollectingSink();\n    await rewriting.handle(\n      {\n        method: \"GET\",\n        url: \"/some/route/for?json=true\",\n        headers: { host: \"shop.example.test\" },\n      },\n      sink,\n    );\n\n    const body = stubBody(sink);\n    // Its own staged tree, so not `root`: the rewrite is the point.\n    expect(body.file).toContain(\".next/server/app/page.js\");\n    expect(body.query).toEqual({ json: \"true\", from: \"/some/route/for\" });\n  });\n});\n\n/**\n * `next start` answers `//` with `308 -> /` and `/api//json` with\n * `308 -> /api/json`; this runtime used to answer 500 and 404. The 500 is the\n * reason the check runs before anything parses the target: `new URL(\"//\", base)`\n * reads a leading `//` as protocol-relative and takes the first path segment for\n * the host. Found by `test/e2e/hydration`, which requests exactly `//`, and by\n * `test/e2e/i18n-ignore-redirect-source-locale/redirects-with-basepath`, whose\n * locale list includes `''` and so asks for `/basepath//to-sv`.\n */\ndescribe(\"a path with repeated slashes or a backslash\", () => {\n  it.each([\n    [\"//\", \"/\"],\n    [\"///\", \"/\"],\n    [\"/api//json\", \"/api/json\"],\n    [\"/basepath//to-sv\", \"/basepath/to-sv\"],\n    [\"/a\\\\b\", \"/a/b\"],\n    // The query is carried across untouched, repeated slashes and all.\n    [\"//some/route?json=true&next=//x\", \"/some/route?json=true&next=//x\"],\n  ])(\"redirects %s to %s with a 308\", async (from, to) => {\n    const sink = await send({ url: from });\n    expect(sink.head?.statusCode).toBe(308);\n    expect(sink.head?.headers.location).toBe(to);\n    // Next.js sends the destination as the body too.\n    expect(sink.body.toString(\"utf-8\")).toBe(to);\n  });\n\n  /** `%5C` is a character in a segment, not a separator - as in Next.js. */\n  it(\"leaves an encoded backslash alone\", async () => {\n    const sink = await send({ url: \"/a%5Cb\" });\n    expect(sink.head?.statusCode).not.toBe(308);\n  });\n});\n\ndescribe(\"splitBody\", () => {\n  const CHUNK = Buffer.alloc(16 * 1024, 7);\n  const upload = () =>\n    Readable.from(\n      Array.from({ length: 8 }, () => CHUNK),\n      { objectMode: false },\n    );\n\n  async function drain(stream: AsyncIterable<Uint8Array>): Promise<number> {\n    let length = 0;\n    for await (const chunk of stream) {\n      length += chunk.length;\n    }\n    return length;\n  }\n\n  // A tee buffers for the branch that is behind, so the middleware branch that\n  // nothing reads would otherwise hold every byte the route streams.\n  it(\"cancels the middleware copy once dispatch is done with it\", async () => {\n    const body = splitBody(upload(), true);\n    body.releaseUnread(false);\n\n    const reader = body.forDispatch.getReader();\n    expect(await reader.read()).toEqual({ done: true, value: undefined });\n    expect(await drain(body.forRequest as Readable)).toBe(8 * CHUNK.length);\n  });\n\n  it(\"leaves the middleware copy alone when middleware is reading it\", async () => {\n    const body = splitBody(upload(), true);\n    const reading = drain(\n      body.forDispatch as unknown as AsyncIterable<Uint8Array>,\n    );\n    body.releaseUnread(false);\n\n    expect(await reading).toBe(8 * CHUNK.length);\n  });\n\n  // Middleware answered, possibly with the upload as its own body; `req` is\n  // never read, so its copy is the one that would pile up.\n  it(\"releases the route's copy when middleware answered\", async () => {\n    const body = splitBody(upload(), true);\n    body.releaseUnread(true);\n\n    expect((body.forRequest as Readable).destroyed).toBe(true);\n    expect(\n      await drain(body.forDispatch as unknown as AsyncIterable<Uint8Array>),\n    ).toBe(8 * CHUNK.length);\n  });\n\n  // Every Lambda request with a body: the shell hands the runtime a Buffer.\n  it(\"reads a Buffer body twice, whole each time\", async () => {\n    const source = Buffer.from(\"x\".repeat(100_000));\n    const body = splitBody(source, true);\n    body.releaseUnread(false);\n\n    expect(\n      await drain(body.forDispatch as unknown as AsyncIterable<Uint8Array>),\n    ).toBe(source.length);\n    expect((body.forRequest as Buffer).length).toBe(source.length);\n  });\n\n  it(\"does not split at all without middleware\", () => {\n    const source = upload();\n    const body = splitBody(source, false);\n    expect(body.forRequest).toBe(source);\n    body.releaseUnread(false);\n    expect(source.destroyed).toBe(false);\n  });\n});\n\ndescribe(\"waitUntil\", () => {\n  it(\"awaits work registered after the first batch settled\", async () => {\n    const marker = join(root, \"late-wait-until-marker\");\n    process.env.CDK_NEXTJS_TEST_MARKER = marker;\n    try {\n      await send({ url: \"/?lateWaitUntil=1\" });\n      expect(readFileSync(marker, \"utf-8\")).toBe(\"late\");\n    } finally {\n      delete process.env.CDK_NEXTJS_TEST_MARKER;\n    }\n  });\n});\n\ndescribe(\"a prerendered status page, requested directly\", () => {\n  it(\"answers /404 with a 404, as next start does\", async () => {\n    const sink = await send({ url: \"/404\" });\n    expect(sink.head?.statusCode).toBe(404);\n    expect(sink.body.toString(\"utf-8\")).toBe(NOT_FOUND_HTML);\n  });\n\n  it(\"answers /500 with a 500\", async () => {\n    const sink = await send({ url: \"/500\" });\n    expect(sink.head?.statusCode).toBe(500);\n    expect(sink.body.toString(\"utf-8\")).toBe(ERROR_HTML);\n  });\n\n  it(\"still serves them to a POST, which next start does not 405\", async () => {\n    const sink = await send({ url: \"/404\", method: \"POST\" });\n    expect(sink.head?.statusCode).toBe(404);\n  });\n});\n\ndescribe(\"an auto-exported Pages Router page\", () => {\n  const ABOUT_HTML = \"<html><body>about</body></html>\";\n  let pages: NextjsRuntime;\n\n  beforeAll(async () => {\n    let aboutFile = \"\";\n    const staged = stageDeployment(MIDDLEWARE_STUB, (manifest) => {\n      aboutFile = `${manifest.relativeProjectDir}/.next/server/pages/about.html`;\n      return {\n        ...manifest,\n        staticFiles: { ...manifest.staticFiles, \"/about\": aboutFile },\n      };\n    });\n    write(join(staged, aboutFile), ABOUT_HTML);\n    pages = await loadRuntime(staged);\n  });\n\n  async function sendTo(method: string): Promise<CollectingSink> {\n    const sink = new CollectingSink();\n    await pages.handle(\n      { method, url: \"/about\", headers: { host: \"shop.example.test\" } },\n      sink,\n    );\n    return sink;\n  }\n\n  it(\"is served to a GET\", async () => {\n    const sink = await sendTo(\"GET\");\n    expect(sink.head?.statusCode).toBe(200);\n    expect(sink.body.toString(\"utf-8\")).toBe(ABOUT_HTML);\n  });\n\n  it(\"answers any other method with a 405, as next start does\", async () => {\n    const sink = await sendTo(\"POST\");\n    expect(sink.head?.statusCode).toBe(405);\n    expect(sink.head?.headers.allow).toBe(\"GET, HEAD\");\n  });\n});\n\ndescribe(\"a route packaged into another functionGroups group\", () => {\n  let grouped: NextjsRuntime;\n\n  beforeAll(async () => {\n    let missing = \"\";\n    const staged = stageDeployment(MIDDLEWARE_STUB, (manifest) => {\n      missing = manifest.entrypoints[\"/isr/[id]\"].filePath;\n      return {\n        ...manifest,\n        groups: {\n          default: Object.keys(manifest.entrypoints).filter(\n            (template) => template !== \"/isr/[id]\",\n          ),\n          blog: [\"/isr/[id]\"],\n        },\n      };\n    });\n    rmSync(join(staged, missing));\n    grouped = await loadRuntime(staged);\n  });\n\n  async function get(url: string): Promise<CollectingSink> {\n    const warn = jest.spyOn(console, \"warn\").mockImplementation(() => {});\n    process.env.CDK_NEXTJS_FUNCTION_GROUP = \"default\";\n    try {\n      const sink = new CollectingSink();\n      await grouped.handle(\n        { method: \"GET\", url, headers: { host: \"shop.example.test\" } },\n        sink,\n      );\n      return sink;\n    } finally {\n      delete process.env.CDK_NEXTJS_FUNCTION_GROUP;\n      warn.mockRestore();\n    }\n  }\n\n  // The edge matches case-sensitively and Next.js doesn't: `/ISR/1` missed the\n  // `blog` group's behavior only because of its case.\n  it(\"redirects a URL that differs only in case to its canonical spelling\", async () => {\n    const sink = await get(\"/ISR/1?x=1\");\n    expect(sink.head?.statusCode).toBe(308);\n    expect(sink.head?.headers.location).toBe(\"/isr/1?x=1\");\n  });\n\n  it(\"keeps the case of a dynamic segment's value\", async () => {\n    const sink = await get(\"/ISR/AbC\");\n    expect(sink.head?.statusCode).toBe(308);\n    expect(sink.head?.headers.location).toBe(\"/isr/AbC\");\n  });\n\n  // `/_next/image` runs in the default group and renders a source that is not\n  // a file in process: for one served by another group, that rendered the 404\n  // page and handed its HTML to the optimizer as the image.\n  it(\"reports an image source in another group rather than fetching its 404 page\", async () => {\n    const warn = jest.spyOn(console, \"warn\").mockImplementation(() => {});\n    process.env.CDK_NEXTJS_FUNCTION_GROUP = \"default\";\n    try {\n      const fetchInternal = (\n        grouped as unknown as {\n          fetchInternal: (\n            href: string,\n            req: unknown,\n          ) => Promise<{\n            statusCode: number;\n            body: Buffer;\n            otherGroup?: string;\n          }>;\n        }\n      ).fetchInternal.bind(grouped);\n      const response = await fetchInternal(\n        \"/isr/1\",\n        new ShimIncomingMessage({\n          method: \"GET\",\n          url: \"/_next/image?url=%2Fisr%2F1&w=64&q=75\",\n          headers: { host: \"shop.example.test\" },\n        }),\n      );\n      expect(response).toMatchObject({ otherGroup: \"blog\" });\n      expect(response.body.length).toBe(0);\n    } finally {\n      delete process.env.CDK_NEXTJS_FUNCTION_GROUP;\n      warn.mockRestore();\n    }\n  });\n\n  it(\"is a 404, not a 500, when case is not the difference\", async () => {\n    const warn = jest.spyOn(console, \"warn\").mockImplementation(() => {});\n    process.env.CDK_NEXTJS_FUNCTION_GROUP = \"default\";\n    try {\n      const sink = new CollectingSink();\n      await grouped.handle(\n        {\n          method: \"GET\",\n          url: \"/isr/1\",\n          headers: { host: \"shop.example.test\" },\n        },\n        sink,\n      );\n      expect(sink.head?.statusCode).toBe(404);\n      expect(sink.head?.headers[\"cache-control\"]).toMatch(/no-store/);\n      expect(String(warn.mock.calls[0]?.[0])).toContain('group \"blog\"');\n    } finally {\n      delete process.env.CDK_NEXTJS_FUNCTION_GROUP;\n      warn.mockRestore();\n    }\n  });\n});\n\ndescribe(\"public/ on the Lambda types\", () => {\n  let lambda: NextjsRuntime;\n  const send$ = jest.spyOn(S3Client.prototype, \"send\");\n\n  beforeAll(async () => {\n    const staged = stageDeployment();\n    const manifest: AdapterManifest = JSON.parse(\n      readFileSync(deployedManifestPath(staged), \"utf-8\"),\n    );\n    // What a Lambda zip carries: the list, not the files.\n    rmSync(join(staged, manifest.relativeProjectDir, \"public\"), {\n      recursive: true,\n    });\n    write(\n      join(staged, RUNTIME_DIR_NAME, PUBLIC_FILES_FILE_NAME),\n      JSON.stringify([\"feed.xml\", \"images/logo@2x.png\"]),\n    );\n    lambda = new NextjsRuntime({\n      deploymentRoot: staged,\n      manifest,\n      bucket: \"assets\",\n      bucketKeyPrefix: \"base\",\n    });\n  });\n\n  afterEach(() => send$.mockReset());\n  afterAll(() => send$.mockRestore());\n\n  async function get(\n    url: string,\n    headers: Record<string, string> = {},\n  ): Promise<CollectingSink> {\n    const sink = new CollectingSink();\n    await lambda.handle(\n      {\n        method: \"GET\",\n        url,\n        headers: { host: \"shop.example.test\", ...headers },\n      },\n      sink,\n    );\n    return sink;\n  }\n\n  it(\"streams a listed file from the assets bucket, under its key prefix\", async () => {\n    send$.mockImplementation((async () => ({\n      Body: Readable.from([Buffer.from(\"<rss/>\")]),\n      ContentType: \"application/rss+xml\",\n      ContentLength: 6,\n      ETag: '\"e1\"',\n      LastModified: new Date(\"2026-01-02T03:04:05Z\"),\n    })) as never);\n    const sink = await get(\"/feed.xml\");\n    expect(sink.head?.statusCode).toBe(200);\n    expect(sink.body.toString(\"utf-8\")).toBe(\"<rss/>\");\n    expect(sink.head?.headers[\"content-type\"]).toBe(\"application/rss+xml\");\n    expect(sink.head?.headers.etag).toBe('\"e1\"');\n    expect(sink.head?.headers[\"cache-control\"]).toBe(\"public, max-age=0\");\n    const command = send$.mock.calls[0][0] as unknown as {\n      input: { Bucket: string; Key: string };\n    };\n    expect(command.input).toMatchObject({\n      Bucket: \"assets\",\n      Key: \"base/feed.xml\",\n    });\n  });\n\n  it(\"uses the file's real name as the key\", async () => {\n    send$.mockImplementation((async () => ({\n      Body: Readable.from([Buffer.from(\"png\")]),\n    })) as never);\n    await get(\"/images/logo@2x.png\");\n    const command = send$.mock.calls[0][0] as unknown as {\n      input: { Key: string };\n    };\n    expect(command.input.Key).toBe(\"base/images/logo@2x.png\");\n  });\n\n  it(\"answers a matching If-None-Match with the 304 S3 gave\", async () => {\n    send$.mockImplementation((async () => {\n      throw Object.assign(new Error(\"Not Modified\"), {\n        name: \"NotModified\",\n        $metadata: { httpStatusCode: 304 },\n      });\n    }) as never);\n    const sink = await get(\"/feed.xml\", { \"if-none-match\": '\"e1\"' });\n    expect(sink.head?.statusCode).toBe(304);\n    expect(sink.body.length).toBe(0);\n  });\n\n  it(\"falls through to the 404 when the object is gone\", async () => {\n    send$.mockImplementation((async () => {\n      throw Object.assign(new Error(\"NoSuchKey\"), {\n        name: \"NoSuchKey\",\n        $metadata: { httpStatusCode: 404 },\n      });\n    }) as never);\n    const sink = await get(\"/feed.xml\");\n    expect(sink.head?.statusCode).toBe(404);\n  });\n\n  it(\"forwards a Range and answers S3's 206\", async () => {\n    send$.mockImplementation((async () => ({\n      Body: Readable.from([Buffer.from(\"rss\")]),\n      ContentLength: 3,\n      ContentRange: \"bytes 1-3/6\",\n      AcceptRanges: \"bytes\",\n    })) as never);\n    const sink = await get(\"/feed.xml\", { range: \"bytes=1-3\" });\n    expect(sink.head?.statusCode).toBe(206);\n    expect(sink.head?.headers[\"content-range\"]).toBe(\"bytes 1-3/6\");\n    expect(sink.head?.headers[\"accept-ranges\"]).toBe(\"bytes\");\n    expect(sink.body.toString(\"utf-8\")).toBe(\"rss\");\n    const command = send$.mock.calls[0][0] as unknown as {\n      input: { Range?: string };\n    };\n    expect(command.input.Range).toBe(\"bytes=1-3\");\n  });\n\n  it(\"answers an unsatisfiable Range with a 416\", async () => {\n    send$.mockImplementation((async () => {\n      throw Object.assign(new Error(\"InvalidRange\"), {\n        name: \"InvalidRange\",\n        $metadata: { httpStatusCode: 416 },\n      });\n    }) as never);\n    const sink = await get(\"/feed.xml\", { range: \"bytes=999-\" });\n    expect(sink.head?.statusCode).toBe(416);\n    expect(sink.body.length).toBe(0);\n  });\n\n  // S3 can't evaluate If-Range, and ignoring Range is always allowed.\n  it(\"drops the Range when If-Range is present\", async () => {\n    send$.mockImplementation((async () => ({\n      Body: Readable.from([Buffer.from(\"<rss/>\")]),\n    })) as never);\n    const sink = await get(\"/feed.xml\", {\n      range: \"bytes=1-3\",\n      \"if-range\": '\"e1\"',\n    });\n    expect(sink.head?.statusCode).toBe(200);\n    const command = send$.mock.calls[0][0] as unknown as {\n      input: { Range?: string };\n    };\n    expect(command.input.Range).toBeUndefined();\n  });\n\n  it(\"uses the object's own Cache-Control, as the edge serves it\", async () => {\n    send$.mockImplementation((async () => ({\n      Body: Readable.from([Buffer.from(\"<rss/>\")]),\n      CacheControl: \"public, max-age=3600\",\n    })) as never);\n    const sink = await get(\"/feed.xml\");\n    expect(sink.head?.headers[\"cache-control\"]).toBe(\"public, max-age=3600\");\n  });\n\n  it(\"leaves an unlisted path to the app\", async () => {\n    await get(\"/test.txt\");\n    expect(send$).not.toHaveBeenCalled();\n  });\n});\n\ndescribe(\"revalidatedPageRoutes\", () => {\n  const manifest = (i18n: unknown) =>\n    ({ buildId: \"b1\", config: { i18n } }) as unknown as AdapterManifest;\n  const i18n = { locales: [\"en\", \"fr\"], defaultLocale: \"en\" };\n\n  it(\"is the route and its data route without i18n\", () => {\n    expect(revalidatedPageRoutes(\"/blog\", manifest(null))).toEqual([\n      [\"/blog\", \"/_next/data/b1/blog.json\"],\n    ]);\n    expect(revalidatedPageRoutes(\"/\", manifest(null))).toEqual([\n      [\"/\", \"/_next/data/b1/index.json\"],\n    ]);\n  });\n\n  // The Next client puts the locale in every data href, the default included.\n  it(\"puts the default locale in the data route, and invalidates both HTML spellings\", () => {\n    expect(revalidatedPageRoutes(\"/blog\", manifest(i18n))).toEqual([\n      [\"/blog\", \"/_next/data/b1/en/blog.json\"],\n      [\"/en/blog\", \"/_next/data/b1/en/blog.json\"],\n    ]);\n    expect(revalidatedPageRoutes(\"/en/blog\", manifest(i18n))).toEqual([\n      [\"/blog\", \"/_next/data/b1/en/blog.json\"],\n      [\"/en/blog\", \"/_next/data/b1/en/blog.json\"],\n    ]);\n  });\n\n  it(\"names the root's data route after the locale\", () => {\n    expect(revalidatedPageRoutes(\"/\", manifest(i18n))).toEqual([\n      [\"/\", \"/_next/data/b1/en.json\"],\n      [\"/en\", \"/_next/data/b1/en.json\"],\n    ]);\n    expect(revalidatedPageRoutes(\"/fr\", manifest(i18n))).toEqual([\n      [\"/fr\", \"/_next/data/b1/fr.json\"],\n    ]);\n  });\n\n  it(\"keeps another locale's page to its own prefix\", () => {\n    expect(revalidatedPageRoutes(\"/fr/blog\", manifest(i18n))).toEqual([\n      [\"/fr/blog\", \"/_next/data/b1/fr/blog.json\"],\n    ]);\n  });\n});\n"]}