@sproutboat/runtime 0.19.0 → 0.19.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @sproutboat/runtime
 
+## 0.19.2
+
+### Patch Changes
+
+- bc3fd25: `Response.body` and `Request.body` are `ReadableStream`s only from compatibility date `2026-10-21`. 0.19.0 changed this for every app, which broke handlers that read `request.body` as a string, such as `JSON.parse(request.body)` in the CLI's own D1 example. An app with an earlier `compatibility_date` keeps the raw body, as before. To opt in, move `compatibility_date` to `2026-10-21` or later and rebuild.
+
+## 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

package/WEB_STREAMS.md

@@ -20,8 +20,10 @@ 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. `body` is a ReadableStream for every body type,
-as in Fetch: a stream body itself, otherwise a stream made once over the bytes.
+their chunks must be bytes, as in workerd. From compatibility date 2026-10-21, `body` is a
+ReadableStream for every body type, as in Fetch: a stream body itself, otherwise a stream made
+once over the bytes. Before that date it is the value as given, as apps written for earlier
+releases read it (`JSON.parse(request.body)`).
 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.19.0",
+  "version": "0.19.2",
   "license": "MIT",
   "type": "module",
   "repository": {

package/src/native-fetch-prelude.js

@@ -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;
@@ -5802,6 +5813,8 @@ async function __sbQueueWithDrain(result, tasks) {
 function __sbDecodeIngress(request) {
   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);

package/test/native-bodies.ts

@@ -92,7 +92,7 @@ try {
   const prelude = core.replace(TRANSPORT_MARKER, broker);
   const generated = join(workdir, "bodies.generated.js");
   const binary = join(workdir, "bodies-native");
-  await writeFile(generated, wrapNativeFetchHandler(handler, prelude, undefined, undefined, undefined, "2026-10-01"));
+  await writeFile(generated, wrapNativeFetchHandler(handler, prelude, undefined, undefined, undefined, "2026-10-21"));
   await rm(binary, { force: true });
 
   const compile = Bun.spawn([node, resolve(porffor, "runtime/index.js"), "native", generated, "-o", binary, "-s", "-O0"], {

package/test/native-request.ts

@@ -19,8 +19,9 @@ const CASES = [
   `new Request("http://a.test/x", { method: "post" }).method`,
 ];
 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()));
+  // Before compatibility date 2026-10-21 (this build has the baseline date) the incoming body is
+  // the raw value, as apps written against earlier releases read it; text() decodes it.
+  if (request.method === "POST") return new Response((request.body instanceof ReadableStream) + ":" + (typeof request.body) + ":" + (await request.text()));
   const cases = [
 ${CASES.map((c) => `    () => (${c}),`).join("\n")}
   ];
@@ -94,8 +95,8 @@ try {
   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")}`);
   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`);
+  assert.equal(posted, "false:string:posted é", "before 2026-10-21 the incoming body stays the raw value");
+  console.log(`Native Request copies match Bun in all ${CASES.length} cases; an app before 2026-10-21 keeps its raw body`);
 } 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"), stream: await new Response(request.body).text() });
+    }
     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",
@@ -58,7 +65,7 @@ try {
   assert(core.includes(TRANSPORT_MARKER), "runtime prelude is missing its transport marker");
   const generated = join(workdir, "utf8.generated.js");
   const binary = join(workdir, "utf8-native");
-  await writeFile(generated, wrapNativeFetchHandler(handler, core.replace(TRANSPORT_MARKER, transport), {}, bindings));
+  await writeFile(generated, wrapNativeFetchHandler(handler, core.replace(TRANSPORT_MARKER, transport), {}, bindings, undefined, "2026-10-21"));
 
   const compile = Bun.spawn([node, resolve(porffor, "runtime/index.js"), "native", generated, "-o", binary, "-s", "-O0"], {
     cwd: workdir,
@@ -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 é", stream: "uploaded é" }, "put(key, request.body) stores the request body, and body reads as UTF-8");
+  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);