@statewalker/webrun-rpc 0.5.0 → 0.7.0

package/dist/index.js

@@ -238,8 +238,11 @@ function listenPort(port, handler, { channelName = "", log = () => {} } = {}) {
 			error
 		});
 	};
-	port.addEventListener("message", onMessage);
-	return () => port.removeEventListener("message", onMessage);
+	const listener = (event) => {
+		onMessage(event);
+	};
+	port.addEventListener("message", listener);
+	return () => port.removeEventListener("message", listener);
 }
 //#endregion
 //#region src/recieve.ts
@@ -468,6 +471,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.
@@ -565,7 +635,7 @@ function runCallerSide(port, input, options) {
 	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 {
@@ -579,7 +649,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
@@ -780,6 +852,50 @@ async function sendChunks(port, channelName, output, { maxMessageSize, log }, si
 	}
 }
 //#endregion
+//#region src/port-credit.ts
+/**
+* Runs `fn` on a later task, never a microtask: a producer looping on
+* `whenPortReady` must let the transport's own events run. `setImmediate`
+* where it exists; elsewhere a `MessageChannel`, because nested `setTimeout`s
+* are clamped to 4 ms in browsers.
+*/
+const setImmediateFn = globalThis.setImmediate;
+/** @internal */
+const nextTask = setImmediateFn ? (fn) => {
+	setImmediateFn(fn);
+} : (() => {
+	let channel;
+	const queue = [];
+	return (fn) => {
+		if (!channel) {
+			channel = new MessageChannel();
+			channel.port1.onmessage = () => queue.shift()?.();
+		}
+		queue.push(fn);
+		channel.port2.postMessage(0);
+	};
+})();
+const states = /* @__PURE__ */ new WeakMap();
+/** @internal Registered by the multiplexer for each port with a window. */
+function setPortSendState(port, state) {
+	states.set(port, state);
+}
+/**
+* Bytes queued on `port` because its window is spent (0 for a port without
+* flow control). A sender that should not queue without bound waits for
+* `whenPortReady` before posting more.
+*/
+function portBufferedAmount(port) {
+	return states.get(port)?.bufferedAmount() ?? 0;
+}
+/**
+* Resolves once at most `below` bytes are queued on `port`, always on a later
+* task (for a port without flow control, on the next one).
+*/
+function whenPortReady(port, below = 0) {
+	return states.get(port)?.ready(below) ?? new Promise((resolve) => nextTask(resolve));
+}
+//#endregion
 //#region src/virtual-port.ts
 /**
 * One virtual port.
@@ -796,6 +912,14 @@ function newVirtualPort(send, requestClose) {
 		if (closing.signal.aborted) return;
 		closing.abort(reason ?? /* @__PURE__ */ new Error("webrun-rpc: the port was closed"));
 	};
