cdk-nextjs 0.6.2 → 0.7.1

package/lib/runtime/http/response.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShimServerResponse = void 0;
+exports.setCookieList = setCookieList;
+exports.asServerResponse = asServerResponse;
+/**
+ * A synthesized, streaming `http.ServerResponse`.
+ *
+ * The response *is* the stream: this is a `Transform` that Next.js writes into,
+ * and the shell pipes into its own byte sink (`awslambda.HttpResponseStream` for
+ * Functions, the real `ServerResponse` for Containers). Status and headers are
+ * emitted once as a {@link ResponseHead} on the `"head"` event, because Lambda's
+ * response stream needs them in a prelude *before* any body byte.
+ *
+ * Modeled on OpenNext's `OpenNextNodeResponse` (MIT, © 2022 SST):
+ * https://github.com/opennextjs/opennextjs-aws/blob/main/packages/open-next/src/http/openNextResponse.ts
+ *
+ * Deliberately much smaller than that file. OpenNext's shim doubles as a
+ * `BaseNextResponse` and re-implements the middleware header merge, because
+ * OpenNext reimplements routing. We hand this object to `handler(req, res, ctx)`,
+ * which wraps it in Next.js's own `NodeNextResponse`
+ * (`next/dist/server/base-http/node.js`) — so the contract is just "be a
+ * `ServerResponse`", and the header-merge logic belongs to `@next/routing`.
+ */
+const node_http_1 = require("node:http");
+const node_stream_1 = require("node:stream");
+/**
+ * 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.
+ */
+function setCookieList(value) {
+    return (Array.isArray(value) ? value : [value])
+        .map((cookie) => String(cookie).trim())
+        .filter(Boolean);
+}
+/** Node never calls these, and Next.js never calls them either. */
+function unsupported(method) {
+    throw new Error(`res.${method}() is not supported by the cdk-nextjs runtime. Next.js does ` +
+        `not call it, so reaching this means something else is writing the ` +
+        `response.`);
+}
+class ShimServerResponse extends node_stream_1.Transform {
+    statusCode = 200;
+    statusMessage;
+    headersSent = false;
+    /** Accepted and ignored: there is no socket to schedule a `Date` header on. */
+    sendDate = false;
+    strictContentLength = false;
+    chunkedEncoding = false;
+    shouldKeepAlive = false;
+    useChunkedEncodingByDefault = false;
+    /** Set by Next.js in a few places; never read by us. */
+    req;
+    /**
+     * 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;
+    /** Lowercased name → original casing + value, mirroring Node's own store. */
+    headerStore = new Map();
+    constructor() {
+        super();
+    }
+    // --- header API -----------------------------------------------------------
+    setHeader(name, value) {
+        this.headerStore.set(name.toLowerCase(), { name, value });
+        return this;
+    }
+    appendHeader(name, value) {
+        const key = name.toLowerCase();
+        const current = this.headerStore.get(key);
+        if (current === undefined) {
+            return this.setHeader(name, value);
+        }
+        const values = Array.isArray(current.value)
+            ? current.value
+            : [String(current.value)];
+        this.headerStore.set(key, {
+            name: current.name,
+            value: values.concat(value),
+        });
+        return this;
+    }
+    getHeader(name) {
+        return this.headerStore.get(name.toLowerCase())?.value;
+    }
+    getHeaders() {
+        const headers = {};
+        for (const { name, value } of this.headerStore.values()) {
+            headers[name.toLowerCase()] = value;
+        }
+        return headers;
+    }
+    getHeaderNames() {
+        return [...this.headerStore.keys()];
+    }
+    hasHeader(name) {
+        return this.headerStore.has(name.toLowerCase());
+    }
+    removeHeader(name) {
+        this.headerStore.delete(name.toLowerCase());
+    }
+    writeHead(statusCode, statusMessageOrHeaders, maybeHeaders) {
+        this.statusCode = statusCode;
+        let headers = maybeHeaders;
+        if (typeof statusMessageOrHeaders === "string") {
+            this.statusMessage = statusMessageOrHeaders;
+        }
+        else if (statusMessageOrHeaders !== undefined) {
+            headers = statusMessageOrHeaders;
+        }
+        if (Array.isArray(headers)) {
+            // Node's flat even/odd `[name, value, name, value]` form, where a name
+            // may repeat (one `Set-Cookie` per cookie), so, as Node does, each name
+            // replaces what was set before but its values add up. Tuples are
+            // flattened into the same form.
+            const flat = Array.isArray(headers[0]) ? headers.flat() : headers;
+            for (let i = 0; i < flat.length; i += 2) {
+                this.removeHeader(String(flat[i]));
+            }
+            for (let i = 0; i < flat.length; i += 2) {
+                const value = flat[i + 1];
+                this.appendHeader(String(flat[i]), typeof value === "number" ? String(value) : value);
+            }
+        }
+        else if (headers) {
+            for (const [name, value] of Object.entries(headers)) {
+                if (value !== undefined) {
+                    this.setHeader(name, value);
+                }
+            }
+        }
+        this.flushHeaders();
+        return 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() {
+        if (this.headersSent) {
+            return;
+        }
+        this.headersSent = true;
+        this.emit("head", this.buildHead());
+    }
+    /** Deprecated on `ServerResponse`, but `NodeNextResponse.sent` reads it. */
+    get finished() {
+        return this.writableEnded;
+    }
+    buildHead() {
+        const headers = {};
+        let cookies = [];
+        for (const { name, value } of this.headerStore.values()) {
+            const key = name.toLowerCase();
+            if (key === "set-cookie") {
+                cookies = setCookieList(value);
+                continue;
+            }
+            if (Array.isArray(value)) {
+                if (key === "location") {
+                    // Next.js sends an array `Location` when a cacheHandler `get` returns
+                    // null for a page that calls `redirect()`. Comma-joining produces a
+                    // URL that resolves to nothing, so take the last write.
+                    console.warn(`[cdk-nextjs] Next.js set ${value.length} Location headers ` +
+                        `(${value.join(" | ")}); using the last one.`);
+                    headers[key] = String(value[value.length - 1]);
+                    continue;
+                }
+                headers[key] = value.join(", ");
+                continue;
+            }
+            headers[key] = String(value);
+        }
+        return {
+            statusCode: this.statusCode,
+            statusMessage: this.statusMessage ?? node_http_1.STATUS_CODES[this.statusCode],
+            headers,
+            cookies,
+        };
+    }
+    // --- stream ---------------------------------------------------------------
+    _transform(chunk, _encoding, callback) {
+        // Lazily, because Next.js only calls `flushHeaders()` on the paths that
+        // stream. `sendPayload` just writes and ends.
+        this.flushHeaders();
+        callback(null, chunk);
+    }
+    _flush(callback) {
+        // An empty body still needs a status line.
+        this.flushHeaders();
+        callback();
+    }
+    // --- the rest of the ServerResponse surface -------------------------------
+    addTrailers() {
+        return unsupported("addTrailers");
+    }
+    assignSocket() {
+        return unsupported("assignSocket");
+    }
+    detachSocket() {
+        return unsupported("detachSocket");
+    }
+    writeContinue() {
+        return unsupported("writeContinue");
+    }
+    writeEarlyHints() {
+        return unsupported("writeEarlyHints");
+    }
+    writeProcessing() {
+        return unsupported("writeProcessing");
+    }
+}
+exports.ShimServerResponse = ShimServerResponse;
+/**
+ * `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.
+ */
+function asServerResponse(res) {
+    return res;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"response.js","sourceRoot":"","sources":["../../../src/runtime/http/response.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * A synthesized, streaming `http.ServerResponse`.\n *\n * The response *is* the stream: this is a `Transform` that Next.js writes into,\n * and the shell pipes into its own byte sink (`awslambda.HttpResponseStream` for\n * Functions, the real `ServerResponse` for Containers). Status and headers are\n * emitted once as a {@link ResponseHead} on the `\"head\"` event, because Lambda's\n * response stream needs them in a prelude *before* any body byte.\n *\n * Modeled on OpenNext's `OpenNextNodeResponse` (MIT, © 2022 SST):\n * https://github.com/opennextjs/opennextjs-aws/blob/main/packages/open-next/src/http/openNextResponse.ts\n *\n * Deliberately much smaller than that file. OpenNext's shim doubles as a\n * `BaseNextResponse` and re-implements the middleware header merge, because\n * OpenNext reimplements routing. We hand this object to `handler(req, res, ctx)`,\n * which wraps it in Next.js's own `NodeNextResponse`\n * (`next/dist/server/base-http/node.js`) — so the contract is just \"be a\n * `ServerResponse`\", and the header-merge logic belongs to `@next/routing`.\n */\nimport { STATUS_CODES } from \"node:http\";\nimport type { OutgoingHttpHeaders, ServerResponse } from \"node:http\";\nimport { Transform } from \"node:stream\";\nimport type { TransformCallback } from \"node:stream\";\n\nexport interface ResponseHead {\n  readonly statusCode: number;\n  readonly statusMessage?: string;\n  /**\n   * Flat header map with `set-cookie` removed — a `Record<string, string>`\n   * cannot represent it, and both sinks take cookies separately.\n   */\n  readonly headers: Record<string, string>;\n  readonly cookies: string[];\n}\n\n/**\n * One entry per `Set-Cookie` line, the way Node's `ServerResponse` emits them:\n * each array element is a whole cookie and a string is exactly one. Nothing here\n * splits on commas — `Expires=` dates contain one in every format (`Wed, 21 Oct`,\n * `Wednesday, 21-Oct-26`), and a heuristic split turns one cookie into a session\n * cookie on the wrong path plus a junk one.\n */\nexport function setCookieList(value: string | string[] | number): string[] {\n  return (Array.isArray(value) ? value : [value])\n    .map((cookie) => String(cookie).trim())\n    .filter(Boolean);\n}\n\ntype HeaderValue = string | number | string[];\n\n/** Node never calls these, and Next.js never calls them either. */\nfunction unsupported(method: string): never {\n  throw new Error(\n    `res.${method}() is not supported by the cdk-nextjs runtime. Next.js does ` +\n      `not call it, so reaching this means something else is writing the ` +\n      `response.`,\n  );\n}\n\nexport class ShimServerResponse extends Transform {\n  public statusCode = 200;\n  public statusMessage?: string;\n  public headersSent = false;\n  /** Accepted and ignored: there is no socket to schedule a `Date` header on. */\n  public sendDate = false;\n  public strictContentLength = false;\n  public chunkedEncoding = false;\n  public shouldKeepAlive = false;\n  public useChunkedEncodingByDefault = false;\n  /** Set by Next.js in a few places; never read by us. */\n  public req?: unknown;\n  /**\n   * Installed by the runtime core when it inserts gzip, so that Next.js's\n   * per-chunk `if (\"flush\" in res) res.flush()` actually reaches the\n   * compressor. Without it, streamed HTML sits in zlib's buffer.\n   */\n  public flush?: () => void;\n\n  /** Lowercased name → original casing + value, mirroring Node's own store. */\n  private readonly headerStore = new Map<\n    string,\n    { name: string; value: HeaderValue }\n  >();\n\n  public constructor() {\n    super();\n  }\n\n  // --- header API -----------------------------------------------------------\n\n  public setHeader(name: string, value: HeaderValue): this {\n    this.headerStore.set(name.toLowerCase(), { name, value });\n    return this;\n  }\n\n  public appendHeader(name: string, value: string | string[]): this {\n    const key = name.toLowerCase();\n    const current = this.headerStore.get(key);\n    if (current === undefined) {\n      return this.setHeader(name, value);\n    }\n    const values = Array.isArray(current.value)\n      ? current.value\n      : [String(current.value)];\n    this.headerStore.set(key, {\n      name: current.name,\n      value: values.concat(value),\n    });\n    return this;\n  }\n\n  public getHeader(name: string): HeaderValue | undefined {\n    return this.headerStore.get(name.toLowerCase())?.value;\n  }\n\n  public getHeaders(): OutgoingHttpHeaders {\n    const headers: OutgoingHttpHeaders = {};\n    for (const { name, value } of this.headerStore.values()) {\n      headers[name.toLowerCase()] = value;\n    }\n    return headers;\n  }\n\n  public getHeaderNames(): string[] {\n    return [...this.headerStore.keys()];\n  }\n\n  public hasHeader(name: string): boolean {\n    return this.headerStore.has(name.toLowerCase());\n  }\n\n  public removeHeader(name: string): void {\n    this.headerStore.delete(name.toLowerCase());\n  }\n\n  public writeHead(\n    statusCode: number,\n    statusMessageOrHeaders?: string | OutgoingHttpHeaders | HeaderValue[],\n    maybeHeaders?: OutgoingHttpHeaders | HeaderValue[],\n  ): this {\n    this.statusCode = statusCode;\n    let headers = maybeHeaders;\n    if (typeof statusMessageOrHeaders === \"string\") {\n      this.statusMessage = statusMessageOrHeaders;\n    } else if (statusMessageOrHeaders !== undefined) {\n      headers = statusMessageOrHeaders;\n    }\n\n    if (Array.isArray(headers)) {\n      // Node's flat even/odd `[name, value, name, value]` form, where a name\n      // may repeat (one `Set-Cookie` per cookie), so, as Node does, each name\n      // replaces what was set before but its values add up. Tuples are\n      // flattened into the same form.\n      const flat = Array.isArray(headers[0]) ? headers.flat() : headers;\n      for (let i = 0; i < flat.length; i += 2) {\n        this.removeHeader(String(flat[i]));\n      }\n      for (let i = 0; i < flat.length; i += 2) {\n        const value = flat[i + 1] as HeaderValue;\n        this.appendHeader(\n          String(flat[i]),\n          typeof value === \"number\" ? String(value) : value,\n        );\n      }\n    } else if (headers) {\n      for (const [name, value] of Object.entries(headers)) {\n        if (value !== undefined) {\n          this.setHeader(name, value as HeaderValue);\n        }\n      }\n    }\n\n    this.flushHeaders();\n    return this;\n  }\n\n  /**\n   * Freezes status + headers and emits them as the `\"head\"` event. Called\n   * explicitly by Next.js before it streams, and lazily by this class on the\n   * first byte or on `end()` when it isn't.\n   */\n  public flushHeaders(): void {\n    if (this.headersSent) {\n      return;\n    }\n    this.headersSent = true;\n    this.emit(\"head\", this.buildHead());\n  }\n\n  /** Deprecated on `ServerResponse`, but `NodeNextResponse.sent` reads it. */\n  public get finished(): boolean {\n    return this.writableEnded;\n  }\n\n  private buildHead(): ResponseHead {\n    const headers: Record<string, string> = {};\n    let cookies: string[] = [];\n    for (const { name, value } of this.headerStore.values()) {\n      const key = name.toLowerCase();\n      if (key === \"set-cookie\") {\n        cookies = setCookieList(value);\n        continue;\n      }\n      if (Array.isArray(value)) {\n        if (key === \"location\") {\n          // Next.js sends an array `Location` when a cacheHandler `get` returns\n          // null for a page that calls `redirect()`. Comma-joining produces a\n          // URL that resolves to nothing, so take the last write.\n          console.warn(\n            `[cdk-nextjs] Next.js set ${value.length} Location headers ` +\n              `(${value.join(\" | \")}); using the last one.`,\n          );\n          headers[key] = String(value[value.length - 1]);\n          continue;\n        }\n        headers[key] = value.join(\", \");\n        continue;\n      }\n      headers[key] = String(value);\n    }\n    return {\n      statusCode: this.statusCode,\n      statusMessage: this.statusMessage ?? STATUS_CODES[this.statusCode],\n      headers,\n      cookies,\n    };\n  }\n\n  // --- stream ---------------------------------------------------------------\n\n  public override _transform(\n    chunk: unknown,\n    _encoding: BufferEncoding,\n    callback: TransformCallback,\n  ): void {\n    // Lazily, because Next.js only calls `flushHeaders()` on the paths that\n    // stream. `sendPayload` just writes and ends.\n    this.flushHeaders();\n    callback(null, chunk);\n  }\n\n  public override _flush(callback: TransformCallback): void {\n    // An empty body still needs a status line.\n    this.flushHeaders();\n    callback();\n  }\n\n  // --- the rest of the ServerResponse surface -------------------------------\n\n  public addTrailers(): never {\n    return unsupported(\"addTrailers\");\n  }\n  public assignSocket(): never {\n    return unsupported(\"assignSocket\");\n  }\n  public detachSocket(): never {\n    return unsupported(\"detachSocket\");\n  }\n  public writeContinue(): never {\n    return unsupported(\"writeContinue\");\n  }\n  public writeEarlyHints(): never {\n    return unsupported(\"writeEarlyHints\");\n  }\n  public writeProcessing(): never {\n    return unsupported(\"writeProcessing\");\n  }\n}\n\n/**\n * `ShimServerResponse` is structurally a `ServerResponse` for everything Next.js\n * touches, but not nominally one (no socket, no trailers). The entrypoint\n * signature wants the real type, so the cast is centralized here with the\n * reasoning attached rather than repeated at each call site.\n */\nexport function asServerResponse(res: ShimServerResponse): ServerResponse {\n  return res as unknown as ServerResponse;\n}\n"]}

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

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

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

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const response_1 = require("./response");
+/** Collects the head and the body bytes the way a sink would. */
+function collect(res) {
+    let head;
+    const chunks = [];
+    res.once("head", (value) => {
+        head = value;
+    });
+    res.on("data", (chunk) => chunks.push(chunk));
+    return {
+        head: () => head,
+        body: () => Buffer.concat(chunks).toString("utf-8"),
+    };
+}
+function finished(res) {
+    return new Promise((resolve, reject) => {
+        res.once("end", resolve);
+        res.once("error", reject);
+        res.resume();
+    });
+}
+describe("ShimServerResponse head", () => {
+    it("emits status and headers once, on the first body byte", async () => {
+        const res = new response_1.ShimServerResponse();
+        const sink = collect(res);
+        res.setHeader("Content-Type", "text/html");
+        expect(sink.head()).toBeUndefined();
+        res.write("<p>hi</p>");
+        expect(sink.head()).toEqual({
+            statusCode: 200,
+            statusMessage: "OK",
+            headers: { "content-type": "text/html" },
+            cookies: [],
+        });
+        res.end();
+        await finished(res);
+        expect(sink.body()).toBe("<p>hi</p>");
+    });
+    it("still emits a head for an empty body", async () => {
+        const res = new response_1.ShimServerResponse();
+        const sink = collect(res);
+        res.statusCode = 204;
+        res.end();
+        await finished(res);
+        expect(sink.head()?.statusCode).toBe(204);
+    });
+    it("is idempotent, so an explicit flushHeaders() plus a write emits once", () => {
+        const res = new response_1.ShimServerResponse();
+        const heads = [];
+        res.on("head", (head) => heads.push(head));
+        res.flushHeaders();
+        res.write("a");
+        res.flushHeaders();
+        expect(heads).toHaveLength(1);
+        expect(res.headersSent).toBe(true);
+    });
+    it("reports `finished` once ended, which NodeNextResponse.sent reads", async () => {
+        const res = new response_1.ShimServerResponse();
+        collect(res);
+        expect(res.finished).toBe(false);
+        res.end("x");
+        await finished(res);
+        expect(res.finished).toBe(true);
+    });
+});
+describe("ShimServerResponse headers", () => {
+    it("keeps set-cookie out of the flat map", () => {
+        const res = new response_1.ShimServerResponse();
+        const sink = collect(res);
+        res.appendHeader("Set-Cookie", "a=1; Path=/");
+        res.appendHeader("Set-Cookie", "b=2; Path=/");
+        res.setHeader("X-Other", "keep");
+        res.flushHeaders();
+        expect(sink.head()?.cookies).toEqual(["a=1; Path=/", "b=2; Path=/"]);
+        expect(sink.head()?.headers).toEqual({ "x-other": "keep" });
+    });
+    it("joins other repeated headers with a comma", () => {
+        const res = new response_1.ShimServerResponse();
+        const sink = collect(res);
+        res.setHeader("Vary", ["Accept", "Cookie"]);
+        res.flushHeaders();
+        expect(sink.head()?.headers.vary).toBe("Accept, Cookie");
+    });
+    it("takes the last of multiple Location values and warns", () => {
+        const res = new response_1.ShimServerResponse();
+        const sink = collect(res);
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
+        res.setHeader("Location", ["/first", "/second"]);
+        res.flushHeaders();
+        // Comma-joining would produce a URL that resolves to nothing.
+        expect(sink.head()?.headers.location).toBe("/second");
+        expect(warn).toHaveBeenCalled();
+        warn.mockRestore();
+    });
+    it("is case-insensitive and supports the rest of the header API", () => {
+        const res = new response_1.ShimServerResponse();
+        res.setHeader("X-A", "1");
+        expect(res.getHeader("x-a")).toBe("1");
+        expect(res.hasHeader("X-A")).toBe(true);
+        expect(res.getHeaderNames()).toEqual(["x-a"]);
+        expect(res.getHeaders()).toEqual({ "x-a": "1" });
+        res.removeHeader("X-A");
+        expect(res.hasHeader("x-a")).toBe(false);
+    });
+});
+describe("ShimServerResponse.writeHead", () => {
+    it("accepts a status message plus a header object", () => {
+        const res = new response_1.ShimServerResponse();
+        const sink = collect(res);
+        res.writeHead(301, "Moved", { Location: "/there" });
+        expect(sink.head()).toEqual({
+            statusCode: 301,
+            statusMessage: "Moved",
+            headers: { location: "/there" },
+            cookies: [],
+        });
+    });
+    it("keeps every value of a name the flat array form repeats", () => {
+        const res = new response_1.ShimServerResponse();
+        const sink = collect(res);
+        res.setHeader("Set-Cookie", "stale=1");
+        res.setHeader("X-A", "stale");
+        res.writeHead(200, ["Set-Cookie", "a=1", "Set-Cookie", "b=2", "X-A", "1"]);
+        expect(sink.head()?.cookies).toEqual(["a=1", "b=2"]);
+        expect(sink.head()?.headers["x-a"]).toBe("1");
+    });
+    it("accepts the flat even/odd array form", () => {
+        const res = new response_1.ShimServerResponse();
+        const sink = collect(res);
+        res.writeHead(200, ["Content-Type", "text/plain", "X-B", "2"]);
+        expect(sink.head()?.headers).toEqual({
+            "content-type": "text/plain",
+            "x-b": "2",
+        });
+    });
+    it("accepts the tuple array form", () => {
+        const res = new response_1.ShimServerResponse();
+        const sink = collect(res);
+        res.writeHead(200, [
+            ["Content-Type", "text/plain"],
+            ["X-B", "2"],
+        ]);
+        expect(sink.head()?.headers).toEqual({
+            "content-type": "text/plain",
+            "x-b": "2",
+        });
+    });
+});
+describe("setCookieList", () => {
+    it.each([
+        "token=x; expires=Wed, 21 Oct 2026 07:28:00 GMT; Path=/",
+        "token=x; Expires=Wednesday, 21-Oct-26 07:28:00 GMT; Path=/",
+        "a=1; Expires=Thu, 01 Jan 2026 00:00:00 GMT",
+    ])("keeps a single cookie whole: %s", (cookie) => {
+        expect((0, response_1.setCookieList)(cookie)).toEqual([cookie]);
+    });
+    it("treats each array entry as one cookie and drops empties", () => {
+        expect((0, response_1.setCookieList)(["a=1; expires=Wed, 21 Oct 2026 07:28:00 GMT", "b=2", ""])).toEqual(["a=1; expires=Wed, 21 Oct 2026 07:28:00 GMT", "b=2"]);
+    });
+    it("emits a lowercase-expires cookie as one Set-Cookie line", () => {
+        const res = new response_1.ShimServerResponse();
+        const cookie = "token=x; expires=Wed, 21 Oct 2026 07:28:00 GMT; Path=/";
+        res.setHeader("Set-Cookie", cookie);
+        let head;
+        res.on("head", (h) => (head = h));
+        res.flushHeaders();
+        expect(head?.cookies).toEqual([cookie]);
+    });
+});
+describe("unsupported ServerResponse methods", () => {
+    it.each(["addTrailers", "assignSocket", "writeContinue", "writeEarlyHints"])("throws a named error from %s()", (method) => {
+        const res = new response_1.ShimServerResponse();
+        expect(() => res[method]()).toThrow(`res.${method}()`);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"response.test.js","sourceRoot":"","sources":["../../../src/runtime/http/response.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { ResponseHead, ShimServerResponse, setCookieList } from \"./response\";\n\n/** Collects the head and the body bytes the way a sink would. */\nfunction collect(res: ShimServerResponse): {\n  head: () => ResponseHead | undefined;\n  body: () => string;\n} {\n  let head: ResponseHead | undefined;\n  const chunks: Buffer[] = [];\n  res.once(\"head\", (value: ResponseHead) => {\n    head = value;\n  });\n  res.on(\"data\", (chunk: Buffer) => chunks.push(chunk));\n  return {\n    head: () => head,\n    body: () => Buffer.concat(chunks).toString(\"utf-8\"),\n  };\n}\n\nfunction finished(res: ShimServerResponse): Promise<void> {\n  return new Promise((resolve, reject) => {\n    res.once(\"end\", resolve);\n    res.once(\"error\", reject);\n    res.resume();\n  });\n}\n\ndescribe(\"ShimServerResponse head\", () => {\n  it(\"emits status and headers once, on the first body byte\", async () => {\n    const res = new ShimServerResponse();\n    const sink = collect(res);\n    res.setHeader(\"Content-Type\", \"text/html\");\n    expect(sink.head()).toBeUndefined();\n\n    res.write(\"<p>hi</p>\");\n    expect(sink.head()).toEqual({\n      statusCode: 200,\n      statusMessage: \"OK\",\n      headers: { \"content-type\": \"text/html\" },\n      cookies: [],\n    });\n    res.end();\n    await finished(res);\n    expect(sink.body()).toBe(\"<p>hi</p>\");\n  });\n\n  it(\"still emits a head for an empty body\", async () => {\n    const res = new ShimServerResponse();\n    const sink = collect(res);\n    res.statusCode = 204;\n    res.end();\n    await finished(res);\n    expect(sink.head()?.statusCode).toBe(204);\n  });\n\n  it(\"is idempotent, so an explicit flushHeaders() plus a write emits once\", () => {\n    const res = new ShimServerResponse();\n    const heads: ResponseHead[] = [];\n    res.on(\"head\", (head: ResponseHead) => heads.push(head));\n    res.flushHeaders();\n    res.write(\"a\");\n    res.flushHeaders();\n    expect(heads).toHaveLength(1);\n    expect(res.headersSent).toBe(true);\n  });\n\n  it(\"reports `finished` once ended, which NodeNextResponse.sent reads\", async () => {\n    const res = new ShimServerResponse();\n    collect(res);\n    expect(res.finished).toBe(false);\n    res.end(\"x\");\n    await finished(res);\n    expect(res.finished).toBe(true);\n  });\n});\n\ndescribe(\"ShimServerResponse headers\", () => {\n  it(\"keeps set-cookie out of the flat map\", () => {\n    const res = new ShimServerResponse();\n    const sink = collect(res);\n    res.appendHeader(\"Set-Cookie\", \"a=1; Path=/\");\n    res.appendHeader(\"Set-Cookie\", \"b=2; Path=/\");\n    res.setHeader(\"X-Other\", \"keep\");\n    res.flushHeaders();\n    expect(sink.head()?.cookies).toEqual([\"a=1; Path=/\", \"b=2; Path=/\"]);\n    expect(sink.head()?.headers).toEqual({ \"x-other\": \"keep\" });\n  });\n\n  it(\"joins other repeated headers with a comma\", () => {\n    const res = new ShimServerResponse();\n    const sink = collect(res);\n    res.setHeader(\"Vary\", [\"Accept\", \"Cookie\"]);\n    res.flushHeaders();\n    expect(sink.head()?.headers.vary).toBe(\"Accept, Cookie\");\n  });\n\n  it(\"takes the last of multiple Location values and warns\", () => {\n    const res = new ShimServerResponse();\n    const sink = collect(res);\n    const warn = jest.spyOn(console, \"warn\").mockImplementation(() => {});\n    res.setHeader(\"Location\", [\"/first\", \"/second\"]);\n    res.flushHeaders();\n    // Comma-joining would produce a URL that resolves to nothing.\n    expect(sink.head()?.headers.location).toBe(\"/second\");\n    expect(warn).toHaveBeenCalled();\n    warn.mockRestore();\n  });\n\n  it(\"is case-insensitive and supports the rest of the header API\", () => {\n    const res = new ShimServerResponse();\n    res.setHeader(\"X-A\", \"1\");\n    expect(res.getHeader(\"x-a\")).toBe(\"1\");\n    expect(res.hasHeader(\"X-A\")).toBe(true);\n    expect(res.getHeaderNames()).toEqual([\"x-a\"]);\n    expect(res.getHeaders()).toEqual({ \"x-a\": \"1\" });\n    res.removeHeader(\"X-A\");\n    expect(res.hasHeader(\"x-a\")).toBe(false);\n  });\n});\n\ndescribe(\"ShimServerResponse.writeHead\", () => {\n  it(\"accepts a status message plus a header object\", () => {\n    const res = new ShimServerResponse();\n    const sink = collect(res);\n    res.writeHead(301, \"Moved\", { Location: \"/there\" });\n    expect(sink.head()).toEqual({\n      statusCode: 301,\n      statusMessage: \"Moved\",\n      headers: { location: \"/there\" },\n      cookies: [],\n    });\n  });\n\n  it(\"keeps every value of a name the flat array form repeats\", () => {\n    const res = new ShimServerResponse();\n    const sink = collect(res);\n    res.setHeader(\"Set-Cookie\", \"stale=1\");\n    res.setHeader(\"X-A\", \"stale\");\n    res.writeHead(200, [\"Set-Cookie\", \"a=1\", \"Set-Cookie\", \"b=2\", \"X-A\", \"1\"]);\n    expect(sink.head()?.cookies).toEqual([\"a=1\", \"b=2\"]);\n    expect(sink.head()?.headers[\"x-a\"]).toBe(\"1\");\n  });\n\n  it(\"accepts the flat even/odd array form\", () => {\n    const res = new ShimServerResponse();\n    const sink = collect(res);\n    res.writeHead(200, [\"Content-Type\", \"text/plain\", \"X-B\", \"2\"]);\n    expect(sink.head()?.headers).toEqual({\n      \"content-type\": \"text/plain\",\n      \"x-b\": \"2\",\n    });\n  });\n\n  it(\"accepts the tuple array form\", () => {\n    const res = new ShimServerResponse();\n    const sink = collect(res);\n    res.writeHead(200, [\n      [\"Content-Type\", \"text/plain\"],\n      [\"X-B\", \"2\"],\n    ] as unknown as string[][]);\n    expect(sink.head()?.headers).toEqual({\n      \"content-type\": \"text/plain\",\n      \"x-b\": \"2\",\n    });\n  });\n});\n\ndescribe(\"setCookieList\", () => {\n  it.each([\n    \"token=x; expires=Wed, 21 Oct 2026 07:28:00 GMT; Path=/\",\n    \"token=x; Expires=Wednesday, 21-Oct-26 07:28:00 GMT; Path=/\",\n    \"a=1; Expires=Thu, 01 Jan 2026 00:00:00 GMT\",\n  ])(\"keeps a single cookie whole: %s\", (cookie) => {\n    expect(setCookieList(cookie)).toEqual([cookie]);\n  });\n\n  it(\"treats each array entry as one cookie and drops empties\", () => {\n    expect(\n      setCookieList([\"a=1; expires=Wed, 21 Oct 2026 07:28:00 GMT\", \"b=2\", \"\"]),\n    ).toEqual([\"a=1; expires=Wed, 21 Oct 2026 07:28:00 GMT\", \"b=2\"]);\n  });\n\n  it(\"emits a lowercase-expires cookie as one Set-Cookie line\", () => {\n    const res = new ShimServerResponse();\n    const cookie = \"token=x; expires=Wed, 21 Oct 2026 07:28:00 GMT; Path=/\";\n    res.setHeader(\"Set-Cookie\", cookie);\n    let head: ResponseHead | undefined;\n    res.on(\"head\", (h: ResponseHead) => (head = h));\n    res.flushHeaders();\n    expect(head?.cookies).toEqual([cookie]);\n  });\n});\n\ndescribe(\"unsupported ServerResponse methods\", () => {\n  it.each([\"addTrailers\", \"assignSocket\", \"writeContinue\", \"writeEarlyHints\"])(\n    \"throws a named error from %s()\",\n    (method) => {\n      const res = new ShimServerResponse() as unknown as Record<\n        string,\n        () => void\n      >;\n      expect(() => res[method]()).toThrow(`res.${method}()`);\n    },\n  );\n});\n"]}

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

@@ -0,0 +1,73 @@
+/**
+ * Connecting a {@link ShimServerResponse} to the bytes-out side of a shell, and
+ * the one thing that has to happen on the way: gzip.
+ *
+ * This lives in shared runtime code rather than in the Lambda shell on purpose.
+ * Neither managed layer can compress a *streamed* response:
+ *
+ * - API Gateway's `minCompressionSize` is set (`src/nextjs-api.ts`) but inert,
+ *   because cdk-nextjs also sets `ResponseTransferMode.STREAM`, and STREAM drops
+ *   content encoding outright — "If you want to compress your integration
+ *   response, do this in your integration".
+ * - CloudFront requires the origin to send `Content-Length`, which a streamed
+ *   response by definition does not. It still compresses non-streamed responses
+ *   and S3 assets, so the gap is exactly streamed HTML and RSC payloads — the
+ *   largest text responses we serve.
+ *
+ * Until the container path was dropped, Lambda Web Adapter did this for us, which
+ * is why nothing in the old code mentions it. **Don't "fix" the API Gateway or
+ * CloudFront settings expecting them to take over.**
+ *
+ * gzip rather than brotli: brotli's streaming throughput at default quality is
+ * poor, and CloudFront prefers `br` only when the origin didn't already encode —
+ * which stops applying the moment we set `content-encoding` ourselves.
+ */
+import { Writable } from "node:stream";
+import type { ShimIncomingMessage } from "./request";
+import { ResponseHead, ShimServerResponse } from "./response";
+export interface ResponseSink {
+    /**
+     * Set by the Lambda sink, for both integrations: a streamed Lambda response
+     * with zero payload bytes after the metadata delimiter is not recognized as a
+     * metadata response at all, so a single space is written instead of nothing.
+     *
+     * API Gateway answers 502. A Function URL is worse because it looks like it
+     * worked: the prelude is discarded and the response arrives as a bare
+     * `200 application/octet-stream` with an empty body, none of the app's headers,
+     * and an HTTP/2 stream that does not close cleanly — whatever the real status
+     * was. Measured against a `NextjsGlobalFunctions` deployment: `HEAD` on a 404
+     * page answered `200`, and a server action whose reply is empty (an action that
+     * only `redirect()`s, which Next.js answers with `x-action-redirect` and no
+     * body) lost the redirect header and so never navigated.
+     *
+     * The pre-adapter image handler carried the same workaround for 304s. RFC 9110
+     * forbids a body on 204/304, and a space technically violates that, but losing
+     * the status entirely is the worse failure — and on the CloudFront path a
+     * conditional request cannot reach the origin anyway, because `if-none-match`
+     * is not in the dynamic cache policy's header allowlist. The container sink
+     * writes to a real `ServerResponse` and does not set this.
+     */
+    readonly padEmptyBody?: boolean;
+    /**
+     * Called exactly once, before any body byte, with the final head. Returns the
+     * stream the body is written to; {@link pipeToSink} ends it.
+     */
+    begin(head: ResponseHead): Writable;
+}
+export interface PipeOptions {
+    /** `next.config` `compress`. */
+    readonly compress: boolean;
+}
+/**
+ * Pipe `res` into `sink`, gzipping when that is both allowed and useful.
+ *
+ * Resolves when the sink's stream has finished, which for Lambda is the point the
+ * client has the whole response. Must be called *before* anything writes to
+ * `res`, because it subscribes to the one-shot `"head"` event.
+ */
+export declare function pipeToSink(req: ShimIncomingMessage, res: ShimServerResponse, sink: ResponseSink, options: PipeOptions): Promise<void>;
+/**
+ * A `q=0` on gzip is a refusal, and both `*` forms have to be honored, so this
+ * parses rather than substring-matching.
+ */
+export declare function acceptsGzip(header: string | string[] | undefined): boolean;