@statewalker/webrun-streams-webrtc 0.3.0 → 0.4.0

package/README.md

@@ -144,7 +144,10 @@ Two limits keep memory bounded whatever the speed of either side:
   the previous one, so a slow handler stalls the caller.
 
 Both ends must speak `CREDIT`: a sender facing a peer that never returns
-credit stops after the first window.
+credit stops after the first window. The receiver enforces the window too: a
+peer that sends more than the window plus the credit it was returned fails the
+call. The receiver drops what it queued, closes the channel, and its side of
+the call throws (on the responder, the handler's input throws).
 
 Each side keeps listening for `CREDIT` until both directions are done, so a
 reply larger than the window, sent after the input ended, still flows. When
@@ -213,10 +216,15 @@ a one-chunk bound.
 
 `END` means "I am done sending", and the peer answers it by carrying on, so it
 cannot express "stop". When the caller leaves early (`.return()` on the call's
-generator, or an error), `duplexOverDataChannel` waits for its own outbound
-pump to settle and then closes the channel. On the responder, the channel's
-`close` event ends the inbound side with `TransportClosedError`, which closes
-the handler's input and runs the handler's `finally`.
+generator, or an error), `duplexOverDataChannel` closes the channel and then
+waits for its own outbound pump to settle. On the responder, the channel's
+`close` event ends the inbound side with `TransportClosedError`; a caller whose
+input throws sends `ERROR` instead, which ends it with that error. Either way
+the handler's input ends with the error (its next read throws it, so a handler
+never takes a truncated upload for a complete one) before the responder waits
+for its own outbound pump, which may be waiting for the handler's next output.
+The handler's `finally` then runs, whether it was reading its input or
+producing output.
 
 On a normal finish the outbound pump is not awaited. The responder feeds the
 handler's input from this generator and closes that input only when the
@@ -243,6 +251,7 @@ SDP, must be opened before `serve` is registered or on a different connection.
 | Channel closes before it opens | `DataChannel closed before open` |
 | Channel error before it opens | `DataChannel error: <message or "unknown">` |
 | Channel closes before the peer sent `END` | `TransportClosedError` (`transport closed`) |
+| The peer sends past the receive window without credit | `webrun-streams-webrtc: the peer sent past the receive window (4194304 bytes) without credit` |
 | Handler throws | The caller's `for await` throws the deserialised error, with `message`, `stack` and custom fields |
 
 On the responder, a channel task that fails (usually a caller that cancelled)

