@statewalker/webrun-rpc 0.4.3 → 0.5.1

package/dist/async-dispose.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Makes `target` disposable with `await using`: installs `dispose` as its
+ * `[Symbol.asyncDispose]`, where the runtime defines the symbol. Hand-written
+ * iterators lose what a native generator gets from `AsyncIteratorPrototype`;
+ * this gives it back. A no-op where the symbol is missing. Kept off the
+ * declared types, which would require consumers to compile with the
+ * `esnext.disposable` lib.
+ */
+export declare function asyncDisposable<T extends object>(target: T, dispose: () => Promise<unknown>): T;
+//# sourceMappingURL=async-dispose.d.ts.map

package/dist/async-dispose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-dispose.d.ts","sourceRoot":"","sources":["../src/async-dispose.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAa/F"}

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;AAM1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAU1D,uEAAuE;AACvE,MAAM,MAAM,MAAM,GAAG,CAAC,IAAI,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,OAAO,KAAK,OAAO,GAAG,SAAS,CAAC;AAElF;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAE7E,MAAM,WAAW,UAAU;IACzB;;;;;;;;;;OAUG;IACH,GAAG,EAAE,cAAc,CAAC;IACpB;;;yEAGqE;IACrE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,OAAO,EAAE,OAAO,CAAC,UAAU,CA0BvC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,UAAU,CAqDnC,CAAC;AAEF,MAAM,WAAW,eAAe;IAC9B,mFAAmF;IACnF,KAAK,EAAE,SAAS,CAAC;IACjB;;;;OAIG;IACH,IAAI,CAAC,EAAE,WAAW,GAAG,WAAW,CAAC;IACjC,oEAAoE;IACpE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,eAAe,GAAG,cAAc,CAEtF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,cAAc,GAAG,cAAc,CAEjE"}
+{"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;AAM1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAW1D,uEAAuE;AACvE,MAAM,MAAM,MAAM,GAAG,CAAC,IAAI,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,OAAO,KAAK,OAAO,GAAG,SAAS,CAAC;AAElF;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAE7E,MAAM,WAAW,UAAU;IACzB;;;;;;;;;;OAUG;IACH,GAAG,EAAE,cAAc,CAAC;IACpB;;;yEAGqE;IACrE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,OAAO,EAAE,OAAO,CAAC,UAAU,CAyCvC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,UAAU,CAqDnC,CAAC;AAEF,MAAM,WAAW,eAAe;IAC9B,mFAAmF;IACnF,KAAK,EAAE,SAAS,CAAC;IACjB;;;;OAIG;IACH,IAAI,CAAC,EAAE,WAAW,GAAG,WAAW,CAAC;IACjC,oEAAoE;IACpE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,eAAe,GAAG,cAAc,CAEtF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,cAAc,GAAG,cAAc,CAEjE"}

package/dist/duplex-over-port.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"duplex-over-port.d.ts","sourceRoot":"","sources":["../src/duplex-over-port.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,MAAM,EAOZ,MAAM,6BAA6B,CAAC;AAGrC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGzD;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,4BAA4B,CAAC;AActD,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,6CAA6C;IAC7C,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;CACpC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,GAAE,qBAA0B,GAAG,MAAM,CAE/F;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,qBAA0B,GAClC,MAAM,IAAI,CA6BZ"}
+{"version":3,"file":"duplex-over-port.d.ts","sourceRoot":"","sources":["../src/duplex-over-port.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,MAAM,EAOZ,MAAM,6BAA6B,CAAC;AAIrC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAIzD;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,4BAA4B,CAAC;AActD,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,6CAA6C;IAC7C,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;CACpC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,GAAE,qBAA0B,GAAG,MAAM,CAE/F;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,qBAA0B,GAClC,MAAM,IAAI,CA8BZ"}

package/dist/index.d.ts

@@ -10,7 +10,7 @@ export * from "./io-send.js";
 export * from "./listen-bidi.js";
 export * from "./listen-port.js";
 export * from "./message-target.js";
-export { DEFAULT_MAX_PORTS, multiplexPort } from "./multiplex-port.js";
+export { DEFAULT_MAX_PORTS, MUX_CLOSED_MESSAGE, multiplexPort } from "./multiplex-port.js";
 export type { PortCodec, PortEnvelope, PortMux, PortMuxOptions } from "./port-types.js";
 export * from "./recieve.js";
 export * from "./send.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AAC/D,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC3E,OAAO,EACL,OAAO,EACP,KAAK,MAAM,EACX,KAAK,eAAe,EACpB,QAAQ,EACR,SAAS,EACT,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,GACN,MAAM,oBAAoB,CAAC;AAC5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACvE,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACxF,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AAC/D,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC3E,OAAO,EACL,OAAO,EACP,KAAK,MAAM,EACX,KAAK,eAAe,EACpB,QAAQ,EACR,SAAS,EACT,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,GACN,MAAM,oBAAoB,CAAC;AAC5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAC3F,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACxF,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,cAAc,wBAAwB,CAAC"}

