@statewalker/webrun-streams-livekit 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-livekit
+
+LiveKit-backed `Connect` / `Serve` adapter. Wraps a connected `Room` plus a participant identity into a byte channel; `emulateMux` provides multi-stream. `RELIABLE` publish mode is forced (ordered, retransmitted).
+
+```ts
+import { connect, serve } from "@statewalker/webrun-streams-livekit";
+
+const { call } = await connect({ room, peerIdentity: "agent-7" });
+const stop = await serve({ room, peerIdentity: "client-3" }, handler);
+```
+
+Conformance is browser-gated; run with `pnpm test:browser` plus `WEBRUN_STREAMS_LIVEKIT_*` env vars set against a running LiveKit server.
+
+## License
+
+MIT

package/dist/byte-channel.d.ts

@@ -0,0 +1,9 @@
+import type { ByteChannel } from "@statewalker/webrun-streams";
+import type { Room } from "livekit-client";
+/**
+ * Wrap a connected LiveKit `Room` plus a remote participant identity into a
+ * `ByteChannel`. Outbound bytes are addressed only to the named participant;
+ * inbound is filtered by sender identity.
+ */
+export declare function byteChannelFromLiveKit(room: Room, peerIdentity: string): ByteChannel;
+//# sourceMappingURL=byte-channel.d.ts.map

package/dist/byte-channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"byte-channel.d.ts","sourceRoot":"","sources":["../src/byte-channel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,KAAK,EAAqB,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAa9D;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,GAAG,WAAW,CAsGpF"}

package/dist/connect-serve.d.ts

