livekit-client 2.11.3 → 2.12.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",
@@ -10156,18 +10200,22 @@ const KEY_PROVIDER_DEFAULTS = {
   ratchetSalt: SALT,
   ratchetWindowSize: 8,
   failureTolerance: DECRYPTION_FAILURE_TOLERANCE,
-  keyringSize: 16,
-  allowKeyExtraction: false
+  keyringSize: 16
 };
 
 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;
@@ -10201,10 +10249,9 @@ function importKey(keyBytes_1) {
       name: ENCRYPTION_ALGORITHM
     };
     let usage = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'encrypt';
-    let extractable = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
     return function* () {
       // https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/importKey
-      return crypto.subtle.importKey('raw', keyBytes, algorithm, extractable, usage === 'derive' ? ['deriveBits', 'deriveKey'] : ['encrypt', 'decrypt']);
+      return crypto.subtle.importKey('raw', keyBytes, algorithm, false, usage === 'derive' ? ['deriveBits', 'deriveKey'] : ['encrypt', 'decrypt']);
     }();
   });
 }
@@ -10337,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
       });
     };
@@ -10579,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.
    */
@@ -11030,6 +11090,7 @@ var EngineEvent;
   EngineEvent["Offline"] = "offline";
   EngineEvent["SignalRequestResponse"] = "signalRequestResponse";
   EngineEvent["SignalConnected"] = "signalConnected";
+  EngineEvent["RoomMoved"] = "roomMoved";
 })(EngineEvent || (EngineEvent = {}));
 var TrackEvent;
 (function (TrackEvent) {
@@ -11188,10 +11249,10 @@ function getOSVersion(ua) {
   return ua.includes('mac os') ? getMatch(/\(.+?(\d+_\d+(:?_\d+)?)/, ua, 1).replace(/_/g, '.') : undefined;
 }
 
-var version$1 = "2.11.3";
+var version$1 = "2.12.0";
 
 const version = version$1;
-const protocolVersion = 15;
+const protocolVersion = 16;
 
 /**
  * Timers that can be overridden with platform specific implementations
@@ -12342,6 +12403,18 @@ function getNewAudioContext() {
     return audioContext;
   }
 }
+/**
+ * @internal
+ */
+function kindToSource(kind) {
+  if (kind === 'audioinput') {
+    return Track.Source.Microphone;
+  } else if (kind === 'videoinput') {
+    return Track.Source.Camera;
+  } else {
+    return Track.Source.Unknown;
+  }
+}
 /**
  * @internal
  */
@@ -12537,7 +12610,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;
       }
     };
@@ -12636,9 +12709,9 @@ class E2EEManager extends eventsExports.EventEmitter {
     room.localParticipant.on(ParticipantEvent.LocalTrackPublished, publication => __awaiter(this, void 0, void 0, function* () {
       this.setupE2EESender(publication.track, publication.track.sender);
     }));
-    keyProvider.on(KeyProviderEvent.SetKey, keyInfo => this.postKey(keyInfo)).on(KeyProviderEvent.RatchetRequest, (participantId, keyIndex) => this.postRatchetRequest(participantId, keyIndex, keyProvider.getOptions().allowKeyExtraction));
+    keyProvider.on(KeyProviderEvent.SetKey, keyInfo => this.postKey(keyInfo)).on(KeyProviderEvent.RatchetRequest, (participantId, keyIndex) => this.postRatchetRequest(participantId, keyIndex));
   }
-  postRatchetRequest(participantIdentity, keyIndex, extractable) {
+  postRatchetRequest(participantIdentity, keyIndex) {
     if (!this.worker) {
       throw Error('could not ratchet key, worker is missing');
     }
@@ -12646,8 +12719,7 @@ class E2EEManager extends eventsExports.EventEmitter {
       kind: 'ratchetRequest',
       data: {
         participantIdentity: participantIdentity,
-        keyIndex,
-        extractable
+        keyIndex
       }
     };
     this.worker.postMessage(msg);
@@ -13531,6 +13603,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
@@ -17635,6 +17714,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);
     };
@@ -18788,8 +18872,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);
@@ -21591,11 +21676,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;
     }
@@ -22810,7 +22890,7 @@ class Room extends eventsExports.EventEmitter {
       }
     };
     this.handleDeviceChange = () => __awaiter(this, void 0, void 0, function* () {
-      var _a, _b;
+      var _a, _b, _c;
       const previousDevices = DeviceManager.getInstance().previousDevices;
       // check for available devices, but don't request permissions in order to avoid prompts for kinds that haven't been used before
       const availableDevices = yield DeviceManager.getInstance().getDevices(undefined, false);
@@ -22827,15 +22907,20 @@ class Room extends eventsExports.EventEmitter {
           }
         }
       }
-      // inputs are automatically handled via TrackEvent.Ended causing a TrackEvent.Restarted. Here we only need to worry about audiooutputs changing
       const kinds = ['audiooutput', 'audioinput', 'videoinput'];
       for (let kind of kinds) {
+        const targetSource = kindToSource(kind);
+        const targetPublication = this.localParticipant.getTrackPublication(targetSource);
+        if (targetPublication && ((_a = targetPublication.track) === null || _a === void 0 ? void 0 : _a.isUserProvided)) {
+          // if the track is user provided, we don't want to switch devices on behalf of the user
+          continue;
+        }
         const devicesOfKind = availableDevices.filter(d => d.kind === kind);
         const activeDevice = this.getActiveDevice(kind);
-        if (activeDevice === ((_a = previousDevices.filter(info => info.kind === kind)[0]) === null || _a === void 0 ? void 0 : _a.deviceId)) {
+        if (activeDevice === ((_b = previousDevices.filter(info => info.kind === kind)[0]) === null || _b === void 0 ? void 0 : _b.deviceId)) {
           // in  Safari the first device is always the default, so we assume a user on the default device would like to switch to the default once it changes
           // FF doesn't emit an event when the default device changes, so we perform the same best effort and switch to the new device once connected and if it's the first in the array
-          if (devicesOfKind.length > 0 && ((_b = devicesOfKind[0]) === null || _b === void 0 ? void 0 : _b.deviceId) !== activeDevice) {
+          if (devicesOfKind.length > 0 && ((_c = devicesOfKind[0]) === null || _c === void 0 ? void 0 : _c.deviceId) !== activeDevice) {
             yield this.switchActiveDevice(kind, devicesOfKind[0].deviceId);
             continue;
           }
@@ -23214,6 +23299,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);