livekit-client 0.18.4-RC6 → 0.18.4

package/dist/livekit-client.esm.mjs

@@ -325,9 +325,9 @@ livekitLogger.setLevel(LogLevel.info);
 function setLogLevel(level) {
   livekitLogger.setLevel(level);
 }
-/**
- * use this to hook into the logging function to allow sending internal livekit logs to third party services
- * if set, the browser logs will lose their stacktrace information (see https://github.com/pimterry/loglevel#writing-plugins)
+/**
+ * use this to hook into the logging function to allow sending internal livekit logs to third party services
+ * if set, the browser logs will lose their stacktrace information (see https://github.com/pimterry/loglevel#writing-plugins)
  */
 
 function setLogExtension(extension) {
@@ -5024,7 +5024,8 @@ function createBaseParticipantInfo() {
     name: '',
     version: 0,
     permission: undefined,
-    region: ''
+    region: '',
+    isPublisher: false
   };
 }
 
@@ -5072,6 +5073,10 @@ const ParticipantInfo = {
       writer.uint32(98).string(message.region);
     }
 
+    if (message.isPublisher === true) {
+      writer.uint32(104).bool(message.isPublisher);
+    }
+
     return writer;
   },
 
@@ -5124,6 +5129,10 @@ const ParticipantInfo = {
           message.region = reader.string();
           break;
 
+        case 13:
+          message.isPublisher = reader.bool();
+          break;
+
         default:
           reader.skipType(tag & 7);
           break;
@@ -5144,7 +5153,8 @@ const ParticipantInfo = {
       name: isSet$1(object.name) ? String(object.name) : '',
       version: isSet$1(object.version) ? Number(object.version) : 0,
       permission: isSet$1(object.permission) ? ParticipantPermission.fromJSON(object.permission) : undefined,
-      region: isSet$1(object.region) ? String(object.region) : ''
+      region: isSet$1(object.region) ? String(object.region) : '',
+      isPublisher: isSet$1(object.isPublisher) ? Boolean(object.isPublisher) : false
     };
   },
 
@@ -5166,11 +5176,12 @@ const ParticipantInfo = {
     message.version !== undefined && (obj.version = Math.round(message.version));
     message.permission !== undefined && (obj.permission = message.permission ? ParticipantPermission.toJSON(message.permission) : undefined);
     message.region !== undefined && (obj.region = message.region);
+    message.isPublisher !== undefined && (obj.isPublisher = message.isPublisher);
     return obj;
   },
 
   fromPartial(object) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
 
     const message = createBaseParticipantInfo();
     message.sid = (_a = object.sid) !== null && _a !== void 0 ? _a : '';
@@ -5183,6 +5194,7 @@ const ParticipantInfo = {
     message.version = (_h = object.version) !== null && _h !== void 0 ? _h : 0;
     message.permission = object.permission !== undefined && object.permission !== null ? ParticipantPermission.fromPartial(object.permission) : undefined;
     message.region = (_j = object.region) !== null && _j !== void 0 ? _j : '';
+    message.isPublisher = (_k = object.isPublisher) !== null && _k !== void 0 ? _k : false;
     return message;
   }
 
@@ -6231,11 +6243,9 @@ const btoa = globalThis$1.btoa || (bin => globalThis$1.Buffer.from(bin, 'binary'
 
 function base64FromBytes(arr) {
   const bin = [];
-
-  for (const byte of arr) {
+  arr.forEach(byte => {
     bin.push(String.fromCharCode(byte));
-  }
-
+  });
   return btoa(bin.join(''));
 }
 
@@ -8585,7 +8595,8 @@ function createBaseTrackPermission() {
   return {
     participantSid: '',
     allTracks: false,
-    trackSids: []
+    trackSids: [],
+    participantIdentity: ''
   };
 }
 
@@ -8605,6 +8616,10 @@ const TrackPermission = {
       writer.uint32(26).string(v);
     }
 
+    if (message.participantIdentity !== '') {
+      writer.uint32(34).string(message.participantIdentity);
+    }
+
     return writer;
   },
 
@@ -8629,6 +8644,10 @@ const TrackPermission = {
           message.trackSids.push(reader.string());
           break;
 
+        case 4:
+          message.participantIdentity = reader.string();
+          break;
+
         default:
           reader.skipType(tag & 7);
           break;
@@ -8642,7 +8661,8 @@ const TrackPermission = {
     return {
       participantSid: isSet(object.participantSid) ? String(object.participantSid) : '',
       allTracks: isSet(object.allTracks) ? Boolean(object.allTracks) : false,
-      trackSids: Array.isArray(object === null || object === void 0 ? void 0 : object.trackSids) ? object.trackSids.map(e => String(e)) : []
+      trackSids: Array.isArray(object === null || object === void 0 ? void 0 : object.trackSids) ? object.trackSids.map(e => String(e)) : [],
+      participantIdentity: isSet(object.participantIdentity) ? String(object.participantIdentity) : ''
     };
   },
 
@@ -8657,16 +8677,18 @@ const TrackPermission = {
       obj.trackSids = [];
     }
 
+    message.participantIdentity !== undefined && (obj.participantIdentity = message.participantIdentity);
     return obj;
   },
 
   fromPartial(object) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
 
     const message = createBaseTrackPermission();
     message.participantSid = (_a = object.participantSid) !== null && _a !== void 0 ? _a : '';
     message.allTracks = (_b = object.allTracks) !== null && _b !== void 0 ? _b : false;
     message.trackSids = ((_c = object.trackSids) === null || _c === void 0 ? void 0 : _c.map(e => e)) || [];
+    message.participantIdentity = (_d = object.participantIdentity) !== null && _d !== void 0 ? _d : '';
     return message;
   }
 
@@ -9207,237 +9229,237 @@ var MediaDeviceFailure;
   MediaDeviceFailure.getFailure = getFailure;
 })(MediaDeviceFailure || (MediaDeviceFailure = {}));
 
