livekit-client 1.8.0 → 1.9.0

package/src/room/Room.ts

@@ -29,6 +29,9 @@ import {
   StreamStateUpdate,
   SubscriptionPermissionUpdate,
 } from '../proto/livekit_rtc';
+import DeviceManager from './DeviceManager';
+import RTCEngine from './RTCEngine';
+import { RegionUrlProvider } from './RegionUrlProvider';
 import {
   audioDefaults,
   publishDefaults,
@@ -36,14 +39,12 @@ import {
   roomOptionDefaults,
   videoDefaults,
 } from './defaults';
-import DeviceManager from './DeviceManager';
 import { ConnectionError, ConnectionErrorReason, UnsupportedServer } from './errors';
 import { EngineEvent, ParticipantEvent, RoomEvent, TrackEvent } from './events';
 import LocalParticipant from './participant/LocalParticipant';
 import type Participant from './participant/Participant';
 import type { ConnectionQuality } from './participant/Participant';
 import RemoteParticipant from './participant/RemoteParticipant';
-import RTCEngine from './RTCEngine';
 import LocalAudioTrack from './track/LocalAudioTrack';
 import LocalTrackPublication from './track/LocalTrackPublication';
 import LocalVideoTrack from './track/LocalVideoTrack';
@@ -53,18 +54,17 @@ import { Track } from './track/Track';
 import type { TrackPublication } from './track/TrackPublication';
 import type { AdaptiveStreamSettings } from './track/types';
 import { getNewAudioContext } from './track/utils';
-import type { SimulationOptions } from './types';
+import type { SimulationOptions, SimulationScenario } from './types';
 import {
-  createDummyVideoStreamTrack,
   Future,
+  Mutex,
+  createDummyVideoStreamTrack,
   getEmptyAudioStreamTrack,
   isCloud,
   isWeb,
-  Mutex,
   supportsSetSinkId,
   unpackStreamId,
 } from './utils';
-import { RegionUrlProvider } from './RegionUrlProvider';
 
 export enum ConnectionState {
   Disconnected = 'disconnected',
@@ -99,23 +99,13 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   /** @internal */
   engine!: RTCEngine;
 
-  // available after connected
-  /** server assigned unique room id */
-  sid: string = '';
-
-  /** user assigned name, derived from JWT token */
-  name: string = '';
-
   /** the current participant */
   localParticipant: LocalParticipant;
 
-  /** room metadata */
-  metadata: string | undefined = undefined;
-
   /** options of room */
   options: InternalRoomOptions;
 
-  private _isRecording: boolean = false;
+  private roomInfo?: RoomModel;
 
   private identityToSid: Map<string, string>;
 
@@ -165,6 +155,36 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.localParticipant = new LocalParticipant('', '', this.engine, this.options);
   }
 
+  /**
+   * if the current room has a participant with `recorder: true` in its JWT grant
+   **/
+  get isRecording(): boolean {
+    return this.roomInfo?.activeRecording ?? false;
+  }
+
+  /** server assigned unique room id */
+  get sid(): string {
+    return this.roomInfo?.sid ?? '';
+  }
+
+  /** user assigned name, derived from JWT token */
+  get name(): string {
+    return this.roomInfo?.name ?? '';
+  }
+
+  /** room metadata */
+  get metadata(): string | undefined {
+    return this.roomInfo?.metadata;
+  }
+
+  get numParticipants(): number {
+    return this.roomInfo?.numParticipants ?? 0;
+  }
+
+  get numPublishers(): number {
+    return this.roomInfo?.numPublishers ?? 0;
+  }
+
   private maybeCreateEngine() {
     if (this.engine) {
       return;
@@ -207,7 +227,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         }
       })
       .on(EngineEvent.Restarting, this.handleRestarting)
-      .on(EngineEvent.Restarted, this.handleRestarted)
+      .on(EngineEvent.SignalRestarted, this.handleSignalRestarted)
       .on(EngineEvent.DCBufferStatusChanged, (status, kind) => {
         this.emit(RoomEvent.DCBufferStatusChanged, status, kind);
       });
@@ -368,31 +388,11 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.localParticipant.sid = pi.sid;
     this.localParticipant.identity = pi.identity;
 
-    this.localParticipant.updateInfo(pi);
-    // forward metadata changed for the local participant
-    this.setupLocalParticipantEvents();
-
     // populate remote participants, these should not trigger new events
