@statewalker/webrun-streams-webrtc 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022-2026 statewalker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,16 @@
+# @statewalker/webrun-streams-webrtc
+
+WebRTC native multi-stream `Connect` / `Serve` adapter. Each `call(input)` opens a fresh `RTCDataChannel` on the supplied `RTCPeerConnection`; the responder listens on `pc.ondatachannel`.
+
+DataChannels have no native half-close, so the adapter carries a tiny 1-byte frame protocol inside each DC message: `DATA` (0x00, body bytes), `END` (0x01, half-close), `ERROR` (0x02, serialised error). Outbound bytes are chunked at 16 KiB.
+
+```ts
+import { connect, serve } from "@statewalker/webrun-streams-webrtc";
+
+const { call } = await connect({ pc });          // RTCPeerConnection
+const stop = await serve({ pc }, handler);
+```
+
+## License
+
+MIT

package/dist/connect-serve.d.ts

@@ -0,0 +1,18 @@
+import type { Connect, Serve } from "@statewalker/webrun-streams";
+export interface WebRtcParams {
+    /** Open `RTCPeerConnection`. Signalling, auth, and connection setup are the caller's responsibility. */
+    pc: RTCPeerConnection;
+}
+/**
+ * Caller-side: each `call(input)` invocation opens a new `RTCDataChannel` on
+ * `pc` and runs the call over it. The DataChannel's `label` is generated
+ * locally and the responder picks the channel up via `pc.ondatachannel`.
+ */
+export declare const connect: Connect<WebRtcParams>;
+/**
+ * Server-side: registers `pc.ondatachannel` and routes each inbound channel
+ * to `handler`. Returns a teardown that stops accepting new channels;
+ * channels already in flight continue until their `Duplex` completes.
+ */
+export declare const serve: Serve<WebRtcParams>;
+//# sourceMappingURL=connect-serve.d.ts.map

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

@@ -0,0 +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;AAG1E,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,CAoBrC,CAAC"}

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

@@ -0,0 +1,16 @@
+/**
+ * Drive one `Duplex` over one `RTCDataChannel`. The DataChannel hosts a tiny
+ * in-band framing protocol:
+ *
+ *     [1-byte type][payload bytes...]
+ *
+ * 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`).
+ *
+ * `RTCDataChannel` has no native half-close, so `END` is emitted by the
+ * sender once its input iterator exhausts; the channel is only physically
+ * closed once both sides have ended.
+ */
+export declare function duplexOverDataChannel(dc: RTCDataChannel, input: AsyncIterable<Uint8Array>): AsyncGenerator<Uint8Array>;
+//# sourceMappingURL=duplex-over-data-channel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"duplex-over-data-channel.d.ts","sourceRoot":"","sources":["../src/duplex-over-data-channel.ts"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,cAAc,EAClB,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,GAC/B,cAAc,CAAC,UAAU,CAAC,CAE5B"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { connect, serve, type WebRtcParams } from "./connect-serve.js";
+export { duplexOverDataChannel } from "./duplex-over-data-channel.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvE,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/index.js