package/dist/index.js

@@ -468,6 +468,73 @@ async function* callBidi(port, input, { options = {}, ...params } = {}) {
 	if (outerError !== void 0) throw outerError;
 }
 //#endregion
+//#region src/async-dispose.ts
+/**
+* Makes `target` disposable with `await using`: installs `dispose` as its
+* `[Symbol.asyncDispose]`, where the runtime defines the symbol. Hand-written
+* iterators lose what a native generator gets from `AsyncIteratorPrototype`;
+* this gives it back. A no-op where the symbol is missing. Kept off the
+* declared types, which would require consumers to compile with the
+* `esnext.disposable` lib.
+*/
+function asyncDisposable(target, dispose) {
+	const asyncDispose = Symbol.asyncDispose;
+	if (asyncDispose && !(asyncDispose in target)) Object.defineProperty(target, asyncDispose, {
+		value: async () => {
+			await dispose();
+		},
+		configurable: true,
+		writable: true
+	});
+	return target;
+}
+//#endregion
+//#region src/return-at-once.ts
+/**
+* `gen`, except that `return()` and `throw()` take effect at once.
+*
+* On an async generator both are queued behind a `next()` that is still
+* pending: a consumer that gives up on a stream while it waits for the peer's
+* next chunk — an aborted fetch whose response head has not come, say — cannot
+* end it until that chunk arrives, which for a peer that never answers is
+* never. The stream's `finally` (which closes its port and tells the peer)
+* then never runs, and on a multiplexer the port is kept for good.
+*
+* So `abandon` runs first, synchronously: it must make the pending `next()`
+* settle (abort the stream), which then resolves done, after which the
+* generator's own `return()` / `throw()` proceeds as usual. On a generator
+* suspended at a `yield` it is the same ending, a step earlier. `abandon` runs once, whichever comes first.
+*/
+function returningAtOnce(gen, abandon) {
+	let abandoned = false;
+	const giveUp = (reason) => {
+		if (abandoned) return;
+		abandoned = true;
+		abandon(reason);
+	};
+	const wrapped = {
+		next: (...args) => gen.next(...args).catch((error) => {
+			if (abandoned) return {
+				done: true,
+				value: void 0
+			};
+			throw error;
+		}),
+		return(value) {
+			giveUp();
+			return gen.return(value);
+		},
+		throw(error) {
+			giveUp(error);
+			return gen.throw(error);
+		},
+		[Symbol.asyncIterator]() {
+			return wrapped;
+		}
+	};
+	return asyncDisposable(wrapped, () => wrapped.return(void 0));
+}
+//#endregion
 //#region src/duplex-over-port.ts
 /**
 * The `type` of the out-of-band notice a side posts when it abandons a stream.
@@ -505,6 +572,7 @@ function duplexOverPort(port, options = {}) {
 function serveDuplexOverPort(port, handler, options = {}) {
 	const controller = new AbortController();
 	const notice = installAbortNotice(port, controller);
+	abortOnPortClose(port, controller);
 	const clock = installStreamTimeout(controller, options.timeout);
 	const inbound = receiveChunks(port, CHANNEL_IN, controller, clock.touch);
 	let output;
@@ -559,11 +627,12 @@ function teardownOnce(controller, notice, clock, inbound, output) {
 function runCallerSide(port, input, options) {
 	const controller = new AbortController();
 	const notice = installAbortNotice(port, controller);
+	abortOnPortClose(port, controller);
 	const clock = installStreamTimeout(controller, options.timeout);
 	const inbound = receiveChunks(port, CHANNEL_OUT, controller, clock.touch);
 	const pump = sendChunks(port, CHANNEL_IN, input, options, controller.signal, clock.touch);
 	pump.catch(() => {});
-	return (async function* () {
+	return returningAtOnce((async function* () {
 		try {
 			yield* inbound.stream;
 		} finally {
@@ -577,7 +646,9 @@ function runCallerSide(port, input, options) {
 				await port.close?.();
 			} catch {}
 		}
-	})();
+	})(), () => {
+		if (!controller.signal.aborted) controller.abort(/* @__PURE__ */ new Error("webrun-rpc: the caller abandoned the stream"));
+	});
 }
 /**
 * Listens for the peer's abort notice, and can post our own. The notice is a
@@ -607,6 +678,27 @@ function installAbortNotice(port, controller) {
 	};
 }
 /**
+* Aborts the stream when its port closes underneath it — the multiplexer was
+* closed, or the peer closed the port — for ports that report it (see
+* `getPortCloseSignal`). Without this a stream waiting for the peer's next
+* chunk would wait forever on a port that can no longer deliver one: the
+* outbound half's `callPort` already fails on the close signal, but nothing
+* failed the inbound half.
+*/
+function abortOnPortClose(port, controller) {
+	const closed = getPortCloseSignal(port);
+	if (!closed) return;
+	const onClose = () => {
+		if (!controller.signal.aborted) controller.abort(closed.reason);
+	};
+	if (closed.aborted) {
+		onClose();
+		return;
+	}
+	closed.addEventListener("abort", onClose, { once: true });
+	controller.signal.addEventListener("abort", () => closed.removeEventListener("abort", onClose), { once: true });
+}
+/**
 * The per-stream inactivity timeout (spec D8). Reset by any chunk in either
 * direction; elapsing aborts the stream. Unset, zero or non-finite installs no
 * timer at all, which is the default: a slow consumer is throttled, not failed.
@@ -768,26 +860,34 @@ async function sendChunks(port, channelName, output, { maxMessageSize, log }, si
 function newVirtualPort(send, requestClose) {
 	const listeners = /* @__PURE__ */ new Set();
 	let closed = false;
