@sproutboat/runtime 0.27.1 → 0.28.0

package/CHANGELOG.md

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

package/package.json

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

package/src/native-fetch-prelude.js

@@ -4745,7 +4745,7 @@ static size_t sb_utf8_encode_units(const uint16_t* s, size_t len, unsigned char*
 
 `;
 
-// sproutd #22: __sbFromUtf8 for a string of bytes (one byte per unit), in C.
+// 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.
@@ -4753,9 +4753,10 @@ 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`
-    if (bytes.type == 195 || bytes.type == 67) {
-      const u32 __p = (u32)bytes.val;
-      const size_t __n = (size_t)*(u32*)(MEM + __p);
+    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);
@@ -4766,7 +4767,7 @@ function __sbFromUtf8Native(bytes) {
         unsigned char* __b = (unsigned char*)malloc(__n + 1);
         uint16_t* __u = (uint16_t*)malloc(__n * 2 + 2);
         if (__b && __u) {
-          if (bytes.type == 195) memcpy(__b, MEM + __p + 4, __n);
+          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);
@@ -6010,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.
@@ -6270,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;
@@ -6338,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);
@@ -6375,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);
@@ -6435,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 {
@@ -6448,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));
   };
@@ -7031,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/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/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 });
+}