@sproutboat/wire 0.15.0 → 0.17.0

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # @sproutboat/wire
 
+## 0.17.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.
+
+### Patch Changes
+
+- Updated dependencies [829ed12]
+  - @sproutboat/runtime@0.28.0
+
+## 0.16.0
+
+### Minor Changes
+
+- 9be9c74: R2 matches workerd from compatibility date `2026-10-26`:
+  
+  - `get`, `put`, `head`, `delete`, `list` and `createMultipartUpload` return Promises, and errors reject them.
+  - An object's `etag` is the MD5 of its bytes, with `checksums.md5`. Objects written before keep their old etag.
+  - Objects have `uploaded` as a `Date`, `version`, `storageClass`, `range` and `writeHttpMetadata(headers)`. A body has `body` (a `ReadableStream`), `bodyUsed`, `text()`, `json()`, `arrayBuffer()` and `blob()`.
+  - `get(key, { range, onlyIf })` takes `{ offset, length }`, `{ suffix }` or a `Range` header, and `etagMatches`, `etagDoesNotMatch`, `uploadedBefore`, `uploadedAfter` or `If-*` headers. When the condition fails it returns the object without a body.
+  - `put(key, value, { onlyIf, httpMetadata })` takes a `ReadableStream` or a `Blob`, and `httpMetadata` as `Headers`. When the condition fails it returns `null`.
+  - `delete([keys])` deletes several keys.
+  - `list({ prefix, limit, cursor, delimiter, include })` pages at up to 1,000 entries, groups keys into `delimitedPrefixes`, and returns `httpMetadata` and `customMetadata` only when `include` asks for them.
+  - A value of the wrong type and a key longer than 1,024 bytes fail with R2's errors.
+  
+  Earlier dates keep the synchronous shim. One change applies at every date: **a `list()` prefix now matches exactly.** It used SQL `LIKE`, so it ignored case and read `_` and `%` as wildcards. Both transports store an object's MD5 in a new column, added to existing stores when they open.
+  
+  Against miniflare 4.20260730, `conformance/bindings/r2.js` in sproutd passes 48/48 at `2026-10-26` (16/48 before).
+
+### Patch Changes
+
+- Updated dependencies [9be9c74]
+  - @sproutboat/runtime@0.27.0
+
 ## 0.15.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/wire",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -23,6 +23,6 @@
   },
   "dependencies": {
     "@sproutboat/assets": "^0.3.0",
-    "@sproutboat/runtime": "^0.26.0"
+    "@sproutboat/runtime": "^0.28.0"
   }
 }

package/src/broker.test.ts

@@ -424,6 +424,28 @@ test("R2: put / get / head / list / delete on a bound bucket", async () => {
   await expect(b.dispatch({ op: "r2.put", bucket: "NOPE", key: "x", body: "y" })).rejects.toThrow("not bound");
 });
 