-	return {
-		port: {
-			addEventListener(_type, listener) {
-				listeners.add(listener);
-			},
-			removeEventListener(_type, listener) {
-				listeners.delete(listener);
-			},
-			postMessage(message, transfer) {
-				if (closed) return;
-				send(message, transfer);
-			},
-			close() {
-				if (closed) return;
-				closed = true;
-				const notify = requestClose;
-				listeners.clear();
-				notify();
-			}
+	const closing = new AbortController();
+	const abort = (reason) => {
+		if (closing.signal.aborted) return;
+		closing.abort(reason ?? /* @__PURE__ */ new Error("webrun-rpc: the port was closed"));
+	};
+	const port = {
+		addEventListener(_type, listener) {
+			listeners.add(listener);
 		},
+		removeEventListener(_type, listener) {
+			listeners.delete(listener);
+		},
+		postMessage(message, transfer) {
+			if (closed) return;
+			send(message, transfer);
+		},
+		close() {
+			if (closed) return;
+			closed = true;
+			const notify = requestClose;
+			listeners.clear();
+			notify();
+			abort();
+		}
+	};
+	setPortCloseSignal(port, closing.signal);
+	return {
+		port,
 		deliver(payload) {
 			if (closed) return;
 			const event = new MessageEvent("message", { data: payload });
@@ -795,9 +895,10 @@ function newVirtualPort(send, requestClose) {
 				listener(event);
 			} catch {}
 		},
-		markClosed() {
+		markClosed(reason) {
 			closed = true;
 			listeners.clear();
+			abort(reason);
 		},
 		isClosed() {
 			return closed;
@@ -806,6 +907,11 @@ function newVirtualPort(send, requestClose) {
 }
 //#endregion
 //#region src/multiplex-port.ts
+/**
+* The message of the error that fails the calls still in flight on a
+* multiplexer when it is closed (`PortMux.close()`).
+*/
+const MUX_CLOSED_MESSAGE = "webrun-rpc: the multiplexer was closed";
 /** Ceiling on concurrently open virtual ports. Bounds the id table only. */
 const DEFAULT_MAX_PORTS = 1024;
 /**
@@ -864,7 +970,7 @@ function multiplexPort(port, options) {
 			}
 			if (!accepted) {
 				open.delete(envelope.id);
-				handle.markClosed();
+				handle.markClosed(/* @__PURE__ */ new Error("webrun-rpc: the port was rejected"));
 				post({
 					type: "close",
 					id: envelope.id,
@@ -881,7 +987,7 @@ function multiplexPort(port, options) {
 		}
 		if (!handle) return;
 		open.delete(envelope.id);
-		handle.markClosed();
+		handle.markClosed(/* @__PURE__ */ new Error("webrun-rpc: the peer closed the port"));
 	};
 	const listener = (event) => {
 		const envelope = codec.read(event);
@@ -913,7 +1019,7 @@ function multiplexPort(port, options) {
 					id
 				});
 				open.delete(id);
-				handle.markClosed();
+				handle.markClosed(/* @__PURE__ */ new Error(MUX_CLOSED_MESSAGE));
 			}
 			muxClosed = true;
 			port.removeEventListener("message", listener);
@@ -944,9 +1050,22 @@ const connect = async ({ mux: factory, timeout }) => {
 		maxMessageSize: mux.maxMessageSize,
 		timeout
 	};
-	const call = (input) => (async function* () {
-		yield* duplexOverPort(await mux.openPort(STREAM_META), streamOptions)(input);
-	})();
+	const call = (input) => {
+		let stream;
+		let abandoned = false;
+		return returningAtOnce((async function* () {
+			const port = await mux.openPort(STREAM_META);
+			if (abandoned) {
+				await port.close?.();
+				return;
+			}
+			stream = duplexOverPort(port, streamOptions)(input);
+			yield* stream;
+		})(), () => {
+			abandoned = true;
+			stream?.return(void 0).catch(() => {});
+		});
+	};
 	return {
 		call,
 		async close() {
@@ -1177,4 +1296,4 @@ function transferPortMux(target, options = {}) {
 	};
 }
 //#endregion
-export { CANCEL_CHANNEL_TYPE, DEFAULT_MAX_PORTS, NO_TIMEOUT, PORT_TRANSFER, STREAM_ABORT, byteChannelFromMessagePort, callBidi, callPort, connect, duplexOverPort, getPortCloseSignal, ioHandle, ioSend, listenBidi, listenCancelChannel, listenPort, multiplexPort, overPipe, overPorts, postCancelChannel, recieve, send, serve, serveDuplexOverPort, setPortCloseSignal, structuredCodec, transferPortMux };
+export { CANCEL_CHANNEL_TYPE, DEFAULT_MAX_PORTS, MUX_CLOSED_MESSAGE, NO_TIMEOUT, PORT_TRANSFER, STREAM_ABORT, byteChannelFromMessagePort, callBidi, callPort, connect, duplexOverPort, getPortCloseSignal, ioHandle, ioSend, listenBidi, listenCancelChannel, listenPort, multiplexPort, overPipe, overPorts, postCancelChannel, recieve, send, serve, serveDuplexOverPort, setPortCloseSignal, structuredCodec, transferPortMux };

package/dist/multiplex-port.d.ts

@@ -1,5 +1,10 @@
 import type { MessageTarget } from "./message-target.js";
 import type { PortMux, PortMuxOptions } from "./port-types.js";
+/**
+ * The message of the error that fails the calls still in flight on a
+ * multiplexer when it is closed (`PortMux.close()`).
+ */
+export declare const MUX_CLOSED_MESSAGE = "webrun-rpc: the multiplexer was closed";
 /** Ceiling on concurrently open virtual ports. Bounds the id table only. */
 export declare const DEFAULT_MAX_PORTS = 1024;
 /**

package/dist/multiplex-port.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multiplex-port.d.ts","sourceRoot":"","sources":["../src/multiplex-port.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAgB,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAG7E,4EAA4E;AAC5E,eAAO,MAAM,iBAAiB,OAAO,CAAC;AAEtC;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAwHnF"}
+{"version":3,"file":"multiplex-port.d.ts","sourceRoot":"","sources":["../src/multiplex-port.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAgB,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAG7E;;;GAGG;AACH,eAAO,MAAM,kBAAkB,2CAA2C,CAAC;AAE3E,4EAA4E;AAC5E,eAAO,MAAM,iBAAiB,OAAO,CAAC;AAEtC;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAwHnF"}

package/dist/return-at-once.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `gen`, except that `return()` and `throw()` take effect at once.
+ *
+ * On an async generator both are queued behind a `next()` that is still
+ * pending: a consumer that gives up on a stream while it waits for the peer's
+ * next chunk — an aborted fetch whose response head has not come, say — cannot
+ * end it until that chunk arrives, which for a peer that never answers is
+ * never. The stream's `finally` (which closes its port and tells the peer)
+ * then never runs, and on a multiplexer the port is kept for good.
+ *
+ * So `abandon` runs first, synchronously: it must make the pending `next()`
+ * settle (abort the stream), which then resolves done, after which the
+ * generator's own `return()` / `throw()` proceeds as usual. On a generator
+ * suspended at a `yield` it is the same ending, a step earlier. `abandon` runs once, whichever comes first.
+ */
+export declare function returningAtOnce<T>(gen: AsyncGenerator<T>, abandon: (reason?: unknown) => void): AsyncGenerator<T>;
+//# sourceMappingURL=return-at-once.d.ts.map

package/dist/return-at-once.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"return-at-once.d.ts","sourceRoot":"","sources":["../src/return-at-once.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,GAAG,EAAE,cAAc,CAAC,CAAC,CAAC,EACtB,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,OAAO,KAAK,IAAI,GAClC,cAAc,CAAC,CAAC,CAAC,CA8BnB"}

package/dist/virtual-port.d.ts

@@ -4,8 +4,12 @@ export interface VirtualPortHandle {
     port: MessageTarget;
     /** Multiplexer-only: hand an inbound payload to the consumer's listeners. */
     deliver(payload: unknown): void;
-    /** Multiplexer-only: the port is finished; drop listeners and go inert. */
-    markClosed(): void;
+    /**
+     * Multiplexer-only: the port is finished; drop listeners and go inert.
+     * `reason` becomes the reason of the port's close signal (see
+     * `getPortCloseSignal`), which is what fails the calls still waiting on it.
+     */
+    markClosed(reason?: unknown): void;
     isClosed(): boolean;
 }
 /**

package/dist/virtual-port.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"virtual-port.d.ts","sourceRoot":"","sources":["../src/virtual-port.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAE1E,MAAM,WAAW,iBAAiB;IAChC,4EAA4E;IAC5E,IAAI,EAAE,aAAa,CAAC;IACpB,6EAA6E;IAC7E,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IAChC,2EAA2E;IAC3E,UAAU,IAAI,IAAI,CAAC;IACnB,QAAQ,IAAI,OAAO,CAAC;CACrB;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,YAAY,EAAE,KAAK,IAAI,EAC3D,YAAY,EAAE,CAAC,MAAM,CAAC,EAAE,OAAO,KAAK,IAAI,GACvC,iBAAiB,CAgDnB"}
+{"version":3,"file":"virtual-port.d.ts","sourceRoot":"","sources":["../src/virtual-port.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAmB,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAE1E,MAAM,WAAW,iBAAiB;IAChC,4EAA4E;IAC5E,IAAI,EAAE,aAAa,CAAC;IACpB,6EAA6E;IAC7E,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IAChC;;;;OAIG;IACH,UAAU,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACnC,QAAQ,IAAI,OAAO,CAAC;CACrB;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,YAAY,EAAE,KAAK,IAAI,EAC3D,YAAY,EAAE,CAAC,MAAM,CAAC,EAAE,OAAO,KAAK,IAAI,GACvC,iBAAiB,CA6DnB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statewalker/webrun-rpc",
-  "version": "0.4.3",
+  "version": "0.5.1",
   "private": false,
   "type": "module",
   "description": "Ports and RPC over them: a port multiplexer, and typed request/response and streaming primitives over any MessageTarget.",
@@ -30,7 +30,7 @@
     "src"
   ],
   "dependencies": {
-    "@statewalker/webrun-streams": "^0.2.2"
+    "@statewalker/webrun-streams": "^0.2.3"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.5.15",
@@ -39,7 +39,7 @@
     "rolldown": "^1.2.12",
     "typescript": "^7.0.2",
     "vitest": "^5.0.3",
-    "@statewalker/webrun-streams-conformance": "^0.3.2"
+    "@statewalker/webrun-streams-conformance": "^0.3.3"
   },
   "sideEffects": false,
   "publishConfig": {

package/src/async-dispose.ts

@@ -0,0 +1,22 @@
+/**
+ * Makes `target` disposable with `await using`: installs `dispose` as its
+ * `[Symbol.asyncDispose]`, where the runtime defines the symbol. Hand-written
+ * iterators lose what a native generator gets from `AsyncIteratorPrototype`;
+ * this gives it back. A no-op where the symbol is missing. Kept off the
+ * declared types, which would require consumers to compile with the
+ * `esnext.disposable` lib.
+ */
+export function asyncDisposable<T extends object>(target: T, dispose: () => Promise<unknown>): T {
+  // Read here, not at module level: a top-level read is code a bundler keeps.
+  const asyncDispose = (Symbol as { asyncDispose?: symbol }).asyncDispose;
+  if (asyncDispose && !(asyncDispose in target)) {
+    Object.defineProperty(target, asyncDispose, {
+      value: async () => {
+        await dispose();
+      },
+      configurable: true,
+      writable: true,
+    });
+  }
+  return target;
+}

package/src/close-signal.ts

@@ -22,7 +22,7 @@
  */
 import type { MessageTarget } from "./message-target.js";
 
-const closeSignals = new WeakMap<MessageTarget, AbortSignal>();
+const closeSignals = /* @__PURE__ */ new WeakMap<MessageTarget, AbortSignal>();
 
 /**
  * Internal: register a port's close signal. Called once by `bindBytesToPort`.

package/src/connect-serve.ts

@@ -7,6 +7,7 @@ import {
 import type { MessageTarget } from "./message-target.js";
 import { multiplexPort } from "./multiplex-port.js";
 import type { PortCodec, PortMux } from "./port-types.js";
+import { returningAtOnce } from "./return-at-once.js";
 
 /**
  * Announced with every port this pair opens. Layer 1 never reads `meta` — it is
@@ -74,19 +75,34 @@ export const connect: Connect<PortParams> = async ({ mux: factory, timeout }) =>
   const mux = await factory();
   const streamOptions: DuplexOverPortOptions = { maxMessageSize: mux.maxMessageSize, timeout };
 
-  const call: Duplex = (input) =>
+  const call: Duplex = (input) => {
+    let stream: AsyncGenerator<Uint8Array> | undefined;
+    let abandoned = false;
     // The port is opened on the consumer's first pull, not when `call` is
     // invoked. A caller that builds a stream and then drops it without
     // iterating therefore costs the peer nothing — under eager opening it
     // would burn a port (and over libp2p, a whole stream) for a call that
     // never arrives.
-    (async function* () {
+    const outer = (async function* () {
       const port = await mux.openPort(STREAM_META);
+      if (abandoned) {
+        // Given up while the port was being opened.
+        await port.close?.();
+        return;
+      }
+      stream = duplexOverPort(port, streamOptions)(input);
       // `yield*` and not a hand-rolled pump: delegation already forwards
       // `return()` and `throw()` into `duplexOverPort`'s generator, which is
       // exactly the cancellation path `Duplex` specifies.
-      yield* duplexOverPort(port, streamOptions)(input);
+      yield* stream;
     })();
+    // Delegation forwards them only once the pending `next()` settles, though:
+    // giving up while the peer has not answered must reach the stream now.
+    return returningAtOnce(outer, () => {
+      abandoned = true;
+      void stream?.return(undefined).catch(() => {});
+    });
+  };
 
   return {
     call,

package/src/duplex-over-port.ts

@@ -9,8 +9,10 @@ import {
   toChunks,
 } from "@statewalker/webrun-streams";
 import { callPort, NO_TIMEOUT } from "./call-port.js";
+import { getPortCloseSignal } from "./close-signal.js";
 import { listenPort } from "./listen-port.js";
 import type { MessageTarget } from "./message-target.js";
+import { returningAtOnce } from "./return-at-once.js";
 import { throughAbort } from "./through-abort.js";
 
 /**
@@ -82,6 +84,7 @@ export function serveDuplexOverPort(
 ): () => void {
   const controller = new AbortController();
   const notice = installAbortNotice(port, controller);
+  abortOnPortClose(port, controller);
   const clock = installStreamTimeout(controller, options.timeout);
   const inbound = receiveChunks(port, CHANNEL_IN, controller, clock.touch);
   let output: AsyncGenerator<Uint8Array>;
@@ -166,6 +169,7 @@ function runCallerSide(
 ): AsyncGenerator<Uint8Array> {
   const controller = new AbortController();
   const notice = installAbortNotice(port, controller);
+  abortOnPortClose(port, controller);
   const clock = installStreamTimeout(controller, options.timeout);
   const inbound = receiveChunks(port, CHANNEL_OUT, controller, clock.touch);
   const pump = sendChunks(port, CHANNEL_IN, input, options, controller.signal, clock.touch);
@@ -174,7 +178,7 @@ function runCallerSide(
     // the consumer's contract is the inbound half.
   });
 
-  return (async function* () {
+  const stream = (async function* () {
     try {
       yield* inbound.stream;
     } finally {
@@ -197,6 +201,13 @@ function runCallerSide(
       }
     }
   })();
+  // A caller that gives up while it waits for the peer's next chunk ends the
+  // stream now: the abort settles that wait, and the `finally` above runs.
+  return returningAtOnce(stream, () => {
+    if (!controller.signal.aborted) {
+      controller.abort(new Error("webrun-rpc: the caller abandoned the stream"));
+    }
+  });
 }
 
 /**
@@ -234,6 +245,30 @@ function installAbortNotice(
   };
 }
 
+/**
+ * Aborts the stream when its port closes underneath it — the multiplexer was
+ * closed, or the peer closed the port — for ports that report it (see
+ * `getPortCloseSignal`). Without this a stream waiting for the peer's next
+ * chunk would wait forever on a port that can no longer deliver one: the
+ * outbound half's `callPort` already fails on the close signal, but nothing
+ * failed the inbound half.
+ */
+function abortOnPortClose(port: MessageTarget, controller: AbortController): void {
+  const closed = getPortCloseSignal(port);
+  if (!closed) return;
+  const onClose = () => {
+    if (!controller.signal.aborted) controller.abort(closed.reason);
+  };
+  if (closed.aborted) {
+    onClose();
+    return;
+  }
+  closed.addEventListener("abort", onClose, { once: true });
+  controller.signal.addEventListener("abort", () => closed.removeEventListener("abort", onClose), {
+    once: true,
+  });
+}
+
 /**
  * The per-stream inactivity timeout (spec D8). Reset by any chunk in either
  * direction; elapsing aborts the stream. Unset, zero or non-finite installs no

package/src/index.ts

@@ -21,7 +21,7 @@ export * from "./io-send.js";
 export * from "./listen-bidi.js";
 export * from "./listen-port.js";
 export * from "./message-target.js";
-export { DEFAULT_MAX_PORTS, multiplexPort } from "./multiplex-port.js";
+export { DEFAULT_MAX_PORTS, MUX_CLOSED_MESSAGE, multiplexPort } from "./multiplex-port.js";
 export type { PortCodec, PortEnvelope, PortMux, PortMuxOptions } from "./port-types.js";
 export * from "./recieve.js";
 export * from "./send.js";

package/src/multiplex-port.ts

@@ -2,6 +2,12 @@ import type { MessageTarget } from "./message-target.js";
 import type { PortEnvelope, PortMux, PortMuxOptions } from "./port-types.js";
 import { newVirtualPort, type VirtualPortHandle } from "./virtual-port.js";
 
+/**
+ * The message of the error that fails the calls still in flight on a
+ * multiplexer when it is closed (`PortMux.close()`).
+ */
+export const MUX_CLOSED_MESSAGE = "webrun-rpc: the multiplexer was closed";
+
 /** Ceiling on concurrently open virtual ports. Bounds the id table only. */
 export const DEFAULT_MAX_PORTS = 1024;
 
@@ -70,7 +76,7 @@ export function multiplexPort(port: MessageTarget, options: PortMuxOptions): Por
       }
       if (!accepted) {
         open.delete(envelope.id);
-        handle.markClosed();
+        handle.markClosed(new Error("webrun-rpc: the port was rejected"));
         post({ type: "close", id: envelope.id, reason: "rejected" });
       }
       return;
@@ -89,7 +95,7 @@ export function multiplexPort(port: MessageTarget, options: PortMuxOptions): Por
 
     if (!handle) return;
     open.delete(envelope.id);
-    handle.markClosed();
+    handle.markClosed(new Error("webrun-rpc: the peer closed the port"));
   };
 
   const listener = (event: MessageEvent): void => {
@@ -124,7 +130,7 @@ export function multiplexPort(port: MessageTarget, options: PortMuxOptions): Por
       for (const [id, handle] of [...open]) {
         post({ type: "close", id });
         open.delete(id);
-        handle.markClosed();
+        handle.markClosed(new Error(MUX_CLOSED_MESSAGE));
       }
       muxClosed = true;
       port.removeEventListener("message", listener);

package/src/return-at-once.ts

@@ -0,0 +1,51 @@
+import { asyncDisposable } from "./async-dispose.js";
+
+/**
+ * `gen`, except that `return()` and `throw()` take effect at once.
+ *
+ * On an async generator both are queued behind a `next()` that is still
+ * pending: a consumer that gives up on a stream while it waits for the peer's
+ * next chunk — an aborted fetch whose response head has not come, say — cannot
+ * end it until that chunk arrives, which for a peer that never answers is
+ * never. The stream's `finally` (which closes its port and tells the peer)
+ * then never runs, and on a multiplexer the port is kept for good.
+ *
+ * So `abandon` runs first, synchronously: it must make the pending `next()`
+ * settle (abort the stream), which then resolves done, after which the
+ * generator's own `return()` / `throw()` proceeds as usual. On a generator
+ * suspended at a `yield` it is the same ending, a step earlier. `abandon` runs once, whichever comes first.
+ */
+export function returningAtOnce<T>(
+  gen: AsyncGenerator<T>,
+  abandon: (reason?: unknown) => void,
+): AsyncGenerator<T> {
+  let abandoned = false;
+  const giveUp = (reason?: unknown) => {
+    if (abandoned) return;
+    abandoned = true;
+    abandon(reason);
+  };
+  const wrapped: AsyncGenerator<T> = {
+    // A `next()` that was pending when the consumer gave up ends as the
+    // stream does — done — rather than rejecting with the abort it caused: a
+    // consumer that raced it against a timer may hold no handler for it.
+    next: (...args: [] | [unknown]) =>
+      gen.next(...args).catch((error: unknown) => {
+        if (abandoned) return { done: true, value: undefined } as IteratorResult<T>;
+        throw error;
+      }),
+    return(value) {
+      giveUp();
+      return gen.return(value);
+    },
+    throw(error) {
+      giveUp(error);
+      return gen.throw(error);
+    },
+    [Symbol.asyncIterator]() {
+      return wrapped;
+    },
+  };
+  // `await using` ends the stream as leaving a `for await` early does.
+  return asyncDisposable(wrapped, () => wrapped.return(undefined));
+}

package/src/virtual-port.ts

@@ -1,3 +1,4 @@
+import { setPortCloseSignal } from "./close-signal.js";
 import type { MessageListener, MessageTarget } from "./message-target.js";
 
 export interface VirtualPortHandle {
@@ -5,8 +6,12 @@ export interface VirtualPortHandle {
   port: MessageTarget;
   /** Multiplexer-only: hand an inbound payload to the consumer's listeners. */
   deliver(payload: unknown): void;
-  /** Multiplexer-only: the port is finished; drop listeners and go inert. */
-  markClosed(): void;
+  /**
+   * Multiplexer-only: the port is finished; drop listeners and go inert.
+   * `reason` becomes the reason of the port's close signal (see
+   * `getPortCloseSignal`), which is what fails the calls still waiting on it.
+   */
+  markClosed(reason?: unknown): void;
   isClosed(): boolean;
 }
 
@@ -23,6 +28,16 @@ export function newVirtualPort(
 ): VirtualPortHandle {
   const listeners = new Set<MessageListener>();
   let closed = false;
+  // A virtual port knows when it is finished, unlike a raw `MessagePort`. Its
+  // close signal is what lets the calls still waiting on it — `callPort`, and
+  // the streams of `duplexOverPort` — fail at once instead of hanging on a
+  // port that has gone inert. Without it, closing a multiplexer left every call
+  // in flight on it pending forever.
+  const closing = new AbortController();
+  const abort = (reason?: unknown) => {
+    if (closing.signal.aborted) return;
+    closing.abort(reason ?? new Error("webrun-rpc: the port was closed"));
+  };
 
   const port: MessageTarget = {
     addEventListener(_type, listener) {
@@ -41,8 +56,10 @@ export function newVirtualPort(
       const notify = requestClose;
       listeners.clear();
       notify();
+      abort();
     },
   };
+  setPortCloseSignal(port, closing.signal);
 
   return {
     port,
@@ -60,9 +77,10 @@ export function newVirtualPort(
         }
       }
     },
-    markClosed() {
+    markClosed(reason) {
       closed = true;
       listeners.clear();
+      abort(reason);
     },
     isClosed() {
       return closed;