@sproutboat/runtime 0.27.0 → 0.28.0

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # @sproutboat/runtime
 
+## 0.28.0
+
+### Minor Changes
+
+- 829ed12: Request bodies stream, from compatibility date `2026-10-27`, as in workerd:
+  
+  - **Ingress.** The native server runs the handler as soon as a request's headers arrive. `request.body` hands out the bytes as they come in, and the server pauses the socket while more than 1 MiB waits unread, so a large upload read through the stream keeps memory flat (a 128 MiB upload peaks at 38 MiB RSS). `text()`, `json()`, `arrayBuffer()` and `bytes()` read the whole body and return Promises.
+  - **Limit.** `SB_REQUEST_BODY_MAX` defaults to 100 MiB for streamed bodies (it stays 1 MiB before the date, where the body is held in memory whole). A larger `Content-Length` gets `413 Payload Too Large` before the handler runs; a chunked body that grows past it closes the connection, and the handler's stream fails.
+  - **Service bindings and `fetch()`.** On the broker transport, a `ReadableStream` request body goes out as it is read, in `FRAME_V1_MORE` frames after the request's head, instead of being read to the end first. The broker feeds them to the upstream request as a stream (with backpressure) and says so in its `ping` reply (`bodyStream: true`); against an older broker, bodies are sent whole as before. A streamed body can't follow a 307 or 308 redirect.
+  
+  Internal trigger and RPC calls keep buffered bodies. Before `2026-10-27` nothing changes: the handler gets the whole body at once and `request.text()` answers synchronously, which a deployed handler may rely on, hence the new date.
+
+## 0.27.1
+
+### Patch Changes
+
+- 0d2d079: Bodies of megabytes no longer take hundreds of megabytes of memory (sproutd #22). Converting bytes to text and text to bytes made one string per character, so reading a 5 MiB R2 object with `text()` peaked at about 400 MiB, and R2 multipart uploads with real (5 MiB) parts ran sproutd's workers out of memory. The conversions now run in one C pass and give exactly the same results. On a standalone build, at 5 MiB:
+  
+  | | before | after |
+  |---|---|---|
+  | `put()` of a string | 82 MiB | 16 MiB |
+  | `put()` then `get()` and `text()` | 400 MiB | 26 MiB |
+  | multipart upload, then `get()` and `text()` | 396 MiB | 21 MiB |
+  | `request.text()` of the request body | 402 MiB | 24 MiB |
+  
+  Also:
+  
+  - At every date, `uploadPart()` stores an `ArrayBuffer` or a typed array as its bytes. It stored the text `[object ArrayBuffer]`.
+  - From `2026-10-26`, `uploadPart()` takes what `put()` takes (a `ReadableStream` or a `Blob` too), and stores text as its UTF-8 bytes, as in workerd. It stored text whose characters all fit in one byte as Latin-1.
+  - From `2026-10-26`, an R2 object body's `body` stream is made when first read, and a whole-object `get()` keeps one copy of the bytes, not two.
+
 ## 0.27.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/runtime",
-  "version": "0.27.0",
+  "version": "0.28.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/ingress-utf8.test.js

@@ -2,17 +2,15 @@ import { expect, test } from "bun:test";
 import { readFileSync } from "node:fs";
 const src = readFileSync(new URL("./native-fetch-prelude.js", import.meta.url), "utf8");
 const decoder = src.slice(src.indexOf("function __sbFromUtf8("), src.indexOf("// sproutboat #181"));
-const ingress = src.slice(
-  src.indexOf("function __sbDecodeIngress("),
-  src.indexOf("globalThis.__sbEntry ="),
-);
+const ingress = src.slice(src.indexOf("function __sbDecodeIngress("), src.indexOf("globalThis.__sbEntry ="));
 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${rawBody}\n${ingress}\nreturn __sbDecodeIngress;`);
+const load = new Function(
+  `// The C fast paths (Porffor.c) cannot run here: the stubs make the JS fallback run.\nfunction __sbFromUtf8Native() { return ""; }\nfunction __sbToBytesNative() { return ""; }\n${decoder}\n${rawBody}\n${ingress}\nreturn __sbDecodeIngress;`,
+);
 const decode = load();
