cdk-nextjs 0.6.1 → 0.7.0

package/lib/runtime/http/sink.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pipeToSink = pipeToSink;
+exports.acceptsGzip = acceptsGzip;
+/**
+ * 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.
+ */
+const node_stream_1 = require("node:stream");
+const promises_1 = require("node:stream/promises");
+const node_zlib_1 = require("node:zlib");
+/**
+ * Content types worth compressing. Everything Next streams as HTML or an RSC
+ * payload is `text/*`; images and fonts are already compressed, and gzipping an
+ * optimized AVIF just burns CPU.
+ */
+const COMPRESSIBLE = /^(?:text\/|application\/(?:json|javascript|xml|manifest|rss\+xml|atom\+xml)|image\/svg\+xml)/;
+/**
+ * Statuses whose body must not be compressed: 204 and 304 have none, and a 206's
+ * body is a byte range of the *uncompressed* representation.
+ *
+ * 206 is reachable — `serveStaticFile` is `send` underneath, which advertises
+ * `Accept-Ranges: bytes` and honors `Range` on the static HTML the runtime serves
+ * itself. Gzipping one produced a response whose `Content-Range` still described
+ * the uncompressed slice (`withGzipHeaders` drops `content-length` but cannot
+ * restate a range), so the client got bytes that did not match what it asked for.
+ */
+const UNCOMPRESSABLE_STATUS = new Set([204, 206, 304]);
+/** `compression`'s own test for the directive. */
+const NO_TRANSFORM = /(?:^|,)\s*?no-transform\s*?(?:,|$)/i;
+/**
+ * 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.
+ */
+function pipeToSink(req, res, sink, options) {
+    return new Promise((resolve, reject) => {
+        let piping = false;
+        res.once("error", reject);
+        // Destroyed before the head went out, and without an error: a client that
+        // disconnected before the first byte, which `handle()` answers with
+        // `res.destroy()`. `Transform.destroy()` with no argument emits only
+        // `"close"`, and the pipeline below never started, so nothing else can ever
+        // settle this promise — leaving `handle()` awaiting it forever, its
+        // `waitUntil` work (ISR revalidation, cache writes) never flushed and the
+        // in-flight render's closure retained for the life of the process.
+        res.once("close", () => {
+            if (!piping) {
+                resolve();
+            }
+        });
+        res.once("head", (head) => {
+            piping = true;
+            const stages = [];
+            const gzip = shouldGzip(req, res, head, options);
+            if (gzip) {
+                const compressor = (0, node_zlib_1.createGzip)();
+                // Next.js calls `res.flush()` after each chunk it writes
+                // (`next/dist/server/pipe-readable.js`); without forwarding it, streamed
+                // HTML sits in zlib's buffer and the response arrives all at once.
+                res.flush = () => compressor.flush(node_zlib_1.constants.Z_SYNC_FLUSH);
+                stages.push(compressor);
+            }
+            if (sink.padEmptyBody) {
+                stages.push(padEmptyBody());
+            }
+            try {
+                stages.push(sink.begin(gzip ? withGzipHeaders(head) : head));
+            }
+            catch (error) {
+                // This runs inside whichever `res` call flushed the head — usually a
+                // `write()` from deep inside Next.js — so an escaping throw lands there,
+                // the pipeline below never starts, and nothing would settle this
+                // promise: `handle()` would hang. A sink's `writeHead` rejecting a
+                // header value is how it happens. Destroying `res` is what stops the
+                // writer; the `"error"` that emits is a no-op after the `reject`.
+                for (const stage of stages) {
+                    stage.destroy();
+                }
+                reject(error);
+                res.destroy(error instanceof Error ? error : new Error(String(error)));
+                return;
+            }
+            (0, promises_1.pipeline)(res, ...stages).then(resolve, reject);
+        });
+    });
+}
+function shouldGzip(req, res, head, options) {
+    if (!options.compress) {
+        return false;
+    }
+    if (req.method === "HEAD" || UNCOMPRESSABLE_STATUS.has(head.statusCode)) {
+        return false;
+    }
+    // Next.js encodes some responses itself; double-encoding is not a thing.
+    if (res.hasHeader("content-encoding")) {
+        return false;
+    }
+    if (!COMPRESSIBLE.test(head.headers["content-type"] ?? "")) {
+        return false;
+    }
+    // The response's opt-out, which `next start`'s `compression` honors too: an
+    // SSE stream sets it so that nothing buffers its events.
+    if (NO_TRANSFORM.test(head.headers["cache-control"] ?? "")) {
+        return false;
+    }
+    return acceptsGzip(req.headers["accept-encoding"]);
+}
+/**
+ * A `q=0` on gzip is a refusal, and both `*` forms have to be honored, so this
+ * parses rather than substring-matching.
+ */
+function acceptsGzip(header) {
+    const value = Array.isArray(header) ? header.join(",") : header;
+    if (!value) {
+        return false;
+    }
+    let wildcard;
+    for (const part of value.split(",")) {
+        const [rawName, ...params] = part.split(";");
+        const name = rawName.trim().toLowerCase();
+        if (name !== "gzip" && name !== "*") {
+            continue;
+        }
+        const q = params
+            .map((p) => p.trim().toLowerCase())
+            .find((p) => p.startsWith("q="));
+        const accepted = q === undefined || Number(q.slice(2)) > 0;
+        if (name === "gzip") {
+            return accepted;
+        }
+        wildcard = accepted;
+    }
+    return wildcard ?? false;
+}
+function withGzipHeaders(head) {
+    const headers = {
+        ...head.headers,
+        "content-encoding": "gzip",
+    };
+    // The length we were told is the uncompressed one, and we do not know the
+    // compressed one until the stream ends.
+    delete headers["content-length"];
+    const vary = headers.vary;
+    if (!vary) {
+        headers.vary = "Accept-Encoding";
+    }
+    else if (!/\baccept-encoding\b/i.test(vary)) {
+        headers.vary = `${vary}, Accept-Encoding`;
+    }
+    return { ...head, headers };
+}
+/** See {@link ResponseSink.padEmptyBody}. */
+function padEmptyBody() {
+    let wroteSomething = false;
+    return new node_stream_1.Transform({
+        transform(chunk, _encoding, callback) {
+            wroteSomething = true;
+            callback(null, chunk);
+        },
+        flush(callback) {
+            callback(null, wroteSomething ? undefined : " ");
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sink.js","sourceRoot":"","sources":["../../../src/runtime/http/sink.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Connecting a {@link ShimServerResponse} to the bytes-out side of a shell, and\n * the one thing that has to happen on the way: gzip.\n *\n * This lives in shared runtime code rather than in the Lambda shell on purpose.\n * Neither managed layer can compress a *streamed* response:\n *\n * - API Gateway's `minCompressionSize` is set (`src/nextjs-api.ts`) but inert,\n *   because cdk-nextjs also sets `ResponseTransferMode.STREAM`, and STREAM drops\n *   content encoding outright — \"If you want to compress your integration\n *   response, do this in your integration\".\n * - CloudFront requires the origin to send `Content-Length`, which a streamed\n *   response by definition does not. It still compresses non-streamed responses\n *   and S3 assets, so the gap is exactly streamed HTML and RSC payloads — the\n *   largest text responses we serve.\n *\n * Until the container path was dropped, Lambda Web Adapter did this for us, which\n * is why nothing in the old code mentions it. **Don't \"fix\" the API Gateway or\n * CloudFront settings expecting them to take over.**\n *\n * gzip rather than brotli: brotli's streaming throughput at default quality is\n * poor, and CloudFront prefers `br` only when the origin didn't already encode —\n * which stops applying the moment we set `content-encoding` ourselves.\n */\nimport { Transform, Writable } from \"node:stream\";\nimport { pipeline } from \"node:stream/promises\";\nimport { constants, createGzip } from \"node:zlib\";\nimport type { ShimIncomingMessage } from \"./request\";\nimport { ResponseHead, ShimServerResponse } from \"./response\";\n\nexport interface ResponseSink {\n  /**\n   * Set by the Lambda sink, for both integrations: a streamed Lambda response\n   * with zero payload bytes after the metadata delimiter is not recognized as a\n   * metadata response at all, so a single space is written instead of nothing.\n   *\n   * API Gateway answers 502. A Function URL is worse because it looks like it\n   * worked: the prelude is discarded and the response arrives as a bare\n   * `200 application/octet-stream` with an empty body, none of the app's headers,\n   * and an HTTP/2 stream that does not close cleanly — whatever the real status\n   * was. Measured against a `NextjsGlobalFunctions` deployment: `HEAD` on a 404\n   * page answered `200`, and a server action whose reply is empty (an action that\n   * only `redirect()`s, which Next.js answers with `x-action-redirect` and no\n   * body) lost the redirect header and so never navigated.\n   *\n   * The pre-adapter image handler carried the same workaround for 304s. RFC 9110\n   * forbids a body on 204/304, and a space technically violates that, but losing\n   * the status entirely is the worse failure — and on the CloudFront path a\n   * conditional request cannot reach the origin anyway, because `if-none-match`\n   * is not in the dynamic cache policy's header allowlist. The container sink\n   * writes to a real `ServerResponse` and does not set this.\n   */\n  readonly padEmptyBody?: boolean;\n  /**\n   * Called exactly once, before any body byte, with the final head. Returns the\n   * stream the body is written to; {@link pipeToSink} ends it.\n   */\n  begin(head: ResponseHead): Writable;\n}\n\n/**\n * Content types worth compressing. Everything Next streams as HTML or an RSC\n * payload is `text/*`; images and fonts are already compressed, and gzipping an\n * optimized AVIF just burns CPU.\n */\nconst COMPRESSIBLE =\n  /^(?:text\\/|application\\/(?:json|javascript|xml|manifest|rss\\+xml|atom\\+xml)|image\\/svg\\+xml)/;\n\n/**\n * Statuses whose body must not be compressed: 204 and 304 have none, and a 206's\n * body is a byte range of the *uncompressed* representation.\n *\n * 206 is reachable — `serveStaticFile` is `send` underneath, which advertises\n * `Accept-Ranges: bytes` and honors `Range` on the static HTML the runtime serves\n * itself. Gzipping one produced a response whose `Content-Range` still described\n * the uncompressed slice (`withGzipHeaders` drops `content-length` but cannot\n * restate a range), so the client got bytes that did not match what it asked for.\n */\nconst UNCOMPRESSABLE_STATUS = new Set([204, 206, 304]);\n\n/** `compression`'s own test for the directive. */\nconst NO_TRANSFORM = /(?:^|,)\\s*?no-transform\\s*?(?:,|$)/i;\n\nexport interface PipeOptions {\n  /** `next.config` `compress`. */\n  readonly compress: boolean;\n}\n\n/**\n * Pipe `res` into `sink`, gzipping when that is both allowed and useful.\n *\n * Resolves when the sink's stream has finished, which for Lambda is the point the\n * client has the whole response. Must be called *before* anything writes to\n * `res`, because it subscribes to the one-shot `\"head\"` event.\n */\nexport function pipeToSink(\n  req: ShimIncomingMessage,\n  res: ShimServerResponse,\n  sink: ResponseSink,\n  options: PipeOptions,\n): Promise<void> {\n  return new Promise<void>((resolve, reject) => {\n    let piping = false;\n    res.once(\"error\", reject);\n    // Destroyed before the head went out, and without an error: a client that\n    // disconnected before the first byte, which `handle()` answers with\n    // `res.destroy()`. `Transform.destroy()` with no argument emits only\n    // `\"close\"`, and the pipeline below never started, so nothing else can ever\n    // settle this promise — leaving `handle()` awaiting it forever, its\n    // `waitUntil` work (ISR revalidation, cache writes) never flushed and the\n    // in-flight render's closure retained for the life of the process.\n    res.once(\"close\", () => {\n      if (!piping) {\n        resolve();\n      }\n    });\n    res.once(\"head\", (head: ResponseHead) => {\n      piping = true;\n      const stages: Array<Transform | Writable> = [];\n\n      const gzip = shouldGzip(req, res, head, options);\n      if (gzip) {\n        const compressor = createGzip();\n        // Next.js calls `res.flush()` after each chunk it writes\n        // (`next/dist/server/pipe-readable.js`); without forwarding it, streamed\n        // HTML sits in zlib's buffer and the response arrives all at once.\n        res.flush = () => compressor.flush(constants.Z_SYNC_FLUSH);\n        stages.push(compressor);\n      }\n      if (sink.padEmptyBody) {\n        stages.push(padEmptyBody());\n      }\n      try {\n        stages.push(sink.begin(gzip ? withGzipHeaders(head) : head));\n      } catch (error) {\n        // This runs inside whichever `res` call flushed the head — usually a\n        // `write()` from deep inside Next.js — so an escaping throw lands there,\n        // the pipeline below never starts, and nothing would settle this\n        // promise: `handle()` would hang. A sink's `writeHead` rejecting a\n        // header value is how it happens. Destroying `res` is what stops the\n        // writer; the `\"error\"` that emits is a no-op after the `reject`.\n        for (const stage of stages) {\n          stage.destroy();\n        }\n        reject(error);\n        res.destroy(error instanceof Error ? error : new Error(String(error)));\n        return;\n      }\n\n      pipeline(res, ...(stages as [Writable])).then(resolve, reject);\n    });\n  });\n}\n\nfunction shouldGzip(\n  req: ShimIncomingMessage,\n  res: ShimServerResponse,\n  head: ResponseHead,\n  options: PipeOptions,\n): boolean {\n  if (!options.compress) {\n    return false;\n  }\n  if (req.method === \"HEAD\" || UNCOMPRESSABLE_STATUS.has(head.statusCode)) {\n    return false;\n  }\n  // Next.js encodes some responses itself; double-encoding is not a thing.\n  if (res.hasHeader(\"content-encoding\")) {\n    return false;\n  }\n  if (!COMPRESSIBLE.test(head.headers[\"content-type\"] ?? \"\")) {\n    return false;\n  }\n  // The response's opt-out, which `next start`'s `compression` honors too: an\n  // SSE stream sets it so that nothing buffers its events.\n  if (NO_TRANSFORM.test(head.headers[\"cache-control\"] ?? \"\")) {\n    return false;\n  }\n  return acceptsGzip(req.headers[\"accept-encoding\"]);\n}\n\n/**\n * A `q=0` on gzip is a refusal, and both `*` forms have to be honored, so this\n * parses rather than substring-matching.\n */\nexport function acceptsGzip(header: string | string[] | undefined): boolean {\n  const value = Array.isArray(header) ? header.join(\",\") : header;\n  if (!value) {\n    return false;\n  }\n  let wildcard: boolean | undefined;\n  for (const part of value.split(\",\")) {\n    const [rawName, ...params] = part.split(\";\");\n    const name = rawName.trim().toLowerCase();\n    if (name !== \"gzip\" && name !== \"*\") {\n      continue;\n    }\n    const q = params\n      .map((p) => p.trim().toLowerCase())\n      .find((p) => p.startsWith(\"q=\"));\n    const accepted = q === undefined || Number(q.slice(2)) > 0;\n    if (name === \"gzip\") {\n      return accepted;\n    }\n    wildcard = accepted;\n  }\n  return wildcard ?? false;\n}\n\nfunction withGzipHeaders(head: ResponseHead): ResponseHead {\n  const headers: Record<string, string> = {\n    ...head.headers,\n    \"content-encoding\": \"gzip\",\n  };\n  // The length we were told is the uncompressed one, and we do not know the\n  // compressed one until the stream ends.\n  delete headers[\"content-length\"];\n  const vary = headers.vary;\n  if (!vary) {\n    headers.vary = \"Accept-Encoding\";\n  } else if (!/\\baccept-encoding\\b/i.test(vary)) {\n    headers.vary = `${vary}, Accept-Encoding`;\n  }\n  return { ...head, headers };\n}\n\n/** See {@link ResponseSink.padEmptyBody}. */\nfunction padEmptyBody(): Transform {\n  let wroteSomething = false;\n  return new Transform({\n    transform(chunk, _encoding, callback) {\n      wroteSomething = true;\n      callback(null, chunk);\n    },\n    flush(callback) {\n      callback(null, wroteSomething ? undefined : \" \");\n    },\n  });\n}\n"]}

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

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

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

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_stream_1 = require("node:stream");
+const node_zlib_1 = require("node:zlib");
+const request_1 = require("./request");
+const response_1 = require("./response");
+const sink_1 = require("./sink");
+class CollectingSink {
+    padEmptyBody;
+    head;
+    chunks = [];
+    constructor(padEmptyBody = false) {
+        this.padEmptyBody = padEmptyBody;
+    }
+    begin(head) {
+        this.head = head;
+        const chunks = this.chunks;
+        return new node_stream_1.Writable({
+            write(chunk, _encoding, callback) {
+                chunks.push(Buffer.from(chunk));
+                callback();
+            },
+        });
+    }
+    get body() {
+        return Buffer.concat(this.chunks);
+    }
+}
+function requestWith(headers, method = "GET") {
+    return new request_1.ShimIncomingMessage({ method, url: "/", headers });
+}
+/** Runs one response through the sink and resolves once the sink is finished. */
+async function run(write, options = {}) {
+    const req = options.req ?? requestWith({ "accept-encoding": "gzip" });
+    const res = new response_1.ShimServerResponse();
+    const sink = new CollectingSink(options.padEmptyBody);
+    const done = (0, sink_1.pipeToSink)(req, res, sink, {
+        compress: options.compress ?? true,
+    });
+    write(res);
+    await done;
+    return sink;
+}
+describe("pipeToSink compression", () => {
+    it("gzips compressible content when the client accepts it", async () => {
+        const sink = await run((res) => {
+            res.setHeader("Content-Type", "text/html; charset=utf-8");
+            res.setHeader("Content-Length", "13");
+            res.end("<p>hello</p>");
+        });
+        expect(sink.head?.headers["content-encoding"]).toBe("gzip");
+        // The length we were told is the uncompressed one and the compressed one is
+        // not known until the stream ends.
+        expect(sink.head?.headers["content-length"]).toBeUndefined();
+        expect(sink.head?.headers.vary).toBe("Accept-Encoding");
+        expect((0, node_zlib_1.gunzipSync)(sink.body).toString("utf-8")).toBe("<p>hello</p>");
+    });
+    it("appends to an existing vary rather than replacing it", async () => {
+        const sink = await run((res) => {
+            res.setHeader("Content-Type", "text/html");
+            res.setHeader("Vary", "Cookie");
+            res.end("x");
+        });
+        expect(sink.head?.headers.vary).toBe("Cookie, Accept-Encoding");
+    });
+    it("forwards res.flush() to the compressor so streamed HTML is not buffered", async () => {
+        const seen = [];
+        const sink = await run((res) => {
+            res.setHeader("Content-Type", "text/html");
+            res.write("<html>");
+            // Next.js does exactly this after every chunk (`pipe-readable.js`).
+            res.flush?.();
+            seen.push(1);
+            res.end("</html>");
+        });
+        expect(seen).toEqual([1]);
+        expect((0, node_zlib_1.gunzipSync)(sink.body).toString("utf-8")).toBe("<html></html>");
+    });
+    it.each([
+        ["an incompressible content type", { "content-type": "image/avif" }],
+        ["an already-encoded body", { "content-encoding": "br" }],
+        [
+            "a response that opts out with no-transform",
+            {
+                "content-type": "text/event-stream",
+                "cache-control": "no-cache, no-transform",
+            },
+        ],
+    ])("does not gzip %s", async (_name, headers) => {
+        const sink = await run((res) => {
+            for (const [name, value] of Object.entries(headers)) {
+                res.setHeader(name, value);
+            }
+            res.end("body");
+        });
+        expect(sink.head?.headers["content-encoding"]).not.toBe("gzip");
+        expect(sink.body.toString("utf-8")).toBe("body");
+    });
+    it("does not gzip a 206, whose body is a range of the stored bytes", async () => {
+        // The one uncompressable status that carries a body. `content-range` counts
+        // bytes of the representation the client asked for, so gzipping the slice
+        // makes the range meaningless - and a client stitching ranges together
+        // (video, a resumed download) cannot use it.
+        const sink = await run((res) => {
+            res.statusCode = 206;
+            res.setHeader("Content-Type", "text/plain");
+            res.setHeader("Content-Range", "bytes 0-3/1000");
+            res.end("body");
+        });
+        expect(sink.head?.headers["content-encoding"]).toBeUndefined();
+        expect(sink.body.toString("utf-8")).toBe("body");
+    });
+    it("does not gzip when the client did not offer it", async () => {
+        const sink = await run((res) => {
+            res.setHeader("Content-Type", "text/html");
+            res.end("body");
+        }, { req: requestWith({}) });
+        expect(sink.head?.headers["content-encoding"]).toBeUndefined();
+        expect(sink.body.toString("utf-8")).toBe("body");
+    });
+    it("does not gzip when next.config sets compress: false", async () => {
+        const sink = await run((res) => {
+            res.setHeader("Content-Type", "text/html");
+            res.end("body");
+        }, { compress: false });
+        expect(sink.head?.headers["content-encoding"]).toBeUndefined();
+    });
+    it.each([
+        ["a HEAD request", { method: "HEAD", status: 200 }],
+        ["a 204", { method: "GET", status: 204 }],
+        ["a 304", { method: "GET", status: 304 }],
+    ])("does not gzip %s", async (_name, { method, status }) => {
+        const sink = await run((res) => {
+            res.statusCode = status;
+            res.setHeader("Content-Type", "text/html");
+            res.end();
+        }, { req: requestWith({ "accept-encoding": "gzip" }, method) });
+        expect(sink.head?.headers["content-encoding"]).toBeUndefined();
+    });
+});
+describe("pipeToSink empty-body padding", () => {
+    it("writes a single space when the sink asks for it", async () => {
+        const sink = await run((res) => {
+            res.statusCode = 304;
+            res.end();
+        }, { padEmptyBody: true });
+        // Zero payload bytes after the prelude makes API Gateway answer 502, and
+        // makes a Function URL drop the prelude and answer a bare
+        // `200 application/octet-stream`.
+        expect(sink.body.toString("utf-8")).toBe(" ");
+    });
+    it("pads a HEAD response, whose body is empty by definition", async () => {
+        const sink = await run((res) => {
+            res.setHeader("content-type", "text/html; charset=utf-8");
+            res.setHeader("content-length", "5798");
+            res.end();
+        }, {
+            padEmptyBody: true,
+            req: requestWith({ "accept-encoding": "gzip" }, "HEAD"),
+        });
+        expect(sink.body.toString("utf-8")).toBe(" ");
+        // The head still describes what a GET would return; the padding byte is not
+        // a body and the integration overwrites `content-length` with 0.
+        expect(sink.head?.headers["content-length"]).toBe("5798");
+    });
+    it("leaves a non-empty body alone", async () => {
+        const sink = await run((res) => res.end("real"), {
+            padEmptyBody: true,
+            compress: false,
+        });
+        expect(sink.body.toString("utf-8")).toBe("real");
+    });
+    it("sends nothing for an empty body when the sink does not ask", async () => {
+        const sink = await run((res) => {
+            res.statusCode = 304;
+            res.end();
+        });
+        expect(sink.body).toHaveLength(0);
+    });
+});
+describe("pipeToSink lifecycle", () => {
+    /**
+     * `handle()` awaits this promise before it flushes `waitUntil` work — ISR
+     * revalidation, cache writes — and before the request's closures can be
+     * collected. A client that disconnects before the first byte destroys the
+     * response without an error, which emits only `"close"`: the pipeline never
+     * started, so nothing else can settle the promise and the await never returned.
+     */
+    it("settles when the response is destroyed before the head goes out", async () => {
+        const req = requestWith({});
+        const res = new response_1.ShimServerResponse();
+        const done = (0, sink_1.pipeToSink)(req, res, new CollectingSink(), {
+            compress: true,
+        });
+        res.destroy();
+        await expect(done).resolves.toBeUndefined();
+    });
+    // The normal path has to keep settling on the pipeline, not on `"close"`: the
+    // body must be fully flushed into the sink by the time this resolves.
+    it("still settles on the pipeline once the head has gone out", async () => {
+        const sink = await run((res) => {
+            res.setHeader("content-type", "text/plain");
+            res.end("body");
+        }, { compress: false });
+        expect(sink.body.toString()).toBe("body");
+    });
+    it("rejects when the response errors", async () => {
+        const req = requestWith({});
+        const res = new response_1.ShimServerResponse();
+        const done = (0, sink_1.pipeToSink)(req, res, new CollectingSink(), {
+            compress: true,
+        });
+        res.destroy(new Error("boom"));
+        await expect(done).rejects.toThrow("boom");
+    });
+    // A sink that cannot take the head — `writeHead` rejecting a header value is
+    // the real case — throws from inside the `"head"` listener, where nothing
+    // else would catch it and the pipeline never starts.
+    it.each([
+        ["writes a body", (res) => res.end("body")],
+        ["ends empty", (res) => res.end()],
+        ["flushes its head first", (res) => res.writeHead(200)],
+    ])("rejects and destroys the response when begin() throws and the response %s", async (_name, write) => {
+        const req = requestWith({});
+        const res = new response_1.ShimServerResponse();
+        const done = (0, sink_1.pipeToSink)(req, res, {
+            begin() {
+                throw new Error("bad head");
+            },
+        }, { compress: false });
+        write(res);
+        await expect(done).rejects.toThrow("bad head");
+        expect(res.destroyed).toBe(true);
+    });
+});
+describe("acceptsGzip", () => {
+    it.each([
+        ["gzip", true],
+        ["gzip, deflate, br", true],
+        ["GZIP;q=0.5", true],
+        ["gzip;q=0", false],
+        ["*", true],
+        ["*;q=0", false],
+        // An explicit gzip preference wins over the wildcard, in either order.
+        ["*;q=0, gzip", true],
+        ["gzip;q=0, *", false],
+        ["br, deflate", false],
+        ["", false],
+        [undefined, false],
+    ])("%s → %s", (header, expected) => {
+        expect((0, sink_1.acceptsGzip)(header)).toBe(expected);
+    });
+    it("joins a repeated header before parsing", () => {
+        expect((0, sink_1.acceptsGzip)(["br", "gzip"])).toBe(true);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sink.test.js","sourceRoot":"","sources":["../../../src/runtime/http/sink.test.ts"],"names":[],"mappings":";;AAAA,6CAAuC;AACvC,yCAAuC;AACvC,uCAAgD;AAChD,yCAA8D;AAC9D,iCAA+D;AAE/D,MAAM,cAAc;IAIiB;IAH5B,IAAI,CAAgB;IACX,MAAM,GAAa,EAAE,CAAC;IAEtC,YAAmC,eAAe,KAAK;QAApB,iBAAY,GAAZ,YAAY,CAAQ;IAAG,CAAC;IAEpD,KAAK,CAAC,IAAkB;QAC7B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC3B,OAAO,IAAI,sBAAQ,CAAC;YAClB,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ;gBAC9B,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;gBAChC,QAAQ,EAAE,CAAC;YACb,CAAC;SACF,CAAC,CAAC;IACL,CAAC;IAED,IAAW,IAAI;QACb,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACpC,CAAC;CACF;AAED,SAAS,WAAW,CAClB,OAA+B,EAC/B,MAAM,GAAG,KAAK;IAEd,OAAO,IAAI,6BAAmB,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,CAAC;AAChE,CAAC;AAQD,iFAAiF;AACjF,KAAK,UAAU,GAAG,CAChB,KAAwC,EACxC,UAAoB,EAAE;IAEtB,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,WAAW,CAAC,EAAE,iBAAiB,EAAE,MAAM,EAAE,CAAC,CAAC;IACtE,MAAM,GAAG,GAAG,IAAI,6BAAkB,EAAE,CAAC;IACrC,MAAM,IAAI,GAAG,IAAI,cAAc,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;IACtD,MAAM,IAAI,GAAG,IAAA,iBAAU,EAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE;QACtC,QAAQ,EAAE,OAAO,CAAC,QAAQ,IAAI,IAAI;KACnC,CAAC,CAAC;IACH,KAAK,CAAC,GAAG,CAAC,CAAC;IACX,MAAM,IAAI,CAAC;IACX,OAAO,IAAI,CAAC;AACd,CAAC;AAED,QAAQ,CAAC,wBAAwB,EAAE,GAAG,EAAE;IACtC,EAAE,CAAC,uDAAuD,EAAE,KAAK,IAAI,EAAE;QACrE,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;YAC7B,GAAG,CAAC,SAAS,CAAC,cAAc,EAAE,0BAA0B,CAAC,CAAC;YAC1D,GAAG,CAAC,SAAS,CAAC,gBAAgB,EAAE,IAAI,CAAC,CAAC;YACtC,GAAG,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;QAC1B,CAAC,CAAC,CAAC;QACH,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC5D,4EAA4E;QAC5E,mCAAmC;QACnC,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,aAAa,EAAE,CAAC;QAC7D,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;QACxD,MAAM,CAAC,IAAA,sBAAU,EAAC,IAAI,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IACvE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,sDAAsD,EAAE,KAAK,IAAI,EAAE;QACpE,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;YAC7B,GAAG,CAAC,SAAS,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC;YAC3C,GAAG,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;YAChC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACf,CAAC,CAAC,CAAC;QACH,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,yBAAyB,CAAC,CAAC;IAClE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,yEAAyE,EAAE,KAAK,IAAI,EAAE;QACvF,MAAM,IAAI,GAAa,EAAE,CAAC;QAC1B,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;YAC7B,GAAG,CAAC,SAAS,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC;YAC3C,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;YACpB,oEAAoE;YACpE,GAAG,CAAC,KAAK,EAAE,EAAE,CAAC;YACd,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACb,GAAG,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACrB,CAAC,CAAC,CAAC;QACH,MAAM,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC1B,MAAM,CAAC,IAAA,sBAAU,EAAC,IAAI,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;IACxE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,IAAI,CAAC;QACN,CAAC,gCAAgC,EAAE,EAAE,cAAc,EAAE,YAAY,EAAE,CAAC;QACpE,CAAC,yBAAyB,EAAE,EAAE,kBAAkB,EAAE,IAAI,EAAE,CAAC;QACzD;YACE,4CAA4C;YAC5C;gBACE,cAAc,EAAE,mBAAmB;gBACnC,eAAe,EAAE,wBAAwB;aAC1C;SACF;KACF,CAAC,CAAC,kBAAkB,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE;QAC9C,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;YAC7B,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;gBACpD,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YAC7B,CAAC;YACD,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAClB,CAAC,CAAC,CAAC;QACH,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAChE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACnD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,gEAAgE,EAAE,KAAK,IAAI,EAAE;QAC9E,4EAA4E;QAC5E,0EAA0E;QAC1E,uEAAuE;QACvE,6CAA6C;QAC7C,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;YAC7B,GAAG,CAAC,UAAU,GAAG,GAAG,CAAC;YACrB,GAAG,CAAC,SAAS,CAAC,cAAc,EAAE,YAAY,CAAC,CAAC;YAC5C,GAAG,CAAC,SAAS,CAAC,eAAe,EAAE,gBAAgB,CAAC,CAAC;YACjD,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAClB,CAAC,CAAC,CAAC;QACH,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,aAAa,EAAE,CAAC;QAC/D,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACnD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,gDAAgD,EAAE,KAAK,IAAI,EAAE;QAC9D,MAAM,IAAI,GAAG,MAAM,GAAG,CACpB,CAAC,GAAG,EAAE,EAAE;YACN,GAAG,CAAC,SAAS,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC;YAC3C,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAClB,CAAC,EACD,EAAE,GAAG,EAAE,WAAW,CAAC,EAAE,CAAC,EAAE,CACzB,CAAC;QACF,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,aAAa,EAAE,CAAC;QAC/D,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACnD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,qDAAqD,EAAE,KAAK,IAAI,EAAE;QACnE,MAAM,IAAI,GAAG,MAAM,GAAG,CACpB,CAAC,GAAG,EAAE,EAAE;YACN,GAAG,CAAC,SAAS,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC;YAC3C,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAClB,CAAC,EACD,EAAE,QAAQ,EAAE,KAAK,EAAE,CACpB,CAAC;QACF,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,aAAa,EAAE,CAAC;IACjE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,IAAI,CAAC;QACN,CAAC,gBAAgB,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;QACnD,CAAC,OAAO,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;QACzC,CAAC,OAAO,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;KAC1C,CAAC,CAAC,kBAAkB,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE;QACzD,MAAM,IAAI,GAAG,MAAM,GAAG,CACpB,CAAC,GAAG,EAAE,EAAE;YACN,GAAG,CAAC,UAAU,GAAG,MAAM,CAAC;YACxB,GAAG,CAAC,SAAS,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC;YAC3C,GAAG,CAAC,GAAG,EAAE,CAAC;QACZ,CAAC,EACD,EAAE,GAAG,EAAE,WAAW,CAAC,EAAE,iBAAiB,EAAE,MAAM,EAAE,EAAE,MAAM,CAAC,EAAE,CAC5D,CAAC;QACF,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,aAAa,EAAE,CAAC;IACjE,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,+BAA+B,EAAE,GAAG,EAAE;IAC7C,EAAE,CAAC,iDAAiD,EAAE,KAAK,IAAI,EAAE;QAC/D,MAAM,IAAI,GAAG,MAAM,GAAG,CACpB,CAAC,GAAG,EAAE,EAAE;YACN,GAAG,CAAC,UAAU,GAAG,GAAG,CAAC;YACrB,GAAG,CAAC,GAAG,EAAE,CAAC;QACZ,CAAC,EACD,EAAE,YAAY,EAAE,IAAI,EAAE,CACvB,CAAC;QACF,yEAAyE;QACzE,0DAA0D;QAC1D,kCAAkC;QAClC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAChD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,yDAAyD,EAAE,KAAK,IAAI,EAAE;QACvE,MAAM,IAAI,GAAG,MAAM,GAAG,CACpB,CAAC,GAAG,EAAE,EAAE;YACN,GAAG,CAAC,SAAS,CAAC,cAAc,EAAE,0BAA0B,CAAC,CAAC;YAC1D,GAAG,CAAC,SAAS,CAAC,gBAAgB,EAAE,MAAM,CAAC,CAAC;YACxC,GAAG,CAAC,GAAG,EAAE,CAAC;QACZ,CAAC,EACD;YACE,YAAY,EAAE,IAAI;YAClB,GAAG,EAAE,WAAW,CAAC,EAAE,iBAAiB,EAAE,MAAM,EAAE,EAAE,MAAM,CAAC;SACxD,CACF,CAAC;QACF,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC9C,4EAA4E;QAC5E,iEAAiE;QACjE,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC5D,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,+BAA+B,EAAE,KAAK,IAAI,EAAE;QAC7C,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE;YAC/C,YAAY,EAAE,IAAI;YAClB,QAAQ,EAAE,KAAK;SAChB,CAAC,CAAC;QACH,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACnD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,4DAA4D,EAAE,KAAK,IAAI,EAAE;QAC1E,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;YAC7B,GAAG,CAAC,UAAU,GAAG,GAAG,CAAC;YACrB,GAAG,CAAC,GAAG,EAAE,CAAC;QACZ,CAAC,CAAC,CAAC;QACH,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IACpC,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,sBAAsB,EAAE,GAAG,EAAE;IACpC;;;;;;OAMG;IACH,EAAE,CAAC,iEAAiE,EAAE,KAAK,IAAI,EAAE;QAC/E,MAAM,GAAG,GAAG,WAAW,CAAC,EAAE,CAAC,CAAC;QAC5B,MAAM,GAAG,GAAG,IAAI,6BAAkB,EAAE,CAAC;QACrC,MAAM,IAAI,GAAG,IAAA,iBAAU,EAAC,GAAG,EAAE,GAAG,EAAE,IAAI,cAAc,EAAE,EAAE;YACtD,QAAQ,EAAE,IAAI;SACf,CAAC,CAAC;QAEH,GAAG,CAAC,OAAO,EAAE,CAAC;QAEd,MAAM,MAAM,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,aAAa,EAAE,CAAC;IAC9C,CAAC,CAAC,CAAC;IAEH,8EAA8E;IAC9E,sEAAsE;IACtE,EAAE,CAAC,0DAA0D,EAAE,KAAK,IAAI,EAAE;QACxE,MAAM,IAAI,GAAG,MAAM,GAAG,CACpB,CAAC,GAAG,EAAE,EAAE;YACN,GAAG,CAAC,SAAS,CAAC,cAAc,EAAE,YAAY,CAAC,CAAC;YAC5C,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAClB,CAAC,EACD,EAAE,QAAQ,EAAE,KAAK,EAAE,CACpB,CAAC;QAEF,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC5C,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,kCAAkC,EAAE,KAAK,IAAI,EAAE;QAChD,MAAM,GAAG,GAAG,WAAW,CAAC,EAAE,CAAC,CAAC;QAC5B,MAAM,GAAG,GAAG,IAAI,6BAAkB,EAAE,CAAC;QACrC,MAAM,IAAI,GAAG,IAAA,iBAAU,EAAC,GAAG,EAAE,GAAG,EAAE,IAAI,cAAc,EAAE,EAAE;YACtD,QAAQ,EAAE,IAAI;SACf,CAAC,CAAC;QAEH,GAAG,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;QAE/B,MAAM,MAAM,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7C,CAAC,CAAC,CAAC;IAEH,6EAA6E;IAC7E,0EAA0E;IAC1E,qDAAqD;IACrD,EAAE,CAAC,IAAI,CAAC;QACN,CAAC,eAAe,EAAE,CAAC,GAAuB,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC/D,CAAC,YAAY,EAAE,CAAC,GAAuB,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;QACtD,CAAC,wBAAwB,EAAE,CAAC,GAAuB,EAAE,EAAE,CAAC,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;KAC5E,CAAC,CACA,2EAA2E,EAC3E,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;QACrB,MAAM,GAAG,GAAG,WAAW,CAAC,EAAE,CAAC,CAAC;QAC5B,MAAM,GAAG,GAAG,IAAI,6BAAkB,EAAE,CAAC;QACrC,MAAM,IAAI,GAAG,IAAA,iBAAU,EACrB,GAAG,EACH,GAAG,EACH;YACE,KAAK;gBACH,MAAM,IAAI,KAAK,CAAC,UAAU,CAAC,CAAC;YAC9B,CAAC;SACF,EACD,EAAE,QAAQ,EAAE,KAAK,EAAE,CACpB,CAAC;QAEF,KAAK,CAAC,GAAG,CAAC,CAAC;QAEX,MAAM,MAAM,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;QAC/C,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC,CACF,CAAC;AACJ,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,aAAa,EAAE,GAAG,EAAE;IAC3B,EAAE,CAAC,IAAI,CAAC;QACN,CAAC,MAAM,EAAE,IAAI,CAAC;QACd,CAAC,mBAAmB,EAAE,IAAI,CAAC;QAC3B,CAAC,YAAY,EAAE,IAAI,CAAC;QACpB,CAAC,UAAU,EAAE,KAAK,CAAC;QACnB,CAAC,GAAG,EAAE,IAAI,CAAC;QACX,CAAC,OAAO,EAAE,KAAK,CAAC;QAChB,uEAAuE;QACvE,CAAC,aAAa,EAAE,IAAI,CAAC;QACrB,CAAC,aAAa,EAAE,KAAK,CAAC;QACtB,CAAC,aAAa,EAAE,KAAK,CAAC;QACtB,CAAC,EAAE,EAAE,KAAK,CAAC;QACX,CAAC,SAAS,EAAE,KAAK,CAAC;KACnB,CAAC,CAAC,SAAS,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE;QACjC,MAAM,CAAC,IAAA,kBAAW,EAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC7C,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,wCAAwC,EAAE,GAAG,EAAE;QAChD,MAAM,CAAC,IAAA,kBAAW,EAAC,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACjD,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["import { Writable } from \"node:stream\";\nimport { gunzipSync } from \"node:zlib\";\nimport { ShimIncomingMessage } from \"./request\";\nimport { ResponseHead, ShimServerResponse } from \"./response\";\nimport { acceptsGzip, pipeToSink, ResponseSink } from \"./sink\";\n\nclass CollectingSink implements ResponseSink {\n  public head?: ResponseHead;\n  public readonly chunks: Buffer[] = [];\n\n  public constructor(public readonly padEmptyBody = false) {}\n\n  public begin(head: ResponseHead): Writable {\n    this.head = head;\n    const chunks = this.chunks;\n    return new Writable({\n      write(chunk, _encoding, callback) {\n        chunks.push(Buffer.from(chunk));\n        callback();\n      },\n    });\n  }\n\n  public get body(): Buffer {\n    return Buffer.concat(this.chunks);\n  }\n}\n\nfunction requestWith(\n  headers: Record<string, string>,\n  method = \"GET\",\n): ShimIncomingMessage {\n  return new ShimIncomingMessage({ method, url: \"/\", headers });\n}\n\ninterface PipeCase {\n  readonly req?: ShimIncomingMessage;\n  readonly compress?: boolean;\n  readonly padEmptyBody?: boolean;\n}\n\n/** Runs one response through the sink and resolves once the sink is finished. */\nasync function run(\n  write: (res: ShimServerResponse) => void,\n  options: PipeCase = {},\n): Promise<CollectingSink> {\n  const req = options.req ?? requestWith({ \"accept-encoding\": \"gzip\" });\n  const res = new ShimServerResponse();\n  const sink = new CollectingSink(options.padEmptyBody);\n  const done = pipeToSink(req, res, sink, {\n    compress: options.compress ?? true,\n  });\n  write(res);\n  await done;\n  return sink;\n}\n\ndescribe(\"pipeToSink compression\", () => {\n  it(\"gzips compressible content when the client accepts it\", async () => {\n    const sink = await run((res) => {\n      res.setHeader(\"Content-Type\", \"text/html; charset=utf-8\");\n      res.setHeader(\"Content-Length\", \"13\");\n      res.end(\"<p>hello</p>\");\n    });\n    expect(sink.head?.headers[\"content-encoding\"]).toBe(\"gzip\");\n    // The length we were told is the uncompressed one and the compressed one is\n    // not known until the stream ends.\n    expect(sink.head?.headers[\"content-length\"]).toBeUndefined();\n    expect(sink.head?.headers.vary).toBe(\"Accept-Encoding\");\n    expect(gunzipSync(sink.body).toString(\"utf-8\")).toBe(\"<p>hello</p>\");\n  });\n\n  it(\"appends to an existing vary rather than replacing it\", async () => {\n    const sink = await run((res) => {\n      res.setHeader(\"Content-Type\", \"text/html\");\n      res.setHeader(\"Vary\", \"Cookie\");\n      res.end(\"x\");\n    });\n    expect(sink.head?.headers.vary).toBe(\"Cookie, Accept-Encoding\");\n  });\n\n  it(\"forwards res.flush() to the compressor so streamed HTML is not buffered\", async () => {\n    const seen: number[] = [];\n    const sink = await run((res) => {\n      res.setHeader(\"Content-Type\", \"text/html\");\n      res.write(\"<html>\");\n      // Next.js does exactly this after every chunk (`pipe-readable.js`).\n      res.flush?.();\n      seen.push(1);\n      res.end(\"</html>\");\n    });\n    expect(seen).toEqual([1]);\n    expect(gunzipSync(sink.body).toString(\"utf-8\")).toBe(\"<html></html>\");\n  });\n\n  it.each([\n    [\"an incompressible content type\", { \"content-type\": \"image/avif\" }],\n    [\"an already-encoded body\", { \"content-encoding\": \"br\" }],\n    [\n      \"a response that opts out with no-transform\",\n      {\n        \"content-type\": \"text/event-stream\",\n        \"cache-control\": \"no-cache, no-transform\",\n      },\n    ],\n  ])(\"does not gzip %s\", async (_name, headers) => {\n    const sink = await run((res) => {\n      for (const [name, value] of Object.entries(headers)) {\n        res.setHeader(name, value);\n      }\n      res.end(\"body\");\n    });\n    expect(sink.head?.headers[\"content-encoding\"]).not.toBe(\"gzip\");\n    expect(sink.body.toString(\"utf-8\")).toBe(\"body\");\n  });\n\n  it(\"does not gzip a 206, whose body is a range of the stored bytes\", async () => {\n    // The one uncompressable status that carries a body. `content-range` counts\n    // bytes of the representation the client asked for, so gzipping the slice\n    // makes the range meaningless - and a client stitching ranges together\n    // (video, a resumed download) cannot use it.\n    const sink = await run((res) => {\n      res.statusCode = 206;\n      res.setHeader(\"Content-Type\", \"text/plain\");\n      res.setHeader(\"Content-Range\", \"bytes 0-3/1000\");\n      res.end(\"body\");\n    });\n    expect(sink.head?.headers[\"content-encoding\"]).toBeUndefined();\n    expect(sink.body.toString(\"utf-8\")).toBe(\"body\");\n  });\n\n  it(\"does not gzip when the client did not offer it\", async () => {\n    const sink = await run(\n      (res) => {\n        res.setHeader(\"Content-Type\", \"text/html\");\n        res.end(\"body\");\n      },\n      { req: requestWith({}) },\n    );\n    expect(sink.head?.headers[\"content-encoding\"]).toBeUndefined();\n    expect(sink.body.toString(\"utf-8\")).toBe(\"body\");\n  });\n\n  it(\"does not gzip when next.config sets compress: false\", async () => {\n    const sink = await run(\n      (res) => {\n        res.setHeader(\"Content-Type\", \"text/html\");\n        res.end(\"body\");\n      },\n      { compress: false },\n    );\n    expect(sink.head?.headers[\"content-encoding\"]).toBeUndefined();\n  });\n\n  it.each([\n    [\"a HEAD request\", { method: \"HEAD\", status: 200 }],\n    [\"a 204\", { method: \"GET\", status: 204 }],\n    [\"a 304\", { method: \"GET\", status: 304 }],\n  ])(\"does not gzip %s\", async (_name, { method, status }) => {\n    const sink = await run(\n      (res) => {\n        res.statusCode = status;\n        res.setHeader(\"Content-Type\", \"text/html\");\n        res.end();\n      },\n      { req: requestWith({ \"accept-encoding\": \"gzip\" }, method) },\n    );\n    expect(sink.head?.headers[\"content-encoding\"]).toBeUndefined();\n  });\n});\n\ndescribe(\"pipeToSink empty-body padding\", () => {\n  it(\"writes a single space when the sink asks for it\", async () => {\n    const sink = await run(\n      (res) => {\n        res.statusCode = 304;\n        res.end();\n      },\n      { padEmptyBody: true },\n    );\n    // Zero payload bytes after the prelude makes API Gateway answer 502, and\n    // makes a Function URL drop the prelude and answer a bare\n    // `200 application/octet-stream`.\n    expect(sink.body.toString(\"utf-8\")).toBe(\" \");\n  });\n\n  it(\"pads a HEAD response, whose body is empty by definition\", async () => {\n    const sink = await run(\n      (res) => {\n        res.setHeader(\"content-type\", \"text/html; charset=utf-8\");\n        res.setHeader(\"content-length\", \"5798\");\n        res.end();\n      },\n      {\n        padEmptyBody: true,\n        req: requestWith({ \"accept-encoding\": \"gzip\" }, \"HEAD\"),\n      },\n    );\n    expect(sink.body.toString(\"utf-8\")).toBe(\" \");\n    // The head still describes what a GET would return; the padding byte is not\n    // a body and the integration overwrites `content-length` with 0.\n    expect(sink.head?.headers[\"content-length\"]).toBe(\"5798\");\n  });\n\n  it(\"leaves a non-empty body alone\", async () => {\n    const sink = await run((res) => res.end(\"real\"), {\n      padEmptyBody: true,\n      compress: false,\n    });\n    expect(sink.body.toString(\"utf-8\")).toBe(\"real\");\n  });\n\n  it(\"sends nothing for an empty body when the sink does not ask\", async () => {\n    const sink = await run((res) => {\n      res.statusCode = 304;\n      res.end();\n    });\n    expect(sink.body).toHaveLength(0);\n  });\n});\n\ndescribe(\"pipeToSink lifecycle\", () => {\n  /**\n   * `handle()` awaits this promise before it flushes `waitUntil` work — ISR\n   * revalidation, cache writes — and before the request's closures can be\n   * collected. A client that disconnects before the first byte destroys the\n   * response without an error, which emits only `\"close\"`: the pipeline never\n   * started, so nothing else can settle the promise and the await never returned.\n   */\n  it(\"settles when the response is destroyed before the head goes out\", async () => {\n    const req = requestWith({});\n    const res = new ShimServerResponse();\n    const done = pipeToSink(req, res, new CollectingSink(), {\n      compress: true,\n    });\n\n    res.destroy();\n\n    await expect(done).resolves.toBeUndefined();\n  });\n\n  // The normal path has to keep settling on the pipeline, not on `\"close\"`: the\n  // body must be fully flushed into the sink by the time this resolves.\n  it(\"still settles on the pipeline once the head has gone out\", async () => {\n    const sink = await run(\n      (res) => {\n        res.setHeader(\"content-type\", \"text/plain\");\n        res.end(\"body\");\n      },\n      { compress: false },\n    );\n\n    expect(sink.body.toString()).toBe(\"body\");\n  });\n\n  it(\"rejects when the response errors\", async () => {\n    const req = requestWith({});\n    const res = new ShimServerResponse();\n    const done = pipeToSink(req, res, new CollectingSink(), {\n      compress: true,\n    });\n\n    res.destroy(new Error(\"boom\"));\n\n    await expect(done).rejects.toThrow(\"boom\");\n  });\n\n  // A sink that cannot take the head — `writeHead` rejecting a header value is\n  // the real case — throws from inside the `\"head\"` listener, where nothing\n  // else would catch it and the pipeline never starts.\n  it.each([\n    [\"writes a body\", (res: ShimServerResponse) => res.end(\"body\")],\n    [\"ends empty\", (res: ShimServerResponse) => res.end()],\n    [\"flushes its head first\", (res: ShimServerResponse) => res.writeHead(200)],\n  ])(\n    \"rejects and destroys the response when begin() throws and the response %s\",\n    async (_name, write) => {\n      const req = requestWith({});\n      const res = new ShimServerResponse();\n      const done = pipeToSink(\n        req,\n        res,\n        {\n          begin() {\n            throw new Error(\"bad head\");\n          },\n        },\n        { compress: false },\n      );\n\n      write(res);\n\n      await expect(done).rejects.toThrow(\"bad head\");\n      expect(res.destroyed).toBe(true);\n    },\n  );\n});\n\ndescribe(\"acceptsGzip\", () => {\n  it.each([\n    [\"gzip\", true],\n    [\"gzip, deflate, br\", true],\n    [\"GZIP;q=0.5\", true],\n    [\"gzip;q=0\", false],\n    [\"*\", true],\n    [\"*;q=0\", false],\n    // An explicit gzip preference wins over the wildcard, in either order.\n    [\"*;q=0, gzip\", true],\n    [\"gzip;q=0, *\", false],\n    [\"br, deflate\", false],\n    [\"\", false],\n    [undefined, false],\n  ])(\"%s → %s\", (header, expected) => {\n    expect(acceptsGzip(header)).toBe(expected);\n  });\n\n  it(\"joins a repeated header before parsing\", () => {\n    expect(acceptsGzip([\"br\", \"gzip\"])).toBe(true);\n  });\n});\n"]}

package/lib/runtime/image-utils.d.ts

@@ -0,0 +1,78 @@
+/**
+ * S3 fetching and error mapping for `/_next/image`, split out from
+ * {@link ./image.ts} so it is unit-testable without `next` present.
+ *
+ * The one value from `next` that this file needs is passed in rather than
+ * imported: `next` is external to the shell bundles, so a static `import` here
+ * would be hoisted into the bundle where it cannot resolve. `image.ts` requires
+ * it through `./next-modules` instead.
+ */
+import { S3Client } from "@aws-sdk/client-s3";
+/** Where the app is served versus where its assets were uploaded. */
+export interface S3AssetLocation {
+    /**
+     * The app's own `basePath` — the prefix of the *URL* it is served at. Only
+     * stripped from the href, never used to build a key: on the API Gateway
+     * deployment types this is the stage name, which never appears in S3.
+     */
+    readonly urlBasePath: string;
+    /**
+     * `NextjsStaticAssets.keyPrefix`: the S3 key prefix the assets were uploaded
+     * under, without a leading slash. Empty for a bucket-root deployment.
+     */
+    readonly keyPrefix: string;
+    /**
+     * The app's `assetPrefix`, when it is a path (`/cdn`). Next.js puts it in
+     * front of `/_next/` in place of `basePath`, so a statically imported image's
+     * href is `/cdn/_next/static/media/…`, and `next start` strips it again when
+     * it serves the file. An absolute `assetPrefix` makes the href absolute, which
+     * never reaches here.
+     * @default - none
+     */
+    readonly assetPrefix?: string;
+}
+/**
+ * Fetches a non-absolute (local) image referenced by an `<Image>` from S3.
+ *
+ * `url` is inconsistent about the app's `basePath`: next-image-loader bakes it
+ * into the href for statically imported images, while plain string paths are
+ * passed through as literally written by the app. So it is stripped when present,
+ * leaving a path relative to the asset root, and the bucket's own key prefix is
+ * applied to that. Deriving the key from `basePath` instead is wrong whenever the
+ * two differ, which they do for every API Gateway deployment.
+ *
+ * The key is percent-decoded, because an S3 key is the file's real name while
+ * `url` is a URL path. `public/hello world.jpg` arrives here as
+ * `/hello%20world.jpg` — the `url` query value is double-encoded, so decoding the
+ * query string leaves one layer — and its object key is `hello world.jpg`.
+ * Next.js's own `fetchInternalImage` gets the decode for free, since it makes an
+ * HTTP subrequest and its static file server resolves the path against the
+ * filesystem; skipping it here 400'd that file
+ * (`next-image-legacy/unicode`). Unicode needs nothing: `äöüščří.png` survives
+ * the query decode as itself and is already the object's name.
+ *
+ * Throws {@link ImageTooLargeError} rather than read past `maximumBody`
+ * (`images.maximumResponseBody`), which `next start` enforces on local sources
+ * too: a large `public/` file would otherwise be read into memory whole.
+ */
+export declare function fetchFromS3(s3: S3Client, bucket: string, url: string, location: S3AssetLocation, maximumBody: number): Promise<{
+    buffer: Buffer;
+    contentType: string | null;
+    etag: string;
+}>;
+/** A source over `images.maximumResponseBody`; see {@link fetchFromS3}. */
+export declare class ImageTooLargeError extends Error {
+    constructor(key: string);
+}
+/** `ImageError` from `next/dist/server/image-optimizer.js`. */
+export type ImageErrorClass = (typeof import("next/dist/server/image-optimizer.js"))["ImageError"];
+/**
+ * Maps an error thrown while processing an image request to the HTTP
+ * status/message it should produce, preserving the status Next.js's own
+ * `ImageError`/`fetchExternalImage` attach. A source over
+ * `images.maximumResponseBody` is the 413 `fetchInternalImage` answers.
+ */
+export declare function resolveErrorResponse(error: unknown, ImageError: ImageErrorClass): {
+    statusCode: number;
+    message: string;
+};