-/**
- * Events are the primary way LiveKit notifies your application of changes.
- *
- * The following are events emitted by [[Room]], listen to room events like
- *
- * ```typescript
- * room.on(RoomEvent.TrackPublished, (track, publication, participant) => {})
- * ```
+/**
+ * Events are the primary way LiveKit notifies your application of changes.
+ *
+ * The following are events emitted by [[Room]], listen to room events like
+ *
+ * ```typescript
+ * room.on(RoomEvent.TrackPublished, (track, publication, participant) => {})
+ * ```
  */
 var RoomEvent;
 
 (function (RoomEvent) {
-  /**
-   * When the connection to the server has been interrupted and it's attempting
-   * to reconnect.
+  /**
+   * When the connection to the server has been interrupted and it's attempting
+   * to reconnect.
    */
   RoomEvent["Reconnecting"] = "reconnecting";
-  /**
-   * Fires when a reconnection has been successful.
+  /**
+   * Fires when a reconnection has been successful.
    */
 
   RoomEvent["Reconnected"] = "reconnected";
-  /**
-   * When disconnected from room. This fires when room.disconnect() is called or
-   * when an unrecoverable connection issue had occured
+  /**
+   * When disconnected from room. This fires when room.disconnect() is called or
+   * when an unrecoverable connection issue had occured
    */
 
   RoomEvent["Disconnected"] = "disconnected";
-  /**
-   * Whenever the connection state of the room changes
-   *
-   * args: ([[RoomState]])
+  /**
+   * Whenever the connection state of the room changes
+   *
+   * args: ([[RoomState]])
    */
 
   RoomEvent["StateChanged"] = "stateChanged";
-  /**
-   * When input or output devices on the machine have changed.
+  /**
+   * When input or output devices on the machine have changed.
    */
 
   RoomEvent["MediaDevicesChanged"] = "mediaDevicesChanged";
-  /**
-   * When a [[RemoteParticipant]] joins *after* the local
-   * participant. It will not emit events for participants that are already
-   * in the room
-   *
-   * args: ([[RemoteParticipant]])
+  /**
+   * When a [[RemoteParticipant]] joins *after* the local
+   * participant. It will not emit events for participants that are already
+   * in the room
+   *
+   * args: ([[RemoteParticipant]])
    */
 
   RoomEvent["ParticipantConnected"] = "participantConnected";
-  /**
-   * When a [[RemoteParticipant]] leaves *after* the local
-   * participant has joined.
-   *
-   * args: ([[RemoteParticipant]])
+  /**
+   * When a [[RemoteParticipant]] leaves *after* the local
+   * participant has joined.
+   *
+   * args: ([[RemoteParticipant]])
    */
 
   RoomEvent["ParticipantDisconnected"] = "participantDisconnected";
-  /**
-   * When a new track is published to room *after* the local
-   * participant has joined. It will not fire for tracks that are already published.
-   *
-   * A track published doesn't mean the participant has subscribed to it. It's
-   * simply reflecting the state of the room.
-   *
-   * args: ([[RemoteTrackPublication]], [[RemoteParticipant]])
+  /**
+   * When a new track is published to room *after* the local
+   * participant has joined. It will not fire for tracks that are already published.
+   *
+   * A track published doesn't mean the participant has subscribed to it. It's
+   * simply reflecting the state of the room.
+   *
+   * args: ([[RemoteTrackPublication]], [[RemoteParticipant]])
    */
 
   RoomEvent["TrackPublished"] = "trackPublished";
-  /**
-   * The [[LocalParticipant]] has subscribed to a new track. This event will **always**
-   * fire as long as new tracks are ready for use.
-   *
-   * args: ([[RemoteTrack]], [[RemoteTrackPublication]], [[RemoteParticipant]])
+  /**
+   * The [[LocalParticipant]] has subscribed to a new track. This event will **always**
+   * fire as long as new tracks are ready for use.
+   *
+   * args: ([[RemoteTrack]], [[RemoteTrackPublication]], [[RemoteParticipant]])
    */
 
   RoomEvent["TrackSubscribed"] = "trackSubscribed";
-  /**
-   * Could not subscribe to a track
-   *
-   * args: (track sid, [[RemoteParticipant]])
+  /**
+   * Could not subscribe to a track
+   *
+   * args: (track sid, [[RemoteParticipant]])
    */
 
   RoomEvent["TrackSubscriptionFailed"] = "trackSubscriptionFailed";
-  /**
-   * A [[RemoteParticipant]] has unpublished a track
-   *
-   * args: ([[RemoteTrackPublication]], [[RemoteParticipant]])
+  /**
+   * A [[RemoteParticipant]] has unpublished a track
+   *
+   * args: ([[RemoteTrackPublication]], [[RemoteParticipant]])
    */
 
   RoomEvent["TrackUnpublished"] = "trackUnpublished";
-  /**
-   * A subscribed track is no longer available. Clients should listen to this
-   * event and ensure they detach tracks.
-   *
-   * args: ([[Track]], [[RemoteTrackPublication]], [[RemoteParticipant]])
+  /**
+   * A subscribed track is no longer available. Clients should listen to this
+   * event and ensure they detach tracks.
+   *
+   * args: ([[Track]], [[RemoteTrackPublication]], [[RemoteParticipant]])
    */
 
   RoomEvent["TrackUnsubscribed"] = "trackUnsubscribed";
-  /**
-   * A track that was muted, fires on both [[RemoteParticipant]]s and [[LocalParticipant]]
-   *
-   * args: ([[TrackPublication]], [[Participant]])
+  /**
+   * A track that was muted, fires on both [[RemoteParticipant]]s and [[LocalParticipant]]
+   *
+   * args: ([[TrackPublication]], [[Participant]])
    */
 
   RoomEvent["TrackMuted"] = "trackMuted";
-  /**
-   * A track that was unmuted, fires on both [[RemoteParticipant]]s and [[LocalParticipant]]
-   *
-   * args: ([[TrackPublication]], [[Participant]])
+  /**
+   * A track that was unmuted, fires on both [[RemoteParticipant]]s and [[LocalParticipant]]
+   *
+   * args: ([[TrackPublication]], [[Participant]])
    */
 
   RoomEvent["TrackUnmuted"] = "trackUnmuted";
-  /**
-   * A local track was published successfully. This event is helpful to know
-   * when to update your local UI with the newly published track.
-   *
-   * args: ([[LocalTrackPublication]], [[LocalParticipant]])
+  /**
+   * A local track was published successfully. This event is helpful to know
+   * when to update your local UI with the newly published track.
+   *
+   * args: ([[LocalTrackPublication]], [[LocalParticipant]])
    */
 
   RoomEvent["LocalTrackPublished"] = "localTrackPublished";
-  /**
-   * A local track was unpublished. This event is helpful to know when to remove
-   * the local track from your UI.
-   *
-   * When a user stops sharing their screen by pressing "End" on the browser UI,
-   * this event will also fire.
-   *
-   * args: ([[LocalTrackPublication]], [[LocalParticipant]])
+  /**
+   * A local track was unpublished. This event is helpful to know when to remove
+   * the local track from your UI.
+   *
+   * When a user stops sharing their screen by pressing "End" on the browser UI,
+   * this event will also fire.
+   *
+   * args: ([[LocalTrackPublication]], [[LocalParticipant]])
    */
 
   RoomEvent["LocalTrackUnpublished"] = "localTrackUnpublished";
-  /**
-   * Active speakers changed. List of speakers are ordered by their audio level.
-   * loudest speakers first. This will include the LocalParticipant too.
-   *
-   * Speaker updates are sent only to the publishing participant and their subscribers.
-   *
-   * args: (Array<[[Participant]]>)
+  /**
+   * Active speakers changed. List of speakers are ordered by their audio level.
+   * loudest speakers first. This will include the LocalParticipant too.
+   *
+   * Speaker updates are sent only to the publishing participant and their subscribers.
+   *
+   * args: (Array<[[Participant]]>)
    */
 
   RoomEvent["ActiveSpeakersChanged"] = "activeSpeakersChanged";
-  /**
-   * @deprecated Use ParticipantMetadataChanged instead
-   * @internal
+  /**
+   * @deprecated Use ParticipantMetadataChanged instead
+   * @internal
    */
 
   RoomEvent["MetadataChanged"] = "metadataChanged";
-  /**
-   * Participant metadata is a simple way for app-specific state to be pushed to
-   * all users.
-   * When RoomService.UpdateParticipantMetadata is called to change a participant's
-   * state, *all*  participants in the room will fire this event.
-   *
-   * args: (prevMetadata: string, [[Participant]])
-   *
+  /**
+   * Participant metadata is a simple way for app-specific state to be pushed to
+   * all users.
+   * When RoomService.UpdateParticipantMetadata is called to change a participant's
+   * state, *all*  participants in the room will fire this event.
+   *
+   * args: (prevMetadata: string, [[Participant]])
+   *
    */
 
   RoomEvent["ParticipantMetadataChanged"] = "participantMetadataChanged";
-  /**
-   * Room metadata is a simple way for app-specific state to be pushed to
-   * all users.
-   * When RoomService.UpdateRoomMetadata is called to change a room's state,
-   * *all*  participants in the room will fire this event.
-   *
-   * args: (string)
+  /**
+   * Room metadata is a simple way for app-specific state to be pushed to
+   * all users.
+   * When RoomService.UpdateRoomMetadata is called to change a room's state,
+   * *all*  participants in the room will fire this event.
+   *
+   * args: (string)
    */
 
   RoomEvent["RoomMetadataChanged"] = "roomMetadataChanged";
-  /**
-   * Data received from another participant.
-   * Data packets provides the ability to use LiveKit to send/receive arbitrary payloads.
-   * All participants in the room will receive the messages sent to the room.
-   *
-   * args: (payload: Uint8Array, participant: [[Participant]], kind: [[DataPacket_Kind]])
+  /**
+   * Data received from another participant.
+   * Data packets provides the ability to use LiveKit to send/receive arbitrary payloads.
+   * All participants in the room will receive the messages sent to the room.
+   *
+   * args: (payload: Uint8Array, participant: [[Participant]], kind: [[DataPacket_Kind]])
    */
 
   RoomEvent["DataReceived"] = "dataReceived";
-  /**
-   * Connection quality was changed for a Participant. It'll receive updates
-   * from the local participant, as well as any [[RemoteParticipant]]s that we are
-   * subscribed to.
-   *
-   * args: (connectionQuality: [[ConnectionQuality]], participant: [[Participant]])
+  /**
+   * Connection quality was changed for a Participant. It'll receive updates
+   * from the local participant, as well as any [[RemoteParticipant]]s that we are
+   * subscribed to.
+   *
+   * args: (connectionQuality: [[ConnectionQuality]], participant: [[Participant]])
    */
 
   RoomEvent["ConnectionQualityChanged"] = "connectionQualityChanged";
-  /**
-   * StreamState indicates if a subscribed (remote) track has been paused by the SFU
-   * (typically this happens because of subscriber's bandwidth constraints)
-   *
-   * When bandwidth conditions allow, the track will be resumed automatically.
-   * TrackStreamStateChanged will also be emitted when that happens.
-   *
-   * args: (pub: [[RemoteTrackPublication]], streamState: [[Track.StreamState]],
-   *        participant: [[RemoteParticipant]])
+  /**
+   * StreamState indicates if a subscribed (remote) track has been paused by the SFU
+   * (typically this happens because of subscriber's bandwidth constraints)
+   *
+   * When bandwidth conditions allow, the track will be resumed automatically.
+   * TrackStreamStateChanged will also be emitted when that happens.
+   *
+   * args: (pub: [[RemoteTrackPublication]], streamState: [[Track.StreamState]],
+   *        participant: [[RemoteParticipant]])
    */
 
   RoomEvent["TrackStreamStateChanged"] = "trackStreamStateChanged";
-  /**
-   * One of subscribed tracks have changed its permissions for the current
-   * participant. If permission was revoked, then the track will no longer
-   * be subscribed. If permission was granted, a TrackSubscribed event will
-   * be emitted.
-   *
-   * args: (pub: [[RemoteTrackPublication]],
-   *        status: [[TrackPublication.SubscriptionStatus]],
-   *        participant: [[RemoteParticipant]])
+  /**
+   * One of subscribed tracks have changed its permissions for the current
+   * participant. If permission was revoked, then the track will no longer
+   * be subscribed. If permission was granted, a TrackSubscribed event will
+   * be emitted.
+   *
+   * args: (pub: [[RemoteTrackPublication]],
+   *        status: [[TrackPublication.SubscriptionStatus]],
+   *        participant: [[RemoteParticipant]])
    */
 
   RoomEvent["TrackSubscriptionPermissionChanged"] = "trackSubscriptionPermissionChanged";
-  /**
-   * LiveKit will attempt to autoplay all audio tracks when you attach them to
-   * audio elements. However, if that fails, we'll notify you via AudioPlaybackStatusChanged.
-   * `Room.canPlayAudio` will indicate if audio playback is permitted.
+  /**
+   * LiveKit will attempt to autoplay all audio tracks when you attach them to
+   * audio elements. However, if that fails, we'll notify you via AudioPlaybackStatusChanged.
+   * `Room.canPlayAudio` will indicate if audio playback is permitted.
    */
 
   RoomEvent["AudioPlaybackStatusChanged"] = "audioPlaybackChanged";
-  /**
-   * When we have encountered an error while attempting to create a track.
-   * The errors take place in getUserMedia().
-   * Use MediaDeviceFailure.getFailure(error) to get the reason of failure.
-   * [[getAudioCreateError]] and [[getVideoCreateError]] will indicate if it had
-   * an error while creating the audio or video track respectively.
-   *
-   * args: (error: Error)
+  /**
+   * When we have encountered an error while attempting to create a track.
+   * The errors take place in getUserMedia().
+   * Use MediaDeviceFailure.getFailure(error) to get the reason of failure.
+   * [[getAudioCreateError]] and [[getVideoCreateError]] will indicate if it had
+   * an error while creating the audio or video track respectively.
+   *
+   * args: (error: Error)
    */
 
   RoomEvent["MediaDevicesError"] = "mediaDevicesError";
-  /**
-   * A participant's permission has changed. Currently only fired on LocalParticipant.
-   * args: (prevPermissions: [[ParticipantPermission]], participant: [[Participant]])
+  /**
+   * A participant's permission has changed. Currently only fired on LocalParticipant.
+   * args: (prevPermissions: [[ParticipantPermission]], participant: [[Participant]])
    */
 
   RoomEvent["ParticipantPermissionsChanged"] = "participantPermissionsChanged";
@@ -9446,141 +9468,141 @@ var RoomEvent;
 var ParticipantEvent;
 
 (function (ParticipantEvent) {
-  /**
-   * When a new track is published to room *after* the local
-   * participant has joined. It will not fire for tracks that are already published.
-   *
-   * A track published doesn't mean the participant has subscribed to it. It's
-   * simply reflecting the state of the room.
-   *
-   * args: ([[RemoteTrackPublication]])
+  /**
+   * When a new track is published to room *after* the local
+   * participant has joined. It will not fire for tracks that are already published.
+   *
+   * A track published doesn't mean the participant has subscribed to it. It's
+   * simply reflecting the state of the room.
+   *
+   * args: ([[RemoteTrackPublication]])
    */
   ParticipantEvent["TrackPublished"] = "trackPublished";
-  /**
-   * Successfully subscribed to the [[RemoteParticipant]]'s track.
-   * This event will **always** fire as long as new tracks are ready for use.
-   *
-   * args: ([[RemoteTrack]], [[RemoteTrackPublication]])
+  /**
+   * Successfully subscribed to the [[RemoteParticipant]]'s track.
+   * This event will **always** fire as long as new tracks are ready for use.
+   *
+   * args: ([[RemoteTrack]], [[RemoteTrackPublication]])
    */
 
   ParticipantEvent["TrackSubscribed"] = "trackSubscribed";
-  /**
-   * Could not subscribe to a track
-   *
-   * args: (track sid)
+  /**
+   * Could not subscribe to a track
+   *
+   * args: (track sid)
    */
 
   ParticipantEvent["TrackSubscriptionFailed"] = "trackSubscriptionFailed";
-  /**
-   * A [[RemoteParticipant]] has unpublished a track
-   *
-   * args: ([[RemoteTrackPublication]])
+  /**
+   * A [[RemoteParticipant]] has unpublished a track
+   *
+   * args: ([[RemoteTrackPublication]])
    */
 
   ParticipantEvent["TrackUnpublished"] = "trackUnpublished";
-  /**
-   * A subscribed track is no longer available. Clients should listen to this
-   * event and ensure they detach tracks.
-   *
-   * args: ([[RemoteTrack]], [[RemoteTrackPublication]])
+  /**
+   * A subscribed track is no longer available. Clients should listen to this
+   * event and ensure they detach tracks.
+   *
+   * args: ([[RemoteTrack]], [[RemoteTrackPublication]])
    */
 
   ParticipantEvent["TrackUnsubscribed"] = "trackUnsubscribed";
-  /**
-   * A track that was muted, fires on both [[RemoteParticipant]]s and [[LocalParticipant]]
-   *
-   * args: ([[TrackPublication]])
+  /**
+   * A track that was muted, fires on both [[RemoteParticipant]]s and [[LocalParticipant]]
+   *
+   * args: ([[TrackPublication]])
    */
 
   ParticipantEvent["TrackMuted"] = "trackMuted";
-  /**
-   * A track that was unmuted, fires on both [[RemoteParticipant]]s and [[LocalParticipant]]
-   *
-   * args: ([[TrackPublication]])
+  /**
+   * A track that was unmuted, fires on both [[RemoteParticipant]]s and [[LocalParticipant]]
+   *
+   * args: ([[TrackPublication]])
    */
 
   ParticipantEvent["TrackUnmuted"] = "trackUnmuted";
-  /**
-   * A local track was published successfully. This event is helpful to know
-   * when to update your local UI with the newly published track.
-   *
-   * args: ([[LocalTrackPublication]])
+  /**
+   * A local track was published successfully. This event is helpful to know
+   * when to update your local UI with the newly published track.
+   *
+   * args: ([[LocalTrackPublication]])
    */
 
   ParticipantEvent["LocalTrackPublished"] = "localTrackPublished";
-  /**
-   * A local track was unpublished. This event is helpful to know when to remove
-   * the local track from your UI.
-   *
-   * When a user stops sharing their screen by pressing "End" on the browser UI,
-   * this event will also fire.
-   *
-   * args: ([[LocalTrackPublication]])
+  /**
+   * A local track was unpublished. This event is helpful to know when to remove
+   * the local track from your UI.
+   *
+   * When a user stops sharing their screen by pressing "End" on the browser UI,
+   * this event will also fire.
+   *
+   * args: ([[LocalTrackPublication]])
    */
 
   ParticipantEvent["LocalTrackUnpublished"] = "localTrackUnpublished";
-  /**
-   * @deprecated Use ParticipantMetadataChanged instead
-   * @internal
+  /**
+   * @deprecated Use ParticipantMetadataChanged instead
+   * @internal
    */
 
   ParticipantEvent["MetadataChanged"] = "metadataChanged";
-  /**
-   * Participant metadata is a simple way for app-specific state to be pushed to
-   * all users.
-   * When RoomService.UpdateParticipantMetadata is called to change a participant's
-   * state, *all*  participants in the room will fire this event.
-   * To access the current metadata, see [[Participant.metadata]].
-   *
-   * args: (prevMetadata: string)
-   *
+  /**
+   * Participant metadata is a simple way for app-specific state to be pushed to
+   * all users.
+   * When RoomService.UpdateParticipantMetadata is called to change a participant's
+   * state, *all*  participants in the room will fire this event.
+   * To access the current metadata, see [[Participant.metadata]].
+   *
+   * args: (prevMetadata: string)
+   *
    */
 
   ParticipantEvent["ParticipantMetadataChanged"] = "participantMetadataChanged";
-  /**
-   * Data received from this participant as sender.
-   * Data packets provides the ability to use LiveKit to send/receive arbitrary payloads.
-   * All participants in the room will receive the messages sent to the room.
-   *
-   * args: (payload: Uint8Array, kind: [[DataPacket_Kind]])
+  /**
+   * Data received from this participant as sender.
+   * Data packets provides the ability to use LiveKit to send/receive arbitrary payloads.
+   * All participants in the room will receive the messages sent to the room.
+   *
+   * args: (payload: Uint8Array, kind: [[DataPacket_Kind]])
    */
 
   ParticipantEvent["DataReceived"] = "dataReceived";
-  /**
-   * Has speaking status changed for the current participant
-   *
-   * args: (speaking: boolean)
+  /**
+   * Has speaking status changed for the current participant
+   *
+   * args: (speaking: boolean)
    */
 
   ParticipantEvent["IsSpeakingChanged"] = "isSpeakingChanged";
-  /**
-   * Connection quality was changed for a Participant. It'll receive updates
-   * from the local participant, as well as any [[RemoteParticipant]]s that we are
-   * subscribed to.
-   *
-   * args: (connectionQuality: [[ConnectionQuality]])
+  /**
+   * Connection quality was changed for a Participant. It'll receive updates
+   * from the local participant, as well as any [[RemoteParticipant]]s that we are
+   * subscribed to.
+   *
+   * args: (connectionQuality: [[ConnectionQuality]])
    */
 
   ParticipantEvent["ConnectionQualityChanged"] = "connectionQualityChanged";
-  /**
-   * StreamState indicates if a subscribed track has been paused by the SFU
-   * (typically this happens because of subscriber's bandwidth constraints)
-   *
-   * When bandwidth conditions allow, the track will be resumed automatically.
-   * TrackStreamStateChanged will also be emitted when that happens.
-   *
-   * args: (pub: [[RemoteTrackPublication]], streamState: [[Track.StreamState]])
+  /**
+   * StreamState indicates if a subscribed track has been paused by the SFU
+   * (typically this happens because of subscriber's bandwidth constraints)
+   *
+   * When bandwidth conditions allow, the track will be resumed automatically.
+   * TrackStreamStateChanged will also be emitted when that happens.
+   *
+   * args: (pub: [[RemoteTrackPublication]], streamState: [[Track.StreamState]])
    */
 
   ParticipantEvent["TrackStreamStateChanged"] = "trackStreamStateChanged";
-  /**
-   * One of subscribed tracks have changed its permissions for the current
-   * participant. If permission was revoked, then the track will no longer
-   * be subscribed. If permission was granted, a TrackSubscribed event will
-   * be emitted.
-   *
-   * args: (pub: [[RemoteTrackPublication]],
-   *        status: [[TrackPublication.SubscriptionStatus]])
+  /**
+   * One of subscribed tracks have changed its permissions for the current
+   * participant. If permission was revoked, then the track will no longer
+   * be subscribed. If permission was granted, a TrackSubscribed event will
+   * be emitted.
+   *
+   * args: (pub: [[RemoteTrackPublication]],
+   *        status: [[TrackPublication.SubscriptionStatus]])
    */
 
   ParticipantEvent["TrackSubscriptionPermissionChanged"] = "trackSubscriptionPermissionChanged"; // fired only on LocalParticipant
@@ -9588,9 +9610,9 @@ var ParticipantEvent;
   /** @internal */
 
   ParticipantEvent["MediaDevicesError"] = "mediaDevicesError";
-  /**
-   * A participant's permission has changed. Currently only fired on LocalParticipant.
-   * args: (prevPermissions: [[ParticipantPermission]])
+  /**
+   * A participant's permission has changed. Currently only fired on LocalParticipant.
+   * args: (prevPermissions: [[ParticipantPermission]])
    */
 
   ParticipantEvent["ParticipantPermissionsChanged"] = "participantPermissionsChanged";
@@ -9633,9 +9655,9 @@ var TrackEvent;
   /** @internal */
 
   TrackEvent["AudioPlaybackFailed"] = "audioPlaybackFailed";
-  /**
-   * @internal
-   * Only fires on LocalAudioTrack instances
+  /**
+   * @internal
+   * Only fires on LocalAudioTrack instances
    */
 
   TrackEvent["AudioSilenceDetected"] = "audioSilenceDetected";
@@ -9651,15 +9673,15 @@ var TrackEvent;
   /** @internal */
 
   TrackEvent["ElementDetached"] = "elementDetached";
-  /**
-   * @internal
-   * Only fires on LocalTracks
+  /**
+   * @internal
+   * Only fires on LocalTracks
    */
 
   TrackEvent["UpstreamPaused"] = "upstreamPaused";
-  /**
-   * @internal
-   * Only fires on LocalTracks
+  /**
+   * @internal
+   * Only fires on LocalTracks
    */
 
   TrackEvent["UpstreamResumed"] = "upstreamResumed";
@@ -9826,24 +9848,47 @@ function getClientInfo() {
   });
   return info;
 }
-let emptyMediaStreamTrack;
-function getEmptyMediaStreamTrack() {
-  if (!emptyMediaStreamTrack) {
+let emptyVideoStreamTrack;
+function getEmptyVideoStreamTrack() {
+  var _a;
+
+  if (!emptyVideoStreamTrack) {
     const canvas = document.createElement('canvas');
     canvas.width = 2;
-    canvas.height = 2; // @ts-ignore
+    canvas.height = 2;
+    (_a = canvas.getContext('2d')) === null || _a === void 0 ? void 0 : _a.fillRect(0, 0, canvas.width, canvas.height); // @ts-ignore
 
     const emptyStream = canvas.captureStream();
-    [emptyMediaStreamTrack] = emptyStream.getTracks();
+    [emptyVideoStreamTrack] = emptyStream.getTracks();
+
+    if (!emptyVideoStreamTrack) {
+      throw Error('Could not get empty media stream video track');
+    }
 
-    if (!emptyMediaStreamTrack) {
-      throw Error('Could not get empty media stream track');
+    emptyVideoStreamTrack.enabled = false;
+  }
+
+  return emptyVideoStreamTrack;
+}
+let emptyAudioStreamTrack;
+function getEmptyAudioStreamTrack() {
+  if (!emptyAudioStreamTrack) {
+    // implementation adapted from https://blog.mozilla.org/webrtc/warm-up-with-replacetrack/
+    const ctx = new AudioContext();
+    const oscillator = ctx.createOscillator();
+    const dst = ctx.createMediaStreamDestination();
+    oscillator.connect(dst);
+    oscillator.start();
+    [emptyAudioStreamTrack] = dst.stream.getAudioTracks();
+
+    if (!emptyAudioStreamTrack) {
+      throw Error('Could not get empty media stream audio track');
     }
 
-    emptyMediaStreamTrack.enabled = false;
+    emptyAudioStreamTrack.enabled = false;
   }
 
-  return emptyMediaStreamTrack;
+  return emptyAudioStreamTrack;
 }
 
 var events = {exports: {}};
@@ -10674,8 +10719,8 @@ class LocalTrack extends Track {
   get isUpstreamPaused() {
     return this._isUpstreamPaused;
   }
-  /**
-   * @returns DeviceID of the device that is currently being used for this track
+  /**
+   * @returns DeviceID of the device that is currently being used for this track
    */
 
 
@@ -10818,7 +10863,8 @@ class LocalTrack extends Track {
 
     this._isUpstreamPaused = true;
     this.emit(TrackEvent.UpstreamPaused, this);
-    await this.sender.replaceTrack(getEmptyMediaStreamTrack());
+    const emptyTrack = this.kind === Track.Kind.Audio ? getEmptyAudioStreamTrack() : getEmptyVideoStreamTrack();
+    await this.sender.replaceTrack(emptyTrack);
   }
 
   async resumeUpstream() {
@@ -10902,9 +10948,9 @@ function constraintsForOptions(options) {
 
   return constraints;
 }
-/**
- * This function detects silence on a given [[Track]] instance.
- * Returns true if the track seems to be entirely silent.
+/**
+ * This function detects silence on a given [[Track]] instance.
+ * Returns true if the track seems to be entirely silent.
  */
 
 async function detectSilence(track) {
@@ -10927,8 +10973,8 @@ async function detectSilence(track) {
 
   return false;
 }
-/**
- * @internal
+/**
+ * @internal
  */
 
 function getNewAudioContext() {
@@ -11256,9 +11302,9 @@ class LocalVideoTrack extends LocalTrack {
 
     await this.restart(constraints);
   }
-  /**
-   * @internal
-   * Sets layers that should be publishing
+  /**
+   * @internal
+   * Sets layers that should be publishing
    */
 
 
@@ -11464,8 +11510,8 @@ class RemoteAudioTrack extends RemoteTrack {
 
     this.elementVolume = 1;
   }
-  /**
-   * sets the volume for all attached audio elements
+  /**
+   * sets the volume for all attached audio elements
    */
 
 
@@ -11476,8 +11522,8 @@ class RemoteAudioTrack extends RemoteTrack {
 
     this.elementVolume = volume;
   }
-  /**
-   * gets the volume for all attached audio elements
+  /**
+   * gets the volume for all attached audio elements
    */
 
 
@@ -11617,6 +11663,10 @@ class RemoteVideoTrack extends RemoteTrack {
       this.updateDimensions();
     }, REACTION_DELAY);
     this.adaptiveStreamSettings = adaptiveStreamSettings;
+
+    if (this.isAdaptiveStream) {
+      this.streamState = Track.StreamState.Paused;
+    }
   }
 
   get isAdaptiveStream() {
@@ -11826,8 +11876,8 @@ class TrackPublication extends events.exports.EventEmitter {
   get isSubscribed() {
     return this.track !== undefined;
   }
-  /**
-   * an [AudioTrack] if this publication holds an audio track
+  /**
+   * an [AudioTrack] if this publication holds an audio track
    */
 
 
@@ -11836,8 +11886,8 @@ class TrackPublication extends events.exports.EventEmitter {
       return this.track;
     }
   }
-  /**
-   * an [VideoTrack] if this publication holds a video track
+  /**
+   * an [VideoTrack] if this publication holds a video track
    */
 
 
@@ -11923,8 +11973,8 @@ class LocalTrackPublication extends TrackPublication {
   get videoTrack() {
     return super.videoTrack;
   }
-  /**
-   * Mute the track associated with this publication
+  /**
+   * Mute the track associated with this publication
    */
 
 
@@ -11933,8 +11983,8 @@ class LocalTrackPublication extends TrackPublication {
 
     return (_a = this.track) === null || _a === void 0 ? void 0 : _a.mute();
   }
-  /**
-   * Unmute track associated with this publication
+  /**
+   * Unmute track associated with this publication
    */
 
 
@@ -11943,10 +11993,10 @@ class LocalTrackPublication extends TrackPublication {
 
     return (_a = this.track) === null || _a === void 0 ? void 0 : _a.unmute();
   }
-  /**
-   * Pauses the media stream track associated with this publication from being sent to the server
-   * and signals "muted" event to other participants
-   * Useful if you want to pause the stream without pausing the local media stream track
+  /**
+   * Pauses the media stream track associated with this publication from being sent to the server
+   * and signals "muted" event to other participants
+   * Useful if you want to pause the stream without pausing the local media stream track
    */
 
 
@@ -11955,9 +12005,9 @@ class LocalTrackPublication extends TrackPublication {
 
     await ((_a = this.track) === null || _a === void 0 ? void 0 : _a.pauseUpstream());
   }
-  /**
-   * Resumes sending the media stream track associated with this publication to the server after a call to [[pauseUpstream()]]
-   * and signals "unmuted" event to other participants (unless the track is explicitly muted)
+  /**
+   * Resumes sending the media stream track associated with this publication to the server after a call to [[pauseUpstream()]]
+   * and signals "unmuted" event to other participants (unless the track is explicitly muted)
    */
 
 
@@ -12002,8 +12052,8 @@ var AudioPresets;
     maxBitrate: 32000
   };
 })(AudioPresets || (AudioPresets = {}));
-/**
- * Sane presets for video resolution/encoding
+/**
+ * Sane presets for video resolution/encoding
  */
 
 
@@ -12033,8 +12083,8 @@ const VideoPresets = {
   /** @deprecated */
   fhd: new VideoPreset(1920, 1080, 3000000, 30)
 };
-/**
- * Four by three presets
+/**
+ * Four by three presets
  */
 
 const VideoPresets43 = {
@@ -12132,11 +12182,11 @@ class Participant extends events.exports.EventEmitter {
   getTracks() {
     return Array.from(this.tracks.values());
   }
-  /**
-   * Finds the first track that matches the source filter, for example, getting
-   * the user's camera track with getTrackBySource(Track.Source.Camera).
-   * @param source
-   * @returns
+  /**
+   * Finds the first track that matches the source filter, for example, getting
+   * the user's camera track with getTrackBySource(Track.Source.Camera).
+   * @param source
+   * @returns
    */
 
 
@@ -12169,10 +12219,10 @@ class Participant extends events.exports.EventEmitter {
       }
     }
   }
-  /**
-   * Finds the first track that matches the track's name.
-   * @param name
-   * @returns
+  /**
+   * Finds the first track that matches the track's name.
+   * @param name
+   * @returns
    */
 
 
@@ -12313,15 +12363,16 @@ class Participant extends events.exports.EventEmitter {
 }
 
 function trackPermissionToProto(perms) {
-  var _a;
+  var _a, _b, _c;
 
-  if (!perms.participantSid) {
-    throw new Error('Invalid track permission, missing participantSid');
+  if (!perms.participantSid && !perms.participantIdentity) {
+    throw new Error('Invalid track permission, must provide at least one of participantIdentity and participantSid');
   }
 
   return {
-    participantSid: perms.participantSid,
-    allTracks: (_a = perms.allowAll) !== null && _a !== void 0 ? _a : false,
+    participantIdentity: (_a = perms.participantIdentity) !== null && _a !== void 0 ? _a : '',
+    participantSid: (_b = perms.participantSid) !== null && _b !== void 0 ? _b : '',
+    allTracks: (_c = perms.allowAll) !== null && _c !== void 0 ? _c : false,
     trackSids: perms.allowedTrackSids || []
   };
 }
@@ -12567,9 +12618,9 @@ class RemoteTrackPublication extends TrackPublication {
       this.emitTrackUpdate();
     };
   }
-  /**
-   * Subscribe or unsubscribe to this remote track
-   * @param subscribed true to subscribe to a track, false to unsubscribe
+  /**
+   * Subscribe or unsubscribe to this remote track
+   * @param subscribed true to subscribe to a track, false to unsubscribe
    */
 
 
@@ -12599,8 +12650,8 @@ class RemoteTrackPublication extends TrackPublication {
 
     return TrackPublication.SubscriptionStatus.Subscribed;
   }
-  /**
-   * Returns true if track is subscribed, and ready for playback
+  /**
+   * Returns true if track is subscribed, and ready for playback
    */
 
 
@@ -12619,11 +12670,11 @@ class RemoteTrackPublication extends TrackPublication {
   get isEnabled() {
     return !this.disabled;
   }
-  /**
-   * disable server from sending down data for this track. this is useful when
-   * the participant is off screen, you may disable streaming down their video
-   * to reduce bandwidth requirements
-   * @param enabled
+  /**
+   * disable server from sending down data for this track. this is useful when
+   * the participant is off screen, you may disable streaming down their video
+   * to reduce bandwidth requirements
+   * @param enabled
    */
 
 
@@ -12635,12 +12686,12 @@ class RemoteTrackPublication extends TrackPublication {
     this.disabled = !enabled;
     this.emitTrackUpdate();
   }
-  /**
-   * for tracks that support simulcasting, adjust subscribed quality
-   *
-   * This indicates the highest quality the client can accept. if network
-   * bandwidth does not allow, server will automatically reduce quality to
-   * optimize for uninterrupted video
+  /**
+   * for tracks that support simulcasting, adjust subscribed quality
+   *
+   * This indicates the highest quality the client can accept. if network
+   * bandwidth does not allow, server will automatically reduce quality to
+   * optimize for uninterrupted video
    */
 
 
@@ -12800,8 +12851,8 @@ class RemoteParticipant extends Participant {
       return track;
     }
   }
-  /**
-   * sets the volume on the participant's microphone track if it exists.
+  /**
+   * sets the volume on the participant's microphone track if it exists.
    */
 
 
@@ -12812,9 +12863,9 @@ class RemoteParticipant extends Participant {
       audioPublication.track.setVolume(volume);
     }
   }
-  /**
-   * gets the volume on the participant's microphone track
-   * returns undefined if no microphone track exists
+  /**
+   * gets the volume on the participant's microphone track
+   * returns undefined if no microphone track exists
    */
 
 
@@ -13123,31 +13174,31 @@ class LocalParticipant extends Participant {
       return track;
     }
   }
-  /**
-   * Enable or disable a participant's camera track.
-   *
-   * If a track has already published, it'll mute or unmute the track.
-   * Resolves with a `LocalTrackPublication` instance if successful and `undefined` otherwise
+  /**
+   * Enable or disable a participant's camera track.
+   *
+   * If a track has already published, it'll mute or unmute the track.
+   * Resolves with a `LocalTrackPublication` instance if successful and `undefined` otherwise
    */
 
 
   setCameraEnabled(enabled) {
     return this.setTrackEnabled(Track.Source.Camera, enabled);
   }
-  /**
-   * Enable or disable a participant's microphone track.
-   *
-   * If a track has already published, it'll mute or unmute the track.
-   * Resolves with a `LocalTrackPublication` instance if successful and `undefined` otherwise
+  /**
+   * Enable or disable a participant's microphone track.
+   *
+   * If a track has already published, it'll mute or unmute the track.
+   * Resolves with a `LocalTrackPublication` instance if successful and `undefined` otherwise
    */
 
 
   setMicrophoneEnabled(enabled) {
     return this.setTrackEnabled(Track.Source.Microphone, enabled);
   }
-  /**
-   * Start or stop sharing a participant's screen
-   * Resolves with a `LocalTrackPublication` instance if successful and `undefined` otherwise
+  /**
+   * Start or stop sharing a participant's screen
+   * Resolves with a `LocalTrackPublication` instance if successful and `undefined` otherwise
    */
 
 
@@ -13167,10 +13218,10 @@ class LocalParticipant extends Participant {
 
     return changed;
   }
-  /**
-   * Enable or disable publishing for a track by source. This serves as a simple
-   * way to manage the common tracks (camera, mic, or screen share).
-   * Resolves with LocalTrackPublication if successful and void otherwise
+  /**
+   * Enable or disable publishing for a track by source. This serves as a simple
+   * way to manage the common tracks (camera, mic, or screen share).
+   * Resolves with LocalTrackPublication if successful and void otherwise
    */
 
 
@@ -13243,9 +13294,9 @@ class LocalParticipant extends Participant {
 
     return track;
   }
-  /**
-   * Publish both camera and microphone at the same time. This is useful for
-   * displaying a single Permission Dialog box to the end user.
+  /**
+   * Publish both camera and microphone at the same time. This is useful for
+   * displaying a single Permission Dialog box to the end user.
    */
 
 
@@ -13269,10 +13320,10 @@ class LocalParticipant extends Participant {
       this.pendingPublishing.delete(Track.Source.Microphone);
     }
   }
-  /**
-   * Create local camera and/or microphone tracks
-   * @param options
-   * @returns
+  /**
+   * Create local camera and/or microphone tracks
+   * @param options
+   * @returns
    */
 
 
@@ -13330,10 +13381,10 @@ class LocalParticipant extends Participant {
       return track;
     });
   }
-  /**
-   * Creates a screen capture tracks with getDisplayMedia().
-   * A LocalVideoTrack is always created and returned.
-   * If { audio: true }, and the browser supports audio capture, a LocalAudioTrack is also created.
+  /**
+   * Creates a screen capture tracks with getDisplayMedia().
+   * A LocalVideoTrack is always created and returned.
+   * If { audio: true }, and the browser supports audio capture, a LocalAudioTrack is also created.
    */
 
 
@@ -13382,10 +13433,10 @@ class LocalParticipant extends Participant {
 
     return localTracks;
   }
-  /**
-   * Publish a new track to the room
-   * @param track
-   * @param options
+  /**
+   * Publish a new track to the room
+   * @param track
+   * @param options
    */
 
 
@@ -13598,16 +13649,16 @@ class LocalParticipant extends Participant {
     });
     return publications;
   }
