livekit-client 2.11.4 → 2.13.0

package/dist/livekit-client.esm.mjs

@@ -3884,6 +3884,9 @@ const DisconnectReason = /* @__PURE__ */proto3.makeEnum("livekit.DisconnectReaso
 }, {
   no: 13,
   name: "SIP_TRUNK_FAILURE"
+}, {
+  no: 14,
+  name: "CONNECTION_TIMEOUT"
 }]);
 const ReconnectReason = /* @__PURE__ */proto3.makeEnum("livekit.ReconnectReason", [{
   no: 0,
@@ -3929,6 +3932,9 @@ const AudioTrackFeature = /* @__PURE__ */proto3.makeEnum("livekit.AudioTrackFeat
 }, {
   no: 5,
   name: "TF_ENHANCED_NOISE_CANCELLATION"
+}, {
+  no: 6,
+  name: "TF_PRECONNECT_BUFFER"
 }]);
 const Room$1 = /* @__PURE__ */proto3.makeMessageType("livekit.Room", () => [{
   no: 1,
@@ -4929,6 +4935,9 @@ const ClientInfo_SDK = /* @__PURE__ */proto3.makeEnum("livekit.ClientInfo.SDK",
 }, {
   no: 12,
   name: "NODE"
+}, {
+  no: 13,
+  name: "UNREAL"
 }]);
 const ClientConfiguration = /* @__PURE__ */proto3.makeMessageType("livekit.ClientConfiguration", () => [{
   no: 1,
@@ -5419,6 +5428,12 @@ const SignalResponse = /* @__PURE__ */proto3.makeMessageType("livekit.SignalResp
   kind: "message",
   T: TrackSubscribed,
   oneof: "message"
+}, {
+  no: 24,
+  name: "room_moved",
+  kind: "message",
+  T: RoomMovedResponse,
+  oneof: "message"
 }]);
 const SimulcastCodec = /* @__PURE__ */proto3.makeMessageType("livekit.SimulcastCodec", () => [{
   no: 1,
@@ -5525,6 +5540,12 @@ const AddTrackRequest = /* @__PURE__ */proto3.makeMessageType("livekit.AddTrackR
   name: "backup_codec_policy",
   kind: "enum",
   T: proto3.getEnumType(BackupCodecPolicy$1)
+}, {
+  no: 17,
+  name: "audio_features",
+  kind: "enum",
+  T: proto3.getEnumType(AudioTrackFeature),
+  repeated: true
 }]);
 const TrickleRequest = /* @__PURE__ */proto3.makeMessageType("livekit.TrickleRequest", () => [{
   no: 1,
@@ -6045,6 +6066,29 @@ const SubscriptionPermissionUpdate = /* @__PURE__ */proto3.makeMessageType("live
   T: 8
   /* ScalarType.BOOL */
 }]);
+const RoomMovedResponse = /* @__PURE__ */proto3.makeMessageType("livekit.RoomMovedResponse", () => [{
+  no: 1,
+  name: "room",
+  kind: "message",
+  T: Room$1
+}, {
+  no: 2,
+  name: "token",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 3,
+  name: "participant",
+  kind: "message",
+  T: ParticipantInfo
+}, {
+  no: 4,
+  name: "other_participants",
+  kind: "message",
+  T: ParticipantInfo,
+  repeated: true
+}]);
 const SyncState = /* @__PURE__ */proto3.makeMessageType("livekit.SyncState", () => [{
   no: 1,
   name: "answer",
@@ -10162,11 +10206,16 @@ const KEY_PROVIDER_DEFAULTS = {
 var KeyProviderEvent;
 (function (KeyProviderEvent) {
   KeyProviderEvent["SetKey"] = "setKey";
+  /** Event for requesting to ratchet the key used to encrypt the stream */
   KeyProviderEvent["RatchetRequest"] = "ratchetRequest";
+  /** Emitted when a key is ratcheted. Could be after auto-ratcheting on decryption failure or
+   *  following a `RatchetRequest`, will contain the ratcheted key material */
   KeyProviderEvent["KeyRatcheted"] = "keyRatcheted";
 })(KeyProviderEvent || (KeyProviderEvent = {}));
 var KeyHandlerEvent;
 (function (KeyHandlerEvent) {
+  /** Emitted when a key has been ratcheted. Is emitted when any key has been ratcheted
+   * i.e. when the FrameCryptor tried to ratchet when decryption is failing  */
   KeyHandlerEvent["KeyRatcheted"] = "keyRatcheted";
 })(KeyHandlerEvent || (KeyHandlerEvent = {}));
 var EncryptionEvent;
@@ -10335,14 +10384,18 @@ class BaseKeyProvider extends eventsExports.EventEmitter {
     let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     super();
     /**
-     * callback being invoked after a ratchet request has been performed on a participant
-     * that surfaces the new key material.
-     * @param material
+     * Callback being invoked after a key has been ratcheted.
+     * Can happen when:
+     * - A decryption failure occurs and the key is auto-ratcheted
+     * - A ratchet request is sent (see {@link ratchetKey()})
+     * @param ratchetResult Contains the ratcheted chain key (exportable to other participants) and the derived new key material.
+     * @param participantId
      * @param keyIndex
      */
-    this.onKeyRatcheted = (material, keyIndex) => {
+    this.onKeyRatcheted = (ratchetResult, participantId, keyIndex) => {
       livekitLogger.debug('key ratcheted event received', {
-        material,
+        ratchetResult,
+        participantId,
         keyIndex
       });
     };
@@ -10577,6 +10630,15 @@ var RoomEvent;
    * args: ([[ConnectionState]])
    */
   RoomEvent["ConnectionStateChanged"] = "connectionStateChanged";
+  /**
+   * When participant has been moved to a different room by the service request.
+   * The behavior looks like the participant has been disconnected and reconnected to a different room
+   * seamlessly without connection state transition.
+   * A new token will be provided for reconnecting to the new room if needed.
+   *
+   * args: ([[room: string, token: string]])
+   */
+  RoomEvent["Moved"] = "moved";
   /**
    * When input or output devices on the machine have changed.
    */
@@ -10701,6 +10763,12 @@ var RoomEvent;
    * args: (changedAttributes: [[Record<string, string]], participant: [[Participant]])
    */
   RoomEvent["ParticipantAttributesChanged"] = "participantAttributesChanged";
+  /**
+   * Emitted when the participant's state changes to ACTIVE and is ready to send/receive data messages
+   *
+   * args: (participant: [[Participant]])
+   */
+  RoomEvent["ParticipantActive"] = "participantActive";
   /**
    * Room metadata is a simple way for app-specific state to be pushed to
    * all users.
@@ -10995,6 +11063,10 @@ var ParticipantEvent;
   ParticipantEvent["LocalTrackSubscribed"] = "localTrackSubscribed";
   /** only emitted on local participant */
   ParticipantEvent["ChatMessage"] = "chatMessage";
+  /**
+   * Emitted when the participant's state changes to ACTIVE and is ready to send/receive data messages
+   */
+  ParticipantEvent["Active"] = "active";
 })(ParticipantEvent || (ParticipantEvent = {}));
 /** @internal */
 var EngineEvent;
@@ -11028,6 +11100,7 @@ var EngineEvent;
   EngineEvent["Offline"] = "offline";
   EngineEvent["SignalRequestResponse"] = "signalRequestResponse";
   EngineEvent["SignalConnected"] = "signalConnected";
+  EngineEvent["RoomMoved"] = "roomMoved";
 })(EngineEvent || (EngineEvent = {}));
 var TrackEvent;
 (function (TrackEvent) {
@@ -11186,10 +11259,10 @@ function getOSVersion(ua) {
   return ua.includes('mac os') ? getMatch(/\(.+?(\d+_\d+(:?_\d+)?)/, ua, 1).replace(/_/g, '.') : undefined;
 }
 
-var version$1 = "2.11.4";
+var version$1 = "2.13.0";
 
 const version = version$1;
-const protocolVersion = 15;
+const protocolVersion = 16;
 
 /**
  * Timers that can be overridden with platform specific implementations
@@ -12547,7 +12620,7 @@ class E2EEManager extends eventsExports.EventEmitter {
           }
           break;
         case 'ratchetKey':
-          this.keyProvider.emit(KeyProviderEvent.KeyRatcheted, data.material, data.keyIndex);
+          this.keyProvider.emit(KeyProviderEvent.KeyRatcheted, data.ratchetResult, data.participantIdentity, data.keyIndex);
           break;
       }
     };
@@ -13540,6 +13613,13 @@ class SignalClient {
       if (this.onLocalTrackSubscribed) {
         this.onLocalTrackSubscribed(msg.value.trackSid);
       }
+    } else if (msg.case === 'roomMoved') {
+      if (this.onTokenRefresh) {
+        this.onTokenRefresh(msg.value.token);
+      }
+      if (this.onRoomMoved) {
+        this.onRoomMoved(msg.value);
+      }
     } else {
       this.log.debug('unsupported message', Object.assign(Object.assign({}, this.logContext), {
         msgCase: msg.case
@@ -17644,6 +17724,11 @@ class RTCEngine extends eventsExports.EventEmitter {
     this.client.onSubscribedQualityUpdate = update => {
       this.emit(EngineEvent.SubscribedQualityUpdate, update);
     };
+    this.client.onRoomMoved = res => {
+      var _a;
+      this.participantSid = (_a = res.participant) === null || _a === void 0 ? void 0 : _a.sid;
+      this.emit(EngineEvent.RoomMoved, res);
+    };
     this.client.onClose = () => {
       this.handleDisconnect('signal', ReconnectReason.RR_SIGNAL_DISCONNECTED);
     };
@@ -17719,8 +17804,7 @@ class RTCEngine extends eventsExports.EventEmitter {
     }
     // create data channels
     this.lossyDC = this.pcManager.createPublisherDataChannel(lossyDataChannel, {
-      // will drop older packets that arrive
-      ordered: true,
+      ordered: false,
       maxRetransmits: 0
     });
     this.reliableDC = this.pcManager.createPublisherDataChannel(reliableDataChannel, {
@@ -18797,8 +18881,9 @@ class RemoteAudioTrack extends RemoteTrack {
       super.attach(element);
     }
     if (this.sinkId && supportsSetSinkId(element)) {
-      /* @ts-ignore */
-      element.setSinkId(this.sinkId);
+      element.setSinkId(this.sinkId).catch(e => {
+        this.log.error('Failed to set sink id on remote audio track', e, this.logContext);
+      });
     }
     if (this.audioContext && needsNewWebAudioConnection) {
       this.log.debug('using audio context mapping', this.logContext);
@@ -19500,16 +19585,17 @@ function createLocalTracks(options, loggerOptions) {
         }
       });
     }
-    // TODO if internal options don't have device Id specified, set it to 'default'
     if (internalOptions.audio === true || typeof internalOptions.audio === 'object' && !internalOptions.audio.deviceId) {
       internalOptions.audio = {
         deviceId: 'default'
       };
     }
-    if (internalOptions.video === true || typeof internalOptions.video === 'object' && !internalOptions.video.deviceId) {
+    if (internalOptions.video === true) {
       internalOptions.video = {
         deviceId: 'default'
       };
+    } else if (typeof internalOptions.video === 'object' && !internalOptions.video.deviceId) {
+      internalOptions.video.deviceId = 'default';
     }
     const opts = mergeDefaultOptions(internalOptions, audioDefaults, videoDefaults);
     const constraints = constraintsForOptions(opts);
@@ -19666,6 +19752,10 @@ class Participant extends eventsExports.EventEmitter {
     var _a;
     return ((_a = this.permissions) === null || _a === void 0 ? void 0 : _a.agent) || this.kind === ParticipantInfo_Kind.AGENT;
   }
+  get isActive() {
+    var _a;
+    return ((_a = this.participantInfo) === null || _a === void 0 ? void 0 : _a.state) === ParticipantInfo_State.ACTIVE;
+  }
   get kind() {
     return this._kind;
   }
@@ -19721,6 +19811,25 @@ class Participant extends eventsExports.EventEmitter {
       }
     }
   }
+  /**
+   * Waits until the participant is active and ready to receive data messages
+   * @returns a promise that resolves when the participant is active
+   */
+  waitUntilActive() {
+    if (this.isActive) {
+      return Promise.resolve();
+    }
+    if (this.activeFuture) {
+      return this.activeFuture.promise;
+    }
+    this.activeFuture = new Future();
+    this.once(ParticipantEvent.Active, () => {
+      var _a, _b;
+      (_b = (_a = this.activeFuture) === null || _a === void 0 ? void 0 : _a.resolve) === null || _b === void 0 ? void 0 : _b.call(_a);
+      this.activeFuture = undefined;
+    });
+    return this.activeFuture.promise;
+  }
   get connectionQuality() {
     return this._connectionQuality;
   }
@@ -19750,6 +19859,7 @@ class Participant extends eventsExports.EventEmitter {
   }
   /** @internal */
   updateInfo(info) {
+    var _a;
     // it's possible the update could be applied out of order due to await
     // during reconnect sequences. when that happens, it's possible for server
     // to have sent more recent version of participant info while JS is waiting
@@ -19764,14 +19874,14 @@ class Participant extends eventsExports.EventEmitter {
     this._setName(info.name);
     this._setMetadata(info.metadata);
     this._setAttributes(info.attributes);
+    if (info.state === ParticipantInfo_State.ACTIVE && ((_a = this.participantInfo) === null || _a === void 0 ? void 0 : _a.state) !== ParticipantInfo_State.ACTIVE) {
+      this.emit(ParticipantEvent.Active);
+    }
     if (info.permission) {
       this.setPermissions(info.permission);
     }
     // set this last so setMetadata can detect changes
     this.participantInfo = info;
-    this.log.trace('update participant info', Object.assign(Object.assign({}, this.logContext), {
-      info
-    }));
     return true;
   }
   /**
@@ -19835,6 +19945,16 @@ class Participant extends eventsExports.EventEmitter {
       this.emit(ParticipantEvent.ConnectionQualityChanged, this._connectionQuality);
     }
   }
+  /**
+   * @internal
+   */
+  setDisconnected() {
+    var _a, _b;
+    if (this.activeFuture) {
+      (_b = (_a = this.activeFuture).reject) === null || _b === void 0 ? void 0 : _b.call(_a, new Error('Participant disconnected'));
+      this.activeFuture = undefined;
+    }
+  }
   /**
    * @internal
    */
@@ -21361,6 +21481,7 @@ class LocalParticipant extends Participant {
         streamId,
         topic: info.topic,
         timestamp: numberToBigInt(Date.now()),
+        attributes: info.attributes,
         contentHeader: {
           case: 'byteHeader',
           value: new DataStream_ByteHeader({
@@ -21600,11 +21721,6 @@ class LocalParticipant extends Participant {
   }
   /** @internal */
   updateInfo(info) {
-    if (info.sid !== this.sid) {
-      // drop updates that specify a wrong sid.
-      // the sid for local participant is only explicitly set on join and full reconnect
-      return false;
-    }
     if (!super.updateInfo(info)) {
       return false;
     }
@@ -23228,6 +23344,20 @@ class Room extends eventsExports.EventEmitter {
       }
       this.localParticipant.emit(ParticipantEvent.LocalTrackSubscribed, trackPublication);
       this.emitWhenConnected(RoomEvent.LocalTrackSubscribed, trackPublication, this.localParticipant);
+    }).on(EngineEvent.RoomMoved, roomMoved => {
+      this.log.debug('room moved', roomMoved);
+      if (roomMoved.room) {
+        this.handleRoomUpdate(roomMoved.room);
+      }
+      this.remoteParticipants.forEach((participant, identity) => {
+        this.handleParticipantDisconnected(identity, participant);
+      });
+      this.emit(RoomEvent.Moved, roomMoved.room.name, roomMoved.token);
+      if (roomMoved.participant) {
+        this.handleParticipantUpdates([roomMoved.participant, ...roomMoved.otherParticipants]);
+      } else {
+        this.handleParticipantUpdates(roomMoved.otherParticipants);
+      }
     });
     if (this.localParticipant) {
       this.localParticipant.setupEngine(this.engine);
@@ -23656,6 +23786,7 @@ class Room extends eventsExports.EventEmitter {
       participant.unpublishTrack(publication.trackSid, true);
     });
     this.emit(RoomEvent.ParticipantDisconnected, participant);
+    participant.setDisconnected();
     (_a = this.localParticipant) === null || _a === void 0 ? void 0 : _a.handleParticipantDisconnected(participant.identity);
   }
   handleStreamHeader(streamHeader, participantIdentity) {
@@ -23862,6 +23993,8 @@ class Room extends eventsExports.EventEmitter {
       this.emit(RoomEvent.TrackSubscriptionFailed, trackSid, participant, error);
     }).on(ParticipantEvent.TrackSubscriptionPermissionChanged, (pub, status) => {
       this.emitWhenConnected(RoomEvent.TrackSubscriptionPermissionChanged, pub, status, participant);
+    }).on(ParticipantEvent.Active, () => {
+      this.emitWhenConnected(RoomEvent.ParticipantActive, participant);
     });
     // update info at the end after callbacks have been set up
     if (info) {