@@ -0,0 +1,302 @@
+import { TransportClosedError, deserializeError, serializeError, toChunks } from "@statewalker/webrun-streams";
+//#region src/duplex-over-data-channel.ts
+const TYPE_DATA = 0;
+const TYPE_END = 1;
+const TYPE_ERROR = 2;
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+/**
+* Drive one `Duplex` over one `RTCDataChannel`. The DataChannel hosts a tiny
+* in-band framing protocol:
+*
+*     [1-byte type][payload bytes...]
+*
+* 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`).
+*
+* `RTCDataChannel` has no native half-close, so `END` is emitted by the
+* sender once its input iterator exhausts; the channel is only physically
+* closed once both sides have ended.
+*/
+function duplexOverDataChannel(dc, input) {
+	return runStream(dc, input);
+}
+async function* runStream(dc, input) {
+	dc.binaryType = "arraybuffer";
+	const incoming = makeInboundQueue();
+	let peerEnded = false;
+	let localEnded = false;
+	const maybeClose = () => {
+		if (peerEnded && localEnded) try {
+			dc.close();
+		} catch {}
+	};
+	const onMessage = (event) => {
+		const data = event.data;
+		let bytes;
+		if (data instanceof ArrayBuffer) bytes = new Uint8Array(data);
+		else if (data instanceof Uint8Array) bytes = data;
+		else if (ArrayBuffer.isView(data)) {
+			const view = data;
+			bytes = new Uint8Array(view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength));
+		} else return;
+		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) {
+			peerEnded = true;
+			incoming.done();
+			maybeClose();
+		} else if (type === TYPE_ERROR) {
+			let err;
+			try {
+				err = deserializeError(JSON.parse(textDecoder.decode(payload)));
+			} catch {
+				err = new Error(textDecoder.decode(payload));
+			}
+			peerEnded = true;
+			incoming.done(err);
+			maybeClose();
+		}
+	};
+	const onClose = () => {
+		if (!peerEnded) {
+			incoming.done(new TransportClosedError());
+			peerEnded = true;
+		}
+	};
+	dc.addEventListener("message", onMessage);
+	dc.addEventListener("close", onClose);
+	const outbound = (async () => {
+		try {
+			for await (const chunk of toChunks(16383)(input)) {
+				if (dc.readyState !== "open") return;
+				const framed = new Uint8Array(chunk.byteLength + 1);
+				framed[0] = TYPE_DATA;
+				framed.set(chunk, 1);
+				dc.send(framed);
+			}
+			if (dc.readyState === "open") {
+				const end = new Uint8Array([TYPE_END]);
+				dc.send(end);
+			}
+		} catch (err) {
+			if (dc.readyState === "open") {
+				const e = err instanceof Error ? err : new Error(String(err));
+				const payload = textEncoder.encode(JSON.stringify(serializeError(e)));
+				const framed = new Uint8Array(payload.byteLength + 1);
+				framed[0] = TYPE_ERROR;
+				framed.set(payload, 1);
+				try {
+					dc.send(framed);
+				} catch {}
+			}
+		} finally {
+			localEnded = true;
+			maybeClose();
+		}
+	})();
+	try {
+		for await (const chunk of incoming.iterate()) yield chunk;
+	} finally {
+		dc.removeEventListener("message", onMessage);
+		dc.removeEventListener("close", onClose);
+		await outbound.catch(() => {});
+	}
+}
+function makeInboundQueue() {
+	const slots = [];
+	let wake = null;
+	let closed = false;
+	return {
+		push(chunk) {
+			if (closed) return;
+			slots.push({
+				type: "value",
+				value: chunk
+			});
+			wake?.();
+		},
+		done(err) {
+			if (closed) return;
+			slots.push({
+				type: "done",
+				err
+			});
+			wake?.();
+		},
+		iterate() {
+			return (async function* () {
+				try {
+					while (true) {
+						if (slots.length === 0) {
+							await new Promise((r) => {
+								wake = r;
+							});
+							wake = null;
+							continue;
+						}
+						const slot = slots.shift();
+						if (slot.type === "done") {
+							if (slot.err) throw slot.err;
+							return;
+						}
+						yield slot.value;
+					}
+				} finally {
+					closed = true;
+					slots.length = 0;
+				}
+			})();
+		}
+	};
+}
+//#endregion
+//#region src/connect-serve.ts
+/**
+* Caller-side: each `call(input)` invocation opens a new `RTCDataChannel` on
+* `pc` and runs the call over it. The DataChannel's `label` is generated
+* locally and the responder picks the channel up via `pc.ondatachannel`.
+*/
+const connect = async ({ pc }) => {
+	let counter = 0;
+	let closed = false;
+	const open = /* @__PURE__ */ new Set();
+	const onConnectionClose = () => {
+		closed = true;
+	};
+	pc.addEventListener("connectionstatechange", () => {
+		if (pc.connectionState === "closed" || pc.connectionState === "failed") onConnectionClose();
+	});
+	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);
+		open.add(dc);
+		dc.addEventListener("close", () => open.delete(dc));
+		return (async function* () {
+			await waitForOpen(dc);
+			yield* duplexOverDataChannel(dc, toAsyncIterable(input));
+		})();
+	};
+	return {
+		call,
+		async close() {
+			closed = true;
+			for (const dc of open) try {
+				dc.close();
+			} catch {}
+		}
+	};
+};
+/**
+* Server-side: registers `pc.ondatachannel` and routes each inbound channel
+* to `handler`. Returns a teardown that stops accepting new channels;
+* channels already in flight continue until their `Duplex` completes.
+*/
+const serve = async ({ pc }, handler) => {
+	const onChannel = (ev) => {
+		const dc = ev.channel;
+		(async () => {
+			await waitForOpen(dc);
+			const inputFromPeer = peekInput(dc);
+			const out = handler(inputFromPeer.input);
+			for await (const chunk of duplexOverDataChannel(dc, out)) inputFromPeer.deliver(chunk);
+			inputFromPeer.done();
+		})();
+	};
+	pc.addEventListener("datachannel", onChannel);
+	let torn = false;
+	return async () => {
+		if (torn) return;
+		torn = true;
+		pc.removeEventListener("datachannel", onChannel);
+	};
+};
+function waitForOpen(dc) {
+	if (dc.readyState === "open") return Promise.resolve();
+	return new Promise((resolve, reject) => {
+		const cleanup = () => {
+			dc.removeEventListener("open", onOpen);
+			dc.removeEventListener("close", onClose);
+			dc.removeEventListener("error", onError);
+		};
+		const onOpen = () => {
+			cleanup();
+			resolve();
+		};
+		const onClose = () => {
+			cleanup();
+			reject(/* @__PURE__ */ new Error("DataChannel closed before open"));
+		};
+		const onError = (ev) => {
+			cleanup();
+			reject(/* @__PURE__ */ new Error(`DataChannel error: ${ev.error?.message ?? "unknown"}`));
+		};
+		dc.addEventListener("open", onOpen);
+		dc.addEventListener("close", onClose);
+		dc.addEventListener("error", onError);
+	});
+}
+function toAsyncIterable(input) {
+	if (input[Symbol.asyncIterator]) return input;
+	const it = input[Symbol.iterator]();
+	return { [Symbol.asyncIterator]() {
+		return { next: () => Promise.resolve(it.next()) };
+	} };
+}
+/**
+* For the server side, the handler needs an `input` async iterable backed by
+* the peer's bytes — which arrive via `duplexOverDataChannel`'s yields on this
+* very `dc`. This helper builds a queue/iterator pair so the handler reads
+* from `input` while we drive `duplexOverDataChannel` and tee chunks into it.
+*
+* The arrangement: `duplexOverDataChannel(dc, handlerOutput)` returns the
+* inbound stream as its own AsyncGenerator. We `deliver()` each chunk into
+* the handler's input queue.
+*/
+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;
+				}
+			} finally {
+				closed = true;
+			}
+		})(),
+		deliver(chunk) {
+			if (closed) return;
+			slots.push({
+				type: "value",
+				value: chunk
+			});
+			wake?.();
+		},
+		done() {
+			if (closed) return;
+			slots.push({ type: "done" });
+			wake?.();
+		}
+	};
+}
+//#endregion
+export { connect, duplexOverDataChannel, serve };

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@statewalker/webrun-streams-webrtc",
+  "version": "0.1.1",
+  "private": false,
+  "type": "module",
+  "description": "WebRTC DataChannel-backed Connect/Serve adapter (native multi-stream) in the webrun-streams-* family",
+  "homepage": "https://github.com/statewalker/webrun-wire",
+  "author": {
+    "name": "Mikhail Kotelnikov",
+    "email": "mikhail.kotelnikov@gmail.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:statewalker/webrun-wire.git"
+  },
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "@statewalker/webrun-streams": "0.1.1"
+  },
+  "devDependencies": {
+    "@roamhq/wrtc": "^0.8.0",
+    "@types/node": "^26.2.0",
+    "rimraf": "^6.1.3",
+    "rolldown": "^1.2.4",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10",
+    "@statewalker/webrun-streams-conformance": "0.1.1"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rimraf dist && rolldown -c && tsc --emitDeclarationOnly --declaration",
+    "test": "vitest run",
+    "test:browser": "vitest run --config vitest.browser.config.ts",
+    "lint": "biome check src tests"
+  }
+}

