cdk-nextjs 0.6.2 → 0.7.0

package/lib/runtime/entrypoints.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Loading and invoking build-output entrypoints.
+ *
+ * All four invocable output types — `app-page`, `app-route`, `page`, `page-api` —
+ * export the same `handler(req, res, ctx)` from
+ * `next/dist/build/templates/{app-page,app-route,pages,pages-api}.js`, so there
+ * is nothing to switch on: `AdapterEntrypoint.type` is carried for diagnostics,
+ * not dispatch.
+ *
+ * Loading is lazy and memoized per file. Lazy because a cold start that requires
+ * every route's module pays for the whole app on the first request; memoized
+ * because locale variants and `_next/data` siblings of one route all resolve to
+ * the same `filePath`.
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { AdapterEntrypoint, AdapterManifest } from "./manifest";
+/**
+ * Per-request context, the third argument of every entrypoint `handler`.
+ *
+ * `requestMeta` is `RequestMeta` from `next/dist/server/request-meta`, typed
+ * loosely here so this module does not need a `next` type import.
+ */
+export interface EntrypointContext {
+    readonly waitUntil?: (promise: Promise<unknown>) => void;
+    readonly requestMeta?: Record<string, unknown>;
+}
+export type EntrypointHandler = (req: IncomingMessage, res: ServerResponse, ctx: EntrypointContext) => Promise<void | null | undefined>;
+export declare class EntrypointRegistry {
+    private readonly root;
+    private readonly manifest;
+    private readonly handlers;
+    /**
+     * @param root absolute path the manifest's repo-root-relative `filePath`s
+     * resolve against — the staging root, which is `process.cwd()` at runtime.
+     * @param manifest used only to explain a failed load; see {@link ownedRouteError}.
+     */
+    constructor(root: string, manifest: AdapterManifest);
+    load(entrypoint: AdapterEntrypoint): Promise<EntrypointHandler>;
+}
+/**
+ * A request for a route packaged into another `functionGroups` group.
+ *
+ * The runtime answers it with a 308 to the URL's canonical spelling when case
+ * is the only difference (`caseCanonicalPath`), and a 404 otherwise, not a 500. The usual way here is a URL the
+ * edge matches differently from Next.js: CloudFront behaviors and API Gateway
+ * resources are case-sensitive and Next.js's route matching is not, so
+ * `/API/reports/1` misses the `api/reports/*` behavior, reaches the default
+ * group, and matches `/api/reports/[id]` there. At the edge that is a different
+ * URL, one no group serves, and a 404 says so; a 500 blamed the deployment.
+ */
+export declare class RouteInOtherGroupError extends Error {
+    /** The group whose package has the route. */
+    readonly owner: string;
+    constructor(message: string, 
+    /** The group whose package has the route. */
+    owner: string, options?: ErrorOptions);
+}

