@statewalker/webrun-streams-webrtc 0.1.6 → 0.4.0

package/dist/index.js

@@ -3,9 +3,62 @@ import { TransportClosedError, deserializeError, serializeError, toChunks } from
 const TYPE_DATA = 0;
 const TYPE_END = 1;
 const TYPE_ERROR = 2;
+const TYPE_CREDIT = 3;
+const LOW_WATER_MARK = 262144;
+/**
+* Receive-side backpressure: a sender may have at most this many payload bytes outstanding that
+* the receiving consumer has not yet pulled. The receiver returns credit (`CREDIT` frames) as its
+* consumer pulls, half a window at a time. A DataChannel delivers every message as it arrives,
+* 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();
 const textDecoder = new TextDecoder();
 /**
+* Messages (and a close) that arrive on a channel before its stream starts listening. A generator
+* runs only on its first `next()`, so without this a peer that answers at once (a handler that
+* throws, a reply with no input to wait for) can be faster than our listener: its frames are
+* dropped and the call hangs or reports a bare close.
+*/
+const held = /* @__PURE__ */ new WeakMap();
+/**
+* Channels this side answers (from `datachannel`). A finished call is closed by its caller only,
+* once it has the responder's `END` or `ERROR`: a responder that closed right after sending them
+* could lose them in flight (Chrome delivers the close first), turning an error into a bare close.
+*/
+const answering = /* @__PURE__ */ new WeakSet();
+function markAnswering(dc) {
+	answering.add(dc);
+}
+/** starts holding a channel's events until {@link duplexOverDataChannel} takes them */
+function holdEvents(dc) {
+	if (held.has(dc)) return;
+	dc.binaryType = "arraybuffer";
+	const events = [];
+	const listener = (ev) => {
+		events.push(ev);
+	};
+	dc.addEventListener("message", listener);
+	dc.addEventListener("close", listener);
+	held.set(dc, {
+		events,
+		listener
+	});
+}
+function takeHeld(dc) {
+	const h = held.get(dc);
+	if (!h) return [];
+	held.delete(dc);
+	dc.removeEventListener("message", h.listener);
+	dc.removeEventListener("close", h.listener);
+	return h.events;
+}
+/**
 * Drive one `Duplex` over one `RTCDataChannel`. The DataChannel hosts a tiny
 * in-band framing protocol:
 *
@@ -13,7 +66,9 @@ const textDecoder = new TextDecoder();
 *
 * Types are `DATA` (0x00, body bytes), `END` (0x01, signals half-close — the
 * sender is done emitting; the channel stays open for the other direction),
-* and `ERROR` (0x02, followed by a serialised `Error`).
+* `ERROR` (0x02, followed by a serialised `Error`) and `CREDIT` (0x03, a
+* big-endian u32: payload bytes the receiver's consumer has pulled, which the
+* sender may now send again; see {@link RECEIVE_WINDOW}).
 *
 * `RTCDataChannel` has no native half-close, so `END` is emitted by the
 * sender once its input iterator exhausts; the channel is only physically
@@ -22,13 +77,52 @@ const textDecoder = new TextDecoder();
 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;
+		wakeSender = null;
+		w?.();
+	};
+	const stalled = () => new Promise((r) => {
+		wakeSender = r;
+	});
+	dc.bufferedAmountLowThreshold = LOW_WATER_MARK;
+	const sendRaw = (bytes) => {
+		dc.send(bytes);
+	};
+	/** set when this call is abandoned (cancelled, or the peer failed): the sender stops waiting */
+	let aborted = false;
+	/** waits for credit for `n` bytes and room in the send buffer; false once the call is over */
+	const room = async (n) => {
+		while (!aborted && dc.readyState === "open" && (credit < n || dc.bufferedAmount > 1048576)) await stalled();
+		return !aborted && dc.readyState === "open";
+	};
+	/** returns credit for what our consumer pulled, half a window at a time */
+	const consumed = (n) => {
+		pulled += n;
+		if (pulled < 2097152 || dc.readyState !== "open") return;
+		const frame = /* @__PURE__ */ new Uint8Array(5);
+		frame[0] = TYPE_CREDIT;
+		new DataView(frame.buffer).setUint32(1, pulled);
+		try {
+			sendRaw(frame);
+			allowance += pulled;
+		} catch {}
+		pulled = 0;
+	};
 	const maybeClose = () => {
-		if (peerEnded && localEnded) try {
+		if (peerEnded && localEnded && !answering.has(dc)) try {
 			dc.close();
 		} catch {}
 	};
@@ -44,11 +138,28 @@ 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();
+		} else if (type === TYPE_CREDIT && payload.byteLength >= 4) {
+			credit += new DataView(payload.buffer, payload.byteOffset, 4).getUint32(0);
+			nudge();
 		} else if (type === TYPE_ERROR) {
 			let err;
 			try {
@@ -62,6 +173,7 @@ async function* runStream(dc, input) {
 		}
 	};
 	const onClose = () => {
+		nudge();
 		if (!peerEnded) {
 			incoming.done(new TransportClosedError());
 			peerEnded = true;
@@ -69,14 +181,26 @@ async function* runStream(dc, input) {
 	};
 	dc.addEventListener("message", onMessage);
 	dc.addEventListener("close", onClose);
+	dc.addEventListener("bufferedamountlow", nudge);
+	for (const ev of takeHeld(dc)) if (ev.type === "message") onMessage(ev);
+	else onClose();
+	if (dc.readyState === "closed") onClose();
+	let inboundFinished = false;
+	const detach = () => {
+		if (!inboundFinished || !localEnded) return;
+		dc.removeEventListener("message", onMessage);
+		dc.removeEventListener("close", onClose);
+		dc.removeEventListener("bufferedamountlow", nudge);
+	};
 	const outbound = (async () => {
 		try {
 			for await (const chunk of toChunks(16383)(input)) {
-				if (dc.readyState !== "open") return;
+				if (!await room(chunk.byteLength)) return;
+				credit -= chunk.byteLength;
 				const framed = new Uint8Array(chunk.byteLength + 1);
 				framed[0] = TYPE_DATA;
 				framed.set(chunk, 1);
-				dc.send(framed);
+				sendRaw(framed);
 			}
 			if (dc.readyState === "open") {
 				const end = new Uint8Array([TYPE_END]);
@@ -96,20 +220,31 @@ async function* runStream(dc, input) {
 		} finally {
 			localEnded = true;
 			maybeClose();
+			detach();
 		}
 	})();
 	let inboundDrained = false;
+	let inboundError;
 	try {
-		for await (const chunk of incoming.iterate()) yield chunk;
+		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 {
-		dc.removeEventListener("message", onMessage);
-		dc.removeEventListener("close", onClose);
+		inboundFinished = true;
+		detach();
 		if (!inboundDrained) {
-			await outbound.catch(() => {});
+			aborted = true;
+			nudge();
 			try {
 				dc.close();
 			} catch {}
+			if (inboundError) hooks.onInboundFailed?.(inboundError);
+			await outbound.catch(() => {});
 		}
 	}
 }
@@ -134,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 {
@@ -161,6 +305,210 @@ function makeInboundQueue() {
 	};
 }
 //#endregion
+//#region src/port-mux.ts
+/** The label prefix of a port's data channel: channels without it are someone else's. */
+const PORT_LABEL_PREFIX = "webrun-port/";
+/**
+* The largest message a data channel delivers between any two browsers (Firefox to Chrome cuts
+* off at 16 KiB). A post past it fails the port with a `RangeError` rather than vanishing.
+*/
+const DEFAULT_PORT_MAX_FRAME_BYTES = 16384;
+/** What one message on a port may carry before the stream tier chunks: 256 bytes under the frame limit (spec D10). */
+const DEFAULT_PORT_MAX_MESSAGE_SIZE = 16128;
+/** `whenDrained` resolves once the channel's `bufferedAmount` is at most this. */
+const PORT_DRAIN_LOW_WATER = 262144;
+let counter = 0;
+/** Inbound port channels a serving mux has taken: on one connection, each port is answered once. */
+const claimed = /* @__PURE__ */ new WeakSet();
+/**
+* Native MessagePorts over WebRTC: every port is its own `RTCDataChannel` (ordered, reliable),
+* labelled `webrun-port/…`. Hand it to `webrun-rpc` as a port source and its stream tier runs one
+* call per port, with its backpressure: a producer stays one confirmed chunk ahead of its
+* consumer, where this package's `connect` / `serve` allow a 4 MiB window.
+*
+* ```ts
+* const codec = { encode: serialize, decode: deserialize }; // webrun-msgpack
+* await serve({ mux: overPorts((onPort) => webrtcPortMux({ pc, codec, onPort })) }, handler);
+* const { call } = await connect({ mux: overPorts(() => webrtcPortMux({ pc, codec })) });
+* ```
+*
+* Messages that arrive before a port's first listener are held for it and delivered after that
+* tick, to every listener added by then.
+*/
+async function webrtcPortMux(options) {
+	const { pc, codec, onPort } = options;
+	const maxFrameBytes = options.maxFrameBytes ?? 16384;
+	const maxMessageSize = options.maxMessageSize ?? 16128;
+	const live = /* @__PURE__ */ new Set();
+	let closed = false;
+	const connectionGone = new AbortController();
+	const onConnectionState = () => {
+		if (pc.connectionState === "failed" || pc.connectionState === "closed") connectionGone.abort(/* @__PURE__ */ new Error(`webrun-streams-webrtc: the connection is ${pc.connectionState}`));
+	};
+	pc.addEventListener("connectionstatechange", onConnectionState);
+	onConnectionState();
+	const wrap = (dc) => {
+		dc.binaryType = "arraybuffer";
+		dc.bufferedAmountLowThreshold = PORT_DRAIN_LOW_WATER;
+		const life = new AbortController();
+		const end = (reason) => {
+			if (!life.signal.aborted) life.abort(reason);
+		};
+		const listeners = /* @__PURE__ */ new Set();
+		let held = [];
+		const deliver = (data) => {
+			if (closeSignal.aborted) return;
+			const event = new MessageEvent("message", { data });
+			for (const l of [...listeners]) try {
+				Promise.resolve(l(event)).catch(() => void 0);
+			} catch {}
+		};
+		const onMessage = (ev) => {
+			if (closeSignal.aborted) return;
+			let data;
+			try {
+				const raw = ev.data;
+				data = codec.decode(raw instanceof ArrayBuffer ? new Uint8Array(raw) : raw);
+			} catch (err) {
+				end(new Error("webrun-streams-webrtc: a frame the port's codec cannot decode", { cause: err }));
+				return;
+			}
+			if (held) held.push(data);
+			else deliver(data);
+		};
+		const onClose = () => end(/* @__PURE__ */ new Error("webrun-streams-webrtc: the data channel closed"));
+		const onError = (ev) => end(/* @__PURE__ */ new Error(`webrun-streams-webrtc: the data channel failed: ${ev.error?.message ?? "unknown"}`));
+		dc.addEventListener("message", onMessage);
+		dc.addEventListener("close", onClose);
+		dc.addEventListener("error", onError);
+		if (dc.readyState === "closing" || dc.readyState === "closed") onClose();
+		const closeSignal = AbortSignal.any([life.signal, connectionGone.signal]);
+		const cleanUp = () => {
+			live.delete(port);
+			dc.removeEventListener("message", onMessage);
+			listeners.clear();
+			held = void 0;
+			if (dc.readyState !== "closed") dc.close();
+		};
+		const port = {
+			closeSignal,
+			get bufferedAmount() {
+				return dc.bufferedAmount;
+			},
+			whenDrained() {
+				if (closeSignal.aborted || dc.bufferedAmount <= 262144) return Promise.resolve();
+				return new Promise((resolve) => {
+					const done = () => {
+						dc.removeEventListener("bufferedamountlow", done);
+						closeSignal.removeEventListener("abort", done);
+						resolve();
+					};
+					dc.addEventListener("bufferedamountlow", done);
+					closeSignal.addEventListener("abort", done);
+				});
+			},
+			postMessage(message) {
+				if (closeSignal.aborted || dc.readyState !== "open") return;
+				const bytes = codec.encode(message);
+				if (bytes.byteLength > maxFrameBytes) {
+					const err = /* @__PURE__ */ new RangeError(`webrun-streams-webrtc: a ${bytes.byteLength}-byte message exceeds maxFrameBytes (${maxFrameBytes})`);
+					end(err);
+					throw err;
+				}
+				try {
+					dc.send(bytes);
+				} catch (err) {
+					end(err instanceof Error ? err : new Error(String(err)));
+				}
+			},
+			addEventListener(_type, listener) {
+				listeners.add(listener);
+				if (held) {
+					const pending = held;
+					held = void 0;
+					queueMicrotask(() => {
+						for (const data of pending) deliver(data);
+					});
+				}
+			},
+			removeEventListener(_type, listener) {
+				listeners.delete(listener);
+			},
+			async close() {
+				end(/* @__PURE__ */ new Error("webrun-streams-webrtc: port closed"));
+			}
+		};
+		live.add(port);
+		if (closeSignal.aborted) cleanUp();
+		else closeSignal.addEventListener("abort", cleanUp, { once: true });
+		return port;
+	};
+	const onChannel = (ev) => {
+		const dc = ev.channel;
+		if (!dc.label.startsWith("webrun-port/")) return;
+		if (!onPort || closed || claimed.has(dc)) return;
+		claimed.add(dc);
+		const port = wrap(dc);
+		let accepted = false;
+		try {
+			accepted = onPort(port) !== false;
+		} catch {
+			accepted = false;
+		}
+		if (!accepted) port.close();
+	};
+	pc.addEventListener("datachannel", onChannel);
+	return {
+		maxMessageSize,
+		async openPort(_meta, opts) {
+			if (closed) throw new Error("webrun-streams-webrtc: port mux closed");
+			const signal = opts?.signal;
+			signal?.throwIfAborted();
+			if (connectionGone.signal.aborted) throw connectionGone.signal.reason;
+			const dc = pc.createDataChannel(`${PORT_LABEL_PREFIX}${(counter++).toString(36)}`, { ordered: true });
+			const port = wrap(dc);
+			await new Promise((resolve, reject) => {
+				if (port.closeSignal.aborted) return reject(port.closeSignal.reason);
+				if (dc.readyState === "open") return resolve();
+				const settle = () => {
+					dc.removeEventListener("open", done);
+					port.closeSignal.removeEventListener("abort", fail);
+					signal?.removeEventListener("abort", cancel);
+				};
+				const done = () => {
+					settle();
+					resolve();
+				};
+				const fail = () => {
+					settle();
+					reject(port.closeSignal.reason);
+				};
+				const cancel = () => {
+					settle();
+					port.close();
+					reject(signal?.reason);
+				};
+				dc.addEventListener("open", done);
+				port.closeSignal.addEventListener("abort", fail, { once: true });
+				signal?.addEventListener("abort", cancel, { once: true });
+			});
+			if (signal) {
+				const onAbort = () => void port.close();
+				signal.addEventListener("abort", onAbort, { once: true });
+				port.closeSignal.addEventListener("abort", () => signal.removeEventListener("abort", onAbort), { once: true });
+			}
+			return port;
+		},
+		async close() {
+			if (closed) return;
+			closed = true;
+			pc.removeEventListener("datachannel", onChannel);
+			pc.removeEventListener("connectionstatechange", onConnectionState);
+			await Promise.allSettled([...live].map((p) => p.close()));
+		}
+	};
+}
+//#endregion
 //#region src/connect-serve.ts
 /**
 * Caller-side: each `call(input)` invocation opens a new `RTCDataChannel` on
@@ -171,18 +519,17 @@ 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");
 		})();
 		const label = `webrun/${Date.now().toString(36)}/${(counter++).toString(36)}`;
 		const dc = pc.createDataChannel(label);
+		holdEvents(dc);
 		open.add(dc);
 		dc.addEventListener("close", () => open.delete(dc));
 		return (async function* () {
@@ -194,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 {}
@@ -208,15 +556,27 @@ const connect = async ({ pc }) => {
 const serve = async ({ pc }, handler) => {
 	const onChannel = (ev) => {
 		const dc = ev.channel;
+		if (dc.label.startsWith("webrun-port/")) return;
+		holdEvents(dc);
+		markAnswering(dc);
 		let inputFromPeer = null;
 		(async () => {
 			await waitForOpen(dc);
-			inputFromPeer = peekInput(dc);
-			const out = handler(inputFromPeer.input);
-			for await (const chunk of duplexOverDataChannel(dc, out)) inputFromPeer.deliver(chunk);
-			inputFromPeer.done();
-		})().catch(() => {
-			inputFromPeer?.done();
+			const peek = peekInput(dc);
+			inputFromPeer = peek;
+			const handlerOutput = handler(peek.input);
+			const out = (async function* () {
+				try {
+					yield* handlerOutput;
+				} finally {
+					peek.release();
+				}
+			})();
+			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);
@@ -273,40 +633,59 @@ function peekInput(_dc) {
 	const slots = [];
 	let wake = null;
 	let closed = false;
-	return {
-		input: (async function* () {
-			try {
-				while (true) {
-					if (slots.length === 0) {
-						await new Promise((r) => {
-							wake = r;
-						});
-						wake = null;
-						continue;
-					}
-					const slot = slots.shift();
-					if (!slot) continue;
-					if (slot.type === "done") return;
-					yield slot.value;
+	let ended = false;
+	const input = (async function* () {
+		try {
+			while (true) {
+				if (slots.length === 0) {
+					await new Promise((r) => {
+						wake = r;
+					});
+					wake = null;
+					continue;
+				}
+				const slot = slots.shift();
+				if (!slot) continue;
+				if (slot.type === "done") {
+					if (slot.err) throw slot.err;
+					return;
 				}
-			} finally {
-				closed = true;
+				slot.taken();
+				yield slot.value;
 			}
-		})(),
+		} finally {
+			release();
+		}
+	})();
+	function release() {
+		closed = true;
+		for (const s of slots.splice(0)) if (s.type === "value") s.taken();
+		wake?.();
+	}
+	return {
+		input,
 		deliver(chunk) {
-			if (closed) return;
+			if (closed) return Promise.resolve();
+			return new Promise((taken) => {
+				slots.push({
+					type: "value",
+					value: chunk,
+					taken
+				});
+				wake?.();
+			});
+		},
+		done(err) {
+			if (closed || ended) return;
+			ended = true;
 			slots.push({
-				type: "value",
-				value: chunk
+				type: "done",
+				err
 			});
 			wake?.();
 		},
-		done() {
-			if (closed) return;
-			slots.push({ type: "done" });
-			wake?.();
-		}
+		release
 	};
 }
 //#endregion
-export { connect, duplexOverDataChannel, serve };
+export { DEFAULT_PORT_MAX_FRAME_BYTES, DEFAULT_PORT_MAX_MESSAGE_SIZE, PORT_DRAIN_LOW_WATER, PORT_LABEL_PREFIX, connect, duplexOverDataChannel, serve, webrtcPortMux };

package/dist/port-mux.d.ts

@@ -0,0 +1,74 @@
+/** The label prefix of a port's data channel: channels without it are someone else's. */
+export declare const PORT_LABEL_PREFIX = "webrun-port/";
+/**
+ * The largest message a data channel delivers between any two browsers (Firefox to Chrome cuts
+ * off at 16 KiB). A post past it fails the port with a `RangeError` rather than vanishing.
+ */
+export declare const DEFAULT_PORT_MAX_FRAME_BYTES: number;
+/** What one message on a port may carry before the stream tier chunks: 256 bytes under the frame limit (spec D10). */
+export declare const DEFAULT_PORT_MAX_MESSAGE_SIZE: number;
+/** `whenDrained` resolves once the channel's `bufferedAmount` is at most this. */
+export declare const PORT_DRAIN_LOW_WATER: number;
+/**
+ * How a port's messages become bytes and back: any value the stream tier posts. `webrun-msgpack`'s
+ * `{ encode: serialize, decode: deserialize }` fits.
+ */
+export interface ValueCodec {
+    encode(value: unknown): Uint8Array;
+    decode(bytes: Uint8Array): unknown;
+}
+type Listener = (event: MessageEvent) => void | Promise<void>;
+/** One port: a data channel as a `MessageTarget` of values, with its close signal on it. */
+export interface DataChannelPort {
+    addEventListener(type: "message", listener: Listener): void;
+    removeEventListener(type: "message", listener: Listener): void;
+    /** Sends one message. `RangeError`, failing the port, past `maxFrameBytes`. */
+    postMessage(message: unknown): void;
+    close(): Promise<void>;
+    readonly bufferedAmount: number;
+    whenDrained(): Promise<void>;
+    /** Aborts when the channel closes or errs, the connection fails, or the port is closed here. */
+    readonly closeSignal: AbortSignal;
+}
+export interface WebRtcPortMuxOptions {
+    /** A connected `RTCPeerConnection` with SCTP negotiated. Signalling is the caller's. */
+    pc: RTCPeerConnection;
+    /** Encodes each message; both ends must agree. */
+    codec: ValueCodec;
+    /**
+     * Called for each port the peer opens (an inbound channel with the port label). `false` refuses
+     * it. A mux without `onPort` (a caller's) ignores inbound ports, leaving them to the serving
+     * mux on the same connection; of several serving muxes on one connection, the first takes each.
+     */
+    onPort?: (port: DataChannelPort) => boolean | undefined;
+    /** Reported as `maxMessageSize`. Default {@link DEFAULT_PORT_MAX_MESSAGE_SIZE}. */
+    maxMessageSize?: number;
+    /** Default {@link DEFAULT_PORT_MAX_FRAME_BYTES}. */
+    maxFrameBytes?: number;
+}
+/** A `webrun-rpc` `PortMux` by shape; this package imports nothing from it. */
+export interface WebRtcPortMux {
+    openPort(meta?: unknown, options?: {
+        signal?: AbortSignal;
+    }): Promise<DataChannelPort>;
+    close(reason?: unknown): Promise<void>;
+    readonly maxMessageSize: number;
+}
+/**
+ * Native MessagePorts over WebRTC: every port is its own `RTCDataChannel` (ordered, reliable),
+ * labelled `webrun-port/…`. Hand it to `webrun-rpc` as a port source and its stream tier runs one
+ * call per port, with its backpressure: a producer stays one confirmed chunk ahead of its
+ * consumer, where this package's `connect` / `serve` allow a 4 MiB window.
+ *
+ * ```ts
+ * const codec = { encode: serialize, decode: deserialize }; // webrun-msgpack
+ * await serve({ mux: overPorts((onPort) => webrtcPortMux({ pc, codec, onPort })) }, handler);
+ * const { call } = await connect({ mux: overPorts(() => webrtcPortMux({ pc, codec })) });
+ * ```
+ *
+ * Messages that arrive before a port's first listener are held for it and delivered after that
+ * tick, to every listener added by then.
+ */
+export declare function webrtcPortMux(options: WebRtcPortMuxOptions): Promise<WebRtcPortMux>;
+export {};
+//# sourceMappingURL=port-mux.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"port-mux.d.ts","sourceRoot":"","sources":["../src/port-mux.ts"],"names":[],"mappings":"AAAA,yFAAyF;AACzF,eAAO,MAAM,iBAAiB,iBAAiB,CAAC;AAEhD;;;GAGG;AACH,eAAO,MAAM,4BAA4B,QAAY,CAAC;AAEtD,sHAAsH;AACtH,eAAO,MAAM,6BAA6B,QAAqC,CAAC;AAEhF,kFAAkF;AAClF,eAAO,MAAM,oBAAoB,QAAa,CAAC;AAE/C;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,CAAC;IACnC,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC;CACpC;AAED,KAAK,QAAQ,GAAG,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE9D,4FAA4F;AAC5F,MAAM,WAAW,eAAe;IAC9B,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC5D,mBAAmB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC/D,+EAA+E;IAC/E,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IACpC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,gGAAgG;IAChG,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;CACnC;AAED,MAAM,WAAW,oBAAoB;IACnC,wFAAwF;IACxF,EAAE,EAAE,iBAAiB,CAAC;IACtB,kDAAkD;IAClD,KAAK,EAAE,UAAU,CAAC;IAClB;;;;OAIG;IACH,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,eAAe,KAAK,OAAO,GAAG,SAAS,CAAC;IACxD,mFAAmF;IACnF,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,oDAAoD;IACpD,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,+EAA+E;AAC/E,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;IACvF,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AAMD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,aAAa,CAAC,CA6MzF"}