-    joinResponse.otherParticipants.forEach((info) => {
-      if (
-        info.sid !== this.localParticipant.sid &&
-        info.identity !== this.localParticipant.identity
-      ) {
-        this.getOrCreateParticipant(info.sid, info);
-      } else {
-        log.warn('received info to create local participant as remote participant', {
-          info,
-          localParticipant: this.localParticipant,
-        });
-      }
-    });
+    this.handleParticipantUpdates([pi, ...joinResponse.otherParticipants]);
 
-    this.name = joinResponse.room!.name;
-    this.sid = joinResponse.room!.sid;
-    this.metadata = joinResponse.room!.metadata;
-    if (this._isRecording !== joinResponse.room!.activeRecording) {
-      this._isRecording = joinResponse.room!.activeRecording;
-      this.emit(RoomEvent.RecordingStatusChanged, joinResponse.room!.activeRecording);
+    if (joinResponse.room) {
+      this.handleRoomUpdate(joinResponse.room);
     }
   };
 
@@ -433,6 +433,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       );
 
       this.applyJoinResponse(joinResponse);
+      // forward metadata changed for the local participant
+      this.setupLocalParticipantEvents();
       this.emit(RoomEvent.SignalConnected);
     } catch (err) {
       this.recreateEngine();
@@ -534,17 +536,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.connectFuture = undefined;
   }
 
-  /**
-   * if the current room has a participant with `recorder: true` in its JWT grant
-   **/
-  get isRecording() {
-    return this._isRecording;
-  }
-
   /**
    * @internal for testing
    */
