@sproutboat/runtime 0.18.0 → 0.19.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @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

package/WEB_STREAMS.md

@@ -20,8 +20,8 @@ runtime links no zlib. Compression writes one fixed-Huffman block per chunk as i
 (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. A body given as a string, bytes or a Blob is
-still exposed as that value, not as a ReadableStream.
+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.18.0",
+  "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

@@ -3092,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) {
@@ -5189,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]);
@@ -5221,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) => {
@@ -5647,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
@@ -5697,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 = "";
@@ -5733,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.
@@ -5794,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 () {
@@ -5986,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,13 @@ 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(),

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);