-const raw = (text) =>
-  Array.from(new TextEncoder().encode(text), (byte) => String.fromCharCode(byte)).join("");
+const raw = (text) => Array.from(new TextEncoder().encode(text), (byte) => String.fromCharCode(byte)).join("");
 
 test("native ingress text and JSON decode Unicode without changing raw bytes", async () => {
   const body = raw('{"id":"caffè-🚤"}');

package/src/native-fetch-prelude.js

@@ -3034,7 +3034,10 @@ if (globalThis.clearInterval == null) globalThis.clearInterval = clearInterval;
 // these express the same spec-mandated checks and are verified under Porffor
 // alpha-10 by examples/kitchen-sink/harness.ts).
 function __sbIsStr(v) {
-  return Object(v) !== v && v === String(v);
+  // sproutd #22: not `Object(v) !== v`, which wraps (copies) a string in Porffor: two such
+  // checks on a 5 MiB part took 20 MiB.
+  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- the one check that does not copy its argument
+  return typeof v === "string";
 }
 function __sbIsFn(v) {
   return v instanceof Function;
@@ -3936,6 +3939,9 @@ const __SB_BYTES_WINDOW = 512;
 // TextEncoder); ArrayBuffer / typed-array input is copied byte for byte.
 function __sbToBytes(input) {
   if (input == null) return "";
+  // sproutd #22: one C pass when the input allows it (see __sbToBytesNative).
+  const native = __sbToBytesNative(input);
+  if (native !== "") return native;
   // Windowed accumulation (#180, then #181). Plain `s +=` in a loop is O(n^2)
   // here, since Porffor's strings have no rope/cons optimization and every
   // append copies the whole accumulated string -- that's #180, a 43KB body
@@ -4015,6 +4021,9 @@ function __sbBufFrom(latin1) {
 // regardless of whether it holds real Latin-1 text or raw bytes, so this
 // decode is only safe where the caller already knows which one it has.
 function __sbFromUtf8(bytes) {
+  // sproutd #22: one C pass for a string of bytes (see __sbFromUtf8Native).
+  const native = __sbFromUtf8Native(bytes);
+  if (native !== "") return native;
   // Collected into an array and joined once at the end, not built with
   // repeated `out +=` -- Porffor's strings have no rope/cons optimization, so
   // `+=` in a loop copies the whole accumulated string on every append,
@@ -4672,8 +4681,168 @@ static int sb_os_random(unsigned char* buf, size_t n) {
   return 0;
 }
 
+// sproutd #22: text and bytes converted in one C pass. The JS loops in
+// __sbFromUtf8 and __sbToBytes made one string per character, so a 5 MiB R2
+// object read with text() took about 400 MiB of heap before the next collection.
+u32 porf_native_fetch_alloc(u32 bytes, u32 type);
+
+// Lenient UTF-8 decode, exactly as __sbFromUtf8's JS: a lead byte whose
+// continuation bytes are not all 10xxxxxx passes through as its own unit.
+// OUT has room for LEN units. Returns the unit count; *WIDE is set when a unit
+// is above 0xff (the result then needs a UTF-16 string).
+static size_t sb_utf8_decode_units(const unsigned char* b, size_t len, uint16_t* out, int* wide) {
+  size_t k = 0;
+  *wide = 0;
+  for (size_t i = 0; i < len; i++) {
+    const unsigned b0 = b[i];
+    if (b0 >= 0x80) {
+      if ((b0 & 0xe0) == 0xc0 && i + 1 < len && (b[i + 1] & 0xc0) == 0x80) {
+        out[k] = (uint16_t)(((b0 & 0x1f) << 6) | (b[i + 1] & 0x3f));
+        if (out[k] > 0xff) *wide = 1;
+        k++; i += 1; continue;
+      }
+      if ((b0 & 0xf0) == 0xe0 && i + 2 < len && (b[i + 1] & 0xc0) == 0x80 && (b[i + 2] & 0xc0) == 0x80) {
+        out[k] = (uint16_t)(((b0 & 0x0f) << 12) | ((b[i + 1] & 0x3f) << 6) | (b[i + 2] & 0x3f));
+        if (out[k] > 0xff) *wide = 1;
+        k++; i += 2; continue;
+      }
+      if ((b0 & 0xf8) == 0xf0 && i + 3 < len && (b[i + 1] & 0xc0) == 0x80 && (b[i + 2] & 0xc0) == 0x80 && (b[i + 3] & 0xc0) == 0x80) {
+        int32_t cp = (int32_t)(((b0 & 0x07) << 18) | ((b[i + 1] & 0x3f) << 12) | ((b[i + 2] & 0x3f) << 6) | (b[i + 3] & 0x3f));
+        cp -= 0x10000;
+        out[k++] = (uint16_t)(0xd800 + (cp >> 10));
+        out[k++] = (uint16_t)(0xdc00 + (cp & 0x3ff));
+        *wide = 1;
+        i += 3; continue;
+      }
+    }
+    out[k++] = (uint16_t)b0;
+  }
+  return k;
+}
+
+// UTF-8 encode, exactly as __sbToBytes's JS: a high surrogate takes the next
+// unit as its pair. OUT has room for 3 bytes per unit. Returns the byte count.
+static size_t sb_utf8_encode_units(const uint16_t* s, size_t len, unsigned char* out) {
+  size_t k = 0;
+  for (size_t i = 0; i < len; i++) {
+    const uint32_t c = s[i];
+    if (c < 0x80) out[k++] = (unsigned char)c;
+    else if (c < 0x800) { out[k++] = (unsigned char)(0xc0 | (c >> 6)); out[k++] = (unsigned char)(0x80 | (c & 0x3f)); }
+    else if (c >= 0xd800 && c < 0xdc00 && i + 1 < len) {
+      const int32_t cp = 0x10000 + (int32_t)((c - 0xd800) << 10) + ((int32_t)s[++i] - 0xdc00);
+      out[k++] = (unsigned char)(0xf0 | ((cp >> 18) & 0xff));
+      out[k++] = (unsigned char)(0x80 | ((cp >> 12) & 0x3f));
+      out[k++] = (unsigned char)(0x80 | ((cp >> 6) & 0x3f));
+      out[k++] = (unsigned char)(0x80 | (cp & 0x3f));
+    } else {
+      out[k++] = (unsigned char)(0xe0 | ((c >> 12) & 0xff));
+      out[k++] = (unsigned char)(0x80 | ((c >> 6) & 0x3f));
+      out[k++] = (unsigned char)(0x80 | (c & 0x3f));
+    }
+  }
+  return k;
+}
+
 `;
 
+// sproutd #22: __sbFromUtf8 for a string of bytes (one byte per unit) or a Uint8Array, in C.
+// Returns "" when it cannot (not a string, or out of memory), so the caller
+// falls back to the JS loop. All-ASCII byte strings are already their text.
+// oxlint-disable-next-line no-unused-vars -- `bytes` is read inside the RawC block below, not by JS.
+function __sbFromUtf8Native(bytes) {
+  let out = "";
+  // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
+  Porffor.c`
+    const int __view = bytes.type == 81 && *(int32_t*)(MEM + (u32)bytes.val) >= 0;
+    if (bytes.type == 195 || bytes.type == 67 || __view) {
+      const u32 __p = __view ? *(u32*)(MEM + (u32)bytes.val + 4) : (u32)bytes.val;
+      const size_t __n = __view ? (size_t)*(int32_t*)(MEM + (u32)bytes.val) : (size_t)*(u32*)(MEM + __p);
+      int __ascii = bytes.type == 195;
+      if (__ascii) {
+        const unsigned char* __s = (const unsigned char*)(MEM + __p + 4);
+        for (size_t __i = 0; __i < __n; __i++) if (__s[__i] >= 0x80) { __ascii = 0; break; }
+      }
+      if (__ascii) out = bytes;
+      else {
+        unsigned char* __b = (unsigned char*)malloc(__n + 1);
+        uint16_t* __u = (uint16_t*)malloc(__n * 2 + 2);
+        if (__b && __u) {
+          if (bytes.type != 67) memcpy(__b, MEM + __p + 4, __n);
+          else { const uint16_t* __w = (const uint16_t*)(MEM + __p + 4); for (size_t __i = 0; __i < __n; __i++) __b[__i] = (unsigned char)(__w[__i] & 0xff); }
+          int __wide = 0;
+          const size_t __k = sb_utf8_decode_units(__b, __n, __u, &__wide);
+          if (__wide) {
+            const u32 __s = porf_native_fetch_alloc((u32)(4 + __k * 2), 67);
+            *(u32*)(MEM + __s) = (u32)__k;
+            memcpy(MEM + __s + 4, __u, __k * 2);
+            out = porf_box((f64)__s, 67);
+          } else {
+            for (size_t __i = 0; __i < __k; __i++) __b[__i] = (unsigned char)__u[__i];
+            out = porf_box((f64)porf_native_fetch_alloc_bytestring((const char*)__b, __k), 195);
+          }
+        }
+        free(__b); free(__u);
+      }
+    }
+  `;
+  return out;
+}
+
+// sproutd #22: __sbToBytes for a string, a Uint8Array or an ArrayBuffer, in C.
+// Returns "" when it cannot (another type, a length-tracking view, out of
+// memory), so the caller falls back to the JS loop.
+// oxlint-disable-next-line no-unused-vars -- `input` is read inside the RawC block below, not by JS.
+function __sbToBytesNative(input) {
+  let out = "";
+  // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
+  Porffor.c`
+    const u32 __p = (u32)input.val;
+    if (input.type == 195) {
+      const size_t __n = (size_t)*(u32*)(MEM + __p);
+      const unsigned char* __s = (const unsigned char*)(MEM + __p + 4);
+      size_t __high = 0;
+      for (size_t __i = 0; __i < __n; __i++) if (__s[__i] >= 0x80) __high++;
+      if (!__high) out = input;
+      else {
+        unsigned char* __o = (unsigned char*)malloc(__n + __high + 1);
+        if (__o) {
+          const unsigned char* __src = (const unsigned char*)(MEM + __p + 4);
+          size_t __k = 0;
+          for (size_t __i = 0; __i < __n; __i++) {
+            const unsigned char __c = __src[__i];
+            if (__c < 0x80) __o[__k++] = __c;
+            else { __o[__k++] = (unsigned char)(0xc0 | (__c >> 6)); __o[__k++] = (unsigned char)(0x80 | (__c & 0x3f)); }
+          }
+          out = porf_box((f64)porf_native_fetch_alloc_bytestring((const char*)__o, __k), 195);
+          free(__o);
+        }
+      }
+    } else if (input.type == 67) {
+      const size_t __n = (size_t)*(u32*)(MEM + __p);
+      uint16_t* __w = (uint16_t*)malloc(__n * 2 + 2);
+      unsigned char* __o = (unsigned char*)malloc(__n * 3 + 1);
+      if (__w && __o) {
+        memcpy(__w, MEM + __p + 4, __n * 2);
+        const size_t __k = sb_utf8_encode_units(__w, __n, __o);
+        out = porf_box((f64)porf_native_fetch_alloc_bytestring((const char*)__o, __k), 195);
+      }
+      free(__w); free(__o);
+    } else if (input.type == 13 || input.type == 81) {
+      const int32_t __len = *(int32_t*)(MEM + __p);
+      if (__len > 0) {
+        const u32 __data = input.type == 13 ? __p + 8 : *(u32*)(MEM + __p + 4) + 4;
+        unsigned char* __o = (unsigned char*)malloc((size_t)__len);
+        if (__o) {
+          memcpy(__o, MEM + __data, (size_t)__len);
+          out = porf_box((f64)porf_native_fetch_alloc_bytestring((const char*)__o, (size_t)__len), 195);
+          free(__o);
+        }
+      }
+    }
+  `;
+  return out;
+}
+
 // TRANSPORT: wrap.ts splices one of transport-broker.js / transport-embedded.js here.
 
 // `nStr` is the decimal byte count as a string (same string-param pattern as
@@ -5218,6 +5387,15 @@ function __sbR2Object(meta, body) {
   return obj;
 }
 
+// A part's value for the transport: an ArrayBuffer or a view as its bytes (String() of one
+// stored "[object ArrayBuffer]", at every date), anything else as text, as before.
+function __sbR2PartValue(value) {
+  value = __sbUnwrapBody(value);
+  if (value == null) return "";
+  if (!__sbIsStr(value) && value.byteLength !== undefined)
+    return __sbToBytes(value.buffer !== undefined ? new Uint8Array(value.buffer, value.byteOffset, value.byteLength) : new Uint8Array(value));
+  return String(value);
+}
 function __sbR2Multipart(bucket, key, uploadId) {
   return {
     key,
@@ -5226,7 +5404,7 @@ function __sbR2Multipart(bucket, key, uploadId) {
       const number = Number(partNumber);
       if (!Number.isInteger(number) || number < 1 || number > 10000)
         throw new TypeError("partNumber must be an integer between 1 and 10000");
-      return __sbR2MultipartPut(bucket, key, uploadId, number, value == null ? "" : String(value)).part;
+      return __sbR2MultipartPut(bucket, key, uploadId, number, __sbR2PartValue(value)).part;
     },
     complete(parts) {
       const r = __sbRpc("r2.multipart.complete", { bucket, key, uploadId, parts: parts || [] });
@@ -5361,7 +5539,16 @@ function __sbR2StrictObject(meta, bytes, range, include) {
     used = true;
     return bytes;
   };
-  obj.body = new Response(__sbBufFrom(bytes)).body;
+  // The stream is made when first asked for: text() and friends read the bytes directly,
+  // so an object read as text never holds a second copy (sproutd #22).
+  let stream = null;
+  Object.defineProperty(obj, "body", {
+    get: () => {
+      if (stream === null) stream = new Response(__sbBufFrom(bytes)).body;
+      return stream;
+    },
+    enumerable: true,
+  });
   Object.defineProperty(obj, "bodyUsed", { get: () => used, enumerable: true });
   obj.text = async () => __sbFromUtf8(take());
   obj.json = async () => JSON.parse(__sbFromUtf8(take()));
@@ -5392,7 +5579,13 @@ function __sbMakeR2(name) {
     return {
       key,
       uploadId,
-      uploadPart: (partNumber, value) => attempt(() => inner.uploadPart(partNumber, value)),
+      // A part is any value put() takes; text is stored as its UTF-8 bytes, as in workerd.
+      uploadPart: async (partNumber, value) => {
+        value = __sbUnwrapBody(value);
+        if (value instanceof Blob) value = await value.arrayBuffer();
+        else if (value != null && __sbIsFn(value.getReader)) value = await new Response(value).arrayBuffer();
+        return inner.uploadPart(partNumber, __sbIsStr(value) ? __sbToBytes(value) : value);
+      },
       // ponytail: a multipart object's etag stays the transport's sha256; workerd's is
       // MD5-of-part-MD5s-N. Add when an app compares multipart etags.
       complete: (parts) => attempt(() => __sbR2StrictObject(__sbRpc("r2.multipart.complete", { bucket: name, key, uploadId, parts: parts || [] }).object, null)),
@@ -5415,7 +5608,8 @@ function __sbMakeR2(name) {
         if (!__sbR2OnlyIf(o.onlyIf, meta.md5 || meta.etag, meta.uploaded)) return __sbR2StrictObject(meta, null, { offset: 0, length: meta.size });
         const bytes = r.body == null ? "" : r.body;
         const range = o.range == null ? { offset: 0, length: meta.size } : __sbR2Range(o.range, meta.size);
-        return __sbR2StrictObject(meta, bytes.slice(range.offset, range.offset + range.length), range);
+        const whole = range.offset === 0 && range.length >= bytes.length;
+        return __sbR2StrictObject(meta, whole ? bytes : bytes.slice(range.offset, range.offset + range.length), range);
       });
     },
     async put(key, value, options) {
@@ -5817,9 +6011,14 @@ globalThis.__sbInstallBindings = function (target, bindings) {
 async function __sbServiceFetch(binding, input, init) {
   const parts = __sbFetchParts(input, init);
   if (parts.signal) parts.signal.throwIfAborted();
-  // A stream body is read to the end first: the wire carries a whole body.
+  // A stream body goes out as it is read where the transport can (__sbStreamsBody), else it
+  // is read to the end first.
   const body = __sbUnwrapBody(parts.body);
-  const wire = body instanceof ReadableStream ? __sbRequestBody(await __sbCollectBody(body)) : __sbPartsBody({ ...parts, body });
+  const wire = __sbStreamsBody(body)
+    ? { bodyStream: true, __sbBodySource: body }
+    : body instanceof ReadableStream
+      ? __sbRequestBody(await __sbCollectBody(body))
+      : __sbPartsBody({ ...parts, body });
   const msg = { binding, url: parts.url, method: parts.method, headers: parts.headers, ...wire };
   const response = await __sbFetchFollowing("service.fetch", msg, "sproutboat service " + binding, parts.redirect, parts.signal);
   // The callee threw: as in workerd, its error is thrown here.
@@ -6077,7 +6276,52 @@ function __sbUpstreamResponse(r) {
 // whole (a broker from before streaming, or sproutd's embedded transport) is handled
 // as before. Cancelling the body, or the signal, drops the exchange, which stops the
 // upstream request.
+// Streamed request bodies, from compatibility date 2026-10-27, on a transport that sends
+// them in frames (the broker's, on an async host, against a broker that takes them):
+// fetch() and service bindings send a ReadableStream body as it is read, instead of
+// reading it to the end first. As in workerd, a streamed body can't follow a 307 or 308.
+function __sbStreamsBody(body) {
+  return (
+    body instanceof ReadableStream &&
+    globalThis.__sbCompat >= "2026-10-27" &&
+    globalThis.__sbBodyStreamable != null &&
+    globalThis.__sbBodyStreamable()
+  );
+}
+// Reads source into the exchange under timer id `id`, a frame per chunk, while ended()
+// is false. Above 4 MiB not yet written it waits for the socket to catch up.
+async function __sbPumpRequestBody(id, source, ended) {
+  const reader = source.getReader();
+  try {
+    for (;;) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      if (ended()) {
+        reader.cancel();
+        return;
+      }
+      let bytes = null;
+      if (value instanceof Uint8Array) bytes = value;
+      else if (value instanceof ArrayBuffer) bytes = new Uint8Array(value);
+      else if (ArrayBuffer.isView(value)) bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+      else throw new TypeError("This ReadableStream did not return bytes.");
+      if (bytes.length === 0) continue;
+      let backlog = Number(globalThis.__sbAsyncBody(id, "c", __sbToBytes(bytes)));
+      while (backlog > 4 * 1024 * 1024 && !ended()) {
+        await new Promise((resolve) => setTimeout(resolve, 2));
+        backlog = Number(globalThis.__sbAsyncBody(id, "q", ""));
+      }
+    }
+    globalThis.__sbAsyncBody(id, "e", "");
+  } catch (error) {
+    globalThis.__sbAsyncBody(id, "x", "");
+    __sbLogUncaught("fetch", error);
+  }
+}
+
 function __sbUpstreamStreamed(op, msg, label, signal) {
+  const source = msg.__sbBodySource;
+  if (source !== undefined) delete msg.__sbBodySource;
   return new Promise((resolve, reject) => {
     let controller = null;
     let onAbort = null;
@@ -6145,6 +6389,7 @@ function __sbUpstreamStreamed(op, msg, label, signal) {
       msg.asyncId = id;
       msg.stream = true;
       globalThis.__sbFetchUpstream(op, msg);
+      if (source !== undefined) __sbPumpRequestBody(id, source, () => done);
     } catch (e) {
       finish();
       reject(e);
@@ -6182,7 +6427,8 @@ function __sbFollowHop(op, msg, label, mode, signal, hops) {
       next.method = "GET";
       next.body = null;
       delete next.bodyBinary;
-    }
+      delete next.bodyStream;
+    } else if (msg.bodyStream === true) throw new TypeError(label + ": a streamed request body can't follow a " + res.status + " redirect");
     return __sbFollowHop(op, next, label, mode, signal, hops + 1);
   };
   const out = __sbUpstream(op, msg, label, signal);
@@ -6242,6 +6488,7 @@ function __sbUpstream(op, msg, label, signal, always) {
 // Worker's fetch. Installed by the generated module (wrap.ts), not here: the
 // prelude must not replace fetch just by being evaluated.
 globalThis.__sbInstallFetch = function () {
+  __sbIngressStreamingSetup();
   globalThis.fetch = function (input, init) {
     let parts;
     try {
@@ -6255,9 +6502,11 @@ globalThis.__sbInstallFetch = function () {
       const msg = { url: parts.url, method: parts.method, headers: parts.headers, ...body };
       return __sbFetchFollowing("fetch", msg, "sproutboat fetch", parts.redirect, parts.signal);
     };
-    // A stream body is read to the end first, as for a service binding: the wire carries a
-    // whole body. It was sent as the text "[object ReadableStream]".
+    // A stream body goes out as it is read, from 2026-10-27 where the transport can
+    // (__sbStreamsBody); else it is read to the end first. It was sent as the text
+    // "[object ReadableStream]".
     const stream = __sbUnwrapBody(parts.body);
+    if (__sbStreamsBody(stream)) return send({ bodyStream: true, __sbBodySource: stream });
     if (stream instanceof ReadableStream) return __sbCollectBody(stream).then((bytes) => send(__sbRequestBody(bytes)));
     return send(__sbPartsBody(parts));
   };
@@ -6838,11 +7087,133 @@ async function __sbQueueWithDrain(result, tasks) {
   return new Response(JSON.stringify(r), { headers: { "content-type": "application/json" } });
 }
 
+// Streamed request bodies, from compatibility date 2026-10-27, on a native server that
+// streams them (a standalone or platform sprout; request-streaming.ts in the toolchain).
+// The handler runs once the headers are in, and request.body hands out the bytes as they
+// arrive: the server pauses the socket while more than 1 MiB waits unread. Before that
+// date the server buffers the whole body and the handler gets it at once, as before.
+// op: "e" enable (at startup), "t" take the current request's body id, "p" poll (a byte
+// count, "0" nothing yet, "-1" ended, "-2" failed), "i" copy into the Uint8Array in data,
+// "w" wait on the timer id in data, "c" close. Returns a short string.
+// oxlint-disable-next-line no-unused-vars -- read inside the RawC block, not by JS.
+function __sbReqBodyOp(op, id, data) {
+  let out = "";
+  // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
+  Porffor.c`
+    extern int sb_reqbody_enable(void);
+    extern unsigned int sb_reqbody_take_current(void);
+    extern long long sb_reqbody_poll(unsigned int);
+    extern size_t sb_reqbody_take(unsigned int, char*, size_t);
+    extern void sb_reqbody_wait(unsigned int, unsigned int);
+    extern void sb_reqbody_close(unsigned int);
+    const char* __o; size_t __ol; char* __oo = 0;
+    porf_native_fetch_read_value(op, &__o, &__ol, &__oo);
+    char __op = __ol ? __o[0] : 0;
+    if (__oo) free(__oo);
+    const unsigned int __id = id.type == 1 && id.val > 0 ? (unsigned int)id.val : 0;
+    char __r[32]; __r[0] = 0;
+    if (__op == 'e') snprintf(__r, sizeof(__r), "%d", sb_reqbody_enable());
+    else if (__op == 't') snprintf(__r, sizeof(__r), "%u", sb_reqbody_take_current());
+    else if (__op == 'p') snprintf(__r, sizeof(__r), "%lld", sb_reqbody_poll(__id));
+    else if (__op == 'i' && data.type == 81) {
+      const u32 __ta = (u32)data.val;
+      const int32_t __len = *(int32_t*)(MEM + __ta);
+      if (__len > 0) {
+        const u32 __at = *(u32*)(MEM + __ta + 4) + 4;
+        snprintf(__r, sizeof(__r), "%zu", sb_reqbody_take(__id, (char*)(MEM + __at), (size_t)__len));
+      }
+    } else if (__op == 'w' && data.type == 1 && data.val > 0) sb_reqbody_wait(__id, (unsigned int)data.val);
+    else if (__op == 'c') sb_reqbody_close(__id);
+    out = porf_box((f64)porf_native_fetch_alloc_bytestring(__r, strlen(__r)), 195);
+  `;
+  return out;
+}
+
+// Turns streaming on in the native server, from 2026-10-27. Called once at startup, after
+// the compatibility date is set (__sbInstallFetch).
+function __sbIngressStreamingSetup() {
+  if (globalThis.__sbCompat >= "2026-10-27") __sbReqBodyOp("e", 0, "");
+}
+
+// request.body for a streamed request: chunks as the server receives them.
+function __sbIngressStream(request, id) {
+  let closed = false;
+  const close = () => {
+    if (!closed) {
+      closed = true;
+      __sbReqBodyOp("c", id, "");
+    }
+  };
+  const step = (controller, resolve) => {
+    const state = Number(__sbReqBodyOp("p", id, ""));
+    if (state === 0) {
+      // Nothing yet: the server fires this timer when bytes, the end or an error arrive.
+      const timer = setTimeout(() => step(controller, resolve), 2147483647);
+      __sbReqBodyOp("w", id, timer);
+      return;
+    }
+    if (state > 0) {
+      const chunk = new Uint8Array(state);
+      __sbReqBodyOp("i", id, chunk);
+      controller.enqueue(chunk);
+    } else {
+      close();
+      if (state === -1) controller.close();
+      else controller.error(new TypeError("Network connection lost."));
+    }
+    resolve();
+  };
+  const stream = new ReadableStream({
+    pull(controller) {
+      return new Promise((resolve) => step(controller, resolve));
+    },
+    cancel() {
+      close();
+    },
+  });
+  request.body = stream;
+  // The bytes of the whole body, read through the stream (so bodyUsed and locking hold).
+  const all = async () => {
+    const body = request.body;
+    if (request.bodyUsed) throw new TypeError("Body has already been used. It can only be used once. Use tee() first if you need to read it twice.");
+    request._bodyUsed = true;
+    const reader = body.getReader();
+    const chunks = [];
+    let size = 0;
+    for (;;) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+      size += value.length;
+    }
+    if (chunks.length === 1) return chunks[0];
+    const out = new Uint8Array(size);
+    let at = 0;
+    for (const chunk of chunks) {
+      out.set(chunk, at);
+      at += chunk.length;
+    }
+    return out;
+  };
+  request.text = async () => __sbFromUtf8(await all());
+  request.json = async () => JSON.parse(__sbFromUtf8(await all()));
+  request.arrayBuffer = async () => {
+    const bytes = await all();
+    return bytes.byteLength === bytes.buffer.byteLength ? bytes.buffer : bytes.slice().buffer;
+  };
+  request.bytes = async () => await all();
+}
+
 // Native HTTP ingress stores the body as one character per raw byte. Keep
 // that representation for binary consumers, but decode text lazily before
 // 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 streamed = globalThis.__sbCompat >= "2026-10-27" ? Number(__sbReqBodyOp("t", 0, "")) : 0;
+  if (streamed > 0) {
+    __sbIngressStream(request, streamed);
+    return;
+  }
   const raw = __sbRawBody(request);
   if (raw == null) return;
   // A GET or HEAD has no body, as in workerd (from 2026-10-23): request.body is null, and

package/src/r2-object.test.js

@@ -18,6 +18,9 @@ const rawStart = src.indexOf("function __sbRawBodyResponse(");
 const utf8End = rawStart;
 const rawEnd = src.indexOf("function __sbEqCt(");
 const r2Start = src.indexOf("function __sbR2Object(");
+const isStrStart = src.indexOf("function __sbIsStr(");
+const isStrEnd = src.indexOf("function __sbIsFn(");
+const bytesStart = src.indexOf("const __SB_BYTES_WINDOW");
 const r2End = src.indexOf("// Installed only when the project declares bindings.");
 if (utf8Start === -1 || utf8End === -1) throw new Error("__sbFromUtf8 block not found in prelude");
 if (rawStart === -1 || rawEnd === -1) throw new Error("__sbRawBodyResponse block not found in prelude");
@@ -27,7 +30,8 @@ if (r2Start === -1 || r2End === -1 || r2End < r2Start) throw new Error("__sbR2Ob
 const load = new Function(
   "__sbRpc",
   "__sbR2MultipartPut",
-  `${src.slice(utf8Start, utf8End)}\n${src.slice(rawStart, rawEnd)}\n${src.slice(r2Start, r2End)}\nreturn { __sbR2Object, __sbR2Multipart };`,
+  // __sbIsStr and __sbToBytes (for uploadPart's values), with the C fast paths stubbed out.
+  `function __sbFromUtf8Native() { return ""; }\nfunction __sbToBytesNative() { return ""; }\n${src.slice(isStrStart, isStrEnd)}\n${src.slice(bytesStart, utf8Start)}\n${src.slice(utf8Start, utf8End)}\n${src.slice(rawStart, rawEnd)}\n${src.slice(r2Start, r2End)}\nreturn { __sbR2Object, __sbR2Multipart };`,
 );
 const calls = [];
 const rpc = (op, value) => {
@@ -70,7 +74,7 @@ test("toResponse() lets caller-supplied headers/status override the defaults", (
   expect(resp.headers.get("content-type")).toBe("application/octet-stream");
 });
 
-test("toResponse() on an empty body still returns bytes, not the string \"\"", async () => {
+test('toResponse() on an empty body still returns bytes, not the string ""', async () => {
   const obj = __sbR2Object(meta, "");
   const resp = obj.toResponse();
   const buf = new Uint8Array(await resp.arrayBuffer());
@@ -84,9 +88,14 @@ test("multipart uploads expose the Cloudflare-shaped uploadPart, complete, and a
   expect(upload.uploadPart(1, "first")).toEqual({ partNumber: 1, etag: "part-1" });
   expect(upload.complete([{ partNumber: 1, etag: "part-1" }])).toMatchObject(meta);
   upload.abort();
-  expect(calls.map((call) => call.op)).toEqual([
-    "r2.multipart.put",
-    "r2.multipart.complete",
-    "r2.multipart.abort",
-  ]);
+  expect(calls.map((call) => call.op)).toEqual(["r2.multipart.put", "r2.multipart.complete", "r2.multipart.abort"]);
+});
+
+test("uploadPart stores an ArrayBuffer or a view as its bytes, not as [object ArrayBuffer]", () => {
+  calls.length = 0;
+  const upload = __sbR2Multipart("FILES", "archive.bin", "upload-1");
+  upload.uploadPart(1, new Uint8Array([0, 255, 65]).buffer);
+  upload.uploadPart(2, new Uint8Array([9, 8, 7, 6]).subarray(1, 3));
+  upload.uploadPart(3, "text");
+  expect(calls.map((call) => call.value.body)).toEqual(["\u0000ÿA", "\u0008\u0007", "text"]);
 });

package/src/to-bytes.test.js

@@ -22,7 +22,7 @@ if (hexStart === -1 || hexEnd === -1 || hexEnd < hexStart) throw new Error("__sb
 
 // oxlint-disable-next-line no-function-constructor -- lifting pure blocks out of the text-only prelude for test
 const load = new Function(
-  `${src.slice(isStrStart, isStrEnd)}\n${src.slice(start, end)}\n${src.slice(hexStart, hexEnd)}\nreturn { __sbToBytes, __sbHexOrBytes };`,
+  `// The C fast paths (Porffor.c) cannot run here: the stubs make the JS fallback run.\nfunction __sbFromUtf8Native() { return ""; }\nfunction __sbToBytesNative() { return ""; }\n${src.slice(isStrStart, isStrEnd)}\n${src.slice(start, end)}\n${src.slice(hexStart, hexEnd)}\nreturn { __sbToBytes, __sbHexOrBytes };`,
 );
 const { __sbToBytes, __sbHexOrBytes } = load();
 

package/src/transport-broker.js

@@ -335,6 +335,11 @@ typedef struct sb_async_job {
   int fd, reused, attempt, connecting;
   // Asked for a streamed response; and has delivered part of one, so never retried.
   int stream, delivered;
+  // Its request body follows the head in frames (sb_async_body), from compatibility date
+  // 2026-10-27: never retried, never pooled, and it reads replies while it still writes.
+  int body_stream;
+  // Bytes of body frames in out not yet written, counted in sb_async_body_backlog.
+  size_t body_unsent;
   long long retry_at;  // ms; 0 = not waiting to retry
   char* json; size_t json_len;
   char* bin; size_t bin_len;
@@ -357,6 +362,15 @@ static int sb_io_started = 0, sb_io_wake[2] = { -1, -1 };
 static u32* sb_async_cancels = 0;
 static size_t sb_async_cancels_n = 0, sb_async_cancels_cap = 0;
 static void (*sb_async_waker)(void) = 0;
+// Request-body frames from the loop (sb_async_body), for the I/O thread to append to
+// their exchanges; and the bytes of them not yet written, which the JS pump keeps low.
+typedef struct sb_async_bodyframe {
+  struct sb_async_bodyframe* next;
+  u32 id;
+  unsigned char* data; size_t len;
+} sb_async_bodyframe;
+static sb_async_bodyframe *sb_async_bodyq = 0, *sb_async_bodyq_tail = 0;
+static size_t sb_async_body_backlog = 0;
 
 void sb_async_set_waker(void (*wake)(void)) { sb_async_waker = wake; }
 int sb_async_enabled(void) { return sb_async_waker != 0; }
@@ -392,6 +406,11 @@ static void sb_async_deliver(u32 id, int final, char* json, size_t json_len, cha
 
 // Hands a finished job (json set) back to the loop, and frees it.
 static void sb_async_finish(sb_async_job* j) {
+  if (j->body_unsent) {
+    pthread_mutex_lock(&sb_async_lock);
+    sb_async_body_backlog -= j->body_unsent;
+    pthread_mutex_unlock(&sb_async_lock);
+  }
   sb_async_deliver(j->id, 1, j->json, j->json_len, j->bin, j->bin_len);
   free(j->out);
   free(j->in);
@@ -440,7 +459,7 @@ static void sb_io_begin(sb_async_job* j, int* idle, int* idle_n) {
 static int sb_io_failed(sb_async_job* j, int rc) {
   if (j->fd >= 0) { close(j->fd); j->fd = -1; }
   int unsent = j->out_off < j->out_len;
-  if (!j->delivered && (unsent || j->reused) && ++j->attempt < 4) {
+  if (!j->delivered && !j->body_stream && (unsent || j->reused) && ++j->attempt < 4) {
     static const long ms[4] = { 0, 5, 25, 100 };
     j->retry_at = sb_now_ms() + ms[j->attempt];
     return 0;
@@ -458,9 +477,26 @@ static int sb_io_step(sb_async_job* j, int* idle, int* idle_n) {
   }
   while (j->out_off < j->out_len) {
     long n = write(j->fd, j->out + j->out_off, j->out_len - j->out_off);
-    if (n > 0) { j->out_off += (size_t)n; continue; }
+    if (n > 0) {
+      j->out_off += (size_t)n;
+      if (j->body_stream) {
+        // Body bytes sit at the end of out: whatever is left unsent beyond them was the head.
+        size_t left = j->out_len - j->out_off;
+        if (left < j->body_unsent) {
+          pthread_mutex_lock(&sb_async_lock);
+          sb_async_body_backlog -= j->body_unsent - left;
+          pthread_mutex_unlock(&sb_async_lock);
+          j->body_unsent = left;
+        }
+      }
+      continue;
+    }
     if (n < 0 && errno == EINTR) continue;
-    if (n < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) return 0;
+    if (n < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
+      // A streamed body: the reply may come before the body is all out, so read too.
+      if (j->body_stream) break;
+      return 0;
+    }
     return sb_io_failed(j, -3);
   }
   for (;;) {
@@ -497,7 +533,8 @@ static int sb_io_step(sb_async_job* j, int* idle, int* idle_n) {
       sb_async_deliver(j->id, 0, json, json_len, bin, bin_len);
       continue;
     }
-    if (*idle_n < SB_IO_IDLE) idle[(*idle_n)++] = j->fd; else close(j->fd);
+    // A streamed body may still have frames on the way: that connection is not reused.
+    if (*idle_n < SB_IO_IDLE && !j->body_stream) idle[(*idle_n)++] = j->fd; else close(j->fd);
     j->fd = -1;
     j->json = sb_io_reply_json(payload, payload_len, &j->json_len, &j->bin, &j->bin_len);
     if (!j->json) sb_async_error(j, -4);
@@ -525,6 +562,35 @@ static void* sb_io_thread(void* unused) {
       j->next = active;
       active = j;
     }
+    // Request-body frames: appended to their exchanges (an ended one drops them).
+    pthread_mutex_lock(&sb_async_lock);
+    sb_async_bodyframe* frames = sb_async_bodyq;
+    sb_async_bodyq = sb_async_bodyq_tail = 0;
+    pthread_mutex_unlock(&sb_async_lock);
+    while (frames) {
+      sb_async_bodyframe* bf = frames;
+      frames = bf->next;
+      sb_async_job* j = active;
+      while (j && j->id != bf->id) j = j->next;
+      if (j && j->body_stream) {
+        if (j->out_off > 0) {
+          memmove(j->out, j->out + j->out_off, j->out_len - j->out_off);
+          j->out_len -= j->out_off;
+          j->out_off = 0;
+        }
+        j->out = (unsigned char*)realloc(j->out, j->out_len + bf->len);
+        if (!j->out) abort();
+        memcpy(j->out + j->out_len, bf->data, bf->len);
+        j->out_len += bf->len;
+        j->body_unsent += bf->len;
+      } else {
+        pthread_mutex_lock(&sb_async_lock);
+        sb_async_body_backlog -= bf->len;
+        pthread_mutex_unlock(&sb_async_lock);
+      }
+      free(bf->data);
+      free(bf);
+    }
     // Exchanges given up on: their connections close, which tells the broker to stop.
     pthread_mutex_lock(&sb_async_lock);
     u32* cancels = sb_async_cancels;
@@ -572,7 +638,9 @@ static void* sb_io_thread(void* unused) {
     for (sb_async_job* j = active; j; j = j->next) {
       if (j->retry_at) continue;
       fds[n].fd = j->fd;
-      fds[n].events = j->connecting || j->out_off < j->out_len ? POLLOUT : POLLIN;
+      fds[n].events = j->connecting ? POLLOUT
+        : j->body_stream ? (short)(POLLIN | (j->out_off < j->out_len ? POLLOUT : 0))
+        : j->out_off < j->out_len ? POLLOUT : POLLIN;
       fds[n].revents = 0;
       owners[n++] = j;
     }
@@ -595,11 +663,13 @@ static void* sb_io_thread(void* unused) {
 
 // The inline C of __sbCallAsync calls this by prototype: Porffor may emit a
 // function's body before this block.
+// stream: bit 1 a streamed response may come; bit 2 the request body follows in frames.
 void sb_async_submit_v1(u32 id, int stream, const char* json, size_t json_len, const char* body, size_t body_len) {
   sb_async_job* j = (sb_async_job*)calloc(1, sizeof(sb_async_job));
   if (!j) abort();
   j->id = id;
-  j->stream = stream;
+  j->stream = stream & 1;
+  j->body_stream = (stream & 2) != 0;
   j->fd = -1;
   size_t req_len = 0;
   char* req = sb_v1_request(json, json_len, body, body_len, &req_len);
@@ -652,6 +722,44 @@ void sb_async_submit_v1(u32 id, int stream, const char* json, size_t json_len, c
   while (write(sb_io_wake[1], &one, 1) < 0 && errno == EINTR) {}
 }
 
+// One frame of exchange id's streamed request body: kind 0 a chunk of data, 1 the end,
+// 2 a failure; 3 queues nothing. Returns the bytes of body frames not yet written, all
+// exchanges together.
+size_t sb_async_body(u32 id, int kind, const char* data, size_t len) {
+  if (kind == 3) {
+    pthread_mutex_lock(&sb_async_lock);
+    size_t backlog = sb_async_body_backlog;
+    pthread_mutex_unlock(&sb_async_lock);
+    return backlog;
+  }
+  const char* json = kind == 0 ? "{\"chunk\":true}" : kind == 1 ? "{\"end\":true}" : "{\"error\":\"the request body stream failed\"}";
+  const size_t json_len = strlen(json), payload = 1 + 4 + json_len + (kind == 0 ? len : 0);
+  sb_async_bodyframe* bf = (sb_async_bodyframe*)calloc(1, sizeof(sb_async_bodyframe));
+  if (!bf) abort();
+  bf->id = id;
+  bf->len = 4 + payload;
+  bf->data = (unsigned char*)malloc(bf->len);
+  if (!bf->data) abort();
+  for (int k = 0; k < 4; k++) bf->data[k] = (unsigned char)((payload >> (8 * k)) & 0xff);
+  bf->data[4] = 2;  // FRAME_V1_MORE
+  for (int k = 0; k < 4; k++) bf->data[5 + k] = (unsigned char)((json_len >> (8 * k)) & 0xff);
+  memcpy(bf->data + 9, json, json_len);
+  if (kind == 0 && len) memcpy(bf->data + 9 + json_len, data, len);
+  pthread_mutex_lock(&sb_async_lock);
+  int started = sb_io_started;
+  if (started) {
+    if (sb_async_bodyq_tail) sb_async_bodyq_tail->next = bf; else sb_async_bodyq = bf;
+    sb_async_bodyq_tail = bf;
+    sb_async_body_backlog += bf->len;
+  }
+  size_t backlog = sb_async_body_backlog;
+  pthread_mutex_unlock(&sb_async_lock);
+  if (!started) { free(bf->data); free(bf); return 0; }
+  char one = 1;
+  while (write(sb_io_wake[1], &one, 1) < 0 && errno == EINTR) {}
+  return backlog;
+}
+
 // The caller gave up on exchange id: the I/O thread drops it and closes its
 // connection. One that already finished is dropped by the drain instead, since its
 // placeholder timer is gone.
@@ -849,7 +957,8 @@ globalThis.__sbFetchUpstream = function (op, msg) {
   // Queued (async host); the reply reaches the callback registered under asyncId, in
   // several frames when msg.stream asks for a streamed response.
   if (msg.asyncId > 0) {
-    __sbCallAsync(JSON.stringify(req), "", msg.asyncId, msg.stream === true ? "1" : "0");
+    // "1" a streamed response may come, "2" the body follows in frames (__sbAsyncBody).
+    __sbCallAsync(JSON.stringify(req), "", msg.asyncId, String((msg.stream === true ? 1 : 0) + (msg.bodyStream === true ? 2 : 0)));
     return { ok: true, pending: true };
   }
   const reply = JSON.parse(__sbCallBin(JSON.stringify(req), ""));
@@ -876,7 +985,7 @@ function __sbCallAsync(reqJson, body, asyncId, stream) {
     }
     const char* __s; size_t __sl; char* __so = 0;
     porf_native_fetch_read_value(stream, &__s, &__sl, &__so);
-    const int __stream = __sl > 0 && __s[0] == '1';
+    const int __stream = __sl > 0 && __s[0] >= '0' && __s[0] <= '3' ? __s[0] - '0' : 0;
     if (__so) free(__so);
     if (asyncId.type == 1 && asyncId.val > 0) sb_async_submit_v1((u32)asyncId.val, __stream, __j, __jl, __b, __bl);
     if (__jo) free(__jo);
@@ -895,6 +1004,48 @@ function __sbCancelAsync(asyncId) {
   `;
 }
 
+// One frame of the streamed request body of the exchange under timer id `asyncId`:
+// kind "c" a chunk (data, one char per byte), "e" the end, "x" a failure, "q" nothing. Returns the
+// bytes of body frames not yet written, as a string.
+// oxlint-disable-next-line no-unused-vars -- read inside the RawC block below, not by JS.
+function __sbAsyncBody(asyncId, kind, data) {
+  let res = "";
+  // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
+  Porffor.c`
+    size_t sb_async_body(u32, int, const char*, size_t);
+    const char* __k; size_t __kl; char* __ko = 0;
+    porf_native_fetch_read_value(kind, &__k, &__kl, &__ko);
+    const int __kind = __kl && __k[0] == 'c' ? 0 : __kl && __k[0] == 'e' ? 1 : __kl && __k[0] == 'q' ? 3 : 2;
+    if (__ko) free(__ko);
+    const char* __d = 0; size_t __dl = 0;
+    if (__kind == 0 && porf_native_fetch_read_raw_bytes(data, &__d, &__dl) != 0) { __d = 0; __dl = 0; }
+    size_t __backlog = asyncId.type == 1 && asyncId.val > 0 ? sb_async_body((u32)asyncId.val, __kind, __d, __dl) : 0;
+    char __r[32];
+    int __n = snprintf(__r, sizeof(__r), "%zu", __backlog);
+    res = porf_box((f64)porf_native_fetch_alloc_bytestring(__r, (size_t)__n), 195);
+  `;
+  return res;
+}
+globalThis.__sbAsyncBody = __sbAsyncBody;
+
+// Whether request bodies can stream to the broker (2026-10-27): an async host, and a
+// broker that says it takes them (bodyStream in its pong). Asked once.
+let __sbBodyStreamCache = -1;
+globalThis.__sbBodyStreamable = function () {
+  if (__sbBodyStreamCache < 0) {
+    __sbBodyStreamCache = 0;
+    if (__sbHttpAsyncEnabled()) {
+      try {
+        const pong = JSON.parse(__sbCall(JSON.stringify({ op: "ping" })));
+        if (pong.bodyStream === true) __sbBodyStreamCache = 1;
+      } catch {
+        // An old broker or none: bodies are sent whole.
+      }
+    }
+  }
+  return __sbBodyStreamCache === 1;
+};
+
 // Before compatibility date 2026-10-22, fetch() through the broker answered at once.
 function __sbAsyncAtAnyDate() {
   return false;

package/src/utf8-decode.test.js

@@ -12,7 +12,9 @@ const end = src.indexOf("// sproutboat #181 — wrap a Response");
 if (start === -1 || end === -1 || end < start) throw new Error("__sbFromUtf8 block not found in prelude");
 
 // oxlint-disable-next-line no-function-constructor -- lifting a pure block out of the text-only prelude for test
-const load = new Function(`${src.slice(start, end)}\nreturn { __sbFromUtf8 };`);
+const load = new Function(
+  `// The C fast paths (Porffor.c) cannot run here: the stubs make the JS fallback run.\nfunction __sbFromUtf8Native() { return ""; }\nfunction __sbToBytesNative() { return ""; }\n${src.slice(start, end)}\nreturn { __sbFromUtf8 };`,
+);
 const { __sbFromUtf8 } = load();
 
 /** Build a bytestring (one char per raw byte) the way __sbToBytes/porf_native_fetch_alloc_bytestring would, from real UTF-8 bytes. */
@@ -78,7 +80,7 @@ if (rbrStart === -1 || rbrEnd === -1 || rbrEnd < rbrStart) {
 // oxlint-disable-next-line no-function-constructor -- lifting a pure block out of the text-only prelude for test
 const loadRbr = new Function(
   "Response",
-  `${src.slice(start, end)}\n${src.slice(rbrStart, rbrEnd)}\nreturn { __sbRawBodyResponse };`,
+  `// The C fast paths (Porffor.c) cannot run here: the stubs make the JS fallback run.\nfunction __sbFromUtf8Native() { return ""; }\nfunction __sbToBytesNative() { return ""; }\n${src.slice(start, end)}\n${src.slice(rbrStart, rbrEnd)}\nreturn { __sbRawBodyResponse };`,
 );
 // A minimal Response stand-in: only what __sbRawBodyResponse touches (the
 // constructor call and setting .text/.json on the instance), no Porffor

package/test/native-byte-text.ts

@@ -0,0 +1,165 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { ensurePorffor } from "../../toolchain/src/acquire";
+import { preludePath, TRANSPORT_MARKER, transportPath, wrapNativeFetchHandler } from "../src/wrap";
+
+// sproutd #22: __sbFromUtf8 and __sbToBytes run in C (__sbFromUtf8Native, __sbToBytesNative).
+// They must give exactly what the JS loops gave, and a body of megabytes must not take
+// hundreds of megabytes of heap (the JS made one string per character: a 5 MiB R2 object
+// read with text() took about 400 MiB).
+const handler = `const bytes = (list) => { let s = ""; for (const b of list) s += String.fromCharCode(b); return s; };
+const codes = (s) => { const out = []; for (let i = 0; i < s.length; i++) out.push(s.charCodeAt(i)); return out; };
+export default {fetch(request) {
+  if (new URL(request.url).pathname === "/big") {
+    const text = __sbFromUtf8("\\u00c3\\u00a9".repeat(4 * 1024 * 1024));
+    const utf8 = __sbToBytes("\\u2713".repeat(1024 * 1024));
+    const ascii = __sbToBytes("a".repeat(8 * 1024 * 1024));
+    return new Response(JSON.stringify([text.length, text.charCodeAt(0), utf8.length, utf8.charCodeAt(2), ascii.length]));
+  }
+  const decode = [
+    "hello", bytes([0x63, 0x61, 0x66, 0xc3, 0xa9, 0x20, 0xf0, 0x9f, 0x8c, 0xb1, 0x20, 0xe2, 0x9c, 0x93]),
+    bytes([0xc2]), bytes([0xe9, 0x41]), bytes([0xf0, 0x9f, 0x8c]), bytes([0xe2, 0x28, 0xa1]), bytes([0xc0, 0x80]),
+    bytes([0xf8, 0x88, 0x80, 0x80, 0x80]), bytes([0xed, 0xa0, 0x80]), bytes([0xf4, 0x90, 0x80, 0x80]), bytes([0xff, 0xfe, 0x00]),
+    JSON.parse('"caf\\\\u00c3\\\\u00a9 \\\\u0100"'), JSON.parse('"\\\\u00e2\\\\u009c\\\\u0093"'), "",
+  ];
+  const encode = [
+    "hello", "caf\\u00e9", "\\u2713 \\ud83c\\udf31", "\\ud800x", "\\udc00", "a\\ud800", "\\u0100\\u07ff\\u0800\\uffff", "",
+    new Uint8Array([0, 255, 128]), new Uint8Array([1, 2, 3]).buffer, new Uint8Array(new Uint8Array([9, 8, 7, 6]).buffer, 1, 2), new Uint8Array(0),
+  ];
+  return new Response(JSON.stringify({ decode: decode.map((s) => codes(__sbFromUtf8(s))), encode: encode.map((v) => codes(__sbToBytes(v))) }));
+}};`;
+
+// The JS the C replaces, lifted from the prelude with the C stubbed out, as the reference.
+const core = await readFile(preludePath, "utf8");
+const lift = (from: string, to: string) => {
+  const start = core.indexOf(from);
+  const end = core.indexOf(to, start);
+  assert(start >= 0 && end > start, `${from} block not found in prelude`);
+  return core.slice(start, end);
+};
+// oxlint-disable-next-line no-function-constructor -- lifting pure blocks out of the text-only prelude for the reference
+const reference = new Function(
+  `function __sbFromUtf8Native() { return ""; }\nfunction __sbToBytesNative() { return ""; }\n` +
+    lift("function __sbIsStr(", "function __sbIsFn(") +
+    lift("const __SB_BYTES_WINDOW", "function __sbBufFrom(") +
+    lift("function __sbFromUtf8(", "// sproutboat #181") +
+    "return { __sbFromUtf8, __sbToBytes };",
+)();
+const bytes = (list: number[]) => String.fromCharCode(...list);
+const codes = (s: string) => [...s].flatMap((c) => [...Array(c.length).keys()].map((i) => c.charCodeAt(i)));
+const want = {
+  decode: [
+    "hello",
+    bytes([0x63, 0x61, 0x66, 0xc3, 0xa9, 0x20, 0xf0, 0x9f, 0x8c, 0xb1, 0x20, 0xe2, 0x9c, 0x93]),
+    bytes([0xc2]),
+    bytes([0xe9, 0x41]),
+    bytes([0xf0, 0x9f, 0x8c]),
+    bytes([0xe2, 0x28, 0xa1]),
+    bytes([0xc0, 0x80]),
+    bytes([0xf8, 0x88, 0x80, 0x80, 0x80]),
+    bytes([0xed, 0xa0, 0x80]),
+    bytes([0xf4, 0x90, 0x80, 0x80]),
+    bytes([0xff, 0xfe, 0x00]),
+    "café Ā",
+    "â\u009c\u0093",
+    "",
+  ].map((s) => codes(reference.__sbFromUtf8(s))),
+  encode: [
+    "hello",
+    "café",
+    "✓ 🌱",
+    "\ud800x",
+    "\udc00",
+    "a\ud800",
+    "Ā߿ࠀ￿",
+    "",
+    new Uint8Array([0, 255, 128]),
+    new Uint8Array([1, 2, 3]).buffer,
+    new Uint8Array(new Uint8Array([9, 8, 7, 6]).buffer, 1, 2),
+    new Uint8Array(0),
+  ].map((v) => codes(reference.__sbToBytes(v))),
+};
+
+function freePort(): number {
+  const listener = Bun.listen({ hostname: "127.0.0.1", port: 0, socket: { data() {} } });
+  const port = listener.port;
+  listener.stop(true);
+  return port;
+}
+
+const workdir = await mkdtemp(join(tmpdir(), "sb-native-byte-text-"));
+let server: ReturnType<typeof Bun.spawn> | undefined;
+try {
+  const porffor = await ensurePorffor();
+  const node = Bun.which("node");
+  if (!node) throw new Error("native byte-text test needs node on PATH");
+  const broker = await readFile(transportPath("broker"), "utf8");
+  assert(core.includes(TRANSPORT_MARKER), "runtime prelude is missing its transport marker");
+  const generated = join(workdir, "bytes.generated.js");
+  const binary = join(workdir, "bytes-native");
+  await writeFile(generated, wrapNativeFetchHandler(handler, core.replace(TRANSPORT_MARKER, broker)));
+  const compile = Bun.spawn(
+    [node, resolve(porffor, "runtime/index.js"), "native", generated, "-o", binary, "-s", "-O0"],
+    {
+      cwd: workdir,
+      stdout: "pipe",
+      stderr: "pipe",
+    },
+  );
+  const [exitCode, stdout, stderr] = await Promise.all([
+    compile.exited,
+    new Response(compile.stdout).text(),
+    new Response(compile.stderr).text(),
+  ]);
+  assert.equal(exitCode, 0, `Porffor native compile failed:\n${stderr}\n${stdout}`);
+
+  const port = freePort();
+  // Peak RSS: /proc's high-water mark on Linux, time(1) on macOS.
+  const linux = process.platform === "linux";
+  server = Bun.spawn(linux ? [binary] : ["/usr/bin/time", "-l", binary], {
+    cwd: workdir,
+    env: { ...process.env, PORT: String(port) },
+    stdout: "ignore",
+    stderr: "pipe",
+  });
+  let ready = false;
+  for (let attempt = 0; attempt < 50 && !ready; attempt++) {
+    try {
+      await fetch(`http://127.0.0.1:${port}/`, { signal: AbortSignal.timeout(500) });
+      ready = true;
+    } catch {
+      if (server.exitCode !== null) break;
+      await Bun.sleep(100);
+    }
+  }
+  assert(ready, "compiled handler did not start");
+  const got = await (await fetch(`http://127.0.0.1:${port}/`)).json();
+  assert.deepEqual(got.decode, want.decode, "__sbFromUtf8 in C decodes as the JS did");
+  assert.deepEqual(got.encode, want.encode, "__sbToBytes in C encodes as the JS did");
+  console.log("C byte/text conversions match the JS ones");
+
+  const big = await (await fetch(`http://127.0.0.1:${port}/big`)).json();
+  assert.deepEqual(big, [4 * 1024 * 1024, 0xe9, 3 * 1024 * 1024, 0x93, 8 * 1024 * 1024]);
+  let peak = 0;
+  if (linux) {
+    const status = await readFile(`/proc/${server.pid}/status`, "utf8");
+    peak = Number(/VmHWM:\s+(\d+) kB/.exec(status)?.[1] ?? 0) * 1024;
+  }
+  server.kill("SIGINT");
+  const timing = linux ? "" : await new Response(server.stderr).text();
+  await server.exited;
+  server = undefined;
+  if (!linux) peak = Number(/(\d+)\s+maximum resident set size/.exec(timing)?.[1] ?? 0);
+  assert(peak > 0, "peak RSS was measured");
+  // The JS took over 600 MiB for these; the C needs the strings plus one scratch copy.
+  assert(peak < 96 * 1024 * 1024, `8 MiB conversions peaked at ${(peak / 1048576).toFixed(1)} MiB`);
+  console.log(`8 MiB conversions peak at ${(peak / 1048576).toFixed(1)} MiB RSS`);
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}

package/test/native-request-streaming.ts

@@ -0,0 +1,221 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { ensurePorffor } from "../../toolchain/src/acquire";
+import { preludePath, TRANSPORT_MARKER, transportPath, wrapNativeFetchHandler } from "../src/wrap";
+
+// Streamed request bodies, from compatibility date 2026-10-27: the handler runs once the
+// headers are in, request.body hands out chunks as they arrive, text()/json()/arrayBuffer()
+// still read the whole body, and a large upload read through the stream keeps memory flat
+// (the server pauses the socket while 1 MiB waits unread).
+const handler = `export default {async fetch(request) {
+  const path = new URL(request.url).pathname;
+  if (path === "/timing") {
+    const reader = request.body.getReader();
+    let first = 0, last = 0, text = "", chunks = 0;
+    for (;;) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      last = Date.now();
+      if (!first) first = last;
+      chunks++;
+      text += new TextDecoder().decode(value);
+    }
+    return Response.json({ text, gapMs: last - first, chunks });
+  }
+  if (path === "/count") {
+    const reader = request.body.getReader();
+    let bytes = 0, sum = 0;
+    for (;;) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      // Every 4096th byte of the whole body, wherever the server split it into chunks.
+      for (let i = (4096 - (bytes % 4096)) % 4096; i < value.length; i += 4096) sum = (sum + value[i]) % 65521;
+      bytes += value.length;
+    }
+    return Response.json({ bytes, sum });
+  }
+  if (path === "/text") { const t = await request.text(); return Response.json({ length: t.length, head: t.slice(0, 8) }); }
+  if (path === "/json") return Response.json(await request.json());
+  if (path === "/ab") { const b = new Uint8Array(await request.arrayBuffer()); return Response.json({ length: b.length, last: b[b.length - 1] }); }
+  if (path === "/twice") { await request.text(); try { await request.text(); return new Response("read twice"); } catch (e) { return new Response(e.name); } }
+  if (path === "/echo") return new Response(request.body);
+  if (path === "/ignore") return new Response("ignored");
+  return new Response("no route " + path, { status: 404 });
+}};`;
+
+function freePort(): number {
+  const listener = Bun.listen({ hostname: "127.0.0.1", port: 0, socket: { data() {} } });
+  const port = listener.port;
+  listener.stop(true);
+  return port;
+}
+
+/** An upload of `total` bytes in 64 KiB chunks, as a stream (chunked transfer encoding). */
+function upload(total: number, gapMs = 0): ReadableStream<Uint8Array> {
+  let sent = 0;
+  return new ReadableStream({
+    async pull(controller) {
+      if (sent >= total) return controller.close();
+      const n = Math.min(65536, total - sent);
+      const chunk = new Uint8Array(n);
+      for (let i = 0; i < n; i += 4096) chunk[i] = (sent + i) % 251;
+      sent += n;
+      controller.enqueue(chunk);
+      if (gapMs) await Bun.sleep(gapMs);
+    },
+  });
+}
+const expectedSum = (total: number) => {
+  let sum = 0;
+  for (let at = 0; at < total; at += 65536) {
+    const n = Math.min(65536, total - at);
+    for (let i = 0; i < n; i += 4096) sum = (sum + ((at + i) % 251)) % 65521;
+  }
+  return sum;
+};
+
+const workdir = await mkdtemp(join(tmpdir(), "sb-native-request-streaming-"));
+let server: ReturnType<typeof Bun.spawn> | undefined;
+try {
+  const porffor = await ensurePorffor();
+  const node = Bun.which("node");
+  if (!node) throw new Error("native request-streaming test needs node on PATH");
+  const [core, broker] = await Promise.all([readFile(preludePath, "utf8"), readFile(transportPath("broker"), "utf8")]);
+  assert(core.includes(TRANSPORT_MARKER), "runtime prelude is missing its transport marker");
+  const generated = join(workdir, "stream.generated.js");
+  const binary = join(workdir, "stream-native");
+  const source = wrapNativeFetchHandler(
+    handler,
+    core.replace(TRANSPORT_MARKER, broker),
+    {},
+    undefined,
+    undefined,
+    "2026-10-27",
+  );
+  await writeFile(generated, source);
+  const compile = Bun.spawn(
+    [node, resolve(porffor, "runtime/index.js"), "native", generated, "-o", binary, "-s", "-O0"],
+    {
+      cwd: workdir,
+      stdout: "pipe",
+      stderr: "pipe",
+    },
+  );
+  const [exitCode, stdout, stderr] = await Promise.all([
+    compile.exited,
+    new Response(compile.stdout).text(),
+    new Response(compile.stderr).text(),
+  ]);
+  assert.equal(exitCode, 0, `Porffor native compile failed:\n${stderr}\n${stdout}`);
+
+  const port = freePort();
+  const linux = process.platform === "linux";
+  server = Bun.spawn(linux ? [binary] : ["/usr/bin/time", "-l", binary], {
+    cwd: workdir,
+    env: { ...process.env, PORT: String(port), SB_REQUEST_BODY_MAX: String(256 * 1024 * 1024) },
+    stdout: "ignore",
+    stderr: "pipe",
+  });
+  const base = `http://127.0.0.1:${port}`;
+  let ready = false;
+  for (let attempt = 0; attempt < 50 && !ready; attempt++) {
+    try {
+      await fetch(`${base}/ignore`, { signal: AbortSignal.timeout(500) });
+      ready = true;
+    } catch {
+      if (server.exitCode !== null) break;
+      await Bun.sleep(100);
+    }
+  }
+  assert(ready, "compiled handler did not start");
+  const post = (path: string, body: BodyInit, headers?: HeadersInit) => {
+    const init: RequestInit & { duplex: string } = { method: "POST", body, headers, duplex: "half" };
+    return fetch(`${base}${path}`, init);
+  };
+
+  // The handler sees the first chunk before the second is sent.
+  const encoder = new TextEncoder();
+  const timed = new ReadableStream({
+    async start(controller) {
+      controller.enqueue(encoder.encode("first "));
+      await Bun.sleep(500);
+      controller.enqueue(encoder.encode("second"));
+      controller.close();
+    },
+  });
+  const timing = await (await post("/timing", timed)).json();
+  assert.equal(timing.text, "first second");
+  assert(timing.gapMs > 300, `the body arrived in parts (${timing.gapMs} ms apart)`);
+  console.log(`request.body streams: the second chunk arrived ${timing.gapMs} ms after the first`);
+
+  // Whole-body readers still work, on a fixed-length and on a chunked body.
+  assert.deepEqual(await (await post("/text", "héllo wörld ✓")).json(), { length: 13, head: "héllo wö" });
+  assert.deepEqual(await (await post("/json", JSON.stringify({ a: [1, "ü"] }))).json(), { a: [1, "ü"] });
+  const big = new Uint8Array(3 * 1024 * 1024 + 7).fill(65);
+  big[big.length - 1] = 66;
+  assert.deepEqual(await (await post("/ab", big)).json(), { length: big.length, last: 66 });
+  assert.deepEqual(await (await post("/ab", upload(5 * 1024 * 1024 + 1))).json(), {
+    length: 5 * 1024 * 1024 + 1,
+    last: (5 * 1024 * 1024) % 251,
+  });
+  assert.equal(await (await post("/twice", "x")).text(), "TypeError");
+  assert.equal(await (await post("/echo", "echo me")).text(), "echo me");
+  // A body the handler never reads doesn't stall the connection or the next request.
+  assert.equal(await (await post("/ignore", new Uint8Array(4 * 1024 * 1024))).text(), "ignored");
+  assert.equal(await (await post("/text", "after")).text(), JSON.stringify({ length: 5, head: "after" }));
+  console.log("text(), json(), arrayBuffer(), echo and an unread body work");
+
+  // Over the limit by Content-Length: 413 before the handler runs.
+  // (Raw, since fetch() sets Content-Length from the body it actually sends.)
+  const statusLine = await new Promise<string>((done, fail) => {
+    let got = "";
+    Bun.connect({
+      hostname: "127.0.0.1",
+      port,
+      socket: {
+        open(socket) {
+          socket.write(`POST /count HTTP/1.1\r\nHost: x\r\nContent-Length: ${300 * 1024 * 1024}\r\n\r\n`);
+        },
+        data(socket, data) {
+          got += data.toString();
+          if (got.includes("\r\n")) {
+            socket.end();
+            done(got.slice(0, got.indexOf("\r\n")));
+          }
+        },
+        error(_socket, error) {
+          fail(error);
+        },
+      },
+    });
+  });
+  assert.equal(statusLine, "HTTP/1.1 413 Payload Too Large");
+  console.log("a body over SB_REQUEST_BODY_MAX by Content-Length gets 413 before the handler runs");
+
+  // Memory stays flat as the upload grows: 128 MiB read through the stream.
+  const total = 128 * 1024 * 1024;
+  const counted = await (await post("/count", upload(total))).json();
+  assert.deepEqual(counted, { bytes: total, sum: expectedSum(total) });
+  let peak = 0;
+  if (linux) {
+    const status = await readFile(`/proc/${server.pid}/status`, "utf8");
+    peak = Number(/VmHWM:\s+(\d+) kB/.exec(status)?.[1] ?? 0) * 1024;
+  }
+  server.kill("SIGINT");
+  const timingOut = linux ? "" : await new Response(server.stderr).text();
+  await server.exited;
+  server = undefined;
+  if (!linux) peak = Number(/(\d+)\s+maximum resident set size/.exec(timingOut)?.[1] ?? 0);
+  assert(peak > 0, "peak RSS was measured");
+  // Buffered, the 128 MiB body alone took 128 MiB three times over.
+  assert(peak < 64 * 1024 * 1024, `a 128 MiB streamed upload peaked at ${(peak / 1048576).toFixed(1)} MiB`);
+  console.log(`a 128 MiB upload read through request.body peaks at ${(peak / 1048576).toFixed(1)} MiB RSS`);
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}