-  /**
-   * Publish a new data payload to the room. Data will be forwarded to each
-   * participant in the room if the destination argument is empty
-   *
-   * @param data Uint8Array of the payload. To send string data, use TextEncoder.encode
-   * @param kind whether to send this as reliable or lossy.
-   * For data that you need delivery guarantee (such as chat messages), use Reliable.
-   * For data that should arrive as quickly as possible, but you are ok with dropped
-   * packets, use Lossy.
-   * @param destination the participants who will receive the message
+  /**
+   * Publish a new data payload to the room. Data will be forwarded to each
+   * participant in the room if the destination argument is empty
+   *
+   * @param data Uint8Array of the payload. To send string data, use TextEncoder.encode
+   * @param kind whether to send this as reliable or lossy.
+   * For data that you need delivery guarantee (such as chat messages), use Reliable.
+   * For data that should arrive as quickly as possible, but you are ok with dropped
+   * packets, use Lossy.
+   * @param destination the participants who will receive the message
    */
 
 
@@ -13634,22 +13685,22 @@ class LocalParticipant extends Participant {
     };
     await this.engine.sendDataPacket(packet, kind);
   }
-  /**
-   * Control who can subscribe to LocalParticipant's published tracks.
-   *
-   * By default, all participants can subscribe. This allows fine-grained control over
-   * who is able to subscribe at a participant and track level.
-   *
-   * Note: if access is given at a track-level (i.e. both [allParticipantsAllowed] and
-   * [ParticipantTrackPermission.allTracksAllowed] are false), any newer published tracks
-   * will not grant permissions to any participants and will require a subsequent
-   * permissions update to allow subscription.
-   *
-   * @param allParticipantsAllowed Allows all participants to subscribe all tracks.
-   *  Takes precedence over [[participantTrackPermissions]] if set to true.
-   *  By default this is set to true.
-   * @param participantTrackPermissions Full list of individual permissions per
-   *  participant/track. Any omitted participants will not receive any permissions.
+  /**
+   * Control who can subscribe to LocalParticipant's published tracks.
+   *
+   * By default, all participants can subscribe. This allows fine-grained control over
+   * who is able to subscribe at a participant and track level.
+   *
+   * Note: if access is given at a track-level (i.e. both [allParticipantsAllowed] and
+   * [ParticipantTrackPermission.allTracksAllowed] are false), any newer published tracks
+   * will not grant permissions to any participants and will require a subsequent
+   * permissions update to allow subscription.
+   *
+   * @param allParticipantsAllowed Allows all participants to subscribe all tracks.
+   *  Takes precedence over [[participantTrackPermissions]] if set to true.
+   *  By default this is set to true.
+   * @param participantTrackPermissions Full list of individual permissions per
+   *  participant/track. Any omitted participants will not receive any permissions.
    */
 
 
