livekit-client 2.13.4 → 2.13.5

package/dist/livekit-client.esm.mjs

@@ -2966,7 +2966,17 @@ function makeUtilCommon() {
         }
         switch (m.kind) {
           case "message":
-            return m.T.equals(va, vb);
+            let a = va;
+            let b = vb;
+            if (m.T.fieldWrapper) {
+              if (a !== undefined && !isMessage(a)) {
+                a = m.T.fieldWrapper.wrapField(a);
+              }
+              if (b !== undefined && !isMessage(b)) {
+                b = m.T.fieldWrapper.wrapField(b);
+              }
+            }
+            return m.T.equals(a, b);
           case "enum":
             return scalarEquals(ScalarType.INT32, va, vb);
           case "scalar":
@@ -3887,6 +3897,9 @@ const DisconnectReason = /* @__PURE__ */proto3.makeEnum("livekit.DisconnectReaso
 }, {
   no: 14,
   name: "CONNECTION_TIMEOUT"
+}, {
+  no: 15,
+  name: "MEDIA_FAILURE"
 }]);
 const ReconnectReason = /* @__PURE__ */proto3.makeEnum("livekit.ReconnectReason", [{
   no: 0,
@@ -4491,6 +4504,18 @@ const DataPacket = /* @__PURE__ */proto3.makeMessageType("livekit.DataPacket", (
   kind: "message",
   T: DataStream_Trailer,
   oneof: "value"
+}, {
+  no: 16,
+  name: "sequence",
+  kind: "scalar",
+  T: 13
+  /* ScalarType.UINT32 */
+}, {
+  no: 17,
+  name: "participant_sid",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
 }]);
 const DataPacket_Kind = /* @__PURE__ */proto3.makeEnum("livekit.DataPacket.Kind", [{
   no: 0,
@@ -5676,6 +5701,17 @@ const ReconnectResponse = /* @__PURE__ */proto3.makeMessageType("livekit.Reconne
   name: "client_configuration",
   kind: "message",
   T: ClientConfiguration
+}, {
+  no: 3,
+  name: "server_info",
+  kind: "message",
+  T: ServerInfo
+}, {
+  no: 4,
+  name: "last_message_seq",
+  kind: "scalar",
+  T: 13
+  /* ScalarType.UINT32 */
 }]);
 const TrackPublishedResponse = /* @__PURE__ */proto3.makeMessageType("livekit.TrackPublishedResponse", () => [{
   no: 1,
@@ -6122,6 +6158,25 @@ const SyncState = /* @__PURE__ */proto3.makeMessageType("livekit.SyncState", ()
   kind: "scalar",
   T: 9,
   repeated: true
+}, {
+  no: 7,
+  name: "datachannel_receive_states",
+  kind: "message",
+  T: DataChannelReceiveState,
+  repeated: true
+}]);
+const DataChannelReceiveState = /* @__PURE__ */proto3.makeMessageType("livekit.DataChannelReceiveState", () => [{
+  no: 1,
+  name: "publisher_sid",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 2,
+  name: "last_seq",
+  kind: "scalar",
+  T: 13
+  /* ScalarType.UINT32 */
 }]);
 const DataChannelInfo = /* @__PURE__ */proto3.makeMessageType("livekit.DataChannelInfo", () => [{
   no: 1,
@@ -11270,7 +11325,7 @@ function getOSVersion(ua) {
   return ua.includes('mac os') ? getMatch(/\(.+?(\d+_\d+(:?_\d+)?)/, ua, 1).replace(/_/g, '.') : undefined;
 }
 
-var version$1 = "2.13.4";
+var version$1 = "2.13.5";
 
 const version = version$1;
 const protocolVersion = 16;
@@ -13189,7 +13244,10 @@ class SignalClient {
         sid,
         reconnectReason: reason
       }));
-      return res;
+      if (res instanceof ReconnectResponse) {
+        return res;
+      }
+      return;
     });
   }
   connect(url, token, opts, abortSignal) {
@@ -13787,6 +13845,135 @@ function createConnectionParams(token, info, opts) {
   return params;
 }
 
+class DataPacketBuffer {
+  constructor() {
+    this.buffer = [];
+    this._totalSize = 0;
+  }
+  push(item) {
+    this.buffer.push(item);
+    this._totalSize += item.data.byteLength;
+  }
+  pop() {
+    const item = this.buffer.shift();
+    if (item) {
+      this._totalSize -= item.data.byteLength;
+    }
+    return item;
+  }
+  getAll() {
+    return this.buffer.slice();
+  }
+  popToSequence(sequence) {
+    while (this.buffer.length > 0) {
+      const first = this.buffer[0];
+      if (first.sequence <= sequence) {
+        this.pop();
+      } else {
+        break;
+      }
+    }
+  }
+  alignBufferedAmount(bufferedAmount) {
+    while (this.buffer.length > 0) {
+      const first = this.buffer[0];
+      if (this._totalSize - first.data.byteLength <= bufferedAmount) {
+        break;
+      }
+      this.pop();
+    }
+  }
+  get length() {
+    return this.buffer.length;
+  }
+}
+
+class TTLMap {
+  /**
+   * @param ttl ttl of the key (ms)
+   */
+  constructor(ttl) {
+    this._map = new Map();
+    this._lastCleanup = 0;
+    this.ttl = ttl;
+  }
+  set(key, value) {
+    const now = Date.now();
+    if (now - this._lastCleanup > this.ttl / 2) {
+      this.cleanup();
+    }
+    const expiresAt = now + this.ttl;
+    this._map.set(key, {
+      value,
+      expiresAt
+    });
+    return this;
+  }
+  get(key) {
+    const entry = this._map.get(key);
+    if (!entry) return undefined;
+    if (entry.expiresAt < Date.now()) {
+      this._map.delete(key);
+      return undefined;
+    }
+    return entry.value;
+  }
+  has(key) {
+    const entry = this._map.get(key);
+    if (!entry) return false;
+    if (entry.expiresAt < Date.now()) {
+      this._map.delete(key);
+      return false;
+    }
+    return true;
+  }
+  delete(key) {
+    return this._map.delete(key);
+  }
+  clear() {
+    this._map.clear();
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of this._map.entries()) {
+      if (entry.expiresAt < now) {
+        this._map.delete(key);
+      }
+    }
+    this._lastCleanup = now;
+  }
+  get size() {
+    this.cleanup();
+    return this._map.size;
+  }
+  forEach(callback) {
+    this.cleanup();
+    for (const [key, entry] of this._map.entries()) {
+      if (entry.expiresAt >= Date.now()) {
+        callback(entry.value, key, this.asValueMap());
+      }
+    }
+  }
+  map(callback) {
+    this.cleanup();
+    const result = [];
+    const valueMap = this.asValueMap();
+    for (const [key, value] of valueMap.entries()) {
+      result.push(callback(value, key, valueMap));
+    }
+    return result;
+  }
+  asValueMap() {
+    const result = new Map();
+    for (const [key, entry] of this._map.entries()) {
+      if (entry.expiresAt >= Date.now()) {
+        result.set(key, entry.value);
+      }
+    }
+    return result;
+  }
+}
+
 var lib = {};
 
 var parser = {};
@@ -17366,6 +17553,7 @@ const lossyDataChannel = '_lossy';
 const reliableDataChannel = '_reliable';
 const minReconnectWait = 2 * 1000;
 const leaveReconnect = 'leave-reconnect';
+const reliabeReceiveStateTTL = 30000;
 var PCState;
 (function (PCState) {
   PCState[PCState["New"] = 0] = "New";
@@ -17402,6 +17590,9 @@ class RTCEngine extends eventsExports.EventEmitter {
     this.maxJoinAttempts = 1;
     this.shouldFailNext = false;
     this.log = livekitLogger;
+    this.reliableDataSequence = 1;
+    this.reliableMessageBuffer = new DataPacketBuffer();
+    this.reliableReceivedState = new TTLMap(reliabeReceiveStateTTL);
     this.handleDataChannel = _a => __awaiter(this, [_a], void 0, function (_ref) {
       var _this = this;
       let {
@@ -17440,6 +17631,14 @@ class RTCEngine extends eventsExports.EventEmitter {
           return;
         }
         const dp = DataPacket.fromBinary(new Uint8Array(buffer));
+        if (dp.sequence > 0 && dp.participantSid !== '') {
+          const lastSeq = this.reliableReceivedState.get(dp.participantSid);
+          if (lastSeq && dp.sequence <= lastSeq) {
+            // ignore duplicate or out-of-order packets in reliable channel
+            return;
+          }
+          this.reliableReceivedState.set(dp.participantSid, dp.sequence);
+        }
         if (((_a = dp.value) === null || _a === void 0 ? void 0 : _a.case) === 'speaker') {
           // dispatch speaker updates
           this.emit(EngineEvent.ActiveSpeakersUpdate, dp.value.value.speakers);
@@ -17540,6 +17739,9 @@ class RTCEngine extends eventsExports.EventEmitter {
     this.isBufferStatusLow = kind => {
       const dc = this.dataChannelForKind(kind);
       if (dc) {
+        if (kind === DataPacket_Kind.RELIABLE) {
+          this.reliableMessageBuffer.alignBufferedAmount(dc.bufferedAmount);
+        }
         return dc.bufferedAmount <= dc.bufferedAmountLowThreshold;
       }
     };
@@ -17661,6 +17863,9 @@ class RTCEngine extends eventsExports.EventEmitter {
       this.lossyDCSub = undefined;
       this.reliableDC = undefined;
       this.reliableDCSub = undefined;
+      this.reliableMessageBuffer = new DataPacketBuffer();
+      this.reliableDataSequence = 1;
+      this.reliableReceivedState.clear();
     });
   }
   cleanupClient() {
@@ -18185,6 +18390,9 @@ class RTCEngine extends eventsExports.EventEmitter {
       if (res) {
         const rtcConfig = this.makeRTCConfiguration(res);
         this.pcManager.updateConfiguration(rtcConfig);
+        if (this.latestJoinResponse) {
+          this.latestJoinResponse.serverInfo = res.serverInfo;
+        }
       } else {
         this.log.warn('Did not receive reconnect response', this.logContext);
       }
@@ -18204,6 +18412,9 @@ class RTCEngine extends eventsExports.EventEmitter {
       if (((_a = this.reliableDC) === null || _a === void 0 ? void 0 : _a.readyState) === 'open' && this.reliableDC.id === null) {
         this.createDataChannels();
       }
+      if (res === null || res === void 0 ? void 0 : res.lastMessageSeq) {
+        this.resendReliableMessagesForResume(res.lastMessageSeq);
+      }
       // resume success
       this.emit(EngineEvent.Resumed);
     });
@@ -18276,16 +18487,42 @@ class RTCEngine extends eventsExports.EventEmitter {
   /* @internal */
   sendDataPacket(packet, kind) {
     return __awaiter(this, void 0, void 0, function* () {
-      const msg = packet.toBinary();
       // make sure we do have a data connection
       yield this.ensurePublisherConnected(kind);
+      if (kind === DataPacket_Kind.RELIABLE) {
+        packet.sequence = this.reliableDataSequence;
+        this.reliableDataSequence += 1;
+      }
+      const msg = packet.toBinary();
       const dc = this.dataChannelForKind(kind);
       if (dc) {
+        if (kind === DataPacket_Kind.RELIABLE) {
+          this.reliableMessageBuffer.push({
+            data: msg,
+            sequence: packet.sequence
+          });
+        }
+        if (this.attemptingReconnect) {
+          return;
+        }
         dc.send(msg);
       }
       this.updateAndEmitDCBufferStatus(kind);
     });
   }
+  resendReliableMessagesForResume(lastMessageSeq) {
+    return __awaiter(this, void 0, void 0, function* () {
+      yield this.ensurePublisherConnected(DataPacket_Kind.RELIABLE);
+      const dc = this.dataChannelForKind(DataPacket_Kind.RELIABLE);
+      if (dc) {
+        this.reliableMessageBuffer.popToSequence(lastMessageSeq);
+        this.reliableMessageBuffer.getAll().forEach(msg => {
+          dc.send(msg.data);
+        });
+      }
+      this.updateAndEmitDCBufferStatus(DataPacket_Kind.RELIABLE);
+    });
+  }
   waitForBufferStatusLow(kind) {
     return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
       if (this.isBufferStatusLow(kind)) {
@@ -18477,7 +18714,13 @@ class RTCEngine extends eventsExports.EventEmitter {
       }),
       publishTracks: getTrackPublicationInfo(localTracks),
       dataChannels: this.dataChannelsInfo(),
-      trackSidsDisabled
+      trackSidsDisabled,
+      datachannelReceiveStates: this.reliableReceivedState.map((seq, sid) => {
+        return new DataChannelReceiveState({
+          publisherSid: sid,
+          lastSeq: seq
+        });
+      })
     }));
   }
   /* @internal */
@@ -23588,7 +23831,7 @@ class Room extends eventsExports.EventEmitter {
       this.remoteParticipants.forEach((participant, identity) => {
         this.handleParticipantDisconnected(identity, participant);
       });
-      this.emit(RoomEvent.Moved, roomMoved.room.name, roomMoved.token);
+      this.emit(RoomEvent.Moved, roomMoved.room.name);
       if (roomMoved.participant) {
         this.handleParticipantUpdates([roomMoved.participant, ...roomMoved.otherParticipants]);
       } else {