@crosslink/webrtc-adapter 0.1.0

package/LICENSE

@@ -0,0 +1,163 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by the
+   copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all other
+   entities that control, are controlled by, or are under common control
+   with that entity. For the purposes of this definition, "control" means
+   (i) the power, direct or indirect, to cause the direction or management
+   of such entity, whether by contract or otherwise, or (ii) ownership of
+   fifty percent (50%) or more of the outstanding shares, or (iii) beneficial
+   ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity exercising
+   permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation source,
+   and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical transformation
+   or translation of a Source form, including but not limited to compiled
+   object code, generated documentation, and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or Object
+   form, made available under the License, as indicated by a copyright notice
+   that is included in or attached to the work.
+
+   "Derivative Works" shall mean any work, whether in Source or Object form,
+   that is based on (or derived from) the Work and for which the editorial
+   revisions, annotations, elaborations, or other modifications represent, as
+   a whole, an original work of authorship. For the purposes of this License,
+   Derivative Works shall not include works that remain separable from, or
+   merely link (or bind by name) to the interfaces of, the Work and Derivative
+   Works thereof.
+
+   "Contribution" shall mean any work of authorship, including the original
+   version of the Work and any modifications or additions to that Work or
+   Derivative Works thereof, that is intentionally submitted to the Licensor
+   for inclusion in the Work by the copyright owner or by an individual or
+   Legal Entity authorized to submit on behalf of the copyright owner. For the
+   purposes of this definition, "submitted" means any form of electronic,
+   verbal, or written communication sent to the Licensor or its representatives,
+   including but not limited to communication on electronic mailing lists,
+   source code control systems, and issue tracking systems that are managed by,
+   or on behalf of, the Licensor for the purpose of discussing and improving
+   the Work, but excluding communication that is conspicuously marked or
+   otherwise designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity on
+   behalf of whom a Contribution has been received by the Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this
+   License, each Contributor hereby grants to You a perpetual, worldwide,
+   non-exclusive, no-charge, royalty-free, irrevocable copyright license to
+   reproduce, prepare Derivative Works of, publicly display, publicly perform,
+   sublicense, and distribute the Work and such Derivative Works in Source or
+   Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this
+   License, each Contributor hereby grants to You a perpetual, worldwide,
+   non-exclusive, no-charge, royalty-free, irrevocable (except as stated in
+   this section) patent license to make, have made, use, offer to sell, sell,
+   import, and otherwise transfer the Work, where such license applies only to
+   those patent claims licensable by such Contributor that are necessarily
+   infringed by their Contribution(s) alone or by combination of their
+   Contribution(s) with the Work to which such Contribution(s) was submitted.
+   If You institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+   Contribution incorporated within the Work constitutes direct or contributory
+   patent infringement, then any patent licenses granted to You under this
+   License for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or
+   Derivative Works thereof in any medium, with or without modifications, and
+   in Source or Object form, provided that You meet the following conditions:
+
+   (a) You must give any other recipients of the Work or Derivative Works
+       a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices stating
+       that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works that You
+       distribute, all copyright, patent, trademark, and attribution notices
+       from the Source form of the Work, excluding those notices that do not
+       pertain to any part of the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its distribution,
+       then any Derivative Works that You distribute must include a readable
+       copy of the attribution notices contained within such NOTICE file,
+       excluding any notices that do not pertain to any part of the Derivative
+       Works, in at least one of the following places: within a NOTICE text
+       file distributed as part of the Derivative Works; within the Source
+       form or documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and wherever
+       such third-party notices normally appear. The contents of the NOTICE
+       file are for informational purposes only and do not modify the License.
+       You may add Your own attribution notices within Derivative Works that
+       You distribute, alongside or as an addendum to the NOTICE text from
+       the Work, provided that such additional attribution notices cannot be
+       construed as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and may
+   provide additional or different license terms and conditions for use,
+   reproduction, or distribution of Your modifications, or for any such
+   Derivative Works as a whole, provided Your use, reproduction, and
+   distribution of the Work otherwise complies with the conditions stated
+   in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any
+   Contribution intentionally submitted for inclusion in the Work by You to
+   the Licensor shall be under the terms and conditions of this License,
+   without any additional terms or conditions. Notwithstanding the above,
+   nothing herein shall supersede or modify the terms of any separate license
+   agreement you may have executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names,
+   trademarks, service marks, or product names of the Licensor, except as
+   required for reasonable and customary use in describing the origin of the
+   Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in
+   writing, Licensor provides the Work (and each Contributor provides its
+   Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+   KIND, either express or implied, including, without limitation, any warranties
+   or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any risks
+   associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in
+   tort (including negligence), contract, or otherwise, unless required by
+   applicable law (such as deliberate and grossly negligent acts) or agreed to
+   in writing, shall any Contributor be liable to You for damages, including
+   any direct, indirect, special, incidental, or consequential damages of any
+   character arising as a result of this License or out of the use or inability
+   to use the Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all other
+   commercial damages or losses), even if such Contributor has been advised of
+   the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work
+   or Derivative Works thereof, You may choose to offer, and charge a fee for,
+   acceptance of support, warranty, indemnity, or other liability obligations
+   and/or rights consistent with this License. However, in accepting such
+   obligations, You may act only on Your own behalf and on Your sole
+   responsibility, not on behalf of any other Contributor, and only if You
+   agree to indemnify, defend, and hold each Contributor harmless for any
+   liability incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS

package/README.md

@@ -0,0 +1,11 @@
+# @crosslink/webrtc-adapter
+
+<p align="center"><img src="https://crosslink.mintlify.site/crosslink.svg" alt="Crosslink" width="320" /></p>
+
+WebRTC data-channel transport support for Crosslink connections.
+
+```bash
+npm install @crosslink/webrtc-adapter
+```
+
+See the [Crosslink documentation](https://crosslink.mintlify.site) and [repository](https://github.com/jacobpowaza/crosslink).

package/dist/index.d.ts

@@ -0,0 +1,194 @@
+import { TransportCandidate, CrosslinkTransport, ConnectionKind } from '@crosslink/core';
+
+/**
+ * SDP exchange over an existing Crosslink session.
+ *
+ * The transport primitives in `./index.js` deliberately know nothing about
+ * signaling: they take an `exchange` callback and leave the question of how an
+ * offer reaches the other side to the embedder. This module answers that
+ * question the obvious way - by sending the offer down a Crosslink session the
+ * two devices already share.
+ *
+ * That makes the exchange inherit everything the session already provides:
+ * it is end-to-end encrypted, it is authenticated to a specific paired device,
+ * and it is capability-gated like any other method. No third party sees the
+ * SDP, and no separate signaling channel has to be stood up, authenticated or
+ * kept alive.
+ *
+ * The shape is:
+ *
+ *   1. Client and host are connected over whatever worked first - typically
+ *      the relay, which is reliable but pays for every byte in latency.
+ *   2. The client calls `crosslink.webrtc.offer` over that session with its
+ *      SDP offer. The host answers with its SDP answer.
+ *   3. Both sides now hold a DataChannel. The client asks its `ClientLink` to
+ *      upgrade onto it, which runs a fresh CLX1 handshake over the channel and
+ *      swaps transports only once that succeeds.
+ *   4. If any of this fails, nothing happens: the relayed session carries on.
+ *
+ * The relayed session is the fallback, not a stepping stone to be torn down
+ * optimistically.
+ */
+
+/** The default method name for the SDP exchange. */
+declare const WEBRTC_OFFER_METHOD = "crosslink.webrtc.offer";
+/** Minimal session description, matching the browser's shape. */
+interface SdpLike {
+    type: "offer" | "answer" | "pranswer" | "rollback";
+    sdp: string;
+}
+interface PeerConnectionLike {
+    createDataChannel(label: string, opts?: {
+        ordered?: boolean;
+    }): DataChannelLike;
+    createOffer(): Promise<SdpLike>;
+    createAnswer(): Promise<SdpLike>;
+    setLocalDescription(d: SdpLike): Promise<void>;
+    setRemoteDescription(d: SdpLike): Promise<void>;
+    close(): void;
+    localDescription?: SdpLike | null;
+    iceGatheringState?: string;
+    onicegatheringstatechange?: (() => void) | null;
+    ondatachannel?: ((ev: {
+        channel: DataChannelLike;
+    }) => void) | null;
+}
+interface DataChannelLike {
+    readyState: string;
+    binaryType: string;
+    send(data: ArrayBuffer | Uint8Array): void;
+    close(): void;
+    onmessage: ((ev: {
+        data: unknown;
+    }) => void) | null;
+    onopen: (() => void) | null;
+    onclose: (() => void) | null;
+    onerror: (() => void) | null;
+}
+interface WebrtcHostOptions {
+    /** e.g. `() => new RTCPeerConnection({ iceServers })`. */
+    createPeer(): PeerConnectionLike;
+    /**
+     * Called with the DataChannel transport once it opens. Feed it to the same
+     * place your LAN and relay transports go - `CrosslinkServer` does this for
+     * you via `enableWebrtcUpgrades`.
+     */
+    onTransport(transport: CrosslinkTransport, deviceId: string): void;
+    /**
+     * Capability required to request an upgrade. Defaults to undefined (any
+     * paired device may). Set one if you want the upgrade itself gated.
+     */
+    capability?: string;
+    /** Method name; override only if it collides with your own namespace. */
+    method?: string;
+    timeoutMs?: number;
+    /** Maximum concurrent half-open peer connections, to bound memory. */
+    maxPending?: number;
+}
+/** The subset of a host server this module needs, so it can be unit-tested. */
+interface ExposeTarget {
+    expose(method: string, handler: (input: unknown, ctx: {
+        deviceId: string;
+    }) => unknown, options?: {
+        capability?: string;
+        timeoutMs?: number;
+    }): unknown;
+}
+/**
+ * Registers the host half of the exchange: an RPC method that accepts an SDP
+ * offer from an authenticated device and returns the answer.
+ *
+ * The resulting DataChannel is handed to `onTransport`, which must run the
+ * normal `HostAcceptor` handshake over it - the WebRTC channel is just a pipe
+ * and carries no authority of its own. A device that reaches the host over
+ * WebRTC still proves its identity exactly as it does over the relay.
+ */
+declare function exposeWebrtcOffer(target: ExposeTarget, options: WebrtcHostOptions): void;
+interface WebrtcClientOptions {
+    createPeer(): PeerConnectionLike;
+    method?: string;
+    timeoutMs?: number;
+    label?: string;
+}
+/** The subset of a client link this module needs. */
+interface CallTarget {
+    call<T>(method: string, input?: unknown, opts?: {
+        timeoutMs?: number;
+    }): Promise<T>;
+}
+/**
+ * Builds a transport candidate that negotiates a DataChannel by exchanging SDP
+ * over `link` - i.e. over the Crosslink session that is already up.
+ *
+ * Pass the result to `ClientLink.upgrade()`, not to the initial candidate
+ * list: it can only work once a session exists to carry the offer.
+ */
+declare function webrtcUpgradeCandidate(link: CallTarget, options: WebrtcClientOptions): TransportCandidate;
+interface UpgradeTarget extends CallTarget {
+    upgrade(candidate: TransportCandidate): Promise<boolean>;
+    readonly transportKind?: string;
+}
+/**
+ * Convenience wrapper: try to move `link` onto a direct WebRTC connection,
+ * returning whether it worked. Never throws - a failed upgrade leaves the
+ * existing (relayed or LAN) session running, which is the whole point.
+ */
+declare function tryUpgradeToWebrtc(link: UpgradeTarget, options: WebrtcClientOptions): Promise<boolean>;
+
+/**
+ * WebRTC direct transport (DataChannel).
+ *
+ * Crosslink frames travel over a single reliable/ordered DataChannel. SDP
+ * exchange happens OUT of band: the embedder supplies an `exchange` callback
+ * (e.g. over an existing Crosslink session, QR, or push notification) - this
+ * module never talks to signaling services itself.
+ *
+ * For the common case - upgrading an existing relayed session to a direct one
+ * by exchanging SDP over that very session - use `./over-crosslink.js`, which
+ * wires the callback for you.
+ */
+
+type RTCPC = {
+    createDataChannel(label: string, opts?: {
+        ordered?: boolean;
+    }): RTCDC & Record<string, unknown>;
+    createOffer(): Promise<RTCSdpLike>;
+    createAnswer(): Promise<RTCSdpLike>;
+    setLocalDescription(d: RTCSdpLike): Promise<void>;
+    setRemoteDescription(d: RTCSdpLike): Promise<void>;
+    close(): void;
+    connectionState?: string;
+    onconnectionstatechange?: (() => void) | null;
+};
+type RTCDC = {
+    readyState: string;
+    binaryType: string;
+    send(data: ArrayBuffer | Uint8Array): void;
+    close(): void;
+    onmessage: ((ev: {
+        data: unknown;
+    }) => void) | null;
+    onopen: (() => void) | null;
+    onclose: (() => void) | null;
+    onerror: (() => void) | null;
+};
+interface RTCSdpLike {
+    type: "offer" | "answer" | "pranswer" | "rollback";
+    sdp: string;
+}
+interface WebRtcDeps {
+    /** e.g. (cfg) => new RTCPeerConnection({ iceServers }) */
+    createPeer(): RTCPC;
+}
+/** Wraps one side of an established DataChannel as a CrosslinkTransport. */
+declare function dataChannelTransport(dc: RTCDC, kind?: ConnectionKind): CrosslinkTransport;
+interface WebrtcOffererOptions {
+    label?: string;
+    timeoutMs?: number;
+}
+/** Candidate for the side that PRODUCES the offer. */
+declare function webrtcOfferCandidate(deps: WebRtcDeps, exchange: (offer: RTCSdpLike) => Promise<RTCSdpLike>, options?: WebrtcOffererOptions): TransportCandidate;
+/** Candidate for the side that ANSWERS. */
+declare function webrtcAnswerCandidate(deps: WebRtcDeps, acceptOffer: () => Promise<RTCSdpLike>, publishAnswer: (answer: RTCSdpLike) => Promise<void>, options?: WebrtcOffererOptions): TransportCandidate;
+
+export { type CallTarget, type ExposeTarget, type SdpLike, type UpgradeTarget, WEBRTC_OFFER_METHOD, type WebRtcDeps, type WebrtcClientOptions, type WebrtcHostOptions, type WebrtcOffererOptions, dataChannelTransport, exposeWebrtcOffer, tryUpgradeToWebrtc, webrtcAnswerCandidate, webrtcOfferCandidate, webrtcUpgradeCandidate };

package/dist/index.js

@@ -0,0 +1,260 @@
+// src/over-crosslink.ts
+var WEBRTC_OFFER_METHOD = "crosslink.webrtc.offer";
+var MAX_SDP_BYTES = 64 * 1024;
+var DEFAULT_TIMEOUT_MS = 15e3;
+var CHANNEL_LABEL = "crosslink";
+function exposeWebrtcOffer(target, options) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const maxPending = options.maxPending ?? 8;
+  let pending = 0;
+  target.expose(
+    options.method ?? WEBRTC_OFFER_METHOD,
+    async (input, ctx) => {
+      const offer = readSdp(input, "offer");
+      if (pending >= maxPending) {
+        throw Object.assign(new Error("too many pending WebRTC upgrades"), {
+          code: "rate_limited"
+        });
+      }
+      pending += 1;
+      const pc = options.createPeer();
+      let settled = false;
+      try {
+        const channelPromise = new Promise((resolve, reject) => {
+          const timer = setTimeout(
+            () => reject(new Error("no datachannel arrived")),
+            timeoutMs
+          );
+          pc.ondatachannel = (ev) => {
+            clearTimeout(timer);
+            resolve(ev.channel);
+          };
+        });
+        await pc.setRemoteDescription(offer);
+        await pc.setLocalDescription(await pc.createAnswer());
+        await gatherSettled(pc, timeoutMs);
+        const answerSdp = pc.localDescription?.sdp;
+        if (!answerSdp) throw new Error("no local description after createAnswer");
+        void channelPromise.then(async (channel) => {
+          await waitOpen(channel, timeoutMs);
+          settled = true;
+          options.onTransport(dataChannelTransport(channel), ctx.deviceId);
+        }).catch(() => {
+          if (!settled) pc.close();
+        });
+        return { type: "answer", sdp: answerSdp };
+      } catch (err) {
+        pc.close();
+        throw err;
+      } finally {
+        pending -= 1;
+      }
+    },
+    {
+      ...options.capability ? { capability: options.capability } : {},
+      timeoutMs: timeoutMs + 1e3
+    }
+  );
+}
+function webrtcUpgradeCandidate(link, options) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  return {
+    kind: "webrtc-direct",
+    connect: async () => {
+      const pc = options.createPeer();
+      try {
+        const channel = pc.createDataChannel(options.label ?? CHANNEL_LABEL, { ordered: true });
+        const opened = waitOpen(channel, timeoutMs);
+        await pc.setLocalDescription(await pc.createOffer());
+        await gatherSettled(pc, timeoutMs);
+        const offerSdp = pc.localDescription?.sdp;
+        if (!offerSdp) throw new Error("no local description after createOffer");
+        const answer = await link.call(
+          options.method ?? WEBRTC_OFFER_METHOD,
+          { type: "offer", sdp: offerSdp },
+          { timeoutMs }
+        );
+        await pc.setRemoteDescription(readSdp(answer, "answer"));
+        await opened;
+        return dataChannelTransport(channel);
+      } catch (err) {
+        pc.close();
+        throw err;
+      }
+    }
+  };
+}
+async function tryUpgradeToWebrtc(link, options) {
+  if (link.transportKind === "webrtc-direct") return true;
+  try {
+    return await link.upgrade(webrtcUpgradeCandidate(link, options));
+  } catch {
+    return false;
+  }
+}
+function readSdp(input, expected) {
+  const value = input;
+  if (!value || typeof value.sdp !== "string" || value.type !== expected) {
+    throw Object.assign(new Error(`expected an SDP ${expected}`), {
+      code: "validation_failed"
+    });
+  }
+  if (value.sdp.length > MAX_SDP_BYTES) {
+    throw Object.assign(new Error("SDP too large"), { code: "payload_too_large" });
+  }
+  return { type: expected, sdp: value.sdp };
+}
+function waitOpen(dc, timeoutMs) {
+  if (dc.readyState === "open") return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error("datachannel open timeout")), timeoutMs);
+    dc.onopen = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    dc.onerror = () => {
+      clearTimeout(timer);
+      reject(new Error("datachannel error"));
+    };
+  });
+}
+function gatherSettled(pc, timeoutMs) {
+  if (pc.iceGatheringState === "complete") return Promise.resolve();
+  return new Promise((resolve) => {
+    const done = () => {
+      pc.onicegatheringstatechange = null;
+      resolve();
+    };
+    pc.onicegatheringstatechange = () => {
+      if (pc.iceGatheringState === "complete") done();
+    };
+    setTimeout(done, Math.min(2e3, timeoutMs));
+  });
+}
+
+// src/index.ts
+function dataChannelTransport(dc, kind = "webrtc-direct") {
+  let dataHandler;
+  let closeHandler;
+  let closed = false;
+  dc.binaryType = "arraybuffer";
+  dc.onmessage = async (ev) => {
+    if (closed) return;
+    const data = ev.data;
+    const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    dataHandler?.(bytes);
+  };
+  const die = () => {
+    if (closed) return;
+    closed = true;
+    closeHandler?.("dc-closed");
+  };
+  dc.onclose = die;
+  dc.onerror = die;
+  return {
+    kind,
+    onData(cb) {
+      dataHandler = cb;
+    },
+    onClose(cb) {
+      closeHandler = cb;
+    },
+    async send(bytes) {
+      if (closed || dc.readyState !== "open") throw new Error("datachannel closed");
+      dc.send(bytes);
+    },
+    close(reason) {
+      if (closed) return;
+      try {
+        dc.close();
+      } catch {
+      }
+      closed = true;
+      closeHandler?.(typeof reason === "string" ? reason : "closed");
+    }
+  };
+}
+function webrtcOfferCandidate(deps, exchange, options = {}) {
+  return {
+    kind: "webrtc-direct",
+    connect: async () => {
+      const pc = deps.createPeer();
+      const channel = pc.createDataChannel(options.label ?? "crosslink", { ordered: true });
+      const opened = waitOpen2(channel, options.timeoutMs ?? 1e4);
+      await pc.setLocalDescription(await pc.createOffer());
+      await gatherSettled2(pc);
+      const answer = await exchange({
+        type: "offer",
+        sdp: pc.localDescription.sdp
+      });
+      await pc.setRemoteDescription(answer);
+      await opened;
+      return dataChannelTransport(channel);
+    }
+  };
+}
+function webrtcAnswerCandidate(deps, acceptOffer, publishAnswer, options = {}) {
+  return {
+    kind: "webrtc-direct",
+    connect: async () => {
+      const pc = deps.createPeer();
+      const offer = await acceptOffer();
+      await pc.setRemoteDescription(offer);
+      const channelPromise = new Promise((resolve, reject) => {
+        const t = setTimeout(() => reject(new Error("no datachannel")), options.timeoutMs ?? 1e4);
+        pc.ondatachannel = (ev) => {
+          clearTimeout(t);
+          resolve(ev.channel);
+        };
+      });
+      await pc.setLocalDescription(await pc.createAnswer());
+      await gatherSettled2(pc);
+      await publishAnswer({
+        type: "answer",
+        sdp: pc.localDescription.sdp
+      });
+      const channel = await channelPromise;
+      await waitOpen2(channel, options.timeoutMs ?? 1e4);
+      return dataChannelTransport(channel);
+    }
+  };
+}
+function waitOpen2(dc, timeoutMs) {
+  if (dc.readyState === "open") return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error("datachannel open timeout")), timeoutMs);
+    dc.onopen = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    const prevError = dc.onerror;
+    dc.onerror = () => {
+      clearTimeout(timer);
+      reject(new Error("datachannel error"));
+      prevError?.();
+    };
+  });
+}
+function gatherSettled2(pc) {
+  const anyPc = pc;
+  if (anyPc.iceGatheringState === "complete") return Promise.resolve();
+  return new Promise((resolve) => {
+    const done = () => resolve();
+    anyPc.onicegatheringstatechange = () => {
+      if (anyPc.iceGatheringState === "complete") {
+        anyPc.onicegatheringstatechange = null;
+        done();
+      }
+    };
+    setTimeout(done, 1500);
+  });
+}
+export {
+  WEBRTC_OFFER_METHOD,
+  dataChannelTransport,
+  exposeWebrtcOffer,
+  tryUpgradeToWebrtc,
+  webrtcAnswerCandidate,
+  webrtcOfferCandidate,
+  webrtcUpgradeCandidate
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@crosslink/webrtc-adapter",
+  "version": "0.1.0",
+  "description": "Crosslink WebRTC data-channel transport adapter (interface + roadmap)",
+  "license": "Apache-2.0",
+  "repository": { "type": "git", "url": "git+https://github.com/jacobpowaza/crosslink.git", "directory": "adapters/webrtc" },
+  "homepage": "https://crosslink.mintlify.site",
+  "bugs": { "url": "https://github.com/jacobpowaza/crosslink/issues" },
+  "publishConfig": { "access": "public" },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@crosslink/core": "^0.1.0",
+    "@crosslink/protocol": "^0.1.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.6",
+    "typescript": "^5.6.3"
+  }
+}