+test("R2: exact list prefix at every date; md5, paged list and delimiter for the shim from 2026-10-26", async () => {
+  const b = make({ bindings: { r2: ["ASSETS"] } });
+  for (const key of ["a_x", "ab", "AB", "d/1", "d/2", "e/1", "f"]) await b.dispatch({ op: "r2.put", bucket: "ASSETS", key, body: "v" });
+  // LIKE listed "ab" for "a_" and "AB" for "a".
+  expect(arr((await b.dispatch({ op: "r2.list", bucket: "ASSETS", prefix: "a_" })).objects).map((o) => obj(o).key)).toEqual(["a_x"]);
+  expect(arr((await b.dispatch({ op: "r2.list", bucket: "ASSETS", prefix: "a" })).objects).map((o) => obj(o).key)).toEqual(["a_x", "ab"]);
+  const put = await b.dispatch({ op: "r2.put", bucket: "ASSETS", key: "m", body: "hello" });
+  await b.dispatch({ op: "r2.md5", bucket: "ASSETS", key: "m", etag: obj(put.object).etag, md5: "5d41402abc4b2a76b9719d911017c592" });
+  expect(obj((await b.dispatch({ op: "r2.head", bucket: "ASSETS", key: "m" })).object).md5).toBe("5d41402abc4b2a76b9719d911017c592");
+  // A stale etag (the object was written again since) records nothing.
+  await b.dispatch({ op: "r2.md5", bucket: "ASSETS", key: "m", etag: "stale", md5: "x" });
+  expect(obj((await b.dispatch({ op: "r2.head", bucket: "ASSETS", key: "m" })).object).md5).toBe("5d41402abc4b2a76b9719d911017c592");
+  const page = (cursor: string) => b.dispatch({ op: "r2.list", bucket: "ASSETS", page: true, prefix: "", cursor, limit: 3, delimiter: "/" });
+  const first = await page("");
+  expect(arr(first.objects).map((o) => obj(o).key)).toEqual(["AB", "a_x", "ab"]);
+  expect(first).toMatchObject({ truncated: true, cursor: "ab", delimitedPrefixes: [] });
+  const second = await page("ab");
+  expect(arr(second.objects).map((o) => obj(o).key)).toEqual(["f"]);
+  expect(second).toMatchObject({ truncated: true, delimitedPrefixes: ["d/", "e/"] });
+  expect(await page(String(second.cursor))).toMatchObject({ objects: [{ key: "m" }], truncated: false, cursor: "" });
+});
+
 test("R2 direct transfer: streamed upload, metadata, one-use ticket and ranged download", async () => {
   const root = mkdtempSync(join(tmpdir(), "sb-r2-transfer-"));
   try {
@@ -1515,3 +1537,60 @@ test("R2 direct download: If-None-Match supports wildcard, lists and weak compar
     expect((await broker.transfer(new Request(url))).status).toBe(410);
   } finally { broker.close(); rmSync(dir, { recursive: true, force: true }); }
 });
+
+test("listen(): a service.fetch body streamed in FRAME_V1_MORE frames reaches the upstream as it arrives", async () => {
+  const arrivals: { text: string; at: number }[] = [];
+  const fetchImpl: FetchLike = async (_url, init) => {
+    // SAFETY: the broker passes the BodySink's ReadableStream as the body of a streamed request.
+    const reader = (init?.body as ReadableStream<Uint8Array>).getReader();
+    for (;;) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      arrivals.push({ text: new TextDecoder().decode(value), at: Date.now() });
+    }
+    return new Response(arrivals.map((a) => a.text).join(""));
+  };
+  const b = make({
+    token: "tok",
+    bindings: { services: [{ binding: "PEER", service: "peer" }] },
+    services: { PEER: "peer.example.com" },
+    edgeUrl: "http://127.0.0.1:8080/",
+    fetchImpl,
+  });
+  const server = listen(b, "127.0.0.1", 0);
+  const socket = createConnection({ host: "127.0.0.1", port: server.port });
+  const replies: Buffer[] = [];
+  let pending = Buffer.alloc(0);
+  socket.on("data", (data: Buffer) => {
+    pending = Buffer.concat([pending, data]);
+    while (pending.length >= 4 && pending.length >= 4 + pending.readUInt32LE(0)) {
+      replies.push(pending.subarray(4, 4 + pending.readUInt32LE(0)));
+      pending = pending.subarray(4 + pending.readUInt32LE(0));
+    }
+  });
+  await new Promise((done) => socket.once("connect", done));
+  const head = {
+    v: 1,
+    token: "tok",
+    op: "service.fetch",
+    binding: "PEER",
+    url: "https://peer/up",
+    method: "POST",
+    bodyStream: true,
+  };
+  socket.write(frameOf(encodeV1(head)));
+  socket.write(frameOf(encodeV1({ chunk: true }, new TextEncoder().encode("first "), true)));
+  await Bun.sleep(300);
+  expect(arrivals.map((a) => a.text)).toEqual(["first "]);
+  socket.write(frameOf(encodeV1({ chunk: true }, new TextEncoder().encode("second"), true)));
+  socket.write(frameOf(encodeV1({ end: true }, undefined, true)));
+  for (let i = 0; i < 100 && replies.length === 0; i++) await Bun.sleep(20);
+  const jsonLength = replies[0].readUInt32LE(1);
+  expect(JSON.parse(replies[0].subarray(5, 5 + jsonLength).toString())).toMatchObject({ ok: true, status: 200 });
+  expect(replies[0].subarray(5 + jsonLength).toString()).toBe("first second");
+  expect(arrivals[1].at - arrivals[0].at).toBeGreaterThan(200);
+  // The broker says it takes streamed bodies.
+  expect(await b.dispatch({ op: "ping" })).toMatchObject({ bodyStream: true });
+  socket.destroy();
+  server.stop();
+});

