@sproutboat/runtime 0.18.0 → 0.19.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @sproutboat/runtime
 
+## 0.19.1
+
+### Patch Changes
+
+- 6676ead: `env.BUCKET.put(key, request.body)`, `env.KV.put(key, request.body)` and `fetch(url, { body: request.body })` store and send the request body again. Since 0.19.0, `body` is a `ReadableStream`, and these took its string form. Incoming request bodies are also read as the bytes they are, so `arrayBuffer()`, `blob()`, `body` and KV `put` no longer UTF-8 encode a non-ASCII upload twice. R2 `put` accepts bytes as well.
+
+## 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.1",
   "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) {
@@ -4045,7 +4045,14 @@ function __sbFromUtf8(bytes) {
 // #232 — a fetch() request body for the wire: text as-is, and an ArrayBuffer or
 // any view as its bytes (one char per byte) flagged bodyBinary, instead of
 // String(view), which sent "0,1,2,...".
+// A body stream the runtime made over a value (Response/Request body): that value. Bindings
+// that take a body at once (R2 and KV put, outbound fetch) read it without draining the
+// stream, so put(key, request.body) works as in Workers. Other values pass through.
+function __sbUnwrapBody(value) {
+  return value != null && value._sbBody !== undefined ? value._sbBody : value;
+}
 function __sbRequestBody(body) {
+  body = __sbUnwrapBody(body);
   if (body == null) return { body: null };
   if (!__sbIsStr(body) && body.byteLength !== undefined) {
     const bytes = body.buffer !== undefined ? new Uint8Array(body.buffer, body.byteOffset, body.byteLength) : body;
@@ -4966,6 +4973,7 @@ globalThis.__sbInstallBindings = function (target, bindings) {
         return type === "json" ? JSON.parse(text) : text;
       },
       put(key, value, options) {
+        value = __sbUnwrapBody(value);
         const msg = { ns, key: String(key), value: "" };
         if (value != null && !__sbIsStr(value) && value.byteLength !== undefined) {
           // ArrayBuffer or any ArrayBufferView: its bytes, not String(view) ("0,1,2,...").
@@ -5011,12 +5019,15 @@ globalThis.__sbInstallBindings = function (target, bindings) {
     const name = bindings.r2[i];
     target[name] = {
       put(key, value, options) {
+        value = __sbUnwrapBody(value);
         const o = options || {};
         // #56 — the body goes out of band where the transport allows it.
+        // Bytes go in as bytes: a byte view or the bytes of a body stream (request.body).
+        const raw = value == null ? "" : !__sbIsStr(value) && value.byteLength !== undefined ? __sbToBytes(value.buffer !== undefined ? new Uint8Array(value.buffer, value.byteOffset, value.byteLength) : value) : String(value);
         return __sbR2Put(
           name,
           String(key),
-          value == null ? "" : String(value),
+          raw,
           o.httpMetadata || {},
           o.customMetadata || {},
         ).object;
@@ -5189,7 +5200,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 +5232,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 +5658,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 +5714,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 +5750,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,8 +5811,10 @@ 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;
+  // Raw bytes, one character each: arrayBuffer(), blob() and body read them as bytes.
+  request._bodyLatin1 = true;
   let decoded = null;
   request.text = function () {
     if (decoded === null) decoded = __sbFromUtf8(raw);
@@ -5986,7 +6005,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") { const viaStream = await new Response(request.body).text(); return new Response((request.body instanceof ReadableStream) + ":" + viaStream); }
   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);

package/test/native-utf8.ts

@@ -17,7 +17,14 @@ const text = "/café/日本/😀/x";
 const handler = `
 const URL = "shadowed";
 export default {
-  async fetch() {
+  async fetch(request) {
+    // put(key, request.body) and fetch(url, { body: request.body }) are the Workers idiom:
+    // body is a ReadableStream, and the bindings take the value it was made from.
+    if (request.method === "POST") {
+      env.UPLOADS.put("upload", request.body);
+      await env.KV.put("upload", request.body);
+      return Response.json({ r2: env.UPLOADS.get("upload").text(), kv: await env.KV.get("upload") });
+    }
     await env.KV.put("k", ${JSON.stringify(text)});
     const kv = await env.KV.get("k");
     await env.DB.prepare("CREATE TABLE t (v TEXT)").run();
@@ -38,7 +45,7 @@ function freePort(): number {
 }
 
 const workdir = await mkdtemp(join(tmpdir(), "sb-native-utf8-"));
-const bindings = { ...EMPTY_BINDINGS, kv: ["KV"], d1: ["DB"] };
+const bindings = { ...EMPTY_BINDINGS, kv: ["KV"], d1: ["DB"], r2: ["UPLOADS"] };
 const broker = createBroker({
   db: ":memory:",
   token: "native-utf8",
@@ -113,7 +120,9 @@ try {
   );
   assert.match(body.error, /tabellà/);
   assert.equal(body.url, "shadowed");
-  console.log("Non-ASCII KV, D1 and error text round-trip through the broker; a handler-level URL stays scoped");
+  const stored = await (await fetch(`http://127.0.0.1:${port}/`, { method: "POST", body: "uploaded é" })).json();
+  assert.deepEqual(stored, { r2: "uploaded é", kv: "uploaded é" }, "put(key, request.body) stores the request body");
+  console.log("Non-ASCII KV, D1 and error text round-trip through the broker; a handler-level URL stays scoped; put(key, request.body) stores the body");
 } finally {
   if (server) {
     server.kill(9);