@@ -18074,9 +18125,11 @@ class RTCEngine extends events.exports.EventEmitter {
     };
 
     let primaryPC = this.publisher.pc;
+    let secondaryPC = this.subscriber.pc;
 
     if (joinResponse.subscriberPrimary) {
-      primaryPC = this.subscriber.pc; // in subscriber primary mode, server side opens sub data channels.
+      primaryPC = this.subscriber.pc;
+      secondaryPC = this.publisher.pc; // in subscriber primary mode, server side opens sub data channels.
 
       this.subscriber.pc.ondatachannel = this.handleDataChannel;
     }
@@ -18107,11 +18160,18 @@ class RTCEngine extends events.exports.EventEmitter {
         // on Safari, PeerConnection will switch to 'disconnected' during renegotiation
         if (this.pcState === PCState.Connected) {
           this.pcState = PCState.Disconnected;
-          this.handleDisconnect('peerconnection');
+          this.handleDisconnect('primary peerconnection');
         }
       }
     };
 
+    secondaryPC.onconnectionstatechange = async () => {
+      // also reconnect if secondary peerconnection fails
+      if (secondaryPC.connectionState === 'failed') {
+        this.handleDisconnect('secondary peerconnection');
+      }
+    };
+
     if (isWeb()) {
       this.subscriber.pc.ontrack = ev => {
         this.emit(EngineEvent.MediaTrackAdded, ev.track, ev.streams[0], ev.receiver);
@@ -18480,20 +18540,20 @@ var RoomState;
   RoomState["Connected"] = "connected";
   RoomState["Reconnecting"] = "reconnecting";
 })(RoomState || (RoomState = {}));
