livekit-client 0.18.4-RC7 → 0.18.5

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) {
@@ -9229,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";
@@ -9468,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
@@ -9610,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";
@@ -9655,9 +9655,9 @@ var TrackEvent;
   /** @internal */
 
   TrackEvent["AudioPlaybackFailed"] = "audioPlaybackFailed";
-  /**
-   * @internal
-   * Only fires on LocalAudioTrack instances
+  /**
+   * @internal
+   * Only fires on LocalAudioTrack instances
    */
 
   TrackEvent["AudioSilenceDetected"] = "audioSilenceDetected";
@@ -9673,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";
@@ -9783,7 +9783,7 @@ class DeviceManager {
 }
 DeviceManager.mediaDeviceKinds = ['audioinput', 'audiooutput', 'videoinput'];
 
-const version = '0.18.4';
+const version = '0.18.5';
 const protocolVersion = 7;
 
 const separator = '|';
@@ -9848,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');
+    }
+
+    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 (!emptyMediaStreamTrack) {
-      throw Error('Could not get empty media stream track');
+    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: {}};
@@ -10328,7 +10351,7 @@ class Track extends events.exports.EventEmitter {
     };
 
     this.kind = kind;
-    this.mediaStreamTrack = mediaTrack;
+    this._mediaStreamTrack = mediaTrack;
     this.source = Track.Source.Unknown;
 
     if (isWeb()) {
@@ -10345,6 +10368,10 @@ class Track extends events.exports.EventEmitter {
     return this._currentBitrate;
   }
 
+  get mediaStreamTrack() {
+    return this._mediaStreamTrack;
+  }
+
   attach(element) {
     let elementType = 'audio';
 
@@ -10378,7 +10405,7 @@ class Track extends events.exports.EventEmitter {
     // we'll want to re-attach it in that case
 
 
-    attachToElement(this.mediaStreamTrack, element);
+    attachToElement(this._mediaStreamTrack, element);
 
     if (element instanceof HTMLAudioElement) {
       // manually play audio to detect audio playback status
@@ -10396,7 +10423,7 @@ class Track extends events.exports.EventEmitter {
   detach(element) {
     // detach from a single element
     if (element) {
-      detachTrack(this.mediaStreamTrack, element);
+      detachTrack(this._mediaStreamTrack, element);
       const idx = this.attachedElements.indexOf(element);
 
       if (idx >= 0) {
@@ -10410,7 +10437,7 @@ class Track extends events.exports.EventEmitter {
 
     const detached = [];
     this.attachedElements.forEach(elm => {
-      detachTrack(this.mediaStreamTrack, elm);
+      detachTrack(this._mediaStreamTrack, elm);
       detached.push(elm);
       this.recycleElement(elm);
       this.emit(TrackEvent.ElementDetached, elm);
@@ -10421,7 +10448,7 @@ class Track extends events.exports.EventEmitter {
   }
 
   stop() {
-    this.mediaStreamTrack.stop();
+    this._mediaStreamTrack.stop();
 
     if (isWeb()) {
       document.removeEventListener('visibilitychange', this.appVisibilityChangedListener);
@@ -10429,11 +10456,11 @@ class Track extends events.exports.EventEmitter {
   }
 
   enable() {
-    this.mediaStreamTrack.enabled = true;
+    this._mediaStreamTrack.enabled = true;
   }
 
   disable() {
-    this.mediaStreamTrack.enabled = false;
+    this._mediaStreamTrack.enabled = false;
   }
 
   recycleElement(element) {
@@ -10663,14 +10690,15 @@ class LocalTrack extends Track {
       this.emit(TrackEvent.Ended, this);
     };
 
-    this.mediaStreamTrack.addEventListener('ended', this.handleEnded);
+    this._mediaStreamTrack.addEventListener('ended', this.handleEnded);
+
     this.constraints = constraints !== null && constraints !== void 0 ? constraints : mediaTrack.getConstraints();
     this.reacquireTrack = false;
     this.wasMuted = false;
   }
 
   get id() {
-    return this.mediaStreamTrack.id;
+    return this._mediaStreamTrack.id;
   }
 
   get dimensions() {
@@ -10681,7 +10709,7 @@ class LocalTrack extends Track {
     const {
       width,
       height
-    } = this.mediaStreamTrack.getSettings();
+    } = this._mediaStreamTrack.getSettings();
 
     if (width && height) {
       return {
@@ -10696,8 +10724,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
    */
 
 
@@ -10710,7 +10738,8 @@ class LocalTrack extends Track {
     const {
       deviceId,
       groupId
-    } = this.mediaStreamTrack.getSettings();
+    } = this._mediaStreamTrack.getSettings();
+
     const kind = this.kind === Track.Kind.Audio ? 'audioinput' : 'videoinput';
     return DeviceManager.getInstance().normalizeDeviceId(kind, deviceId, groupId);
   }
@@ -10732,17 +10761,20 @@ class LocalTrack extends Track {
 
 
     this.attachedElements.forEach(el => {
-      detachTrack(this.mediaStreamTrack, el);
+      detachTrack(this._mediaStreamTrack, el);
     });
-    this.mediaStreamTrack.removeEventListener('ended', this.handleEnded); // on Safari, the old audio track must be stopped before attempting to acquire
+
+    this._mediaStreamTrack.removeEventListener('ended', this.handleEnded); // on Safari, the old audio track must be stopped before attempting to acquire
     // the new track, otherwise the new track will stop with
     // 'A MediaStreamTrack ended due to a capture failure`
 
-    this.mediaStreamTrack.stop();
+
+    this._mediaStreamTrack.stop();
+
     track.addEventListener('ended', this.handleEnded);
     livekitLogger.debug('replace MediaStreamTrack');
     await this.sender.replaceTrack(track);
-    this.mediaStreamTrack = track;
+    this._mediaStreamTrack = track;
     this.attachedElements.forEach(el => {
       attachToElement(track, el);
     });
@@ -10773,20 +10805,23 @@ class LocalTrack extends Track {
 
 
     this.attachedElements.forEach(el => {
-      detachTrack(this.mediaStreamTrack, el);
+      detachTrack(this._mediaStreamTrack, el);
     });
-    this.mediaStreamTrack.removeEventListener('ended', this.handleEnded); // on Safari, the old audio track must be stopped before attempting to acquire
+
+    this._mediaStreamTrack.removeEventListener('ended', this.handleEnded); // on Safari, the old audio track must be stopped before attempting to acquire
     // the new track, otherwise the new track will stop with
     // 'A MediaStreamTrack ended due to a capture failure`
 
-    this.mediaStreamTrack.stop(); // create new track and attach
+
+    this._mediaStreamTrack.stop(); // create new track and attach
+
 
     const mediaStream = await navigator.mediaDevices.getUserMedia(streamConstraints);
     const newTrack = mediaStream.getTracks()[0];
     newTrack.addEventListener('ended', this.handleEnded);
     livekitLogger.debug('re-acquired MediaStreamTrack');
     await this.sender.replaceTrack(newTrack);
-    this.mediaStreamTrack = newTrack;
+    this._mediaStreamTrack = newTrack;
     this.attachedElements.forEach(el => {
       attachToElement(newTrack, el);
     });
@@ -10801,12 +10836,12 @@ class LocalTrack extends Track {
     }
 
     this.isMuted = muted;
-    this.mediaStreamTrack.enabled = !muted;
+    this._mediaStreamTrack.enabled = !muted;
     this.emit(muted ? TrackEvent.Muted : TrackEvent.Unmuted, this);
   }
 
   get needsReAcquisition() {
-    return this.mediaStreamTrack.readyState !== 'live' || this.mediaStreamTrack.muted || !this.mediaStreamTrack.enabled || this.reacquireTrack;
+    return this._mediaStreamTrack.readyState !== 'live' || this._mediaStreamTrack.muted || !this._mediaStreamTrack.enabled || this.reacquireTrack;
   }
 
   async handleAppVisibilityChanged() {
@@ -10840,7 +10875,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() {
@@ -10855,7 +10891,7 @@ class LocalTrack extends Track {
 
     this._isUpstreamPaused = false;
     this.emit(TrackEvent.UpstreamResumed, this);
-    await this.sender.replaceTrack(this.mediaStreamTrack);
+    await this.sender.replaceTrack(this._mediaStreamTrack);
   }
 
 }
@@ -10924,9 +10960,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) {
@@ -10949,8 +10985,8 @@ async function detectSilence(track) {
 
   return false;
 }
-/**
- * @internal
+/**
+ * @internal
  */
 
 function getNewAudioContext() {
@@ -10980,7 +11016,9 @@ class LocalAudioTrack extends LocalTrack {
       try {
         stats = await this.getSenderStats();
       } catch (e) {
-        livekitLogger.error('could not get audio sender stats', e);
+        livekitLogger.error('could not get audio sender stats', {
+          error: e
+        });
         return;
       }
 
@@ -11014,7 +11052,7 @@ class LocalAudioTrack extends LocalTrack {
     if (this.source === Track.Source.Microphone && this.stopOnMute) {
       livekitLogger.debug('stopping mic track'); // also stop the track, so that microphone indicator is turned off
 
-      this.mediaStreamTrack.stop();
+      this._mediaStreamTrack.stop();
     }
 
     await super.mute();
@@ -11168,7 +11206,9 @@ class LocalVideoTrack extends LocalTrack {
 
   stop() {
     this.sender = undefined;
-    this.mediaStreamTrack.getConstraints();
+
+    this._mediaStreamTrack.getConstraints();
+
     super.stop();
   }
 
@@ -11176,7 +11216,7 @@ class LocalVideoTrack extends LocalTrack {
     if (this.source === Track.Source.Camera) {
       livekitLogger.debug('stopping camera track'); // also stop the track, so that camera indicator is turned off
 
-      this.mediaStreamTrack.stop();
+      this._mediaStreamTrack.stop();
     }
 
     await super.mute();
@@ -11278,9 +11318,9 @@ class LocalVideoTrack extends LocalTrack {
 
     await this.restart(constraints);
   }
-  /**
-   * @internal
-   * Sets layers that should be publishing
+  /**
+   * @internal
+   * Sets layers that should be publishing
    */
 
 
@@ -11357,7 +11397,7 @@ class LocalVideoTrack extends LocalTrack {
     if (!isMobile()) return;
 
     if (this.isInBackground && this.source === Track.Source.Camera) {
-      this.mediaStreamTrack.enabled = false;
+      this._mediaStreamTrack.enabled = false;
     }
   }
 
@@ -11486,8 +11526,8 @@ class RemoteAudioTrack extends RemoteTrack {
 
     this.elementVolume = 1;
   }
-  /**
-   * sets the volume for all attached audio elements
+  /**
+   * sets the volume for all attached audio elements
    */
 
 
@@ -11498,8 +11538,8 @@ class RemoteAudioTrack extends RemoteTrack {
 
     this.elementVolume = volume;
   }
-  /**
-   * gets the volume for all attached audio elements
+  /**
+   * gets the volume for all attached audio elements
    */
 
 
@@ -11639,11 +11679,23 @@ class RemoteVideoTrack extends RemoteTrack {
       this.updateDimensions();
     }, REACTION_DELAY);
     this.adaptiveStreamSettings = adaptiveStreamSettings;
+
+    if (this.isAdaptiveStream) {
+      this.streamState = Track.StreamState.Paused;
+    }
   }
 
   get isAdaptiveStream() {
     return this.adaptiveStreamSettings !== undefined;
   }
+
+  get mediaStreamTrack() {
+    if (this.isAdaptiveStream && this.attachedElements.length === 0) {
+      throw Error('When using adaptiveStream, you need to use remoteVideoTrack.attach() to add the track to a HTMLVideoElement, direct usage of mediaStreamTrack is unsupported in this case');
+    }
+
+    return this._mediaStreamTrack;
+  }
   /** @internal */
 
 
@@ -11652,9 +11704,9 @@ class RemoteVideoTrack extends RemoteTrack {
     this.attachedElements.forEach(element => {
       // detach or attach
       if (muted) {
-        detachTrack(this.mediaStreamTrack, element);
+        detachTrack(this._mediaStreamTrack, element);
       } else {
-        attachToElement(this.mediaStreamTrack, element);
+        attachToElement(this._mediaStreamTrack, element);
       }
     });
   }
@@ -11848,8 +11900,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
    */
 
 
@@ -11858,8 +11910,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
    */
 
 
@@ -11945,8 +11997,8 @@ class LocalTrackPublication extends TrackPublication {
   get videoTrack() {
     return super.videoTrack;
   }
-  /**
-   * Mute the track associated with this publication
+  /**
+   * Mute the track associated with this publication
    */
 
 
@@ -11955,8 +12007,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
    */
 
 
@@ -11965,10 +12017,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
    */
 
 
@@ -11977,9 +12029,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)
    */
 
 
@@ -12024,8 +12076,8 @@ var AudioPresets;
     maxBitrate: 32000
   };
 })(AudioPresets || (AudioPresets = {}));
-/**
- * Sane presets for video resolution/encoding
+/**
+ * Sane presets for video resolution/encoding
  */
 
 
@@ -12055,8 +12107,8 @@ const VideoPresets = {
   /** @deprecated */
   fhd: new VideoPreset(1920, 1080, 3000000, 30)
 };
-/**
- * Four by three presets
+/**
+ * Four by three presets
  */
 
 const VideoPresets43 = {
@@ -12154,11 +12206,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
    */
 
 
@@ -12191,10 +12243,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
    */
 
 
@@ -12404,9 +12456,10 @@ function computeVideoEncodings(isScreenShare, width, height, options) {
   }
 
   const useSimulcast = options === null || options === void 0 ? void 0 : options.simulcast;
+  const scalabilityMode = options === null || options === void 0 ? void 0 : options.scalabilityMode;
 
-  if (!videoEncoding && !useSimulcast || !width || !height) {
-    // when we aren't simulcasting, will need to return a single encoding without
+  if (!videoEncoding && !useSimulcast && !scalabilityMode || !width || !height) {
+    // when we aren't simulcasting or svc, will need to return a single encoding without
     // capping bandwidth. we always require a encoding for dynacast
     return [{}];
   }
@@ -12417,11 +12470,41 @@ function computeVideoEncodings(isScreenShare, width, height, options) {
     livekitLogger.debug('using video encoding', videoEncoding);
   }
 
+  const original = new VideoPreset(width, height, videoEncoding.maxBitrate, videoEncoding.maxFramerate);
+  livekitLogger.debug("scalabilityMode ".concat(scalabilityMode));
+
+  if (scalabilityMode) {
+    const encodings = []; // svc use first encoding as the original, so we sort encoding from high to low
+
+    switch (scalabilityMode) {
+      case 'L3T3':
+        for (let i = 0; i < 3; i += 1) {
+          encodings.push({
+            rid: videoRids[2 - i],
+            scaleResolutionDownBy: 2 ** i,
+            maxBitrate: videoEncoding ? videoEncoding.maxBitrate / 2 ** i : 0,
+
+            /* @ts-ignore */
+            maxFramerate: original.encoding.maxFramerate,
+
+            /* @ts-ignore */
+            scalabilityMode: 'L3T3'
+          });
+        }
+
+        livekitLogger.debug('encodings', encodings);
+        return encodings;
+
+      default:
+        // TODO : support other scalability modes
+        throw new Error("unsupported scalabilityMode: ".concat(scalabilityMode));
+    }
+  }
+
   if (!useSimulcast) {
     return [videoEncoding];
   }
 
-  const original = new VideoPreset(width, height, videoEncoding.maxBitrate, videoEncoding.maxFramerate);
   let presets = [];
 
   if (isScreenShare) {
@@ -12590,9 +12673,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
    */
 
 
@@ -12622,8 +12705,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
    */
 
 
@@ -12642,11 +12725,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
    */
 
 
@@ -12658,12 +12741,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
    */
 
 
@@ -12823,8 +12906,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.
    */
 
 
@@ -12835,9 +12918,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
    */
 
 
@@ -13146,31 +13229,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
    */
 
 
@@ -13190,10 +13273,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
    */
 
 
@@ -13266,9 +13349,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.
    */
 
 
@@ -13292,10 +13375,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
    */
 
 
@@ -13353,10 +13436,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.
    */
 
 
@@ -13405,15 +13488,15 @@ 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
    */
 
 
   async publishTrack(track, options) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g;
 
     const opts = _objectSpread2(_objectSpread2({}, (_a = this.roomOptions) === null || _a === void 0 ? void 0 : _a.publishDefaults), options); // convert raw media track into audio or video track
 
@@ -13486,7 +13569,19 @@ class LocalParticipant extends Participant {
       const height = (_e = settings.height) !== null && _e !== void 0 ? _e : (_f = track.dimensions) === null || _f === void 0 ? void 0 : _f.height; // width and height should be defined for video
 
       req.width = width !== null && width !== void 0 ? width : 0;
-      req.height = height !== null && height !== void 0 ? height : 0;
+      req.height = height !== null && height !== void 0 ? height : 0; // for svc codecs, disable simulcast and enable scalability L3T3
+      // by default
+
+      if (track instanceof LocalVideoTrack) {
+        if ((opts === null || opts === void 0 ? void 0 : opts.videoCodec) === 'vp9' || (opts === null || opts === void 0 ? void 0 : opts.videoCodec) === 'av1') {
+          opts.simulcast = false;
+          opts.scalabilityMode = (_g = opts.scalabilityMode) !== null && _g !== void 0 ? _g : 'L3T3';
+        } else {
+          // other codecs, unset scalability
+          opts.scalabilityMode = undefined;
+        }
+      }
+
       encodings = computeVideoEncodings(track.source === Track.Source.ScreenShare, width, height, opts);
       req.layers = videoLayersFromEncodings(req.width, req.height, encodings);
     } else if (track.kind === Track.Kind.Audio && opts.audioBitrate) {
@@ -13516,6 +13611,11 @@ class LocalParticipant extends Participant {
     }
 
     const transceiver = this.engine.publisher.pc.addTransceiver(track.mediaStreamTrack, transceiverInit);
+
+    if (opts.videoCodec) {
+      this.setPreferredCodec(transceiver, track.kind, opts.videoCodec);
+    }
+
     this.engine.negotiate(); // store RTPSender
 
     track.sender = transceiver.sender;
@@ -13526,10 +13626,6 @@ class LocalParticipant extends Participant {
       track.startMonitor();
     }
 
-    if (opts.videoCodec) {
-      this.setPreferredCodec(transceiver, track.kind, opts.videoCodec);
-    }
-
     this.addTrackPublication(publication); // send event for publication
 
     this.emit(ParticipantEvent.LocalTrackPublished, publication);
@@ -13621,16 +13717,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
    */
 
 
@@ -13657,22 +13753,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.
    */
 
 
@@ -13711,21 +13807,38 @@ class LocalParticipant extends Participant {
 
     const cap = RTCRtpSender.getCapabilities(kind);
     if (!cap) return;
-    const selected = cap.codecs.find(c => {
+    let selected;
+    const codecs = [];
+    cap.codecs.forEach(c => {
       const codec = c.mimeType.toLowerCase();
-      const matchesVideoCodec = codec === "video/".concat(videoCodec); // for h264 codecs that have sdpFmtpLine available, use only if the
+      const matchesVideoCodec = codec === "video/".concat(videoCodec);
+
+      if (selected !== undefined) {
+        codecs.push(c);
+        return;
+      } // for h264 codecs that have sdpFmtpLine available, use only if the
       // profile-level-id is 42e01f for cross-browser compatibility
 
+
       if (videoCodec === 'h264' && c.sdpFmtpLine) {
-        return matchesVideoCodec && c.sdpFmtpLine.includes('profile-level-id=42e01f');
+        if (matchesVideoCodec && c.sdpFmtpLine.includes('profile-level-id=42e01f')) {
+          selected = c;
+          return;
+        }
       }
 
-      return matchesVideoCodec || codec === 'audio/opus';
+      if (matchesVideoCodec || codec === 'audio/opus') {
+        selected = c;
+        return;
+      }
+
+      codecs.push(c);
     });
 
     if (selected && 'setCodecPreferences' in transceiver) {
       // @ts-ignore
-      transceiver.setCodecPreferences([selected]);
+      codecs.unshift(selected);
+      transceiver.setCodecPreferences(codecs);
     }
   }
   /** @internal */
@@ -18097,9 +18210,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;
     }
@@ -18130,11 +18245,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);
@@ -18488,12 +18610,11 @@ const publishDefaults = {
 };
 const audioDefaults = {
   autoGainControl: true,
-  channelCount: 1,
   echoCancellation: true,
   noiseSuppression: true
 };
 const videoDefaults = {
-  resolution: VideoPresets.h540.resolution
+  resolution: VideoPresets.h720.resolution
 };
 
 var RoomState;
@@ -18503,20 +18624,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;
@@ -18526,9 +18647,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
@@ -18640,8 +18761,8 @@ class Room extends events.exports.EventEmitter {
         });
       });
     };
-    /**
-     * disconnects the room, emits [[RoomEvent.Disconnected]]
+    /**
+     * disconnects the room, emits [[RoomEvent.Disconnected]]
      */
 
 
@@ -18936,13 +19057,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
    */
 
 
@@ -18950,10 +19071,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
    */
 
 
@@ -18968,8 +19089,8 @@ class Room extends events.exports.EventEmitter {
       return this.localParticipant;
     }
   }
-  /**
-   * @internal for testing
+  /**
+   * @internal for testing
    */
 
 
@@ -19006,12 +19127,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`
    */
 
 
@@ -19036,23 +19157,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
    */
 
 
@@ -19248,10 +19369,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;
@@ -19277,9 +19398,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.
    */
 
 
@@ -19308,24 +19429,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) {
@@ -19403,11 +19524,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) {
@@ -19443,9 +19564,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) {
@@ -19462,10 +19583,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) {