@ngrok/app-server 0.3.4 → 0.3.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (36) hide show
  1. package/README.md +2 -2
  2. package/dist/cli.js +3 -3
  3. package/dist/{compress-JuJf2HaO.js → compress-CO0Nwc8x.js} +11 -2
  4. package/dist/compress-CO0Nwc8x.js.map +1 -0
  5. package/dist/{create-server-BX2rH6-E.js → create-server-C_90R50y.js} +11 -9
  6. package/dist/{create-server-BX2rH6-E.js.map → create-server-C_90R50y.js.map} +1 -1
  7. package/dist/{entry-ChHgs269.js → entry-65IESBSA.js} +3 -3
  8. package/dist/{entry-ChHgs269.js.map → entry-65IESBSA.js.map} +1 -1
  9. package/dist/index.d.ts +1 -1
  10. package/dist/index.js +4 -4
  11. package/dist/{load-entry-BOgJPt1I.js → load-entry-svVuPIFq.js} +4 -4
  12. package/dist/{load-entry-BOgJPt1I.js.map → load-entry-svVuPIFq.js.map} +1 -1
  13. package/dist/{log-BP6xXXZl.js → log-C8LGQ23s.js} +29 -2
  14. package/dist/log-C8LGQ23s.js.map +1 -0
  15. package/dist/{node-C0Ad7CVL.js → node-Bgzhwix0.js} +2 -2
  16. package/dist/{node-C0Ad7CVL.js.map → node-Bgzhwix0.js.map} +1 -1
  17. package/dist/{node-B0AYf_IA.js → node-DFI5TjTk.js} +4 -4
  18. package/dist/{node-B0AYf_IA.js.map → node-DFI5TjTk.js.map} +1 -1
  19. package/dist/node.js +2 -2
  20. package/dist/react-router.js +1 -1
  21. package/dist/{response-edge-Bc1-C_Cx.js → response-edge-D3CAjukJ.js} +2 -2
  22. package/dist/{response-edge-Bc1-C_Cx.js.map → response-edge-D3CAjukJ.js.map} +1 -1
  23. package/dist/{response-writer-DzvUAz9x.js → response-writer-5SOKsW3C.js} +3 -3
  24. package/dist/{response-writer-DzvUAz9x.js.map → response-writer-5SOKsW3C.js.map} +1 -1
  25. package/dist/{serve-BUJ7ZonG.js → serve-DKoZxZj4.js} +2 -2
  26. package/dist/{serve-BUJ7ZonG.js.map → serve-DKoZxZj4.js.map} +1 -1
  27. package/dist/{start-DiQf9ttp.js → start-3_WlRLdK.js} +63 -8
  28. package/dist/start-3_WlRLdK.js.map +1 -0
  29. package/dist/{tcp-Bws6oEau.js → tcp-CKMCT9RP.js} +2 -2
  30. package/dist/{tcp-Bws6oEau.js.map → tcp-CKMCT9RP.js.map} +1 -1
  31. package/dist/testing.js +3 -3
  32. package/dist/vercel.js +4 -4
  33. package/package.json +1 -1
  34. package/dist/compress-JuJf2HaO.js.map +0 -1
  35. package/dist/log-BP6xXXZl.js.map +0 -1
  36. package/dist/start-DiQf9ttp.js.map +0 -1