-/**
- * In LiveKit, a room is the logical grouping for a list of participants.
- * Participants in a room can publish tracks, and subscribe to others' tracks.
- *
- * a Room fires [[RoomEvent | RoomEvents]].
- *
- * @noInheritDoc
+/**
+ * In LiveKit, a room is the logical grouping for a list of participants.
+ * Participants in a room can publish tracks, and subscribe to others' tracks.
+ *
+ * a Room fires [[RoomEvent | RoomEvents]].
+ *
+ * @noInheritDoc
  */
 
 
 class Room extends events.exports.EventEmitter {
-  /**
-   * Creates a new Room, the primary construct for a LiveKit session.
-   * @param options
+  /**
+   * Creates a new Room, the primary construct for a LiveKit session.
+   * @param options
    */
   constructor(options) {
     var _this;
@@ -18503,9 +18563,9 @@ class Room extends events.exports.EventEmitter {
     super();
     _this = this;
     this.state = RoomState.Disconnected;
-    /**
-     * list of participants that are actively speaking. when this changes
-     * a [[RoomEvent.ActiveSpeakersChanged]] event is fired
+    /**
+     * list of participants that are actively speaking. when this changes
+     * a [[RoomEvent.ActiveSpeakersChanged]] event is fired
      */
 
     this.activeSpeakers = []; // available after connected
@@ -18617,8 +18677,8 @@ class Room extends events.exports.EventEmitter {
         });
       });
     };