package/dist/connect-serve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connect-serve.d.ts","sourceRoot":"","sources":["../src/connect-serve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAU,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAI1E,MAAM,WAAW,YAAY;IAC3B,wGAAwG;IACxG,EAAE,EAAE,iBAAiB,CAAC;CACvB;AAED;;;;GAIG;AACH,eAAO,MAAM,OAAO,EAAE,OAAO,CAAC,YAAY,CA0CzC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,YAAY,CA0CrC,CAAC"}
+{"version":3,"file":"connect-serve.d.ts","sourceRoot":"","sources":["../src/connect-serve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAU,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAS1E,MAAM,WAAW,YAAY;IAC3B,wGAAwG;IACxG,EAAE,EAAE,iBAAiB,CAAC;CACvB;AAED;;;;GAIG;AACH,eAAO,MAAM,OAAO,EAAE,OAAO,CAAC,YAAY,CAyCzC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,YAAY,CA+CrC,CAAC"}

package/dist/duplex-over-data-channel.d.ts

@@ -12,6 +12,9 @@ export declare const LOW_WATER_MARK: number;
  * whether or not anyone reads, so without credit a slow reader's queue grows without bound. The
  * window is larger than the send buffer's high-water mark so a long round trip does not throttle a
  * fast link: the buffer limit is what bounds the sender's memory.
+ *
+ * The receiver enforces it: a peer that sends more than the window plus the credit returned fails
+ * the call (the queued payload is dropped, the stream throws, the channel is closed).
  */
 export declare const RECEIVE_WINDOW: number;
 export declare function markAnswering(dc: RTCDataChannel): void;
@@ -34,4 +37,15 @@ export declare function holdEvents(dc: RTCDataChannel): void;
  * closed once both sides have ended.
  */
 export declare function duplexOverDataChannel(dc: RTCDataChannel, input: AsyncIterable<Uint8Array>): AsyncGenerator<Uint8Array>;
+export interface RunStreamHooks {
+    /**
+     * Called once when the inbound side fails (the peer's `ERROR`, the channel closing, a peer
+     * past the receive window), before the stream waits for its outbound pump to settle. A
+     * responder ends its handler's input here: the pump may be waiting for the handler's next
+     * output while the handler waits for its next input.
+     */
+    onInboundFailed?(err: Error): void;
+}
+/** {@link duplexOverDataChannel}, with hooks for `serve` */
+export declare function runStream(dc: RTCDataChannel, input: AsyncIterable<Uint8Array> | Iterable<Uint8Array>, hooks?: RunStreamHooks): AsyncGenerator<Uint8Array>;
 //# sourceMappingURL=duplex-over-data-channel.d.ts.map

package/dist/duplex-over-data-channel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"duplex-over-data-channel.d.ts","sourceRoot":"","sources":["../src/duplex-over-data-channel.ts"],"names":[],"mappings":"AAcA;;;;GAIG;AACH,eAAO,MAAM,eAAe,QAAc,CAAC;AAC3C,eAAO,MAAM,cAAc,QAAa,CAAC;AACzC;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,QAAkB,CAAC;AAoB9C,wBAAgB,aAAa,CAAC,EAAE,EAAE,cAAc,GAAG,IAAI,CAEtD;AAED,uFAAuF;AACvF,wBAAgB,UAAU,CAAC,EAAE,EAAE,cAAc,GAAG,IAAI,CAUnD;AAWD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,cAAc,EAClB,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,GAC/B,cAAc,CAAC,UAAU,CAAC,CAE5B"}
+{"version":3,"file":"duplex-over-data-channel.d.ts","sourceRoot":"","sources":["../src/duplex-over-data-channel.ts"],"names":[],"mappings":"AAcA;;;;GAIG;AACH,eAAO,MAAM,eAAe,QAAc,CAAC;AAC3C,eAAO,MAAM,cAAc,QAAa,CAAC;AACzC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,QAAkB,CAAC;AAoB9C,wBAAgB,aAAa,CAAC,EAAE,EAAE,cAAc,GAAG,IAAI,CAEtD;AAED,uFAAuF;AACvF,wBAAgB,UAAU,CAAC,EAAE,EAAE,cAAc,GAAG,IAAI,CAUnD;AAWD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,cAAc,EAClB,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,GAC/B,cAAc,CAAC,UAAU,CAAC,CAE5B;AAED,MAAM,WAAW,cAAc;IAC7B;;;;;OAKG;IACH,eAAe,CAAC,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,CAAC;CACpC;AAED,4DAA4D;AAC5D,wBAAuB,SAAS,CAC9B,EAAE,EAAE,cAAc,EAClB,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,QAAQ,CAAC,UAAU,CAAC,EACvD,KAAK,GAAE,cAAmB,GACzB,cAAc,CAAC,UAAU,CAAC,CA4O5B"}

package/dist/index.js

@@ -12,6 +12,9 @@ const LOW_WATER_MARK = 262144;
 * whether or not anyone reads, so without credit a slow reader's queue grows without bound. The
 * window is larger than the send buffer's high-water mark so a long round trip does not throttle a
 * fast link: the buffer limit is what bounds the sender's memory.
+*
+* The receiver enforces it: a peer that sends more than the window plus the credit returned fails
+* the call (the queued payload is dropped, the stream throws, the channel is closed).
 */
 const RECEIVE_WINDOW = 4194304;
 const textEncoder = new TextEncoder();
