@tangentfeed/transport-webrtc 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sreeraj T A
+
+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,8 @@
+# @tangentfeed/transport-webrtc
+
+WebRTC transports for tangentfeed.
+
+- `WebRTCTransport` — cross-device mesh brokered by a signaling server
+- `ManualPairTransport` — serverless pairing by QR code or copy-paste
+
+Part of [tangentfeed](https://github.com/sreerajta/tangentfeed). MIT licensed.

package/dist/index.d.ts

@@ -0,0 +1,173 @@
+import { Transport, WireMsg } from '@tangentfeed/core';
+
+/**
+ * Manual pairing transport — WebRTC with zero infrastructure.
+ *
+ * Instead of a signaling server, two humans carry the signaling: device A
+ * displays its offer as a QR code (or copyable text), device B ingests it and
+ * displays an answer, A ingests that, and the DataChannel opens. Works with
+ * no internet at all on a shared LAN.
+ *
+ * The trick that makes one-QR-per-direction possible: NON-trickle ICE. We
+ * wait for candidate gathering to finish (with a timeout fallback — host
+ * candidates alone are enough on a LAN) so the SDP blob contains every
+ * candidate inline. Nothing else about the stack changes: this class speaks
+ * the same Transport interface, so the Replicator neither knows nor cares
+ * that signaling traveled by camera.
+ *
+ * Exactly two peers by design. Blobs are base64url(JSON) and single-use.
+ */
+
+type ManualPairState = "idle" | "gathering" | "waiting-for-answer" | "connecting" | "connected" | "failed" | "closed";
+interface ManualPairOptions {
+    deviceId: string;
+    wrtc?: {
+        RTCPeerConnection: typeof RTCPeerConnection;
+    };
+    rtcConfig?: RTCConfiguration;
+    onError?: (err: unknown) => void;
+    onState?: (state: ManualPairState) => void;
+    /** max ms to wait for full ICE gathering before shipping what we have */
+    gatherTimeoutMs?: number;
+}
+interface Blob1 {
+    v: 1;
+    kind: "offer" | "answer";
+    device: string;
+    /** pairing space id, minted by the offerer; the answerer adopts it */
+    space: string;
+    sdp: RTCSessionDescriptionInit;
+}
+declare class ManualPairTransport implements Transport {
+    private readonly opts;
+    private readonly RTCPC;
+    private pc;
+    private channel;
+    private readonly msgListeners;
+    private readonly peerConnectListeners;
+    private _state;
+    private _space;
+    private _peerDevice;
+    constructor(opts: ManualPairOptions);
+    get state(): ManualPairState;
+    /** The pairing space id (offerer mints it; answerer learns it from the offer). */
+    get space(): string | null;
+    get peerDevice(): string | null;
+    /** Role A: create the offer blob to display as a QR / copy to the peer. */
+    createOffer(): Promise<string>;
+    /** Role A: ingest the answer blob the peer displayed. */
+    acceptAnswer(blob: string): Promise<void>;
+    /** Role B: ingest an offer blob; returns the answer blob to display back. */
+    acceptOffer(blob: string): Promise<string>;
+    send(msg: WireMsg): void;
+    onMessage(cb: (msg: WireMsg) => void): () => void;
+    onPeerConnect(cb: (peerId?: string) => void): () => void;
+    close(): void;
+    private newPc;
+    private attachChannel;
+    /** Resolve when ICE gathering completes, or after the timeout with whatever
+     * candidates exist (host candidates suffice on a LAN). */
+    private gathered;
+    private setState;
+}
+declare function encodeBlob(msg: Blob1): string;
+declare function decodeBlob(blob: string): Blob1;
+
+/**
+ * WebRTC transport — device-to-device sync over DataChannels.
+ *
+ * Same four-member Transport interface as BroadcastChannel; everything below
+ * this API line is peer lifecycle:
+ *
+ *   - Presence via the signaling server (join room → peers / peer-joined).
+ *   - Deterministic roles kill offer-glare at the root: for any pair, the
+ *     LOWER deviceId is the initiator (creates the DataChannel and offer);
+ *     the higher answers. Only one side ever offers, so the classic
+ *     both-offer-simultaneously race cannot occur.
+ *   - Trickle ICE relayed as opaque blobs through the signaling server.
+ *   - Fan-out send: WireMsg JSON to every open channel (bus semantics);
+ *     Replicator's `to` filtering discards what isn't addressed to a peer.
+ *   - Signaling reconnect with capped exponential backoff; peer connections
+ *     are rebuilt on rejoin. Op idempotency upstream makes all of this safe.
+ *
+ * Environment injection: pass `wrtc` (RTCPeerConnection impl) and
+ * `WebSocketImpl` for Node (node-datachannel/polyfill, global WebSocket);
+ * browsers need neither.
+ */
+
+type PeerConnectCb = (peerId?: string) => void;
+type SignalingState = "connecting" | "connected" | "disconnected" | "conflict";
+/**
+ * Public STUN, used when the caller supplies no `iceServers`.
+ *
+ * STUN only discovers your public address; it cannot relay. Two peers behind
+ * symmetric NAT will still fail to connect, and for those you need a TURN
+ * server — which relays traffic and therefore costs bandwidth, which is why
+ * there is no public default for it. See docs/TURN.md.
+ */
+declare const DEFAULT_ICE_SERVERS: RTCIceServer[];
+interface WebRTCTransportOptions {
+    space: string;
+    deviceId: string;
+    /** ws:// or wss:// URL of the signaling server */
+    signalingUrl: string;
+    /** RTCPeerConnection constructor; defaults to globalThis.RTCPeerConnection */
+    wrtc?: {
+        RTCPeerConnection: typeof RTCPeerConnection;
+    };
+    /** WebSocket constructor; defaults to globalThis.WebSocket */
+    WebSocketImpl?: typeof WebSocket;
+    /**
+     * Passed straight to RTCPeerConnection. Omit `iceServers` and you get
+     * DEFAULT_ICE_SERVERS — a public STUN server, enough for two peers behind
+     * ordinary home routers and not enough for symmetric NAT or strict
+     * corporate firewalls. Those need TURN; see docs/TURN.md.
+     */
+    rtcConfig?: RTCConfiguration;
+    /** called on non-fatal internal errors (a peer failing, signaling drop) */
+    onError?: (err: unknown, ctx: {
+        peer?: string;
+    }) => void;
+    /**
+     * Signaling connection lifecycle. "conflict" is terminal: another
+     * connection claimed this deviceId (the server evicted us). We do NOT
+     * auto-reconnect on conflict — doing so would make the two holders evict
+     * each other in an endless loop. Recover by reconnecting with a new id.
+     */
+    onSignalingState?: (state: SignalingState) => void;
+}
+declare class WebRTCTransport implements Transport {
+    private readonly opts;
+    private readonly RTCPC;
+    private readonly WS;
+    private ws;
+    private readonly peers;
+    private readonly msgListeners;
+    private readonly peerConnectListeners;
+    private closed;
+    private backoff;
+    constructor(opts: WebRTCTransportOptions);
+    send(msg: WireMsg): void;
+    onMessage(cb: (msg: WireMsg) => void): () => void;
+    onPeerConnect(cb: PeerConnectCb): () => void;
+    close(): void;
+    /** Currently connected (channel-open) peer deviceIds. For UI. */
+    get connectedPeers(): string[];
+    /** Per-peer diagnostics for debugging/UI: connection + ICE + channel state. */
+    get peerDiagnostics(): {
+        id: string;
+        connection: string;
+        ice: string;
+        channel: string;
+    }[];
+    private connectSignaling;
+    private sigSend;
+    private handleSignaling;
+    private isInitiatorFor;
+    private ensurePeer;
+    private handleSignal;
+    private attachChannel;
+    private dropPeer;
+}
+
+export { DEFAULT_ICE_SERVERS, type ManualPairOptions, type ManualPairState, ManualPairTransport, type SignalingState, WebRTCTransport, type WebRTCTransportOptions, decodeBlob, encodeBlob };

package/dist/index.js

@@ -0,0 +1,442 @@
+// src/manual.ts
+var CHANNEL_LABEL = "tangentfeed";
+var ManualPairTransport = class {
+  opts;
+  RTCPC;
+  pc = null;
+  channel = null;
+  msgListeners = /* @__PURE__ */ new Set();
+  peerConnectListeners = /* @__PURE__ */ new Set();
+  _state = "idle";
+  _space = null;
+  _peerDevice = null;
+  constructor(opts) {
+    this.opts = opts;
+    const rtc = opts.wrtc?.RTCPeerConnection ?? globalThis.RTCPeerConnection;
+    if (!rtc) throw new Error("no RTCPeerConnection available; pass opts.wrtc");
+    this.RTCPC = rtc;
+  }
+  get state() {
+    return this._state;
+  }
+  /** The pairing space id (offerer mints it; answerer learns it from the offer). */
+  get space() {
+    return this._space;
+  }
+  get peerDevice() {
+    return this._peerDevice;
+  }
+  // ---------- pairing (device A) ----------
+  /** Role A: create the offer blob to display as a QR / copy to the peer. */
+  async createOffer() {
+    if (this.pc) throw new Error("pairing already in progress; create a new transport");
+    this._space = "manual-" + randHex(8);
+    const pc = this.newPc();
+    this.attachChannel(pc.createDataChannel(CHANNEL_LABEL));
+    this.setState("gathering");
+    const offer = await pc.createOffer();
+    await pc.setLocalDescription(offer);
+    await this.gathered(pc);
+    this.setState("waiting-for-answer");
+    return encodeBlob({
+      v: 1,
+      kind: "offer",
+      device: this.opts.deviceId,
+      space: this._space,
+      sdp: pc.localDescription ?? offer
+    });
+  }
+  /** Role A: ingest the answer blob the peer displayed. */
+  async acceptAnswer(blob) {
+    const msg = decodeBlob(blob);
+    if (msg.kind !== "answer") throw new Error("expected an ANSWER blob, got an offer \u2014 paste it on the other device");
+    if (!this.pc) throw new Error("no pending offer; call createOffer first");
+    this._peerDevice = msg.device;
+    this.setState("connecting");
+    await this.pc.setRemoteDescription(msg.sdp);
+  }
+  // ---------- pairing (device B) ----------
+  /** Role B: ingest an offer blob; returns the answer blob to display back. */
+  async acceptOffer(blob) {
+    if (this.pc) throw new Error("pairing already in progress; create a new transport");
+    const msg = decodeBlob(blob);
+    if (msg.kind !== "offer") throw new Error("expected an OFFER blob, got an answer");
+    this._space = msg.space;
+    this._peerDevice = msg.device;
+    const pc = this.newPc();
+    pc.ondatachannel = (ev) => this.attachChannel(ev.channel);
+    this.setState("gathering");
+    await pc.setRemoteDescription(msg.sdp);
+    const answer = await pc.createAnswer();
+    await pc.setLocalDescription(answer);
+    await this.gathered(pc);
+    this.setState("connecting");
+    return encodeBlob({
+      v: 1,
+      kind: "answer",
+      device: this.opts.deviceId,
+      space: msg.space,
+      sdp: pc.localDescription ?? answer
+    });
+  }
+  // ---------- Transport interface ----------
+  send(msg) {
+    if (this.channel?.readyState === "open") {
+      try {
+        this.channel.send(JSON.stringify(msg));
+      } catch (err) {
+        this.opts.onError?.(err);
+      }
+    }
+  }
+  onMessage(cb) {
+    this.msgListeners.add(cb);
+    return () => this.msgListeners.delete(cb);
+  }
+  onPeerConnect(cb) {
+    this.peerConnectListeners.add(cb);
+    return () => this.peerConnectListeners.delete(cb);
+  }
+  close() {
+    this.setState("closed");
+    try {
+      this.channel?.close();
+    } catch {
+    }
+    try {
+      this.pc?.close();
+    } catch {
+    }
+    this.channel = null;
+    this.pc = null;
+    this.msgListeners.clear();
+    this.peerConnectListeners.clear();
+  }
+  // ---------- internals ----------
+  newPc() {
+    const pc = new this.RTCPC(this.opts.rtcConfig ?? {});
+    this.pc = pc;
+    pc.onconnectionstatechange = () => {
+      if (pc.connectionState === "connected") this.setState("connected");
+      if (["failed", "closed"].includes(pc.connectionState)) {
+        if (this._state !== "closed") this.setState("failed");
+      }
+    };
+    return pc;
+  }
+  attachChannel(channel) {
+    this.channel = channel;
+    channel.onopen = () => {
+      this.setState("connected");
+      for (const cb of this.peerConnectListeners) cb(this._peerDevice ?? void 0);
+    };
+    channel.onmessage = (ev) => {
+      try {
+        const msg = JSON.parse(String(ev.data));
+        for (const cb of this.msgListeners) cb(msg);
+      } catch (err) {
+        this.opts.onError?.(err);
+      }
+    };
+    channel.onclose = () => {
+      if (this._state !== "closed") this.setState("failed");
+    };
+  }
+  /** Resolve when ICE gathering completes, or after the timeout with whatever
+   * candidates exist (host candidates suffice on a LAN). */
+  gathered(pc) {
+    if (pc.iceGatheringState === "complete") return Promise.resolve();
+    const timeoutMs = this.opts.gatherTimeoutMs ?? 2500;
+    return new Promise((resolve) => {
+      const done = () => {
+        clearTimeout(timer);
+        resolve();
+      };
+      const timer = setTimeout(done, timeoutMs);
+      const check = () => {
+        if (pc.iceGatheringState === "complete") done();
+      };
+      pc.addEventListener?.("icegatheringstatechange", check);
+      const prev = pc.onicecandidate;
+      pc.onicecandidate = (ev) => {
+        prev?.call(pc, ev);
+        if (!ev.candidate) done();
+      };
+    });
+  }
+  setState(s) {
+    this._state = s;
+    this.opts.onState?.(s);
+  }
+};
+function encodeBlob(msg) {
+  return b64urlEncode(JSON.stringify(msg));
+}
+function decodeBlob(blob) {
+  let parsed;
+  try {
+    parsed = JSON.parse(b64urlDecode(blob.trim()));
+  } catch {
+    throw new Error("not a valid pairing blob (paste the whole code, nothing else)");
+  }
+  const m = parsed;
+  if (m?.v !== 1 || !m.sdp || m.kind !== "offer" && m.kind !== "answer" || !m.space) {
+    throw new Error("unrecognized pairing blob format");
+  }
+  return m;
+}
+function b64urlEncode(s) {
+  const bytes = new TextEncoder().encode(s);
+  let bin = "";
+  for (const b of bytes) bin += String.fromCharCode(b);
+  const b64 = typeof btoa === "function" ? btoa(bin) : Buffer.from(bytes).toString("base64");
+  return b64.replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function b64urlDecode(s) {
+  const b64 = s.replaceAll("-", "+").replaceAll("_", "/");
+  const padded = b64 + "=".repeat((4 - b64.length % 4) % 4);
+  const bin = typeof atob === "function" ? atob(padded) : Buffer.from(padded, "base64").toString("binary");
+  const bytes = Uint8Array.from(bin, (c) => c.charCodeAt(0));
+  return new TextDecoder().decode(bytes);
+}
+function randHex(n) {
+  const b = new Uint8Array(n / 2);
+  globalThis.crypto.getRandomValues(b);
+  return Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+}
+
+// src/index.ts
+var DEFAULT_ICE_SERVERS = [
+  { urls: "stun:stun.l.google.com:19302" }
+];
+var CHANNEL_LABEL2 = "tangentfeed";
+var MAX_BACKOFF_MS = 15e3;
+var WebRTCTransport = class {
+  opts;
+  RTCPC;
+  WS;
+  ws = null;
+  peers = /* @__PURE__ */ new Map();
+  msgListeners = /* @__PURE__ */ new Set();
+  peerConnectListeners = /* @__PURE__ */ new Set();
+  closed = false;
+  backoff = 500;
+  constructor(opts) {
+    this.opts = opts;
+    const rtc = opts.wrtc?.RTCPeerConnection ?? globalThis.RTCPeerConnection;
+    const ws = opts.WebSocketImpl ?? globalThis.WebSocket;
+    if (!rtc) throw new Error("no RTCPeerConnection available; pass opts.wrtc");
+    if (!ws) throw new Error("no WebSocket available; pass opts.WebSocketImpl");
+    this.RTCPC = rtc;
+    this.WS = ws;
+    this.connectSignaling();
+  }
+  // ---------- Transport interface ----------
+  send(msg) {
+    const payload = JSON.stringify(msg);
+    for (const peer of this.peers.values()) {
+      if (peer.channel?.readyState === "open") {
+        try {
+          peer.channel.send(payload);
+        } catch (err) {
+          this.opts.onError?.(err, {});
+        }
+      }
+    }
+  }
+  onMessage(cb) {
+    this.msgListeners.add(cb);
+    return () => this.msgListeners.delete(cb);
+  }
+  onPeerConnect(cb) {
+    this.peerConnectListeners.add(cb);
+    return () => this.peerConnectListeners.delete(cb);
+  }
+  close() {
+    this.closed = true;
+    for (const [id] of this.peers) this.dropPeer(id);
+    this.ws?.close();
+    this.ws = null;
+    this.msgListeners.clear();
+    this.peerConnectListeners.clear();
+  }
+  /** Currently connected (channel-open) peer deviceIds. For UI. */
+  get connectedPeers() {
+    return [...this.peers.entries()].filter(([, p]) => p.channel?.readyState === "open").map(([id]) => id);
+  }
+  /** Per-peer diagnostics for debugging/UI: connection + ICE + channel state. */
+  get peerDiagnostics() {
+    return [...this.peers.entries()].map(([id, p]) => ({
+      id,
+      connection: p.pc.connectionState ?? "?",
+      ice: p.pc.iceConnectionState ?? "?",
+      channel: p.channel?.readyState ?? "no channel"
+    }));
+  }
+  // ---------- signaling ----------
+  connectSignaling() {
+    if (this.closed) return;
+    this.opts.onSignalingState?.("connecting");
+    const ws = new this.WS(this.opts.signalingUrl);
+    this.ws = ws;
+    ws.onopen = () => {
+      this.backoff = 500;
+      this.opts.onSignalingState?.("connected");
+      this.sigSend({ t: "join", space: this.opts.space, device: this.opts.deviceId });
+    };
+    ws.onmessage = (ev) => {
+      let msg;
+      try {
+        msg = JSON.parse(String(ev.data));
+      } catch {
+        return;
+      }
+      void this.handleSignaling(msg).catch(
+        (err) => this.opts.onError?.(err, {})
+      );
+    };
+    ws.onclose = (ev) => {
+      if (this.closed) return;
+      if (ev.code === 4e3) {
+        this.opts.onSignalingState?.("conflict");
+        this.opts.onError?.(
+          new Error("deviceId already connected to this space (evicted); rejoin with a new deviceId"),
+          {}
+        );
+        return;
+      }
+      this.opts.onSignalingState?.("disconnected");
+      setTimeout(() => this.connectSignaling(), this.backoff);
+      this.backoff = Math.min(this.backoff * 2, MAX_BACKOFF_MS);
+    };
+    ws.onerror = () => {
+    };
+  }
+  sigSend(msg) {
+    if (this.ws && this.ws.readyState === 1) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+  async handleSignaling(msg) {
+    switch (msg["t"]) {
+      case "peers": {
+        for (const device of msg["devices"] ?? []) {
+          void this.ensurePeer(device);
+        }
+        break;
+      }
+      case "peer-joined": {
+        void this.ensurePeer(msg["device"]);
+        break;
+      }
+      case "peer-left": {
+        this.dropPeer(msg["device"]);
+        break;
+      }
+      case "signal": {
+        await this.handleSignal(msg["from"], msg["data"]);
+        break;
+      }
+    }
+  }
+  // ---------- peer lifecycle ----------
+  isInitiatorFor(peerId) {
+    return this.opts.deviceId < peerId;
+  }
+  async ensurePeer(peerId) {
+    if (!peerId || peerId === this.opts.deviceId || this.peers.has(peerId)) return;
+    const config = {
+      iceServers: DEFAULT_ICE_SERVERS,
+      ...this.opts.rtcConfig
+    };
+    const pc = new this.RTCPC(config);
+    const peer = { pc, pendingCandidates: [], remoteDescSet: false };
+    this.peers.set(peerId, peer);
+    pc.onicecandidate = (ev) => {
+      if (ev.candidate) {
+        this.sigSend({ t: "signal", to: peerId, data: { kind: "ice", candidate: ev.candidate } });
+      }
+    };
+    pc.onconnectionstatechange = () => {
+      if (["failed", "closed", "disconnected"].includes(pc.connectionState)) {
+        this.dropPeer(peerId);
+      }
+    };
+    if (this.isInitiatorFor(peerId)) {
+      this.attachChannel(peerId, pc.createDataChannel(CHANNEL_LABEL2));
+      try {
+        const offer = await pc.createOffer();
+        await pc.setLocalDescription(offer);
+        this.sigSend({ t: "signal", to: peerId, data: { kind: "sdp", description: pc.localDescription } });
+      } catch (err) {
+        this.opts.onError?.(err, { peer: peerId });
+        this.dropPeer(peerId);
+      }
+    } else {
+      pc.ondatachannel = (ev) => this.attachChannel(peerId, ev.channel);
+    }
+  }
+  async handleSignal(from, data) {
+    await this.ensurePeer(from);
+    const peer = this.peers.get(from);
+    if (!peer) return;
+    try {
+      if (data.kind === "sdp" && data.description) {
+        await peer.pc.setRemoteDescription(data.description);
+        peer.remoteDescSet = true;
+        for (const c of peer.pendingCandidates.splice(0)) {
+          await peer.pc.addIceCandidate(c);
+        }
+        if (data.description.type === "offer") {
+          const answer = await peer.pc.createAnswer();
+          await peer.pc.setLocalDescription(answer);
+          this.sigSend({ t: "signal", to: from, data: { kind: "sdp", description: peer.pc.localDescription } });
+        }
+      } else if (data.kind === "ice" && data.candidate) {
+        if (peer.remoteDescSet) await peer.pc.addIceCandidate(data.candidate);
+        else peer.pendingCandidates.push(data.candidate);
+      }
+    } catch (err) {
+      this.opts.onError?.(err, { peer: from });
+    }
+  }
+  attachChannel(peerId, channel) {
+    const peer = this.peers.get(peerId);
+    if (!peer) return;
+    peer.channel = channel;
+    channel.onopen = () => {
+      for (const cb of this.peerConnectListeners) cb(peerId);
+    };
+    channel.onmessage = (ev) => {
+      try {
+        const msg = JSON.parse(String(ev.data));
+        for (const cb of this.msgListeners) cb(msg);
+      } catch (err) {
+        this.opts.onError?.(err, { peer: peerId });
+      }
+    };
+    channel.onclose = () => {
+      if (this.peers.get(peerId)?.channel === channel) this.dropPeer(peerId);
+    };
+  }
+  dropPeer(peerId) {
+    const peer = this.peers.get(peerId);
+    if (!peer) return;
+    this.peers.delete(peerId);
+    try {
+      peer.channel?.close();
+    } catch {
+    }
+    try {
+      peer.pc.close();
+    } catch {
+    }
+  }
+};
+export {
+  DEFAULT_ICE_SERVERS,
+  ManualPairTransport,
+  WebRTCTransport,
+  decodeBlob,
+  encodeBlob
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@tangentfeed/transport-webrtc",
+  "version": "0.2.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "scripts": {
+    "test": "vitest run",
+    "build": "tsup src/index.ts --format esm --dts --clean --external node-datachannel",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "@tangentfeed/core": "0.2.0"
+  },
+  "devDependencies": {
+    "@tangentfeed/signaling-server": "0.2.0",
+    "@types/node": "^20.0.0",
+    "node-datachannel": "^0.26.0",
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0",
+    "tsup": "^8.5.0"
+  },
+  "description": "WebRTC transports for tangentfeed: signaling-server mesh and serverless QR pairing",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sreerajta/tangentfeed.git",
+    "directory": "packages/transport-webrtc"
+  },
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  }
+}