@stacksjs/bun-router 0.0.24 → 0.0.26

package/dist/cli.js

@@ -2047,7 +2047,7 @@ function getPrefix() {
 }
 var prefix = getPrefix();
 // package.json
-var version = "0.0.24";
+var version = "0.0.26";
 
 // src/cli/middleware.ts
 import fs2 from "fs/promises";

package/dist/index.js

@@ -2057,6 +2057,8 @@ function isCompressible(contentType) {
   if (!contentType)
     return false;
   const type = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+  if (type === "text/event-stream")
+    return false;
   if (type.startsWith("text/"))
     return true;
   return [
@@ -2099,10 +2101,10 @@ function shouldCompress(response, encoding, threshold) {
     return false;
   if (!isCompressible(response.headers.get("content-type")))
     return false;
-  const length = Number(response.headers.get("content-length") ?? Number.NaN);
-  if (!Number.isFinite(length))
+  if (!response.body)
     return false;
-  return length >= threshold;
+  const length = Number(response.headers.get("content-length") ?? Number.NaN);
+  return Number.isFinite(length) ? length >= threshold : true;
 }
 async function compressResponse(response, request2, options = {}) {
   const settings = { ...DEFAULT_COMPRESSION, ...options };
@@ -2114,19 +2116,61 @@ async function compressResponse(response, request2, options = {}) {
       appendVary(response.headers, "Accept-Encoding");
     return response;
   }
-  const body = new Uint8Array(await response.arrayBuffer());
-  const compressed = encoding === "gzip" ? Bun.gzipSync(body, { level: settings.level }) : Bun.deflateSync(body, { level: settings.level });
-  if (compressed.byteLength >= body.byteLength) {
+  const known = Number(response.headers.get("content-length") ?? Number.NaN);
+  const body = Number.isFinite(known) ? { stream: response.body, size: known, ended: false } : await peekBody(response.body, settings.threshold);
+  if (body.ended && body.size < settings.threshold) {
     const headers2 = new Headers(response.headers);
     appendVary(headers2, "Accept-Encoding");
-    return new Response(body, { status: response.status, statusText: response.statusText, headers: headers2 });
+    return new Response(body.stream, { status: response.status, statusText: response.statusText, headers: headers2 });
   }
   const headers = new Headers(response.headers);
   headers.set("Content-Encoding", encoding);
-  headers.set("Content-Length", String(compressed.byteLength));
   appendVary(headers, "Accept-Encoding");
+  headers.delete("Content-Length");
+  const compressed = body.stream.pipeThrough(new CompressionStream(encoding === "gzip" ? "gzip" : "deflate"));
   return new Response(compressed, { status: response.status, statusText: response.statusText, headers });
 }
+async function peekBody(source, limit) {
+  const reader = source.getReader();
+  const prefix = [];
+  let size = 0;
+  let ended = false;
+  while (size < limit) {
+    const { value, done } = await reader.read();
+    if (done) {
+      ended = true;
+      break;
+    }
+    if (value) {
+      prefix.push(value);
+      size += value.byteLength;
+    }
+  }
+  const stream = new ReadableStream({
+    start(controller) {
+      for (const chunk of prefix)
+        controller.enqueue(chunk);
+      if (ended)
+        controller.close();
+    },
+    async pull(controller) {
+      if (ended)
+        return;
+      const { value, done } = await reader.read();
+      if (done) {
+        ended = true;
+        controller.close();
+        return;
+      }
+      if (value)
+        controller.enqueue(value);
+    },
+    cancel(reason) {
+      return reader.cancel(reason);
+    }
+  });
+  return { stream, size, ended };
+}
 function appendVary(headers, value) {
   const existing = headers.get("vary");
   if (!existing) {
@@ -13785,6 +13829,7 @@ export {
   performanceDashboard,
   performanceAssertions,
   performanceAlerting,
+  peekBody,
   parseThrottleString,
   oauth2Auth,
   normalizePath,

package/dist/response/compression.d.ts

@@ -7,25 +7,39 @@
  * HTML and compresses to about a tenth of that, on every request, for every
  * visitor - and the same is true of any JSON list long enough to matter.
  *
- * Three rules, and the middle one is the important one:
+ * Three rules:
  *
  * - **Only when the client asked.** `Accept-Encoding` decides, and `Vary` says
  *   so, because a cache that hands a gzipped body to a client that did not ask
  *   is a cache that breaks that client.
- * - **Only when the length is known.** A response with no `Content-Length` is a
- *   stream, and buffering one to compress it would turn a progressive render
- *   into a wait - the diff manifest that streams a hundred files as they parse
- *   would arrive all at once, at the end. Streams are left alone.
  * - **Only when it is worth it.** Below a kilobyte the header costs more than
  *   the saving, and already-compressed bytes (an image, a woff2, a zip) get
  *   bigger rather than smaller.
+ * - **Never by buffering.** The body is piped through a `CompressionStream`
+ *   rather than read into memory, so a response that streams keeps streaming:
+ *   the diff manifest that sends a hundred files as they parse still arrives a
+ *   file at a time, compressed. Buffering to compress would have turned this
+ *   product's progressive render into a wait, which is a worse trade than the
+ *   bytes are worth.
+ *
+ * A piped body has no length until it ends, so `Content-Length` comes off and
+ * the response goes out chunked. That is the ordinary shape for a compressed
+ * response and every client handles it; a browser showing a page as it arrives
+ * is not waiting for a number.
  */
 /** zlib's own range, so a level Bun would reject is a type error rather than a throw. */
 export type CompressionLevel = -1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
 export interface CompressionOptions {
     /** Off turns the whole thing off, for a proxy that already compresses. */
     enabled?: boolean;
-    /** zlib level. 6 is the usual balance; 9 costs noticeably more CPU for a few percent. */
+    /**
+     * Kept for callers that set it, and unused by the stream path.
+     *
+     * `CompressionStream` has no level knob - it is the platform's, at its own
+     * default - and piping is what keeps a streamed response streaming. A level
+     * would mean going back to buffering, which is the trade this deliberately
+     * does not make.
+     */
     level?: CompressionLevel;
     /** Bodies below this many bytes are sent as they are. */
     threshold?: number;
@@ -53,7 +67,16 @@ export declare function isCompressible(contentType: string | null): boolean;
  * response path is a different change from this one.
  */
 export declare function negotiateEncoding(header: string | null): 'gzip' | 'deflate' | null;
-/** Whether this response should be compressed at all, and why not when it should not. */
+/**
+ * Whether this response should be compressed at all.
+ *
+ * `Content-Length` is a *hint here rather than a requirement*: Bun does not put
+ * one on a `Response` built from a string, so treating its absence as "this is
+ * a stream, leave it alone" left every server-rendered page uncompressed - the
+ * exact case this exists for. When there is a length, it decides against
+ * bodies too small to be worth it; when there is not, the body is piped and
+ * the threshold cannot apply.
+ */
 export declare function shouldCompress(response: Response, encoding: string | null, threshold: number): boolean;
 /**
  * The response, compressed when that is the right thing to do.
@@ -62,5 +85,18 @@ export declare function shouldCompress(response: Response, encoding: string | nu
  * unconditionally at the end of the pipeline.
  */
 export declare function compressResponse(response: Response, request: Request, options?: CompressionOptions): Promise<Response>;
+/**
+ * Read up to `limit` bytes, and hand back a stream that still has them.
+ *
+ * The prefix is re-emitted before the rest of the source, so nothing is lost
+ * and nothing is held beyond the limit. `ended` says the body finished inside
+ * the prefix, which is what makes a small answer distinguishable from the
+ * beginning of a large one.
+ */
+export declare function peekBody(source: ReadableStream<Uint8Array>, limit: number): Promise<{
+    stream: ReadableStream<Uint8Array>;
+    size: number;
+    ended: boolean;
+}>;
 /** Add to `Vary` without dropping what is already there. */
 export declare function appendVary(headers: Headers, value: string): void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/bun-router",
   "type": "module",
-  "version": "0.0.24",
+  "version": "0.0.26",
   "description": "A fast, type-safe router for Bun.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",