cdk-nextjs 0.6.2 → 0.7.1

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeResponseSink = void 0;
+class NodeResponseSink {
+    res;
+    constructor(res) {
+        this.res = res;
+    }
+    begin(head) {
+        try {
+            this.res.writeHead(head.statusCode, head.statusMessage, {
+                ...head.headers,
+                // The one header Node models as an array, which is exactly why
+                // `ResponseHead` carries cookies separately.
+                ...(head.cookies.length > 0 ? { "set-cookie": head.cookies } : {}),
+            });
+        }
+        catch (error) {
+            // `writeHead` rejects a header value Node will not put on the wire — a
+            // non-latin1 `Content-Disposition` filename, a CR/LF. `pipeToSink` tears
+            // down the render when this rethrows, but nothing ever answered the real
+            // response: the connection sat open until the ALB's idle timeout and the
+            // client got a 502/504. `sendError`'s 500 cannot help, since the head it
+            // would send never gets this far either.
+            failHead(this.res);
+            throw error;
+        }
+        return this.res;
+    }
+}
+exports.NodeResponseSink = NodeResponseSink;
+/** Answer a plain 500 in place of a head `writeHead` refused. */
+function failHead(res) {
+    if (res.headersSent) {
+        res.destroy();
+        return;
+    }
+    // The refused call may have set some of its headers before it threw.
+    for (const name of res.getHeaderNames()) {
+        res.removeHeader(name);
+    }
+    res.writeHead(500, {
+        "Content-Type": "text/plain; charset=utf-8",
+        "Cache-Control": "private, no-cache, no-store, max-age=0, must-revalidate",
+    });
+    res.end("Internal Server Error");
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_http_1 = require("node:http");
+const node_sink_1 = require("./node-sink");
+/**
+ * A real `node:http` server, because what is under test is how Node's own
+ * `writeHead` validation interacts with the sink: a stub `ServerResponse` would
+ * not reject the header values that hung the container shell.
+ */
+async function respondWith(head) {
+    let thrown;
+    const server = (0, node_http_1.createServer)((_req, res) => {
+        try {
+            new node_sink_1.NodeResponseSink(res).begin(head).end("the body");
+        }
+        catch (error) {
+            thrown = error;
+        }
+    });
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+    const { port } = server.address();
+    try {
+        return await new Promise((resolve, reject) => {
+            const req = (0, node_http_1.request)({ port, host: "127.0.0.1", path: "/" }, (res) => {
+                let body = "";
+                res.setEncoding("utf-8");
+                res.on("data", (chunk) => (body += chunk));
+                res.on("end", () => resolve({ status: res.statusCode, body, thrown }));
+            });
+            // What the ALB did: wait for an answer that never came.
+            req.setTimeout(2_000, () => reject(new Error("the response hung")));
+            req.on("error", reject);
+            req.end();
+        });
+    }
+    finally {
+        server.close();
+    }
+}
+describe("NodeResponseSink", () => {
+    it("writes the head, cookies included, and hands back the response", async () => {
+        const result = await respondWith({
+            statusCode: 201,
+            headers: { "content-type": "text/plain" },
+            cookies: ["a=1", "b=2"],
+        });
+        expect(result).toMatchObject({ status: 201, body: "the body" });
+        expect(result.thrown).toBeUndefined();
+    });
+    it.each([
+        ["a non-latin1 value", 'attachment; filename="résumé—final.pdf"'],
+        ["a CR/LF", "one\r\nx-injected: yes"],
+    ])("answers 500 rather than hanging when writeHead rejects %s", async (_name, value) => {
+        const result = await respondWith({
+            statusCode: 200,
+            headers: { "content-disposition": value },
+            cookies: [],
+        });
+        expect(result.status).toBe(500);
+        expect(result.body).toBe("Internal Server Error");
+        // Rethrown, so `pipeToSink` tears the render down. (Node's own error
+        // class, from outside Jest's realm, hence not `toBeInstanceOf`.)
+        expect(result.thrown).toMatchObject({ code: "ERR_INVALID_CHAR" });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/runtime/http/request.d.ts

@@ -0,0 +1,62 @@
+/**
+ * A synthesized `http.IncomingMessage`.
+ *
+ * Both shells use this — the Lambda shell because it has an event rather than a
+ * socket, and the container shell so that the code paths Next.js exercises are
+ * the ones the Lambda e2e suite covers. Handing Containers a real
+ * `IncomingMessage` would mean the container suite proves nothing about Lambda.
+ *
+ * Derived from `serverless-http`'s `lib/request.js` (MIT, © Doug Moscrop) — the
+ * fake-socket shape and the `_read` push are its work:
+ * https://github.com/dougmoscrop/serverless-http/blob/master/lib/request.js
+ *
+ * What Next.js actually reads off `req` (`next/dist/server/base-http/node.js`,
+ * `NodeNextRequest`): `method`, `url` (which it *reassigns* during
+ * normalization), `headers`, `cookies` (which it *assigns*), the
+ * `NEXT_REQUEST_META` symbol, `fetchMetrics`, and `on("data"|"end"|"error")`.
+ * Nothing else, so nothing else needs to be faithful.
+ */
+import { IncomingMessage } from "node:http";
+import type { IncomingHttpHeaders } from "node:http";
+import { Readable } from "node:stream";
+export interface IncomingMessageInit {
+    readonly method: string;
+    /**
+     * Origin-form target: path + query, never absolute. This is what Next.js
+     * parses and rewrites, so it must be exactly what the route resolved to.
+     */
+    readonly url: string;
+    readonly headers: IncomingHttpHeaders;
+    /**
+     * `undefined` for bodyless requests. A `Readable` is piped through with
+     * backpressure; a `Buffer` is pushed in one go.
+     */
+    readonly body?: Readable | Buffer;
+    /** Fills `req.socket.remoteAddress`, which `x-forwarded-for` handling reads. */
+    readonly remoteAddress?: string;
+    /** `false` for the container shell behind an ALB terminating TLS. */
+    readonly encrypted?: boolean;
+    /** `RuntimeRequest.trustForwardedHost`, kept for the requests made on its behalf. */
+    readonly trustForwardedHost?: boolean;
+}
+export declare class ShimIncomingMessage extends IncomingMessage {
+    /** Set by Next.js's `NodeNextRequest.originalRequest` getter. */
+    cookies?: unknown;
+    fetchMetrics?: unknown;
+    /** See {@link IncomingMessageInit.trustForwardedHost}. */
+    readonly trustForwardedHost: boolean;
+    private source?;
+    private pumping;
+    constructor(init: IncomingMessageInit);
+    _read(size?: number): void;
+    /**
+     * `IncomingMessage.prototype._destroy` reaches for the socket — it calls
+     * `stream.finished()` on it to wait for the connection to close — and throws
+     * `ERR_INVALID_ARG_TYPE` on the synthesized one. There is no connection to tear
+     * down here, so the destroy is just completed, after the `"aborted"` that
+     * signals a truncated request.
+     */
+    _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+}
+/** Lowercases and flattens a `Headers` into `IncomingHttpHeaders`. */
+export declare function toIncomingHttpHeaders(headers: Headers): IncomingHttpHeaders;

package/lib/runtime/http/request.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShimIncomingMessage = void 0;
+exports.toIncomingHttpHeaders = toIncomingHttpHeaders;
+/**
+ * A synthesized `http.IncomingMessage`.
+ *
+ * Both shells use this — the Lambda shell because it has an event rather than a
+ * socket, and the container shell so that the code paths Next.js exercises are
+ * the ones the Lambda e2e suite covers. Handing Containers a real
+ * `IncomingMessage` would mean the container suite proves nothing about Lambda.
+ *
+ * Derived from `serverless-http`'s `lib/request.js` (MIT, © Doug Moscrop) — the
+ * fake-socket shape and the `_read` push are its work:
+ * https://github.com/dougmoscrop/serverless-http/blob/master/lib/request.js
+ *
+ * What Next.js actually reads off `req` (`next/dist/server/base-http/node.js`,
+ * `NodeNextRequest`): `method`, `url` (which it *reassigns* during
+ * normalization), `headers`, `cookies` (which it *assigns*), the
+ * `NEXT_REQUEST_META` symbol, `fetchMetrics`, and `on("data"|"end"|"error")`.
+ * Nothing else, so nothing else needs to be faithful.
+ */
+const node_http_1 = require("node:http");
+/**
+ * The subset of `net.Socket` that `IncomingMessage`'s constructor and Next.js
+ * touch. A real socket cannot be synthesized, and nothing needs one.
+ */
+function fakeSocket(init) {
+    return {
+        encrypted: init.encrypted ?? true,
+        readable: false,
+        remoteAddress: init.remoteAddress,
+        address: () => ({ port: init.encrypted === false ? 80 : 443 }),
+        end: () => { },
+        destroy: () => { },
+        // `send` (used by `serveStatic`) checks this before streaming a file.
+        writable: true,
+    };
+}
+class ShimIncomingMessage extends node_http_1.IncomingMessage {
+    /** Set by Next.js's `NodeNextRequest.originalRequest` getter. */
+    cookies;
+    fetchMetrics;
+    /** See {@link IncomingMessageInit.trustForwardedHost}. */
+    trustForwardedHost;
+    source;
+    pumping = false;
+    constructor(init) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        super(fakeSocket(init));
+        const headers = { ...init.headers };
+        const body = init.body;
+        if (Buffer.isBuffer(body) &&
+            headers["content-length"] === undefined &&
+            headers["transfer-encoding"] === undefined) {
+            // RFC 9110: a body without a length is unframed. Next.js's body parsing
+            // for Pages API routes reads `content-length`, and API Gateway / Function
+            // URL events do not always carry one.
+            headers["content-length"] = String(Buffer.byteLength(body));
+        }
+        this.trustForwardedHost = init.trustForwardedHost ?? false;
+        this.method = init.method.toUpperCase();
+        this.url = init.url;
+        this.headers = headers;
+        this.httpVersion = "1.1";
+        this.httpVersionMajor = 1;
+        this.httpVersionMinor = 1;
+        if (body === undefined) {
+            this.complete = true;
+            this.push(null);
+        }
+        else if (Buffer.isBuffer(body)) {
+            this.complete = true;
+            this.push(body);
+            this.push(null);
+        }
+        else {
+            this.source = body;
+        }
+    }
+    _read(size) {
+        const source = this.source;
+        if (!source) {
+            return;
+        }
+        if (this.pumping) {
+            source.resume();
+            return;
+        }
+        this.pumping = true;
+        source.on("data", (chunk) => {
+            if (!this.push(chunk)) {
+                source.pause();
+            }
+        });
+        source.on("end", () => {
+            this.complete = true;
+            this.push(null);
+        });
+        source.on("error", (error) => {
+            this.destroy(error);
+        });
+        void size;
+    }
+    /**
+     * `IncomingMessage.prototype._destroy` reaches for the socket — it calls
+     * `stream.finished()` on it to wait for the connection to close — and throws
+     * `ERR_INVALID_ARG_TYPE` on the synthesized one. There is no connection to tear
+     * down here, so the destroy is just completed, after the `"aborted"` that
+     * signals a truncated request.
+     */
+    _destroy(error, callback) {
+        if (!this.readableEnded || !this.complete) {
+            this.aborted = true;
+            this.emit("aborted");
+        }
+        callback(error);
+    }
+}
+exports.ShimIncomingMessage = ShimIncomingMessage;
+/** Lowercases and flattens a `Headers` into `IncomingHttpHeaders`. */
+function toIncomingHttpHeaders(headers) {
+    const result = {};
+    headers.forEach((value, name) => {
+        if (name === "set-cookie") {
+            // The only request header Node models as an array.
+            result["set-cookie"] = headers.getSetCookie();
+            return;
+        }
+        result[name] = value;
+    });
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"request.js","sourceRoot":"","sources":["../../../src/runtime/http/request.ts"],"names":[],"mappings":";;;AAwJA,sDAWC;AAnKD;;;;;;;;;;;;;;;;;GAiBG;AACH,yCAA4C;AAyB5C;;;GAGG;AACH,SAAS,UAAU,CAAC,IAAyB;IAC3C,OAAO;QACL,SAAS,EAAE,IAAI,CAAC,SAAS,IAAI,IAAI;QACjC,QAAQ,EAAE,KAAK;QACf,aAAa,EAAE,IAAI,CAAC,aAAa;QACjC,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;QAC9D,GAAG,EAAE,GAAG,EAAE,GAAE,CAAC;QACb,OAAO,EAAE,GAAG,EAAE,GAAE,CAAC;QACjB,sEAAsE;QACtE,QAAQ,EAAE,IAAI;KACf,CAAC;AACJ,CAAC;AAED,MAAa,mBAAoB,SAAQ,2BAAe;IACtD,iEAAiE;IAC1D,OAAO,CAAW;IAClB,YAAY,CAAW;IAC9B,0DAA0D;IAC1C,kBAAkB,CAAU;IAEpC,MAAM,CAAY;IAClB,OAAO,GAAG,KAAK,CAAC;IAExB,YAAmB,IAAyB;QAC1C,8DAA8D;QAC9D,KAAK,CAAC,UAAU,CAAC,IAAI,CAAQ,CAAC,CAAC;QAE/B,MAAM,OAAO,GAAG,EAAE,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QACpC,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACvB,IACE,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC;YACrB,OAAO,CAAC,gBAAgB,CAAC,KAAK,SAAS;YACvC,OAAO,CAAC,mBAAmB,CAAC,KAAK,SAAS,EAC1C,CAAC;YACD,wEAAwE;YACxE,0EAA0E;YAC1E,sCAAsC;YACtC,OAAO,CAAC,gBAAgB,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC;QAC9D,CAAC;QAED,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,kBAAkB,IAAI,KAAK,CAAC;QAC3D,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;QACxC,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC;QACpB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;QACzB,IAAI,CAAC,gBAAgB,GAAG,CAAC,CAAC;QAC1B,IAAI,CAAC,gBAAgB,GAAG,CAAC,CAAC;QAE1B,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;YACrB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAClB,CAAC;aAAM,IAAI,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;YACjC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;YACrB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAChB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAClB,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACrB,CAAC;IACH,CAAC;IAEe,KAAK,CAAC,IAAa;QACjC,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC3B,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO;QACT,CAAC;QACD,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,MAAM,CAAC,MAAM,EAAE,CAAC;YAChB,OAAO;QACT,CAAC;QACD,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAa,EAAE,EAAE;YAClC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;gBACtB,MAAM,CAAC,KAAK,EAAE,CAAC;YACjB,CAAC;QACH,CAAC,CAAC,CAAC;QACH,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE;YACpB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;YACrB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAClB,CAAC,CAAC,CAAC;QACH,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE;YAC3B,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACtB,CAAC,CAAC,CAAC;QACH,KAAK,IAAI,CAAC;IACZ,CAAC;IAED;;;;;;OAMG;IACa,QAAQ,CACtB,KAAmB,EACnB,QAAwC;QAExC,IAAI,CAAC,IAAI,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC1C,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;YACpB,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACvB,CAAC;QACD,QAAQ,CAAC,KAAK,CAAC,CAAC;IAClB,CAAC;CACF;AAzFD,kDAyFC;AAED,sEAAsE;AACtE,SAAgB,qBAAqB,CAAC,OAAgB;IACpD,MAAM,MAAM,GAAwB,EAAE,CAAC;IACvC,OAAO,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE;QAC9B,IAAI,IAAI,KAAK,YAAY,EAAE,CAAC;YAC1B,mDAAmD;YACnD,MAAM,CAAC,YAAY,CAAC,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;YAC9C,OAAO;QACT,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;IACvB,CAAC,CAAC,CAAC;IACH,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["/**\n * A synthesized `http.IncomingMessage`.\n *\n * Both shells use this — the Lambda shell because it has an event rather than a\n * socket, and the container shell so that the code paths Next.js exercises are\n * the ones the Lambda e2e suite covers. Handing Containers a real\n * `IncomingMessage` would mean the container suite proves nothing about Lambda.\n *\n * Derived from `serverless-http`'s `lib/request.js` (MIT, © Doug Moscrop) — the\n * fake-socket shape and the `_read` push are its work:\n * https://github.com/dougmoscrop/serverless-http/blob/master/lib/request.js\n *\n * What Next.js actually reads off `req` (`next/dist/server/base-http/node.js`,\n * `NodeNextRequest`): `method`, `url` (which it *reassigns* during\n * normalization), `headers`, `cookies` (which it *assigns*), the\n * `NEXT_REQUEST_META` symbol, `fetchMetrics`, and `on(\"data\"|\"end\"|\"error\")`.\n * Nothing else, so nothing else needs to be faithful.\n */\nimport { IncomingMessage } from \"node:http\";\nimport type { IncomingHttpHeaders } from \"node:http\";\nimport { Readable } from \"node:stream\";\n\nexport interface IncomingMessageInit {\n  readonly method: string;\n  /**\n   * Origin-form target: path + query, never absolute. This is what Next.js\n   * parses and rewrites, so it must be exactly what the route resolved to.\n   */\n  readonly url: string;\n  readonly headers: IncomingHttpHeaders;\n  /**\n   * `undefined` for bodyless requests. A `Readable` is piped through with\n   * backpressure; a `Buffer` is pushed in one go.\n   */\n  readonly body?: Readable | Buffer;\n  /** Fills `req.socket.remoteAddress`, which `x-forwarded-for` handling reads. */\n  readonly remoteAddress?: string;\n  /** `false` for the container shell behind an ALB terminating TLS. */\n  readonly encrypted?: boolean;\n  /** `RuntimeRequest.trustForwardedHost`, kept for the requests made on its behalf. */\n  readonly trustForwardedHost?: boolean;\n}\n\n/**\n * The subset of `net.Socket` that `IncomingMessage`'s constructor and Next.js\n * touch. A real socket cannot be synthesized, and nothing needs one.\n */\nfunction fakeSocket(init: IncomingMessageInit) {\n  return {\n    encrypted: init.encrypted ?? true,\n    readable: false,\n    remoteAddress: init.remoteAddress,\n    address: () => ({ port: init.encrypted === false ? 80 : 443 }),\n    end: () => {},\n    destroy: () => {},\n    // `send` (used by `serveStatic`) checks this before streaming a file.\n    writable: true,\n  };\n}\n\nexport class ShimIncomingMessage extends IncomingMessage {\n  /** Set by Next.js's `NodeNextRequest.originalRequest` getter. */\n  public cookies?: unknown;\n  public fetchMetrics?: unknown;\n  /** See {@link IncomingMessageInit.trustForwardedHost}. */\n  public readonly trustForwardedHost: boolean;\n\n  private source?: Readable;\n  private pumping = false;\n\n  public constructor(init: IncomingMessageInit) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    super(fakeSocket(init) as any);\n\n    const headers = { ...init.headers };\n    const body = init.body;\n    if (\n      Buffer.isBuffer(body) &&\n      headers[\"content-length\"] === undefined &&\n      headers[\"transfer-encoding\"] === undefined\n    ) {\n      // RFC 9110: a body without a length is unframed. Next.js's body parsing\n      // for Pages API routes reads `content-length`, and API Gateway / Function\n      // URL events do not always carry one.\n      headers[\"content-length\"] = String(Buffer.byteLength(body));\n    }\n\n    this.trustForwardedHost = init.trustForwardedHost ?? false;\n    this.method = init.method.toUpperCase();\n    this.url = init.url;\n    this.headers = headers;\n    this.httpVersion = \"1.1\";\n    this.httpVersionMajor = 1;\n    this.httpVersionMinor = 1;\n\n    if (body === undefined) {\n      this.complete = true;\n      this.push(null);\n    } else if (Buffer.isBuffer(body)) {\n      this.complete = true;\n      this.push(body);\n      this.push(null);\n    } else {\n      this.source = body;\n    }\n  }\n\n  public override _read(size?: number): void {\n    const source = this.source;\n    if (!source) {\n      return;\n    }\n    if (this.pumping) {\n      source.resume();\n      return;\n    }\n    this.pumping = true;\n    source.on(\"data\", (chunk: Buffer) => {\n      if (!this.push(chunk)) {\n        source.pause();\n      }\n    });\n    source.on(\"end\", () => {\n      this.complete = true;\n      this.push(null);\n    });\n    source.on(\"error\", (error) => {\n      this.destroy(error);\n    });\n    void size;\n  }\n\n  /**\n   * `IncomingMessage.prototype._destroy` reaches for the socket — it calls\n   * `stream.finished()` on it to wait for the connection to close — and throws\n   * `ERR_INVALID_ARG_TYPE` on the synthesized one. There is no connection to tear\n   * down here, so the destroy is just completed, after the `\"aborted\"` that\n   * signals a truncated request.\n   */\n  public override _destroy(\n    error: Error | null,\n    callback: (error?: Error | null) => void,\n  ): void {\n    if (!this.readableEnded || !this.complete) {\n      this.aborted = true;\n      this.emit(\"aborted\");\n    }\n    callback(error);\n  }\n}\n\n/** Lowercases and flattens a `Headers` into `IncomingHttpHeaders`. */\nexport function toIncomingHttpHeaders(headers: Headers): IncomingHttpHeaders {\n  const result: IncomingHttpHeaders = {};\n  headers.forEach((value, name) => {\n    if (name === \"set-cookie\") {\n      // The only request header Node models as an array.\n      result[\"set-cookie\"] = headers.getSetCookie();\n      return;\n    }\n    result[name] = value;\n  });\n  return result;\n}\n"]}

package/lib/runtime/http/request.test.d.ts

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

package/lib/runtime/http/request.test.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_stream_1 = require("node:stream");
+const request_1 = require("./request");
+async function readAll(stream) {
+    const chunks = [];
+    for await (const chunk of stream) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString("utf-8");
+}
+describe("ShimIncomingMessage", () => {
+    it("exposes the request line and headers Next.js reads", () => {
+        const req = new request_1.ShimIncomingMessage({
+            method: "get",
+            url: "/a?b=c",
+            headers: { host: "example.test" },
+        });
+        // Uppercased: Next.js compares `req.method === "POST"` in several places.
+        expect(req.method).toBe("GET");
+        expect(req.url).toBe("/a?b=c");
+        expect(req.headers.host).toBe("example.test");
+        expect(req.httpVersion).toBe("1.1");
+    });
+    it("ends the stream immediately when there is no body", async () => {
+        const req = new request_1.ShimIncomingMessage({
+            method: "GET",
+            url: "/",
+            headers: {},
+        });
+        expect(req.complete).toBe(true);
+        await expect(readAll(req)).resolves.toBe("");
+    });
+    it("frames a Buffer body with a content-length", async () => {
+        const req = new request_1.ShimIncomingMessage({
+            method: "POST",
+            url: "/api",
+            headers: { "content-type": "application/json" },
+            body: Buffer.from('{"a":1}'),
+        });
+        // Pages API body parsing reads `content-length`, and neither Function URL
+        // nor API Gateway events reliably carry one.
+        expect(req.headers["content-length"]).toBe("7");
+        await expect(readAll(req)).resolves.toBe('{"a":1}');
+    });
+    it("leaves an existing content-length alone", () => {
+        const req = new request_1.ShimIncomingMessage({
+            method: "POST",
+            url: "/api",
+            headers: { "content-length": "99" },
+            body: Buffer.from("ab"),
+        });
+        expect(req.headers["content-length"]).toBe("99");
+    });
+    it("pipes a streamed body through", async () => {
+        const req = new request_1.ShimIncomingMessage({
+            method: "PUT",
+            url: "/upload",
+            headers: { "transfer-encoding": "chunked" },
+            body: node_stream_1.Readable.from([Buffer.from("one "), Buffer.from("two")]),
+        });
+        await expect(readAll(req)).resolves.toBe("one two");
+        expect(req.complete).toBe(true);
+    });
+    it("destroys itself when the source stream errors", async () => {
+        const source = new node_stream_1.Readable({
+            read() {
+                this.destroy(new Error("upstream gone"));
+            },
+        });
+        const req = new request_1.ShimIncomingMessage({
+            method: "POST",
+            url: "/",
+            headers: {},
+            body: source,
+        });
+        await expect(readAll(req)).rejects.toThrow("upstream gone");
+    });
+    it("fills the socket fields that `send` and x-forwarded-for handling read", () => {
+        const req = new request_1.ShimIncomingMessage({
+            method: "GET",
+            url: "/",
+            headers: {},
+            remoteAddress: "203.0.113.7",
+            encrypted: false,
+        });
+        expect(req.socket.remoteAddress).toBe("203.0.113.7");
+        // `serveStatic` checks `res.socket.writable` before streaming a file.
+        expect(req.socket.writable).toBe(true);
+    });
+});
+describe("toIncomingHttpHeaders", () => {
+    it("flattens a Headers, keeping set-cookie as an array", () => {
+        const headers = new Headers({ "x-a": "1" });
+        headers.append("set-cookie", "a=1");
+        headers.append("set-cookie", "b=2");
+        expect((0, request_1.toIncomingHttpHeaders)(headers)).toEqual({
+            "x-a": "1",
+            "set-cookie": ["a=1", "b=2"],
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"request.test.js","sourceRoot":"","sources":["../../../src/runtime/http/request.test.ts"],"names":[],"mappings":";;AAAA,6CAAuC;AACvC,uCAAuE;AAEvE,KAAK,UAAU,OAAO,CAAC,MAAgB;IACrC,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QACjC,MAAM,CAAC,IAAI,CAAC,KAAe,CAAC,CAAC;IAC/B,CAAC;IACD,OAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;AACjD,CAAC;AAED,QAAQ,CAAC,qBAAqB,EAAE,GAAG,EAAE;IACnC,EAAE,CAAC,oDAAoD,EAAE,GAAG,EAAE;QAC5D,MAAM,GAAG,GAAG,IAAI,6BAAmB,CAAC;YAClC,MAAM,EAAE,KAAK;YACb,GAAG,EAAE,QAAQ;YACb,OAAO,EAAE,EAAE,IAAI,EAAE,cAAc,EAAE;SAClC,CAAC,CAAC;QACH,0EAA0E;QAC1E,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC/B,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC/B,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QAC9C,MAAM,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACtC,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,mDAAmD,EAAE,KAAK,IAAI,EAAE;QACjE,MAAM,GAAG,GAAG,IAAI,6BAAmB,CAAC;YAClC,MAAM,EAAE,KAAK;YACb,GAAG,EAAE,GAAG;YACR,OAAO,EAAE,EAAE;SACZ,CAAC,CAAC;QACH,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChC,MAAM,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC/C,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,4CAA4C,EAAE,KAAK,IAAI,EAAE;QAC1D,MAAM,GAAG,GAAG,IAAI,6BAAmB,CAAC;YAClC,MAAM,EAAE,MAAM;YACd,GAAG,EAAE,MAAM;YACX,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;YAC/C,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC;SAC7B,CAAC,CAAC;QACH,0EAA0E;QAC1E,6CAA6C;QAC7C,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAChD,MAAM,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACtD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,yCAAyC,EAAE,GAAG,EAAE;QACjD,MAAM,GAAG,GAAG,IAAI,6BAAmB,CAAC;YAClC,MAAM,EAAE,MAAM;YACd,GAAG,EAAE,MAAM;YACX,OAAO,EAAE,EAAE,gBAAgB,EAAE,IAAI,EAAE;YACnC,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;SACxB,CAAC,CAAC;QACH,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACnD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,+BAA+B,EAAE,KAAK,IAAI,EAAE;QAC7C,MAAM,GAAG,GAAG,IAAI,6BAAmB,CAAC;YAClC,MAAM,EAAE,KAAK;YACb,GAAG,EAAE,SAAS;YACd,OAAO,EAAE,EAAE,mBAAmB,EAAE,SAAS,EAAE;YAC3C,IAAI,EAAE,sBAAQ,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;SAC/D,CAAC,CAAC;QACH,MAAM,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACpD,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAClC,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,+CAA+C,EAAE,KAAK,IAAI,EAAE;QAC7D,MAAM,MAAM,GAAG,IAAI,sBAAQ,CAAC;YAC1B,IAAI;gBACF,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC,CAAC;YAC3C,CAAC;SACF,CAAC,CAAC;QACH,MAAM,GAAG,GAAG,IAAI,6BAAmB,CAAC;YAClC,MAAM,EAAE,MAAM;YACd,GAAG,EAAE,GAAG;YACR,OAAO,EAAE,EAAE;YACX,IAAI,EAAE,MAAM;SACb,CAAC,CAAC;QACH,MAAM,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;IAC9D,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,uEAAuE,EAAE,GAAG,EAAE;QAC/E,MAAM,GAAG,GAAG,IAAI,6BAAmB,CAAC;YAClC,MAAM,EAAE,KAAK;YACb,GAAG,EAAE,GAAG;YACR,OAAO,EAAE,EAAE;YACX,aAAa,EAAE,aAAa;YAC5B,SAAS,EAAE,KAAK;SACjB,CAAC,CAAC;QACH,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QACrD,sEAAsE;QACtE,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACzC,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,uBAAuB,EAAE,GAAG,EAAE;IACrC,EAAE,CAAC,oDAAoD,EAAE,GAAG,EAAE;QAC5D,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;QAC5C,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;QACpC,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;QACpC,MAAM,CAAC,IAAA,+BAAqB,EAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC;YAC7C,KAAK,EAAE,GAAG;YACV,YAAY,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC;SAC7B,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["import { Readable } from \"node:stream\";\nimport { ShimIncomingMessage, toIncomingHttpHeaders } from \"./request\";\n\nasync function readAll(stream: Readable): Promise<string> {\n  const chunks: Buffer[] = [];\n  for await (const chunk of stream) {\n    chunks.push(chunk as Buffer);\n  }\n  return Buffer.concat(chunks).toString(\"utf-8\");\n}\n\ndescribe(\"ShimIncomingMessage\", () => {\n  it(\"exposes the request line and headers Next.js reads\", () => {\n    const req = new ShimIncomingMessage({\n      method: \"get\",\n      url: \"/a?b=c\",\n      headers: { host: \"example.test\" },\n    });\n    // Uppercased: Next.js compares `req.method === \"POST\"` in several places.\n    expect(req.method).toBe(\"GET\");\n    expect(req.url).toBe(\"/a?b=c\");\n    expect(req.headers.host).toBe(\"example.test\");\n    expect(req.httpVersion).toBe(\"1.1\");\n  });\n\n  it(\"ends the stream immediately when there is no body\", async () => {\n    const req = new ShimIncomingMessage({\n      method: \"GET\",\n      url: \"/\",\n      headers: {},\n    });\n    expect(req.complete).toBe(true);\n    await expect(readAll(req)).resolves.toBe(\"\");\n  });\n\n  it(\"frames a Buffer body with a content-length\", async () => {\n    const req = new ShimIncomingMessage({\n      method: \"POST\",\n      url: \"/api\",\n      headers: { \"content-type\": \"application/json\" },\n      body: Buffer.from('{\"a\":1}'),\n    });\n    // Pages API body parsing reads `content-length`, and neither Function URL\n    // nor API Gateway events reliably carry one.\n    expect(req.headers[\"content-length\"]).toBe(\"7\");\n    await expect(readAll(req)).resolves.toBe('{\"a\":1}');\n  });\n\n  it(\"leaves an existing content-length alone\", () => {\n    const req = new ShimIncomingMessage({\n      method: \"POST\",\n      url: \"/api\",\n      headers: { \"content-length\": \"99\" },\n      body: Buffer.from(\"ab\"),\n    });\n    expect(req.headers[\"content-length\"]).toBe(\"99\");\n  });\n\n  it(\"pipes a streamed body through\", async () => {\n    const req = new ShimIncomingMessage({\n      method: \"PUT\",\n      url: \"/upload\",\n      headers: { \"transfer-encoding\": \"chunked\" },\n      body: Readable.from([Buffer.from(\"one \"), Buffer.from(\"two\")]),\n    });\n    await expect(readAll(req)).resolves.toBe(\"one two\");\n    expect(req.complete).toBe(true);\n  });\n\n  it(\"destroys itself when the source stream errors\", async () => {\n    const source = new Readable({\n      read() {\n        this.destroy(new Error(\"upstream gone\"));\n      },\n    });\n    const req = new ShimIncomingMessage({\n      method: \"POST\",\n      url: \"/\",\n      headers: {},\n      body: source,\n    });\n    await expect(readAll(req)).rejects.toThrow(\"upstream gone\");\n  });\n\n  it(\"fills the socket fields that `send` and x-forwarded-for handling read\", () => {\n    const req = new ShimIncomingMessage({\n      method: \"GET\",\n      url: \"/\",\n      headers: {},\n      remoteAddress: \"203.0.113.7\",\n      encrypted: false,\n    });\n    expect(req.socket.remoteAddress).toBe(\"203.0.113.7\");\n    // `serveStatic` checks `res.socket.writable` before streaming a file.\n    expect(req.socket.writable).toBe(true);\n  });\n});\n\ndescribe(\"toIncomingHttpHeaders\", () => {\n  it(\"flattens a Headers, keeping set-cookie as an array\", () => {\n    const headers = new Headers({ \"x-a\": \"1\" });\n    headers.append(\"set-cookie\", \"a=1\");\n    headers.append(\"set-cookie\", \"b=2\");\n    expect(toIncomingHttpHeaders(headers)).toEqual({\n      \"x-a\": \"1\",\n      \"set-cookie\": [\"a=1\", \"b=2\"],\n    });\n  });\n});\n"]}

package/lib/runtime/http/response.d.ts

@@ -0,0 +1,77 @@
+import type { OutgoingHttpHeaders, ServerResponse } from "node:http";
+import { Transform } from "node:stream";
+import type { TransformCallback } from "node:stream";
+export interface ResponseHead {
+    readonly statusCode: number;
+    readonly statusMessage?: string;
+    /**
+     * Flat header map with `set-cookie` removed — a `Record<string, string>`
+     * cannot represent it, and both sinks take cookies separately.
+     */
+    readonly headers: Record<string, string>;
+    readonly cookies: string[];
+}
+/**
+ * One entry per `Set-Cookie` line, the way Node's `ServerResponse` emits them:
+ * each array element is a whole cookie and a string is exactly one. Nothing here
+ * splits on commas — `Expires=` dates contain one in every format (`Wed, 21 Oct`,
+ * `Wednesday, 21-Oct-26`), and a heuristic split turns one cookie into a session
+ * cookie on the wrong path plus a junk one.
+ */
+export declare function setCookieList(value: string | string[] | number): string[];
+type HeaderValue = string | number | string[];
+export declare class ShimServerResponse extends Transform {
+    statusCode: number;
+    statusMessage?: string;
+    headersSent: boolean;
+    /** Accepted and ignored: there is no socket to schedule a `Date` header on. */
+    sendDate: boolean;
+    strictContentLength: boolean;
+    chunkedEncoding: boolean;
+    shouldKeepAlive: boolean;
+    useChunkedEncodingByDefault: boolean;
+    /** Set by Next.js in a few places; never read by us. */
+    req?: unknown;
+    /**
+     * Installed by the runtime core when it inserts gzip, so that Next.js's
+     * per-chunk `if ("flush" in res) res.flush()` actually reaches the
+     * compressor. Without it, streamed HTML sits in zlib's buffer.
+     */
+    flush?: () => void;
+    /** Lowercased name → original casing + value, mirroring Node's own store. */
+    private readonly headerStore;
+    constructor();
+    setHeader(name: string, value: HeaderValue): this;
+    appendHeader(name: string, value: string | string[]): this;
+    getHeader(name: string): HeaderValue | undefined;
+    getHeaders(): OutgoingHttpHeaders;
+    getHeaderNames(): string[];
+    hasHeader(name: string): boolean;
+    removeHeader(name: string): void;
+    writeHead(statusCode: number, statusMessageOrHeaders?: string | OutgoingHttpHeaders | HeaderValue[], maybeHeaders?: OutgoingHttpHeaders | HeaderValue[]): this;
+    /**
+     * Freezes status + headers and emits them as the `"head"` event. Called
+     * explicitly by Next.js before it streams, and lazily by this class on the
+     * first byte or on `end()` when it isn't.
+     */
+    flushHeaders(): void;
+    /** Deprecated on `ServerResponse`, but `NodeNextResponse.sent` reads it. */
+    get finished(): boolean;
+    private buildHead;
+    _transform(chunk: unknown, _encoding: BufferEncoding, callback: TransformCallback): void;
+    _flush(callback: TransformCallback): void;
+    addTrailers(): never;
+    assignSocket(): never;
+    detachSocket(): never;
+    writeContinue(): never;
+    writeEarlyHints(): never;
+    writeProcessing(): never;
+}
+/**
+ * `ShimServerResponse` is structurally a `ServerResponse` for everything Next.js
+ * touches, but not nominally one (no socket, no trailers). The entrypoint
+ * signature wants the real type, so the cast is centralized here with the
+ * reasoning attached rather than repeated at each call site.
+ */
+export declare function asServerResponse(res: ShimServerResponse): ServerResponse;
+export {};