@afterrealism/dendri-client 2.3.7 → 2.5.0

package/dist/store.cjs

@@ -3531,7 +3531,7 @@ var Util = class extends BinaryPackChunker {
 var util = new Util();
 
 // src/api.ts
-var version = "2.3.7";
+var version = "2.5.0";
 var API = class _API {
   constructor(_options) {
     this._options = _options;
@@ -3544,6 +3544,7 @@ var API = class _API {
     const url = new URL(`${protocol}://${host}:${port}${path}${key}/${method}`);
     url.searchParams.set("ts", `${Date.now()}${Math.random()}`);
     url.searchParams.set("version", version);
+    if (this._options.apiKey) url.searchParams.set("api_key", this._options.apiKey);
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), _API.FETCH_TIMEOUT);
     return fetch(url.href, {
@@ -3568,15 +3569,16 @@ var API = class _API {
       throw new Error(`Could not get an ID from the server.${pathError}`);
     }
   }
-  /** Fetch TURN credentials from the signaling server's GET /turn endpoint. */
+  /** Fetch TURN credentials from the signaling server's turn-credentials endpoint. */
   async getTurnCredentials() {
     const protocol = this._options.secure ? "https" : "http";
-    const { host, port } = this._options;
-    const url = `${protocol}://${host}:${port}/turn`;
+    const { host, port, path, key } = this._options;
+    const url = new URL(`${protocol}://${host}:${port}${path}${key}/turn-credentials`);
+    if (this._options.apiKey) url.searchParams.set("api_key", this._options.apiKey);
     try {
       const controller = new AbortController();
       const timeoutId = setTimeout(() => controller.abort(), _API.FETCH_TIMEOUT);
-      const response = await fetch(url, {
+      const response = await fetch(url.href, {
         referrerPolicy: this._options.referrerPolicy,
         signal: controller.signal
       }).finally(() => clearTimeout(timeoutId));
@@ -3701,6 +3703,7 @@ var Negotiator = class {
   }
   connection;
   _pendingCandidates = [];
+  _iceCandidateFilter = null;
   /** Returns a PeerConnection object set up correctly (for data, media). */
   startConnection(options) {
     const peerConnection = this._startPeerConnection();
@@ -3723,6 +3726,13 @@ var Negotiator = class {
   _startPeerConnection() {
     logger_default.log("Creating RTCPeerConnection.");
     const peerConnection = new RTCPeerConnection(this.connection.provider?.options.config);
+    if (this.connection.provider?.options.ipPolicy === "public") {
+      const isPublicCandidate = (c) => {
+        const sdp2 = c.candidate ?? "";
+        return !sdp2.includes("typ host");
+      };
+      this._iceCandidateFilter = isPublicCandidate;
+    }
     this._setupListeners(peerConnection);
     return peerConnection;
   }
@@ -3735,6 +3745,9 @@ var Negotiator = class {
     logger_default.log("Listening for ICE candidates.");
     peerConnection.onicecandidate = (evt) => {
       if (!evt.candidate?.candidate) return;
+      if (this._iceCandidateFilter && !this._iceCandidateFilter(evt.candidate)) {
+        return;
+      }
       logger_default.log(`Received ICE candidates for ${peerId}:`, evt.candidate);
       provider.socket.send({
         type: "CANDIDATE" /* Candidate */,
@@ -4073,6 +4086,7 @@ var DataConnection = class _DataConnection extends BaseConnection {
     this.dataChannel.onopen = () => {
       logger_default.log(`DC#${this.connectionId} dc connection success`);
       this._open = true;
+      this._applyAdaptiveBuffer(dc);
       this.emit("open");
     };
     this.dataChannel.onclose = () => {
@@ -4080,6 +4094,24 @@ var DataConnection = class _DataConnection extends BaseConnection {
       this.close();
     };
   }
+  _applyAdaptiveBuffer(dc) {
+    const pc = this.peerConnection;
+    if (!pc || typeof pc.getStats !== "function") return;
+    pc.getStats().then((stats) => {
+      let rtt = null;
+      stats.forEach((report) => {
+        if (report.type === "candidate-pair" && report.state === "succeeded" && report.currentRoundTripTime) {
+          rtt = report.currentRoundTripTime * 1e3;
+        }
+      });
+      if (rtt !== null) {
+        const bdp = 12.5 * 1024 * 1024 * (rtt / 1e3);
+        const optimal = Math.max(1 * 1024 * 1024, Math.min(32 * 1024 * 1024, Math.ceil(bdp)));
+        dc.bufferedAmountLowThreshold = optimal;
+      }
+    }).catch(() => {
+    });
+  }
   /**
    * Exposed functionality for users.
    */
@@ -4614,7 +4646,17 @@ var HybridConnection = class extends import_eventemitter32.EventEmitter {
     if (this._closed) {
       return;
     }
-    this._attemptWebRTC();
+    logger_default.log(
+      `HybridConnection: start peer=${this.peer} iceTimeout=${this._options.iceTimeout ?? 1e4}ms encryptRelay=${this._encryptRelay}`
+    );
+    if (typeof this._provider?.on !== "function") {
+      this._attemptWebRTC();
+      return;
+    }
+    this._tryConnectionReversal().then((direct) => {
+      if (direct) return;
+      this._attemptWebRTC();
+    });
   }
   /** Send data through the best available transport, optionally tagged with a topic. */
   send(data, options) {
@@ -4904,10 +4946,16 @@ var HybridConnection = class extends import_eventemitter32.EventEmitter {
     this._dataConnection = dc;
     this._iceTimer = setTimeout(() => {
       if (this._mode !== "webrtc" /* WebRTC */) {
+        logger_default.warn(
+          `HybridConnection: ICE timeout after ${iceTimeout}ms for ${this.peer}, falling back to relay`
+        );
         this._fallbackToRelay();
       }
     }, iceTimeout);
     this._dataConnection.on("open", () => {
+      logger_default.log(
+        `HybridConnection: WebRTC opened to ${this.peer} (attempt ${this._upgradeAttempts + 1})`
+      );
       this._clearIceTimer();
       this._clearUpgradeTimer();
       this._upgradeAttempts = 0;
@@ -4948,6 +4996,7 @@ var HybridConnection = class extends import_eventemitter32.EventEmitter {
   /** Update the transport mode and emit if changed. */
   _setMode(mode) {
     if (this._mode !== mode) {
+      logger_default.log(`HybridConnection: transport ${this._mode} -> ${mode} for ${this.peer}`);
       this._mode = mode;
       this.emit("transportChanged", mode);
     }
@@ -4988,6 +5037,117 @@ var HybridConnection = class extends import_eventemitter32.EventEmitter {
       this._attemptWebRTC();
     }, interval);
   }
+  async _tryConnectionReversal() {
+    if (typeof this._provider?.on !== "function") return false;
+    try {
+      const resp = await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error("timeout")), 3e3);
+        const handler = (data) => {
+          clearTimeout(timer);
+          this._provider.off("CONNECT-REQUEST" /* ConnectRequest */, handler);
+          resolve(data);
+        };
+        this._provider.on("CONNECT-REQUEST" /* ConnectRequest */, handler);
+        this._provider.socket.send({
+          type: "CONNECT-REQUEST" /* ConnectRequest */,
+          payload: { peer: this.peer }
+        });
+      });
+      const addr = resp?.address;
+      if (!addr) return false;
+      const pc = new RTCPeerConnection(this._provider.options.config);
+      const dc = pc.createDataChannel("probe", { id: 0 });
+      await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          pc.close();
+          reject(new Error("direct-dial-timeout"));
+        }, 2500);
+        dc.onopen = () => {
+          clearTimeout(timer);
+          resolve();
+        };
+        dc.onerror = () => {
+          clearTimeout(timer);
+          pc.close();
+          reject(new Error("dc-error"));
+        };
+      });
+      this._dataConnection = void 0;
+      this._setMode("webrtc" /* WebRTC */);
+      pc.close();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async _gatherSrflxCandidates() {
+    const pc = new RTCPeerConnection({ iceServers: this._provider.options.config?.iceServers });
+    pc.createDataChannel("probe");
+    const offer = await pc.createOffer();
+    await pc.setLocalDescription(offer);
+    const candidates = [];
+    await new Promise((resolve) => {
+      const timer = setTimeout(resolve, 2e3);
+      pc.onicecandidate = (evt) => {
+        if (!evt.candidate) {
+          clearTimeout(timer);
+          resolve();
+          return;
+        }
+        if (!evt.candidate.candidate.includes("typ host")) {
+          candidates.push(evt.candidate.candidate);
+        }
+      };
+    });
+    pc.close();
+    return candidates;
+  }
+  async _dcutrHolePunch() {
+    try {
+      const localAddrs = await this._gatherSrflxCandidates();
+      const t0 = performance.now();
+      const peerAddrs = await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error("dcutr-timeout")), 8e3);
+        const handler = (data) => {
+          clearTimeout(timer);
+          this._provider.off("DCUTR-CONNECT" /* DcutrConnect */, handler);
+          resolve(data?.addresses ?? []);
+        };
+        this._provider.on("DCUTR-CONNECT" /* DcutrConnect */, handler);
+        this._provider.socket.send({
+          type: "DCUTR-CONNECT" /* DcutrConnect */,
+          payload: { addresses: localAddrs }
+        });
+      });
+      const relayRtt = performance.now() - t0;
+      this._provider.socket.send({ type: "DCUTR-SYNC" /* DcutrSync */, payload: {} });
+      await new Promise((r) => setTimeout(r, relayRtt / 2));
+      for (let i = 0; i < Math.min(peerAddrs.length, 4); i++) {
+        try {
+          const pc = new RTCPeerConnection(this._provider.options.config);
+          await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+              pc.close();
+              reject(new Error("dc-dial-timeout"));
+            }, 5e3);
+            const dc = pc.createDataChannel("dcutr");
+            dc.onopen = () => {
+              clearTimeout(timer);
+              resolve();
+            };
+          });
+          this._dataConnection = void 0;
+          this._setMode("webrtc" /* WebRTC */);
+          pc.close();
+          return true;
+        } catch {
+        }
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
 };
 
 // src/mediaconnection.ts
@@ -5144,17 +5304,29 @@ var PollingTransport = class _PollingTransport extends SignalingTransport {
   _heartbeatTimer;
   _lastSeq = 0;
   _baseUrl;
+  _key;
+  _jwt;
+  _apiKey;
   _pingInterval;
   _abortController;
   /** Backoff schedule base delays in milliseconds. */
   static BACKOFF_SCHEDULE = [0, 1e3, 2e3, 4e3, 8e3, 16e3, 3e4];
   /** Random jitter range in milliseconds (applied as +/-). */
   static BACKOFF_JITTER = 500;
-  constructor(secure, host, port, path, _key, pingInterval = 5e3, _jwt) {
+  constructor(secure, host, port, path, key, pingInterval = 5e3, jwt, apiKey) {
     super();
     const protocol = secure ? "https://" : "http://";
     this._baseUrl = `${protocol + host}:${port}${path}`;
     this._pingInterval = pingInterval;
+    this._key = key;
+    this._jwt = jwt;
+    this._apiKey = apiKey;
+  }
+  /** Append the shared auth params (key, jwt, api_key) so every HTTP call authenticates like the WS transport. */
+  _applyAuthParams(params) {
+    params.set("key", this._key);
+    if (this._jwt) params.set("jwt", this._jwt);
+    if (this._apiKey) params.set("api_key", this._apiKey);
   }
   get reconnectAttempt() {
     return this._reconnectAttempt;
@@ -5182,6 +5354,7 @@ var PollingTransport = class _PollingTransport extends SignalingTransport {
           id: this._id,
           token: this._token
         });
+        this._applyAuthParams(params);
         if (this._lastSeq > 0) params.set("last_seq", String(this._lastSeq));
         const response = await fetch(`${this._baseUrl}http/poll?${params}`, {
           signal: this._abortController.signal
@@ -5220,6 +5393,7 @@ var PollingTransport = class _PollingTransport extends SignalingTransport {
       id: this._id,
       token: this._token
     });
+    this._applyAuthParams(params);
     try {
       await fetch(`${this._baseUrl}http/send?${params}`, {
         method: "POST",
@@ -5284,13 +5458,16 @@ var PollingTransport = class _PollingTransport extends SignalingTransport {
 };
 
 // src/socket.ts
-var version2 = "2.3.7";
+var version2 = "2.5.0";
 var Socket = class _Socket extends SignalingTransport {
-  constructor(secure, host, port, path, key, pingInterval = 5e3, jwt) {
+  constructor(secure, host, port, path, key, pingInterval = 5e3, jwt, apiKey) {
     super();
     this.pingInterval = pingInterval;
     const wsProtocol = secure ? "wss://" : "ws://";
     this._baseUrl = `${wsProtocol + host}:${port}${path}dendri?key=${key}`;
+    if (apiKey) {
+      this._baseUrl += `&api_key=${encodeURIComponent(apiKey)}`;
+    }
     this._jwt = jwt;
   }
   pingInterval;
@@ -5326,7 +5503,7 @@ var Socket = class _Socket extends SignalingTransport {
     if (this._jwt) {
       wsUrl += `&jwt=${encodeURIComponent(this._jwt)}`;
     }
-    if (!!this._socket || !this._disconnected) {
+    if (this._socket || !this._disconnected) {
       return;
     }
     this._socket = new WebSocket(`${wsUrl}&version=${version2}`);
@@ -5596,18 +5773,28 @@ var SSETransport = class _SSETransport extends SignalingTransport {
   _heartbeatTimer;
   _lastSeq = 0;
   _baseUrl;
+  _key;
   _jwt;
+  _apiKey;
   _pingInterval;
   /** Backoff schedule base delays in milliseconds. */
   static BACKOFF_SCHEDULE = [0, 1e3, 2e3, 4e3, 8e3, 16e3, 3e4];
   /** Random jitter range in milliseconds (applied as +/-). */
   static BACKOFF_JITTER = 500;
-  constructor(secure, host, port, path, _key, pingInterval = 5e3, jwt) {
+  constructor(secure, host, port, path, key, pingInterval = 5e3, jwt, apiKey) {
     super();
     const protocol = secure ? "https://" : "http://";
     this._baseUrl = `${protocol + host}:${port}${path}`;
     this._pingInterval = pingInterval;
+    this._key = key;
     this._jwt = jwt;
+    this._apiKey = apiKey;
+  }
+  /** Append the shared auth params (key, jwt, api_key) so every HTTP call authenticates like the WS transport. */
+  _applyAuthParams(params) {
+    params.set("key", this._key);
+    if (this._jwt) params.set("jwt", this._jwt);
+    if (this._apiKey) params.set("api_key", this._apiKey);
   }
   get reconnectAttempt() {
     return this._reconnectAttempt;
@@ -5625,10 +5812,9 @@ var SSETransport = class _SSETransport extends SignalingTransport {
     if (this._disconnected) return;
     const params = new URLSearchParams({
       id: this._id,
-      token: this._token,
-      key: "dendri"
+      token: this._token
     });
-    if (this._jwt) params.set("jwt", this._jwt);
+    this._applyAuthParams(params);
     if (this._lastSeq > 0) params.set("last_seq", String(this._lastSeq));
     const url = `${this._baseUrl}http/sse?${params}`;
     try {
@@ -5702,6 +5888,7 @@ var SSETransport = class _SSETransport extends SignalingTransport {
       id: this._id,
       token: this._token
     });
+    this._applyAuthParams(params);
     try {
       await fetch(`${this._baseUrl}http/send?${params}`, {
         method: "POST",
@@ -5774,6 +5961,28 @@ var SSETransport = class _SSETransport extends SignalingTransport {
 };
 
 // src/dendri.ts
+function parseServerUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error(
+      `Invalid Dendri "url" option: "${url}". Expected a full URL like "wss://signal.example.com".`
+    );
+  }
+  const secure = parsed.protocol === "wss:" || parsed.protocol === "https:";
+  if (!secure && parsed.protocol !== "ws:" && parsed.protocol !== "http:") {
+    throw new Error(
+      `Invalid Dendri "url" protocol: "${parsed.protocol}". Use wss://, ws://, https://, or http://.`
+    );
+  }
+  return {
+    host: parsed.hostname,
+    port: parsed.port ? Number(parsed.port) : secure ? 443 : 80,
+    secure,
+    path: parsed.pathname || "/"
+  };
+}
 var Dendri = class _Dendri extends EventEmitterWithError {
   static DEFAULT_KEY = "dendri";
   _serializers = {
@@ -5864,6 +6073,9 @@ var Dendri = class _Dendri extends EventEmitterWithError {
     } else if (id) {
       userId = id.toString();
     }
+    if (providedOptions?.url) {
+      providedOptions = { ...parseServerUrl(providedOptions.url), ...providedOptions };
+    }
     const normalizedOptions = {
       debug: 0,
       // 1: Errors, 2: Warnings, 3: All logs
@@ -5917,7 +6129,7 @@ var Dendri = class _Dendri extends EventEmitterWithError {
         return;
       }
     }
-    if (!!userId && !util.validateId(userId)) {
+    if (userId && !util.validateId(userId)) {
       this._delayedAbort("invalid-id" /* InvalidID */, `ID "${userId}" is invalid`);
       return;
     }
@@ -5982,7 +6194,8 @@ var Dendri = class _Dendri extends EventEmitterWithError {
       this._options.path,
       this._options.key,
       this._options.pingInterval,
-      this._options.jwt
+      this._options.jwt,
+      this._options.apiKey
     ) : transport === "polling" ? new PollingTransport(
       this._options.secure ?? false,
       this._options.host,
@@ -5990,7 +6203,8 @@ var Dendri = class _Dendri extends EventEmitterWithError {
       this._options.path,
       this._options.key,
       this._options.pingInterval,
-      this._options.jwt
+      this._options.jwt,
+      this._options.apiKey
     ) : new Socket(
       this._options.secure ?? false,
       this._options.host,
@@ -5998,7 +6212,8 @@ var Dendri = class _Dendri extends EventEmitterWithError {
       this._options.path,
       this._options.key,
       this._options.pingInterval,
-      this._options.jwt
+      this._options.jwt,
+      this._options.apiKey
     );
     socket.on("message" /* Message */, (data) => {
       this._handleMessage(data);
@@ -6830,7 +7045,13 @@ var Room = class extends import_eventemitter35.EventEmitter {
         sentViaWebRTC = true;
       }
     }
-    if (!sentViaWebRTC && this._peer?.socket) {
+    if (this._dendriOptions?.enableRelay && this._peer?.socket) {
+      this._peer.socket.send({
+        type: "DATA" /* Data */,
+        room: this._roomId,
+        payload: wire
+      });
+    } else if (!sentViaWebRTC && this._peer?.socket) {
       this._peer.socket.send({
         type: "DATA" /* Data */,
         room: this._roomId,
@@ -6864,7 +7085,13 @@ var Room = class extends import_eventemitter35.EventEmitter {
         sentViaWebRTC = true;
       }
     }
-    if (!sentViaWebRTC && this._peer?.socket) {
+    if (this._dendriOptions?.enableRelay && this._peer?.socket) {
+      this._peer.socket.send({
+        type: "DATA" /* Data */,
+        room: this._roomId,
+        payload: wire
+      });
+    } else if (!sentViaWebRTC && this._peer?.socket) {
       this._peer.socket.send({
         type: "DATA" /* Data */,
         room: this._roomId,
@@ -7055,8 +7282,8 @@ var Room = class extends import_eventemitter35.EventEmitter {
       const remotePeerId = conn.peer;
       this._connections.set(remotePeerId, conn);
       this._knownPeers.add(remotePeerId);
+      this.emit("peerJoined", remotePeerId);
       conn.on("open", () => {
-        this.emit("peerJoined", remotePeerId);
         for (const [peerId, c] of this._connections) {
           if (peerId !== remotePeerId && c.open) {
             c.send({ __room: { type: "peer-joined", peerId: remotePeerId } });
@@ -7378,6 +7605,14 @@ var Room = class extends import_eventemitter35.EventEmitter {
     const conn = this._connections.get(peerId);
     if (conn?.open) {
       conn.send(data);
+      if (this._dendriOptions?.enableRelay && this._peer?.socket) {
+        this._peer.socket.send({
+          type: "DATA" /* Data */,
+          dst: peerId,
+          room: this._roomId,
+          payload: data
+        });
+      }
       return;
     }
     if (!this._isHost && this._hostId) {