package/src/connect-serve.ts

@@ -0,0 +1,182 @@
+import type { Connect, Duplex, Serve } from "@statewalker/webrun-streams";
+import { duplexOverDataChannel } from "./duplex-over-data-channel.js";
+
+export interface WebRtcParams {
+  /** Open `RTCPeerConnection`. Signalling, auth, and connection setup are the caller's responsibility. */
+  pc: RTCPeerConnection;
+}
+
+/**
+ * Caller-side: each `call(input)` invocation opens a new `RTCDataChannel` on
+ * `pc` and runs the call over it. The DataChannel's `label` is generated
+ * locally and the responder picks the channel up via `pc.ondatachannel`.
+ */
+export const connect: Connect<WebRtcParams> = async ({ pc }) => {
+  let counter = 0;
+  let closed = false;
+  const open = new Set<RTCDataChannel>();
+  const onConnectionClose = (): void => {
+    closed = true;
+  };
+  pc.addEventListener("connectionstatechange", () => {
+    if (pc.connectionState === "closed" || pc.connectionState === "failed") onConnectionClose();
+  });
+
+  const call: Duplex = (input) => {
+    if (closed) {
+      return (async function* () {
+        if ((0 as number) === 0) throw new Error("webrun-streams-webrtc: connection closed");
+        yield new Uint8Array(0);
+      })();
+    }
+    const label = `webrun/${Date.now().toString(36)}/${(counter++).toString(36)}`;
+    const dc = pc.createDataChannel(label);
+    open.add(dc);
+    dc.addEventListener("close", () => open.delete(dc));
+    return (async function* () {
+      await waitForOpen(dc);
+      yield* duplexOverDataChannel(dc, toAsyncIterable(input));
+    })();
+  };
+
+  return {
+    call,
+    async close() {
+      closed = true;
+      for (const dc of open) {
+        try {
+          dc.close();
+        } catch {
+          /* ignore */
+        }
+      }
+    },
+  };
+};
+
+/**
+ * Server-side: registers `pc.ondatachannel` and routes each inbound channel
+ * to `handler`. Returns a teardown that stops accepting new channels;
+ * channels already in flight continue until their `Duplex` completes.
+ */
+export const serve: Serve<WebRtcParams> = async ({ pc }, handler: Duplex) => {
+  const onChannel = (ev: RTCDataChannelEvent): void => {
+    const dc = ev.channel;
+    void (async () => {
+      await waitForOpen(dc);
+      const inputFromPeer = peekInput(dc);
+      const out = handler(inputFromPeer.input);
+      for await (const chunk of duplexOverDataChannel(dc, out)) {
+        inputFromPeer.deliver(chunk);
+      }
+      inputFromPeer.done();
+    })();
+  };
+  pc.addEventListener("datachannel", onChannel);
+  let torn = false;
+  return async () => {
+    if (torn) return;
+    torn = true;
+    pc.removeEventListener("datachannel", onChannel);
+  };
+};
+
+function waitForOpen(dc: RTCDataChannel): Promise<void> {
+  if (dc.readyState === "open") return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    const cleanup = (): void => {
+      dc.removeEventListener("open", onOpen);
+      dc.removeEventListener("close", onClose);
+      dc.removeEventListener("error", onError);
+    };
+    const onOpen = (): void => {
+      cleanup();
+      resolve();
+    };
+    const onClose = (): void => {
+      cleanup();
+      reject(new Error("DataChannel closed before open"));
+    };
+    const onError = (ev: Event): void => {
+      cleanup();
+      reject(
+        new Error(
+          `DataChannel error: ${(ev as unknown as { error?: { message?: string } }).error?.message ?? "unknown"}`,
+        ),
+      );
+    };
+    dc.addEventListener("open", onOpen);
+    dc.addEventListener("close", onClose);
+    dc.addEventListener("error", onError);
+  });
+}
+
+function toAsyncIterable(
+  input: AsyncIterable<Uint8Array> | Iterable<Uint8Array>,
+): AsyncIterable<Uint8Array> {
+  if ((input as AsyncIterable<Uint8Array>)[Symbol.asyncIterator]) {
+    return input as AsyncIterable<Uint8Array>;
+  }
+  const it = (input as Iterable<Uint8Array>)[Symbol.iterator]();
+  return {
+    [Symbol.asyncIterator]() {
+      return {
+        next: () => Promise.resolve(it.next()),
+      };
+    },
+  };
+}
+
+interface PeekInput {
+  input: AsyncGenerator<Uint8Array>;
+  deliver(chunk: Uint8Array): void;
+  done(): void;
+}
+
+/**
+ * For the server side, the handler needs an `input` async iterable backed by
+ * the peer's bytes — which arrive via `duplexOverDataChannel`'s yields on this
+ * very `dc`. This helper builds a queue/iterator pair so the handler reads
+ * from `input` while we drive `duplexOverDataChannel` and tee chunks into it.
+ *
+ * The arrangement: `duplexOverDataChannel(dc, handlerOutput)` returns the
+ * inbound stream as its own AsyncGenerator. We `deliver()` each chunk into
+ * the handler's input queue.
+ */
+function peekInput(_dc: RTCDataChannel): PeekInput {
+  const slots: Array<{ type: "value"; value: Uint8Array } | { type: "done" }> = [];
+  let wake: (() => void) | null = null;
+  let closed = false;
+  const input = (async function* () {
+    try {
+      while (true) {
+        if (slots.length === 0) {
+          await new Promise<void>((r) => {
+            wake = r;
+          });
+          wake = null;
+          continue;
+        }
+        const slot = slots.shift();
+        if (!slot) continue;
+        if (slot.type === "done") return;
+        yield slot.value;
+      }
+    } finally {
+      closed = true;
+    }
+  })();
+  return {
+    input,
+    deliver(chunk: Uint8Array): void {
+      if (closed) return;
+      slots.push({ type: "value", value: chunk });
+      wake?.();
+    },
+    done(): void {
+      if (closed) return;
+      slots.push({ type: "done" });
+      wake?.();
+    },
+  };
+}

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