package/lib/runtime/entrypoints.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteInOtherGroupError = exports.EntrypointRegistry = void 0;
+const node_path_1 = require("node:path");
+const load_module_1 = require("./load-module");
+const manifest_1 = require("./manifest");
+class EntrypointRegistry {
+    root;
+    manifest;
+    handlers = new Map();
+    /**
+     * @param root absolute path the manifest's repo-root-relative `filePath`s
+     * resolve against — the staging root, which is `process.cwd()` at runtime.
+     * @param manifest used only to explain a failed load; see {@link ownedRouteError}.
+     */
+    constructor(root, manifest) {
+        this.root = root;
+        this.manifest = manifest;
+    }
+    load(entrypoint) {
+        let handler = this.handlers.get(entrypoint.filePath);
+        if (!handler) {
+            handler = loadEntrypointHandler(this.root, entrypoint, this.manifest);
+            // Cached as the promise so two concurrent first requests for one route
+            // share a single (expensive) module load.
+            this.handlers.set(entrypoint.filePath, handler);
+            // Evicted on failure, because the cache is keyed on the file and not on
+            // the attempt: a load can fail for a reason that has nothing to do with the
+            // file (EMFILE under a cold-start burst, an allocation near the memory
+            // limit), and a cached rejection makes that transient failure permanent —
+            // the same 500 for every later request until the sandbox is recycled.
+            handler.catch(() => {
+                if (this.handlers.get(entrypoint.filePath) === handler) {
+                    this.handlers.delete(entrypoint.filePath);
+                }
+            });
+        }
+        return handler;
+    }
+}
+exports.EntrypointRegistry = EntrypointRegistry;
+async function loadEntrypointHandler(root, entrypoint, manifest) {
+    const absolute = (0, node_path_1.join)(root, entrypoint.filePath);
+    let exports;
+    try {
+        exports = await (0, load_module_1.loadBuiltModule)(absolute);
+    }
+    catch (error) {
+        const message = `Could not load the entrypoint for "${entrypoint.id}" from ` +
+            `"${absolute}" (manifest filePath "${entrypoint.filePath}", type ` +
+            `"${entrypoint.type}"). The deployment package is incomplete.`;
+        const owner = owningGroup(entrypoint, manifest);
+        if (owner) {
+            throw new RouteInOtherGroupError(message + ownedRouteError(owner.self, owner.owner), owner.owner, { cause: error });
+        }
+        throw new Error(message, { cause: error });
+    }
+    return (0, load_module_1.requireFunctionExport)(exports, "handler", () => `The entrypoint for "${entrypoint.id}" at "${absolute}"`);
+}
+/**
+ * A request for a route packaged into another `functionGroups` group.
+ *
+ * The runtime answers it with a 308 to the URL's canonical spelling when case
+ * is the only difference (`caseCanonicalPath`), and a 404 otherwise, not a 500. The usual way here is a URL the
+ * edge matches differently from Next.js: CloudFront behaviors and API Gateway
+ * resources are case-sensitive and Next.js's route matching is not, so
+ * `/API/reports/1` misses the `api/reports/*` behavior, reaches the default
+ * group, and matches `/api/reports/[id]` there. At the edge that is a different
+ * URL, one no group serves, and a 404 says so; a 500 blamed the deployment.
+ */
+class RouteInOtherGroupError extends Error {
+    owner;
+    constructor(message, 
+    /** The group whose package has the route. */
+    owner, options) {
+        super(message, options);
+        this.owner = owner;
+        this.name = "RouteInOtherGroupError";
+    }
+}
+exports.RouteInOtherGroupError = RouteInOtherGroupError;
+/**
+ * The one thing splitting can break that nothing else can: a request arriving at
+ * a function whose package does not contain the route.
+ *
+ * Every group ships the same manifest, so the function knows the route exists and
+ * which group owns it; what it does not have is the file. Without this the
+ * symptom is a module-not-found on a path nobody wrote, and the cause — a
+ * CloudFront behavior or API Gateway resource pointing at the wrong function, or
+ * a URL whose case the edge did not match — is several layers away. With it, the
+ * log names both groups.
+ */
+function owningGroup(entrypoint, manifest) {
+    const groups = manifest.groups;
+    const self = process.env[manifest_1.FUNCTION_GROUP_ENV_VAR];
+    if (!groups || !self) {
+        return undefined;
+    }
+    const templates = Object.entries(manifest.entrypoints)
+        .filter(([, candidate]) => candidate.id === entrypoint.id)
+        .map(([template]) => template);
+    const owner = Object.entries(groups).find(([, owned]) => owned.some((template) => templates.includes(template)))?.[0];
+    return owner && owner !== self ? { self, owner } : undefined;
+}
+function ownedRouteError(self, owner) {
+    return (` This function is \`functionGroups\` group "${self}", but this route was ` +
+        `packaged into group "${owner}" — so the request reached the wrong function. ` +
+        `Check that the route pattern in group "${owner}" covers the URL that was ` +
+        `requested: a pattern can be too narrow at the edge while still claiming the ` +
+        `route at build time (for example "/reports/**" claims "/reports/[id]" but ` +
+        `the CloudFront behavior it becomes, "reports/*", does not match "/reports"), ` +
+        `and the edge matches case-sensitively where Next.js does not ("/API/x" ` +
+        `misses an "api/*" behavior).`);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entrypoints.js","sourceRoot":"","sources":["../../src/runtime/entrypoints.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Loading and invoking build-output entrypoints.\n *\n * All four invocable output types — `app-page`, `app-route`, `page`, `page-api` —\n * export the same `handler(req, res, ctx)` from\n * `next/dist/build/templates/{app-page,app-route,pages,pages-api}.js`, so there\n * is nothing to switch on: `AdapterEntrypoint.type` is carried for diagnostics,\n * not dispatch.\n *\n * Loading is lazy and memoized per file. Lazy because a cold start that requires\n * every route's module pays for the whole app on the first request; memoized\n * because locale variants and `_next/data` siblings of one route all resolve to\n * the same `filePath`.\n */\nimport type { IncomingMessage, ServerResponse } from \"node:http\";\nimport { join } from \"node:path\";\nimport { loadBuiltModule, requireFunctionExport } from \"./load-module\";\nimport {\n  AdapterEntrypoint,\n  AdapterManifest,\n  FUNCTION_GROUP_ENV_VAR,\n} from \"./manifest\";\n\n/**\n * Per-request context, the third argument of every entrypoint `handler`.\n *\n * `requestMeta` is `RequestMeta` from `next/dist/server/request-meta`, typed\n * loosely here so this module does not need a `next` type import.\n */\nexport interface EntrypointContext {\n  readonly waitUntil?: (promise: Promise<unknown>) => void;\n  readonly requestMeta?: Record<string, unknown>;\n}\n\nexport type EntrypointHandler = (\n  req: IncomingMessage,\n  res: ServerResponse,\n  ctx: EntrypointContext,\n) => Promise<void | null | undefined>;\n\nexport class EntrypointRegistry {\n  private readonly handlers = new Map<string, Promise<EntrypointHandler>>();\n\n  /**\n   * @param root absolute path the manifest's repo-root-relative `filePath`s\n   * resolve against — the staging root, which is `process.cwd()` at runtime.\n   * @param manifest used only to explain a failed load; see {@link ownedRouteError}.\n   */\n  public constructor(\n    private readonly root: string,\n    private readonly manifest: AdapterManifest,\n  ) {}\n\n  public load(entrypoint: AdapterEntrypoint): Promise<EntrypointHandler> {\n    let handler = this.handlers.get(entrypoint.filePath);\n    if (!handler) {\n      handler = loadEntrypointHandler(this.root, entrypoint, this.manifest);\n      // Cached as the promise so two concurrent first requests for one route\n      // share a single (expensive) module load.\n      this.handlers.set(entrypoint.filePath, handler);\n      // Evicted on failure, because the cache is keyed on the file and not on\n      // the attempt: a load can fail for a reason that has nothing to do with the\n      // file (EMFILE under a cold-start burst, an allocation near the memory\n      // limit), and a cached rejection makes that transient failure permanent —\n      // the same 500 for every later request until the sandbox is recycled.\n      handler.catch(() => {\n        if (this.handlers.get(entrypoint.filePath) === handler) {\n          this.handlers.delete(entrypoint.filePath);\n        }\n      });\n    }\n    return handler;\n  }\n}\n\nasync function loadEntrypointHandler(\n  root: string,\n  entrypoint: AdapterEntrypoint,\n  manifest: AdapterManifest,\n): Promise<EntrypointHandler> {\n  const absolute = join(root, entrypoint.filePath);\n  let exports: unknown;\n  try {\n    exports = await loadBuiltModule(absolute);\n  } catch (error) {\n    const message =\n      `Could not load the entrypoint for \"${entrypoint.id}\" from ` +\n      `\"${absolute}\" (manifest filePath \"${entrypoint.filePath}\", type ` +\n      `\"${entrypoint.type}\"). The deployment package is incomplete.`;\n    const owner = owningGroup(entrypoint, manifest);\n    if (owner) {\n      throw new RouteInOtherGroupError(\n        message + ownedRouteError(owner.self, owner.owner),\n        owner.owner,\n        { cause: error },\n      );\n    }\n    throw new Error(message, { cause: error });\n  }\n  return requireFunctionExport<EntrypointHandler>(\n    exports,\n    \"handler\",\n    () => `The entrypoint for \"${entrypoint.id}\" at \"${absolute}\"`,\n  );\n}\n\n/**\n * A request for a route packaged into another `functionGroups` group.\n *\n * The runtime answers it with a 308 to the URL's canonical spelling when case\n * is the only difference (`caseCanonicalPath`), and a 404 otherwise, not a 500. The usual way here is a URL the\n * edge matches differently from Next.js: CloudFront behaviors and API Gateway\n * resources are case-sensitive and Next.js's route matching is not, so\n * `/API/reports/1` misses the `api/reports/*` behavior, reaches the default\n * group, and matches `/api/reports/[id]` there. At the edge that is a different\n * URL, one no group serves, and a 404 says so; a 500 blamed the deployment.\n */\nexport class RouteInOtherGroupError extends Error {\n  public constructor(\n    message: string,\n    /** The group whose package has the route. */\n    public readonly owner: string,\n    options?: ErrorOptions,\n  ) {\n    super(message, options);\n    this.name = \"RouteInOtherGroupError\";\n  }\n}\n\n/**\n * The one thing splitting can break that nothing else can: a request arriving at\n * a function whose package does not contain the route.\n *\n * Every group ships the same manifest, so the function knows the route exists and\n * which group owns it; what it does not have is the file. Without this the\n * symptom is a module-not-found on a path nobody wrote, and the cause — a\n * CloudFront behavior or API Gateway resource pointing at the wrong function, or\n * a URL whose case the edge did not match — is several layers away. With it, the\n * log names both groups.\n */\nfunction owningGroup(\n  entrypoint: AdapterEntrypoint,\n  manifest: AdapterManifest,\n): { readonly self: string; readonly owner: string } | undefined {\n  const groups = manifest.groups;\n  const self = process.env[FUNCTION_GROUP_ENV_VAR];\n  if (!groups || !self) {\n    return undefined;\n  }\n  const templates = Object.entries(manifest.entrypoints)\n    .filter(([, candidate]) => candidate.id === entrypoint.id)\n    .map(([template]) => template);\n  const owner = Object.entries(groups).find(([, owned]) =>\n    owned.some((template) => templates.includes(template)),\n  )?.[0];\n  return owner && owner !== self ? { self, owner } : undefined;\n}\n\nfunction ownedRouteError(self: string, owner: string): string {\n  return (\n    ` This function is \\`functionGroups\\` group \"${self}\", but this route was ` +\n    `packaged into group \"${owner}\" — so the request reached the wrong function. ` +\n    `Check that the route pattern in group \"${owner}\" covers the URL that was ` +\n    `requested: a pattern can be too narrow at the edge while still claiming the ` +\n    `route at build time (for example \"/reports/**\" claims \"/reports/[id]\" but ` +\n    `the CloudFront behavior it becomes, \"reports/*\", does not match \"/reports\"), ` +\n    `and the edge matches case-sensitively where Next.js does not (\"/API/x\" ` +\n    `misses an \"api/*\" behavior).`\n  );\n}\n"]}

package/lib/runtime/http/abort-signal.d.ts

@@ -0,0 +1,6 @@
+/**
+ * An `AbortSignal` that fires when the client of a `node:http` request goes
+ * away, for the Containers shell to hand the runtime as `RuntimeRequest.signal`.
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+export declare function clientAbortSignal(req: IncomingMessage, res: ServerResponse): AbortSignal;

package/lib/runtime/http/abort-signal.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clientAbortSignal = clientAbortSignal;
+function clientAbortSignal(req, res) {
+    const aborted = new AbortController();
+    req.once("aborted", () => aborted.abort());
+    // `aborted` only fires while the request body is still arriving. A client that
+    // sent a complete request and then left — a long-poll, an SSE stream — is only
+    // seen as the response's socket closing before the response finished, which
+    // is also how `next start` notices it (`res.on('close')` in
+    // `signalFromNodeResponse`).
+    res.once("close", () => {
+        if (!res.writableFinished) {
+            aborted.abort();
+        }
+    });
+    return aborted.signal;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/runtime/http/abort-signal.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/runtime/http/abort-signal.test.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_http_1 = require("node:http");
+const abort_signal_1 = require("./abort-signal");
+/** A server whose handler hands each request's signal to `onSignal`. */
+function listen(handler) {
+    const server = (0, node_http_1.createServer)((req, res) => handler((0, abort_signal_1.clientAbortSignal)(req, res), res));
+    return new Promise((resolve) => server.listen(0, "127.0.0.1", () => resolve({ server, port: server.address().port })));
+}
+describe("clientAbortSignal", () => {
+    let server;
+    afterEach(() => new Promise((resolve) => server ? server.close(() => resolve()) : resolve()));
+    // A long-poll: the request is complete, so `aborted` never fires on it.
+    it("fires when the client leaves after sending a complete request", async () => {
+        let signal;
+        const seen = new Promise((resolve) => {
+            void listen((s, res) => {
+                signal = s;
+                res.writeHead(200);
+                res.write("waiting");
+                s.addEventListener("abort", () => resolve());
+            }).then((listening) => {
+                server = listening.server;
+                const req = (0, node_http_1.request)({ port: listening.port, path: "/" }, (res) => {
+                    res.once("data", () => req.destroy());
+                });
+                req.end();
+            });
+        });
+        await seen;
+        expect(signal.aborted).toBe(true);
+    });
+    it("stays quiet for a response that finished", async () => {
+        let signal;
+        const closed = new Promise((resolve) => {
+            void listen((s, res) => {
+                signal = s;
+                res.once("close", () => resolve());
+                res.end("done");
+            }).then((listening) => {
+                server = listening.server;
+                (0, node_http_1.request)({ port: listening.port, path: "/" }, (res) => res.resume()).end();
+            });
+        });
+        await closed;
+        expect(signal.aborted).toBe(false);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJvcnQtc2lnbmFsLnRlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcnVudGltZS9odHRwL2Fib3J0LXNpZ25hbC50ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEseUNBQTBEO0FBRTFELGlEQUFtRDtBQUVuRCx3RUFBd0U7QUFDeEUsU0FBUyxNQUFNLENBQ2IsT0FHUztJQUVULE1BQU0sTUFBTSxHQUFHLElBQUEsd0JBQVksRUFBQyxDQUFDLEdBQUcsRUFBRSxHQUFHLEVBQUUsRUFBRSxDQUN2QyxPQUFPLENBQUMsSUFBQSxnQ0FBaUIsRUFBQyxHQUFHLEVBQUUsR0FBRyxDQUFDLEVBQUUsR0FBRyxDQUFDLENBQzFDLENBQUM7SUFDRixPQUFPLElBQUksT0FBTyxDQUFDLENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FDN0IsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLEVBQUUsV0FBVyxFQUFFLEdBQUcsRUFBRSxDQUNqQyxPQUFPLENBQUMsRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFHLE1BQU0sQ0FBQyxPQUFPLEVBQWtCLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FDbEUsQ0FDRixDQUFDO0FBQ0osQ0FBQztBQUVELFFBQVEsQ0FBQyxtQkFBbUIsRUFBRSxHQUFHLEVBQUU7SUFDakMsSUFBSSxNQUEwQixDQUFDO0lBQy9CLFNBQVMsQ0FDUCxHQUFHLEVBQUUsQ0FDSCxJQUFJLE9BQU8sQ0FBTyxDQUFDLE9BQU8sRUFBRSxFQUFFLENBQzVCLE1BQU0sQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxHQUFHLEVBQUUsQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxPQUFPLEVBQUUsQ0FDbkQsQ0FDSixDQUFDO0lBRUYsd0VBQXdFO0lBQ3hFLEVBQUUsQ0FBQywrREFBK0QsRUFBRSxLQUFLLElBQUksRUFBRTtRQUM3RSxJQUFJLE1BQW9CLENBQUM7UUFDekIsTUFBTSxJQUFJLEdBQUcsSUFBSSxPQUFPLENBQU8sQ0FBQyxPQUFPLEVBQUUsRUFBRTtZQUN6QyxLQUFLLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxHQUFHLEVBQUUsRUFBRTtnQkFDckIsTUFBTSxHQUFHLENBQUMsQ0FBQztnQkFDWCxHQUFHLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyxDQUFDO2dCQUNuQixHQUFHLENBQUMsS0FBSyxDQUFDLFNBQVMsQ0FBQyxDQUFDO2dCQUNyQixDQUFDLENBQUMsZ0JBQWdCLENBQUMsT0FBTyxFQUFFLEdBQUcsRUFBRSxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7WUFDL0MsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsU0FBUyxFQUFFLEVBQUU7Z0JBQ3BCLE1BQU0sR0FBRyxTQUFTLENBQUMsTUFBTSxDQUFDO2dCQUMxQixNQUFNLEdBQUcsR0FBRyxJQUFBLG1CQUFPLEVBQUMsRUFBRSxJQUFJLEVBQUUsU0FBUyxDQUFDLElBQUksRUFBRSxJQUFJLEVBQUUsR0FBRyxFQUFFLEVBQUUsQ0FBQyxHQUFHLEVBQUUsRUFBRTtvQkFDL0QsR0FBRyxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsR0FBRyxFQUFFLENBQUMsR0FBRyxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7Z0JBQ3hDLENBQUMsQ0FBQyxDQUFDO2dCQUNILEdBQUcsQ0FBQyxHQUFHLEVBQUUsQ0FBQztZQUNaLENBQUMsQ0FBQyxDQUFDO1FBQ0wsQ0FBQyxDQUFDLENBQUM7UUFDSCxNQUFNLElBQUksQ0FBQztRQUNYLE1BQU0sQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ3BDLENBQUMsQ0FBQyxDQUFDO0lBRUgsRUFBRSxDQUFDLDBDQUEwQyxFQUFFLEtBQUssSUFBSSxFQUFFO1FBQ3hELElBQUksTUFBb0IsQ0FBQztRQUN6QixNQUFNLE1BQU0sR0FBRyxJQUFJLE9BQU8sQ0FBTyxDQUFDLE9BQU8sRUFBRSxFQUFFO1lBQzNDLEtBQUssTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLEdBQUcsRUFBRSxFQUFFO2dCQUNyQixNQUFNLEdBQUcsQ0FBQyxDQUFDO2dCQUNYLEdBQUcsQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLEdBQUcsRUFBRSxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7Z0JBQ25DLEdBQUcsQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLENBQUM7WUFDbEIsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsU0FBUyxFQUFFLEVBQUU7Z0JBQ3BCLE1BQU0sR0FBRyxTQUFTLENBQUMsTUFBTSxDQUFDO2dCQUMxQixJQUFBLG1CQUFPLEVBQUMsRUFBRSxJQUFJLEVBQUUsU0FBUyxDQUFDLElBQUksRUFBRSxJQUFJLEVBQUUsR0FBRyxFQUFFLEVBQUUsQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUNuRCxHQUFHLENBQUMsTUFBTSxFQUFFLENBQ2IsQ0FBQyxHQUFHLEVBQUUsQ0FBQztZQUNWLENBQUMsQ0FBQyxDQUFDO1FBQ0wsQ0FBQyxDQUFDLENBQUM7UUFDSCxNQUFNLE1BQU0sQ0FBQztRQUNiLE1BQU0sQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ3JDLENBQUMsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBjcmVhdGVTZXJ2ZXIsIHJlcXVlc3QsIFNlcnZlciB9IGZyb20gXCJub2RlOmh0dHBcIjtcbmltcG9ydCB0eXBlIHsgQWRkcmVzc0luZm8gfSBmcm9tIFwibm9kZTpuZXRcIjtcbmltcG9ydCB7IGNsaWVudEFib3J0U2lnbmFsIH0gZnJvbSBcIi4vYWJvcnQtc2lnbmFsXCI7XG5cbi8qKiBBIHNlcnZlciB3aG9zZSBoYW5kbGVyIGhhbmRzIGVhY2ggcmVxdWVzdCdzIHNpZ25hbCB0byBgb25TaWduYWxgLiAqL1xuZnVuY3Rpb24gbGlzdGVuKFxuICBoYW5kbGVyOiAoXG4gICAgc2lnbmFsOiBBYm9ydFNpZ25hbCxcbiAgICByZXM6IGltcG9ydChcIm5vZGU6aHR0cFwiKS5TZXJ2ZXJSZXNwb25zZSxcbiAgKSA9PiB2b2lkLFxuKTogUHJvbWlzZTx7IHNlcnZlcjogU2VydmVyOyBwb3J0OiBudW1iZXIgfT4ge1xuICBjb25zdCBzZXJ2ZXIgPSBjcmVhdGVTZXJ2ZXIoKHJlcSwgcmVzKSA9PlxuICAgIGhhbmRsZXIoY2xpZW50QWJvcnRTaWduYWwocmVxLCByZXMpLCByZXMpLFxuICApO1xuICByZXR1cm4gbmV3IFByb21pc2UoKHJlc29sdmUpID0+XG4gICAgc2VydmVyLmxpc3RlbigwLCBcIjEyNy4wLjAuMVwiLCAoKSA9PlxuICAgICAgcmVzb2x2ZSh7IHNlcnZlciwgcG9ydDogKHNlcnZlci5hZGRyZXNzKCkgYXMgQWRkcmVzc0luZm8pLnBvcnQgfSksXG4gICAgKSxcbiAgKTtcbn1cblxuZGVzY3JpYmUoXCJjbGllbnRBYm9ydFNpZ25hbFwiLCAoKSA9PiB7XG4gIGxldCBzZXJ2ZXI6IFNlcnZlciB8IHVuZGVmaW5lZDtcbiAgYWZ0ZXJFYWNoKFxuICAgICgpID0+XG4gICAgICBuZXcgUHJvbWlzZTx2b2lkPigocmVzb2x2ZSkgPT5cbiAgICAgICAgc2VydmVyID8gc2VydmVyLmNsb3NlKCgpID0+IHJlc29sdmUoKSkgOiByZXNvbHZlKCksXG4gICAgICApLFxuICApO1xuXG4gIC8vIEEgbG9uZy1wb2xsOiB0aGUgcmVxdWVzdCBpcyBjb21wbGV0ZSwgc28gYGFib3J0ZWRgIG5ldmVyIGZpcmVzIG9uIGl0LlxuICBpdChcImZpcmVzIHdoZW4gdGhlIGNsaWVudCBsZWF2ZXMgYWZ0ZXIgc2VuZGluZyBhIGNvbXBsZXRlIHJlcXVlc3RcIiwgYXN5bmMgKCkgPT4ge1xuICAgIGxldCBzaWduYWwhOiBBYm9ydFNpZ25hbDtcbiAgICBjb25zdCBzZWVuID0gbmV3IFByb21pc2U8dm9pZD4oKHJlc29sdmUpID0+IHtcbiAgICAgIHZvaWQgbGlzdGVuKChzLCByZXMpID0+IHtcbiAgICAgICAgc2lnbmFsID0gcztcbiAgICAgICAgcmVzLndyaXRlSGVhZCgyMDApO1xuICAgICAgICByZXMud3JpdGUoXCJ3YWl0aW5nXCIpO1xuICAgICAgICBzLmFkZEV2ZW50TGlzdGVuZXIoXCJhYm9ydFwiLCAoKSA9PiByZXNvbHZlKCkpO1xuICAgICAgfSkudGhlbigobGlzdGVuaW5nKSA9PiB7XG4gICAgICAgIHNlcnZlciA9IGxpc3RlbmluZy5zZXJ2ZXI7XG4gICAgICAgIGNvbnN0IHJlcSA9IHJlcXVlc3QoeyBwb3J0OiBsaXN0ZW5pbmcucG9ydCwgcGF0aDogXCIvXCIgfSwgKHJlcykgPT4ge1xuICAgICAgICAgIHJlcy5vbmNlKFwiZGF0YVwiLCAoKSA9PiByZXEuZGVzdHJveSgpKTtcbiAgICAgICAgfSk7XG4gICAgICAgIHJlcS5lbmQoKTtcbiAgICAgIH0pO1xuICAgIH0pO1xuICAgIGF3YWl0IHNlZW47XG4gICAgZXhwZWN0KHNpZ25hbC5hYm9ydGVkKS50b0JlKHRydWUpO1xuICB9KTtcblxuICBpdChcInN0YXlzIHF1aWV0IGZvciBhIHJlc3BvbnNlIHRoYXQgZmluaXNoZWRcIiwgYXN5bmMgKCkgPT4ge1xuICAgIGxldCBzaWduYWwhOiBBYm9ydFNpZ25hbDtcbiAgICBjb25zdCBjbG9zZWQgPSBuZXcgUHJvbWlzZTx2b2lkPigocmVzb2x2ZSkgPT4ge1xuICAgICAgdm9pZCBsaXN0ZW4oKHMsIHJlcykgPT4ge1xuICAgICAgICBzaWduYWwgPSBzO1xuICAgICAgICByZXMub25jZShcImNsb3NlXCIsICgpID0+IHJlc29sdmUoKSk7XG4gICAgICAgIHJlcy5lbmQoXCJkb25lXCIpO1xuICAgICAgfSkudGhlbigobGlzdGVuaW5nKSA9PiB7XG4gICAgICAgIHNlcnZlciA9IGxpc3RlbmluZy5zZXJ2ZXI7XG4gICAgICAgIHJlcXVlc3QoeyBwb3J0OiBsaXN0ZW5pbmcucG9ydCwgcGF0aDogXCIvXCIgfSwgKHJlcykgPT5cbiAgICAgICAgICByZXMucmVzdW1lKCksXG4gICAgICAgICkuZW5kKCk7XG4gICAgICB9KTtcbiAgICB9KTtcbiAgICBhd2FpdCBjbG9zZWQ7XG4gICAgZXhwZWN0KHNpZ25hbC5hYm9ydGVkKS50b0JlKGZhbHNlKTtcbiAgfSk7XG59KTtcbiJdfQ==

package/lib/runtime/http/node-server.d.ts

@@ -0,0 +1,38 @@
+import type { IncomingHttpHeaders, IncomingMessage, Server } from "node:http";
+import type { NextjsRuntime } from "../core";
+/** Methods RFC 9110 allows a body on, and only when one is actually framed. */
+export declare function hasRequestBody(req: IncomingMessage): boolean;
+export interface RuntimeServer {
+    readonly server: Server;
+    /**
+     * Stops accepting connections, then resolves once the open ones are gone and
+     * every request's `waitUntil` work has settled.
+     */
+    shutdown(): Promise<void>;
+}
+export interface RuntimeServerOptions {
+    /**
+     * Whether every request comes through CloudFront, which sets
+     * `cloudfront-forwarded-proto` itself. True only on Global Containers, whose
+     * ALB is reachable through the distribution's VPC origin alone
+     * (`CDK_NEXTJS_TRUST_CLOUDFRONT_PROTO`, set by the construct). See
+     * {@link viewerHeaders}.
+     */
+    readonly trustCloudFrontProto?: boolean;
+}
+export declare function createRuntimeServer(runtime: Pick<NextjsRuntime, "handle">, options?: RuntimeServerOptions): RuntimeServer;
+/**
+ * The request's headers, with `x-forwarded-proto` naming the viewer's protocol
+ * when that is known.
+ *
+ * Behind CloudFront without a certificate, CloudFront reaches the ALB over plain
+ * HTTP, so the ALB's `x-forwarded-proto` is `http` for an app every viewer
+ * reaches over HTTPS. The runtime builds absolute URLs from it - `request.url`,
+ * `req.nextUrl.origin`, and the origin Next.js forwards a server action to,
+ * where CloudFront then answered 307 and `test/e2e/app-dir/action-forward-loop`
+ * failed. CloudFront's own `cloudfront-forwarded-proto` is the viewer's, but it
+ * is trusted only when every request comes through CloudFront: anywhere else a
+ * client could send it straight to the ALB and pick the scheme of URLs a cached
+ * page then serves to everyone.
+ */
+export declare function viewerHeaders(headers: IncomingHttpHeaders, trustCloudFrontProto: boolean | undefined): IncomingHttpHeaders;

package/lib/runtime/http/node-server.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasRequestBody = hasRequestBody;
+exports.createRuntimeServer = createRuntimeServer;
+exports.viewerHeaders = viewerHeaders;
+/**
+ * The container shell's `node:http` server, and its shutdown.
+ *
+ * Its own module rather than inline in `server.mts` so it can be tested without
+ * starting the server that module starts on import.
+ */
+const node_http_1 = require("node:http");
+const abort_signal_1 = require("./abort-signal");
+const node_sink_1 = require("./node-sink");
+/**
+ * Longer than the ALB's idle timeout (60 s by default). With Node's default of
+ * 5 s, the server closes keep-alive connections the ALB still considers open;
+ * the ALB answers the next request on one with a 502, and CloudFront caches
+ * that 502 for its error caching TTL, failing every request for the path until
+ * it expires. An ALB with a longer idle timeout needs this raised to match.
+ * https://docs.aws.amazon.com/elasticloadbalancing/latest/application/edit-load-balancer-attributes.html#connection-idle-timeout
+ */
+const KEEP_ALIVE_TIMEOUT_MS = 65_000;
+/** Methods RFC 9110 allows a body on, and only when one is actually framed. */
+function hasRequestBody(req) {
+    if (req.method === "GET" || req.method === "HEAD") {
+        return false;
+    }
+    return (req.headers["content-length"] !== undefined ||
+        req.headers["transfer-encoding"] !== undefined);
+}
+function createRuntimeServer(runtime, options = {}) {
+    // `handle` resolves only once the `waitUntil` work a request registered — ISR
+    // revalidation, notably — has settled, which is after its response and its
+    // connection are done. Tracked so shutdown can wait for that too.
+    const inFlight = new Set();
+    const server = (0, node_http_1.createServer)((req, res) => {
+        const handled = serve(runtime, req, res, options)
+            .catch((error) => {
+            // `NextjsRuntime.handle` answers 500 itself, so reaching this means the
+            // shell's own translation failed.
+            console.error("The container shell failed to handle a request:", error);
+            if (!res.headersSent) {
+                res.writeHead(500, { "Content-Type": "text/plain; charset=utf-8" });
+            }
+            res.end("Internal Server Error");
+        })
+            .finally(() => inFlight.delete(handled));
+        inFlight.add(handled);
+    });
+    server.keepAliveTimeout = KEEP_ALIVE_TIMEOUT_MS;
+    // must exceed keepAliveTimeout, or Node can drop a connection that just
+    // started sending a request's headers
+    server.headersTimeout = KEEP_ALIVE_TIMEOUT_MS + 1_000;
+    // `server.close` alone is not enough: it calls back once the connections are
+    // gone, and a revalidation still running in `waitUntil` would be killed
+    // mid-write, losing the fresh entry.
+    const shutdown = () => new Promise((resolve) => {
+        server.close(() => {
+            void Promise.allSettled(inFlight).then(() => resolve());
+        });
+    });
+    return { server, shutdown };
+}
+/**
+ * The request's headers, with `x-forwarded-proto` naming the viewer's protocol
+ * when that is known.
+ *
+ * Behind CloudFront without a certificate, CloudFront reaches the ALB over plain
+ * HTTP, so the ALB's `x-forwarded-proto` is `http` for an app every viewer
+ * reaches over HTTPS. The runtime builds absolute URLs from it - `request.url`,
+ * `req.nextUrl.origin`, and the origin Next.js forwards a server action to,
+ * where CloudFront then answered 307 and `test/e2e/app-dir/action-forward-loop`
+ * failed. CloudFront's own `cloudfront-forwarded-proto` is the viewer's, but it
+ * is trusted only when every request comes through CloudFront: anywhere else a
+ * client could send it straight to the ALB and pick the scheme of URLs a cached
+ * page then serves to everyone.
+ */
+function viewerHeaders(headers, trustCloudFrontProto) {
+    const viewerProto = headers["cloudfront-forwarded-proto"];
+    if (!trustCloudFrontProto || typeof viewerProto !== "string") {
+        return headers;
+    }
+    return { ...headers, "x-forwarded-proto": viewerProto };
+}
+async function serve(runtime, req, res, options) {
+    await runtime.handle({
+        method: req.method ?? "GET",
+        url: req.url ?? "/",
+        headers: viewerHeaders(req.headers, options.trustCloudFrontProto),
+        body: hasRequestBody(req) ? req : undefined,
+        remoteAddress: req.socket.remoteAddress,
+        // TLS terminates at the ALB (Regional) or CloudFront (Global); the hop to
+        // this container is plaintext HTTP/1.1.
+        encrypted: false,
+        signal: (0, abort_signal_1.clientAbortSignal)(req, res),
+    }, new node_sink_1.NodeResponseSink(res));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-server.js","sourceRoot":"","sources":["../../../src/runtime/http/node-server.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The container shell's `node:http` server, and its shutdown.\n *\n * Its own module rather than inline in `server.mts` so it can be tested without\n * starting the server that module starts on import.\n */\nimport { createServer } from \"node:http\";\nimport type {\n  IncomingHttpHeaders,\n  IncomingMessage,\n  Server,\n  ServerResponse,\n} from \"node:http\";\nimport type { NextjsRuntime } from \"../core\";\nimport { clientAbortSignal } from \"./abort-signal\";\nimport { NodeResponseSink } from \"./node-sink\";\n\n/**\n * Longer than the ALB's idle timeout (60 s by default). With Node's default of\n * 5 s, the server closes keep-alive connections the ALB still considers open;\n * the ALB answers the next request on one with a 502, and CloudFront caches\n * that 502 for its error caching TTL, failing every request for the path until\n * it expires. An ALB with a longer idle timeout needs this raised to match.\n * https://docs.aws.amazon.com/elasticloadbalancing/latest/application/edit-load-balancer-attributes.html#connection-idle-timeout\n */\nconst KEEP_ALIVE_TIMEOUT_MS = 65_000;\n\n/** Methods RFC 9110 allows a body on, and only when one is actually framed. */\nexport function hasRequestBody(req: IncomingMessage): boolean {\n  if (req.method === \"GET\" || req.method === \"HEAD\") {\n    return false;\n  }\n  return (\n    req.headers[\"content-length\"] !== undefined ||\n    req.headers[\"transfer-encoding\"] !== undefined\n  );\n}\n\nexport interface RuntimeServer {\n  readonly server: Server;\n  /**\n   * Stops accepting connections, then resolves once the open ones are gone and\n   * every request's `waitUntil` work has settled.\n   */\n  shutdown(): Promise<void>;\n}\n\nexport interface RuntimeServerOptions {\n  /**\n   * Whether every request comes through CloudFront, which sets\n   * `cloudfront-forwarded-proto` itself. True only on Global Containers, whose\n   * ALB is reachable through the distribution's VPC origin alone\n   * (`CDK_NEXTJS_TRUST_CLOUDFRONT_PROTO`, set by the construct). See\n   * {@link viewerHeaders}.\n   */\n  readonly trustCloudFrontProto?: boolean;\n}\n\nexport function createRuntimeServer(\n  runtime: Pick<NextjsRuntime, \"handle\">,\n  options: RuntimeServerOptions = {},\n): RuntimeServer {\n  // `handle` resolves only once the `waitUntil` work a request registered — ISR\n  // revalidation, notably — has settled, which is after its response and its\n  // connection are done. Tracked so shutdown can wait for that too.\n  const inFlight = new Set<Promise<void>>();\n\n  const server = createServer((req, res) => {\n    const handled = serve(runtime, req, res, options)\n      .catch((error) => {\n        // `NextjsRuntime.handle` answers 500 itself, so reaching this means the\n        // shell's own translation failed.\n        console.error(\"The container shell failed to handle a request:\", error);\n        if (!res.headersSent) {\n          res.writeHead(500, { \"Content-Type\": \"text/plain; charset=utf-8\" });\n        }\n        res.end(\"Internal Server Error\");\n      })\n      .finally(() => inFlight.delete(handled));\n    inFlight.add(handled);\n  });\n  server.keepAliveTimeout = KEEP_ALIVE_TIMEOUT_MS;\n  // must exceed keepAliveTimeout, or Node can drop a connection that just\n  // started sending a request's headers\n  server.headersTimeout = KEEP_ALIVE_TIMEOUT_MS + 1_000;\n\n  // `server.close` alone is not enough: it calls back once the connections are\n  // gone, and a revalidation still running in `waitUntil` would be killed\n  // mid-write, losing the fresh entry.\n  const shutdown = () =>\n    new Promise<void>((resolve) => {\n      server.close(() => {\n        void Promise.allSettled(inFlight).then(() => resolve());\n      });\n    });\n\n  return { server, shutdown };\n}\n\n/**\n * The request's headers, with `x-forwarded-proto` naming the viewer's protocol\n * when that is known.\n *\n * Behind CloudFront without a certificate, CloudFront reaches the ALB over plain\n * HTTP, so the ALB's `x-forwarded-proto` is `http` for an app every viewer\n * reaches over HTTPS. The runtime builds absolute URLs from it - `request.url`,\n * `req.nextUrl.origin`, and the origin Next.js forwards a server action to,\n * where CloudFront then answered 307 and `test/e2e/app-dir/action-forward-loop`\n * failed. CloudFront's own `cloudfront-forwarded-proto` is the viewer's, but it\n * is trusted only when every request comes through CloudFront: anywhere else a\n * client could send it straight to the ALB and pick the scheme of URLs a cached\n * page then serves to everyone.\n */\nexport function viewerHeaders(\n  headers: IncomingHttpHeaders,\n  trustCloudFrontProto: boolean | undefined,\n): IncomingHttpHeaders {\n  const viewerProto = headers[\"cloudfront-forwarded-proto\"];\n  if (!trustCloudFrontProto || typeof viewerProto !== \"string\") {\n    return headers;\n  }\n  return { ...headers, \"x-forwarded-proto\": viewerProto };\n}\n\nasync function serve(\n  runtime: Pick<NextjsRuntime, \"handle\">,\n  req: IncomingMessage,\n  res: ServerResponse,\n  options: RuntimeServerOptions,\n): Promise<void> {\n  await runtime.handle(\n    {\n      method: req.method ?? \"GET\",\n      url: req.url ?? \"/\",\n      headers: viewerHeaders(req.headers, options.trustCloudFrontProto),\n      body: hasRequestBody(req) ? req : undefined,\n      remoteAddress: req.socket.remoteAddress,\n      // TLS terminates at the ALB (Regional) or CloudFront (Global); the hop to\n      // this container is plaintext HTTP/1.1.\n      encrypted: false,\n      signal: clientAbortSignal(req, res),\n    },\n    new NodeResponseSink(res),\n  );\n}\n"]}

package/lib/runtime/http/node-server.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/runtime/http/node-server.test.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_http_1 = require("node:http");
+const node_server_1 = require("./node-server");
+/** A real server around a stub runtime, and one request to it. */
+async function withServer(handle, run) {
+    const { server, shutdown } = (0, node_server_1.createRuntimeServer)({ handle });
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+    const { port } = server.address();
+    const get = () => new Promise((resolve, reject) => {
+        // No keep-alive agent, so the connection closes with the response and
+        // `server.close` is not left waiting on an idle socket.
+        const req = (0, node_http_1.request)({ port, host: "127.0.0.1", path: "/", agent: false }, (res) => {
+            let body = "";
+            res.setEncoding("utf-8");
+            res.on("data", (chunk) => (body += chunk));
+            res.on("end", () => resolve({ status: res.statusCode, body }));
+        });
+        req.on("error", reject);
+        req.end();
+    });
+    try {
+        return await run(get, shutdown);
+    }
+    finally {
+        server.close();
+    }
+}
+describe("viewerHeaders", () => {
+    // Global Containers without a certificate: CloudFront reaches the ALB over
+    // HTTP, so the ALB says `http` while the viewer used HTTPS.
+    const behindCloudFront = {
+        host: "d111.cloudfront.net",
+        "x-forwarded-proto": "http",
+        "cloudfront-forwarded-proto": "https",
+    };
+    it("takes the viewer's protocol from CloudFront when every request comes through it", () => {
+        expect((0, node_server_1.viewerHeaders)(behindCloudFront, true)["x-forwarded-proto"]).toBe("https");
+    });
+    it("ignores cloudfront-forwarded-proto a client could have sent the ALB itself", () => {
+        expect((0, node_server_1.viewerHeaders)(behindCloudFront, false)["x-forwarded-proto"]).toBe("http");
+        expect((0, node_server_1.viewerHeaders)(behindCloudFront, undefined)).toBe(behindCloudFront);
+    });
+    it("keeps x-forwarded-proto when CloudFront sent no protocol", () => {
+        const headers = { host: "alb.example.test", "x-forwarded-proto": "http" };
+        expect((0, node_server_1.viewerHeaders)(headers, true)).toBe(headers);
+    });
+});
+describe("hasRequestBody", () => {
+    const message = (method, headers = {}) => ({ method, headers });
+    it("is false for GET and HEAD, whatever their framing says", () => {
+        expect((0, node_server_1.hasRequestBody)(message("GET", { "content-length": "3" }))).toBe(false);
+        expect((0, node_server_1.hasRequestBody)(message("HEAD", { "transfer-encoding": "chunked" }))).toBe(false);
+    });
+    it("is true only for a body that is actually framed", () => {
+        expect((0, node_server_1.hasRequestBody)(message("POST"))).toBe(false);
+        expect((0, node_server_1.hasRequestBody)(message("POST", { "content-length": "0" }))).toBe(true);
+        expect((0, node_server_1.hasRequestBody)(message("DELETE", { "transfer-encoding": "chunked" }))).toBe(true);
+    });
+});
+describe("createRuntimeServer", () => {
+    it("answers a plain 500 when the shell itself fails", async () => {
+        const error = jest.spyOn(console, "error").mockImplementation(() => { });
+        try {
+            const response = await withServer(async () => {
+                throw new Error("translation failed");
+            }, (get) => get());
+            expect(response).toEqual({ status: 500, body: "Internal Server Error" });
+            expect(String(error.mock.calls[0][0])).toMatch(/container shell failed/);
+        }
+        finally {
+            error.mockRestore();
+        }
+    });
+    // What an ECS rolling deploy does: SIGTERM while an ISR regeneration is still
+    // running in `waitUntil`, after its response has gone out.
+    it("shuts down only once in-flight waitUntil work has settled", async () => {
+        let release;
+        const waitUntilWork = new Promise((resolve) => (release = resolve));
+        const handle = async (_request, sink) => {
+            sink.begin({ statusCode: 200, headers: {}, cookies: [] }).end("ok");
+            await waitUntilWork;
+        };
+        await withServer(handle, async (get, shutdown) => {
+            expect(await get()).toEqual({ status: 200, body: "ok" });
+            let stopped = false;
+            const stopping = shutdown().then(() => (stopped = true));
+            await new Promise((resolve) => setTimeout(resolve, 20));
+            expect(stopped).toBe(false);
+            release();
+            await stopping;
+            expect(stopped).toBe(true);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-server.test.js","sourceRoot":"","sources":["../../../src/runtime/http/node-server.test.ts"],"names":[],"mappings":"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","sourcesContent":["import type { IncomingMessage } from \"node:http\";\nimport { request as httpRequest } from \"node:http\";\nimport type { AddressInfo } from \"node:net\";\nimport type { NextjsRuntime } from \"../core\";\nimport {\n  createRuntimeServer,\n  hasRequestBody,\n  viewerHeaders,\n} from \"./node-server\";\n\ntype Handle = NextjsRuntime[\"handle\"];\n\n/** A real server around a stub runtime, and one request to it. */\nasync function withServer<T>(\n  handle: Handle,\n  run: (\n    get: () => Promise<{ status?: number; body: string }>,\n    shutdown: () => Promise<void>,\n  ) => Promise<T>,\n): Promise<T> {\n  const { server, shutdown } = createRuntimeServer({ handle });\n  await new Promise<void>((resolve) => server.listen(0, \"127.0.0.1\", resolve));\n  const { port } = server.address() as AddressInfo;\n  const get = () =>\n    new Promise<{ status?: number; body: string }>((resolve, reject) => {\n      // No keep-alive agent, so the connection closes with the response and\n      // `server.close` is not left waiting on an idle socket.\n      const req = httpRequest(\n        { port, host: \"127.0.0.1\", path: \"/\", agent: false },\n        (res) => {\n          let body = \"\";\n          res.setEncoding(\"utf-8\");\n          res.on(\"data\", (chunk) => (body += chunk));\n          res.on(\"end\", () => resolve({ status: res.statusCode, body }));\n        },\n      );\n      req.on(\"error\", reject);\n      req.end();\n    });\n  try {\n    return await run(get, shutdown);\n  } finally {\n    server.close();\n  }\n}\n\ndescribe(\"viewerHeaders\", () => {\n  // Global Containers without a certificate: CloudFront reaches the ALB over\n  // HTTP, so the ALB says `http` while the viewer used HTTPS.\n  const behindCloudFront = {\n    host: \"d111.cloudfront.net\",\n    \"x-forwarded-proto\": \"http\",\n    \"cloudfront-forwarded-proto\": \"https\",\n  };\n\n  it(\"takes the viewer's protocol from CloudFront when every request comes through it\", () => {\n    expect(viewerHeaders(behindCloudFront, true)[\"x-forwarded-proto\"]).toBe(\n      \"https\",\n    );\n  });\n\n  it(\"ignores cloudfront-forwarded-proto a client could have sent the ALB itself\", () => {\n    expect(viewerHeaders(behindCloudFront, false)[\"x-forwarded-proto\"]).toBe(\n      \"http\",\n    );\n    expect(viewerHeaders(behindCloudFront, undefined)).toBe(behindCloudFront);\n  });\n\n  it(\"keeps x-forwarded-proto when CloudFront sent no protocol\", () => {\n    const headers = { host: \"alb.example.test\", \"x-forwarded-proto\": \"http\" };\n    expect(viewerHeaders(headers, true)).toBe(headers);\n  });\n});\n\ndescribe(\"hasRequestBody\", () => {\n  const message = (method: string, headers: Record<string, string> = {}) =>\n    ({ method, headers }) as unknown as IncomingMessage;\n\n  it(\"is false for GET and HEAD, whatever their framing says\", () => {\n    expect(hasRequestBody(message(\"GET\", { \"content-length\": \"3\" }))).toBe(\n      false,\n    );\n    expect(\n      hasRequestBody(message(\"HEAD\", { \"transfer-encoding\": \"chunked\" })),\n    ).toBe(false);\n  });\n\n  it(\"is true only for a body that is actually framed\", () => {\n    expect(hasRequestBody(message(\"POST\"))).toBe(false);\n    expect(hasRequestBody(message(\"POST\", { \"content-length\": \"0\" }))).toBe(\n      true,\n    );\n    expect(\n      hasRequestBody(message(\"DELETE\", { \"transfer-encoding\": \"chunked\" })),\n    ).toBe(true);\n  });\n});\n\ndescribe(\"createRuntimeServer\", () => {\n  it(\"answers a plain 500 when the shell itself fails\", async () => {\n    const error = jest.spyOn(console, \"error\").mockImplementation(() => {});\n    try {\n      const response = await withServer(\n        async () => {\n          throw new Error(\"translation failed\");\n        },\n        (get) => get(),\n      );\n      expect(response).toEqual({ status: 500, body: \"Internal Server Error\" });\n      expect(String(error.mock.calls[0][0])).toMatch(/container shell failed/);\n    } finally {\n      error.mockRestore();\n    }\n  });\n\n  // What an ECS rolling deploy does: SIGTERM while an ISR regeneration is still\n  // running in `waitUntil`, after its response has gone out.\n  it(\"shuts down only once in-flight waitUntil work has settled\", async () => {\n    let release!: () => void;\n    const waitUntilWork = new Promise<void>((resolve) => (release = resolve));\n    const handle: Handle = async (_request, sink) => {\n      sink.begin({ statusCode: 200, headers: {}, cookies: [] }).end(\"ok\");\n      await waitUntilWork;\n    };\n    await withServer(handle, async (get, shutdown) => {\n      expect(await get()).toEqual({ status: 200, body: \"ok\" });\n\n      let stopped = false;\n      const stopping = shutdown().then(() => (stopped = true));\n      await new Promise((resolve) => setTimeout(resolve, 20));\n      expect(stopped).toBe(false);\n\n      release();\n      await stopping;\n      expect(stopped).toBe(true);\n    });\n  });\n});\n"]}

package/lib/runtime/http/node-sink.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The container shell's {@link ResponseSink}: the head goes to a real
+ * `node:http` `ServerResponse`, which is then the stream the body is piped into.
+ *
+ * Its own module rather than inline in `server.mts` so it can be tested without
+ * starting the server that module starts on import.
+ */
+import type { ServerResponse } from "node:http";
+import type { Writable } from "node:stream";
+import type { ResponseHead } from "./response";
+import type { ResponseSink } from "./sink";
+export declare class NodeResponseSink implements ResponseSink {
+    private readonly res;
+    constructor(res: ServerResponse);
+    begin(head: ResponseHead): Writable;
+}