-    /**
-     * disconnects the room, emits [[RoomEvent.Disconnected]]
+    /**
+     * disconnects the room, emits [[RoomEvent.Disconnected]]
      */
 
 
@@ -18913,13 +18973,13 @@ class Room extends events.exports.EventEmitter {
       }
     }).on(EngineEvent.Restarting, this.handleRestarting).on(EngineEvent.Restarted, this.handleRestarted);
   }
-  /**
-   * getLocalDevices abstracts navigator.mediaDevices.enumerateDevices.
-   * In particular, it handles Chrome's unique behavior of creating `default`
-   * devices. When encountered, it'll be removed from the list of devices.
-   * The actual default device will be placed at top.
-   * @param kind
-   * @returns a list of available local devices
+  /**
+   * getLocalDevices abstracts navigator.mediaDevices.enumerateDevices.
+   * In particular, it handles Chrome's unique behavior of creating `default`
+   * devices. When encountered, it'll be removed from the list of devices.
+   * The actual default device will be placed at top.
+   * @param kind
+   * @returns a list of available local devices
    */
 
 
@@ -18927,10 +18987,10 @@ class Room extends events.exports.EventEmitter {
     let requestPermissions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
     return DeviceManager.getInstance().getDevices(kind, requestPermissions);
   }
-  /**
-   * retrieves a participant by identity
-   * @param identity
-   * @returns
+  /**
+   * retrieves a participant by identity
+   * @param identity
+   * @returns
    */
 
 