@@ -0,0 +1,193 @@
+import {
+  deserializeError,
+  serializeError,
+  TransportClosedError,
+  toChunks,
+} from "@statewalker/webrun-streams";
+
+const TYPE_DATA = 0x00;
+const TYPE_END = 0x01;
+const TYPE_ERROR = 0x02;
+
+const DC_MTU = 16 * 1024; // conservative across browsers
+const FRAME_OVERHEAD = 1; // 1-byte type tag
+
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+
+/**
+ * Drive one `Duplex` over one `RTCDataChannel`. The DataChannel hosts a tiny
+ * in-band framing protocol:
+ *
+ *     [1-byte type][payload bytes...]
+ *
+ * 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`).
+ *
+ * `RTCDataChannel` has no native half-close, so `END` is emitted by the
+ * sender once its input iterator exhausts; the channel is only physically
+ * closed once both sides have ended.
+ */
+export function duplexOverDataChannel(
+  dc: RTCDataChannel,
+  input: AsyncIterable<Uint8Array>,
+): AsyncGenerator<Uint8Array> {
+  return runStream(dc, input);
+}
+
+async function* runStream(
+  dc: RTCDataChannel,
+  input: AsyncIterable<Uint8Array> | Iterable<Uint8Array>,
+): AsyncGenerator<Uint8Array> {
+  dc.binaryType = "arraybuffer";
+
+  const incoming = makeInboundQueue();
+  let peerEnded = false;
+  let localEnded = false;
+
+  const maybeClose = (): void => {
+    if (peerEnded && localEnded) {
+      try {
+        dc.close();
+      } catch {
+        /* ignore */
+      }
+    }
+  };
+
+  const onMessage = (event: MessageEvent): void => {
+    const data = event.data as unknown;
+    let bytes: Uint8Array;
+    if (data instanceof ArrayBuffer) bytes = new Uint8Array(data);
+    else if (data instanceof Uint8Array) bytes = data;
+    else if (ArrayBuffer.isView(data)) {
+      const view = data as ArrayBufferView;
+      bytes = new Uint8Array(view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength));
+    } else return;
+    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) {
+      peerEnded = true;
+      incoming.done();
+      maybeClose();
+    } else if (type === TYPE_ERROR) {
+      let err: Error;
+      try {
+        err = deserializeError(JSON.parse(textDecoder.decode(payload)));
+      } catch {
+        err = new Error(textDecoder.decode(payload));
+      }
+      peerEnded = true;
+      incoming.done(err);
+      maybeClose();
+    }
+  };
+
+  const onClose = (): void => {
+    if (!peerEnded) {
+      incoming.done(new TransportClosedError());
+      peerEnded = true;
+    }
+  };
+
+  dc.addEventListener("message", onMessage);
+  dc.addEventListener("close", onClose);
+
+  // Outbound pump runs in parallel with inbound iteration.
+  const outbound = (async () => {
+    try {
+      for await (const chunk of toChunks(DC_MTU - FRAME_OVERHEAD)(input)) {
+        if (dc.readyState !== "open") return;
+        const framed = new Uint8Array(chunk.byteLength + 1);
+        framed[0] = TYPE_DATA;
+        framed.set(chunk, 1);
+        (dc as unknown as { send: (data: Uint8Array) => void }).send(framed);
+      }
+      if (dc.readyState === "open") {
+        const end = new Uint8Array([TYPE_END]);
+        (dc as unknown as { send: (data: Uint8Array) => void }).send(end);
+      }
+    } catch (err) {
+      if (dc.readyState === "open") {
+        const e = err instanceof Error ? err : new Error(String(err));
+        const payload = textEncoder.encode(JSON.stringify(serializeError(e)));
+        const framed = new Uint8Array(payload.byteLength + 1);
+        framed[0] = TYPE_ERROR;
+        framed.set(payload, 1);
+        try {
+          (dc as unknown as { send: (data: Uint8Array) => void }).send(framed);
+        } catch {
+          /* ignore */
+        }
+      }
+    } finally {
+      localEnded = true;
+      maybeClose();
+    }
+  })();
+
+  try {
+    for await (const chunk of incoming.iterate()) {
+      yield chunk;
+    }
+  } finally {
+    dc.removeEventListener("message", onMessage);
+    dc.removeEventListener("close", onClose);
+    // Wait for outbound to settle so close() doesn't truncate in-flight sends.
+    await outbound.catch(() => {});
+  }
+}
+
+interface InboundQueue {
+  push(chunk: Uint8Array): void;
+  done(err?: Error): void;
+  iterate(): AsyncGenerator<Uint8Array>;
+}
+
+function makeInboundQueue(): InboundQueue {
+  type Slot = { type: "value"; value: Uint8Array } | { type: "done"; err?: Error };
+  const slots: Slot[] = [];
+  let wake: (() => void) | null = null;
+  let closed = false;
+
+  return {
+    push(chunk: Uint8Array): void {
+      if (closed) return;
+      slots.push({ type: "value", value: chunk });
+      wake?.();
+    },
+    done(err?: Error): void {
+      if (closed) return;
+      slots.push({ type: "done", err });
+      wake?.();
+    },
+    iterate(): AsyncGenerator<Uint8Array> {
+      return (async function* () {
+        try {
+          while (true) {
+            if (slots.length === 0) {
+              await new Promise<void>((r) => {
+                wake = r;
+              });
+              wake = null;
+              continue;
+            }
+            const slot = slots.shift() as Slot;
+            if (slot.type === "done") {
+              if (slot.err) throw slot.err;
+              return;
+            }
+            yield slot.value;
+          }
+        } finally {
+          closed = true;
+          slots.length = 0;
+        }
+      })();
+    },
+  };
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export { connect, serve, type WebRtcParams } from "./connect-serve.js";
+export { duplexOverDataChannel } from "./duplex-over-data-channel.js";