@sproutboat/runtime 0.27.1 → 0.29.0

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/transport-embedded.js

@@ -4194,12 +4194,17 @@ function __sbEmbeddedDispatch(msg) {
   }
 
   if (op === "queue.send" || op === "queue.send_batch") {
-    const items = op === "queue.send" ? [msg.body] : msg.messages || [];
+    // send_batch's items are { body, delaySeconds } objects, like the broker's. They were
+    // stored with String(item), so every sendBatch() body arrived as "[object Object]"
+    // (data loss), and delaySeconds was ignored on both calls.
+    const items = op === "queue.send" ? [{ body: msg.body, delaySeconds: msg.delaySeconds }] : msg.messages || [];
     for (let i = 0; i < items.length; i++) {
+      const item = items[i] || {};
+      const delay = Math.max(0, Number(item.delaySeconds) || 0) * 1000;
       __sbSql(
         store,
         "INSERT INTO mq (queue, id, body, visible_at, attempts, dead) VALUES (?1,?2,?3,?4,0,0)",
-        [msg.queue, __sbHex(12), String(items[i]), Date.now()],
+        [msg.queue, __sbHex(12), String(item.body), Date.now() + delay],
       );
     }
     return { ok: true };
@@ -4240,8 +4245,21 @@ function __sbEmbeddedDispatch(msg) {
       store,
       // Same clamp as the broker: an unbounded list builds the whole result in
       // memory before the caller sees any of it.
-      "SELECT key, value FROM do_storage WHERE cls = ? AND id = ? AND key LIKE ? || '%' ORDER BY key LIMIT ?",
-      [msg.cls, msg.id, msg.prefix || "", Math.min(Math.max(Number(msg.limit) || 1000, 1), 10000)],
+      // start, startAfter, end and reverse come from 2026-10-28 storage (null when unset).
+      // The prefix match is exact: LIKE also matched _ and % as wildcards, case-insensitively.
+      "SELECT key, value FROM do_storage WHERE cls = ?1 AND id = ?2 AND substr(key, 1, length(?3)) = ?3" +
+        " AND (?5 IS NULL OR key >= ?5) AND (?6 IS NULL OR key > ?6) AND (?7 IS NULL OR key < ?7)" +
+        (msg.reverse ? " ORDER BY key DESC" : " ORDER BY key") +
+        " LIMIT ?4",
+      [
+        msg.cls,
+        msg.id,
+        msg.prefix || "",
+        Math.min(Math.max(Number(msg.limit) || 1000, 1), 10000),
+        msg.start == null ? null : String(msg.start),
+        msg.startAfter == null ? null : String(msg.startAfter),
+        msg.end == null ? null : String(msg.end),
+      ],
     );
     const entries = [];
     for (let i = 0; i < r.rows.length; i++) entries.push([r.rows[i][0], r.rows[i][1]]);
@@ -4799,7 +4817,7 @@ globalThis.__sbStartLocalTriggers = function (handlers, bindings) {
         try {
           const instance = __sbGetDOInstance(cls, id);
           if (__sbIsFn(instance.alarm)) {
-            const res = instance.alarm();
+            const res = __sbDOGated() ? __sbDOEnter(instance.__sbGate, () => instance.alarm()) : instance.alarm();
             if (res && __sbIsFn(res.then)) await res;
             if (instance.__sbTasks.length) await __sbDrainWaitUntil(instance.__sbTasks);
           }

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