@afterrealism/dendri-client 2.3.7 → 2.4.0

package/dist/dendri.browser.global.js

@@ -3536,7 +3536,7 @@ var dendri = (() => {
   var util = new Util();
 
   // src/api.ts
-  var version = "2.3.7";
+  var version = "2.4.0";
   var API = class _API {
     constructor(_options) {
       this._options = _options;
@@ -3573,11 +3573,11 @@ var dendri = (() => {
         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 = `${protocol}://${host}:${port}${path}${key}/turn-credentials`;
       try {
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), _API.FETCH_TIMEOUT);
@@ -3706,6 +3706,7 @@ var dendri = (() => {
     }
     connection;
     _pendingCandidates = [];
+    _iceCandidateFilter = null;
     /** Returns a PeerConnection object set up correctly (for data, media). */
     startConnection(options) {
       const peerConnection = this._startPeerConnection();
@@ -3728,6 +3729,13 @@ var dendri = (() => {
     _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;
     }
@@ -3740,6 +3748,9 @@ var dendri = (() => {
       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 */,
@@ -4078,6 +4089,7 @@ var dendri = (() => {
       this.dataChannel.onopen = () => {
         logger_default.log(`DC#${this.connectionId} dc connection success`);
         this._open = true;
+        this._applyAdaptiveBuffer(dc);
         this.emit("open");
       };
       this.dataChannel.onclose = () => {
@@ -4085,6 +4097,24 @@ var dendri = (() => {
         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.
      */
@@ -4619,7 +4649,17 @@ var dendri = (() => {
       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) {
@@ -4909,10 +4949,16 @@ var dendri = (() => {
       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;
@@ -4953,6 +4999,7 @@ var dendri = (() => {
     /** 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);
       }
@@ -4993,6 +5040,117 @@ var dendri = (() => {
         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
@@ -5289,7 +5447,7 @@ var dendri = (() => {
   };
 
   // src/socket.ts
-  var version2 = "2.3.7";
+  var version2 = "2.4.0";
   var Socket = class _Socket extends SignalingTransport {
     constructor(secure, host, port, path, key, pingInterval = 5e3, jwt) {
       super();
@@ -5331,7 +5489,7 @@ var dendri = (() => {
       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}`);
@@ -5922,7 +6080,7 @@ var dendri = (() => {
           return;
         }
       }
-      if (!!userId && !util.validateId(userId)) {
+      if (userId && !util.validateId(userId)) {
         this._delayedAbort("invalid-id" /* InvalidID */, `ID "${userId}" is invalid`);
         return;
       }