@sproutboat/runtime 0.17.1 → 0.19.0

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @sproutboat/runtime
 
+## 0.19.0
+
+### Minor Changes
+
+- 4274bef: `Response.body` and `Request.body` are `ReadableStream`s for every body type, as in the Fetch spec and workerd. Before, they held the value given (a string, bytes or a `Blob`). `res.body.getReader()`, `res.body.pipeThrough(...)` and `new Response(other.body)` now work on any response, including the incoming request. The value as given stays internal, so responses are still written with a fixed length unless the body really is a stream. A body whose stream has been locked can no longer be read with `text()` and the other readers, which throw a `TypeError`.
+
+## 0.18.0
+
+### Minor Changes
+
+- 145e3dc: `HTMLRewriter`, matching Cloudflare's API and lol-html's output.
+  
+  - **Handlers:** `on(selector, { element, text, comments })` and `onDocument({ doctype, text, comments, end })`.
+  - **Element methods:** attributes, `tagName`, `before`/`after`/`prepend`/`append`/`replace`/`setInnerContent` with `{ html }`, `remove`, `removeAndKeepContent` and `onEndTag`.
+  - **Selectors:** type, `*`, `#id`, `.class`, the attribute operators, descendant and child combinators, and lists.
+  - **Async:** handlers may be async.
+  
+  It reads the whole body before rewriting rather than streaming it. 37 cases are checked against Bun's lol-html-based HTMLRewriter, including where lol-html keeps attributes byte for byte and does not imply end tags.
+- 2541458: More of the Web platform, from sproutd's W2 conformance suite against workerd:
+  
+  - `CompressionStream` and `DecompressionStream` for `gzip`, `deflate` and `deflate-raw`, in JavaScript, because the native runtime links no zlib. Output decompresses with zlib, and zlib's output (stored, fixed and dynamic blocks) decompresses here. A corrupt or truncated input errors with a `TypeError`.
+  - A `Response` or `Request` whose body is a `ReadableStream` is read to the end by `text()`, `json()`, `arrayBuffer()` and `blob()`. Before, these returned `"[object ReadableStream]"`. Chunks must be bytes, as in workerd.
+  - `JSON.parse` applies its reviver: children first, `undefined` deletes the property, and `this` is the holder.
+
+### Patch Changes
+
+- 116ee47: sproutd builds the runtime again. In split builds Porffor cannot type a prelude function's parameters, and the compression checksums' `let c = ~crc` compiled to C that assigned a boxed value to a number. The checksums now start from the parameter itself.
+
 ## 0.17.1
 
 ### Patch Changes

package/WEB_STREAMS.md