@@ -18945,8 +19005,8 @@ class Room extends events.exports.EventEmitter {
       return this.localParticipant;
     }
   }
-  /**
-   * @internal for testing
+  /**
+   * @internal for testing
    */
 
 
@@ -18983,12 +19043,12 @@ class Room extends events.exports.EventEmitter {
       this.engine.client.sendSimulateScenario(req);
     }
   }
-  /**
-   * Browsers have different policies regarding audio playback. Most requiring
-   * some form of user interaction (click/tap/etc).
-   * In those cases, audio will be silent until a click/tap triggering one of the following
-   * - `startAudio`
-   * - `getUserMedia`
+  /**
+   * Browsers have different policies regarding audio playback. Most requiring
+   * some form of user interaction (click/tap/etc).
+   * In those cases, audio will be silent until a click/tap triggering one of the following
+   * - `startAudio`
+   * - `getUserMedia`
    */
 
 
@@ -19013,23 +19073,23 @@ class Room extends events.exports.EventEmitter {
       throw err;
     }
   }
-  /**
-   * Returns true if audio playback is enabled
+  /**
+   * Returns true if audio playback is enabled
    */
 
 
   get canPlaybackAudio() {
     return this.audioEnabled;
   }
-  /**
-   * Switches all active device used in this room to the given device.
-   *
-   * Note: setting AudioOutput is not supported on some browsers. See [setSinkId](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/setSinkId#browser_compatibility)
-   *
-   * @param kind use `videoinput` for camera track,
-   *  `audioinput` for microphone track,
-   *  `audiooutput` to set speaker for all incoming audio tracks
-   * @param deviceId
+  /**
+   * Switches all active device used in this room to the given device.
+   *
+   * Note: setting AudioOutput is not supported on some browsers. See [setSinkId](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/setSinkId#browser_compatibility)
+   *
+   * @param kind use `videoinput` for camera track,
+   *  `audioinput` for microphone track,
+   *  `audiooutput` to set speaker for all incoming audio tracks
+   * @param deviceId
    */
 
 
