@afterrealism/dendri-client 2.3.7 → 2.4.0

package/dist/dendri.cjs

@@ -3533,7 +3533,7 @@ var Logger = class {
 var logger_default = new Logger();
 
 // src/api.ts
-var version = "2.3.7";
+var version = "2.4.0";
 var API = class _API {
   constructor(_options) {
     this._options = _options;
@@ -3570,11 +3570,11 @@ 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 = `${protocol}://${host}:${port}${path}${key}/turn-credentials`;
     try {
       const controller = new AbortController();
       const timeoutId = setTimeout(() => controller.abort(), _API.FETCH_TIMEOUT);
@@ -3683,6 +3683,9 @@ var ServerMessageType = /* @__PURE__ */ ((ServerMessageType2) => {
   ServerMessageType2["HostMigrate"] = "HOST-MIGRATE";
   ServerMessageType2["PresenceUpdate"] = "PRESENCE-UPDATE";
   ServerMessageType2["KeyExchange"] = "KEY-EXCHANGE";
+  ServerMessageType2["ConnectRequest"] = "CONNECT-REQUEST";
+  ServerMessageType2["DcutrConnect"] = "DCUTR-CONNECT";
+  ServerMessageType2["DcutrSync"] = "DCUTR-SYNC";
   return ServerMessageType2;
 })(ServerMessageType || {});
 var TransportMode = /* @__PURE__ */ ((TransportMode2) => {
@@ -3708,6 +3711,11 @@ var ConnectionQuality = /* @__PURE__ */ ((ConnectionQuality2) => {
   ConnectionQuality2["Unknown"] = "unknown";
   return ConnectionQuality2;
 })(ConnectionQuality || {});
+var TopicClass = /* @__PURE__ */ ((TopicClass2) => {
+  TopicClass2["Persistent"] = "persistent";
+  TopicClass2["Ephemeral"] = "ephemeral";
+  return TopicClass2;
+})(TopicClass || {});
 
 // src/dendriError.ts
 var import_eventemitter3 = __toESM(require_eventemitter3(), 1);
@@ -3796,6 +3804,7 @@ var Negotiator = class {
   }
   connection;
   _pendingCandidates = [];
+  _iceCandidateFilter = null;
   /** Returns a PeerConnection object set up correctly (for data, media). */
   startConnection(options) {
     const peerConnection = this._startPeerConnection();
@@ -3818,6 +3827,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;
   }
@@ -3830,6 +3846,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 */,
@@ -4168,6 +4187,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 = () => {
@@ -4175,6 +4195,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.
    */
@@ -4709,7 +4747,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) {
@@ -4999,10 +5047,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;
@@ -5043,6 +5097,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);
     }
@@ -5083,6 +5138,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
@@ -5379,7 +5545,7 @@ var PollingTransport = class _PollingTransport extends SignalingTransport {
 };
 
 // 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();
@@ -5421,7 +5587,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}`);
@@ -6012,7 +6178,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;
     }
@@ -8791,7 +8957,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,
@@ -8825,7 +8997,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,
@@ -9016,8 +9194,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 } });
@@ -9339,6 +9517,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) {
@@ -9403,7 +9589,7 @@ var DendriServerAPI = class {
   }
   /** Get TURN credentials */
   async getTurnCredentials() {
-    const res = await fetch(`${this._baseUrl}/turn`);
+    const res = await fetch(`${this._baseUrl}/${this._key}/turn-credentials`);
     if (!res.ok) throw new Error(`TURN credentials failed: ${res.status}`);
     return res.json();
   }
@@ -9712,6 +9898,7 @@ exports.ServerMessageType = ServerMessageType;
 exports.SignalingTransport = SignalingTransport;
 exports.SocketEventType = SocketEventType;
 exports.StreamConnection = StreamConnection;
+exports.TopicClass = TopicClass;
 exports.TopicManager = TopicManager;
 exports.TransportMode = TransportMode;
 exports.createDendriStore = createDendriStore;