-  async simulateScenario(scenario: string) {
+  async simulateScenario(scenario: SimulationScenario) {
     let postAction = () => {};
     let req: SimulateScenario | undefined;
     switch (scenario) {
@@ -593,6 +588,13 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
           this.engine.client.onClose('simulate resume-reconnect');
         }
         break;
+      case 'full-reconnect':
+        this.engine.fullReconnectOnNext = true;
+        await this.engine.client.close();
+        if (this.engine.client.onClose) {
+          this.engine.client.onClose('simulate full-reconnect');
+        }
+        break;
       case 'force-tcp':
       case 'force-tls':
         req = SimulateScenario.fromPartial({
@@ -734,6 +736,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   private setupLocalParticipantEvents() {
     this.localParticipant
       .on(ParticipantEvent.ParticipantMetadataChanged, this.onLocalParticipantMetadataChanged)
+      .on(ParticipantEvent.ParticipantNameChanged, this.onLocalParticipantNameChanged)
       .on(ParticipantEvent.TrackMuted, this.onLocalTrackMuted)
       .on(ParticipantEvent.TrackUnmuted, this.onLocalTrackUnmuted)
       .on(ParticipantEvent.LocalTrackPublished, this.onLocalTrackPublished)
@@ -825,20 +828,14 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
   };
 
-  private handleRestarted = async (joinResponse: JoinResponse) => {
-    log.debug(`reconnected to server`, {
+  private handleSignalRestarted = async (joinResponse: JoinResponse) => {
+    log.debug(`signal reconnected to server`, {
       region: joinResponse.serverRegion,
     });
 
-    try {
-      // rehydrate participants
-      if (joinResponse.participant) {
-        // with a restart, the sid will have changed, we'll map our understanding to it
-        this.localParticipant.sid = joinResponse.participant.sid;
-        this.handleParticipantUpdates([joinResponse.participant]);
-      }
-      this.handleParticipantUpdates(joinResponse.otherParticipants);
+    this.applyJoinResponse(joinResponse);
 
+    try {
       // unpublish & republish tracks
       const localPubs: LocalTrackPublication[] = [];
       this.localParticipant.tracks.forEach((pub) => {
@@ -872,10 +869,24 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       );
     } catch (error) {
       log.error('error trying to re-publish tracks after reconnection', { error });
-    } finally {
-      this.setAndEmitConnectionState(ConnectionState.Connected);
-      this.emit(RoomEvent.Reconnected);
     }
+
+    try {
+      await this.engine.waitForRestarted();
+      log.debug(`fully reconnected to server`, {
+        region: joinResponse.serverRegion,
+      });
+    } catch {
+      // reconnection failed, handleDisconnect is being invoked already, just return here
+      return;
+    }
+    this.setAndEmitConnectionState(ConnectionState.Connected);
+    this.emit(RoomEvent.Reconnected);
+
+    // emit participant connected events after connection has been re-established
+    this.participants.forEach((participant) => {
+      this.emit(RoomEvent.ParticipantConnected, participant);
+    });
   };
 
   private handleDisconnect(shouldStopTracks = true, reason?: DisconnectReason) {
@@ -901,6 +912,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
     this.localParticipant
       .off(ParticipantEvent.ParticipantMetadataChanged, this.onLocalParticipantMetadataChanged)
+      .off(ParticipantEvent.ParticipantNameChanged, this.onLocalParticipantNameChanged)
       .off(ParticipantEvent.TrackMuted, this.onLocalTrackMuted)
       .off(ParticipantEvent.TrackUnmuted, this.onLocalTrackUnmuted)
       .off(ParticipantEvent.LocalTrackPublished, this.onLocalTrackPublished)
@@ -1106,14 +1118,14 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.emit(RoomEvent.MediaDevicesChanged);
   };
 
-  private handleRoomUpdate = (r: RoomModel) => {
-    if (this._isRecording !== r.activeRecording) {
-      this._isRecording = r.activeRecording;
-      this.emit(RoomEvent.RecordingStatusChanged, r.activeRecording);
+  private handleRoomUpdate = (room: RoomModel) => {
+    const oldRoom = this.roomInfo;
+    this.roomInfo = room;
+    if (oldRoom && oldRoom.metadata !== room.metadata) {
+      this.emitWhenConnected(RoomEvent.RoomMetadataChanged, room.metadata);
     }
-    if (this.metadata !== r.metadata) {
-      this.metadata = r.metadata;
-      this.emitWhenConnected(RoomEvent.RoomMetadataChanged, r.metadata);
+    if (oldRoom?.activeRecording !== room.activeRecording) {
+      this.emitWhenConnected(RoomEvent.RecordingStatusChanged, room.activeRecording);
     }
   };
 
@@ -1222,6 +1234,9 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       .on(ParticipantEvent.ParticipantMetadataChanged, (metadata: string | undefined) => {
         this.emitWhenConnected(RoomEvent.ParticipantMetadataChanged, metadata, participant);
       })
+      .on(ParticipantEvent.ParticipantNameChanged, (name) => {
+        this.emitWhenConnected(RoomEvent.ParticipantNameChanged, name, participant);
+      })
       .on(ParticipantEvent.ConnectionQualityChanged, (quality: ConnectionQuality) => {
         this.emitWhenConnected(RoomEvent.ConnectionQualityChanged, quality, participant);
       })
@@ -1338,6 +1353,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.emit(RoomEvent.ParticipantMetadataChanged, metadata, this.localParticipant);
   };
 
+  private onLocalParticipantNameChanged = (name: string) => {
+    this.emit(RoomEvent.ParticipantNameChanged, name, this.localParticipant);
+  };
+
   private onLocalTrackMuted = (pub: TrackPublication) => {
     this.emit(RoomEvent.TrackMuted, pub, this.localParticipant);
   };
@@ -1392,7 +1411,19 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       ...options.participants,
     };
     this.handleDisconnect();
-    this.name = 'simulated-room';
+    this.roomInfo = {
+      sid: 'RM_SIMULATED',
+      name: 'simulated-room',
+      emptyTimeout: 0,
+      maxParticipants: 0,
+      creationTime: new Date().getTime(),
+      metadata: '',
+      numParticipants: 1,
+      numPublishers: 1,
+      turnPassword: '',
+      enabledCodecs: [],
+      activeRecording: false,
+    };
 
     this.localParticipant.updateInfo(
       ParticipantInfo.fromPartial({
@@ -1537,6 +1568,7 @@ export type RoomEventCallbacks = {
     metadata: string | undefined,
     participant: RemoteParticipant | LocalParticipant,
   ) => void;
+  participantNameChanged: (name: string, participant: RemoteParticipant | LocalParticipant) => void;
   participantPermissionsChanged: (
     prevPermissions: ParticipantPermission | undefined,
     participant: RemoteParticipant | LocalParticipant,

package/src/room/events.ts

@@ -168,6 +168,14 @@ export enum RoomEvent {
    */
   ParticipantMetadataChanged = 'participantMetadataChanged',
 
+  /**
+   * Participant's display name changed
+   *
+   * args: (name: string, [[Participant]])
+   *
+   */
+  ParticipantNameChanged = 'participantNameChanged',
+
   /**
    * Room metadata is a simple way for app-specific state to be pushed to
    * all users.
@@ -359,6 +367,14 @@ export enum ParticipantEvent {
    */
   ParticipantMetadataChanged = 'participantMetadataChanged',
 
+  /**
+   * Participant's display name changed
+   *
+   * args: (name: string, [[Participant]])
+   *
+   */
+  ParticipantNameChanged = 'participantNameChanged',
+
   /**
    * Data received from this participant as sender.
    * Data packets provides the ability to use LiveKit to send/receive arbitrary payloads.
@@ -433,6 +449,7 @@ export enum EngineEvent {
   Restarting = 'restarting',
   Restarted = 'restarted',
   SignalResumed = 'signalResumed',
+  SignalRestarted = 'signalRestarted',
   Closing = 'closing',
   MediaTrackAdded = 'mediaTrackAdded',
   ActiveSpeakersUpdate = 'activeSpeakersUpdate',

package/src/room/participant/LocalParticipant.ts

@@ -10,35 +10,35 @@ import {
   TrackPublishedResponse,
   TrackUnpublishedResponse,
 } from '../../proto/livekit_rtc';
+import type RTCEngine from '../RTCEngine';
 import { DeviceUnsupportedError, TrackInvalidError, UnexpectedConnectionState } from '../errors';
 import { EngineEvent, ParticipantEvent, TrackEvent } from '../events';
-import type RTCEngine from '../RTCEngine';
 import LocalAudioTrack from '../track/LocalAudioTrack';
 import LocalTrack from '../track/LocalTrack';
 import LocalTrackPublication from '../track/LocalTrackPublication';
 import LocalVideoTrack, { videoLayersFromEncodings } from '../track/LocalVideoTrack';
+import { Track } from '../track/Track';
 import {
   AudioCaptureOptions,
   BackupVideoCodec,
   CreateLocalTracksOptions,
-  isBackupCodec,
   ScreenShareCaptureOptions,
   ScreenSharePresets,
   TrackPublishOptions,
   VideoCaptureOptions,
+  isBackupCodec,
 } from '../track/options';
-import { Track } from '../track/Track';
 import { constraintsForOptions, mergeDefaultOptions } from '../track/utils';
 import type { DataPublishOptions } from '../types';
 import { Future, isFireFox, isSafari, isWeb, supportsAV1 } from '../utils';
 import Participant from './Participant';
 import { ParticipantTrackPermission, trackPermissionToProto } from './ParticipantTrackPermission';
+import RemoteParticipant from './RemoteParticipant';
 import {
   computeTrackBackupEncodings,
   computeVideoEncodings,
   mediaTrackToLocalTrack,
 } from './publishUtils';
-import RemoteParticipant from './RemoteParticipant';
 
 export default class LocalParticipant extends Participant {
   audioTracks: Map<string, LocalTrackPublication>;
@@ -148,6 +148,26 @@ export default class LocalParticipant extends Participant {
     this.reconnectFuture = undefined;
   };
 
+  /**
+   * Sets and updates the metadata of the local participant.
+   * Note: this requires `CanUpdateOwnMetadata` permission encoded in the token.
+   * @param metadata
+   */
+  setMetadata(metadata: string): void {
+    super.setMetadata(metadata);
+    this.engine.client.sendUpdateLocalMetadata(metadata, this.name ?? '');
+  }
+
+  /**
+   * Sets and updates the name of the local participant.
+   * Note: this requires `CanUpdateOwnMetadata` permission encoded in the token.
+   * @param metadata
+   */
+  setName(name: string): void {
+    super.setName(name);
+    this.engine.client.sendUpdateLocalMetadata(this.metadata ?? '', name);
+  }
+
   /**
    * Enable or disable a participant's camera track.
    *
@@ -961,13 +981,15 @@ export default class LocalParticipant extends Participant {
   }
 
   /** @internal */
-  updateInfo(info: ParticipantInfo) {
+  updateInfo(info: ParticipantInfo): boolean {
     if (info.sid !== this.sid) {
       // drop updates that specify a wrong sid.
       // the sid for local participant is only explicitly set on join and full reconnect
-      return;
+      return false;
+    }
+    if (!super.updateInfo(info)) {
+      return false;
     }
-    super.updateInfo(info);
 
     // reconcile track mute status.
     // if server's track mute status doesn't match actual, we'll have to update
@@ -986,6 +1008,7 @@ export default class LocalParticipant extends Participant {
         }
       }
     });
+    return true;
   }
 
   private updateTrackSubscriptionPermissions = () => {

package/src/room/participant/Participant.ts

@@ -2,10 +2,10 @@ import { EventEmitter } from 'events';
 import type TypedEmitter from 'typed-emitter';
 import log from '../../logger';
 import {
-  ConnectionQuality as ProtoQuality,
   DataPacket_Kind,
   ParticipantInfo,
   ParticipantPermission,
+  ConnectionQuality as ProtoQuality,
 } from '../../proto/livekit_models';
 import { ParticipantEvent, TrackEvent } from '../events';
 import type LocalTrackPublication from '../track/LocalTrackPublication';
@@ -144,10 +144,23 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
   }
 
   /** @internal */
-  updateInfo(info: ParticipantInfo) {
+  updateInfo(info: ParticipantInfo): boolean {
+    // it's possible the update could be applied out of order due to await
+    // during reconnect sequences. when that happens, it's possible for server
+    // to have sent more recent version of participant info while JS is waiting
+    // to process the existing payload.
+    // when the participant sid remains the same, and we already have a later version
+    // of the payload, they can be safely skipped
+    if (
+      this.participantInfo &&
+      this.participantInfo.sid === info.sid &&
+      this.participantInfo.version > info.version
+    ) {
+      return false;
+    }
     this.identity = info.identity;
     this.sid = info.sid;
-    this.name = info.name;
+    this.setName(info.name);
     this.setMetadata(info.metadata);
     if (info.permission) {
       this.setPermissions(info.permission);
@@ -155,6 +168,7 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
     // set this last so setMetadata can detect changes
     this.participantInfo = info;
     log.trace('update participant info', { info });
+    return true;
   }
 
   /** @internal */
@@ -168,6 +182,15 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
     }
   }
 
+  protected setName(name: string) {
+    const changed = this.name !== name;
+    this.name = name;
+
+    if (changed) {
+      this.emit(ParticipantEvent.ParticipantNameChanged, name);
+    }
+  }
+
   /** @internal */
   setPermissions(permissions: ParticipantPermission): boolean {
     const prevPermissions = this.permissions;
@@ -250,6 +273,7 @@ export type ParticipantEventCallbacks = {
   localTrackPublished: (publication: LocalTrackPublication) => void;
   localTrackUnpublished: (publication: LocalTrackPublication) => void;
   participantMetadataChanged: (prevMetadata: string | undefined, participant?: any) => void;
+  participantNameChanged: (name: string) => void;
   dataReceived: (payload: Uint8Array, kind: DataPacket_Kind) => void;
   isSpeakingChanged: (speaking: boolean) => void;
   connectionQualityChanged: (connectionQuality: ConnectionQuality) => void;

package/src/room/participant/RemoteParticipant.ts

@@ -3,13 +3,13 @@ import log from '../../logger';
 import type { ParticipantInfo } from '../../proto/livekit_models';
 import type { UpdateSubscription, UpdateTrackSettings } from '../../proto/livekit_rtc';
 import { ParticipantEvent, TrackEvent } from '../events';
-import type { AudioOutputOptions } from '../track/options';
 import RemoteAudioTrack from '../track/RemoteAudioTrack';
 import type RemoteTrack from '../track/RemoteTrack';
 import RemoteTrackPublication from '../track/RemoteTrackPublication';
 import RemoteVideoTrack from '../track/RemoteVideoTrack';
 import { Track } from '../track/Track';
 import type { TrackPublication } from '../track/TrackPublication';
+import type { AudioOutputOptions } from '../track/options';
 import type { AdaptiveStreamSettings } from '../track/types';
 import Participant, { ParticipantEventCallbacks } from './Participant';
 
@@ -215,8 +215,10 @@ export default class RemoteParticipant extends Participant {
   }
 
   /** @internal */
-  updateInfo(info: ParticipantInfo) {
-    super.updateInfo(info);
+  updateInfo(info: ParticipantInfo): boolean {
+    if (!super.updateInfo(info)) {
+      return false;
+    }
 
     // we are getting a list of all available tracks, reconcile in here
     // and send out events for changes
@@ -277,6 +279,7 @@ export default class RemoteParticipant extends Participant {
     newTracks.forEach((publication) => {
       this.emit(ParticipantEvent.TrackPublished, publication);
     });
+    return true;
   }
 
   /** @internal */

package/src/room/participant/publishUtils.test.ts

@@ -3,8 +3,8 @@ import {
   computeDefaultScreenShareSimulcastPresets,
   computeVideoEncodings,
   determineAppropriateEncoding,
-  presets169,
   presets43,
+  presets169,
   presetsForResolution,
   presetsScreenShare,
   sortPresets,

package/src/room/participant/publishUtils.ts

@@ -2,6 +2,7 @@ import log from '../../logger';
 import { TrackInvalidError } from '../errors';
 import LocalAudioTrack from '../track/LocalAudioTrack';
 import LocalVideoTrack from '../track/LocalVideoTrack';
+import { Track } from '../track/Track';
 import {
   BackupVideoCodec,
   ScreenSharePresets,
@@ -12,7 +13,6 @@ import {
   VideoPresets,
   VideoPresets43,
 } from '../track/options';
-import { Track } from '../track/Track';
 
 /** @internal */
 export function mediaTrackToLocalTrack(

package/src/room/track/LocalAudioTrack.ts

@@ -3,8 +3,8 @@ import { TrackEvent } from '../events';
 import { AudioSenderStats, computeBitrate, monitorFrequency } from '../stats';
 import { isWeb } from '../utils';
 import LocalTrack from './LocalTrack';
-import type { AudioCaptureOptions } from './options';
 import { Track } from './Track';
+import type { AudioCaptureOptions } from './options';
 import { constraintsForOptions, detectSilence } from './utils';
 
 export default class LocalAudioTrack extends LocalTrack {

package/src/room/track/LocalTrack.ts

@@ -3,14 +3,14 @@ import DeviceManager from '../DeviceManager';
 import { TrackInvalidError } from '../errors';
 import { TrackEvent } from '../events';
 import {
+  Mutex,
   getEmptyAudioStreamTrack,
   getEmptyVideoStreamTrack,
   isMobile,
-  Mutex,
   sleep,
 } from '../utils';
+import { Track, attachToElement, detachTrack } from './Track';
 import type { VideoCodec } from './options';
-import { attachToElement, detachTrack, Track } from './Track';
 
 const defaultDimensionsTimeout = 2 * 1000;
 

package/src/room/track/LocalTrackPublication.ts

@@ -3,9 +3,9 @@ import { TrackEvent } from '../events';
 import type LocalAudioTrack from './LocalAudioTrack';
 import type LocalTrack from './LocalTrack';
 import type LocalVideoTrack from './LocalVideoTrack';
-import type { TrackPublishOptions } from './options';
 import type { Track } from './Track';
 import { TrackPublication } from './TrackPublication';
+import type { TrackPublishOptions } from './options';
 
 export default class LocalTrackPublication extends TrackPublication {
   track?: LocalTrack = undefined;

package/src/room/track/LocalVideoTrack.ts

@@ -2,11 +2,11 @@ import type { SignalClient } from '../../api/SignalClient';
 import log from '../../logger';
 import { VideoLayer, VideoQuality } from '../../proto/livekit_models';
 import type { SubscribedCodec, SubscribedQuality } from '../../proto/livekit_rtc';
-import { computeBitrate, monitorFrequency, VideoSenderStats } from '../stats';
-import { isFireFox, isMobile, isWeb, Mutex } from '../utils';
+import { VideoSenderStats, computeBitrate, monitorFrequency } from '../stats';
+import { Mutex, isFireFox, isMobile, isWeb } from '../utils';
 import LocalTrack from './LocalTrack';
-import type { VideoCaptureOptions, VideoCodec } from './options';
 import { Track } from './Track';
+import type { VideoCaptureOptions, VideoCodec } from './options';
 import { constraintsForOptions } from './utils';
 
 export class SimulcastTrackInfo {

package/src/room/track/RemoteAudioTrack.ts

@@ -2,9 +2,9 @@ import log from '../../logger';
 import { TrackEvent } from '../events';
 import { AudioReceiverStats, computeBitrate } from '../stats';
 import { supportsSetSinkId } from '../utils';
-import type { AudioOutputOptions } from './options';
 import RemoteTrack from './RemoteTrack';
 import { Track } from './Track';
+import type { AudioOutputOptions } from './options';
 
 export default class RemoteAudioTrack extends RemoteTrack {
   private prevStats?: AudioReceiverStats;

package/src/room/track/RemoteVideoTrack.test.ts

@@ -1,6 +1,6 @@
+import MockMediaStreamTrack from '../../test/MockMediaStreamTrack';
 import { TrackEvent } from '../events';
 import RemoteVideoTrack, { ElementInfo } from './RemoteVideoTrack';
-import MockMediaStreamTrack from '../../test/MockMediaStreamTrack';
 import type { Track } from './Track';
 
 jest.useFakeTimers();