@@ -19225,10 +19285,10 @@ class Room extends events.exports.EventEmitter {
     }
 
     const previousSdp = this.engine.subscriber.pc.localDescription;
-    /* 1. autosubscribe on, so subscribed tracks = all tracks - unsub tracks,
-          in this case, we send unsub tracks, so server add all tracks to this
-          subscribe pc and unsub special tracks from it.
-       2. autosubscribe off, we send subscribed tracks.
+    /* 1. autosubscribe on, so subscribed tracks = all tracks - unsub tracks,
+          in this case, we send unsub tracks, so server add all tracks to this
+          subscribe pc and unsub special tracks from it.
+       2. autosubscribe off, we send subscribed tracks.
     */
 
     const sendUnsub = ((_a = this.connOptions) === null || _a === void 0 ? void 0 : _a.autoSubscribe) || false;
@@ -19254,9 +19314,9 @@ class Room extends events.exports.EventEmitter {
       dataChannels: this.localParticipant.dataChannelsInfo()
     });
   }
-  /**
-   * After resuming, we'll need to notify the server of the current
-   * subscription settings.
+  /**
+   * After resuming, we'll need to notify the server of the current
+   * subscription settings.
    */
 
 
@@ -19285,24 +19345,24 @@ class Room extends events.exports.EventEmitter {
 
 }
 
-/**
- * @deprecated Use room.connect() instead
- *
- * Connects to a LiveKit room, shorthand for `new Room()` and [[Room.connect]]
- *
- * ```typescript
- * connect('wss://myhost.livekit.io', token, {
- *   // publish audio and video tracks on joining
- *   audio: true,
- *   video: true,
- *   captureDefaults: {
- *    facingMode: 'user',
- *   },
- * })
- * ```
- * @param url URL to LiveKit server
- * @param token AccessToken, a JWT token that includes authentication and room details
- * @param options
+/**
+ * @deprecated Use room.connect() instead
+ *
+ * Connects to a LiveKit room, shorthand for `new Room()` and [[Room.connect]]
+ *
+ * ```typescript
+ * connect('wss://myhost.livekit.io', token, {
+ *   // publish audio and video tracks on joining
+ *   audio: true,
+ *   video: true,
+ *   captureDefaults: {
+ *    facingMode: 'user',
+ *   },
+ * })
+ * ```
+ * @param url URL to LiveKit server
+ * @param token AccessToken, a JWT token that includes authentication and room details
+ * @param options
  */
 
 async function connect(url, token, options) {
@@ -19380,11 +19440,11 @@ async function connect(url, token, options) {
   return room;
 }
 
-/**
- * Creates a local video and audio track at the same time. When acquiring both
- * audio and video tracks together, it'll display a single permission prompt to
- * the user instead of two separate ones.
- * @param options
+/**
+ * Creates a local video and audio track at the same time. When acquiring both
+ * audio and video tracks together, it'll display a single permission prompt to
+ * the user instead of two separate ones.
+ * @param options
  */
 
 async function createLocalTracks(options) {
@@ -19420,9 +19480,9 @@ async function createLocalTracks(options) {
     return track;
   });
 }
-/**
- * Creates a [[LocalVideoTrack]] with getUserMedia()
- * @param options
+/**
+ * Creates a [[LocalVideoTrack]] with getUserMedia()
+ * @param options
  */
 
 async function createLocalVideoTrack(options) {
@@ -19439,10 +19499,10 @@ async function createLocalAudioTrack(options) {
   });
   return tracks[0];
 }
-/**
- * Creates a screen capture tracks with getDisplayMedia().
- * A LocalVideoTrack is always created and returned.
- * If { audio: true }, and the browser supports audio capture, a LocalAudioTrack is also created.
+/**
+ * Creates a screen capture tracks with getDisplayMedia().
+ * A LocalVideoTrack is always created and returned.
+ * If { audio: true }, and the browser supports audio capture, a LocalAudioTrack is also created.
  */
 
 async function createLocalScreenTracks(options) {