@afterrealism/dendri-client 2.3.7 → 2.5.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.5.0";
   var API = class _API {
     constructor(_options) {
       this._options = _options;
@@ -3549,6 +3549,7 @@ var dendri = (() => {
       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, {
@@ -3573,15 +3574,16 @@ 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 = 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));
@@ -3706,6 +3708,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 +3731,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 +3750,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 +4091,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 +4099,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 +4651,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 +4951,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 +5001,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 +5042,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
@@ -5149,17 +5309,29 @@ var dendri = (() => {
     _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;
@@ -5187,6 +5359,7 @@ var dendri = (() => {
             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
@@ -5225,6 +5398,7 @@ var dendri = (() => {
         id: this._id,
         token: this._token
       });
+      this._applyAuthParams(params);
       try {
         await fetch(`${this._baseUrl}http/send?${params}`, {
           method: "POST",
@@ -5289,13 +5463,16 @@ var dendri = (() => {
   };
 
   // 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;
@@ -5331,7 +5508,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}`);
@@ -5601,18 +5778,28 @@ var dendri = (() => {
     _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;
@@ -5630,10 +5817,9 @@ var dendri = (() => {
       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 {
@@ -5707,6 +5893,7 @@ var dendri = (() => {
         id: this._id,
         token: this._token
       });
+      this._applyAuthParams(params);
       try {
         await fetch(`${this._baseUrl}http/send?${params}`, {
           method: "POST",
@@ -5779,6 +5966,28 @@ var dendri = (() => {
   };
 
   // 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 = {
@@ -5869,6 +6078,9 @@ var dendri = (() => {
       } 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
@@ -5922,7 +6134,7 @@ var dendri = (() => {
           return;
         }
       }
-      if (!!userId && !util.validateId(userId)) {
+      if (userId && !util.validateId(userId)) {
         this._delayedAbort("invalid-id" /* InvalidID */, `ID "${userId}" is invalid`);
         return;
       }
@@ -5987,7 +6199,8 @@ var dendri = (() => {
         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,
@@ -5995,7 +6208,8 @@ var dendri = (() => {
         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,
@@ -6003,7 +6217,8 @@ var dendri = (() => {
         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);