package/src/broker.ts

@@ -150,6 +150,7 @@ type R2Row = {
   http_json: string;
   custom_json: string;
   blob_id: string | null;
+  md5?: string | null;
 };
 type R2UploadRow = {
   key: string;
@@ -195,9 +196,11 @@ export type Broker = {
    * `service.fetch` in flight then stops its upstream request too. With `emit`, a
    * `fetch` or `service.fetch` that asks to stream (`stream: true`) sends its head and
    * each body chunk through it as they arrive (FRAME_V1_MORE frames); the returned
-   * frame ends the response.
+   * frame ends the response. With `body`, a `fetch` or `service.fetch` whose head asked
+   * for it (`bodyStream: true`) sends that stream as its request body: the listener feeds
+   * it from the FRAME_V1_MORE frames that follow the head on the same connection.
    */
-  handleFrame(payload: Buffer, signal?: AbortSignal, emit?: FrameEmitter): Promise<Buffer>;
+  handleFrame(payload: Buffer, signal?: AbortSignal, emit?: FrameEmitter, body?: ReadableStream<Uint8Array>): Promise<Buffer>;
   /** Serve one reserved direct R2 upload or download request. */
   transfer(request: Request): Promise<Response>;
   close(): void;
@@ -317,6 +320,8 @@ export function createBroker(opts: BrokerOptions = {}): Broker {
     );
     const r2Columns = conn.query<{ name: string }, []>("PRAGMA table_info(r2)").all();
     if (!r2Columns.some((column) => column.name === "blob_id")) conn.exec("ALTER TABLE r2 ADD COLUMN blob_id TEXT");
+    // The MD5 of an object's bytes, its etag from compatibility date 2026-10-26 (r2.md5).
+    if (!r2Columns.some((column) => column.name === "md5")) conn.exec("ALTER TABLE r2 ADD COLUMN md5 TEXT");
     conn.exec(
       "CREATE TABLE IF NOT EXISTS r2_upload (bucket TEXT NOT NULL, key TEXT NOT NULL, upload_id TEXT NOT NULL, " +
         "uploaded TEXT NOT NULL, http_json TEXT NOT NULL DEFAULT '{}', custom_json TEXT NOT NULL DEFAULT '{}', " +
@@ -1095,6 +1100,38 @@ export function createBroker(opts: BrokerOptions = {}): Broker {
     return r2Row(row);
   };
 
+  // One page of r2.list for the shim from 2026-10-26: at most LIMIT entries after CURSOR,
+  // keys under PREFIX, those holding DELIMITER after it grouped into delimitedPrefixes (a
+  // group counts as one entry). Same rules as the embedded transport's __sbR2ListPage.
+  // ponytail: with a delimiter every key after the cursor is read; an index on the
+  // delimited prefix if buckets grow past ~100k keys.
+  const r2ListPage = (store: Database, bucket: string, prefix: string, cursor: string, limit: number, delimiter: string) => {
+    const rows = store
+      .query<R2Row, [string, string, string]>(
+        "SELECT * FROM r2 WHERE bucket = ?1 AND substr(key, 1, length(?2)) = ?2 AND key > ?3 ORDER BY key" +
+          (delimiter ? "" : ` LIMIT ${limit + 1}`),
+      )
+      .all(bucket, prefix, cursor);
+    const objects: ReturnType<typeof r2Row>[] = [];
+    const delimitedPrefixes: string[] = [];
+    let last = "";
+    let truncated = false;
+    for (const row of rows) {
+      const at = delimiter ? row.key.indexOf(delimiter, prefix.length) : -1;
+      const group = at < 0 ? "" : row.key.slice(0, at + delimiter.length);
+      if (!group || delimitedPrefixes[delimitedPrefixes.length - 1] !== group) {
+        if (objects.length + delimitedPrefixes.length >= limit) {
+          truncated = true;
+          break;
+        }
+        if (group) delimitedPrefixes.push(group);
+        else objects.push(r2Row(row));
+      }
+      last = row.key;
+    }
+    return { ok: true, objects, delimitedPrefixes, truncated, cursor: truncated ? last : "" };
+  };
+
   const r2Row = (r: R2Row) => ({
     key: r.key,
     size: r.size,
@@ -1102,6 +1139,7 @@ export function createBroker(opts: BrokerOptions = {}): Broker {
     uploaded: r.uploaded,
     httpMetadata: parseJsonValue(r.http_json),
     customMetadata: parseJsonValue(r.custom_json),
+    md5: r.md5 ?? null,
   });
 
   /**
@@ -1192,7 +1230,7 @@ export function createBroker(opts: BrokerOptions = {}): Broker {
     }
   }
 
-  async function proxyFetch(msg: Frame, signal?: AbortSignal, emit?: FrameEmitter): Promise<Upstream> {
+  async function proxyFetch(msg: Frame, signal?: AbortSignal, emit?: FrameEmitter, body?: ReadableStream<Uint8Array>): Promise<Upstream> {
     let url: URL;
     try {
       url = new URL(str(msg.url));
@@ -1211,7 +1249,7 @@ export function createBroker(opts: BrokerOptions = {}): Broker {
     const init: RequestInit = {
       method,
       headers,
-      body: method === "GET" || method === "HEAD" ? undefined : upstreamBody(msg),
+      body: method === "GET" || method === "HEAD" ? undefined : (body ?? upstreamBody(msg)),
       redirect: "manual",
       signal,
     };
@@ -1232,7 +1270,7 @@ export function createBroker(opts: BrokerOptions = {}): Broker {
    * minus the trip through the network (and therefore minus TLS and the
    * default-deny egress rules, which is why this is not `fetch`).
    */
-  async function serviceFetch(msg: Frame, signal?: AbortSignal, emit?: FrameEmitter): Promise<Upstream> {
+  async function serviceFetch(msg: Frame, signal?: AbortSignal, emit?: FrameEmitter, body?: ReadableStream<Uint8Array>): Promise<Upstream> {
     const binding = str(msg.binding);
     const declared = bindings.services.find((entry) => entry.binding === binding);
     if (!declared) throw new Error(`service not bound: ${binding}`);
@@ -1266,7 +1304,7 @@ export function createBroker(opts: BrokerOptions = {}): Broker {
     const res = await doFetch(target, {
       method,
       headers,
-      body: method === "GET" || method === "HEAD" ? undefined : upstreamBody(msg),
+      body: method === "GET" || method === "HEAD" ? undefined : (body ?? upstreamBody(msg)),
       redirect: "manual",
       signal,
     });
@@ -1279,7 +1317,8 @@ export function createBroker(opts: BrokerOptions = {}): Broker {
   async function dispatch(msg: Frame): Promise<Frame> {
     switch (msg.op) {
       case "ping":
-        return { ok: true, op: "pong", echo: msg.msg ?? null, pid: process.pid };
+        // bodyStream: this broker takes streamed request bodies (FRAME_V1_MORE frames after a head).
+        return { ok: true, op: "pong", echo: msg.msg ?? null, pid: process.pid, bodyStream: true };
       case "kv.get": {
         const { store, part } = storeFor("kv", requireKv(msg.ns));
         const stmts = kvStmts(store);
@@ -1543,14 +1582,22 @@ export function createBroker(opts: BrokerOptions = {}): Broker {
         if (row) r2DeleteBlob(store, bucket, key, row.blob_id);
         return { ok: true };
       }
+      case "r2.md5": {
+        // Recorded after the put that wrote these bytes (etag): the shim from 2026-10-26 hashes them.
+        const { store, part: bucket } = storeFor("r2", requireR2(msg.bucket));
+        store.query("UPDATE r2 SET md5 = ?1 WHERE bucket = ?2 AND key = ?3 AND etag = ?4").run(str(msg.md5), bucket, str(msg.key), str(msg.etag));
+        return { ok: true };
+      }
       case "r2.list": {
+        // The prefix matches exactly at every date: LIKE ignored case and read "_" and "%" as wildcards.
         const { store, part: bucket } = storeFor("r2", requireR2(msg.bucket));
         const prefix = str(msg.prefix);
         const cursor = str(msg.cursor);
-        const limit = Math.min(Math.max(Number(msg.limit) || 1000, 1), 1000);
+        const limit = Math.min(Math.max(Math.floor(Number(msg.limit)) || 1000, 1), 1000);
+        if (msg.page === true) return r2ListPage(store, bucket, prefix, cursor, limit, str(msg.delimiter));
         const rows = store
           .query<R2Row, [string, string, string, number]>(
-            "SELECT * FROM r2 WHERE bucket = ? AND key LIKE ? || '%' AND key > ? ORDER BY key LIMIT ?",
+            "SELECT * FROM r2 WHERE bucket = ?1 AND substr(key, 1, length(?2)) = ?2 AND key > ?3 ORDER BY key LIMIT ?4",
           )
           .all(bucket, prefix, cursor, limit + 1);
         const truncated = rows.length > limit;
@@ -1741,6 +1788,7 @@ export function createBroker(opts: BrokerOptions = {}): Broker {
     binary: Uint8Array,
     signal?: AbortSignal,
     emit?: FrameEmitter,
+    body?: ReadableStream<Uint8Array>,
   ): Promise<{ reply: Frame; bytes?: Uint8Array }> {
     if (msg.op === "r2.put") {
       // The body arrived as bytes; write it straight to its own file rather
@@ -1791,8 +1839,8 @@ export function createBroker(opts: BrokerOptions = {}): Broker {
     }
 
     // #232 — a v1 fetch gets the upstream body as raw bytes, not decoded text.
-    if (msg.op === "fetch") return proxyFetch(msg, signal, emit);
-    if (msg.op === "service.fetch") return serviceFetch(msg, signal, emit);
+    if (msg.op === "fetch") return proxyFetch(msg, signal, emit, body);
+    if (msg.op === "service.fetch") return serviceFetch(msg, signal, emit, body);
 
     if (msg.op === "assets.get") {
       if (!bindings.assets) throw new Error("assets not bound");
@@ -1824,7 +1872,7 @@ export function createBroker(opts: BrokerOptions = {}): Broker {
   }
 
   /** One wire frame in, one out. See `handleFrame` on the Broker type. */
-  async function handleFrame(payload: Buffer, signal?: AbortSignal, emit?: FrameEmitter): Promise<Buffer> {
+  async function handleFrame(payload: Buffer, signal?: AbortSignal, emit?: FrameEmitter, body?: ReadableStream<Uint8Array>): Promise<Buffer> {
     if (payload.length === 0 || payload[0] !== FRAME_V1) {
       return encodeFrame(await handlePayload(payload.toString("utf8")));
     }
@@ -1840,7 +1888,7 @@ export function createBroker(opts: BrokerOptions = {}): Broker {
         const seen = replayed.get(replayKey);
         if (seen) return frameOf(encodeV1(seen));
       }
-      const { reply, bytes } = await dispatchBinary(msg, binary, signal, emit);
+      const { reply, bytes } = await dispatchBinary(msg, binary, signal, emit, body);
       if (replayKey && REPLAYABLE.has(str(msg.op))) rememberReplay(replayKey, reply);
       return frameOf(encodeV1(reply, bytes));
     } catch (e) {
@@ -1876,6 +1924,7 @@ export function createBroker(opts: BrokerOptions = {}): Broker {
     "r2.multipart.abort",
     "r2.transfer.create",
     "r2.delete",
+    "r2.md5",
     "do.storage.put",
     "do.storage.delete",
     "do.storage.delete_all",
@@ -2193,6 +2242,85 @@ export function encodeFrame(obj: Frame): Buffer {
 /** The bound TCP listener: the port actually assigned, and its shutdown handle. */
 export type BrokerServer = { port: number; stop(): void };
 
+/** Whether a payload is the head of a fetch whose request body follows in FRAME_V1_MORE frames. */
+function bodyStreamHead(payload: Buffer): boolean {
+  if (payload.length < 5 || payload[0] !== FRAME_V1) return false;
+  const jsonLen = payload.readUInt32LE(1);
+  if (5 + jsonLen > payload.length) return false;
+  const head = payload.subarray(5, 5 + jsonLen).toString("utf8");
+  // Cheap first: most frames are not this.
+  if (!head.includes('"bodyStream":true')) return false;
+  const msg = jsonObject(parseJsonValue(head));
+  return msg?.bodyStream === true;
+}
+
+/** The request body of a streamed-body request, fed by the frames after its head. */
+type BodySink = {
+  stream: ReadableStream<Uint8Array>;
+  /** A FRAME_V1_MORE payload: `{ chunk: true }` plus bytes, `{ end: true }`, or `{ error }`. */
+  frame(payload: Buffer): void;
+  fail(reason: string): void;
+};
+/** Bytes a streamed request body may hold unread before the sprout's connection is paused. */
+const BODY_SINK_HIGH = 4 * 1024 * 1024;
+function bodySink(socket: { pause(): void; resume(): void }): BodySink {
+  let controller: ReadableStreamDefaultController<Uint8Array> | null = null;
+  let finished = false;
+  let paused = false;
+  const resume = () => {
+    if (paused) {
+      paused = false;
+      socket.resume();
+    }
+  };
+  const finish = () => {
+    finished = true;
+    resume();
+  };
+  const stream = new ReadableStream<Uint8Array>(
+    {
+      start(c) {
+        controller = c;
+      },
+      pull() {
+        resume();
+      },
+      cancel() {
+        finish();
+      },
+    },
+    new ByteLengthQueuingStrategy({ highWaterMark: BODY_SINK_HIGH }),
+  );
+  return {
+    stream,
+    frame(payload) {
+      if (finished || !controller || payload.length < 5) return;
+      const jsonLen = payload.readUInt32LE(1);
+      const msg = jsonObject(parseJsonValue(payload.subarray(5, 5 + jsonLen).toString("utf8")));
+      if (msg?.chunk === true) {
+        const bytes = payload.subarray(5 + jsonLen);
+        if (bytes.length) controller.enqueue(new Uint8Array(bytes));
+        if ((controller.desiredSize ?? 1) <= 0 && !paused) {
+          paused = true;
+          socket.pause();
+        }
+        return;
+      }
+      finish();
+      if (msg?.end === true) controller.close();
+      else {
+        const error = msg?.error;
+        controller.error(new Error(isString(error) ? error : "the request body failed"));
+      }
+    },
+    fail(reason) {
+      if (finished) return;
+      finish();
+      controller?.error(new Error(reason));
+    },
+  };
+}
+
 /** Start the TCP listener. Returns the bound port. */
 export function listen(broker: Broker, hostname: string, port: number): BrokerServer {
   // Chunks are held in a list and joined once, when a whole frame has arrived.
@@ -2209,6 +2337,8 @@ export function listen(broker: Broker, hostname: string, port: number): BrokerSe
     written: (() => void) | null;
     /** Aborted when the connection closes, so upstream requests it started stop. */
     abort: AbortController;
+    /** The request body a streamed-body request on this connection is reading, if any. */
+    sink: BodySink | null;
   };
   const flush = (socket: Bun.Socket<SocketState>): void => {
     const state = socket.data;
@@ -2246,6 +2376,7 @@ export function listen(broker: Broker, hostname: string, port: number): BrokerSe
           offset: 0,
           written: null,
           abort: new AbortController(),
+          sink: null,
         };
       },
       drain: flush,
@@ -2256,6 +2387,7 @@ export function listen(broker: Broker, hostname: string, port: number): BrokerSe
         state.chunks = [];
         state.size = 0;
         state.output = null;
+        state.sink?.fail("the sprout closed the connection");
         const done = state.written;
         state.written = null;
         done?.();
@@ -2286,6 +2418,23 @@ export function listen(broker: Broker, hostname: string, port: number): BrokerSe
           const rest = buf.subarray(4 + len);
           state.chunks = rest.length ? [Buffer.from(rest)] : [];
           state.size = rest.length;
+          // A frame of a streamed request body: to its request's stream.
+          if (payload.length > 0 && payload[0] === FRAME_V1_MORE) {
+            state.sink?.frame(payload);
+            continue;
+          }
+          // A request whose body follows in frames: it runs while this loop feeds them.
+          if (bodyStreamHead(payload)) {
+            const sink = bodySink(socket);
+            state.sink = sink;
+            void (async () => {
+              const reply = await broker.handleFrame(payload, state.abort.signal, (frame) => send(socket, frame), sink.stream);
+              await send(socket, reply);
+              // Body frames the sprout still sends (the upstream answered early) are dropped.
+              sink.fail("the request already ended");
+            })();
+            continue;
+          }
           // Bun does not buffer unwritten bytes. Serialize replies and retain
           // the unsent suffix until drain, including binary R2 responses.
           await send(socket, await broker.handleFrame(payload, state.abort.signal, (frame) => send(socket, frame)));