cdk-nextjs 0.6.2 → 0.7.1

package/lib/runtime/core.js

@@ -0,0 +1,1216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NextjsRuntime = void 0;
+exports.withoutInternalHeaders = withoutInternalHeaders;
+exports.revalidatedPageRoutes = revalidatedPageRoutes;
+exports.loadRuntime = loadRuntime;
+exports.splitBody = splitBody;
+/* eslint-disable import/no-extraneous-dependencies */
+/**
+ * The runtime core: one `handle(request, sink)` that both shells wrap.
+ *
+ * The Lambda shell (`lambda.mts`) and the container shell (`server.mts`) do
+ * nothing but turn their input into a {@link RuntimeRequest} and their output into
+ * a {@link ResponseSink}. Everything else — synthesizing `req`/`res`, dispatch,
+ * middleware, entrypoint invocation, static files, image optimization, gzip,
+ * `waitUntil` — happens here, so the container e2e suite exercises the same code
+ * Lambda runs. That is deliberate: the container path used to get real
+ * `node:http` objects from Lambda Web Adapter, which meant container tests proved
+ * nothing about Lambda.
+ */
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const node_stream_1 = require("node:stream");
+const case_redirect_1 = require("./case-redirect");
+const dispatch_1 = require("./dispatch");
+const entrypoints_1 = require("./entrypoints");
+const request_1 = require("./http/request");
+const response_1 = require("./http/response");
+const sink_1 = require("./http/sink");
+const image_1 = require("./image");
+const manifest_1 = require("./manifest");
+const middleware_1 = require("./middleware");
+const next_modules_1 = require("./next-modules");
+const public_files_1 = require("./public-files");
+const static_files_1 = require("./static-files");
+const util_1 = require("./util");
+class NextjsRuntime {
+    options;
+    entrypoints;
+    dispatcher;
+    middleware;
+    images;
+    /** The 500 ladder; see `statusTargets`. */
+    errorTargetFor;
+    /** The assets bucket, when `public/` files are served from it. */
+    publicBucket;
+    constructor(options) {
+        this.options = options;
+        const { manifest, deploymentRoot } = options;
+        this.entrypoints = new entrypoints_1.EntrypointRegistry(deploymentRoot, manifest);
+        // Listed once, at cold start; see `resolvePublicFiles`.
+        const publicFiles = (0, public_files_1.resolvePublicFiles)(deploymentRoot, manifest);
+        this.dispatcher = new dispatch_1.Dispatcher({
+            manifest,
+            publicFiles: publicFiles.files,
+        });
+        // On disk otherwise, with `.next/static`.
+        this.publicBucket = publicFiles.inS3 ? options.bucket : undefined;
+        this.errorTargetFor = (0, dispatch_1.statusTargets)(manifest, 500);
+        this.images = new image_1.RuntimeImageOptimizer({
+            deploymentRoot,
+            manifest,
+            bucket: this.publicBucket ?? "",
+            bucketKeyPrefix: options.bucketKeyPrefix ?? "",
+            fetchInternal: (href, req, maximumBody) => this.fetchInternal(href, req, maximumBody),
+        });
+        // The runner is shared — it memoizes the loaded middleware module — while the
+        // `invokeMiddleware` callback it produces is per request.
+        this.middleware = manifest.middleware
+            ? new middleware_1.MiddlewareRunner({
+                middleware: manifest.middleware,
+                root: deploymentRoot,
+            })
+            : undefined;
+    }
+    get manifest() {
+        return this.options.manifest;
+    }
+    async handle(request, sink) {
+        const { manifest } = this.options;
+        const pending = [];
+        const waitUntil = (promise) => {
+            pending.push(promise);
+        };
+        const body = splitBody(request.body, this.middleware !== undefined);
+        const req = new request_1.ShimIncomingMessage({
+            method: request.method,
+            url: request.url,
+            headers: withoutInternalHeaders(request.headers, request.url, manifest.config.basePath),
+            body: body.forRequest,
+            remoteAddress: request.remoteAddress,
+            encrypted: request.encrypted,
+            trustForwardedHost: request.trustForwardedHost,
+        });
+        const res = new response_1.ShimServerResponse();
+        // Next.js reads `res.req` in a few error paths.
+        res.req = req;
+        request.signal?.addEventListener("abort", () => res.destroy(), {
+            once: true,
+        });
+        // The rejection handler is attached here rather than at the `await` below.
+        // `route()` awaits real I/O, so a stream that breaks while it runs would
+        // leave this promise rejected with no handler attached for a full event-loop
+        // turn — and Node 24 defaults to `--unhandled-rejections=throw`, which on
+        // the container shell takes the whole task down and aborts every other
+        // in-flight request on it. A mid-stream EPIPE from one client disconnect is
+        // not grounds for that.
+        //
+        // The error is logged, not rethrown: the stream broke after (or while) the
+        // head went out — a client disconnect, or `sendError` destroying a
+        // half-written response — and neither is an invocation failure. Rethrowing
+        // would make Lambda retry a request the client already abandoned.
+        const finished = (0, sink_1.pipeToSink)(req, res, sink, {
+            compress: manifest.config.compress,
+        }).catch((error) => {
+            console.error("The response stream did not complete:", error);
+        });
+        // For the error page's locale; unset when the throw is `absoluteUrl`'s.
+        let url;
+        try {
+            // Before anything parses the target, including `absoluteUrl` - `new URL`
+            // reads a leading `//` as protocol-relative and would take the first path
+            // segment for the host.
+            const collapsed = collapseRepeatedSlashes(request.url);
+            if (collapsed !== undefined) {
+                sendRedirect(res, collapsed, 308);
+            }
+            else {
+                // Inside the try: `absoluteUrl` builds a `URL` out of the request line
+                // and the forwarded headers, and a throw here has to reach the error
+                // ladder like any other. Outside it, on the Lambda shells — whose
+                // handlers wrap nothing — the same throw is an invocation error and a
+                // 502.
+                url = absoluteUrl(request);
+                await this.route(req, res, url, body, waitUntil, request);
+            }
+        }
+        catch (error) {
+            await this.sendError(req, res, waitUntil, error, url);
+        }
+        await finished;
+        // Lambda freezes the execution environment the moment the handler resolves —
+        // there is no post-response keepalive — so background work registered with
+        // `waitUntil` (notably ISR revalidation) has to be awaited here. After the
+        // response stream has closed, so client latency is unaffected; billed
+        // duration extends, which is the correct trade against a revalidation that
+        // never completes.
+        //
+        // Drained until nothing new arrives, not awaited once: `waitUntil` keeps
+        // being called after the response — Next's `AfterContext` registers its
+        // callback queue on the first `after()`, and an `after(promise)` made from
+        // inside a running callback, or a background regeneration that itself calls
+        // `after()`, registers more. A single `allSettled` snapshots the array and
+        // lets Lambda freeze on that late work.
+        let settledCount = 0;
+        while (settledCount < pending.length) {
+            const batch = pending.slice(settledCount);
+            settledCount = pending.length;
+            const settled = await Promise.allSettled(batch);
+            for (const result of settled) {
+                if (result.status === "rejected") {
+                    console.error("A waitUntil() promise rejected:", result.reason);
+                }
+            }
+        }
+    }
+    async route(req, res, url, body, waitUntil, request) {
+        const result = await this.dispatcher.dispatch({
+            method: req.method ?? "GET",
+            url,
+            headers: new Headers(toWebHeaders(req.headers)),
+            body: body.forDispatch,
+            invokeMiddleware: this.middleware?.invokerFor({
+                waitUntil,
+                signal: request.signal,
+            }),
+        });
+        body.releaseUnread(result.kind === "middleware-responded");
+        applyHeaders(res, result.responseHeaders);
+        if (result.status !== undefined) {
+            res.statusCode = result.status;
+        }
+        switch (result.kind) {
+            case "entrypoint": {
+                let handler;
+                try {
+                    handler = await this.entrypoints.load(result.entrypoint);
+                }
+                catch (error) {
+                    if (!(error instanceof entrypoints_1.RouteInOtherGroupError))
+                        throw error;
+                    // A URL the edge sent here only because of its case goes to its
+                    // canonical spelling, which the edge routes to the owning group.
+                    const canonical = (0, case_redirect_1.caseCanonicalPath)(url.pathname, result.resolvedPathname, this.options.manifest);
+                    if (canonical) {
+                        sendRedirect(res, `${canonical}${url.search}`, 308);
+                        return;
+                    }
+                    if (request.onRouteInOtherGroup) {
+                        // Explained by the caller of `handleInternally`, which knows why it
+                        // happened.
+                        request.onRouteInOtherGroup(error);
+                    }
+                    else {
+                        // Logged, because it is also what a misrouted group looks like; see
+                        // `RouteInOtherGroupError` for why it is a 404.
+                        console.warn(error.message);
+                    }
+                    await this.sendUnmatched(req, res, waitUntil, { pathname: url.pathname, requestHeaders: result.requestHeaders }, url);
+                    return;
+                }
+                // The invocation target, not the requested URL: `resolveRoutes` has
+                // applied rewrites, stripped i18n prefixes, and appended the `nxtP`
+                // route params as query values. That is exactly the contract Next.js
+                // documents for a proxy in front of a function — `RouteModule.prepare`
+                // recovers `params` from these query values — so that contract, not
+                // `requestMeta.params`, is how params get passed. The one exception is
+                // a capture the contract would corrupt; see `outOfBandRouteParams`.
+                const outOfBand = (0, dispatch_1.outOfBandRouteParams)(result.invocationTarget.query, result.resolvedPathname);
+                const invocationQuery = outOfBand?.query ?? result.invocationTarget.query;
+                const { pathname } = result.invocationTarget;
+                const search = (0, util_1.toSearch)(invocationQuery);
+                req.url = search ? `${pathname}?${search}` : pathname;
+                // Middleware may have rewritten request headers via
+                // `NextResponse.next({ request: { headers } })`.
+                req.headers = (0, request_1.toIncomingHttpHeaders)(result.requestHeaders);
+                await handler(req, (0, response_1.asServerResponse)(res), {
+                    waitUntil,
+                    requestMeta: {
+                        // The resolved query, stated rather than left to be re-derived.
+                        //
+                        // `RouteModule.prepare` runs `handleRewrites` against `req.url`
+                        // unconditionally, and `req.url` is the *already rewritten* target.
+                        // A `beforeFiles` rewrite whose condition still holds after it has
+                        // been applied therefore gets applied twice: in
+                        // `test/e2e/link-with-api-rewrite` the rule
+                        // `/:path(.*)` + `has: query json=true` -> `/api/json?from=/:path`
+                        // matched `/api/json?json=true&from=/some/route/for` a second time
+                        // and overwrote `from` with `/api/json`. `next start` escapes it
+                        // because its router leaves `req.url` as the URL the client sent, so
+                        // the one pass `prepare` makes is the only one.
+                        //
+                        // `prepare` prefers this meta over its own `parsedUrl.query`
+                        // ("when deployed proxies will add query values from resolving the
+                        // routes to pass to function"), which is the documented division of
+                        // labour for a proxy in front of a function - and it is the same
+                        // division the `req.url` above relies on. Setting it does not stop
+                        // the second rewrite pass, it just stops that pass from being what
+                        // the route sees.
+                        query: { ...invocationQuery },
+                        // Set only for a capture the query contract cannot carry, and then
+                        // in place of it rather than alongside.
+                        ...(outOfBand ? { params: outOfBand.params } : {}),
+                        // Without this, `RouteModule.prepare` falls back to
+                        // `http://localhost${req.url}` and every absolute URL a route
+                        // handler builds is wrong. `relativeProjectDir` is deliberately
+                        // *not* passed: the runtime `chdir`s to the project dir, so the
+                        // value Next.js inlined at build time ("") is already correct, and
+                        // `app-page-runtime.js` ignores the requestMeta override anyway.
+                        initURL: url.href,
+                        // Feeds `routerServerContext.hostname` (`route-module.js`
+                        // `getRouterServerContext`). Includes the port, because it is
+                        // concatenated into absolute URLs.
+                        hostname: url.host,
+                        // Both routers call this for a `notFound: true` / `notFound()` that
+                        // the entrypoint itself cannot render, and fall back to
+                        // `res.end('This page could not be found')` — no status, no app 404
+                        // page — when it is absent. The `req`/`res` they pass are the ones
+                        // handed in just above, so the captured pair is used instead of
+                        // re-deriving them.
+                        render404: async () => {
+                            await this.sendNotFound(req, res, waitUntil, this.dispatcher.notFoundFor(url));
+                        },
+                        // `res.revalidate()` from a Pages API route. Without it, Next.js
+                        // falls back to `fetch('https://' + req.headers.host + urlPath)` —
+                        // and only when `experimental.trustHostHeader` is set, which it is
+                        // not, so `res.revalidate()` threw
+                        //
+                        //   Failed to revalidate /: Invariant: missing internal
+                        //   router-server-methods this is an internal bug
+                        //
+                        // and `test/e2e/revalidate-reason` saw `stale` where `next start`
+                        // reports `on-demand`: the route still re-rendered, just as an
+                        // ordinary stale regeneration rather than the on-demand one it
+                        // asked for.
+                        //
+                        // Answering it in process rather than by setting
+                        // `trustHostHeader`: the fetch path would leave the function, cross
+                        // CloudFront and come back — a second billed invocation, a
+                        // dependency on `x-prerender-revalidate` surviving the edge, and a
+                        // reason to trust a client-supplied `Host`. Next.js's own
+                        // non-serverless answer is the same shape as this one
+                        // (`NextServer#revalidate` runs its request handler against a
+                        // mocked `req`/`res`).
+                        revalidate: (config) => this.revalidate(config, request),
+                    },
+                });
+                // A Pages API route owns the end of its response: `stream.pipe(res)`,
+                // an `externalResolver` proxy, or a callback that calls `res.json()`
+                // later all return from the handler before they are done writing, and
+                // ending here sent an empty 200 and made their writes throw
+                // `ERR_STREAM_WRITE_AFTER_END`. `next start`'s `apiResolver` leaves it
+                // open too — one that never ends stalls, there as here. `handle` awaits
+                // the response itself, so nothing is cut short by returning.
+                if (!res.writableEnded && result.entrypoint.type !== "page-api") {
+                    res.end();
+                }
+                return;
+            }
+            case "static-file": {
+                const statusPage = result.source === "server"
+                    ? this.statusPageStatus(result.pathname)
+                    : undefined;
+                // `next start` serves a `public/` or `_next/static` file to GET and
+                // HEAD only, and `send` would serve it to any method. The same goes for
+                // an auto-exported Pages Router page (`base-server.js`
+                // `renderToResponseWithComponentsImpl`: a string `Component` answers
+                // anything else with a 405), except the 404 and 500 pages.
+                if (req.method !== "GET" &&
+                    req.method !== "HEAD" &&
+                    (result.source !== "server" ||
+                        (statusPage === undefined && result.filePath.endsWith(".html")))) {
+                    sendMethodNotAllowed(res);
+                    return;
+                }
+                // "ensure correct status is set when visiting a status page directly":
+                // `next start` answers `/404` with a 404 and `/500` with a 500, not the
+                // 200 their prerendered HTML would otherwise go out with.
+                if (statusPage !== undefined) {
+                    res.statusCode = statusPage;
+                }
+                const etag = this.options.manifest.config.generateEtags;
+                const publicDir = `${(0, public_files_1.publicDirKey)(this.options.manifest)}/`;
+                const served = (await (0, static_files_1.serveStaticFile)(req, res, this.options.deploymentRoot, result.filePath, { etag })) ||
+                    // Listed but not staged: a Lambda root, whose `public/` is in S3.
+                    (result.source === "public" &&
+                        !!this.publicBucket &&
+                        (await (0, static_files_1.serveS3PublicFile)(req, res, {
+                            bucket: this.publicBucket,
+                            keyPrefix: this.options.bucketKeyPrefix ?? "",
+                            file: result.filePath.slice(publicDir.length),
+                            etag,
+                        })));
+                if (!served) {
+                    // The routing rule that matched a build asset already set its
+                    // year-long `immutable` Cache-Control, which `sendUnmatched`
+                    // replaces: under it the 404 would be cached at the edge and in
+                    // browsers for that long, and a chunk that shows up on the next
+                    // deploy would stay missing.
+                    await this.sendUnmatched(req, res, waitUntil, result, url);
+                }
+                return;
+            }
+            case "image-optimization":
+                if (!this.images.isEnabled()) {
+                    await this.sendUnmatched(req, res, waitUntil, { pathname: url.pathname, requestHeaders: result.requestHeaders }, url);
+                    return;
+                }
+                req.headers = (0, request_1.toIncomingHttpHeaders)(result.requestHeaders);
+                await this.images.handle(req, res, result.url, waitUntil);
+                return;
+            case "redirect":
+                sendRedirect(res, result.location, result.status);
+                return;
+            case "external-rewrite":
+                await proxyExternal(req, res, result.url, result.requestHeaders);
+                return;
+            case "middleware-responded":
+                await sendWebResponse(res, result.response);
+                return;
+            case "response":
+                res.end();
+                return;
+            case "not-found":
+                await this.sendUnmatched(req, res, waitUntil, result, url);
+                return;
+        }
+    }
+    /**
+     * 404 or 500 when `pathname` is the prerendered `/404` or `/500` page — under
+     * `basePath` and, in an i18n app, any locale (`/fr/404`) — and `undefined`
+     * otherwise. `next start` matches the page, not the URL, so the locale does
+     * not matter.
+     */
+    statusPageStatus(pathname) {
+        const { basePath, i18n } = this.options.manifest.config;
+        let page = (0, util_1.withoutPathPrefix)(pathname, basePath);
+        const locales = i18n?.locales;
+        for (const locale of locales ?? []) {
+            const stripped = (0, util_1.withoutPathPrefix)(page, `/${locale}`);
+            if (stripped !== page) {
+                page = stripped;
+                break;
+            }
+        }
+        if (page === "/404")
+            return 404;
+        if (page === "/500")
+            return 500;
+        return undefined;
+    }
+    /**
+     * `next start`'s answer to a path nothing serves (`router-server.js`, the
+     * "404 case"), for both ways of getting here: dispatch matched nothing, or it
+     * matched a build asset that is not in the package.
+     *
+     * No-store, always. A prerendered `/_not-found` would otherwise send its
+     * cache entry's year-long `s-maxage`, and the CDN would keep the 404 past the
+     * deploy that adds the route. Set rather than forced: Next's page handlers
+     * only write a `Cache-Control` when none is set (`sendRenderResult`,
+     * `pages-handler.js`), which is exactly how `next start`'s own no-store here
+     * survives the render. `render404` is not this path: a `notFound()` from an
+     * ISR page is cacheable for that page's revalidate period.
+     *
+     * A missing `_next/static` file, and a GET or HEAD whose `Sec-Fetch-Dest`
+     * says it cannot display HTML (an `<img>`, a script, a font), get a
+     * plain-text `Not Found` instead of the rendered page — nothing would show
+     * it, and rendering it is the expensive part.
+     *
+     * Everything else renders the app's 404 as the path that was asked for, not
+     * as `/_not-found`: the App Router serializes the canonical URL into the RSC
+     * payload, so a client hydrated off a `/_not-found` payload reports the wrong
+     * `usePathname()` and pushes the wrong history entry. It renders with the
+     * request headers middleware set, too — a CSP nonce, say.
+     */
+    async sendUnmatched(req, res, waitUntil, result, url) {
+        res.setHeader("Cache-Control", NO_STORE);
+        const { basePath, assetPrefix } = this.options.manifest.config;
+        const pathname = (0, util_1.withoutPathPrefix)((0, util_1.withoutPathPrefix)(result.pathname, basePath), assetPrefix);
+        if (pathname.startsWith("/_next/static/") ||
+            ((req.method === "GET" || req.method === "HEAD") &&
+                NON_HTML_SEC_FETCH_DESTS.has((0, util_1.firstValue)(req.headers["sec-fetch-dest"]) ?? ""))) {
+            res.statusCode = 404;
+            res.setHeader("Content-Type", "text/plain; charset=utf-8");
+            res.end("Not Found");
+            return;
+        }
+        req.headers = (0, request_1.toIncomingHttpHeaders)(result.requestHeaders);
+        await this.sendNotFound(req, res, waitUntil, this.dispatcher.notFoundFor(url), `${result.pathname}${url.search}`);
+    }
+    /**
+     * One on-demand revalidation, run against this runtime rather than over the
+     * network. Wired in as `requestMeta.revalidate`; see the comment there.
+     *
+     * The response is thrown away — only its status matters — but it goes through
+     * the full {@link handle}, so the entrypoint sees a request with
+     * `x-prerender-revalidate` on it and writes the fresh entry through the cache
+     * handler exactly as a request from outside would. `handle` awaits its own
+     * `waitUntil` work, so the new entry is committed before `res.revalidate()`
+     * resolves, which is what callers that revalidate and then redirect depend on.
+     *
+     * The accept/throw rule is `NextServer#revalidate`'s, verbatim: a revalidation
+     * is successful if it was cached or answered 200, and `notFound: true`
+     * legitimately answers 404 for an `unstable_onlyGenerated` caller. Anything
+     * else throws, and `res.revalidate()` turns it into `Failed to revalidate
+     * <path>: <message>`.
+     */
+    async revalidate(config, origin) {
+        const { head, otherGroup } = await this.handleInternally({
+            method: "GET",
+            url: config.urlPath,
+            // The caller's authority, not the revalidated path's: it is what
+            // `absoluteUrl` builds the request URL from, and a revalidation is for
+            // the origin being served. The forwarded pair with it — behind
+            // CloudFront `host` is the Function URL, and a render that built its
+            // absolute URLs from that would cache links to the raw function.
+            headers: {
+                ...config.headers,
+                host: origin.headers.host,
+                ...pickDefined(origin.headers, [
+                    "x-forwarded-host",
+                    "x-forwarded-proto",
+                ]),
+            },
+            encrypted: origin.encrypted,
+            trustForwardedHost: origin.trustForwardedHost,
+        }, {});
+        const status = head?.statusCode ?? 500;
+        if (otherGroup) {
+            const self = process.env[manifest_1.FUNCTION_GROUP_ENV_VAR];
+            // A page packaged into another `functionGroups` group: it is rendered in
+            // process, and this function does not have the page's code. Checked
+            // first because it renders as a 404, which `unstable_onlyGenerated`
+            // would otherwise accept.
+            throw new Error(`Invalid response ${status}: "${config.urlPath}" belongs to ` +
+                `\`functionGroups\` group "${otherGroup.owner}", and ` +
+                `res.revalidate() can only revalidate pages in the group it runs ` +
+                `in ("${self}"). Call it from an API route in group ` +
+                `"${otherGroup.owner}", or use revalidatePath()/revalidateTag(), ` +
+                `which work from any group.`);
+        }
+        if (head?.headers["x-nextjs-cache"] !== "REVALIDATED" &&
+            status !== 200 &&
+            !(status === 404 && config.opts.unstable_onlyGenerated)) {
+            throw new Error(`Invalid response ${status}`);
+        }
+        await invalidateRevalidatedPage(config.urlPath, this.options.manifest);
+    }
+    /**
+     * An image optimization source that is not a file: `<Image src="/api/avatar">`
+     * served by a route handler. Wired in as the optimizer's `fetchInternal`, and
+     * run in process for the reasons {@link revalidate} is — `next start` fetches
+     * the source from itself over loopback, which here would be a second billed
+     * invocation through CloudFront.
+     *
+     * Only the authority is forwarded, as `next start`'s `fetchInternalImage`
+     * forwards none of the viewer's headers: the source is cached and served to
+     * everyone, so it must not depend on one viewer's cookies.
+     */
+    async fetchInternal(href, req, maximumBody) {
+        const request = {
+            method: "GET",
+            url: href,
+            headers: pickDefined(req.headers, [
+                "host",
+                "x-forwarded-host",
+                "x-forwarded-proto",
+            ]),
+            encrypted: req.socket?.encrypted,
+            trustForwardedHost: req.trustForwardedHost,
+        };
+        const { head, body, otherGroup, tooLarge } = await this.handleInternally(request, { maximumBody });
+        if (tooLarge) {
+            return { statusCode: 0, headers: {}, body: Buffer.alloc(0), tooLarge };
+        }
+        if (otherGroup) {
+            // The edge sends every `/_next/image` request to the default group, and
+            // the source is rendered in process, so a route packaged into another
+            // group is out of reach: the optimizer answers (and logs) a 502.
+            return {
+                statusCode: 0,
+                headers: {},
+                body: Buffer.alloc(0),
+                otherGroup: otherGroup.owner,
+            };
+        }
+        return {
+            statusCode: head?.statusCode ?? 0,
+            headers: head?.headers ?? {},
+            body,
+        };
+    }
+    /**
+     * One request through {@link handle}, answered to this runtime instead of a
+     * client: the head, the body when it is wanted, and the error when the route
+     * is packaged into another `functionGroups` group. `handle` awaits the
+     * request's `waitUntil` work too, so whatever the render wrote is committed by
+     * the time this resolves.
+     *
+     * The body is kept only when `maximumBody` is set. One past it fails the
+     * response stream, which stops the route writing, and comes back as
+     * `tooLarge` rather than held in memory.
+     */
+    async handleInternally(request, options) {
+        let head;
+        const chunks = [];
+        let size = 0;
+        let tooLarge = false;
+        let otherGroup;
+        const onRouteInOtherGroup = (error) => {
+            otherGroup = error;
+        };
+        await this.handle({ ...request, onRouteInOtherGroup }, {
+            begin(responseHead) {
+                head = responseHead;
+                return new node_stream_1.Writable({
+                    write(chunk, _encoding, callback) {
+                        if (options.maximumBody === undefined)
+                            return callback();
+                        size += chunk.byteLength;
+                        if (size > options.maximumBody) {
+                            tooLarge = true;
+                            return callback(new Error("Over images.maximumResponseBody"));
+                        }
+                        chunks.push(Buffer.from(chunk));
+                        callback();
+                    },
+                });
+            },
+        });
+        return {
+            head,
+            body: tooLarge ? Buffer.alloc(0) : Buffer.concat(chunks),
+            otherGroup,
+            tooLarge,
+        };
+    }
+    /**
+     * App Router builds an invocable `/_not-found`, Pages Router a prerendered
+     * `404.html` (per locale under i18n) or else `/_error`; see `statusTargets`.
+     */
+    async sendNotFound(req, res, waitUntil, target, 
+    /**
+     * What to render the 404 as. Omitted by `render404`, which is called
+     * mid-render with `req.url` already pointing at the route that gave up —
+     * the path Next.js would render that 404 for.
+     */
+    requestedUrl) {
+        res.statusCode = 404;
+        if (target.kind === "entrypoint") {
+            const handler = await this.entrypoints.load(target.entrypoint);
+            req.url = requestedUrl ?? req.url;
+            await handler(req, (0, response_1.asServerResponse)(res), { waitUntil });
+            if (!res.writableEnded) {
+                res.end();
+            }
+            return;
+        }
+        if (target.kind === "static-file" &&
+            (await this.sendHtmlFile(res, target))) {
+            return;
+        }
+        res.setHeader("Content-Type", "text/plain; charset=utf-8");
+        res.end("This page could not be found.");
+    }
+    /**
+     * Turn a thrown error into a response, rendering the app's error page when it
+     * has one.
+     *
+     * Next.js's own page handlers catch, report and then *rethrow* ("rethrow so
+     * that we can handle serving error page", `pages-handler.ts`), which makes the
+     * error page the host's job — the same division of labor as `render404`. Without
+     * this ladder every throw answered a bare `text/plain` 500 and a custom
+     * `pages/_error` was dead code (`test/e2e/async-modules`, whose `/make-error`
+     * throws in `getServerSideProps`).
+     *
+     * Once the head is out there is nothing to say — destroying the stream is what
+     * tells the client the response is truncated rather than complete.
+     */
+    async sendError(req, res, waitUntil, error, 
+    /** The request, as received: which locale's prerendered 500 to send. */
+    url) {
+        console.error("Unhandled error while handling the request:", error);
+        if (res.headersSent) {
+            res.destroy(asError(error));
+            return;
+        }
+        res.statusCode = 500;
+        // A failed render may have set headers describing a body that never
+        // arrived. Every rung below sends a different body, so they go first: a
+        // stale `Content-Length` on a 500.html of another size hangs the client or
+        // desyncs a keep-alive connection.
+        res.removeHeader("Content-Length");
+        res.removeHeader("ETag");
+        // Every rung, the error-page entrypoint included: otherwise the throwing
+        // render's `s-maxage` (or a `headers()` rule's) rides along and CloudFront
+        // caches the 500. `next start` sets it before rendering the error page too.
+        res.setHeader("Cache-Control", NO_STORE);
+        const target = this.errorTargetFor(url);
+        if (target.kind === "entrypoint") {
+            try {
+                const handler = await this.entrypoints.load(target.entrypoint);
+                // `req.url` is left alone: the error page renders for the URL that was
+                // asked for, and `_error`'s `getInitialProps` reads the status off `res`,
+                // which is why the 500 above is set first.
+                await handler(req, (0, response_1.asServerResponse)(res), { waitUntil });
+                if (!res.writableEnded) {
+                    res.end();
+                }
+                return;
+            }
+            catch (errorPageError) {
+                console.error("The error page itself failed to render:", errorPageError);
+                if (res.headersSent) {
+                    res.destroy(asError(errorPageError));
+                    return;
+                }
+            }
+        }
+        if (target.kind === "static-file" &&
+            (await this.sendHtmlFile(res, target))) {
+            return;
+        }
+        // Again: an error page that threw may have described its own body too.
+        res.removeHeader("Content-Length");
+        res.removeHeader("ETag");
+        res.statusCode = 500;
+        res.setHeader("Content-Type", "text/plain; charset=utf-8");
+        res.setHeader("Cache-Control", NO_STORE);
+        res.end("Internal Server Error");
+    }
+    /**
+     * A prerendered 404 or 500 page, or `false` when it cannot be read and the
+     * caller's plain-text fallback should answer. Read rather than `serveStatic`,
+     * which keeps the status already set but would answer a `Range` request with
+     * a 206 of the error page, and add `ETag`, `Last-Modified` and, where none is
+     * set yet, a public `Cache-Control` to it.
+     */
+    async sendHtmlFile(res, target) {
+        let html;
+        try {
+            html = await (0, promises_1.readFile)((0, node_path_1.join)(this.options.deploymentRoot, target.filePath));
+        }
+        catch {
+            return false;
+        }
+        res.setHeader("Content-Type", "text/html; charset=utf-8");
+        res.end(html);
+        return true;
+    }
+}
+exports.NextjsRuntime = NextjsRuntime;
+/**
+ * What next sends with an error it rendered itself. Without it a `Cache-Control`
+ * left behind by the render that threw can get a 500 cached at the edge.
+ */
+const NO_STORE = "private, no-cache, no-store, max-age=0, must-revalidate";
+/**
+ * `Sec-Fetch-Dest` values that can never display an HTML response, from
+ * `next/dist/server/lib/is-non-html-sec-fetch-dest.js`. Restated rather than
+ * required, because that module is recent and the app's `next` may predate it:
+ * a failed require here would turn every 404 into a 500. Excludes `document`,
+ * `iframe` and the like, and `empty` — `fetch()`, which is how RSC requests go.
+ */
+const NON_HTML_SEC_FETCH_DESTS = new Set([
+    "audio",
+    "audioworklet",
+    "font",
+    "image",
+    "json",
+    "manifest",
+    "paintworklet",
+    "report",
+    "script",
+    "serviceworker",
+    "sharedworker",
+    "style",
+    "track",
+    "video",
+    "webidentity",
+    "worker",
+    "xslt",
+]);
+/**
+ * `INTERNAL_HEADERS` from `next/dist/server/lib/server-ipc/utils.js` (Next
+ * 16.3), which `next start` deletes from every request before routing it
+ * (`filterInternalHeaders` in `router-server.js`). They are signals between
+ * Next's own router and render layers; honoring one a client sent lets it steer
+ * those layers — `next-resume` makes a PPR page resume from a postponed state
+ * the client supplies. Restated rather than required, like
+ * {@link NON_HTML_SEC_FETCH_DESTS}.
+ */
+const INTERNAL_HEADERS = new Set([
+    "x-middleware-rewrite",
+    "x-middleware-redirect",
+    "x-middleware-set-cookie",
+    "x-middleware-skip",
+    "x-middleware-override-headers",
+    "x-middleware-next",
+    "x-now-route-matches",
+    "x-matched-path",
+    "x-nextjs-data",
+    "x-next-resume-state-length",
+    "next-resume",
+]);
+/**
+ * The request headers with {@link INTERNAL_HEADERS} removed, and `x-nextjs-data`
+ * put back for a `_next/data` request, which is what `next start`'s
+ * `resolveRoutes` does (`setIsNextDataRequest`) right after stripping it: the
+ * header is internal, but Next's handlers and middleware still read it — it is
+ * how a data request gets `x-nextjs-matched-path` — so a real data request has
+ * to keep it.
+ */
+function withoutInternalHeaders(headers, target, basePath) {
+    const filtered = {};
+    for (const [name, value] of Object.entries(headers)) {
+        if (!INTERNAL_HEADERS.has(name)) {
+            filtered[name] = value;
+        }
+    }
+    const pathname = (0, util_1.withoutPathPrefix)(target.split("?")[0], basePath);
+    if (pathname.startsWith("/_next/data/") && pathname.endsWith(".json")) {
+        filtered["x-nextjs-data"] = "1";
+    }
+    return filtered;
+}
+/**
+ * Invalidate the CDN copies of a page `res.revalidate()` just regenerated: its
+ * HTML and RSC payload, and its Pages Router `_next/data` JSON. Without this the
+ * fresh entry sat behind CloudFront's copy of the old one for the page's whole
+ * `s-maxage` — a year, for an on-demand-only ISR page. `revalidatePath` and
+ * `revalidateTag` go through the cache handler's `revalidateTag`, which already
+ * invalidates; `res.revalidate()` does not touch it.
+ *
+ * Every route is without `basePath`, which the hook prefixes. A no-op outside
+ * the Global constructs, where no hook is registered.
+ */
+async function invalidateRevalidatedPage(urlPath, manifest) {
+    const hook = globalThis[manifest_1.REVALIDATED_PAGE_HOOK];
+    if (typeof hook !== "function") {
+        return;
+    }
+    const route = (0, util_1.withoutPathPrefix)(urlPath.split("?")[0], manifest.config.basePath);
+    try {
+        // One call, deduplicated: the default locale's two pairs share a data
+        // route, and each invalidation path counts against CloudFront's quota.
+        await hook([...new Set(revalidatedPageRoutes(route, manifest).flat())]);
+    }
+    catch (error) {
+        // The regeneration itself succeeded; the edge catches up at `s-maxage`.
+        console.warn(`Could not invalidate the CDN copy of ${urlPath}:`, error);
+    }
+}
+/**
+ * The `[route, dataRoute]` pairs a revalidated page is cached under at the edge.
+ *
+ * In an i18n app the Next client always puts the locale in a data href, the
+ * default locale included (`/_next/data/<id>/en/blog.json`, and `…/en.json` for
+ * the root), so the unprefixed data route names nothing CloudFront holds. The
+ * page is one locale's — `res.revalidate("/blog")` regenerates the default
+ * locale's, `"/fr/blog"` French — and the default locale's HTML is reachable,
+ * and cached, both with and without its prefix, so its two pairs share a data
+ * route, which the caller sends once.
+ */
+function revalidatedPageRoutes(route, manifest) {
+    const dataRoute = (page) => `/_next/data/${manifest.buildId}${page === "/" ? "/index" : page.replace(/\/+$/, "")}.json`;
+    const i18n = manifest.config.i18n;
+    if (!i18n?.defaultLocale) {
+        return [[route, dataRoute(route)]];
+    }
+    const { defaultLocale } = i18n;
+    const segment = route.split("/")[1] ?? "";
+    const locale = (i18n.locales ?? []).includes(segment)
+        ? segment
+        : defaultLocale;
+    const page = locale === segment ? (0, util_1.withoutPathPrefix)(route, `/${segment}`) : route;
+    const localized = page === "/" ? `/${locale}` : `/${locale}${page}`;
+    // The root's data route is the locale itself, not `/<locale>/index`.
+    const localizedData = `/_next/data/${manifest.buildId}${localized.replace(/\/+$/, "")}.json`;
+    return locale === defaultLocale
+        ? [
+            [page, localizedData],
+            [localized, localizedData],
+        ]
+        : [[localized, localizedData]];
+}
+function asError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+/**
+ * Read the manifest and pin the layout it describes.
+ *
+ * `process.cwd()` is load-bearing and there is exactly one chance to get it
+ * right: Next.js inlines `relative(buildCwd, projectDir)` into every entrypoint
+ * and resolves it against the *runtime* cwd to find
+ * `required-server-files.json`, the prerender manifest, and the app's chunks.
+ * `assertBuildCwd` in `build-outputs.ts` keeps that inlined value `""`, so the
+ * whole invariant reduces to "cwd is the staged project dir" — asserted rather
+ * than assumed, because getting it wrong produces a
+ * `Cannot find module …/required-server-files.json` from inside compiled Next.js
+ * code with no indication that the layout is the problem.
+ */
+async function loadRuntime(deploymentRoot) {
+    const manifestPath = (0, manifest_1.deployedManifestPath)(deploymentRoot);
+    let manifest;
+    try {
+        manifest = JSON.parse(await (0, promises_1.readFile)(manifestPath, "utf-8"));
+    }
+    catch (error) {
+        throw new Error(`Could not read the cdk-nextjs adapter manifest at "${manifestPath}". ` +
+            `The deployment package is incomplete: synth copies ` +
+            `${manifest_1.MANIFEST_FILE_NAME} in next to the bundled runtime.`, { cause: error });
+    }
+    const projectDir = (0, node_path_1.join)(deploymentRoot, manifest.relativeProjectDir);
+    const probe = (0, node_path_1.join)(projectDir, manifest.config.distDir, "required-server-files.json");
+    try {
+        await (0, promises_1.readFile)(probe);
+    }
+    catch (error) {
+        throw new Error(`The deployment root "${deploymentRoot}" does not contain the staged ` +
+            `Next.js project: expected "${probe}" to exist. Every built entrypoint ` +
+            `resolves its own paths against process.cwd(), so this layout is part ` +
+            `of the contract, not a convenience.`, { cause: error });
+    }
+    // `next start` forces this, and externalized packages (React for Pages Router
+    // SSR, anything in `serverExternalPackages`) pick their dev or prod build from
+    // it at require time. The Containers Dockerfiles set it and the Functions
+    // constructs do too; this covers a hand-wired function. Before any `require`.
+    // (`next`'s typings declare NODE_ENV read-only.)
+    process.env.NODE_ENV ??= "production";
+    process.chdir(projectDir);
+    // Before anything can serve a request: the runtime's own `next` imports resolve
+    // out of the staged app, not out of the shell's directory. See `next-modules.ts`.
+    (0, next_modules_1.useNextFrom)(projectDir);
+    // Before any entrypoint can read them at module scope.
+    (0, next_modules_1.loadEnvFiles)(projectDir);
+    // Then, before any entrypoint (or middleware) can be loaded: Next's own
+    // node-environment bootstrap. See `setupNodeEnvironment`.
+    (0, next_modules_1.setupNodeEnvironment)();
+    // And last, once the environment is ready: `register()`, before any entrypoint
+    // or middleware module is evaluated. See `registerInstrumentation`.
+    await (0, next_modules_1.registerInstrumentation)(projectDir, manifest.config.distDir);
+    return new NextjsRuntime({
+        deploymentRoot,
+        manifest,
+        bucket: process.env.CDK_NEXTJS_STATIC_ASSETS_BUCKET_NAME,
+        bucketKeyPrefix: process.env.CDK_NEXTJS_STATIC_ASSETS_KEY_PREFIX,
+    });
+}
+/**
+ * A syntactically valid `host[:port]`: a registered name or a bracketed IPv6
+ * literal, optionally with a port. Anything else cannot be the authority of a
+ * URL.
+ */
+const HOST_AUTHORITY = /^(?:\[[0-9A-Fa-f:.]+\]|[0-9A-Za-z._-]+)(?::\d{1,5})?$/;
+/**
+ * The first value that is actually usable as an authority, or `undefined`.
+ *
+ * `x-forwarded-host` can arrive as a list when more than one proxy appends to
+ * it. Validating is what keeps a malformed value from making the `URL`
+ * constructor throw — which on the Lambda shells is an invocation error and a
+ * 502, not a response.
+ */
+function validAuthority(value) {
+    const candidate = (0, util_1.firstValue)(value)?.split(",")[0].trim();
+    return candidate && HOST_AUTHORITY.test(candidate) ? candidate : undefined;
+}
+/**
+ * `resolveRoutes` needs an absolute URL, and it becomes the origin every
+ * absolute URL the app builds starts with — `req.nextUrl.origin` in middleware,
+ * `initURL` for a route handler — so its host has to be one the client cannot
+ * pick.
+ *
+ * That is `Host` on every deployment but one: CloudFront forwards the viewer's
+ * `Host` to a container origin (`ALL_VIEWER`), an ALB passes it through, and API
+ * Gateway sets its own domain. The exception is a Lambda Function URL, where
+ * CloudFront has to send the URL's own domain as `Host` and puts the viewer's in
+ * `x-forwarded-host`; see {@link RuntimeRequest.trustForwardedHost}. Anywhere
+ * else the header is the client's, and honoring it let a request with
+ * `X-Forwarded-Host: evil.example` point a password-reset link at evil.example —
+ * and, on Global Containers, have CloudFront cache that page, since the header
+ * is not in its cache key.
+ */
+function absoluteUrl(request) {
+    const host = (request.trustForwardedHost
+        ? validAuthority(request.headers["x-forwarded-host"])
+        : undefined) ??
+        validAuthority(request.headers.host) ??
+        "localhost";
+    // Behind CloudFront on Global Containers the container shell has already put
+    // the viewer's protocol here; see `trustCloudFrontProto` in http/node-server.ts.
+    const forwardedProto = (0, util_1.firstValue)(request.headers["x-forwarded-proto"])
+        ?.split(",")[0]
+        .trim()
+        .toLowerCase();
+    // Client-supplied where no proxy overwrites it, but harmless: the host is
+    // already fixed, and anything but these two would not parse.
+    const proto = forwardedProto === "http" || forwardedProto === "https"
+        ? forwardedProto
+        : request.encrypted === false
+            ? "http"
+            : "https";
+    return new URL(request.url, `${proto}://${host}`);
+}
+function pickDefined(headers, names) {
+    const picked = {};
+    for (const name of names) {
+        if (headers[name] !== undefined) {
+            picked[name] = headers[name];
+        }
+    }
+    return picked;
+}
+/**
+ * `normalizeRepeatedSlashes` (`next/dist/shared/lib/utils.js`), applied where
+ * Next.js applies it: before routing, as a 308 to the collapsed path.
+ * `base-server.ts` does `if (urlNoQuery?.match(/(\\|\/\/)/))
+ * res.redirect(normalizeRepeatedSlashes(req.url), 308)`, so `/a//b` and `/a\b`
+ * both answer a redirect to `/a/b` rather than a 404 - and `@next/routing`'s
+ * `resolveRoutes` does not do it for us, which is how `//` reached this runtime as
+ * a 500 and `/api//json` as a 404.
+ *
+ * Encoded backslashes are left alone, as Next.js leaves them: `%5C` is a literal
+ * character in a path segment, not a separator.
+ *
+ * Returns `undefined` when there is nothing to collapse, which is the common case.
+ */
+function collapseRepeatedSlashes(target) {
+    const parts = target.split("?");
+    const pathname = parts[0];
+    if (!/\\|\/\//.test(pathname)) {
+        return undefined;
+    }
+    const query = parts.length > 1 ? `?${parts.slice(1).join("?")}` : "";
+    return pathname.replace(/\\/g, "/").replace(/\/\/+/g, "/") + query;
+}
+/**
+ * `resolveRoutes` hands `requestBody` to middleware, which consumes it, while the
+ * entrypoint needs the same bytes — the same problem `next-server` solves with
+ * `getCloneableBody()`. Only split when there is middleware to feed: teeing costs
+ * a buffer copy of every upload on a path that would otherwise be a straight pipe.
+ *
+ * A `tee()` buffers, for the branch that is behind, every chunk the other one
+ * has read — so a branch that is never read holds the whole body. Middleware
+ * that doesn't read the body is the common case (and its matcher may not even
+ * have run it), after which the entrypoint streaming an upload would pile all
+ * of it up in the middleware branch: the whole upload in memory, on a
+ * container that serves other requests. So once dispatch returns, the branch
+ * with no reader left is cancelled — the middleware one, or the entrypoint one
+ * when middleware answered and `req` will never be read. Cancelling one
+ * branch leaves the source and the other branch running.
+ */
+function splitBody(body, hasMiddleware) {
+    const releaseNothing = () => { };
+    if (body === undefined) {
+        return {
+            forDispatch: new Blob([]).stream(),
+            releaseUnread: releaseNothing,
+        };
+    }
+    if (!hasMiddleware) {
+        return {
+            forRequest: body,
+            forDispatch: new Blob([]).stream(),
+            releaseUnread: releaseNothing,
+        };
+    }
+    if (Buffer.isBuffer(body)) {
+        // Already fully in memory, so "teeing" is just reading it twice.
+        return {
+            forRequest: body,
+            forDispatch: new Blob([body]).stream(),
+            releaseUnread: releaseNothing,
+        };
+    }
+    const [forMiddleware, forEntrypoint] = node_stream_1.Readable.toWeb(body).tee();
+    const forRequest = node_stream_1.Readable.fromWeb(forEntrypoint);
+    return {
+        forRequest,
+        forDispatch: forMiddleware,
+        releaseUnread(middlewareResponded) {
+            if (middlewareResponded) {
+                // `fromWeb` holds the branch's reader, so it is destroyed rather than
+                // cancelled; its `_destroy` cancels the reader.
+                forRequest.destroy();
+            }
+            else if (!forMiddleware.locked) {
+                // Locked means middleware took a reader: it is reading, or has read,
+                // the body itself, and a locked stream cannot be cancelled anyway.
+                forMiddleware.cancel().catch(() => { });
+            }
+        },
+    };
+}
+/** `IncomingHttpHeaders` → the flat entries a `Headers` constructor accepts. */
+function toWebHeaders(headers) {
+    const entries = [];
+    for (const [name, value] of Object.entries(headers)) {
+        if (value === undefined) {
+            continue;
+        }
+        for (const single of Array.isArray(value) ? value : [value]) {
+            entries.push([name, single]);
+        }
+    }
+    return entries;
+}
+/**
+ * `headers()` rules, the immutable `cache-control` for build assets, and anything
+ * middleware set with `NextResponse.next({ headers })`. Applied before the
+ * entrypoint runs so that a route can still override its own.
+ */
+function applyHeaders(res, headers) {
+    for (const [name, value] of headers.entries()) {
+        // `entries()` yields `set-cookie` once per cookie, so appending the whole
+        // `getSetCookie()` array here would emit N² of them — two cookies set by
+        // middleware arrived as ["a=1","b=2","a=1","b=2"]. Handled once, outside.
+        if (name === "set-cookie") {
+            continue;
+        }
+        res.setHeader(name, value);
+    }
+    for (const cookie of headers.getSetCookie()) {
+        res.appendHeader("set-cookie", cookie);
+    }
+}
+/**
+ * Mirrors Next.js's own redirect response (`base-server.ts`): the destination is
+ * also the body, and a 308 carries a `Refresh` header because some clients and
+ * intermediaries still do not implement 308.
+ */
+function sendRedirect(res, location, status) {
+    res.statusCode = status;
+    res.setHeader("Location", location);
+    if (status === 308) {
+        res.setHeader("Refresh", `0;url=${location}`);
+    }
+    res.setHeader("Content-Type", "text/plain; charset=utf-8");
+    res.end(location);
+}
+/**
+ * `next start`'s answer to a POST, PUT or DELETE for a static file: 405 with
+ * `Allow: GET, HEAD` (`router-server.js`). It renders that through `/_error`;
+ * this is the plain-text equivalent, since the status and `Allow` are what a
+ * client acts on.
+ */
+function sendMethodNotAllowed(res) {
+    res.statusCode = 405;
+    res.setHeader("Allow", "GET, HEAD");
+    res.setHeader("Content-Type", "text/plain; charset=utf-8");
+    res.end("Method Not Allowed");
+}
+/**
+ * Request headers {@link proxyExternal} does not forward. The upstream's own
+ * `Host` must win; the rest describe our connection, not the proxied one, and
+ * undici throws on most of them, which would answer the request with a 500.
+ * Next.js's list for the requests it makes with undici (`ipcForbiddenHeaders`,
+ * `next/dist/server/lib/server-ipc/utils.js`), plus `host` and `upgrade`, minus
+ * `content-encoding`: Next strips that over a body it has already decoded, while
+ * this one is forwarded as received, still encoded.
+ */
+const PROXY_DROPPED_HEADERS = [
+    "host",
+    "upgrade",
+    "accept-encoding",
+    "keepalive",
+    "keep-alive",
+    "transfer-encoding",
+    "connection",
+    "expect",
+];
+/**
+ * The SigV4 signature Origin Access Control put on a request to the Function
+ * URL, also dropped by {@link proxyExternal} when the request was IAM-verified:
+ * forwarded, it would let the third-party origin replay the request against
+ * the Function URL. Anywhere else these are the client's own, and are
+ * forwarded as `next start` forwards them.
+ */
+const SIGV4_HEADERS = [
+    "authorization",
+    "x-amz-date",
+    "x-amz-content-sha256",
+    "x-amz-security-token",
+];
+/** A `next.config` rewrite whose destination is another origin. */
+async function proxyExternal(req, res, url, requestHeaders) {
+    const method = req.method ?? "GET";
+    const hasBody = method !== "GET" && method !== "HEAD";
+    const headers = new Headers(requestHeaders);
+    for (const name of PROXY_DROPPED_HEADERS) {
+        headers.delete(name);
+    }
+    if (req.trustForwardedHost) {
+        for (const name of SIGV4_HEADERS) {
+            headers.delete(name);
+        }
+    }
+    const upstream = await fetch(url, {
+        method,
+        headers,
+        body: hasBody ? node_stream_1.Readable.toWeb(req) : undefined,
+        redirect: "manual",
+        ...(hasBody ? { duplex: "half" } : {}),
+    });
+    await sendWebResponse(res, upstream);
+}
+/**
+ * Headers describing the framing of a body that is no longer the body being
+ * sent, dropped from every `Response` {@link sendWebResponse} forwards.
+ *
+ * A proxied origin's `Response` came back from `fetch`, and so, often, did
+ * middleware's own (`return fetch(upstream)` in `proxy.ts`, since middleware
+ * runs in process and its `fetch` is undici). undici decodes the body — gzip,
+ * deflate, br, zstd — and leaves `content-encoding` and `content-length`
+ * describing the encoded bytes it already threw away. Forwarding them emits
+ * plaintext labelled `gzip` (the browser fails the whole response with
+ * `ERR_CONTENT_DECODING_FAILED`) under a `Content-Length` that is too short,
+ * and `shouldGzip` then declines to compress it because `content-encoding` is
+ * already set, so nothing downstream repairs it. `transfer-encoding` is
+ * hop-by-hop: it described the upstream connection, not this one.
+ *
+ * Stock Next.js drops the same three from every middleware response
+ * (`FORBIDDEN_HEADERS` in `next/dist/server/web/sandbox/sandbox.js`), so
+ * middleware cannot label a body it encoded itself there either.
+ */
+const STALE_FRAMING_HEADERS = new Set([
+    "content-encoding",
+    "content-length",
+    "transfer-encoding",
+]);
+/** Stream a `Response` — middleware's own, or a proxied origin's — into `res`. */
+async function sendWebResponse(res, response) {
+    res.statusCode = response.status;
+    if (response.statusText) {
+        res.statusMessage = response.statusText;
+    }
+    const headers = new Headers(response.headers);
+    for (const name of STALE_FRAMING_HEADERS) {
+        headers.delete(name);
+    }
+    applyHeaders(res, headers);
+    if (!response.body) {
+        res.end();
+        return;
+    }
+    for await (const chunk of response.body) {
+        // Leaving the loop cancels the body, which is what stops a proxied origin
+        // from being read to the end for a client that has already gone.
+        if (res.destroyed) {
+            return;
+        }
+        // Paced by the client: without waiting for `drain`, a large proxied body
+        // headed for a slow client is buffered whole in memory.
+        const accepted = res.write(chunk);
+        // Set by the sink when it compresses. Without it the chunk sits in zlib's
+        // buffer, and a streamed body — server-sent events through a rewrite, a
+        // middleware `ReadableStream` — reaches the client all at once, at the end.
+        // Next.js flushes after every chunk for the same reason (`pipe-readable`).
+        res.flush?.();
+        if (!accepted && !(await (0, util_1.drained)(res))) {
+            return;
+        }
+    }
+    res.end();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"core.js","sourceRoot":"","sources":["../../src/runtime/core.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\n/**\n * The runtime core: one `handle(request, sink)` that both shells wrap.\n *\n * The Lambda shell (`lambda.mts`) and the container shell (`server.mts`) do\n * nothing but turn their input into a {@link RuntimeRequest} and their output into\n * a {@link ResponseSink}. Everything else — synthesizing `req`/`res`, dispatch,\n * middleware, entrypoint invocation, static files, image optimization, gzip,\n * `waitUntil` — happens here, so the container e2e suite exercises the same code\n * Lambda runs. That is deliberate: the container path used to get real\n * `node:http` objects from Lambda Web Adapter, which meant container tests proved\n * nothing about Lambda.\n */\nimport { readFile } from \"node:fs/promises\";\nimport type { IncomingHttpHeaders } from \"node:http\";\nimport { join } from \"node:path\";\nimport { Readable, Writable } from \"node:stream\";\nimport { caseCanonicalPath } from \"./case-redirect\";\nimport {\n  Dispatcher,\n  outOfBandRouteParams,\n  StatusTarget,\n  statusTargets,\n} from \"./dispatch\";\nimport {\n  EntrypointHandler,\n  EntrypointRegistry,\n  RouteInOtherGroupError,\n} from \"./entrypoints\";\nimport { ShimIncomingMessage, toIncomingHttpHeaders } from \"./http/request\";\nimport {\n  asServerResponse,\n  ResponseHead,\n  ShimServerResponse,\n} from \"./http/response\";\nimport { pipeToSink, ResponseSink } from \"./http/sink\";\nimport { InternalImageResponse, RuntimeImageOptimizer } from \"./image\";\nimport {\n  AdapterManifest,\n  deployedManifestPath,\n  FUNCTION_GROUP_ENV_VAR,\n  MANIFEST_FILE_NAME,\n  REVALIDATED_PAGE_HOOK,\n} from \"./manifest\";\nimport { MiddlewareRunner } from \"./middleware\";\nimport {\n  loadEnvFiles,\n  registerInstrumentation,\n  setupNodeEnvironment,\n  useNextFrom,\n} from \"./next-modules\";\nimport { publicDirKey, resolvePublicFiles } from \"./public-files\";\nimport { serveS3PublicFile, serveStaticFile } from \"./static-files\";\nimport { drained, firstValue, toSearch, withoutPathPrefix } from \"./util\";\n\n/** One request, normalized by a shell. */\nexport interface RuntimeRequest {\n  readonly method: string;\n  /** Origin-form target exactly as received: path + query, never absolute. */\n  readonly url: string;\n  readonly headers: IncomingHttpHeaders;\n  readonly body?: Readable | Buffer;\n  readonly remoteAddress?: string;\n  /** `false` behind a TLS-terminating ALB. Only affects the synthesized socket. */\n  readonly encrypted?: boolean;\n  /**\n   * Aborted when the client disconnects. Wiring it to `res.destroy()` is what\n   * makes `request.signal.onabort` fire inside route handlers.\n   */\n  readonly signal?: AbortSignal;\n  /**\n   * Whether `x-forwarded-host` names the host the client asked for. Only the\n   * shell can know: it is `true` for a Function URL event whose SigV4 Lambda\n   * verified. That is any IAM-authorized invoker — in practice CloudFront's\n   * Origin Access Control, whose viewer-request function overwrites the header\n   * with the viewer's `Host` (CloudFront has to replace `Host` itself with the\n   * Function URL's domain), plus principals granted `lambda:InvokeFunctionUrl`,\n   * who could replace the function's code anyway. It is also what\n   * `proxyExternal` drops OAC's signature on. Everywhere else the header is\n   * whatever the client sent, and it is\n   * ignored, as `next start` ignores it without `experimental.trustHostHeader`.\n   */\n  readonly trustForwardedHost?: boolean;\n  /**\n   * Set by {@link NextjsRuntime.handleInternally} for the in-process requests it\n   * makes: called with the `RouteInOtherGroupError` the route threw, instead of\n   * logging the misrouted-request warning, which describes a CloudFront or API\n   * Gateway problem this is not.\n   */\n  readonly onRouteInOtherGroup?: (error: RouteInOtherGroupError) => void;\n}\n\n/**\n * `RevalidateFn`'s argument (`next/dist/server/lib/router-utils/router-server-context`),\n * restated because that module is not part of `next`'s published type surface.\n */\ninterface RevalidateConfig {\n  readonly urlPath: string;\n  readonly headers: { [key: string]: string | string[] };\n  readonly opts: { unstable_onlyGenerated?: boolean };\n}\n\nexport interface NextjsRuntimeOptions {\n  /**\n   * Absolute path to the deployment root — the staged tree every manifest key\n   * resolves against. `LAMBDA_TASK_ROOT` for Functions, the image `WORKDIR` for\n   * Containers; both shells derive it from their own location instead.\n   */\n  readonly deploymentRoot: string;\n  readonly manifest: AdapterManifest;\n  /** `CDK_NEXTJS_STATIC_ASSETS_BUCKET_NAME`. */\n  readonly bucket?: string;\n  /** `CDK_NEXTJS_STATIC_ASSETS_KEY_PREFIX`. */\n  readonly bucketKeyPrefix?: string;\n}\n\nexport class NextjsRuntime {\n  private readonly entrypoints: EntrypointRegistry;\n  private readonly dispatcher: Dispatcher;\n  private readonly middleware?: MiddlewareRunner;\n  private readonly images: RuntimeImageOptimizer;\n  /** The 500 ladder; see `statusTargets`. */\n  private readonly errorTargetFor: (url: URL | undefined) => StatusTarget;\n  /** The assets bucket, when `public/` files are served from it. */\n  private readonly publicBucket?: string;\n\n  public constructor(private readonly options: NextjsRuntimeOptions) {\n    const { manifest, deploymentRoot } = options;\n    this.entrypoints = new EntrypointRegistry(deploymentRoot, manifest);\n    // Listed once, at cold start; see `resolvePublicFiles`.\n    const publicFiles = resolvePublicFiles(deploymentRoot, manifest);\n    this.dispatcher = new Dispatcher({\n      manifest,\n      publicFiles: publicFiles.files,\n    });\n    // On disk otherwise, with `.next/static`.\n    this.publicBucket = publicFiles.inS3 ? options.bucket : undefined;\n    this.errorTargetFor = statusTargets(manifest, 500);\n    this.images = new RuntimeImageOptimizer({\n      deploymentRoot,\n      manifest,\n      bucket: this.publicBucket ?? \"\",\n      bucketKeyPrefix: options.bucketKeyPrefix ?? \"\",\n      fetchInternal: (href, req, maximumBody) =>\n        this.fetchInternal(href, req, maximumBody),\n    });\n    // The runner is shared — it memoizes the loaded middleware module — while the\n    // `invokeMiddleware` callback it produces is per request.\n    this.middleware = manifest.middleware\n      ? new MiddlewareRunner({\n          middleware: manifest.middleware,\n          root: deploymentRoot,\n        })\n      : undefined;\n  }\n\n  public get manifest(): AdapterManifest {\n    return this.options.manifest;\n  }\n\n  public async handle(\n    request: RuntimeRequest,\n    sink: ResponseSink,\n  ): Promise<void> {\n    const { manifest } = this.options;\n    const pending: Array<Promise<unknown>> = [];\n    const waitUntil = (promise: Promise<unknown>) => {\n      pending.push(promise);\n    };\n\n    const body = splitBody(request.body, this.middleware !== undefined);\n    const req = new ShimIncomingMessage({\n      method: request.method,\n      url: request.url,\n      headers: withoutInternalHeaders(\n        request.headers,\n        request.url,\n        manifest.config.basePath,\n      ),\n      body: body.forRequest,\n      remoteAddress: request.remoteAddress,\n      encrypted: request.encrypted,\n      trustForwardedHost: request.trustForwardedHost,\n    });\n    const res = new ShimServerResponse();\n    // Next.js reads `res.req` in a few error paths.\n    res.req = req;\n    request.signal?.addEventListener(\"abort\", () => res.destroy(), {\n      once: true,\n    });\n\n    // The rejection handler is attached here rather than at the `await` below.\n    // `route()` awaits real I/O, so a stream that breaks while it runs would\n    // leave this promise rejected with no handler attached for a full event-loop\n    // turn — and Node 24 defaults to `--unhandled-rejections=throw`, which on\n    // the container shell takes the whole task down and aborts every other\n    // in-flight request on it. A mid-stream EPIPE from one client disconnect is\n    // not grounds for that.\n    //\n    // The error is logged, not rethrown: the stream broke after (or while) the\n    // head went out — a client disconnect, or `sendError` destroying a\n    // half-written response — and neither is an invocation failure. Rethrowing\n    // would make Lambda retry a request the client already abandoned.\n    const finished = pipeToSink(req, res, sink, {\n      compress: manifest.config.compress,\n    }).catch((error: unknown) => {\n      console.error(\"The response stream did not complete:\", error);\n    });\n\n    // For the error page's locale; unset when the throw is `absoluteUrl`'s.\n    let url: URL | undefined;\n    try {\n      // Before anything parses the target, including `absoluteUrl` - `new URL`\n      // reads a leading `//` as protocol-relative and would take the first path\n      // segment for the host.\n      const collapsed = collapseRepeatedSlashes(request.url);\n      if (collapsed !== undefined) {\n        sendRedirect(res, collapsed, 308);\n      } else {\n        // Inside the try: `absoluteUrl` builds a `URL` out of the request line\n        // and the forwarded headers, and a throw here has to reach the error\n        // ladder like any other. Outside it, on the Lambda shells — whose\n        // handlers wrap nothing — the same throw is an invocation error and a\n        // 502.\n        url = absoluteUrl(request);\n        await this.route(req, res, url, body, waitUntil, request);\n      }\n    } catch (error) {\n      await this.sendError(req, res, waitUntil, error, url);\n    }\n\n    await finished;\n\n    // Lambda freezes the execution environment the moment the handler resolves —\n    // there is no post-response keepalive — so background work registered with\n    // `waitUntil` (notably ISR revalidation) has to be awaited here. After the\n    // response stream has closed, so client latency is unaffected; billed\n    // duration extends, which is the correct trade against a revalidation that\n    // never completes.\n    //\n    // Drained until nothing new arrives, not awaited once: `waitUntil` keeps\n    // being called after the response — Next's `AfterContext` registers its\n    // callback queue on the first `after()`, and an `after(promise)` made from\n    // inside a running callback, or a background regeneration that itself calls\n    // `after()`, registers more. A single `allSettled` snapshots the array and\n    // lets Lambda freeze on that late work.\n    let settledCount = 0;\n    while (settledCount < pending.length) {\n      const batch = pending.slice(settledCount);\n      settledCount = pending.length;\n      const settled = await Promise.allSettled(batch);\n      for (const result of settled) {\n        if (result.status === \"rejected\") {\n          console.error(\"A waitUntil() promise rejected:\", result.reason);\n        }\n      }\n    }\n  }\n\n  private async route(\n    req: ShimIncomingMessage,\n    res: ShimServerResponse,\n    url: URL,\n    body: SplitBody,\n    waitUntil: (promise: Promise<unknown>) => void,\n    request: RuntimeRequest,\n  ): Promise<void> {\n    const result = await this.dispatcher.dispatch({\n      method: req.method ?? \"GET\",\n      url,\n      headers: new Headers(toWebHeaders(req.headers)),\n      body: body.forDispatch,\n      invokeMiddleware: this.middleware?.invokerFor({\n        waitUntil,\n        signal: request.signal,\n      }),\n    });\n    body.releaseUnread(result.kind === \"middleware-responded\");\n\n    applyHeaders(res, result.responseHeaders);\n    if (result.status !== undefined) {\n      res.statusCode = result.status;\n    }\n\n    switch (result.kind) {\n      case \"entrypoint\": {\n        let handler: EntrypointHandler;\n        try {\n          handler = await this.entrypoints.load(result.entrypoint);\n        } catch (error) {\n          if (!(error instanceof RouteInOtherGroupError)) throw error;\n          // A URL the edge sent here only because of its case goes to its\n          // canonical spelling, which the edge routes to the owning group.\n          const canonical = caseCanonicalPath(\n            url.pathname,\n            result.resolvedPathname,\n            this.options.manifest,\n          );\n          if (canonical) {\n            sendRedirect(res, `${canonical}${url.search}`, 308);\n            return;\n          }\n          if (request.onRouteInOtherGroup) {\n            // Explained by the caller of `handleInternally`, which knows why it\n            // happened.\n            request.onRouteInOtherGroup(error);\n          } else {\n            // Logged, because it is also what a misrouted group looks like; see\n            // `RouteInOtherGroupError` for why it is a 404.\n            console.warn(error.message);\n          }\n          await this.sendUnmatched(\n            req,\n            res,\n            waitUntil,\n            { pathname: url.pathname, requestHeaders: result.requestHeaders },\n            url,\n          );\n          return;\n        }\n        // The invocation target, not the requested URL: `resolveRoutes` has\n        // applied rewrites, stripped i18n prefixes, and appended the `nxtP`\n        // route params as query values. That is exactly the contract Next.js\n        // documents for a proxy in front of a function — `RouteModule.prepare`\n        // recovers `params` from these query values — so that contract, not\n        // `requestMeta.params`, is how params get passed. The one exception is\n        // a capture the contract would corrupt; see `outOfBandRouteParams`.\n        const outOfBand = outOfBandRouteParams(\n          result.invocationTarget.query,\n          result.resolvedPathname,\n        );\n        const invocationQuery =\n          outOfBand?.query ?? result.invocationTarget.query;\n        const { pathname } = result.invocationTarget;\n        const search = toSearch(invocationQuery);\n        req.url = search ? `${pathname}?${search}` : pathname;\n        // Middleware may have rewritten request headers via\n        // `NextResponse.next({ request: { headers } })`.\n        req.headers = toIncomingHttpHeaders(result.requestHeaders);\n        await handler(req, asServerResponse(res), {\n          waitUntil,\n          requestMeta: {\n            // The resolved query, stated rather than left to be re-derived.\n            //\n            // `RouteModule.prepare` runs `handleRewrites` against `req.url`\n            // unconditionally, and `req.url` is the *already rewritten* target.\n            // A `beforeFiles` rewrite whose condition still holds after it has\n            // been applied therefore gets applied twice: in\n            // `test/e2e/link-with-api-rewrite` the rule\n            // `/:path(.*)` + `has: query json=true` -> `/api/json?from=/:path`\n            // matched `/api/json?json=true&from=/some/route/for` a second time\n            // and overwrote `from` with `/api/json`. `next start` escapes it\n            // because its router leaves `req.url` as the URL the client sent, so\n            // the one pass `prepare` makes is the only one.\n            //\n            // `prepare` prefers this meta over its own `parsedUrl.query`\n            // (\"when deployed proxies will add query values from resolving the\n            // routes to pass to function\"), which is the documented division of\n            // labour for a proxy in front of a function - and it is the same\n            // division the `req.url` above relies on. Setting it does not stop\n            // the second rewrite pass, it just stops that pass from being what\n            // the route sees.\n            query: { ...invocationQuery },\n            // Set only for a capture the query contract cannot carry, and then\n            // in place of it rather than alongside.\n            ...(outOfBand ? { params: outOfBand.params } : {}),\n            // Without this, `RouteModule.prepare` falls back to\n            // `http://localhost${req.url}` and every absolute URL a route\n            // handler builds is wrong. `relativeProjectDir` is deliberately\n            // *not* passed: the runtime `chdir`s to the project dir, so the\n            // value Next.js inlined at build time (\"\") is already correct, and\n            // `app-page-runtime.js` ignores the requestMeta override anyway.\n            initURL: url.href,\n            // Feeds `routerServerContext.hostname` (`route-module.js`\n            // `getRouterServerContext`). Includes the port, because it is\n            // concatenated into absolute URLs.\n            hostname: url.host,\n            // Both routers call this for a `notFound: true` / `notFound()` that\n            // the entrypoint itself cannot render, and fall back to\n            // `res.end('This page could not be found')` — no status, no app 404\n            // page — when it is absent. The `req`/`res` they pass are the ones\n            // handed in just above, so the captured pair is used instead of\n            // re-deriving them.\n            render404: async () => {\n              await this.sendNotFound(\n                req,\n                res,\n                waitUntil,\n                this.dispatcher.notFoundFor(url),\n              );\n            },\n            // `res.revalidate()` from a Pages API route. Without it, Next.js\n            // falls back to `fetch('https://' + req.headers.host + urlPath)` —\n            // and only when `experimental.trustHostHeader` is set, which it is\n            // not, so `res.revalidate()` threw\n            //\n            //   Failed to revalidate /: Invariant: missing internal\n            //   router-server-methods this is an internal bug\n            //\n            // and `test/e2e/revalidate-reason` saw `stale` where `next start`\n            // reports `on-demand`: the route still re-rendered, just as an\n            // ordinary stale regeneration rather than the on-demand one it\n            // asked for.\n            //\n            // Answering it in process rather than by setting\n            // `trustHostHeader`: the fetch path would leave the function, cross\n            // CloudFront and come back — a second billed invocation, a\n            // dependency on `x-prerender-revalidate` surviving the edge, and a\n            // reason to trust a client-supplied `Host`. Next.js's own\n            // non-serverless answer is the same shape as this one\n            // (`NextServer#revalidate` runs its request handler against a\n            // mocked `req`/`res`).\n            revalidate: (config: RevalidateConfig) =>\n              this.revalidate(config, request),\n          },\n        });\n        // A Pages API route owns the end of its response: `stream.pipe(res)`,\n        // an `externalResolver` proxy, or a callback that calls `res.json()`\n        // later all return from the handler before they are done writing, and\n        // ending here sent an empty 200 and made their writes throw\n        // `ERR_STREAM_WRITE_AFTER_END`. `next start`'s `apiResolver` leaves it\n        // open too — one that never ends stalls, there as here. `handle` awaits\n        // the response itself, so nothing is cut short by returning.\n        if (!res.writableEnded && result.entrypoint.type !== \"page-api\") {\n          res.end();\n        }\n        return;\n      }\n\n      case \"static-file\": {\n        const statusPage =\n          result.source === \"server\"\n            ? this.statusPageStatus(result.pathname)\n            : undefined;\n        // `next start` serves a `public/` or `_next/static` file to GET and\n        // HEAD only, and `send` would serve it to any method. The same goes for\n        // an auto-exported Pages Router page (`base-server.js`\n        // `renderToResponseWithComponentsImpl`: a string `Component` answers\n        // anything else with a 405), except the 404 and 500 pages.\n        if (\n          req.method !== \"GET\" &&\n          req.method !== \"HEAD\" &&\n          (result.source !== \"server\" ||\n            (statusPage === undefined && result.filePath.endsWith(\".html\")))\n        ) {\n          sendMethodNotAllowed(res);\n          return;\n        }\n        // \"ensure correct status is set when visiting a status page directly\":\n        // `next start` answers `/404` with a 404 and `/500` with a 500, not the\n        // 200 their prerendered HTML would otherwise go out with.\n        if (statusPage !== undefined) {\n          res.statusCode = statusPage;\n        }\n        const etag = this.options.manifest.config.generateEtags;\n        const publicDir = `${publicDirKey(this.options.manifest)}/`;\n        const served =\n          (await serveStaticFile(\n            req,\n            res,\n            this.options.deploymentRoot,\n            result.filePath,\n            { etag },\n          )) ||\n          // Listed but not staged: a Lambda root, whose `public/` is in S3.\n          (result.source === \"public\" &&\n            !!this.publicBucket &&\n            (await serveS3PublicFile(req, res, {\n              bucket: this.publicBucket,\n              keyPrefix: this.options.bucketKeyPrefix ?? \"\",\n              file: result.filePath.slice(publicDir.length),\n              etag,\n            })));\n        if (!served) {\n          // The routing rule that matched a build asset already set its\n          // year-long `immutable` Cache-Control, which `sendUnmatched`\n          // replaces: under it the 404 would be cached at the edge and in\n          // browsers for that long, and a chunk that shows up on the next\n          // deploy would stay missing.\n          await this.sendUnmatched(req, res, waitUntil, result, url);\n        }\n        return;\n      }\n\n      case \"image-optimization\":\n        if (!this.images.isEnabled()) {\n          await this.sendUnmatched(\n            req,\n            res,\n            waitUntil,\n            { pathname: url.pathname, requestHeaders: result.requestHeaders },\n            url,\n          );\n          return;\n        }\n        req.headers = toIncomingHttpHeaders(result.requestHeaders);\n        await this.images.handle(req, res, result.url, waitUntil);\n        return;\n\n      case \"redirect\":\n        sendRedirect(res, result.location, result.status);\n        return;\n\n      case \"external-rewrite\":\n        await proxyExternal(req, res, result.url, result.requestHeaders);\n        return;\n\n      case \"middleware-responded\":\n        await sendWebResponse(res, result.response);\n        return;\n\n      case \"response\":\n        res.end();\n        return;\n\n      case \"not-found\":\n        await this.sendUnmatched(req, res, waitUntil, result, url);\n        return;\n    }\n  }\n\n  /**\n   * 404 or 500 when `pathname` is the prerendered `/404` or `/500` page — under\n   * `basePath` and, in an i18n app, any locale (`/fr/404`) — and `undefined`\n   * otherwise. `next start` matches the page, not the URL, so the locale does\n   * not matter.\n   */\n  private statusPageStatus(pathname: string): number | undefined {\n    const { basePath, i18n } = this.options.manifest.config;\n    let page = withoutPathPrefix(pathname, basePath);\n    const locales = (i18n as { locales?: readonly string[] } | null)?.locales;\n    for (const locale of locales ?? []) {\n      const stripped = withoutPathPrefix(page, `/${locale}`);\n      if (stripped !== page) {\n        page = stripped;\n        break;\n      }\n    }\n    if (page === \"/404\") return 404;\n    if (page === \"/500\") return 500;\n    return undefined;\n  }\n\n  /**\n   * `next start`'s answer to a path nothing serves (`router-server.js`, the\n   * \"404 case\"), for both ways of getting here: dispatch matched nothing, or it\n   * matched a build asset that is not in the package.\n   *\n   * No-store, always. A prerendered `/_not-found` would otherwise send its\n   * cache entry's year-long `s-maxage`, and the CDN would keep the 404 past the\n   * deploy that adds the route. Set rather than forced: Next's page handlers\n   * only write a `Cache-Control` when none is set (`sendRenderResult`,\n   * `pages-handler.js`), which is exactly how `next start`'s own no-store here\n   * survives the render. `render404` is not this path: a `notFound()` from an\n   * ISR page is cacheable for that page's revalidate period.\n   *\n   * A missing `_next/static` file, and a GET or HEAD whose `Sec-Fetch-Dest`\n   * says it cannot display HTML (an `<img>`, a script, a font), get a\n   * plain-text `Not Found` instead of the rendered page — nothing would show\n   * it, and rendering it is the expensive part.\n   *\n   * Everything else renders the app's 404 as the path that was asked for, not\n   * as `/_not-found`: the App Router serializes the canonical URL into the RSC\n   * payload, so a client hydrated off a `/_not-found` payload reports the wrong\n   * `usePathname()` and pushes the wrong history entry. It renders with the\n   * request headers middleware set, too — a CSP nonce, say.\n   */\n  private async sendUnmatched(\n    req: ShimIncomingMessage,\n    res: ShimServerResponse,\n    waitUntil: (promise: Promise<unknown>) => void,\n    result: { readonly pathname: string; readonly requestHeaders: Headers },\n    url: URL,\n  ): Promise<void> {\n    res.setHeader(\"Cache-Control\", NO_STORE);\n    const { basePath, assetPrefix } = this.options.manifest.config;\n    const pathname = withoutPathPrefix(\n      withoutPathPrefix(result.pathname, basePath),\n      assetPrefix,\n    );\n    if (\n      pathname.startsWith(\"/_next/static/\") ||\n      ((req.method === \"GET\" || req.method === \"HEAD\") &&\n        NON_HTML_SEC_FETCH_DESTS.has(\n          firstValue(req.headers[\"sec-fetch-dest\"]) ?? \"\",\n        ))\n    ) {\n      res.statusCode = 404;\n      res.setHeader(\"Content-Type\", \"text/plain; charset=utf-8\");\n      res.end(\"Not Found\");\n      return;\n    }\n    req.headers = toIncomingHttpHeaders(result.requestHeaders);\n    await this.sendNotFound(\n      req,\n      res,\n      waitUntil,\n      this.dispatcher.notFoundFor(url),\n      `${result.pathname}${url.search}`,\n    );\n  }\n\n  /**\n   * One on-demand revalidation, run against this runtime rather than over the\n   * network. Wired in as `requestMeta.revalidate`; see the comment there.\n   *\n   * The response is thrown away — only its status matters — but it goes through\n   * the full {@link handle}, so the entrypoint sees a request with\n   * `x-prerender-revalidate` on it and writes the fresh entry through the cache\n   * handler exactly as a request from outside would. `handle` awaits its own\n   * `waitUntil` work, so the new entry is committed before `res.revalidate()`\n   * resolves, which is what callers that revalidate and then redirect depend on.\n   *\n   * The accept/throw rule is `NextServer#revalidate`'s, verbatim: a revalidation\n   * is successful if it was cached or answered 200, and `notFound: true`\n   * legitimately answers 404 for an `unstable_onlyGenerated` caller. Anything\n   * else throws, and `res.revalidate()` turns it into `Failed to revalidate\n   * <path>: <message>`.\n   */\n  private async revalidate(\n    config: RevalidateConfig,\n    origin: RuntimeRequest,\n  ): Promise<void> {\n    const { head, otherGroup } = await this.handleInternally(\n      {\n        method: \"GET\",\n        url: config.urlPath,\n        // The caller's authority, not the revalidated path's: it is what\n        // `absoluteUrl` builds the request URL from, and a revalidation is for\n        // the origin being served. The forwarded pair with it — behind\n        // CloudFront `host` is the Function URL, and a render that built its\n        // absolute URLs from that would cache links to the raw function.\n        headers: {\n          ...config.headers,\n          host: origin.headers.host,\n          ...pickDefined(origin.headers, [\n            \"x-forwarded-host\",\n            \"x-forwarded-proto\",\n          ]),\n        },\n        encrypted: origin.encrypted,\n        trustForwardedHost: origin.trustForwardedHost,\n      },\n      {},\n    );\n\n    const status = head?.statusCode ?? 500;\n    if (otherGroup) {\n      const self = process.env[FUNCTION_GROUP_ENV_VAR];\n      // A page packaged into another `functionGroups` group: it is rendered in\n      // process, and this function does not have the page's code. Checked\n      // first because it renders as a 404, which `unstable_onlyGenerated`\n      // would otherwise accept.\n      throw new Error(\n        `Invalid response ${status}: \"${config.urlPath}\" belongs to ` +\n          `\\`functionGroups\\` group \"${otherGroup.owner}\", and ` +\n          `res.revalidate() can only revalidate pages in the group it runs ` +\n          `in (\"${self}\"). Call it from an API route in group ` +\n          `\"${otherGroup.owner}\", or use revalidatePath()/revalidateTag(), ` +\n          `which work from any group.`,\n      );\n    }\n    if (\n      head?.headers[\"x-nextjs-cache\"] !== \"REVALIDATED\" &&\n      status !== 200 &&\n      !(status === 404 && config.opts.unstable_onlyGenerated)\n    ) {\n      throw new Error(`Invalid response ${status}`);\n    }\n\n    await invalidateRevalidatedPage(config.urlPath, this.options.manifest);\n  }\n\n  /**\n   * An image optimization source that is not a file: `<Image src=\"/api/avatar\">`\n   * served by a route handler. Wired in as the optimizer's `fetchInternal`, and\n   * run in process for the reasons {@link revalidate} is — `next start` fetches\n   * the source from itself over loopback, which here would be a second billed\n   * invocation through CloudFront.\n   *\n   * Only the authority is forwarded, as `next start`'s `fetchInternalImage`\n   * forwards none of the viewer's headers: the source is cached and served to\n   * everyone, so it must not depend on one viewer's cookies.\n   */\n  private async fetchInternal(\n    href: string,\n    req: ShimIncomingMessage,\n    maximumBody: number,\n  ): Promise<InternalImageResponse> {\n    const request: RuntimeRequest = {\n      method: \"GET\",\n      url: href,\n      headers: pickDefined(req.headers, [\n        \"host\",\n        \"x-forwarded-host\",\n        \"x-forwarded-proto\",\n      ]),\n      encrypted: (req.socket as { encrypted?: boolean } | undefined)?.encrypted,\n      trustForwardedHost: req.trustForwardedHost,\n    };\n    const { head, body, otherGroup, tooLarge } = await this.handleInternally(\n      request,\n      { maximumBody },\n    );\n    if (tooLarge) {\n      return { statusCode: 0, headers: {}, body: Buffer.alloc(0), tooLarge };\n    }\n    if (otherGroup) {\n      // The edge sends every `/_next/image` request to the default group, and\n      // the source is rendered in process, so a route packaged into another\n      // group is out of reach: the optimizer answers (and logs) a 502.\n      return {\n        statusCode: 0,\n        headers: {},\n        body: Buffer.alloc(0),\n        otherGroup: otherGroup.owner,\n      };\n    }\n    return {\n      statusCode: head?.statusCode ?? 0,\n      headers: head?.headers ?? {},\n      body,\n    };\n  }\n\n  /**\n   * One request through {@link handle}, answered to this runtime instead of a\n   * client: the head, the body when it is wanted, and the error when the route\n   * is packaged into another `functionGroups` group. `handle` awaits the\n   * request's `waitUntil` work too, so whatever the render wrote is committed by\n   * the time this resolves.\n   *\n   * The body is kept only when `maximumBody` is set. One past it fails the\n   * response stream, which stops the route writing, and comes back as\n   * `tooLarge` rather than held in memory.\n   */\n  private async handleInternally(\n    request: RuntimeRequest,\n    options: { readonly maximumBody?: number },\n  ): Promise<{\n    head?: ResponseHead;\n    body: Buffer;\n    otherGroup?: RouteInOtherGroupError;\n    tooLarge: boolean;\n  }> {\n    let head: ResponseHead | undefined;\n    const chunks: Buffer[] = [];\n    let size = 0;\n    let tooLarge = false;\n    let otherGroup: RouteInOtherGroupError | undefined;\n    const onRouteInOtherGroup = (error: RouteInOtherGroupError) => {\n      otherGroup = error;\n    };\n    await this.handle(\n      { ...request, onRouteInOtherGroup },\n      {\n        begin(responseHead) {\n          head = responseHead;\n          return new Writable({\n            write(chunk: Buffer, _encoding, callback) {\n              if (options.maximumBody === undefined) return callback();\n              size += chunk.byteLength;\n              if (size > options.maximumBody) {\n                tooLarge = true;\n                return callback(new Error(\"Over images.maximumResponseBody\"));\n              }\n              chunks.push(Buffer.from(chunk));\n              callback();\n            },\n          });\n        },\n      },\n    );\n    return {\n      head,\n      body: tooLarge ? Buffer.alloc(0) : Buffer.concat(chunks),\n      otherGroup,\n      tooLarge,\n    };\n  }\n\n  /**\n   * App Router builds an invocable `/_not-found`, Pages Router a prerendered\n   * `404.html` (per locale under i18n) or else `/_error`; see `statusTargets`.\n   */\n  private async sendNotFound(\n    req: ShimIncomingMessage,\n    res: ShimServerResponse,\n    waitUntil: (promise: Promise<unknown>) => void,\n    target: StatusTarget,\n    /**\n     * What to render the 404 as. Omitted by `render404`, which is called\n     * mid-render with `req.url` already pointing at the route that gave up —\n     * the path Next.js would render that 404 for.\n     */\n    requestedUrl?: string,\n  ): Promise<void> {\n    res.statusCode = 404;\n\n    if (target.kind === \"entrypoint\") {\n      const handler = await this.entrypoints.load(target.entrypoint);\n      req.url = requestedUrl ?? req.url;\n      await handler(req, asServerResponse(res), { waitUntil });\n      if (!res.writableEnded) {\n        res.end();\n      }\n      return;\n    }\n\n    if (\n      target.kind === \"static-file\" &&\n      (await this.sendHtmlFile(res, target))\n    ) {\n      return;\n    }\n\n    res.setHeader(\"Content-Type\", \"text/plain; charset=utf-8\");\n    res.end(\"This page could not be found.\");\n  }\n\n  /**\n   * Turn a thrown error into a response, rendering the app's error page when it\n   * has one.\n   *\n   * Next.js's own page handlers catch, report and then *rethrow* (\"rethrow so\n   * that we can handle serving error page\", `pages-handler.ts`), which makes the\n   * error page the host's job — the same division of labor as `render404`. Without\n   * this ladder every throw answered a bare `text/plain` 500 and a custom\n   * `pages/_error` was dead code (`test/e2e/async-modules`, whose `/make-error`\n   * throws in `getServerSideProps`).\n   *\n   * Once the head is out there is nothing to say — destroying the stream is what\n   * tells the client the response is truncated rather than complete.\n   */\n  private async sendError(\n    req: ShimIncomingMessage,\n    res: ShimServerResponse,\n    waitUntil: (promise: Promise<unknown>) => void,\n    error: unknown,\n    /** The request, as received: which locale's prerendered 500 to send. */\n    url: URL | undefined,\n  ): Promise<void> {\n    console.error(\"Unhandled error while handling the request:\", error);\n    if (res.headersSent) {\n      res.destroy(asError(error));\n      return;\n    }\n    res.statusCode = 500;\n    // A failed render may have set headers describing a body that never\n    // arrived. Every rung below sends a different body, so they go first: a\n    // stale `Content-Length` on a 500.html of another size hangs the client or\n    // desyncs a keep-alive connection.\n    res.removeHeader(\"Content-Length\");\n    res.removeHeader(\"ETag\");\n    // Every rung, the error-page entrypoint included: otherwise the throwing\n    // render's `s-maxage` (or a `headers()` rule's) rides along and CloudFront\n    // caches the 500. `next start` sets it before rendering the error page too.\n    res.setHeader(\"Cache-Control\", NO_STORE);\n    const target = this.errorTargetFor(url);\n\n    if (target.kind === \"entrypoint\") {\n      try {\n        const handler = await this.entrypoints.load(target.entrypoint);\n        // `req.url` is left alone: the error page renders for the URL that was\n        // asked for, and `_error`'s `getInitialProps` reads the status off `res`,\n        // which is why the 500 above is set first.\n        await handler(req, asServerResponse(res), { waitUntil });\n        if (!res.writableEnded) {\n          res.end();\n        }\n        return;\n      } catch (errorPageError) {\n        console.error(\n          \"The error page itself failed to render:\",\n          errorPageError,\n        );\n        if (res.headersSent) {\n          res.destroy(asError(errorPageError));\n          return;\n        }\n      }\n    }\n\n    if (\n      target.kind === \"static-file\" &&\n      (await this.sendHtmlFile(res, target))\n    ) {\n      return;\n    }\n\n    // Again: an error page that threw may have described its own body too.\n    res.removeHeader(\"Content-Length\");\n    res.removeHeader(\"ETag\");\n    res.statusCode = 500;\n    res.setHeader(\"Content-Type\", \"text/plain; charset=utf-8\");\n    res.setHeader(\"Cache-Control\", NO_STORE);\n    res.end(\"Internal Server Error\");\n  }\n\n  /**\n   * A prerendered 404 or 500 page, or `false` when it cannot be read and the\n   * caller's plain-text fallback should answer. Read rather than `serveStatic`,\n   * which keeps the status already set but would answer a `Range` request with\n   * a 206 of the error page, and add `ETag`, `Last-Modified` and, where none is\n   * set yet, a public `Cache-Control` to it.\n   */\n  private async sendHtmlFile(\n    res: ShimServerResponse,\n    target: { readonly filePath: string },\n  ): Promise<boolean> {\n    let html: Buffer;\n    try {\n      html = await readFile(join(this.options.deploymentRoot, target.filePath));\n    } catch {\n      return false;\n    }\n    res.setHeader(\"Content-Type\", \"text/html; charset=utf-8\");\n    res.end(html);\n    return true;\n  }\n}\n\n/**\n * What next sends with an error it rendered itself. Without it a `Cache-Control`\n * left behind by the render that threw can get a 500 cached at the edge.\n */\nconst NO_STORE = \"private, no-cache, no-store, max-age=0, must-revalidate\";\n\n/**\n * `Sec-Fetch-Dest` values that can never display an HTML response, from\n * `next/dist/server/lib/is-non-html-sec-fetch-dest.js`. Restated rather than\n * required, because that module is recent and the app's `next` may predate it:\n * a failed require here would turn every 404 into a 500. Excludes `document`,\n * `iframe` and the like, and `empty` — `fetch()`, which is how RSC requests go.\n */\nconst NON_HTML_SEC_FETCH_DESTS: ReadonlySet<string> = new Set([\n  \"audio\",\n  \"audioworklet\",\n  \"font\",\n  \"image\",\n  \"json\",\n  \"manifest\",\n  \"paintworklet\",\n  \"report\",\n  \"script\",\n  \"serviceworker\",\n  \"sharedworker\",\n  \"style\",\n  \"track\",\n  \"video\",\n  \"webidentity\",\n  \"worker\",\n  \"xslt\",\n]);\n\n/**\n * `INTERNAL_HEADERS` from `next/dist/server/lib/server-ipc/utils.js` (Next\n * 16.3), which `next start` deletes from every request before routing it\n * (`filterInternalHeaders` in `router-server.js`). They are signals between\n * Next's own router and render layers; honoring one a client sent lets it steer\n * those layers — `next-resume` makes a PPR page resume from a postponed state\n * the client supplies. Restated rather than required, like\n * {@link NON_HTML_SEC_FETCH_DESTS}.\n */\nconst INTERNAL_HEADERS: ReadonlySet<string> = new Set([\n  \"x-middleware-rewrite\",\n  \"x-middleware-redirect\",\n  \"x-middleware-set-cookie\",\n  \"x-middleware-skip\",\n  \"x-middleware-override-headers\",\n  \"x-middleware-next\",\n  \"x-now-route-matches\",\n  \"x-matched-path\",\n  \"x-nextjs-data\",\n  \"x-next-resume-state-length\",\n  \"next-resume\",\n]);\n\n/**\n * The request headers with {@link INTERNAL_HEADERS} removed, and `x-nextjs-data`\n * put back for a `_next/data` request, which is what `next start`'s\n * `resolveRoutes` does (`setIsNextDataRequest`) right after stripping it: the\n * header is internal, but Next's handlers and middleware still read it — it is\n * how a data request gets `x-nextjs-matched-path` — so a real data request has\n * to keep it.\n */\nexport function withoutInternalHeaders(\n  headers: IncomingHttpHeaders,\n  target: string,\n  basePath: string,\n): IncomingHttpHeaders {\n  const filtered: IncomingHttpHeaders = {};\n  for (const [name, value] of Object.entries(headers)) {\n    if (!INTERNAL_HEADERS.has(name)) {\n      filtered[name] = value;\n    }\n  }\n  const pathname = withoutPathPrefix(target.split(\"?\")[0], basePath);\n  if (pathname.startsWith(\"/_next/data/\") && pathname.endsWith(\".json\")) {\n    filtered[\"x-nextjs-data\"] = \"1\";\n  }\n  return filtered;\n}\n\n/** Every route to invalidate, each once, in one CloudFront invalidation. */\ntype RevalidatedPageHook = (routes: readonly string[]) => Promise<void>;\n\n/**\n * Invalidate the CDN copies of a page `res.revalidate()` just regenerated: its\n * HTML and RSC payload, and its Pages Router `_next/data` JSON. Without this the\n * fresh entry sat behind CloudFront's copy of the old one for the page's whole\n * `s-maxage` — a year, for an on-demand-only ISR page. `revalidatePath` and\n * `revalidateTag` go through the cache handler's `revalidateTag`, which already\n * invalidates; `res.revalidate()` does not touch it.\n *\n * Every route is without `basePath`, which the hook prefixes. A no-op outside\n * the Global constructs, where no hook is registered.\n */\nasync function invalidateRevalidatedPage(\n  urlPath: string,\n  manifest: AdapterManifest,\n): Promise<void> {\n  const hook = (globalThis as Record<symbol, unknown>)[\n    REVALIDATED_PAGE_HOOK\n  ] as RevalidatedPageHook | undefined;\n  if (typeof hook !== \"function\") {\n    return;\n  }\n  const route = withoutPathPrefix(\n    urlPath.split(\"?\")[0],\n    manifest.config.basePath,\n  );\n  try {\n    // One call, deduplicated: the default locale's two pairs share a data\n    // route, and each invalidation path counts against CloudFront's quota.\n    await hook([...new Set(revalidatedPageRoutes(route, manifest).flat())]);\n  } catch (error) {\n    // The regeneration itself succeeded; the edge catches up at `s-maxage`.\n    console.warn(`Could not invalidate the CDN copy of ${urlPath}:`, error);\n  }\n}\n\n/**\n * The `[route, dataRoute]` pairs a revalidated page is cached under at the edge.\n *\n * In an i18n app the Next client always puts the locale in a data href, the\n * default locale included (`/_next/data/<id>/en/blog.json`, and `…/en.json` for\n * the root), so the unprefixed data route names nothing CloudFront holds. The\n * page is one locale's — `res.revalidate(\"/blog\")` regenerates the default\n * locale's, `\"/fr/blog\"` French — and the default locale's HTML is reachable,\n * and cached, both with and without its prefix, so its two pairs share a data\n * route, which the caller sends once.\n */\nexport function revalidatedPageRoutes(\n  route: string,\n  manifest: Pick<AdapterManifest, \"buildId\" | \"config\">,\n): Array<[string, string]> {\n  const dataRoute = (page: string) =>\n    `/_next/data/${manifest.buildId}${\n      page === \"/\" ? \"/index\" : page.replace(/\\/+$/, \"\")\n    }.json`;\n  const i18n = manifest.config.i18n as {\n    readonly locales?: readonly string[];\n    readonly defaultLocale?: string;\n  } | null;\n  if (!i18n?.defaultLocale) {\n    return [[route, dataRoute(route)]];\n  }\n  const { defaultLocale } = i18n;\n  const segment = route.split(\"/\")[1] ?? \"\";\n  const locale = (i18n.locales ?? []).includes(segment)\n    ? segment\n    : defaultLocale;\n  const page =\n    locale === segment ? withoutPathPrefix(route, `/${segment}`) : route;\n  const localized = page === \"/\" ? `/${locale}` : `/${locale}${page}`;\n  // The root's data route is the locale itself, not `/<locale>/index`.\n  const localizedData = `/_next/data/${manifest.buildId}${localized.replace(/\\/+$/, \"\")}.json`;\n  return locale === defaultLocale\n    ? [\n        [page, localizedData],\n        [localized, localizedData],\n      ]\n    : [[localized, localizedData]];\n}\n\nfunction asError(error: unknown): Error {\n  return error instanceof Error ? error : new Error(String(error));\n}\n\n/**\n * Read the manifest and pin the layout it describes.\n *\n * `process.cwd()` is load-bearing and there is exactly one chance to get it\n * right: Next.js inlines `relative(buildCwd, projectDir)` into every entrypoint\n * and resolves it against the *runtime* cwd to find\n * `required-server-files.json`, the prerender manifest, and the app's chunks.\n * `assertBuildCwd` in `build-outputs.ts` keeps that inlined value `\"\"`, so the\n * whole invariant reduces to \"cwd is the staged project dir\" — asserted rather\n * than assumed, because getting it wrong produces a\n * `Cannot find module …/required-server-files.json` from inside compiled Next.js\n * code with no indication that the layout is the problem.\n */\nexport async function loadRuntime(\n  deploymentRoot: string,\n): Promise<NextjsRuntime> {\n  const manifestPath = deployedManifestPath(deploymentRoot);\n  let manifest: AdapterManifest;\n  try {\n    manifest = JSON.parse(await readFile(manifestPath, \"utf-8\"));\n  } catch (error) {\n    throw new Error(\n      `Could not read the cdk-nextjs adapter manifest at \"${manifestPath}\". ` +\n        `The deployment package is incomplete: synth copies ` +\n        `${MANIFEST_FILE_NAME} in next to the bundled runtime.`,\n      { cause: error },\n    );\n  }\n\n  const projectDir = join(deploymentRoot, manifest.relativeProjectDir);\n  const probe = join(\n    projectDir,\n    manifest.config.distDir,\n    \"required-server-files.json\",\n  );\n  try {\n    await readFile(probe);\n  } catch (error) {\n    throw new Error(\n      `The deployment root \"${deploymentRoot}\" does not contain the staged ` +\n        `Next.js project: expected \"${probe}\" to exist. Every built entrypoint ` +\n        `resolves its own paths against process.cwd(), so this layout is part ` +\n        `of the contract, not a convenience.`,\n      { cause: error },\n    );\n  }\n  // `next start` forces this, and externalized packages (React for Pages Router\n  // SSR, anything in `serverExternalPackages`) pick their dev or prod build from\n  // it at require time. The Containers Dockerfiles set it and the Functions\n  // constructs do too; this covers a hand-wired function. Before any `require`.\n  // (`next`'s typings declare NODE_ENV read-only.)\n  (process.env as Record<string, string | undefined>).NODE_ENV ??= \"production\";\n  process.chdir(projectDir);\n  // Before anything can serve a request: the runtime's own `next` imports resolve\n  // out of the staged app, not out of the shell's directory. See `next-modules.ts`.\n  useNextFrom(projectDir);\n  // Before any entrypoint can read them at module scope.\n  loadEnvFiles(projectDir);\n  // Then, before any entrypoint (or middleware) can be loaded: Next's own\n  // node-environment bootstrap. See `setupNodeEnvironment`.\n  setupNodeEnvironment();\n  // And last, once the environment is ready: `register()`, before any entrypoint\n  // or middleware module is evaluated. See `registerInstrumentation`.\n  await registerInstrumentation(projectDir, manifest.config.distDir);\n\n  return new NextjsRuntime({\n    deploymentRoot,\n    manifest,\n    bucket: process.env.CDK_NEXTJS_STATIC_ASSETS_BUCKET_NAME,\n    bucketKeyPrefix: process.env.CDK_NEXTJS_STATIC_ASSETS_KEY_PREFIX,\n  });\n}\n\n/**\n * A syntactically valid `host[:port]`: a registered name or a bracketed IPv6\n * literal, optionally with a port. Anything else cannot be the authority of a\n * URL.\n */\nconst HOST_AUTHORITY = /^(?:\\[[0-9A-Fa-f:.]+\\]|[0-9A-Za-z._-]+)(?::\\d{1,5})?$/;\n\n/**\n * The first value that is actually usable as an authority, or `undefined`.\n *\n * `x-forwarded-host` can arrive as a list when more than one proxy appends to\n * it. Validating is what keeps a malformed value from making the `URL`\n * constructor throw — which on the Lambda shells is an invocation error and a\n * 502, not a response.\n */\nfunction validAuthority(\n  value: string | string[] | undefined,\n): string | undefined {\n  const candidate = firstValue(value)?.split(\",\")[0].trim();\n  return candidate && HOST_AUTHORITY.test(candidate) ? candidate : undefined;\n}\n\n/**\n * `resolveRoutes` needs an absolute URL, and it becomes the origin every\n * absolute URL the app builds starts with — `req.nextUrl.origin` in middleware,\n * `initURL` for a route handler — so its host has to be one the client cannot\n * pick.\n *\n * That is `Host` on every deployment but one: CloudFront forwards the viewer's\n * `Host` to a container origin (`ALL_VIEWER`), an ALB passes it through, and API\n * Gateway sets its own domain. The exception is a Lambda Function URL, where\n * CloudFront has to send the URL's own domain as `Host` and puts the viewer's in\n * `x-forwarded-host`; see {@link RuntimeRequest.trustForwardedHost}. Anywhere\n * else the header is the client's, and honoring it let a request with\n * `X-Forwarded-Host: evil.example` point a password-reset link at evil.example —\n * and, on Global Containers, have CloudFront cache that page, since the header\n * is not in its cache key.\n */\nfunction absoluteUrl(request: RuntimeRequest): URL {\n  const host =\n    (request.trustForwardedHost\n      ? validAuthority(request.headers[\"x-forwarded-host\"])\n      : undefined) ??\n    validAuthority(request.headers.host) ??\n    \"localhost\";\n  // Behind CloudFront on Global Containers the container shell has already put\n  // the viewer's protocol here; see `trustCloudFrontProto` in http/node-server.ts.\n  const forwardedProto = firstValue(request.headers[\"x-forwarded-proto\"])\n    ?.split(\",\")[0]\n    .trim()\n    .toLowerCase();\n  // Client-supplied where no proxy overwrites it, but harmless: the host is\n  // already fixed, and anything but these two would not parse.\n  const proto =\n    forwardedProto === \"http\" || forwardedProto === \"https\"\n      ? forwardedProto\n      : request.encrypted === false\n        ? \"http\"\n        : \"https\";\n  return new URL(request.url, `${proto}://${host}`);\n}\n\nfunction pickDefined(\n  headers: IncomingHttpHeaders,\n  names: readonly string[],\n): IncomingHttpHeaders {\n  const picked: IncomingHttpHeaders = {};\n  for (const name of names) {\n    if (headers[name] !== undefined) {\n      picked[name] = headers[name];\n    }\n  }\n  return picked;\n}\n\n/**\n * `normalizeRepeatedSlashes` (`next/dist/shared/lib/utils.js`), applied where\n * Next.js applies it: before routing, as a 308 to the collapsed path.\n * `base-server.ts` does `if (urlNoQuery?.match(/(\\\\|\\/\\/)/))\n * res.redirect(normalizeRepeatedSlashes(req.url), 308)`, so `/a//b` and `/a\\b`\n * both answer a redirect to `/a/b` rather than a 404 - and `@next/routing`'s\n * `resolveRoutes` does not do it for us, which is how `//` reached this runtime as\n * a 500 and `/api//json` as a 404.\n *\n * Encoded backslashes are left alone, as Next.js leaves them: `%5C` is a literal\n * character in a path segment, not a separator.\n *\n * Returns `undefined` when there is nothing to collapse, which is the common case.\n */\nfunction collapseRepeatedSlashes(target: string): string | undefined {\n  const parts = target.split(\"?\");\n  const pathname = parts[0];\n  if (!/\\\\|\\/\\//.test(pathname)) {\n    return undefined;\n  }\n  const query = parts.length > 1 ? `?${parts.slice(1).join(\"?\")}` : \"\";\n  return pathname.replace(/\\\\/g, \"/\").replace(/\\/\\/+/g, \"/\") + query;\n}\n\nexport interface SplitBody {\n  /** What `req` reads: the entrypoint's copy. */\n  readonly forRequest?: Readable | Buffer;\n  /** What `resolveRoutes` hands middleware. */\n  readonly forDispatch: ReadableStream;\n  /**\n   * Called once dispatch has returned, with whether middleware answered the\n   * request itself. Lets go of whichever copy nothing will read any more.\n   */\n  releaseUnread(middlewareResponded: boolean): void;\n}\n\n/**\n * `resolveRoutes` hands `requestBody` to middleware, which consumes it, while the\n * entrypoint needs the same bytes — the same problem `next-server` solves with\n * `getCloneableBody()`. Only split when there is middleware to feed: teeing costs\n * a buffer copy of every upload on a path that would otherwise be a straight pipe.\n *\n * A `tee()` buffers, for the branch that is behind, every chunk the other one\n * has read — so a branch that is never read holds the whole body. Middleware\n * that doesn't read the body is the common case (and its matcher may not even\n * have run it), after which the entrypoint streaming an upload would pile all\n * of it up in the middleware branch: the whole upload in memory, on a\n * container that serves other requests. So once dispatch returns, the branch\n * with no reader left is cancelled — the middleware one, or the entrypoint one\n * when middleware answered and `req` will never be read. Cancelling one\n * branch leaves the source and the other branch running.\n */\nexport function splitBody(\n  body: Readable | Buffer | undefined,\n  hasMiddleware: boolean,\n): SplitBody {\n  const releaseNothing = (): void => {};\n  if (body === undefined) {\n    return {\n      forDispatch: new Blob([]).stream(),\n      releaseUnread: releaseNothing,\n    };\n  }\n  if (!hasMiddleware) {\n    return {\n      forRequest: body,\n      forDispatch: new Blob([]).stream(),\n      releaseUnread: releaseNothing,\n    };\n  }\n  if (Buffer.isBuffer(body)) {\n    // Already fully in memory, so \"teeing\" is just reading it twice.\n    return {\n      forRequest: body,\n      forDispatch: new Blob([body]).stream(),\n      releaseUnread: releaseNothing,\n    };\n  }\n  const [forMiddleware, forEntrypoint] = Readable.toWeb(body).tee();\n  const forRequest = Readable.fromWeb(forEntrypoint as never);\n  return {\n    forRequest,\n    forDispatch: forMiddleware as ReadableStream,\n    releaseUnread(middlewareResponded) {\n      if (middlewareResponded) {\n        // `fromWeb` holds the branch's reader, so it is destroyed rather than\n        // cancelled; its `_destroy` cancels the reader.\n        forRequest.destroy();\n      } else if (!forMiddleware.locked) {\n        // Locked means middleware took a reader: it is reading, or has read,\n        // the body itself, and a locked stream cannot be cancelled anyway.\n        forMiddleware.cancel().catch(() => {});\n      }\n    },\n  };\n}\n\n/** `IncomingHttpHeaders` → the flat entries a `Headers` constructor accepts. */\nfunction toWebHeaders(headers: IncomingHttpHeaders): Array<[string, string]> {\n  const entries: Array<[string, string]> = [];\n  for (const [name, value] of Object.entries(headers)) {\n    if (value === undefined) {\n      continue;\n    }\n    for (const single of Array.isArray(value) ? value : [value]) {\n      entries.push([name, single]);\n    }\n  }\n  return entries;\n}\n\n/**\n * `headers()` rules, the immutable `cache-control` for build assets, and anything\n * middleware set with `NextResponse.next({ headers })`. Applied before the\n * entrypoint runs so that a route can still override its own.\n */\nfunction applyHeaders(res: ShimServerResponse, headers: Headers): void {\n  for (const [name, value] of headers.entries()) {\n    // `entries()` yields `set-cookie` once per cookie, so appending the whole\n    // `getSetCookie()` array here would emit N² of them — two cookies set by\n    // middleware arrived as [\"a=1\",\"b=2\",\"a=1\",\"b=2\"]. Handled once, outside.\n    if (name === \"set-cookie\") {\n      continue;\n    }\n    res.setHeader(name, value);\n  }\n  for (const cookie of headers.getSetCookie()) {\n    res.appendHeader(\"set-cookie\", cookie);\n  }\n}\n\n/**\n * Mirrors Next.js's own redirect response (`base-server.ts`): the destination is\n * also the body, and a 308 carries a `Refresh` header because some clients and\n * intermediaries still do not implement 308.\n */\nfunction sendRedirect(\n  res: ShimServerResponse,\n  location: string,\n  status: number,\n): void {\n  res.statusCode = status;\n  res.setHeader(\"Location\", location);\n  if (status === 308) {\n    res.setHeader(\"Refresh\", `0;url=${location}`);\n  }\n  res.setHeader(\"Content-Type\", \"text/plain; charset=utf-8\");\n  res.end(location);\n}\n\n/**\n * `next start`'s answer to a POST, PUT or DELETE for a static file: 405 with\n * `Allow: GET, HEAD` (`router-server.js`). It renders that through `/_error`;\n * this is the plain-text equivalent, since the status and `Allow` are what a\n * client acts on.\n */\nfunction sendMethodNotAllowed(res: ShimServerResponse): void {\n  res.statusCode = 405;\n  res.setHeader(\"Allow\", \"GET, HEAD\");\n  res.setHeader(\"Content-Type\", \"text/plain; charset=utf-8\");\n  res.end(\"Method Not Allowed\");\n}\n\n/**\n * Request headers {@link proxyExternal} does not forward. The upstream's own\n * `Host` must win; the rest describe our connection, not the proxied one, and\n * undici throws on most of them, which would answer the request with a 500.\n * Next.js's list for the requests it makes with undici (`ipcForbiddenHeaders`,\n * `next/dist/server/lib/server-ipc/utils.js`), plus `host` and `upgrade`, minus\n * `content-encoding`: Next strips that over a body it has already decoded, while\n * this one is forwarded as received, still encoded.\n */\nconst PROXY_DROPPED_HEADERS: readonly string[] = [\n  \"host\",\n  \"upgrade\",\n  \"accept-encoding\",\n  \"keepalive\",\n  \"keep-alive\",\n  \"transfer-encoding\",\n  \"connection\",\n  \"expect\",\n];\n\n/**\n * The SigV4 signature Origin Access Control put on a request to the Function\n * URL, also dropped by {@link proxyExternal} when the request was IAM-verified:\n * forwarded, it would let the third-party origin replay the request against\n * the Function URL. Anywhere else these are the client's own, and are\n * forwarded as `next start` forwards them.\n */\nconst SIGV4_HEADERS: readonly string[] = [\n  \"authorization\",\n  \"x-amz-date\",\n  \"x-amz-content-sha256\",\n  \"x-amz-security-token\",\n];\n\n/** A `next.config` rewrite whose destination is another origin. */\nasync function proxyExternal(\n  req: ShimIncomingMessage,\n  res: ShimServerResponse,\n  url: URL,\n  requestHeaders: Headers,\n): Promise<void> {\n  const method = req.method ?? \"GET\";\n  const hasBody = method !== \"GET\" && method !== \"HEAD\";\n  const headers = new Headers(requestHeaders);\n  for (const name of PROXY_DROPPED_HEADERS) {\n    headers.delete(name);\n  }\n  if (req.trustForwardedHost) {\n    for (const name of SIGV4_HEADERS) {\n      headers.delete(name);\n    }\n  }\n  const upstream = await fetch(url, {\n    method,\n    headers,\n    body: hasBody ? (Readable.toWeb(req) as ReadableStream) : undefined,\n    redirect: \"manual\",\n    ...(hasBody ? { duplex: \"half\" } : {}),\n  } as RequestInit);\n  await sendWebResponse(res, upstream);\n}\n\n/**\n * Headers describing the framing of a body that is no longer the body being\n * sent, dropped from every `Response` {@link sendWebResponse} forwards.\n *\n * A proxied origin's `Response` came back from `fetch`, and so, often, did\n * middleware's own (`return fetch(upstream)` in `proxy.ts`, since middleware\n * runs in process and its `fetch` is undici). undici decodes the body — gzip,\n * deflate, br, zstd — and leaves `content-encoding` and `content-length`\n * describing the encoded bytes it already threw away. Forwarding them emits\n * plaintext labelled `gzip` (the browser fails the whole response with\n * `ERR_CONTENT_DECODING_FAILED`) under a `Content-Length` that is too short,\n * and `shouldGzip` then declines to compress it because `content-encoding` is\n * already set, so nothing downstream repairs it. `transfer-encoding` is\n * hop-by-hop: it described the upstream connection, not this one.\n *\n * Stock Next.js drops the same three from every middleware response\n * (`FORBIDDEN_HEADERS` in `next/dist/server/web/sandbox/sandbox.js`), so\n * middleware cannot label a body it encoded itself there either.\n */\nconst STALE_FRAMING_HEADERS: ReadonlySet<string> = new Set([\n  \"content-encoding\",\n  \"content-length\",\n  \"transfer-encoding\",\n]);\n\n/** Stream a `Response` — middleware's own, or a proxied origin's — into `res`. */\nasync function sendWebResponse(\n  res: ShimServerResponse,\n  response: Response,\n): Promise<void> {\n  res.statusCode = response.status;\n  if (response.statusText) {\n    res.statusMessage = response.statusText;\n  }\n  const headers = new Headers(response.headers);\n  for (const name of STALE_FRAMING_HEADERS) {\n    headers.delete(name);\n  }\n  applyHeaders(res, headers);\n  if (!response.body) {\n    res.end();\n    return;\n  }\n  for await (const chunk of response.body as unknown as AsyncIterable<Uint8Array>) {\n    // Leaving the loop cancels the body, which is what stops a proxied origin\n    // from being read to the end for a client that has already gone.\n    if (res.destroyed) {\n      return;\n    }\n    // Paced by the client: without waiting for `drain`, a large proxied body\n    // headed for a slow client is buffered whole in memory.\n    const accepted = res.write(chunk);\n    // Set by the sink when it compresses. Without it the chunk sits in zlib's\n    // buffer, and a streamed body — server-sent events through a rewrite, a\n    // middleware `ReadableStream` — reaches the client all at once, at the end.\n    // Next.js flushes after every chunk for the same reason (`pipe-readable`).\n    res.flush?.();\n    if (!accepted && !(await drained(res))) {\n      return;\n    }\n  }\n  res.end();\n}\n"]}