package/README.md CHANGED
@@ -167,7 +167,7 @@ A React Router app with no Vite plugin also works: `app-server serve build/serve
167
167
 
168
168
  ## Commands
169
169
 
170
- - `app-server start`: development. Vite in middleware mode inside the pipeline, with HMR on the same port. It needs the `appServer` plugin. Each request loads the latest server entry, so an edit to a route or to `server.ts` applies at once. A Vite plugin gets the CLI's HTTP server as `server.httpServer` in its `configureServer` hook, so it can wait for `listening` and `close`. A Vite restart, such as after an edit to `vite.config.ts`, keeps that server open. So a new plugin instance gets no `listening`, and the old instance gets `close` only at exit. To clean up for each instance, use Vite's `closeServer` hook. The port is `--port`, else `PORT`, else Vite's `server.port`. When that port is in use, `start` tries each next port, unless Vite's `server.strictPort` is true. The host is `HOST`, else Vite's `server.host`. On `SIGTERM` or `SIGINT`, it stops Vite and the server, then exits.
170
+ - `app-server start`: development. Vite in middleware mode inside the pipeline, with HMR on the same port. It needs the `appServer` plugin. Each request loads the latest server entry, so an edit to a route or to `server.ts` applies at once. A Vite plugin gets the CLI's HTTP server as `server.httpServer` in its `configureServer` hook, so it can wait for `listening` and `close`. A Vite restart, such as after an edit to `vite.config.ts`, keeps that server open. So a new plugin instance gets no `listening`, and the old instance gets `close` only at exit. To clean up for each instance, use Vite's `closeServer` hook. The port is `--port`, else `PORT`, else Vite's `server.port`. When that port is in use, `start` tries each next port, unless Vite's `server.strictPort` is true. The host is `HOST`, else Vite's `server.host`. When it listens, `start` prints its URLs as `vite dev` does, through Vite's logger. Its other log lines, such as a port in use, use the text format of Go's `log/slog`, not JSON. On `SIGTERM` or `SIGINT`, it stops Vite and the server, then exits.
171
171
  - `node build/server/app-server.js`: production, with no install. Use `dist/server/app-server.js` for TanStack Start. It reads `PORT` and `HOST`, and it drains on `SIGTERM` or `SIGINT`, as `app-server serve` does. It has no `--port`. It sets `NODE_ENV` to `production` when `NODE_ENV` has no value.
172
172
  - `app-server serve [path]`: production. With no path, it runs the first of `build/server/app-server.js` (React Router), `dist/server/app-server.js` (TanStack Start), and `build/server/index.js` (a plain React Router build). The port is `--port`, else `PORT`, else 3000. The host is `HOST`, else every interface. A port in use stops startup at once. On `SIGTERM` or `SIGINT`, it drains, then exits, even when the app left a timer. A server process serves the client build that was there at start. A deploy starts a new process.
173
173
 
@@ -274,7 +274,7 @@ The function differs from a long-lived process:
274
274
  1. `health()`: the liveness and readiness probes at `/livez` and `/readyz`. A probe skips the access log. `defaultPlugins({ health })` changes them, and `false` turns them off. See [Health checks](#health-checks).
275
275
  2. `requestId()`: reuses a valid incoming `X-Request-Id`, else makes a UUID, and echoes it.
276
276
  3. `accessLog({ redactQuery })`: one line per request when the response ends, for the response that leaves the server, with Datadog standard attributes (`http.status_code`, `network.bytes_written`, `duration` in nanoseconds). Query values are `REDACTED` by default. A 5xx line has the level `error`, and each other line has the level `info`. With React Router, a line for a request that React Router answers has the route pattern that it matched as `http.route`, such as `/domains/:domainId`. A prerendered page that the server sends from its file has no `http.route`. In development, a request that Vite answers, such as a source module or `/@vite/client`, gets no line. A request of the `vercel` build's check of the CDN pages gets no line.
277
- 4. `streamingCompress()`: brotli or gzip that flushes after each chunk. A client gets brotli, at quality 4, when its `Accept-Encoding` ranks `br` at least as high as `gzip`. For HTML, brotli at quality 4 is smaller than gzip, for the same CPU time. For example, a page of 149 KiB in 10 chunks takes 0.60 ms and 7.7 KiB as brotli, and 0.68 ms and 10.6 KiB as gzip, on an Apple M3 Max. The `compression` middleware of Express also uses quality 4. Chunks that the body has queued together go out as one, up to 16 KiB, so a rendered page costs fewer flushes. When the body ends by the time the stream finishes its last chunk, that chunk and the end of the stream go out together. On the node host, a body that ends with its first chunk, up to 64 KiB, uses a zlib stream from a pool, so a small page costs no new zlib stream. Each encoding keeps up to 16 streams between responses. The gzip streams hold about 4.3 MiB in all. A gzip stream takes only such a body, and only one at least as long as each earlier body of that stream, so the gzip bytes of a body depend on that body alone. A reset gives a brotli stream a new encoder, so its bytes also depend on the body alone. On Bun and Deno, each brotli body gets a new stream, because a reset there loses the quality or gives no bytes. It skips encoded, partial, and `no-transform` responses, and a body under 1,024 bytes: by its `Content-Length`, or a body from a string. It adds `Accept-Encoding` to `Vary` only on a compressible type, the same types that get a copy from the build. A static file with a compressed copy from the build gets that copy, and this plugin skips it. It follows the `q` values of `Accept-Encoding`, and `q=0` refuses an encoding. The host gives the streams. On a host with neither, the plugin does nothing.
277
+ 4. `streamingCompress()`: brotli or gzip that flushes after each chunk. A client gets brotli, at quality 4, when its `Accept-Encoding` ranks `br` at least as high as `gzip`. For HTML, brotli at quality 4 is smaller than gzip, for the same CPU time. For example, a page of 149 KiB in 10 chunks takes 0.60 ms and 7.7 KiB as brotli, and 0.68 ms and 10.6 KiB as gzip, on an Apple M3 Max. The `compression` middleware of Express also uses quality 4. The brotli window is 256 KiB, not the default of 4 MiB. Why: Node.js tells V8 the full window of each open encoder, and under load V8 then runs a full garbage collection for every few responses. A page under 256 KiB gets the same bytes, and a page of 2.7 MB gets 5% more. Chunks that the body has queued together go out as one, up to 64 KiB, so a rendered page costs fewer flushes. For example, a rendered page of 19 KB that the body queues at once costs one zlib call, not three. When the body ends by the time the stream finishes its last chunk, that chunk and the end of the stream go out together. On the node host, a body that ends with its first chunk, up to 64 KiB, uses a zlib stream from a pool, so a small page costs no new zlib stream. Each encoding keeps up to 16 streams between responses. The gzip streams hold about 4.3 MiB in all. A gzip stream takes only such a body, and only one at least as long as each earlier body of that stream, so the gzip bytes of a body depend on that body alone. A reset gives a brotli stream a new encoder, so its bytes also depend on the body alone. On Bun and Deno, each brotli body gets a new stream, because a reset there loses the quality or gives no bytes. It skips encoded, partial, and `no-transform` responses, and a body under 1,024 bytes: by its `Content-Length`, or a body from a string. It adds `Accept-Encoding` to `Vary` only on a compressible type, the same types that get a copy from the build. A static file with a compressed copy from the build gets that copy, and this plugin skips it. It follows the `q` values of `Accept-Encoding`, and `q=0` refuses an encoding. The host gives the streams. On a host with neither, the plugin does nothing.
278
278
  5. `securityHeaders()`: safe default security headers on each response, prerendered pages included. `defaultPlugins({ securityHeaders })` changes them, and `false` turns them off. See [Security headers](#security-headers).
279
279
  6. `bodyLimit({ maxBytes })`: a 413 for a request body over `defaultPlugins({ bodyLimit })`, 10 mebibytes (MiB) by default. `false` turns it off. A `Content-Length` that is too large gets the 413 before the app runs. A streamed body errors when it passes the limit. When the app reads the body before it answers, the response becomes a 413. When the app streams the body into its response, the response stream errors. A `bodyLimit` that is not a whole number of 0 or more stops startup. The body streams. The plugin does not read it into memory.
280
280
  7. The plugins of the named options. They see every response, prerendered pages included:
package/dist/cli.js CHANGED
@@ -1,5 +1,5 @@
1
1
  #!/usr/bin/env node
2
- import { t as parsePort } from "./tcp-Bws6oEau.js";
2
+ import { t as parsePort } from "./tcp-CKMCT9RP.js";
3
3
  import process from "node:process";
4
4
  import { parseArgs } from "node:util";
5
5
 
@@ -42,12 +42,12 @@ try {
42
42
  if (args?.help === true) process.stdout.write(`${USAGE}\n`);
43
43
  else if (args?.command === "start") {
44
44
  process.env.NODE_ENV ??= "development";
45
- const { start } = await import("./start-DiQf9ttp.js");
45
+ const { start } = await import("./start-3_WlRLdK.js");
46
46
  await start();
47
47
  } else if (args?.command === "serve") {
48
48
  process.env.NODE_ENV ??= "production";
49
49
  if (typeof process.setSourceMapsEnabled === "function") process.setSourceMapsEnabled(true);
50
- const { serve } = await import("./serve-BUJ7ZonG.js");
50
+ const { serve } = await import("./serve-DKoZxZj4.js");
51
51
  await serve({ buildPath: args.buildPath });
52
52
  } else if (args != null) fail(args.command == null ? "Give a command." : `Unknown command: ${args.command}.`);
53
53
 
@@ -94,9 +94,18 @@ const DEFLATE_POOL = {
94
94
  * Express also uses 4.
95
95
  */
96
96
  const BROTLI_QUALITY = 4;
97
+ /**
98
+ * The base-2 logarithm of the brotli window, 256 KiB. Why not the default
99
+ * of 22 (4 MiB): Node.js tells V8 the full size of each encoder's ring
100
+ * buffer as external memory, and at 32 open encoders V8 then runs a full
101
+ * garbage collection for every few responses. A page under 256 KiB gets
102
+ * the same bytes, and a page of 2.7 MB gets 5% more.
103
+ */
104
+ const BROTLI_WINDOW_BITS = 18;
97
105
  const BROTLI_PARAMS = {
98
106
  [constants.BROTLI_PARAM_MODE]: constants.BROTLI_MODE_TEXT,
99
- [constants.BROTLI_PARAM_QUALITY]: BROTLI_QUALITY
107
+ [constants.BROTLI_PARAM_QUALITY]: BROTLI_QUALITY,
108
+ [constants.BROTLI_PARAM_LGWIN]: BROTLI_WINDOW_BITS
100
109
  };
101
110
  /**
102
111
  * The brotli pool. Why not sized: a reset makes a new brotli encoder with the
@@ -374,4 +383,4 @@ function brotliStream(source) {
374
383
  }
375
384
 
376
385
  export { gzipStream as n, waitsForZlib as r, brotliStream as t };
377
- //# sourceMappingURL=compress-JuJf2HaO.js.map
386
+ //# sourceMappingURL=compress-CO0Nwc8x.js.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"compress-CO0Nwc8x.js","names":[],"sources":["../src/node/compress.ts"],"sourcesContent":["import type { Transform } from \"node:stream\";\nimport {\n\tbrotliCompressSync,\n\tconstants,\n\tcrc32,\n\tcreateBrotliCompress,\n\tcreateDeflateRaw,\n\tcreateGzip,\n} from \"node:zlib\";\n\n/**\n * A stream from {@link gzipStream} or {@link brotliStream}. Why a class: the\n * node response writer reads `busy` to hold the head for zlib's first chunk,\n * and a field costs less than a `WeakMap` entry for each response.\n */\nclass ZlibBody extends ReadableStream<Uint8Array> {\n\t/** Whether the next chunk waits only on zlib, because the source gave the bytes already. */\n\tpublic busy = false;\n}\n\n/**\n * Whether the next chunk of `stream` waits only on zlib, because its source\n * gave the bytes already. It gives `undefined` for a stream that is not from\n * {@link gzipStream} or {@link brotliStream}.\n *\n * @example\n * waitsForZlib(gzipStream(source)); // => false, until the first read gives zlib a chunk\n */\nexport function waitsForZlib(stream: ReadableStream<Uint8Array>): boolean | undefined {\n\treturn stream instanceof ZlibBody ? stream.busy : undefined;\n}\n\n/**\n * The gzip header (RFC 1952): the magic number, deflate, no flags, no time,\n * and the Unix system code.\n */\nconst HEADER = Buffer.from([31, 139, 8, 0, 0, 0, 0, 0, 0, 3]);\n\n/** The gzip member of an empty body: the header, a final empty block, a CRC-32 of 0, and a size of 0. */\nconst EMPTY_MEMBER = Buffer.concat([HEADER, Buffer.from([3, 0, 0, 0, 0, 0, 0, 0, 0, 0])]);\n\n/**\n * The largest body that a pooled gzip or brotli stream compresses. Why a\n * limit: above about 64 KiB, the CRC-32 of a gzip body on the main thread\n * costs more than a new zlib stream does.\n */\nconst POOLED_MAX_BYTES = 64 * 1024;\n\n/** The most zlib streams that wait for a body in each pool. Why a limit: an idle deflate stream keeps about 276 KiB of zlib state. */\nconst MAX_IDLE = 16;\n\nfunction ignore(): void {}\n\n/**\n * A zlib stream that compresses one body at a time, the target of its output\n * and of its failure, and the size of the longest body that it compressed.\n */\ntype Pooled = {\n\tstream: Transform;\n\toutput: (chunk: Buffer) => void;\n\tfail: (error: Error) => void;\n\tsize: number;\n};\n\n/** The idle zlib streams of one encoding, the last one given back last. */\ntype Pool = {\n\t/** A new zlib stream that finishes its output with each write. */\n\tcreate: () => Transform;\n\tidle: Pooled[];\n\t/**\n\t * Whether a reset keeps state of the earlier bodies, so a stream records\n\t * the size of its longest body (see {@link take}).\n\t */\n\tsized: boolean;\n\t/** Whether a reset lets the stream compress the next body. Else each body gets a new stream. */\n\treuses: boolean;\n};\n\nfunction newPooled(pool: Pool): Pooled {\n\tconst pooled: Pooled = { stream: pool.create(), output: ignore, fail: ignore, size: 0 };\n\tpooled.stream.on(\"data\", (chunk: Buffer) => {\n\t\tpooled.output(chunk);\n\t});\n\t// Why both: zlib destroys the stream at a failure, and then it never calls the write callback.\n\tpooled.stream.on(\"error\", (error) => {\n\t\tpooled.fail(error);\n\t});\n\tpooled.stream.on(\"close\", () => {\n\t\t// Why the check: a stream that the pool destroys has no body, and an error costs its stack.\n\t\tif (pooled.fail !== ignore) {\n\t\t\tpooled.fail(new Error(\"The zlib stream closed.\"));\n\t\t}\n\t});\n\treturn pooled;\n}\n\n/**\n * The deflate pool. Why `Z_FINISH`: when the output fills the buffer of the\n * stream exactly, the stream calls zlib again, and a sync flush then adds an\n * empty block. So the output would depend on earlier bodies.\n */\nconst DEFLATE_POOL: Pool = {\n\tcreate: () => createDeflateRaw({ flush: constants.Z_FINISH }),\n\tidle: [],\n\tsized: true,\n\treuses: true,\n};\n\n/**\n * The brotli quality of a response. Why 4: for HTML, its output is smaller\n * than gzip level 6, for the same CPU time. The `compression` middleware of\n * Express also uses 4.\n */\nconst BROTLI_QUALITY = 4;\n\n/**\n * The base-2 logarithm of the brotli window, 256 KiB. Why not the default\n * of 22 (4 MiB): Node.js tells V8 the full size of each encoder's ring\n * buffer as external memory, and at 32 open encoders V8 then runs a full\n * garbage collection for every few responses. A page under 256 KiB gets\n * the same bytes, and a page of 2.7 MB gets 5% more.\n */\nconst BROTLI_WINDOW_BITS = 18;\n\nconst BROTLI_PARAMS = {\n\t[constants.BROTLI_PARAM_MODE]: constants.BROTLI_MODE_TEXT,\n\t[constants.BROTLI_PARAM_QUALITY]: BROTLI_QUALITY,\n\t[constants.BROTLI_PARAM_LGWIN]: BROTLI_WINDOW_BITS,\n};\n\n/**\n * The brotli pool. Why not sized: a reset makes a new brotli encoder with the\n * same parameters, so the output of a body never depends on an earlier one.\n */\nconst BROTLI_POOL: Pool = {\n\tcreate: () =>\n\t\tcreateBrotliCompress({ flush: constants.BROTLI_OPERATION_FINISH, params: BROTLI_PARAMS }),\n\tidle: [],\n\tsized: false,\n\t// Why not on Bun or Deno: after a reset, a Bun encoder forgets its quality, and a Deno encoder gives no bytes.\n\treuses: !(\"Bun\" in globalThis) && !(\"Deno\" in globalThis),\n};\n\n/**\n * An idle stream of `pool` for a body of `size` bytes, else a new one. It\n * takes a stream whose bodies were each no longer than this one: the longest\n * such, and of those the last one given back, whose memory is still in the\n * cache.\n *\n * Why for deflate: a reset keeps the window of zlib, and zlib reads the bytes\n * after the end of a body to hash and match its last bytes. After a longer\n * body, these are bytes of that body, so they could change the output of this\n * one. A stream whose bodies were no longer has only the zeros that zlib\n * writes after each body there, as a new stream does.\n */\nfunction take(pool: Pool, size: number): Pooled {\n\tconst { idle } = pool;\n\tlet best = -1;\n\tlet bestSize = -1;\n\tfor (let index = idle.length - 1; index >= 0; index -= 1) {\n\t\tconst each = idle[index]?.size ?? Infinity;\n\t\tif (each <= size && each > bestSize) {\n\t\t\tbest = index;\n\t\t\tbestSize = each;\n\t\t}\n\t}\n\tif (best === -1) {\n\t\treturn newPooled(pool);\n\t}\n\tconst taken = idle[best];\n\tconst last = idle.pop();\n\tif (taken == null || last == null) {\n\t\treturn newPooled(pool);\n\t}\n\t// Why move the last one into the gap: the order of the others does not matter, and it costs no copy.\n\tif (last !== taken) {\n\t\tidle[best] = last;\n\t}\n\treturn taken;\n}\n\n/**\n * Gives back a stream of `pool` after its body. Why reset: the next body must\n * not use the bytes of this one as a dictionary. When the pool is full, it\n * keeps the streams of the shortest bodies, which more bodies can take.\n */\nfunction release(pool: Pool, pooled: Pooled): void {\n\tpooled.output = ignore;\n\tpooled.fail = ignore;\n\tconst { stream } = pooled;\n\t// Why check the queues: a stream with output or input still queued would give it to the next body.\n\tif (\n\t\t!pool.reuses ||\n\t\tstream.destroyed ||\n\t\tstream.readableLength !== 0 ||\n\t\tstream.writableLength !== 0\n\t) {\n\t\tstream.destroy();\n\t\treturn;\n\t}\n\t// oxlint-disable-next-line typescript/no-unsafe-type-assertion -- each pool creates a zlib stream, which has `reset`.\n\t(stream as Transform & { reset: () => void }).reset();\n\t// Why the check: a reset that fails destroys the stream.\n\tif (stream.destroyed) {\n\t\treturn;\n\t}\n\tconst { idle } = pool;\n\tif (idle.length < MAX_IDLE) {\n\t\tidle.push(pooled);\n\t\treturn;\n\t}\n\tlet longest = 0;\n\tfor (let index = 1; index < idle.length; index += 1) {\n\t\tif ((idle[index]?.size ?? 0) > (idle[longest]?.size ?? 0)) {\n\t\t\tlongest = index;\n\t\t}\n\t}\n\tconst evicted = idle[longest];\n\tif (evicted != null && evicted.size > pooled.size) {\n\t\tidle[longest] = pooled;\n\t\tevicted.stream.destroy();\n\t} else {\n\t\tstream.destroy();\n\t}\n}\n\n/** Writes `chunk` to `stream`. zlib gives all the output of the chunk before this resolves. */\nasync function write(stream: Transform, chunk: Uint8Array): Promise<void> {\n\treturn new Promise((resolve, reject) => {\n\t\tstream.write(chunk, (error) => {\n\t\t\tif (error == null) {\n\t\t\t\tresolve();\n\t\t\t} else {\n\t\t\t\treject(error);\n\t\t\t}\n\t\t});\n\t});\n}\n\n/**\n * The output of a stream of `pool` for a body of one chunk, in one zlib call.\n * `use` gets the stream while zlib compresses, so a cancel can destroy it,\n * and gets `undefined` before the stream goes back to the pool. Why only a\n * body of one chunk: a deflate reset keeps the old window, and a second write\n * reads its bytes as history. The output of one write is the same as from a\n * new stream, so it does not depend on an earlier body.\n */\nasync function compressOnce(\n\tpool: Pool,\n\tvalue: Uint8Array,\n\tuse: (pooled: Pooled | undefined) => void,\n): Promise<Buffer[]> {\n\tconst pooled = take(pool, value.byteLength);\n\tuse(pooled);\n\tconst parts: Buffer[] = [];\n\tpooled.output = (chunk) => {\n\t\tparts.push(chunk);\n\t};\n\ttry {\n\t\tawait new Promise<void>((resolve, reject) => {\n\t\t\tpooled.fail = reject;\n\t\t\tpooled.stream.write(value, (error) => {\n\t\t\t\tif (error != null) {\n\t\t\t\t\treject(error);\n\t\t\t\t} else if (pooled.stream.destroyed) {\n\t\t\t\t\treject(new Error(\"The zlib stream closed.\"));\n\t\t\t\t} else {\n\t\t\t\t\tresolve();\n\t\t\t\t}\n\t\t\t});\n\t\t});\n\t} catch (error) {\n\t\tpooled.output = ignore;\n\t\tpooled.fail = ignore;\n\t\tpooled.stream.destroy();\n\t\tthrow error;\n\t}\n\tif (pool.sized) {\n\t\tpooled.size = Math.max(pooled.size, value.byteLength);\n\t}\n\t// Why first: a cancel after this must not destroy a stream that the pool gives to another body.\n\tuse(undefined);\n\trelease(pool, pooled);\n\treturn parts;\n}\n\n/**\n * The gzip member of a body of one chunk: the raw deflate output of a pooled\n * stream, with the header and the trailer written here.\n */\nasync function gzipOnce(\n\tvalue: Uint8Array,\n\tuse: (pooled: Pooled | undefined) => void,\n): Promise<Buffer> {\n\tconst parts = await compressOnce(DEFLATE_POOL, value, use);\n\tconst trailer = Buffer.allocUnsafe(8);\n\ttrailer.writeUInt32LE(crc32(value), 0);\n\ttrailer.writeUInt32LE(value.byteLength, 4);\n\treturn Buffer.concat([HEADER, ...parts, trailer]);\n}\n\n/** The brotli stream of a body of one chunk, from a pooled encoder. */\nasync function brotliOnce(\n\tvalue: Uint8Array,\n\tuse: (pooled: Pooled | undefined) => void,\n): Promise<Buffer> {\n\treturn Buffer.concat(await compressOnce(BROTLI_POOL, value, use));\n}\n\n/** How {@link zlibStream} compresses a body. */\ntype Codec = {\n\t/** A new zlib stream that flushes after each write. */\n\tcreate: () => Transform;\n\t/** The output for a body with no bytes. */\n\tempty: Buffer;\n\t/**\n\t * The output for a body of one chunk, up to 64 KiB, with no new zlib\n\t * stream. `use` gets the zlib stream while it compresses.\n\t */\n\tonce: (value: Uint8Array, use: (pooled: Pooled | undefined) => void) => Promise<Buffer>;\n};\n\n/**\n * Compresses a byte stream with `codec`. Each written chunk is readable at\n * once. It reads the next source chunk only when the consumer pulls, so a\n * slow client holds back the source. When the source ends by the time zlib\n * finishes a chunk, that chunk and the end of the stream go out as one. Why:\n * the host writes each chunk to the socket on its own, and a write costs more\n * than its few bytes.\n */\nfunction zlibStream(source: ReadableStream<Uint8Array>, codec: Codec): ReadableStream<Uint8Array> {\n\tconst reader = source.getReader();\n\tlet ended = false;\n\tconst markEnded = () => {\n\t\tended = true;\n\t};\n\t// Why a flag: after each zlib write, it tells with no read whether the source ended meanwhile.\n\tvoid reader.closed.then(markEnded, () => {});\n\t/** The zlib stream of a body of more than one chunk. */\n\tlet zlib: Transform | undefined;\n\t/** The pooled zlib stream while it compresses the one chunk of a body. */\n\tlet pooled: Pooled | undefined;\n\tlet started = false;\n\t/** The zlib output that waits for the next enqueue. */\n\tlet held: Buffer[] = [];\n\tlet heldBytes = 0;\n\tconst enqueueHeld = (controller: ReadableStreamDefaultController<Uint8Array>) => {\n\t\tconst [first] = held;\n\t\tif (first == null) {\n\t\t\treturn;\n\t\t}\n\t\t// Why no copy for one chunk: zlib gives each chunk its own bytes, and it never writes them again.\n\t\tcontroller.enqueue(held.length === 1 ? first : Buffer.concat(held));\n\t\theld = [];\n\t\theldBytes = 0;\n\t};\n\tconst startZlib = (\n\t\tbody: ZlibBody,\n\t\tcontroller: ReadableStreamDefaultController<Uint8Array>,\n\t): Transform => {\n\t\tconst created = codec.create();\n\t\tcreated.on(\"data\", (chunk: Buffer) => {\n\t\t\theld.push(chunk);\n\t\t\theldBytes += chunk.byteLength;\n\t\t\t// Why: the output of a large source chunk goes out while zlib still compresses the rest.\n\t\t\tif (heldBytes >= constants.Z_DEFAULT_CHUNK) {\n\t\t\t\tenqueueHeld(controller);\n\t\t\t}\n\t\t});\n\t\tcreated.on(\"end\", () => {\n\t\t\tbody.busy = false;\n\t\t\tenqueueHeld(controller);\n\t\t\tcontroller.close();\n\t\t});\n\t\tcreated.on(\"error\", (error) => {\n\t\t\tbody.busy = false;\n\t\t\tcontroller.error(error);\n\t\t});\n\t\treturn created;\n\t};\n\tconst stream: ZlibBody = new ZlibBody(\n\t\t{\n\t\t\tasync pull(controller) {\n\t\t\t\ttry {\n\t\t\t\t\tlet chunk = await reader.read();\n\t\t\t\t\t// Why skip empty chunks: zlib writes nothing for one, and a pull that enqueues nothing\n\t\t\t\t\t// is not called again.\n\t\t\t\t\twhile (!chunk.done && chunk.value.byteLength === 0) {\n\t\t\t\t\t\tchunk = await reader.read();\n\t\t\t\t\t}\n\t\t\t\t\tif (!started) {\n\t\t\t\t\t\tstarted = true;\n\t\t\t\t\t\tif (chunk.done) {\n\t\t\t\t\t\t\tcontroller.enqueue(codec.empty);\n\t\t\t\t\t\t\tcontroller.close();\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tstream.busy = true;\n\t\t\t\t\t\t// Why wait: a source that closes in the pull that gave this chunk ends one microtask later.\n\t\t\t\t\t\tawait Promise.resolve();\n\t\t\t\t\t\tif (ended && chunk.value.byteLength <= POOLED_MAX_BYTES) {\n\t\t\t\t\t\t\tconst output = await codec.once(chunk.value, (each) => {\n\t\t\t\t\t\t\t\tpooled = each;\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\tstream.busy = false;\n\t\t\t\t\t\t\tcontroller.enqueue(output);\n\t\t\t\t\t\t\tcontroller.close();\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tzlib ??= startZlib(stream, controller);\n\t\t\t\t\tstream.busy = true;\n\t\t\t\t\tif (chunk.done) {\n\t\t\t\t\t\tzlib.end();\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tawait write(zlib, chunk.value);\n\t\t\t\t\tif (ended) {\n\t\t\t\t\t\tzlib.end();\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tstream.busy = false;\n\t\t\t\t\t// Why the output is here: zlib emits the output of a chunk before it calls the write\n\t\t\t\t\t// callback, so this pull enqueues a chunk and the consumer's read does not wait.\n\t\t\t\t\tenqueueHeld(controller);\n\t\t\t\t} catch (error) {\n\t\t\t\t\tstream.busy = false;\n\t\t\t\t\tzlib?.destroy();\n\t\t\t\t\tthrow error;\n\t\t\t\t}\n\t\t\t},\n\t\t\t// Why cancel the source: a client disconnect must reach the handler, so it stops its work.\n\t\t\tasync cancel(reason) {\n\t\t\t\tzlib?.destroy();\n\t\t\t\t// Why destroy: a stream that a write still uses must never go back to the pool.\n\t\t\t\tpooled?.stream.destroy();\n\t\t\t\treturn reader.cancel(reason);\n\t\t\t},\n\t\t},\n\t\t// Why 0: the stream reads its source only when the consumer reads.\n\t\t{ highWaterMark: 0 },\n\t);\n\treturn stream;\n}\n\nconst GZIP: Codec = {\n\tcreate: () => createGzip({ flush: constants.Z_SYNC_FLUSH }),\n\tempty: EMPTY_MEMBER,\n\tonce: gzipOnce,\n};\n\n/**\n * Gzips a byte stream. `Z_SYNC_FLUSH` makes each written chunk readable at\n * once. It reads the next source chunk only when the consumer pulls, so a slow\n * client holds back the source. When the source ends by the time zlib\n * finishes a chunk, that chunk and the gzip trailer go out as one.\n *\n * A body that ends with its first chunk, up to 64 KiB, takes a pooled raw\n * deflate stream. Why: a new zlib stream costs more main-thread time than\n * zlib takes for a small page.\n *\n * @example\n * new Response(gzipStream(response.body), response);\n */\nexport function gzipStream(source: ReadableStream<Uint8Array>): ReadableStream<Uint8Array> {\n\treturn zlibStream(source, GZIP);\n}\n\nconst BROTLI: Codec = {\n\tcreate: () =>\n\t\tcreateBrotliCompress({ flush: constants.BROTLI_OPERATION_FLUSH, params: BROTLI_PARAMS }),\n\tempty: brotliCompressSync(new Uint8Array(), { params: BROTLI_PARAMS }),\n\tonce: brotliOnce,\n};\n\n/**\n * Compresses a byte stream with brotli, quality 4. `BROTLI_OPERATION_FLUSH`\n * makes each written chunk readable at once. It reads and ends as\n * {@link gzipStream} does, and a body that ends with its first chunk, up to\n * 64 KiB, also takes a pooled encoder.\n *\n * @example\n * new Response(brotliStream(response.body), response);\n */\nexport function brotliStream(source: ReadableStream<Uint8Array>): ReadableStream<Uint8Array> {\n\treturn zlibStream(source, BROTLI);\n}\n"],"mappings":"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"}
@@ -1,8 +1,8 @@
1
1
  import { r as withRequestContext } from "./request-context-BtQ87VYb.js";
2
2
  import { a as replaceResponse, o as withHeaderHook, r as hookedHeaders, s as writableHeaders } from "./header-hook-Vzw9J9BY.js";
3
3
  import { c as presenceHeaders, l as presenceHeadersOf, o as checkOptionPlugins, r as buildId, s as optionPlugin } from "./build-id-B0448vZH.js";
4
- import { i as requestLogger, r as jsonSink, t as errorAttributes } from "./log-BP6xXXZl.js";
5
- import { n as finishResponse, r as onResponseSent } from "./response-edge-Bc1-C_Cx.js";
4
+ import { i as requestLogger, r as jsonSink, t as errorAttributes } from "./log-C8LGQ23s.js";
5
+ import { n as finishResponse, r as onResponseSent } from "./response-edge-D3CAjukJ.js";
6
6
  import { r as manifestKey } from "./build-manifest-DBMWe3Lx.js";
7
7
  import { a as isCompressible, i as forbidsTransform, n as MIN_COMPRESS_BYTES, o as preferredEncoding, s as readIfQueued } from "./compression-CT2mWlKM.js";
8
8
  import { i as isFilePath$1, n as findStaticFile, o as staticResponse, s as withVary, t as contentType } from "./static-files-C2ea8KQ6.js";
@@ -1048,11 +1048,13 @@ function requestId({ headerName = "X-Request-Id", datadogTraceIds = false } = {}
1048
1048
 
1049
1049
  // src/core/plugins/streaming-compress.ts
1050
1050
  /**
1051
- * The most bytes that one pull of {@link replay} joins. Why 16 KiB: a source
1051
+ * The most bytes that one pull of {@link replay} joins. Why 64 KiB: each
1052
+ * zlib write costs a trip to the thread pool, and the node host compresses a
1053
+ * body of one chunk up to 64 KiB with a pooled stream in one trip. A source
1052
1054
  * that makes a chunk on each read looks queued, so the join can read ahead of
1053
- * the client by this size, the default read-ahead of a Node.js stream.
1055
+ * the client by this size.
1054
1056
  */
1055
- const MAX_JOINED_BYTES = 16384;
1057
+ const MAX_JOINED_BYTES = 65536;
1056
1058
  /**
1057
1059
  * Reads at most two chunks that `reader` has queued, and never waits for
1058
1060
  * more. Why two: a body from a string or a buffer queues its bytes and its
@@ -1109,7 +1111,7 @@ function replay(reader, queued) {
1109
1111
  async pull(controller) {
1110
1112
  const parts = [];
1111
1113
  let size = 0;
1112
- const fits = (chunk) => parts.length === 0 || size + chunk.byteLength <= 16384;
1114
+ const fits = (chunk) => parts.length === 0 || size + chunk.byteLength <= 65536;
1113
1115
  for (let [chunk] = chunks; chunk != null && fits(chunk); [chunk] = chunks) {
1114
1116
  chunks.shift();
1115
1117
  parts.push(chunk);
@@ -1125,7 +1127,7 @@ function replay(reader, queued) {
1125
1127
  parts.push(result.value);
1126
1128
  size = result.value.byteLength;
1127
1129
  }
1128
- while (chunks.length === 0 && pending == null && !done && size < 16384) {
1130
+ while (chunks.length === 0 && pending == null && !done && size < 65536) {
1129
1131
  const next = await readIfQueued(reader);
1130
1132
  if ("pending" in next) ({pending} = next);
1131
1133
  else if (next.result.done) done = true;
@@ -1158,7 +1160,7 @@ function compressed(response, body, { encoding, hasLength }) {
1158
1160
  * chunk, so a streamed page shell or a server-sent event reaches the client
1159
1161
  * at once. A client gets brotli when its `Accept-Encoding` ranks `br` at
1160
1162
  * least as high as `gzip`. Chunks that the body has queued together are one
1161
- * chunk, up to 16 KiB. `hono/compress` holds a stream until it ends. Skips a
1163
+ * chunk, up to 64 KiB. `hono/compress` holds a stream until it ends. Skips a
1162
1164
  * response that is already encoded, a partial response, one marked
1163
1165
  * `no-transform`, and one whose `Content-Length` is under 1 KiB. It adds
1164
1166
  * `Accept-Encoding` to the `Vary` of each response that it can compress. The
@@ -1485,4 +1487,4 @@ function serverInternals(app) {
1485
1487
  }
1486
1488
 
1487
1489
  export { assets as _, streamingCompress as a, prefersMarkdown as b, securityHeaders as c, noindex as d, health as f, accessLog as g, bodyLimit as h, withForwardedProto as i, redirects as l, shutdownSignal as m, defaultPlugins as n, requestId as o, abortShutdownSignal as p, serverInternals as r, contentSecurityPolicy as s, createServer as t, privateDocuments as u, prerendered as v, trailingSlash as y };
1488
- //# sourceMappingURL=create-server-BX2rH6-E.js.map
1490
+ //# sourceMappingURL=create-server-C_90R50y.js.map