@@ -14,8 +14,14 @@ the status and headers go out at once and each chunk is written as it is produce
 (chunked encoding), so Server-Sent Events and long responses work. Chunks must be bytes.
 Hosts that do not stream yet (sproutd's workers) read the stream to the end and send it
 buffered, at most 32 MiB. Request bodies and outbound fetch remain buffered.
-TextEncoderStream and TextDecoderStream are included; CompressionStream and
-DecompressionStream are not.
+TextEncoderStream and TextDecoderStream are included, and CompressionStream and
+DecompressionStream ("gzip", "deflate", "deflate-raw") in JavaScript, since the native
+runtime links no zlib. Compression writes one fixed-Huffman block per chunk as it arrives
+(close to zlib on text: 252 bytes against 221 for 22.5 KB); decompression inflates all
+block types once the input ends and checks the CRC-32 or Adler-32. Response and Request
+bodies that are ReadableStreams are read by text(), json(), arrayBuffer() and blob(), and
+their chunks must be bytes, as in workerd. `body` is a ReadableStream for every body type,
+as in Fetch: a stream body itself, otherwise a stream made once over the bytes.
 BYOB buffer detachment requires transfer support from the underlying engine;
 the polyfill cannot supply that engine primitive. Full Web Platform Tests
 conformance has not been established for Porffor.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/runtime",
-  "version": "0.17.1",
+  "version": "0.19.0",
   "license": "MIT",
   "type": "module",
   "repository": {

package/src/ingress-utf8.test.js

@@ -6,9 +6,10 @@ const ingress = src.slice(
   src.indexOf("function __sbDecodeIngress("),
   src.indexOf("globalThis.__sbEntry ="),
 );
-if (!decoder || !ingress) throw new Error("Ingress decoder source not found");
+const rawBody = src.slice(src.indexOf("function __sbRawBody("), src.indexOf("function __sbHasStreamBody("));
+if (!decoder || !ingress || !rawBody) throw new Error("Ingress decoder source not found");
 // oxlint-disable-next-line no-function-constructor -- Exercise the text-only runtime prelude.
-const load = new Function(`${decoder}\n${ingress}\nreturn __sbDecodeIngress;`);
+const load = new Function(`${decoder}\n${rawBody}\n${ingress}\nreturn __sbDecodeIngress;`);
 const decode = load();
 const raw = (text) =>
   Array.from(new TextEncoder().encode(text), (byte) => String.fromCharCode(byte)).join("");

package/src/native-fetch-prelude.js

@@ -2305,6 +2305,706 @@
 /* oxlint-enable */
 // END WEB STREAMS
 
+// COMPRESSION STREAMS: CompressionStream and DecompressionStream ("gzip", "deflate",
+// "deflate-raw"), in JavaScript: the native runtime links no zlib. Compression is LZ77 with
+// fixed Huffman codes, one block per written chunk, so output follows input as it arrives;
+// it is smaller than the input for text, not as small as zlib's. Decompression inflates
+// stored, fixed and dynamic blocks once the input ends, and checks the CRC-32 or Adler-32.
+// A malformed or truncated stream errors with a TypeError, as in workerd.
+
+const __sbCrcTable = (() => {
+  const table = new Int32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    table[n] = c;
+  }
+  return table;
+})();
+// c starts as the parameter itself. In split builds (sproutd) a prelude function may be
+// called from app code, so Porffor cannot type its parameters; it typed c as a number
+// from the loop but boxed ~crc (crc might be a BigInt), and the C did not compile.
+function __sbCrc32(crc, bytes) {
+  let c = crc;
+  c = ~c;
+  for (let i = 0; i < bytes.length; i++) c = __sbCrcTable[(c ^ bytes[i]) & 255] ^ (c >>> 8);
+  return ~c >>> 0;
+}
+function __sbAdler32(adler, bytes) {
+  let a = adler, b = adler;
+  a = a & 0xffff;
+  b = b >>> 16;
+  for (let i = 0; i < bytes.length; ) {
+    const end = Math.min(i + 3800, bytes.length);
+    for (; i < end; i++) { a += bytes[i]; b += a; }
+    a %= 65521; b %= 65521;
+  }
+  return ((b << 16) | a) >>> 0;
+}
+
+// Length and distance codes (RFC 1951 3.2.5).
+const __sbLenBase = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258];
+const __sbLenExtra = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0];
+const __sbDistBase = [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577];
+const __sbDistExtra = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13];
+
+class __sbBitWriter {
+  constructor() { this.out = new Uint8Array(1024); this.length = 0; this.bits = 0; this.count = 0; }
+  byte(b) {
+    if (this.length == this.out.length) { const grown = new Uint8Array(this.out.length * 2); grown.set(this.out); this.out = grown; }
+    this.out[this.length++] = b;
+  }
+  // Values go out least significant bit first.
+  write(value, n) {
+    this.bits |= value << this.count;
+    this.count += n;
+    while (this.count >= 8) { this.byte(this.bits & 255); this.bits >>>= 8; this.count -= 8; }
+  }
+  // Huffman codes go out most significant bit first.
+  code(code, n) {
+    let reversed = 0;
+    for (let i = 0; i < n; i++) { reversed = (reversed << 1) | (code & 1); code >>= 1; }
+    this.write(reversed, n);
+  }
+  align() { if (this.count > 0) { this.byte(this.bits & 255); this.bits = 0; this.count = 0; } }
+  take() { const out = this.out.slice(0, this.length); this.length = 0; return out; }
+}
+function __sbFixedLiteral(w, v) {
+  if (v < 144) w.code(0x30 + v, 8);
+  else if (v < 256) w.code(0x190 + v - 144, 9);
+  else if (v < 280) w.code(v - 256, 7);
+  else w.code(0xc0 + v - 280, 8);
+}
+// One fixed-Huffman block for data, matching within it (a hash chain of 3-byte prefixes).
+function __sbDeflateBlock(w, data, last) {
+  w.write(last ? 1 : 0, 1);
+  w.write(1, 2);
+  const head = new Int32Array(1 << 15).fill(-1);
+  const prev = new Int32Array(Math.max(data.length, 1));
+  const hash = (i) => ((data[i] << 10) ^ (data[i + 1] << 5) ^ data[i + 2]) & 0x7fff;
+  let i = 0;
+  while (i < data.length) {
+    let bestLen = 0, bestDist = 0;
+    if (i + 2 < data.length) {
+      const h = hash(i);
+      let candidate = head[h], chain = 32;
+      while (candidate >= 0 && i - candidate <= 32768 && chain-- > 0) {
+        let len = 0;
+        const max = Math.min(258, data.length - i);
+        while (len < max && data[candidate + len] == data[i + len]) len++;
+        if (len > bestLen) { bestLen = len; bestDist = i - candidate; if (len == max) break; }
+        candidate = prev[candidate];
+      }
+      prev[i] = head[h];
+      head[h] = i;
+    }
+    if (bestLen >= 3) {
+      let code = 0;
+      while (code < 28 && __sbLenBase[code + 1] <= bestLen) code++;
+      __sbFixedLiteral(w, 257 + code);
+      if (__sbLenExtra[code]) w.write(bestLen - __sbLenBase[code], __sbLenExtra[code]);
+      let dcode = 0;
+      while (dcode < 29 && __sbDistBase[dcode + 1] <= bestDist) dcode++;
+      w.code(dcode, 5);
+      if (__sbDistExtra[dcode]) w.write(bestDist - __sbDistBase[dcode], __sbDistExtra[dcode]);
+      // Index the skipped positions so later matches can start inside this one.
+      for (let k = 1; k < bestLen && i + k + 2 < data.length; k++) { const h = hash(i + k); prev[i + k] = head[h]; head[h] = i + k; }
+      i += bestLen;
+    } else {
+      __sbFixedLiteral(w, data[i]);
+      i++;
+    }
+  }
+  __sbFixedLiteral(w, 256);
+}
+
+class __sbHuffman {
+  // Canonical code from code lengths, decoded bit by bit (RFC 1951 3.2.2).
+  constructor(lengths) {
+    this.counts = new Int32Array(16);
+    this.symbols = new Int32Array(lengths.length);
+    for (let i = 0; i < lengths.length; i++) this.counts[lengths[i]]++;
+    this.counts[0] = 0;
+    const offsets = new Int32Array(16);
+    for (let i = 1; i < 16; i++) offsets[i] = offsets[i - 1] + this.counts[i - 1];
+    for (let i = 0; i < lengths.length; i++) if (lengths[i]) this.symbols[offsets[lengths[i]]++] = i;
+  }
+}
+class __sbBitReader {
+  constructor(data, at) { this.data = data; this.at = at; this.bits = 0; this.count = 0; }
+  need(n) {
+    while (this.count < n) {
+      if (this.at >= this.data.length) throw new TypeError("Decompression failed: unexpected end of data");
+      this.bits |= this.data[this.at++] << this.count;
+      this.count += 8;
+    }
+  }
+  read(n) {
+    if (n == 0) return 0;
+    this.need(n);
+    const v = this.bits & ((1 << n) - 1);
+    this.bits >>>= n;
+    this.count -= n;
+    return v;
+  }
+  decode(h) {
+    let code = 0, first = 0, index = 0;
+    for (let len = 1; len < 16; len++) {
+      code |= this.read(1);
+      const count = h.counts[len];
+      if (code - count < first) return h.symbols[index + (code - first)];
+      index += count;
+      first += count;
+      first <<= 1;
+      code <<= 1;
+    }
+    throw new TypeError("Decompression failed: invalid Huffman code");
+  }
+  // The byte after the last bit read; stored blocks and trailers start on a byte.
+  byteAt() { return this.at - (this.count >> 3); }
+  align() { this.bits = 0; this.count = 0; }
+}
+const __sbFixedLit = (() => {
+  const l = new Uint8Array(288);
+  for (let i = 0; i < 288; i++) l[i] = i < 144 ? 8 : i < 256 ? 9 : i < 280 ? 7 : 8;
+  return new __sbHuffman(l);
+})();
+const __sbFixedDist = new __sbHuffman(new Uint8Array(30).fill(5));
+const __sbClOrder = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
+function __sbGrow(out, used, n) {
+  let size = out.length * 2;
+  while (size < used + n) size *= 2;
+  const grown = new Uint8Array(size);
+  grown.set(out.subarray(0, used));
+  return grown;
+}
+// Inflates raw deflate data from at; answers the output and the byte after the last block.
+function __sbInflate(data, at) {
+  const r = new __sbBitReader(data, at);
+  // Not named length: Porffor loses writes to a local of that name (Alpha 18).
+  let out = new Uint8Array(Math.max(1024, data.length * 4));
+  let used = 0;
+  let last = 0;
+  while (!last) {
+    last = r.read(1);
+    const type = r.read(2);
+    if (type == 0) {
+      r.align();
+      const p = r.at;
+      if (p + 4 > data.length) throw new TypeError("Decompression failed: unexpected end of data");
+      const len = data[p] | (data[p + 1] << 8), nlen = data[p + 2] | (data[p + 3] << 8);
+      if ((len ^ 0xffff) != nlen) throw new TypeError("Decompression failed: invalid stored block");
+      if (p + 4 + len > data.length) throw new TypeError("Decompression failed: unexpected end of data");
+      if (used + len > out.length) out = __sbGrow(out, used, len);
+      out.set(data.subarray(p + 4, p + 4 + len), used); used += len;
+      r.at = p + 4 + len;
+      continue;
+    }
+    let lit = __sbFixedLit, dist = __sbFixedDist;
+    if (type == 2) {
+      const hlit = r.read(5) + 257, hdist = r.read(5) + 1, hclen = r.read(4) + 4;
+      const cl = new Uint8Array(19);
+      for (let i = 0; i < hclen; i++) cl[__sbClOrder[i]] = r.read(3);
+      const clh = new __sbHuffman(cl);
+      const lengths = new Uint8Array(hlit + hdist);
+      for (let i = 0; i < hlit + hdist; ) {
+        const sym = r.decode(clh);
+        if (sym < 16) lengths[i++] = sym;
+        else {
+          let repeat = 0, value = 0;
+          if (sym == 16) { if (i == 0) throw new TypeError("Decompression failed: invalid code lengths"); value = lengths[i - 1]; repeat = 3 + r.read(2); }
+          else if (sym == 17) repeat = 3 + r.read(3);
+          else repeat = 11 + r.read(7);
+          if (i + repeat > hlit + hdist) throw new TypeError("Decompression failed: invalid code lengths");
+          while (repeat--) lengths[i++] = value;
+        }
+      }
+      lit = new __sbHuffman(lengths.subarray(0, hlit));
+      dist = new __sbHuffman(lengths.subarray(hlit));
+    } else if (type != 1) throw new TypeError("Decompression failed: invalid block type");
+    for (;;) {
+      const sym = r.decode(lit);
+      if (sym < 256) { if (used + 1 > out.length) out = __sbGrow(out, used, 1); out[used++] = sym; continue; }
+      if (sym == 256) break;
+      const code = sym - 257;
+      if (code >= 29) throw new TypeError("Decompression failed: invalid used code");
+      const len = __sbLenBase[code] + r.read(__sbLenExtra[code]);
+      const dcode = r.decode(dist);
+      if (dcode >= 30) throw new TypeError("Decompression failed: invalid distance code");
+      const d = __sbDistBase[dcode] + r.read(__sbDistExtra[dcode]);
+      if (d > used) throw new TypeError("Decompression failed: distance too far back");
+      if (used + len > out.length) out = __sbGrow(out, used, len);
+      for (let k = 0; k < len; k++) { out[used] = out[used - d]; used++; }
+    }
+  }
+  return { out: out.slice(0, used), end: r.byteAt() };
+}
+
+function __sbFormat(format, what) {
+  const f = String(format);
+  if (f != "gzip" && f != "deflate" && f != "deflate-raw") throw new TypeError("Unsupported " + what + " format: " + f);
+  return f;
+}
+function __sbChunkBytes(chunk) {
+  if (chunk instanceof Uint8Array) return chunk;
+  if (chunk instanceof ArrayBuffer) return new Uint8Array(chunk);
+  if (ArrayBuffer.isView(chunk)) return new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+  throw new TypeError("The provided value is not of type '(ArrayBuffer or ArrayBufferView)'");
+}
+
+class CompressionStream {
+  constructor(format) {
+    const kind = __sbFormat(format, "compression");
+    const w = new __sbBitWriter();
+    let check = kind == "deflate" ? 1 : 0, size = 0;
+    if (kind == "gzip") for (const b of [0x1f, 0x8b, 8, 0, 0, 0, 0, 0, 0, 0xff]) w.byte(b);
+    else if (kind == "deflate") { w.byte(0x78); w.byte(0x9c); }
+    const t = new TransformStream({
+      transform(chunk, controller) {
+        const bytes = __sbChunkBytes(chunk);
+        if (!bytes.length) return;
+        if (kind == "gzip") check = __sbCrc32(check, bytes);
+        else if (kind == "deflate") check = __sbAdler32(check, bytes);
+        size = (size + bytes.length) >>> 0;
+        __sbDeflateBlock(w, bytes, false);
+        const out = w.take();
+        if (out.length) controller.enqueue(out);
+      },
+      flush(controller) {
+        __sbDeflateBlock(w, new Uint8Array(0), true);
+        w.align();
+        if (kind == "gzip") for (const v of [check, size]) for (let k = 0; k < 4; k++) w.byte((v >>> (8 * k)) & 255);
+        else if (kind == "deflate") for (let k = 3; k >= 0; k--) w.byte((check >>> (8 * k)) & 255);
+        controller.enqueue(w.take());
+      },
+    });
+    this._t = t;
+  }
+  get readable() { return this._t.readable; }
+  get writable() { return this._t.writable; }
+}
+
+class DecompressionStream {
+  constructor(format) {
+    const kind = __sbFormat(format, "decompression");
+    const parts = [];
+    let total = 0;
+    const t = new TransformStream({
+      transform(chunk) { const bytes = __sbChunkBytes(chunk); parts.push(bytes.slice()); total += bytes.length; },
+      flush(controller) {
+        const data = new Uint8Array(total);
+        let at = 0;
+        for (const p of parts) { data.set(p, at); at += p.length; }
+        let start = 0;
+        if (kind == "gzip") {
+          if (data.length < 18 || data[0] != 0x1f || data[1] != 0x8b || data[2] != 8) throw new TypeError("Decompression failed: not gzip data");
+          const flags = data[3];
+          start = 10;
+          if (flags & 4) start += 2 + (data[start] | (data[start + 1] << 8));
+          if (flags & 8) { while (start < data.length && data[start]) start++; start++; }
+          if (flags & 16) { while (start < data.length && data[start]) start++; start++; }
+          if (flags & 2) start += 2;
+        } else if (kind == "deflate") {
+          if (data.length < 6 || (data[0] & 15) != 8 || ((data[0] << 8) | data[1]) % 31 != 0 || data[1] & 32) throw new TypeError("Decompression failed: not zlib data");
+          start = 2;
+        }
+        const { out, end } = __sbInflate(data, start);
+        if (kind == "gzip") {
+          if (end + 8 > data.length) throw new TypeError("Decompression failed: unexpected end of data");
+          const crc = (data[end] | (data[end + 1] << 8) | (data[end + 2] << 16) | (data[end + 3] << 24)) >>> 0;
+          const isize = (data[end + 4] | (data[end + 5] << 8) | (data[end + 6] << 16) | (data[end + 7] << 24)) >>> 0;
+          if (crc != __sbCrc32(0, out) || isize != out.length >>> 0) throw new TypeError("Decompression failed: gzip checksum mismatch");
+        } else if (kind == "deflate") {
+          if (end + 4 > data.length) throw new TypeError("Decompression failed: unexpected end of data");
+          const adler = ((data[end] << 24) | (data[end + 1] << 16) | (data[end + 2] << 8) | data[end + 3]) >>> 0;
+          if (adler != __sbAdler32(1, out)) throw new TypeError("Decompression failed: deflate checksum mismatch");
+        }
+        if (out.length) controller.enqueue(out);
+      },
+    });
+    this._t = t;
+  }
+  get readable() { return this._t.readable; }
+  get writable() { return this._t.writable; }
+}
+// Static installs, so app code sees the names when it is compiled apart (see streams-entry.js).
+if (globalThis.CompressionStream == null) globalThis.CompressionStream = CompressionStream;
+if (globalThis.DecompressionStream == null) globalThis.DecompressionStream = DecompressionStream;
+// END COMPRESSION STREAMS
+
+// HTML REWRITER: Cloudflare's HTMLRewriter in JavaScript (workerd uses lol-html). It reads
+// the whole body, then tokenizes it once: elements, text and comments are matched against
+// the selectors given to on() and onDocument(), handlers run in document order (and may be
+// async), and the changes they ask for are written as the document is re-emitted.
+// Selectors: type, *, #id, .class, [attr], [attr=v], [attr~=v], [attr^=v], [attr$=v],
+// [attr*=v], [attr|=v], descendant and child combinators, and lists. Not :nth-child and
+// other pseudo-classes, which throw a TypeError on on(), as an unsupported selector does.
+
+const __sbVoidTags = new Set(["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"]);
+const __sbRawTextTags = new Set(["script", "style", "textarea", "title", "xmp", "iframe", "noembed", "noframes", "plaintext"]);
+function __sbEscapeText(s) { return String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;"); }
+function __sbEscapeAttr(s) { return String(s).replace(/&/g, "&amp;").replace(/"/g, "&quot;"); }
+function __sbContent(content, options) { return options && options.html ? String(content) : __sbEscapeText(content); }
+
+// One compound selector: [{ tag, id, classes, attrs }] joined by combinators.
+function __sbParseSelector(text) {
+  const list = [];
+  for (const part of String(text).split(",")) {
+    const steps = [];
+    let s = part.trim(), combinator = " ";
+    if (!s) throw new TypeError("Invalid selector: " + text);
+    while (s.length) {
+      const step = { tag: null, id: null, classes: [], attrs: [], combinator };
+      let m;
+      let star = false;
+      if ((m = /^(\*|[a-zA-Z][\w-]*)/.exec(s))) { if (m[1] != "*") step.tag = m[1].toLowerCase(); else star = true; s = s.slice(m[0].length); }
+      for (;;) {
+        if ((m = /^#([\w-]+)/.exec(s))) { step.id = m[1]; s = s.slice(m[0].length); continue; }
+        if ((m = /^\.([\w-]+)/.exec(s))) { step.classes.push(m[1]); s = s.slice(m[0].length); continue; }
+        if ((m = /^\[\s*([\w:-]+)\s*(?:([~^$*|]?=)\s*(?:"([^"]*)"|'([^']*)'|([^\]\s]+))\s*)?(i)?\s*\]/.exec(s))) {
+          step.attrs.push({ name: m[1].toLowerCase(), op: m[2] || null, value: m[3] ?? m[4] ?? m[5] ?? "", ci: !!m[6] });
+          s = s.slice(m[0].length);
+          continue;
+        }
+        break;
+      }
+      if (s.length && s[0] == ":") throw new TypeError("Unsupported pseudo-class selector: " + text);
+      if (step.tag == null && step.id == null && !step.classes.length && !step.attrs.length && !star)
+        throw new TypeError("Invalid selector: " + text);
+      steps.push(step);
+      const ws = /^\s*/.exec(s)[0];
+      s = s.slice(ws.length);
+      if (!s.length) break;
+      if (s[0] == ">") { combinator = ">"; s = s.slice(1).trimStart(); }
+      else if (ws.length) combinator = " ";
+      else throw new TypeError("Invalid selector: " + text);
+    }
+    list.push(steps);
+  }
+  return list;
+}
+function __sbStepMatches(step, el) {
+  if (step.tag != null && step.tag != el.tag) return false;
+  if (step.id != null && el.attr("id") !== step.id) return false;
+  if (step.classes.length) {
+    const have = (el.attr("class") || "").split(/\s+/);
+    for (const c of step.classes) if (!have.includes(c)) return false;
+  }
+  for (const a of step.attrs) {
+    let v = el.attr(a.name);
+    if (v == null) return false;
+    if (!a.op) continue;
+    let want = a.value;
+    if (a.ci) { v = v.toLowerCase(); want = want.toLowerCase(); }
+    if (a.op == "=" && v !== want) return false;
+    if (a.op == "~=" && !v.split(/\s+/).includes(want)) return false;
+    if (a.op == "^=" && (!want || !v.startsWith(want))) return false;
+    if (a.op == "$=" && (!want || !v.endsWith(want))) return false;
+    if (a.op == "*=" && (!want || !v.includes(want))) return false;
+    if (a.op == "|=" && v !== want && !v.startsWith(want + "-")) return false;
+  }
+  return true;
+}
+// stack: the open elements, outermost first; the last is the candidate.
+function __sbSelectorMatches(steps, stack) {
+  const match = (si, ei) => {
+    if (!__sbStepMatches(steps[si], stack[ei])) return false;
+    if (si == 0) return true;
+    if (steps[si].combinator == ">") return ei > 0 && match(si - 1, ei - 1);
+    for (let k = ei - 1; k >= 0; k--) if (match(si - 1, k)) return true;
+    return false;
+  };
+  return match(steps.length - 1, stack.length - 1);
+}
+
+// Content to write around a node, from before/after/prepend/append/replace calls.
+class __sbEdits {
+  constructor() { this.before = ""; this.after = ""; this.replaced = null; this.removed = false; }
+}
+class __sbElement {
+  constructor(state) { this._s = state; }
+  get tagName() { return this._s.tag; }
+  set tagName(name) { this._s.tag = String(name).toLowerCase(); this._s.renamed = true; }
+  get namespaceURI() { return "http://www.w3.org/1999/xhtml"; }
+  get attributes() { return this._s.attrs.map((a) => [a[0], a[1]])[Symbol.iterator](); }
+  get removed() { return this._s.edits.removed; }
+  get selfClosing() { return this._s.selfClosing; }
+  get canHaveContent() { return !__sbVoidTags.has(this._s.tag); }
+  getAttribute(name) { return this._s.attr(String(name).toLowerCase()); }
+  hasAttribute(name) { return this._s.attr(String(name).toLowerCase()) != null; }
+  setAttribute(name, value) {
+    const n = String(name).toLowerCase();
+    const at = this._s.attrs.findIndex((a) => a[0] == n);
+    if (at >= 0) this._s.attrs[at] = [n, String(value), null]; else this._s.attrs.push([n, String(value), null]);
+    this._s.attrsChanged = true;
+    return this;
+  }
+  removeAttribute(name) {
+    const n = String(name).toLowerCase();
+    this._s.attrs = this._s.attrs.filter((a) => a[0] != n);
+    this._s.attrsChanged = true;
+    return this;
+  }
+  before(content, options) { this._s.edits.before += __sbContent(content, options); return this; }
+  after(content, options) { this._s.edits.after = __sbContent(content, options) + this._s.edits.after; return this; }
+  prepend(content, options) { this._s.prepend = __sbContent(content, options) + this._s.prepend; return this; }
+  append(content, options) { this._s.append += __sbContent(content, options); return this; }
+  setInnerContent(content, options) { this._s.inner = __sbContent(content, options); this._s.prepend = ""; this._s.append = ""; return this; }
+  replace(content, options) { this._s.edits.replaced = __sbContent(content, options); this._s.edits.removed = true; return this; }
+  remove() { this._s.edits.removed = true; this._s.edits.replaced = ""; return this; }
+  removeAndKeepContent() { this._s.keepContent = true; this._s.edits.removed = true; return this; }
+  onEndTag(handler) { this._s.endHandlers.push(handler); }
+}
+class __sbEndTag {
+  constructor(state) { this._s = state; }
+  get name() { return this._s.tag; }
+  set name(n) { this._s.tag = String(n).toLowerCase(); }
+  before(content, options) { this._s.endBefore += __sbContent(content, options); return this; }
+  after(content, options) { this._s.endAfter = __sbContent(content, options) + this._s.endAfter; return this; }
+  remove() { this._s.endRemoved = true; return this; }
+}
+class __sbTextChunk {
+  constructor(text, last) { this.text = text; this.lastInTextNode = last; this._e = new __sbEdits(); }
+  get removed() { return this._e.removed; }
+  before(content, options) { this._e.before += __sbContent(content, options); return this; }
+  after(content, options) { this._e.after = __sbContent(content, options) + this._e.after; return this; }
+  replace(content, options) { this._e.replaced = __sbContent(content, options); this._e.removed = true; return this; }
+  remove() { this._e.removed = true; this._e.replaced = ""; return this; }
+}
+class __sbComment {
+  constructor(text) { this.text = text; this._e = new __sbEdits(); }
+  get removed() { return this._e.removed; }
+  before(content, options) { this._e.before += __sbContent(content, options); return this; }
+  after(content, options) { this._e.after = __sbContent(content, options) + this._e.after; return this; }
+  replace(content, options) { this._e.replaced = __sbContent(content, options); this._e.removed = true; return this; }
+  remove() { this._e.removed = true; this._e.replaced = ""; return this; }
+}
+class __sbDocEnd {
+  constructor(out) { this._out = out; }
+  append(content, options) { this._out.push(__sbContent(content, options)); return this; }
+}
+
+class __sbRewriteRun {
+  constructor(handlers, documentHandlers, html) {
+    this.handlers = handlers;
+    this.documentHandlers = documentHandlers;
+    this.html = html;
+    this.out = [];
+    this.stack = [];
+    // Inner content of an element replaced by setInnerContent, remove or replace is skipped:
+    // the depth in the stack below which output is suppressed, or -1.
+    this.skipBelow = -1;
+  }
+  emit(s) { if (this.skipBelow < 0) this.out.push(s); }
+  async call(handler, method, arg) {
+    const f = handler && handler[method];
+    if (__sbIsFn(f)) await f.call(handler, arg);
+  }
+  // Text and comment handlers run for content anywhere inside a matched element.
+  inside(steps) {
+    for (let i = 0; i < this.stack.length; i++) if (steps.some((s) => __sbSelectorMatches(s, this.stack.slice(0, i + 1)))) return true;
+    return false;
+  }
+  // A text node arrives as its text, then an empty chunk with lastInTextNode, as lol-html does.
+  async text(raw) {
+    if (!raw.length || this.skipBelow >= 0) return;
+    for (const [text, last] of [[raw, false], ["", true]]) {
+      const chunk = new __sbTextChunk(text, last);
+      for (const h of this.documentHandlers) await this.call(h, "text", chunk);
+      for (const [steps, h] of this.handlers) if (this.inside(steps)) await this.call(h, "text", chunk);
+      this.emit(chunk._e.removed ? chunk._e.before + (chunk._e.replaced ?? "") + chunk._e.after : chunk._e.before + text + chunk._e.after);
+    }
+  }
+  async comment(raw) {
+    if (this.skipBelow >= 0) return;
+    const c = new __sbComment(raw);
+    for (const h of this.documentHandlers) await this.call(h, "comments", c);
+    for (const [steps, h] of this.handlers) if (this.inside(steps)) await this.call(h, "comments", c);
+    this.emit(c._e.removed ? c._e.before + (c._e.replaced ?? "") + c._e.after : c._e.before + "<!--" + c.text + "-->" + c._e.after);
+  }
+  async doctype(raw) {
+    const m = /^<!doctype\s+([^\s>]+)?/i.exec(raw);
+    const d = { name: m && m[1] ? m[1].toLowerCase() : null, publicId: null, systemId: null };
+    for (const h of this.documentHandlers) await this.call(h, "doctype", d);
+    this.emit(raw);
+  }
+  startTag(state) {
+    let s = "<" + (state.renamed ? state.tag : state.rawName);
+    for (const [n, v, raw] of state.attrs) s += raw != null ? " " + raw : " " + n + '="' + __sbEscapeAttr(v) + '"';
+    return s + (state.selfClosing ? " />" : ">");
+  }
+  async element(tag, rawName, attrs, selfClosing, rawStart) {
+    const state = {
+      tag, rawName, attrs, selfClosing, rawStart,
+      attr(name) { const a = this.attrs.find((x) => x[0] == name); return a ? a[1] : null; },
+      edits: new __sbEdits(), prepend: "", append: "", inner: null, keepContent: false, renamed: false, attrsChanged: false,
+      endHandlers: [], endBefore: "", endAfter: "", endRemoved: false,
+    };
+    const skipped = this.skipBelow >= 0;
+    this.stack.push(state);
+    if (!skipped) {
+      const el = new __sbElement(state);
+      for (const [steps, h] of this.handlers) if (steps.some((s) => __sbSelectorMatches(s, this.stack))) await this.call(h, "element", el);
+    }
+    const e = state.edits;
+    this.emit(e.before);
+    const unchanged = !state.renamed && !state.attrsChanged;
+    if (!e.removed || state.keepContent) {
+      if (!e.removed) this.emit(unchanged ? rawStart : this.startTag(state));
+    } else this.emit(e.replaced ?? "");
+    const isVoid = __sbVoidTags.has(tag) || selfClosing;
+    if (isVoid) {
+      this.stack.pop();
+      this.emit(e.after);
+      return null;
+    }
+    if (!e.removed || state.keepContent) this.emit(state.prepend);
+    if (state.inner != null) { this.emit(state.inner); if (this.skipBelow < 0) this.skipBelow = this.stack.length; }
+    else if (e.removed && !state.keepContent && this.skipBelow < 0) this.skipBelow = this.stack.length;
+    return state;
+  }
+  async endTag(state, rawEnd) {
+    if (this.skipBelow == this.stack.length) this.skipBelow = -1;
+    this.stack.pop();
+    const e = state.edits;
+    if (!e.removed || state.keepContent) this.emit(state.append);
+    if (!e.removed) {
+      const end = new __sbEndTag(state);
+      for (const handler of state.endHandlers) await handler(end);
+      this.emit(state.endBefore);
+      if (!state.endRemoved) this.emit(state.renamed || end.name != state.tag ? "</" + state.tag + ">" : rawEnd);
+      this.emit(state.endAfter);
+    }
+    this.emit(e.after);
+  }
+  async run() {
+    const html = this.html;
+    let i = 0, textStart = 0;
+    const flushText = async (to) => { if (to > textStart) await this.text(html.slice(textStart, to)); };
+    const open = [];
+    while (i < html.length) {
+      const lt = html.indexOf("<", i);
+      if (lt < 0) break;
+      const next = html[lt + 1];
+      if (html.startsWith("<!--", lt)) {
+        await flushText(lt);
+        const end = html.indexOf("-->", lt + 4);
+        const stop = end < 0 ? html.length : end;
+        await this.comment(html.slice(lt + 4, stop));
+        i = textStart = end < 0 ? html.length : end + 3;
+        continue;
+      }
+      if (next == "!" || next == "?") {
+        await flushText(lt);
+        const end = html.indexOf(">", lt);
+        const raw = html.slice(lt, end < 0 ? html.length : end + 1);
+        if (/^<!doctype/i.test(raw)) await this.doctype(raw); else this.emit(raw);
+        i = textStart = lt + raw.length;
+        continue;
+      }
+      if (next == "/" && /[a-zA-Z]/.test(html[lt + 2] || "")) {
+        await flushText(lt);
+        const end = html.indexOf(">", lt);
+        const raw = html.slice(lt, end < 0 ? html.length : end + 1);
+        const name = /^<\/([^\s/>]+)/.exec(raw)[1].toLowerCase();
+        // Close up to the matching open element; unmatched end tags pass through.
+        let at = -1;
+        for (let k = open.length - 1; k >= 0; k--) if (open[k].rawName.toLowerCase() == name) { at = k; break; }
+        if (at < 0) this.emit(raw);
+        else {
+          while (open.length > at + 1) { const inner = open.pop(); await this.endTag(inner, ""); }
+          await this.endTag(open.pop(), raw);
+        }
+        i = textStart = lt + raw.length;
+        continue;
+      }
+      if (!/[a-zA-Z]/.test(next || "")) { i = lt + 1; continue; }
+      await flushText(lt);
+      // A start tag: name, then attributes (quoted, unquoted or bare) up to > or />.
+      let p = lt + 1;
+      while (p < html.length && !/[\s/>]/.test(html[p])) p++;
+      const rawName = html.slice(lt + 1, p);
+      const tag = rawName.toLowerCase();
+      const attrs = [];
+      let selfClosing = false;
+      for (;;) {
+        while (p < html.length && /\s/.test(html[p])) p++;
+        if (p >= html.length) break;
+        if (html[p] == ">") { p++; break; }
+        if (html[p] == "/" && html[p + 1] == ">") { selfClosing = true; p += 2; break; }
+        if (html[p] == "/") { p++; continue; }
+        const start = p;
+        let q = p;
+        while (q < html.length && !/[\s=/>]/.test(html[q])) q++;
+        const name = html.slice(p, q).toLowerCase();
+        p = q;
+        while (p < html.length && /\s/.test(html[p])) p++;
+        if (html[p] == "=") {
+          p++;
+          while (p < html.length && /\s/.test(html[p])) p++;
+          let value;
+          if (html[p] == '"' || html[p] == "'") {
+            const quote = html[p], close = html.indexOf(quote, p + 1);
+            value = html.slice(p + 1, close < 0 ? html.length : close);
+            p = close < 0 ? html.length : close + 1;
+          } else {
+            let r = p;
+            while (r < html.length && !/[\s>]/.test(html[r])) r++;
+            value = html.slice(p, r);
+            p = r;
+          }
+          attrs.push([name, value.replace(/&amp;/g, "&").replace(/&quot;/g, '"'), html.slice(start, p)]);
+        } else attrs.push([name, "", html.slice(start, p)]);
+      }
+      const rawStart = html.slice(lt, p);
+      const state = await this.element(tag, rawName, attrs, selfClosing && !__sbVoidTags.has(tag) ? false : selfClosing, rawStart);
+      if (state) open.push(state);
+      i = textStart = p;
+      // Raw text elements hold their content verbatim up to their own end tag.
+      if (state && __sbRawTextTags.has(tag)) {
+        const close = html.toLowerCase().indexOf("</" + tag, p);
+        const stop = close < 0 ? html.length : close;
+        await this.text(html.slice(p, stop));
+        i = textStart = stop;
+      }
+    }
+    await flushText(html.length);
+    // An element whose end tag never came has not ended: nothing appended to it is written
+    // (lol-html does not imply end tags).
+    open.length = 0;
+    const tail = [];
+    for (const h of this.documentHandlers) if (__sbIsFn(h.end)) await h.end(new __sbDocEnd(tail));
+    return this.out.join("") + tail.join("");
+  }
+}
+
+class HTMLRewriter {
+  constructor() { this._handlers = []; this._documentHandlers = []; }
+  on(selector, handlers) { this._handlers.push([__sbParseSelector(selector), handlers]); return this; }
+  onDocument(handlers) { this._documentHandlers.push(handlers); return this; }
+  transform(response) {
+    const handlers = this._handlers, documentHandlers = this._documentHandlers;
+    const headers = new Headers(response.headers);
+    headers.delete("content-length");
+    const body = new ReadableStream({
+      async start(controller) {
+        try {
+          const html = await response.text();
+          const out = await new __sbRewriteRun(handlers, documentHandlers, html).run();
+          controller.enqueue(new TextEncoder().encode(out));
+          controller.close();
+        } catch (error) {
+          controller.error(error);
+        }
+      },
+    });
+    return new Response(body, { status: response.status, statusText: response.statusText, headers });
+  }
+}
+// A static install, so app code sees the name when it is compiled apart (see streams-entry.js).
+if (globalThis.HTMLRewriter == null) globalThis.HTMLRewriter = HTMLRewriter;
+// END HTML REWRITER
+
 // Porffor exposes native timers lexically. Libraries also access them through
 // globalThis, including noble hashes 2.4's host-task yields.
 if (globalThis.setTimeout == null) globalThis.setTimeout = setTimeout;
@@ -2392,7 +3092,7 @@ function __sbCpuMs() {
 function __sbTagCpu(res, t0) {
   const cpu = __sbCpuMs() - t0;
   try {
-    const body = res && res.body;
+    const body = __sbRawBody(res);
     if (__sbIsStr(body) && !res.headers.has("set-cookie")) {
       const headers = {};
       res.headers.forEach(function (value, name) {
@@ -4489,7 +5189,7 @@ globalThis.__sbInstallBindings = function (target, bindings) {
           url,
           method: opts.method || "GET",
           headers,
-          ...__sbRequestBody(opts.body),
+          ...__sbRequestBody(opts instanceof Request ? __sbRawBody(opts) : opts.body),
         });
         const respHeaders = new Headers();
         for (let j = 0; j < (r.headers || []).length; j++) respHeaders.set(r.headers[j][0], r.headers[j][1]);
@@ -4521,7 +5221,7 @@ globalThis.__sbInstallFetch = function () {
       if (__sbIsFn(source.forEach)) source.forEach((v, k) => headers.push([k, v]));
       else for (const k in source) headers.push([k, source[k]]);
     }
-    const body = opts.body !== undefined ? opts.body : req && req.body !== "" ? req.body : null;
+    const body = opts.body !== undefined && !(opts instanceof Request) ? opts.body : req && __sbRawBody(req) !== "" ? __sbRawBody(req) : null;
     const method = opts.method || (req && req.method) || "GET";
     const msg = { url, method, headers, ...__sbRequestBody(body) };
     const respond = (r) => {
@@ -4947,8 +5647,14 @@ async function __sbCollectBody(stream) {
   }
   return out;
 }
+// The body as given (a string, bytes or a ReadableStream), not the stream the Fetch-spec
+// body getter makes over it; plain objects keep their body as is.
+function __sbRawBody(message) {
+  if (message == null) return null;
+  return message._bodyInit !== undefined ? message._bodyInit : message.body;
+}
 function __sbHasStreamBody(res) {
-  return res != null && res.body instanceof ReadableStream;
+  return res != null && __sbRawBody(res) instanceof ReadableStream;
 }
 
 // B19: on a host that streams (a standalone sprout's native server defines sb_stream_*), a
@@ -4997,7 +5703,7 @@ function __sbStreamingSupported() {
   return __sbStreaming === 1;
 }
 function __sbStreamResponse(response) {
-  const stream = response.body;
+  const stream = __sbRawBody(response);
   const id = __sbStreamOp("o", "0", "");
   response.headers.set("x-sb-stream", id);
   response.body = "";
@@ -5033,7 +5739,7 @@ async function __sbFetchWithDrain(res, tasks) {
     r = res && __sbIsFn(res.then) ? await res : res;
     if (__sbHasStreamBody(r)) {
       if (__sbStreamingSupported()) __sbStreamResponse(r);
-      else r.body = await __sbCollectBody(r.body);
+      else r.body = await __sbCollectBody(__sbRawBody(r));
     }
   } catch (error) {
     // #179 — a rejected handler promise must not take the process down with it.
@@ -5094,7 +5800,7 @@ async function __sbQueueWithDrain(result, tasks) {
 // handing the request to user code. Request.text() in Porffor otherwise treats
 // the raw bytes as already-decoded characters and corrupts Unicode/HMAC input.
 function __sbDecodeIngress(request) {
-  const raw = request.body;
+  const raw = __sbRawBody(request);
   if (raw == null) return;
   let decoded = null;
   request.text = function () {
@@ -5286,7 +5992,8 @@ async function __sbRunQueueBatch(handlers, body, ctx) {
 
 function __sbReadJson(request) {
   try {
-    return JSON.parse(request.body == null ? "{}" : String(request.body));
+    const body = __sbRawBody(request);
+    return JSON.parse(body == null ? "{}" : String(body));
   } catch {
     return {};
   }

package/test/native-bodies.ts

@@ -18,6 +18,38 @@ const handler = `export default {async fetch(request) {
   if (path === "/stream-strings") return new Response(new ReadableStream({ start(c) { c.enqueue("text"); c.close(); } }));
   if (path === "/form") { const f = new FormData(); f.append("a", "1"); f.append("f", new Blob(["xy"]), "n.txt"); return new Response(f); }
   const cases = [
+    // body is a ReadableStream for every body type (Fetch), and readers still work.
+    () => [new Response("hi").body instanceof ReadableStream, new Response(new Uint8Array([1])).body instanceof ReadableStream, new Response(null).body, new Request("http://a.test", { method: "POST", body: "q" }).body instanceof ReadableStream].join(","),
+    async () => new Response(new Response("abc").body).text(),
+    async () => { const r = new Response("x"); const b = r.body; return (b === r.body) + ":" + (await r.text()); },
+    async () => { const r = new Response("x"); r.body.getReader(); try { await r.text(); return "no throw"; } catch (e) { return e.name; } },
+    async () => { const reader = new Response("chunk").body.getReader(); const { value, done } = await reader.read(); return new TextDecoder().decode(value) + ":" + done + ":" + (await reader.read()).done; },
+    async () => { const r = new Response("cloned"); return (await r.clone().text()) + "|" + (await r.text()); },
+    // HTMLRewriter, against Bun's (lol-html, as in workerd): the W2 cases and more.
+    () => typeof HTMLRewriter,
+    () => new HTMLRewriter().on("h1", { element(e) { e.setInnerContent("x"); } }).transform(new Response("<h1>a</h1><p>b</p>")).text(),
+    () => new HTMLRewriter().on("a", { element(e) { e.setAttribute("href", "/n"); } }).transform(new Response('<a href="/o" data-x=1>l</a>')).text(),
+    () => new HTMLRewriter().on("script", { element(e) { e.remove(); } }).transform(new Response("<p>a</p><script>if (a < b) x()</script>")).text(),
+    async () => { let t = ""; await new HTMLRewriter().on("p", { text(c) { t += c.text + (c.lastInTextNode ? "|" : ""); } }).transform(new Response("<p>hi <b>there</b></p>")).text(); return t; },
+    () => new HTMLRewriter().on("body", { element(e) { e.append("<i>z</i>", { html: true }).prepend("<&>"); } }).transform(new Response("<body>a</body>")).text(),
+    () => new HTMLRewriter().on("div > span.k, #m", { element(e) { e.replace("R"); } }).on("p", { comments(c) { c.remove(); } }).transform(new Response('<div><span class="k">1</span><p><!--c-->2<span class="k">3</span></p></div><i id="m">4</i>')).text(),
+    () => new HTMLRewriter().on("li", { async element(e) { await null; e.removeAndKeepContent(); } }).onDocument({ end(d) { d.append("<!--e-->", { html: true }); } }).transform(new Response("<ul><li>a</li><li>b</li></ul>")).text(),
+    // CompressionStream and DecompressionStream: our output round-trips, and zlib's decodes.
+    async () => { const out = []; for (const f of ["gzip", "deflate", "deflate-raw"]) out.push(await new Response(new ReadableStream({ start(c) { c.enqueue(new TextEncoder().encode("hello ".repeat(200))); c.close(); } }).pipeThrough(new CompressionStream(f)).pipeThrough(new DecompressionStream(f))).text() === "hello ".repeat(200)); return out.join(","); },
+    async () => new Response(new ReadableStream({ start(c) { c.enqueue(Uint8Array.from(atob("H4sIAAAAAAACEysuKMovLUnKTyxRKB5uTACdCbks3AAAAA=="), (ch) => ch.charCodeAt(0))); c.close(); } }).pipeThrough(new DecompressionStream("gzip"))).text(),
+    async () => new Response(new ReadableStream({ start(c) { c.enqueue(Uint8Array.from(atob("eJxLqcxLzM1MVsgoTUvLTcxTSBnlj4ZHJv3SQ2peCgCxCfLI"), (ch) => ch.charCodeAt(0))); c.close(); } }).pipeThrough(new DecompressionStream("deflate"))).text(),
+    async () => { const s = new ReadableStream({ start(c) { c.enqueue(new TextEncoder().encode("hello hello")); c.close(); } }).pipeThrough(new CompressionStream("gzip")).pipeThrough(new DecompressionStream("gzip")).pipeThrough(new TextDecoderStream()); let t = ""; for (const r = s.getReader(); ;) { const { value, done } = await r.read(); if (done) break; t += value; } return t; },
+    // workerd knows gzip, deflate and deflate-raw; Bun (the reference) also brotli.
+    () => { try { new CompressionStream("brotli"); return "workerd:no throw"; } catch (e) { return "workerd:" + e.name; } },
+    // A ReadableStream body is read to its end by text(), arrayBuffer(), json() and blob().
+    async () => new Response(new ReadableStream({ start(c) { c.enqueue(new TextEncoder().encode("hé")); c.enqueue(new Uint8Array([33])); c.close(); } })).text(),
+    async () => Array.from(new Uint8Array(await new Response(new ReadableStream({ start(c) { c.enqueue(new Uint8Array([1, 2])); c.close(); } })).arrayBuffer())).join(","),
+    async () => JSON.stringify(await new Response(new ReadableStream({ start(c) { c.enqueue(new TextEncoder().encode('{"a":[1]}')); c.close(); } })).json()),
+    async () => (await new Response(new ReadableStream({ start(c) { c.enqueue(new Uint8Array([120])); c.close(); } })).blob()).size,
+    async () => new Request("http://a.test", { method: "POST", body: new ReadableStream({ start(c) { c.enqueue(new TextEncoder().encode("req")); c.close(); } }), duplex: "half" }).text(),
+    // Chunks must be bytes: workerd throws a TypeError, where Bun (the reference below) reads a
+    // string chunk as text. "workerd:" marks the answer to expect from workerd instead.
+    async () => { try { await new Response(new ReadableStream({ start(c) { c.enqueue("s"); c.close(); } })).text(); return "workerd:no throw"; } catch (e) { return "workerd:" + e.name; } },
     () => new Request("http://a.test/a/../b?x=1#f").url,
     async () => { const r = new Request("http://a.test", { method: "POST", body: "x" }); await r.text(); try { await r.text(); return "no throw"; } catch (e) { return r.bodyUsed + ":" + e.name; } },
     () => new Request("http://a.test").redirect,
@@ -125,7 +157,7 @@ try {
   for (const run of reference) {
     try { want.push(String(await run())); } catch (e) { want.push("THROWS " + (e instanceof Error ? e.name : String(e))); }
   }
-  assert.deepEqual(got, want);
+  assert.deepEqual(got, want.map((w) => (w.startsWith("workerd:") ? "workerd:TypeError" : w)));
   console.log(`Native bodies are sent as bytes and ${want.length} Fetch class cases match Bun`);
 } finally {
   if (server) {

package/test/native-json.ts

@@ -17,6 +17,11 @@ const CASES = [
   `JSON.stringify({ n: { toJSON() { return 42; } } })`,
   `JSON.stringify({ nested: { at: new Date(0), list: [new Date(0)] } })`,
   `JSON.stringify({ plain: { x: 1 } })`,
+  // The reviver: children first, undefined deletes, `this` is the holder, arrays by index.
+  `JSON.stringify(JSON.parse('{"a":1,"b":{"c":2}}', (k, v) => (typeof v === "number" ? v * 10 : v)))`,
+  `JSON.stringify(JSON.parse('{"a":1,"drop":2,"l":[1,2,3]}', (k, v) => (k === "drop" ? undefined : v)))`,
+  `JSON.stringify(JSON.parse('[5,6]', function (k, v) { return k === "" ? v : k + ":" + v + ":" + Array.isArray(this); }))`,
+  `JSON.stringify(JSON.parse('{"x":1}', (k, v) => (k === "" ? "root:" + typeof v : v)))`,
 ];
 const handler = `export default {fetch() {
   const U = URL;

package/test/native-request.ts

@@ -18,7 +18,9 @@ const CASES = [
   `new Request(new URL("http://a.test/u")).url`,
   `new Request("http://a.test/x", { method: "post" }).method`,
 ];
-const handler = `export default {async fetch() {
+const handler = `export default {async fetch(request) {
+  // The incoming request: its body is a ReadableStream, and text() still reads it.
+  if (request.method === "POST") return new Response((request.body instanceof ReadableStream) + ":" + (await request.text()));
   const cases = [
 ${CASES.map((c) => `    () => (${c}),`).join("\n")}
   ];
@@ -91,7 +93,9 @@ try {
   const got = JSON.parse(await (await fetch(`http://127.0.0.1:${port}/`)).text()) as string[];
   const diffs = CASES.flatMap((c, i) => (got[i] === want[i] ? [] : [`${c}\n    want ${JSON.stringify(want[i])}\n    got  ${JSON.stringify(got[i])}`]));
   assert.deepEqual(diffs, [], `Request copies differ from Bun in ${diffs.length} of ${CASES.length} cases:\n${diffs.join("\n")}`);
-  console.log(`Native Request copies match Bun in all ${CASES.length} cases`);
+  const posted = await (await fetch(`http://127.0.0.1:${port}/`, { method: "POST", body: "posted é" })).text();
+  assert.equal(posted, "true:posted é", "the incoming request body is a stream and text() reads it");
+  console.log(`Native Request copies match Bun in all ${CASES.length} cases; the incoming body is a stream`);
 } finally {
   if (server) {
     server.kill(9);