@@ -74,13 +77,17 @@ function takeHeld(dc) {
 function duplexOverDataChannel(dc, input) {
 	return runStream(dc, input);
 }
-async function* runStream(dc, input) {
+/** {@link duplexOverDataChannel}, with hooks for `serve` */
+async function* runStream(dc, input, hooks = {}) {
 	dc.binaryType = "arraybuffer";
 	const incoming = makeInboundQueue();
 	let peerEnded = false;
 	let localEnded = false;
 	let credit = RECEIVE_WINDOW;
 	let pulled = 0;
+	/** what the peer may still send us: the window plus the credit we returned, less what came */
+	let allowance = RECEIVE_WINDOW;
+	let overrun = false;
 	let wakeSender = null;
 	const nudge = () => {
 		const w = wakeSender;
@@ -108,10 +115,11 @@ async function* runStream(dc, input) {
 		const frame = /* @__PURE__ */ new Uint8Array(5);
 		frame[0] = TYPE_CREDIT;
 		new DataView(frame.buffer).setUint32(1, pulled);
-		pulled = 0;
 		try {
 			sendRaw(frame);
+			allowance += pulled;
 		} catch {}
+		pulled = 0;
 	};
 	const maybeClose = () => {
 		if (peerEnded && localEnded && !answering.has(dc)) try {
@@ -130,8 +138,22 @@ async function* runStream(dc, input) {
 		if (bytes.byteLength === 0) return;
 		const type = bytes[0];
 		const payload = bytes.subarray(1);
-		if (type === TYPE_DATA) incoming.push(new Uint8Array(payload));
-		else if (type === TYPE_END) {
+		if (type === TYPE_DATA) {
+			if (overrun) return;
+			allowance -= payload.byteLength;
+			if (allowance < 0) {
+				overrun = true;
+				peerEnded = true;
+				incoming.fail(/* @__PURE__ */ new Error(`webrun-streams-webrtc: the peer sent past the receive window (${RECEIVE_WINDOW} bytes) without credit`));
+				aborted = true;
+				nudge();
+				try {
+					dc.close();
+				} catch {}
+				return;
+			}
+			incoming.push(new Uint8Array(payload));
+		} else if (type === TYPE_END) {
 			peerEnded = true;
 			incoming.done();
 			maybeClose();
@@ -202,12 +224,16 @@ async function* runStream(dc, input) {
 		}
 	})();
 	let inboundDrained = false;
+	let inboundError;
 	try {
 		for await (const chunk of incoming.iterate()) {
 			yield chunk;
 			consumed(chunk.byteLength);
 		}
 		inboundDrained = true;
+	} catch (err) {
+		inboundError = err instanceof Error ? err : new Error(String(err));
+		throw err;
 	} finally {
 		inboundFinished = true;
 		detach();
@@ -217,6 +243,7 @@ async function* runStream(dc, input) {
 			try {
 				dc.close();
 			} catch {}
+			if (inboundError) hooks.onInboundFailed?.(inboundError);
 			await outbound.catch(() => {});
 		}
 	}
@@ -242,6 +269,15 @@ function makeInboundQueue() {
 			});
 			wake?.();
 		},
+		fail(err) {
+			if (closed) return;
+			slots.length = 0;
+			slots.push({
+				type: "done",
+				err
+			});
+			wake?.();
+		},
 		iterate() {
 			return (async function* () {
 				try {
@@ -483,12 +519,10 @@ const connect = async ({ pc }) => {
 	let counter = 0;
 	let closed = false;
 	const open = /* @__PURE__ */ new Set();
-	const onConnectionClose = () => {
-		closed = true;
+	const onStateChange = () => {
+		if (pc.connectionState === "closed" || pc.connectionState === "failed") closed = true;
 	};
-	pc.addEventListener("connectionstatechange", () => {
-		if (pc.connectionState === "closed" || pc.connectionState === "failed") onConnectionClose();
-	});
+	pc.addEventListener("connectionstatechange", onStateChange);
 	const call = (input) => {
 		if (closed) return (async function* () {
 			throw new Error("webrun-streams-webrtc: connection closed");
@@ -507,6 +541,7 @@ const connect = async ({ pc }) => {
 		call,
 		async close() {
 			closed = true;
+			pc.removeEventListener("connectionstatechange", onStateChange);
 			for (const dc of open) try {
 				dc.close();
 			} catch {}
@@ -537,10 +572,11 @@ const serve = async ({ pc }, handler) => {
 					peek.release();
 				}
 			})();
-			for await (const chunk of duplexOverDataChannel(dc, out)) await inputFromPeer.deliver(chunk);
-			inputFromPeer.done();
-		})().catch(() => {
-			inputFromPeer?.done();
+			const inbound = runStream(dc, out, { onInboundFailed: (err) => peek.done(err) });
+			for await (const chunk of inbound) await peek.deliver(chunk);
+			peek.done();
+		})().catch((err) => {
+			inputFromPeer?.done(err instanceof Error ? err : new Error(String(err)));
 		});
 	};
 	pc.addEventListener("datachannel", onChannel);
@@ -597,6 +633,7 @@ function peekInput(_dc) {
 	const slots = [];
 	let wake = null;
 	let closed = false;
+	let ended = false;
 	const input = (async function* () {
 		try {
 			while (true) {
@@ -609,7 +646,10 @@ function peekInput(_dc) {
 				}
 				const slot = slots.shift();
 				if (!slot) continue;
-				if (slot.type === "done") return;
+				if (slot.type === "done") {
+					if (slot.err) throw slot.err;
+					return;
+				}
 				slot.taken();
 				yield slot.value;
 			}
@@ -635,9 +675,13 @@ function peekInput(_dc) {
 				wake?.();
 			});
 		},
-		done() {
-			if (closed) return;
-			slots.push({ type: "done" });
+		done(err) {
+			if (closed || ended) return;
+			ended = true;
+			slots.push({
+				type: "done",
+				err
+			});
 			wake?.();
 		},
 		release

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statewalker/webrun-streams-webrtc",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "private": false,
   "type": "module",
   "description": "WebRTC DataChannel-backed Connect/Serve adapter (native multi-stream) in the webrun-streams-* family",
@@ -30,7 +30,7 @@
     "src"
   ],
   "dependencies": {
-    "@statewalker/webrun-streams": "^0.3.0"
+    "@statewalker/webrun-streams": "^0.4.0"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.5.15",
@@ -42,9 +42,9 @@
     "rolldown": "^1.2.12",
     "typescript": "^7.0.2",
     "vitest": "^5.0.5",
-    "@statewalker/webrun-msgpack": "^0.10.0",
-    "@statewalker/webrun-streams-conformance": "^0.4.0",
-    "@statewalker/webrun-rpc": "^0.11.0"
+    "@statewalker/webrun-msgpack": "^0.11.0",
+    "@statewalker/webrun-rpc": "^0.12.0",
+    "@statewalker/webrun-streams-conformance": "^0.5.0"
   },
   "sideEffects": false,
   "publishConfig": {
@@ -55,6 +55,8 @@
     "build": "rimraf dist && rolldown -c && tsc --emitDeclarationOnly --declaration",
     "test": "vitest run",
     "test:browser": "vitest run --config vitest.browser.config.ts",
+    "typecheck": "tsc --noEmit",
+    "typecheck:tests": "tsc -p tsconfig.tests.json",
     "lint": "biome check src tests"
   }
 }

package/src/connect-serve.ts

@@ -1,5 +1,10 @@
 import type { Connect, Duplex, Serve } from "@statewalker/webrun-streams";
-import { duplexOverDataChannel, holdEvents, markAnswering } from "./duplex-over-data-channel.js";
+import {
+  duplexOverDataChannel,
+  holdEvents,
+  markAnswering,
+  runStream,
+} from "./duplex-over-data-channel.js";
 import { PORT_LABEL_PREFIX } from "./port-mux.js";
 
 export interface WebRtcParams {
@@ -16,12 +21,10 @@ export const connect: Connect<WebRtcParams> = async ({ pc }) => {
   let counter = 0;
   let closed = false;
   const open = new Set<RTCDataChannel>();
-  const onConnectionClose = (): void => {
-    closed = true;
+  const onStateChange = (): void => {
+    if (pc.connectionState === "closed" || pc.connectionState === "failed") closed = true;
   };
-  pc.addEventListener("connectionstatechange", () => {
-    if (pc.connectionState === "closed" || pc.connectionState === "failed") onConnectionClose();
-  });
+  pc.addEventListener("connectionstatechange", onStateChange);
 
   const call: Duplex = (input) => {
     if (closed) {
@@ -45,6 +48,7 @@ export const connect: Connect<WebRtcParams> = async ({ pc }) => {
     call,
     async close() {
       closed = true;
+      pc.removeEventListener("connectionstatechange", onStateChange);
       for (const dc of open) {
         try {
           dc.close();
@@ -82,18 +86,23 @@ export const serve: Serve<WebRtcParams> = async ({ pc }, handler: Duplex) => {
           peek.release();
         }
       })();
-      // the next chunk is pulled (and its credit returned) only once the handler took this one
-      for await (const chunk of duplexOverDataChannel(dc, out)) {
-        await inputFromPeer.deliver(chunk);
+      // The next chunk is pulled (and its credit returned) only once the handler took this one.
+      // When the inbound side fails (the caller cancelled and closed the channel, or its input
+      // threw), the handler's input ends with that error before the stream waits for its outbound
+      // pump: the pump may be waiting for the handler's output, the handler for its input.
+      const inbound = runStream(dc, out, { onInboundFailed: (err) => peek.done(err) });
+      for await (const chunk of inbound) {
+        await peek.deliver(chunk);
       }
-      inputFromPeer.done();
-    })().catch(() => {
+      peek.done();
+    })().catch((err: unknown) => {
       // A caller that cancels mid-response closes the DataChannel, which
       // surfaces here as TransportClosedError. That is the cancellation
       // working, not a fault: this task is fire-and-forget, so without a
-      // catch it becomes an unhandled rejection that fails the page. Closing
-      // the handler's input is what runs the handler's own `finally`.
-      inputFromPeer?.done();
+      // catch it becomes an unhandled rejection that fails the page. Ending
+      // the handler's input (with the error, so a handler does not take a
+      // truncated upload for a complete one) is what runs its own `finally`.
+      inputFromPeer?.done(err instanceof Error ? err : new Error(String(err)));
     });
   };
   pc.addEventListener("datachannel", onChannel);
@@ -155,7 +164,8 @@ interface PeekInput {
   input: AsyncGenerator<Uint8Array>;
   /** resolves once the handler has taken the chunk (or stopped reading) */
   deliver(chunk: Uint8Array): Promise<void>;
-  done(): void;
+  /** ends the input after the chunks already delivered; with `err`, the handler's read throws it */
+  done(err?: Error): void;
   /** the handler is finished: pending and later chunks are dropped */
   release(): void;
 }
@@ -171,10 +181,12 @@ interface PeekInput {
  * the handler's input queue.
  */
 function peekInput(_dc: RTCDataChannel): PeekInput {
-  const slots: Array<{ type: "value"; value: Uint8Array; taken: () => void } | { type: "done" }> =
-    [];
+  const slots: Array<
+    { type: "value"; value: Uint8Array; taken: () => void } | { type: "done"; err?: Error }
+  > = [];
   let wake: (() => void) | null = null;
   let closed = false;
+  let ended = false;
   const input = (async function* () {
     try {
       while (true) {
@@ -187,7 +199,10 @@ function peekInput(_dc: RTCDataChannel): PeekInput {
         }
         const slot = slots.shift();
         if (!slot) continue;
-        if (slot.type === "done") return;
+        if (slot.type === "done") {
+          if (slot.err) throw slot.err;
+          return;
+        }
         slot.taken();
         yield slot.value;
       }
@@ -209,9 +224,10 @@ function peekInput(_dc: RTCDataChannel): PeekInput {
         wake?.();
       });
     },
-    done(): void {
-      if (closed) return;
-      slots.push({ type: "done" });
+    done(err?: Error): void {
+      if (closed || ended) return;
+      ended = true;
+      slots.push({ type: "done", err });
       wake?.();
     },
     release,

package/src/duplex-over-data-channel.ts

@@ -26,6 +26,9 @@ export const LOW_WATER_MARK = 256 * 1024;
  * whether or not anyone reads, so without credit a slow reader's queue grows without bound. The
  * window is larger than the send buffer's high-water mark so a long round trip does not throttle a
  * fast link: the buffer limit is what bounds the sender's memory.
+ *
+ * The receiver enforces it: a peer that sends more than the window plus the credit returned fails
+ * the call (the queued payload is dropped, the stream throws, the channel is closed).
  */
 export const RECEIVE_WINDOW = 4 * 1024 * 1024;
 const FRAME_OVERHEAD = 1; // 1-byte type tag
@@ -96,9 +99,21 @@ export function duplexOverDataChannel(
   return runStream(dc, input);
 }
 
-async function* runStream(
+export interface RunStreamHooks {
+  /**
+   * Called once when the inbound side fails (the peer's `ERROR`, the channel closing, a peer
+   * past the receive window), before the stream waits for its outbound pump to settle. A
+   * responder ends its handler's input here: the pump may be waiting for the handler's next
+   * output while the handler waits for its next input.
+   */
+  onInboundFailed?(err: Error): void;
+}
+
+/** {@link duplexOverDataChannel}, with hooks for `serve` */
+export async function* runStream(
   dc: RTCDataChannel,
   input: AsyncIterable<Uint8Array> | Iterable<Uint8Array>,
+  hooks: RunStreamHooks = {},
 ): AsyncGenerator<Uint8Array> {
   dc.binaryType = "arraybuffer";
 
@@ -109,6 +124,9 @@ async function* runStream(
   // flow control: what the peer still lets us send, and what our consumer has pulled
   let credit = RECEIVE_WINDOW;
   let pulled = 0;
+  /** what the peer may still send us: the window plus the credit we returned, less what came */
+  let allowance = RECEIVE_WINDOW;
+  let overrun = false;
   let wakeSender: (() => void) | null = null;
   const nudge = (): void => {
     const w = wakeSender;
@@ -142,12 +160,13 @@ async function* runStream(
     const frame = new Uint8Array(5);
     frame[0] = TYPE_CREDIT;
     new DataView(frame.buffer).setUint32(1, pulled);
-    pulled = 0;
     try {
       sendRaw(frame);
+      allowance += pulled;
     } catch {
       /* closing */
     }
+    pulled = 0;
   };
 
   const maybeClose = (): void => {
@@ -173,6 +192,27 @@ async function* runStream(
     const type = bytes[0];
     const payload = bytes.subarray(1);
     if (type === TYPE_DATA) {
+      if (overrun) return;
+      allowance -= payload.byteLength;
+      if (allowance < 0) {
+        // the peer ignores credit: fail the call rather than queue without bound
+        overrun = true;
+        peerEnded = true;
+        incoming.fail(
+          new Error(
+            `webrun-streams-webrtc: the peer sent past the receive window (${RECEIVE_WINDOW} bytes) without credit`,
+          ),
+        );
+        // and tell the peer now, not once our consumer reaches the error
+        aborted = true;
+        nudge();
+        try {
+          dc.close();
+        } catch {
+          /* already closing */
+        }
+        return;
+      }
       incoming.push(new Uint8Array(payload));
     } else if (type === TYPE_END) {
       peerEnded = true;
@@ -257,12 +297,16 @@ async function* runStream(
   })();
 
   let inboundDrained = false;
+  let inboundError: Error | undefined;
   try {
     for await (const chunk of incoming.iterate()) {
       yield chunk;
       consumed(chunk.byteLength); // pulled: the peer may send that much again
     }
     inboundDrained = true;
+  } catch (err) {
+    inboundError = err instanceof Error ? err : new Error(String(err));
+    throw err;
   } finally {
     inboundFinished = true;
     detach();
@@ -300,6 +344,9 @@ async function* runStream(
       } catch {
         /* already closing */
       }
+      // A responder's pump may be waiting for the handler's next output while the handler waits
+      // for its next input: end that input (with the error) before waiting on the pump.
+      if (inboundError) hooks.onInboundFailed?.(inboundError);
       await outbound.catch(() => {});
     }
   }
@@ -308,6 +355,8 @@ async function* runStream(
 interface InboundQueue {
   push(chunk: Uint8Array): void;
   done(err?: Error): void;
+  /** drops what is queued and ends with `err` */
+  fail(err: Error): void;
   iterate(): AsyncGenerator<Uint8Array>;
 }
 
@@ -328,6 +377,12 @@ function makeInboundQueue(): InboundQueue {
       slots.push({ type: "done", err });
       wake?.();
     },
+    fail(err: Error): void {
+      if (closed) return;
+      slots.length = 0;
+      slots.push({ type: "done", err });
+      wake?.();
+    },
     iterate(): AsyncGenerator<Uint8Array> {
       return (async function* () {
         try {