+	const close = (reason) => {
+		if (closed) return;
+		closed = true;
+		const notify = requestClose;
+		listeners.clear();
+		notify(reason);
+		abort(reason);
+	};
 	const port = {
 		addEventListener(_type, listener) {
 			listeners.add(listener);
@@ -807,24 +931,28 @@ function newVirtualPort(send, requestClose) {
 			if (closed) return;
 			send(message, transfer);
 		},
-		close() {
-			if (closed) return;
-			closed = true;
-			const notify = requestClose;
-			listeners.clear();
-			notify();
-			abort();
-		}
+		close
 	};
 	setPortCloseSignal(port, closing.signal);
+	const dispose = Symbol.dispose;
+	if (dispose) Object.defineProperty(port, dispose, {
+		value: () => close(),
+		configurable: true
+	});
 	return {
 		port,
 		deliver(payload) {
 			if (closed) return;
 			const event = new MessageEvent("message", { data: payload });
+			let pending;
 			for (const listener of [...listeners]) try {
-				listener(event);
+				const result = listener(event);
+				if (result && typeof result.then === "function") {
+					pending ??= [];
+					pending.push(result);
+				}
 			} catch {}
+			return pending ? Promise.allSettled(pending) : void 0;
 		},
 		markClosed(reason) {
 			closed = true;
@@ -833,6 +961,9 @@ function newVirtualPort(send, requestClose) {
 		},
 		isClosed() {
 			return closed;
+		},
+		hasListeners() {
+			return listeners.size > 0;
 		}
 	};
 }
@@ -843,45 +974,303 @@ function newVirtualPort(send, requestClose) {
 * multiplexer when it is closed (`PortMux.close()`).
 */
 const MUX_CLOSED_MESSAGE = "webrun-rpc: the multiplexer was closed";
+/**
+* The id of keepalive's `ping` / `pong`: one no port ever takes. An older mux
+* whose codec passes unknown envelopes through reads them as a close of that
+* id, which must therefore not be a real port (0 is the initiator's first).
+*/
+const KEEPALIVE_ID = Number.MAX_SAFE_INTEGER;
+/** The longest delay a timer holds; past it `setInterval` fires at once. */
+const MAX_TIMER_MS = 2 ** 31 - 1;
 /** Ceiling on concurrently open virtual ports. Bounds the id table only. */
 const DEFAULT_MAX_PORTS = 1024;
 /**
+* What a message costs a port's window when the codec cannot say
+* (`PortCodec.encode`): its bytes and string lengths, found in its values up
+* to 4 levels deep (at most 256 values), and at least 64. Both ends compute it
+* from the same structured value, so they agree.
+*/
+function estimateMessageSize(payload) {
+	let budget = 256;
+	const walk = (v, depth) => {
+		if (budget-- <= 0) return 0;
+		if (typeof v === "string") return v.length;
+		if (v instanceof ArrayBuffer) return v.byteLength;
+		if (ArrayBuffer.isView(v)) return v.byteLength;
+		if (v === null || typeof v !== "object" || depth >= 4) return 8;
+		let n = 16;
+		if (Array.isArray(v)) for (const x of v) n += walk(x, depth + 1);
+		else for (const k in v) n += k.length + walk(v[k], depth + 1);
+		return n;
+	};
+	return Math.max(64, walk(payload, 0));
+}
+/**
 * The default `PortMux`: emulates multiplexing over a single port.
 *
 * A transport that already multiplexes natively supplies its own `PortMux`
 * instead — this implementation is for transports that offer one pipe.
 */
 function multiplexPort(port, options) {
-	const { codec, onPort, side = "initiator", maxPorts = DEFAULT_MAX_PORTS, maxMessageSize } = options;
+	const { codec, onPort, side = "initiator", maxPorts = DEFAULT_MAX_PORTS, maxMessageSize, signal, window, frameSize, keepalive, onLeak } = options;
+	const misses = keepalive?.misses ?? 3;
+	if (keepalive && !(Number.isFinite(keepalive.intervalMs) && keepalive.intervalMs > 0 && keepalive.intervalMs <= MAX_TIMER_MS && Number.isSafeInteger(misses) && misses > 0)) throw new RangeError(`webrun-rpc: keepalive needs an intervalMs in (0, ${MAX_TIMER_MS}] and a positive integer misses`);
+	if (frameSize != null && !(Number.isSafeInteger(frameSize) && frameSize > 0)) throw new RangeError(`webrun-rpc: frameSize must be a positive integer, got ${frameSize}`);
 	const open = /* @__PURE__ */ new Map();
+	const leaks = onLeak ? new FinalizationRegistry(({ id, record, release }) => {
+		const entry = open.get(id);
+		if (entry?.handle !== record) return;
+		const { handle: _, credit: __, partial: ___, ...info } = entry;
+		if (!record.hasListeners()) {
+			release("leaked");
+			record.markClosed(/* @__PURE__ */ new Error("webrun-rpc: the port was dropped without close()"));
+		}
+		try {
+			onLeak?.(info);
+		} catch {}
+	}) : void 0;
+	const touch = (id) => {
+		const entry = open.get(id);
+		if (entry) entry.lastActivity = Date.now();
+	};
 	let nextId = side === "initiator" ? 0 : 1;
 	let muxClosed = false;
+	/** This end counts encoded bytes and reassembles frames. */
+	const exactCodec = codec.encode != null && codec.decode != null;
 	const post = (envelope, transfer) => {
 		if (muxClosed) return;
+		codecPost(envelope, transfer);
+	};
+	/** Like `post`, also while closing: the mux's own close notices. */
+	const codecPost = (envelope, transfer) => {
 		try {
 			codec.post(port, envelope, transfer);
 		} catch {}
 	};
-	const attach = (id) => {
-		let self;
-		self = newVirtualPort((payload, transfer) => post({
-			type: "message",
-			id,
-			payload
-		}, transfer), (reason) => {
+	const outgoing = /* @__PURE__ */ new Map();
+	const ring = [];
+	let pumping = false;
+	const pump = async () => {
+		pumping = true;
+		try {
+			while (ring.length && !muxClosed) {
+				if (port.whenDrained) await port.whenDrained();
+				if (muxClosed) break;
+				const id = ring.shift();
+				const queue = outgoing.get(id);
+				const item = queue?.shift();
+				if (queue?.length) ring.push(id);
+				else outgoing.delete(id);
+				item?.();
+			}
+		} catch (err) {
+			close(err).catch(() => {});
+		} finally {
+			pumping = false;
+		}
+	};
+	const sendOnPort = (id, item) => {
+		if (frameSize == null) {
+			item();
+			return;
+		}
+		let queue = outgoing.get(id);
+		if (!queue) {
+			queue = [];
+			outgoing.set(id, queue);
+			ring.push(id);
+		}
+		queue.push(item);
+		if (!pumping) pump();
+	};
+	const dropOutgoing = (id) => {
+		if (!outgoing.delete(id)) return;
+		const at = ring.indexOf(id);
+		if (at >= 0) ring.splice(at, 1);
+	};
+	const postBytes = (bytes) => {
+		if (muxClosed) return;
+		try {
+			port.postMessage(bytes);
+		} catch {}
+	};
+	const releaseWaiters = (c) => {
+		for (const w of c?.waiters.splice(0) ?? []) w.resolve();
+	};
+	const flush = (c) => {
+		while (c.queue.length) {
+			const next = c.queue[0];
+			if (c.enforced && c.outstanding > 0 && c.outstanding + next.size > c.window) break;
+			c.queue.shift();
+			c.queued -= next.size;
+			c.outstanding += next.size;
+			next.send();
+		}
+		for (const w of [...c.waiters]) if (c.queued <= w.below) {
+			c.waiters.splice(c.waiters.indexOf(w), 1);
+			w.resolve();
+		}
+	};
+	const grant = (id, c, bytes) => {
+		c.unconsumed -= bytes;
+		c.toGrant += bytes;
+		const send = () => {
+			c.grantScheduled = false;
+			if (!c.toGrant || !open.has(id)) return;
 			post({
+				type: "credit",
+				id,
+				bytes: c.toGrant
+			});
+			c.toGrant = 0;
+		};
+		if (c.toGrant >= c.window / 4) {
+			send();
+			return;
+		}
+		if (c.grantScheduled) return;
+		c.grantScheduled = true;
+		setTimeout(send, 0);
+	};
+	const attach = (id, meta, portWindow, opener, exact) => {
+		const c = typeof portWindow === "number" && Number.isSafeInteger(portWindow) && portWindow > 0 ? {
+			window: portWindow,
+			enforced: false,
+			opener,
+			exact,
+			outstanding: 0,
+			queue: [],
+			queued: 0,
+			unconsumed: 0,
+			waiters: [],
+			toGrant: 0,
+			grantScheduled: false
+		} : void 0;
+		const self = newVirtualPort((payload, transfer) => {
+			touch(id);
+			const envelope = {
+				type: "message",
+				id,
+				payload
+			};
+			if (!c) {
+				post(envelope, transfer);
+				return;
+			}
+			const bytes = c.exact ? codec.encode?.(envelope) : void 0;
+			const size = bytes?.byteLength ?? estimateMessageSize(payload);
+			const waits = frameSize != null || c.queue.length > 0 || c.enforced && c.outstanding > 0 && c.outstanding + size > c.window;
+			const held = !bytes && waits ? {
+				...envelope,
+				payload: structuredClone(payload, { transfer })
+			} : void 0;
+			const send = () => {
+				if (!bytes) {
+					sendOnPort(id, held ? () => post(held) : () => post(envelope, transfer));
+					return;
+				}
+				if (frameSize != null && c.enforced && c.exact && bytes.byteLength > frameSize) {
+					for (let at = 0; at < bytes.byteLength; at += frameSize) {
+						const data = bytes.subarray(at, at + frameSize);
+						const frame = at + frameSize >= bytes.byteLength ? {
+							type: "frame",
+							id,
+							data,
+							last: true
+						} : {
+							type: "frame",
+							id,
+							data
+						};
+						sendOnPort(id, () => post(frame));
+					}
+					return;
+				}
+				sendOnPort(id, () => postBytes(bytes));
+			};
+			c.queue.push({
+				send,
+				size
+			});
+			c.queued += size;
+			flush(c);
+		}, (reason) => {
+			release(reason);
+			record.markClosed(reason);
+		});
+		function release(reason) {
+			open.delete(id);
+			leaks?.unregister(record);
+			if (c?.queue.length) {
+				for (const item of c.queue.splice(0)) item.send();
+				c.queued = 0;
+			}
+			sendOnPort(id, () => post({
 				type: "close",
 				id,
 				reason
+			}));
+			releaseWaiters(c);
+		}
+		const { markClosed, isClosed, hasListeners } = self;
+		if (c) {
+			const deliver = self.deliver;
+			self.deliver = (payload, size = estimateMessageSize(payload)) => {
+				c.unconsumed += size;
+				const done = deliver(payload);
+				if (done) done.then(() => grant(id, c, size));
+				else grant(id, c, size);
+				return done;
+			};
+			setPortSendState(self.port, {
+				bufferedAmount: () => c.queued,
+				ready: (below = 0) => new Promise((resolve) => {
+					if (c.queued <= below || isClosed()) nextTask(resolve);
+					else c.waiters.push({
+						below,
+						resolve: () => nextTask(resolve)
+					});
+				})
 			});
-			open.delete(id);
-			self.markClosed();
+		}
+		const record = {
+			deliver: self.deliver,
+			markClosed,
+			isClosed,
+			hasListeners,
+			close: (reason) => {
+				if (isClosed()) return;
+				release(reason);
+				markClosed(reason);
+			}
+		};
+		leaks?.register(self.port, {
+			id,
+			record,
+			release
+		}, record);
+		const now = Date.now();
+		open.set(id, {
+			id,
+			meta,
+			openedAt: now,
+			lastActivity: now,
+			handle: record,
+			credit: c
 		});
-		open.set(id, self);
 		return self;
 	};
-	const handleEnvelope = (envelope) => {
+	const handleEnvelope = (envelope, event) => {
 		if (muxClosed) return;
+		heardSincePing = true;
+		if (envelope.type === "ping" || envelope.type === "pong") {
+			peerKeepsAlive = true;
+			if (envelope.type === "ping") post({
+				type: "pong",
+				id: KEEPALIVE_ID
+			});
+			return;
+		}
 		if (envelope.type === "open") {
 			if (open.has(envelope.id)) return;
 			if (open.size >= maxPorts) {
@@ -892,7 +1281,18 @@ function multiplexPort(port, options) {
 				});
 				return;
 			}
-			const handle = attach(envelope.id);
+			const handle = attach(envelope.id, envelope.meta, envelope.window, false, envelope.exact === true && exactCodec);
+			const credit = open.get(envelope.id)?.credit;
+			if (credit) post(credit.exact ? {
+				type: "credit",
+				id: envelope.id,
+				bytes: 0,
+				exact: true
+			} : {
+				type: "credit",
+				id: envelope.id,
+				bytes: 0
+			});
 			let accepted = false;
 			if (onPort) try {
 				accepted = onPort(handle.port, envelope.meta) !== false;
@@ -907,57 +1307,191 @@ function multiplexPort(port, options) {
 					id: envelope.id,
 					reason: "rejected"
 				});
+				return;
 			}
 			return;
 		}
-		const handle = open.get(envelope.id);
+		const entry = open.get(envelope.id);
+		if (envelope.type === "credit") {
+			const c = entry?.credit;
+			if (!c || !(envelope.bytes >= 0)) return;
+			if (!c.enforced && c.opener) {
+				if (c.exact && envelope.exact !== true) {
+					c.exact = false;
+					c.outstanding = 0;
+				}
+				post({
+					type: "credit",
+					id: envelope.id,
+					bytes: 0
+				});
+			}
+			c.enforced = true;
+			c.outstanding = Math.max(0, c.outstanding - envelope.bytes);
+			flush(c);
+			return;
+		}
 		if (envelope.type === "message") {
-			if (!handle) return;
-			handle.deliver(envelope.payload);
+			const sizeOf = (c) => (c.exact ? byteLengthOf(event.data) : void 0) ?? estimateMessageSize(envelope.payload);
+			if (!entry) return;
+			touch(envelope.id);
+			entry.handle.deliver(envelope.payload, entry.credit ? sizeOf(entry.credit) : void 0);
 			return;
 		}
-		if (!handle) return;
+		if (envelope.type === "frame") {
+			if (!entry?.credit?.exact || !codec.decode || !(envelope.data instanceof Uint8Array)) return;
+			touch(envelope.id);
+			const partial = entry.partial ?? {
+				chunks: [],
+				bytes: 0
+			};
+			entry.partial = partial;
+			partial.chunks.push(envelope.data);
+			partial.bytes += envelope.data.byteLength;
+			if (!envelope.last) return;
+			entry.partial = void 0;
+			const whole = new Uint8Array(partial.bytes);
+			let at = 0;
+			for (const chunk of partial.chunks) {
+				whole.set(chunk, at);
+				at += chunk.byteLength;
+			}
+			const inner = codec.decode(whole);
+			if (inner?.type !== "message" || inner.id !== envelope.id) return;
+			entry.handle.deliver(inner.payload, whole.byteLength);
+			return;
+		}
+		dropOutgoing(envelope.id);
+		if (!entry) return;
 		open.delete(envelope.id);
-		handle.markClosed(/* @__PURE__ */ new Error("webrun-rpc: the peer closed the port"));
+		releaseWaiters(entry.credit);
+		entry.handle.markClosed(/* @__PURE__ */ new Error("webrun-rpc: the peer closed the port"));
 	};
 	const listener = (event) => {
 		const envelope = codec.read(event);
-		if (envelope) handleEnvelope(envelope);
+		if (envelope) handleEnvelope(envelope, event);
+	};
+	let peerKeepsAlive = false;
+	let heardSincePing = true;
+	let unanswered = 0;
+	let pinger;
+	const tick = () => {
+		if (!keepalive) return;
+		const backlogged = (port.bufferedAmount ?? 0) > 0;
+		if (heardSincePing) unanswered = 0;
+		else if (peerKeepsAlive && !backlogged) unanswered++;
+		if (unanswered >= misses) {
+			close(/* @__PURE__ */ new Error(`webrun-rpc: the peer did not answer ${misses} keepalive pings, ${keepalive.intervalMs} ms apart`)).catch(() => {});
+			return;
+		}
+		heardSincePing = false;
+		post({
+			type: "ping",
+			id: KEEPALIVE_ID
+		});
+	};
+	const close = async (reason) => {
+		if (muxClosed) return;
+		clearInterval(pinger);
+		muxClosed = true;
+		signal?.removeEventListener("abort", onTransportAbort);
+		port.removeEventListener("message", listener);
+		const closedNow = /* @__PURE__ */ new Set();
+		for (const [id, { handle, credit }] of [...open]) {
+			closedNow.add(id);
+			codecPost({
+				type: "close",
+				id
+			});
+			open.delete(id);
+			releaseWaiters(credit);
+			handle.markClosed(reason ?? /* @__PURE__ */ new Error("webrun-rpc: the multiplexer was closed"));
+		}
+		for (const id of outgoing.keys()) if (!closedNow.has(id)) codecPost({
+			type: "close",
+			id
+		});
+		outgoing.clear();
+		ring.length = 0;
+		await port.close?.();
+	};
+	const onTransportAbort = () => {
+		close(signal?.reason).catch(() => {});
 	};
 	port.addEventListener("message", listener);
 	port.start?.();
+	if (keepalive) {
+		pinger = setInterval(tick, keepalive.intervalMs);
+		pinger.unref?.();
+	}
+	if (signal?.aborted) close(signal.reason).catch(() => {});
+	else signal?.addEventListener("abort", onTransportAbort, { once: true });
 	return {
 		maxMessageSize,
-		async openPort(meta) {
+		async openPort(meta, { signal: portSignal } = {}) {
 			if (muxClosed) throw new Error("webrun-rpc: the multiplexer is closed");
-			if (open.size >= maxPorts) throw new RangeError(`webrun-rpc: maxPorts (${maxPorts}) reached`);
+			if (portSignal?.aborted) throw portSignal.reason;
+			if (open.size >= maxPorts) throw new RangeError(`webrun-rpc: maxPorts (${maxPorts}) reached; open ports by kind: ${describeKinds(open.values())}`);
 			while (open.has(nextId)) nextId += 2;
 			const id = nextId;
 			nextId += 2;
-			const handle = attach(id);
-			post({
+			const handle = attach(id, meta, window, true, exactCodec);
+			post(window ? exactCodec ? {
+				type: "open",
+				id,
+				meta,
+				window,
+				exact: true
+			} : {
+				type: "open",
+				id,
+				meta,
+				window
+			} : {
 				type: "open",
 				id,
 				meta
 			});
+			if (portSignal) {
+				const record = open.get(id)?.handle;
+				const onAbort = () => {
+					if (record && open.get(id)?.handle === record) record.close(portSignal.reason);
+				};
+				portSignal.addEventListener("abort", onAbort, { once: true });
+				getPortCloseSignal(handle.port)?.addEventListener("abort", () => portSignal.removeEventListener("abort", onAbort), { once: true });
+			}
 			return handle.port;
 		},
-		async close() {
-			if (muxClosed) return;
-			for (const [id, handle] of [...open]) {
-				post({
-					type: "close",
-					id
-				});
-				open.delete(id);
-				handle.markClosed(/* @__PURE__ */ new Error(MUX_CLOSED_MESSAGE));
-			}
-			muxClosed = true;
-			port.removeEventListener("message", listener);
-			await port.close?.();
+		close,
+		ports() {
+			return [...open.values()].map(({ handle: _, credit, ...info }) => credit ? {
+				...info,
+				...credit.enforced ? { window: credit.window } : {},
+				queued: credit.queued,
+				outstanding: credit.outstanding,
+				unconsumed: credit.unconsumed
+			} : info);
 		}
 	};
 }
+/** The byte length of a received message's data, or `undefined` if it is not bytes. */
+function byteLengthOf(data) {
+	if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) return data.byteLength;
+}
+/**
+* `"http: 1000, ws: 24"`: the three commonest `meta.kind`s among `entries`, so
+* a full table names who filled it. A port without a kind counts as `"?"`.
+*/
+function describeKinds(entries) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const { meta } of entries) {
+		const kind = meta?.kind;
+		const name = typeof kind === "string" ? kind : "?";
+		counts.set(name, (counts.get(name) ?? 0) + 1);
+	}
+	if (!counts.size) return "none";
+	return [...counts].sort((x, y) => y[1] - x[1]).slice(0, 3).map(([name, n]) => `${name}: ${n}`).join(", ");
+}
 //#endregion
 //#region src/connect-serve.ts
 /**
@@ -981,9 +1515,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() {
@@ -1119,7 +1666,7 @@ function isEnvelope(value) {
 	const candidate = value;
 	if (typeof candidate.id !== "number") return false;
 	if (!Number.isInteger(candidate.id) || candidate.id < 0) return false;
-	return candidate.type === "open" || candidate.type === "message" || candidate.type === "close";
+	return candidate.type === "open" || candidate.type === "message" || candidate.type === "close" || candidate.type === "credit" || candidate.type === "frame" || candidate.type === "ping" || candidate.type === "pong";
 }
 /**
 * For ports whose messages are structured values — a real `MessagePort`, a
@@ -1165,7 +1712,7 @@ const PORT_TRANSFER = "webrun-rpc:port-transfer";
 */
 function transferPortMux(target, options = {}) {
 	const { onPort, maxMessageSize } = options;
-	const issued = /* @__PURE__ */ new Set();
+	const issued = /* @__PURE__ */ new Map();
 	let closed = false;
 	const listener = (event) => {
 		if (closed) return;
@@ -1184,28 +1731,47 @@ function transferPortMux(target, options = {}) {
 			port.close();
 			return;
 		}
-		issued.add(port);
+		const forget = () => issued.delete(port);
+		issued.set(port, forget);
+		const close = port.close.bind(port);
+		port.close = () => {
+			forget();
+			close();
+		};
 	};
 	target.addEventListener("message", listener);
 	target.start?.();
 	return {
 		maxMessageSize,
-		async openPort(meta) {
+		async openPort(meta, { signal } = {}) {
 			if (closed) throw new Error("webrun-rpc: the multiplexer is closed");
+			if (signal?.aborted) throw signal.reason;
 			const channel = new MessageChannel();
 			channel.port1.start();
 			target.postMessage({
 				type: PORT_TRANSFER,
 				meta
 			}, [channel.port2]);
-			issued.add(channel.port1);
-			return channel.port1;
+			const port = channel.port1;
+			const onAbort = () => port.close();
+			signal?.addEventListener("abort", onAbort, { once: true });
+			const forget = () => {
+				signal?.removeEventListener("abort", onAbort);
+				issued.delete(port);
+			};
+			issued.set(port, forget);
+			const close = port.close.bind(port);
+			port.close = () => {
+				forget();
+				close();
+			};
+			return port;
 		},
 		async close() {
 			if (closed) return;
 			closed = true;
 			target.removeEventListener("message", listener);
-			for (const port of issued) try {
+			for (const port of [...issued.keys()]) try {
 				port.close();
 			} catch {}
 			issued.clear();
@@ -1214,4 +1780,4 @@ function transferPortMux(target, options = {}) {
 	};
 }
 //#endregion
-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 };
+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, portBufferedAmount, postCancelChannel, recieve, send, serve, serveDuplexOverPort, setPortCloseSignal, structuredCodec, transferPortMux, whenPortReady };