@@ -0,0 +1,11 @@
+import { type Connect, type Serve } from "@statewalker/webrun-streams";
+import type { Room } from "livekit-client";
+export interface LiveKitParams {
+    /** Already-connected LiveKit `Room`. */
+    room: Room;
+    /** Identity of the remote participant the call addresses. */
+    peerIdentity: string;
+}
+export declare const connect: Connect<LiveKitParams>;
+export declare const serve: Serve<LiveKitParams>;
+//# 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,EAAE,KAAK,OAAO,EAA2B,KAAK,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAChG,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAG3C,MAAM,WAAW,aAAa;IAC5B,wCAAwC;IACxC,IAAI,EAAE,IAAI,CAAC;IACX,6DAA6D;IAC7D,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,eAAO,MAAM,OAAO,EAAE,OAAO,CAAC,aAAa,CAS1C,CAAC;AAEF,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,aAAa,CAYtC,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { byteChannelFromLiveKit } from "./byte-channel.js";
+export { connect, type LiveKitParams, serve } from "./connect-serve.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,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,114 @@
+import { emulateMux } from "@statewalker/webrun-streams";
+//#region src/byte-channel.ts
+/**
+* Wrap a connected LiveKit `Room` plus a remote participant identity into a
+* `ByteChannel`. Outbound bytes are addressed only to the named participant;
+* inbound is filtered by sender identity.
+*/
+function byteChannelFromLiveKit(room, peerIdentity) {
+	let closedResolve;
+	const closed = new Promise((r) => {
+		closedResolve = r;
+	});
+	let isClosed = false;
+	const queue = [];
+	let pending = null;
+	const deliver = (bytes) => {
+		if (isClosed) return;
+		if (pending) {
+			const r = pending;
+			pending = null;
+			r({
+				value: bytes,
+				done: false
+			});
+		} else queue.push(bytes);
+	};
+	const onData = (payload, participant) => {
+		if (!participant) return;
+		if (participant.identity !== peerIdentity) return;
+		deliver(new Uint8Array(payload));
+	};
+	const onDisconnected = () => {
+		fireClose();
+	};
+	const onParticipantDisconnected = (participant) => {
+		if (participant.identity !== peerIdentity) return;
+		fireClose();
+	};
+	const fireClose = () => {
+		if (isClosed) return;
+		isClosed = true;
+		roomApi.off("dataReceived", onData);
+		roomApi.off("disconnected", onDisconnected);
+		roomApi.off("participantDisconnected", onParticipantDisconnected);
+		if (pending) {
+			const r = pending;
+			pending = null;
+			r({
+				value: void 0,
+				done: true
+			});
+		}
+		closedResolve();
+	};
+	const roomApi = room;
+	roomApi.on("dataReceived", onData);
+	roomApi.on("disconnected", onDisconnected);
+	roomApi.on("participantDisconnected", onParticipantDisconnected);
+	return {
+		send(bytes) {
+			if (isClosed) return;
+			room.localParticipant.publishData(bytes, {
+				reliable: true,
+				destinationIdentities: [peerIdentity]
+			}).catch(() => {});
+		},
+		recv: { [Symbol.asyncIterator]() {
+			return { next() {
+				if (queue.length > 0) return Promise.resolve({
+					value: queue.shift(),
+					done: false
+				});
+				if (isClosed) return Promise.resolve({
+					value: void 0,
+					done: true
+				});
+				return new Promise((resolve) => {
+					pending = resolve;
+				});
+			} };
+		} },
+		closed,
+		close() {
+			fireClose();
+		}
+	};
+}
+//#endregion
+//#region src/connect-serve.ts
+const connect = async ({ room, peerIdentity }) => {
+	const channel = byteChannelFromLiveKit(room, peerIdentity);
+	const mux = emulateMux(channel, { side: "initiator" });
+	return {
+		call: mux.call,
+		async close() {
+			await mux.close();
+		}
+	};
+};
+const serve = async ({ room, peerIdentity }, handler) => {
+	const channel = byteChannelFromLiveKit(room, peerIdentity);
+	const mux = emulateMux(channel, { side: "responder" });
+	const off = mux.serve(handler);
+	channel.closed.then(() => mux.close());
+	let torn = false;
+	return async () => {
+		if (torn) return;
+		torn = true;
+		await off();
+		await mux.close();
+	};
+};
+//#endregion
+export { byteChannelFromLiveKit, connect, serve };

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@statewalker/webrun-streams-livekit",
+  "version": "0.1.1",
+  "private": false,
+  "type": "module",
+  "description": "LiveKit-backed Connect/Serve adapter 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"
+  },
+  "peerDependencies": {
+    "livekit-client": "^2.18.3"
+  },
+  "devDependencies": {
+    "@types/node": "^26.2.0",
+    "livekit-client": "^2.18.3",
+    "livekit-server-sdk": "^2.10.0",
+    "rimraf": "^6.1.3",
+    "rolldown": "^1.2.4",
+    "testcontainers": "^11.0.0",
+    "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/byte-channel.ts

@@ -0,0 +1,122 @@
+import type { ByteChannel } from "@statewalker/webrun-streams";
+import type { RemoteParticipant, Room } from "livekit-client";
+
+/**
+ * livekit-client v2 `publishData` options shape. Reliable mode is ordered +
+ * retransmitted; the bridged-byte contract requires this. `destinationIdentities`
+ * restricts the publish to the named recipients so peer-to-peer pairings on the
+ * same room don't fan out to every participant.
+ */
+type DataPublishOptions = {
+  reliable?: boolean;
+  destinationIdentities?: string[];
+};
+
+/**
+ * Wrap a connected LiveKit `Room` plus a remote participant identity into a
+ * `ByteChannel`. Outbound bytes are addressed only to the named participant;
+ * inbound is filtered by sender identity.
+ */
+export function byteChannelFromLiveKit(room: Room, peerIdentity: string): ByteChannel {
+  let closedResolve!: () => void;
+  const closed = new Promise<void>((r) => {
+    closedResolve = r;
+  });
+  let isClosed = false;
+
+  const queue: Uint8Array[] = [];
+  let pending: ((value: IteratorResult<Uint8Array>) => void) | null = null;
+
+  const deliver = (bytes: Uint8Array): void => {
+    if (isClosed) return;
+    if (pending) {
+      const r = pending;
+      pending = null;
+      r({ value: bytes, done: false });
+    } else {
+      queue.push(bytes);
+    }
+  };
+
+  const onData = (payload: Uint8Array, participant?: RemoteParticipant): void => {
+    if (!participant) return;
+    if (participant.identity !== peerIdentity) return;
+    deliver(new Uint8Array(payload));
+  };
+
+  const onDisconnected = (): void => {
+    fireClose();
+  };
+
+  const onParticipantDisconnected = (participant: RemoteParticipant): void => {
+    if (participant.identity !== peerIdentity) return;
+    fireClose();
+  };
+
+  const fireClose = (): void => {
+    if (isClosed) return;
+    isClosed = true;
+    roomApi.off("dataReceived", onData as (...args: unknown[]) => void);
+    roomApi.off("disconnected", onDisconnected);
+    roomApi.off(
+      "participantDisconnected",
+      onParticipantDisconnected as (...args: unknown[]) => void,
+    );
+    if (pending) {
+      const r = pending;
+      pending = null;
+      r({ value: undefined, done: true } as IteratorResult<Uint8Array>);
+    }
+    closedResolve();
+  };
+
+  // livekit-client surfaces events via a typed emitter; coerce to the
+  // structural on/off shape we need.
+  const roomApi = room as unknown as {
+    on(ev: string, fn: (...args: unknown[]) => void): void;
+    off(ev: string, fn: (...args: unknown[]) => void): void;
+  };
+  roomApi.on("dataReceived", onData as (...args: unknown[]) => void);
+  roomApi.on("disconnected", onDisconnected);
+  roomApi.on("participantDisconnected", onParticipantDisconnected as (...args: unknown[]) => void);
+
+  const recv: AsyncIterable<Uint8Array> = {
+    [Symbol.asyncIterator]() {
+      return {
+        next(): Promise<IteratorResult<Uint8Array>> {
+          if (queue.length > 0) {
+            return Promise.resolve({ value: queue.shift() as Uint8Array, done: false });
+          }
+          if (isClosed) {
+            return Promise.resolve({
+              value: undefined,
+              done: true,
+            } as IteratorResult<Uint8Array>);
+          }
+          return new Promise<IteratorResult<Uint8Array>>((resolve) => {
+            pending = resolve;
+          });
+        },
+      };
+    },
+  };
+
+  return {
+    send(bytes) {
+      if (isClosed) return;
+      const publish = room.localParticipant as unknown as {
+        publishData: (data: Uint8Array, options?: DataPublishOptions) => Promise<void>;
+      };
+      publish
+        .publishData(bytes, { reliable: true, destinationIdentities: [peerIdentity] })
+        .catch(() => {
+          /* publish failure surfaces via disconnect events */
+        });
+    },
+    recv,
+    closed,
+    close() {
+      fireClose();
+    },
+  };
+}

package/src/connect-serve.ts

@@ -0,0 +1,35 @@
+import { type Connect, type Duplex, emulateMux, type Serve } from "@statewalker/webrun-streams";
+import type { Room } from "livekit-client";
+import { byteChannelFromLiveKit } from "./byte-channel.js";
+
+export interface LiveKitParams {
+  /** Already-connected LiveKit `Room`. */
+  room: Room;
+  /** Identity of the remote participant the call addresses. */
+  peerIdentity: string;
+}
+
+export const connect: Connect<LiveKitParams> = async ({ room, peerIdentity }) => {
+  const channel = byteChannelFromLiveKit(room, peerIdentity);
+  const mux = emulateMux(channel, { side: "initiator" });
+  return {
+    call: mux.call,
+    async close() {
+      await mux.close();
+    },
+  };
+};
+
+export const serve: Serve<LiveKitParams> = async ({ room, peerIdentity }, handler: Duplex) => {
+  const channel = byteChannelFromLiveKit(room, peerIdentity);
+  const mux = emulateMux(channel, { side: "responder" });
+  const off = mux.serve(handler);
+  void channel.closed.then(() => mux.close());
+  let torn = false;
+  return async () => {
+    if (torn) return;
+    torn = true;
+    await off();
+    await mux.close();
+  };
+};

package/src/index.ts

@@ -0,0 +1,2 @@
+export { byteChannelFromLiveKit } from "./byte-channel.js";
+export { connect, type LiveKitParams, serve } from "./connect-serve.js";