livekit-client 1.15.10 → 2.0.0

package/src/room/Room.ts

@@ -85,9 +85,6 @@ export enum ConnectionState {
 
 const connectionReconcileFrequency = 2 * 1000;
 
-/** @deprecated RoomState has been renamed to [[ConnectionState]] */
-export const RoomState = ConnectionState;
-
 /**
  * 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.
@@ -99,8 +96,10 @@ export const RoomState = ConnectionState;
 class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>) {
   state: ConnectionState = ConnectionState.Disconnected;
 
-  /** map of sid: [[RemoteParticipant]] */
-  participants: Map<string, RemoteParticipant>;
+  /**
+   * map of identity: [[RemoteParticipant]]
+   */
+  remoteParticipants: Map<string, RemoteParticipant>;
 
   /**
    * list of participants that are actively speaking. when this changes
@@ -122,7 +121,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
   private roomInfo?: RoomModel;
 
-  private identityToSid: Map<string, string>;
+  private sidToIdentity: Map<string, string>;
 
   /** connect options of room */
   private connOptions?: InternalRoomConnectOptions;
@@ -141,8 +140,6 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
   private e2eeManager: E2EEManager | undefined;
 
-  private cachedParticipantSids: Array<string>;
-
   private connectionReconcileInterval?: ReturnType<typeof setInterval>;
 
   private regionUrlProvider?: RegionUrlProvider;
@@ -153,6 +150,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
   private log = log;
 
+  private bufferedEvents: Array<any> = [];
+
+  private isResuming: boolean = false;
+
   /**
    * Creates a new Room, the primary construct for a LiveKit session.
    * @param options
@@ -160,9 +161,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   constructor(options?: RoomOptions) {
     super();
     this.setMaxListeners(100);
-    this.participants = new Map();
-    this.cachedParticipantSids = [];
-    this.identityToSid = new Map();
+    this.remoteParticipants = new Map();
+    this.sidToIdentity = new Map();
     this.options = { ...roomOptionDefaults, ...options };
 
     this.log = getLogger(this.options.loggerName ?? LoggerNames.Room);
@@ -246,7 +246,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   private get logContext() {
     return {
       room: this.name,
-      roomSid: this.sid,
+      roomSid: this.roomInfo?.sid,
       identity: this.localParticipant.identity,
     };
   }
@@ -258,9 +258,30 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     return this.roomInfo?.activeRecording ?? false;
   }
 
-  /** server assigned unique room id */
-  get sid(): string {
-    return this.roomInfo?.sid ?? '';
+  /**
+   * server assigned unique room id.
+   * returns once a sid has been issued by the server.
+   */
+  async getSid(): Promise<string> {
+    if (this.state === ConnectionState.Disconnected) {
+      return '';
+    }
+    if (this.roomInfo && this.roomInfo.sid !== '') {
+      return this.roomInfo.sid;
+    }
+    return new Promise((resolve, reject) => {
+      const handleRoomUpdate = (roomInfo: RoomModel) => {
+        if (roomInfo.sid !== '') {
+          this.engine.off(EngineEvent.RoomUpdate, handleRoomUpdate);
+          resolve(roomInfo.sid);
+        }
+      };
+      this.engine.on(EngineEvent.RoomUpdate, handleRoomUpdate);
+      this.once(RoomEvent.Disconnected, () => {
+        this.engine.off(EngineEvent.RoomUpdate, handleRoomUpdate);
+        reject('Room disconnected before room server id was available');
+      });
+    });
   }
 
   /** user assigned name, derived from JWT token */
@@ -309,26 +330,19 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       .on(EngineEvent.DataPacketReceived, this.handleDataPacket)
       .on(EngineEvent.Resuming, () => {
         this.clearConnectionReconcile();
-        if (this.setAndEmitConnectionState(ConnectionState.Reconnecting)) {
-          this.emit(RoomEvent.Reconnecting);
-        }
-        this.cachedParticipantSids = Array.from(this.participants.keys());
+        this.isResuming = true;
+        this.log.info('Resuming signal connection', this.logContext);
       })
       .on(EngineEvent.Resumed, () => {
-        this.setAndEmitConnectionState(ConnectionState.Connected);
-        this.emit(RoomEvent.Reconnected);
         this.registerConnectionReconcile();
+        this.isResuming = false;
+        this.log.info('Resumed signal connection', this.logContext);
         this.updateSubscriptions();
-
-        // once reconnected, figure out if any participants connected during reconnect and emit events for it
-        const diffParticipants = Array.from(this.participants.values()).filter(
-          (p) => !this.cachedParticipantSids.includes(p.sid),
-        );
-        diffParticipants.forEach((p) => this.emit(RoomEvent.ParticipantConnected, p));
-        this.cachedParticipantSids = [];
+        this.emitBufferedEvents();
       })
       .on(EngineEvent.SignalResumed, () => {
-        if (this.state === ConnectionState.Reconnecting) {
+        this.bufferedEvents = [];
+        if (this.state === ConnectionState.Reconnecting || this.isResuming) {
           this.sendSyncState();
         }
       })
@@ -515,7 +529,6 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       token,
       {
         autoSubscribe: connectOptions.autoSubscribe,
-        publishOnly: connectOptions.publishOnly,
         adaptiveStream:
           typeof roomOptions.adaptiveStream === 'object' ? true : roomOptions.adaptiveStream,
         maxRetries: connectOptions.maxRetries,
@@ -578,7 +591,11 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     opts: RoomConnectOptions | undefined,
     abortController: AbortController,
   ) => {
-    if (this.state === ConnectionState.Reconnecting) {
+    if (
+      this.state === ConnectionState.Reconnecting ||
+      this.isResuming ||
+      this.engine?.pendingReconnect
+    ) {
       this.log.info('Reconnection attempt replaced by new connection attempt', this.logContext);
       // make sure we close and recreate the existing engine in order to get rid of any potentially ongoing reconnection attempts
       this.recreateEngine();
@@ -680,7 +697,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       });
       if (
         this.state === ConnectionState.Connecting ||
-        this.state === ConnectionState.Reconnecting
+        this.state === ConnectionState.Reconnecting ||
+        this.isResuming
       ) {
         // try aborting pending connection attempt
         this.log.warn('abort connection attempt', this.logContext);
@@ -714,10 +732,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     if (this.localParticipant.identity === identity) {
       return this.localParticipant;
     }
-    const sid = this.identityToSid.get(identity);
-    if (sid) {
-      return this.participants.get(sid);
-    }
+    return this.remoteParticipants.get(identity);
   }
 
   private clearConnectionFutures() {
@@ -881,17 +896,25 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
           }
           // set the srcObject to null on page hide in order to prevent lock screen controls to show up for it
           dummyAudioEl.srcObject = document.hidden ? null : stream;
+          if (!document.hidden) {
+            this.log.debug(
+              'page visible again, triggering startAudio to resume playback and update playback status',
+              this.logContext,
+            );
+            this.startAudio();
+          }
         });
         document.body.append(dummyAudioEl);
         this.once(RoomEvent.Disconnected, () => {
           dummyAudioEl?.remove();
+          dummyAudioEl = null;
         });
       }
       elements.push(dummyAudioEl);
     }
 
-    this.participants.forEach((p) => {
-      p.audioTracks.forEach((t) => {
+    this.remoteParticipants.forEach((p) => {
+      p.audioTrackPublications.forEach((t) => {
         if (t.track) {
           t.track.attachedElements.forEach((e) => {
             elements.push(e);
@@ -917,8 +940,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
   startVideo = async () => {
     const elements: HTMLMediaElement[] = [];
-    for (const p of this.participants.values()) {
-      p.videoTracks.forEach((tr) => {
+    for (const p of this.remoteParticipants.values()) {
+      p.videoTrackPublications.forEach((tr) => {
         tr.track?.attachedElements.forEach((el) => {
           if (!elements.includes(el)) {
             elements.push(el);
@@ -956,15 +979,6 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     return !this.isVideoPlaybackBlocked;
   }
 
-  /**
-   * Returns the active audio output device used in this room.
-   * @return the previously successfully set audio output device ID or an empty string if the default device is used.
-   * @deprecated use `getActiveDevice('audiooutput')` instead
-   */
-  getActiveAudioOutputDevice(): string {
-    return this.options.audioOutput?.deviceId ?? '';
-  }
-
   getActiveDevice(kind: MediaDeviceKind): string | undefined {
     return this.localParticipant.activeDeviceMap.get(kind);
   }
@@ -987,7 +1001,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       const prevDeviceId = this.options.audioCaptureDefaults!.deviceId;
       this.options.audioCaptureDefaults!.deviceId = deviceConstraint;
       deviceHasChanged = prevDeviceId !== deviceConstraint;
-      const tracks = Array.from(this.localParticipant.audioTracks.values()).filter(
+      const tracks = Array.from(this.localParticipant.audioTrackPublications.values()).filter(
         (track) => track.source === Track.Source.Microphone,
       );
       try {
@@ -1002,7 +1016,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       const prevDeviceId = this.options.videoCaptureDefaults!.deviceId;
       this.options.videoCaptureDefaults!.deviceId = deviceConstraint;
       deviceHasChanged = prevDeviceId !== deviceConstraint;
-      const tracks = Array.from(this.localParticipant.videoTracks.values()).filter(
+      const tracks = Array.from(this.localParticipant.videoTrackPublications.values()).filter(
         (track) => track.source === Track.Source.Camera,
       );
       try {
@@ -1015,8 +1029,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       }
     } else if (kind === 'audiooutput') {
       if (
-        (!supportsSetSinkId() && !this.options.expWebAudioMix) ||
-        (this.options.expWebAudioMix && this.audioContext && !('setSinkId' in this.audioContext))
+        (!supportsSetSinkId() && !this.options.webAudioMix) ||
+        (this.options.webAudioMix && this.audioContext && !('setSinkId' in this.audioContext))
       ) {
         throw new Error('cannot switch audio output, setSinkId not supported');
       }
@@ -1026,12 +1040,12 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       deviceHasChanged = prevDeviceId !== deviceConstraint;
 
       try {
-        if (this.options.expWebAudioMix) {
+        if (this.options.webAudioMix) {
           // @ts-expect-error setSinkId is not yet in the typescript type of AudioContext
           this.audioContext?.setSinkId(deviceId);
         } else {
           await Promise.all(
-            Array.from(this.participants.values()).map((p) => p.setAudioOutput({ deviceId })),
+            Array.from(this.remoteParticipants.values()).map((p) => p.setAudioOutput({ deviceId })),
           );
         }
       } catch (e) {
@@ -1068,10 +1082,13 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.engine?.close();
     /* @ts-ignore */
     this.engine = undefined;
+    this.isResuming = false;
 
     // clear out existing remote participants, since they may have attached
     // the old engine
-    this.participants.clear();
+    this.remoteParticipants.clear();
+    this.sidToIdentity.clear();
+    this.bufferedEvents = [];
     this.maybeCreateEngine();
   }
 
@@ -1105,23 +1122,25 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       return;
     }
     const parts = unpackStreamId(stream.id);
-    const participantId = parts[0];
+    const participantSid = parts[0];
     let streamId = parts[1];
     let trackId = mediaTrack.id;
     // firefox will get streamId (pID|trackId) instead of (pID|streamId) as it doesn't support sync tracks by stream
     // and generates its own track id instead of infer from sdp track id.
     if (streamId && streamId.startsWith('TR')) trackId = streamId;
 
-    if (participantId === this.localParticipant.sid) {
+    if (participantSid === this.localParticipant.sid) {
       this.log.warn('tried to create RemoteParticipant for local participant', this.logContext);
       return;
     }
 
-    const participant = this.participants.get(participantId) as RemoteParticipant | undefined;
+    const participant = Array.from(this.remoteParticipants.values()).find(
+      (p) => p.sid === participantSid,
+    ) as RemoteParticipant | undefined;
 
     if (!participant) {
       this.log.error(
-        `Tried to add a track for a participant, that's not present. Sid: ${participantId}`,
+        `Tried to add a track for a participant, that's not present. Sid: ${participantSid}`,
         this.logContext,
       );
       return;
@@ -1146,9 +1165,12 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
   private handleRestarting = () => {
     this.clearConnectionReconcile();
+    // in case we went from resuming to full-reconnect, make sure to reflect it on the isResuming flag
+    this.isResuming = false;
+
     // also unwind existing participants & existing subscriptions
-    for (const p of this.participants.values()) {
-      this.handleParticipantDisconnected(p.sid, p);
+    for (const p of this.remoteParticipants.values()) {
+      this.handleParticipantDisconnected(p.identity, p);
     }
 
     if (this.setAndEmitConnectionState(ConnectionState.Reconnecting)) {
@@ -1161,8 +1183,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       ...this.logContext,
       region: joinResponse.serverRegion,
     });
+    this.bufferedEvents = [];
 
-    this.cachedParticipantSids = [];
     this.applyJoinResponse(joinResponse);
 
     try {
@@ -1188,15 +1210,13 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.setAndEmitConnectionState(ConnectionState.Connected);
     this.emit(RoomEvent.Reconnected);
     this.registerConnectionReconcile();
-
-    // emit participant connected events after connection has been re-established
-    this.participants.forEach((participant) => {
-      this.emit(RoomEvent.ParticipantConnected, participant);
-    });
+    this.emitBufferedEvents();
   };
 
   private handleDisconnect(shouldStopTracks = true, reason?: DisconnectReason) {
     this.clearConnectionReconcile();
+    this.isResuming = false;
+    this.bufferedEvents = [];
     if (this.state === ConnectionState.Disconnected) {
       return;
     }
@@ -1204,13 +1224,13 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.regionUrl = undefined;
 
     try {
-      this.participants.forEach((p) => {
-        p.tracks.forEach((pub) => {
+      this.remoteParticipants.forEach((p) => {
+        p.trackPublications.forEach((pub) => {
           p.unpublishTrack(pub.trackSid);
         });
       });
 
-      this.localParticipant.tracks.forEach((pub) => {
+      this.localParticipant.trackPublications.forEach((pub) => {
         if (pub.track) {
           this.localParticipant.unpublishTrack(pub.track, shouldStopTracks);
         }
@@ -1235,13 +1255,14 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
           this.onLocalParticipantPermissionsChanged,
         );
 
-      this.localParticipant.tracks.clear();
-      this.localParticipant.videoTracks.clear();
-      this.localParticipant.audioTracks.clear();
+      this.localParticipant.trackPublications.clear();
+      this.localParticipant.videoTrackPublications.clear();
+      this.localParticipant.audioTrackPublications.clear();
 
-      this.participants.clear();
+      this.remoteParticipants.clear();
+      this.sidToIdentity.clear();
       this.activeSpeakers = [];
-      if (this.audioContext && typeof this.options.expWebAudioMix === 'boolean') {
+      if (this.audioContext && typeof this.options.webAudioMix === 'boolean') {
         this.audioContext.close();
         this.audioContext = undefined;
       }
@@ -1265,39 +1286,32 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         return;
       }
 
-      // ensure identity <=> sid mapping
-      const sid = this.identityToSid.get(info.identity);
-      if (sid && sid !== info.sid) {
-        // sid had changed, need to remove previous participant
-        this.handleParticipantDisconnected(sid, this.participants.get(sid));
+      // LiveKit server doesn't send identity info prior to version 1.5.2 in disconnect updates
+      // so we try to map an empty identity to an already known sID manually
+      if (info.identity === '') {
+        info.identity = this.sidToIdentity.get(info.sid) ?? '';
       }
 
-      let remoteParticipant = this.participants.get(info.sid);
-      const isNewParticipant = !remoteParticipant;
+      let remoteParticipant = this.remoteParticipants.get(info.identity);
 
       // when it's disconnected, send updates
       if (info.state === ParticipantInfo_State.DISCONNECTED) {
-        this.handleParticipantDisconnected(info.sid, remoteParticipant);
+        this.handleParticipantDisconnected(info.identity, remoteParticipant);
       } else {
         // create participant if doesn't exist
-        remoteParticipant = this.getOrCreateParticipant(info.sid, info);
-        if (!isNewParticipant) {
-          // just update, no events
-          remoteParticipant.updateInfo(info);
-        }
+        remoteParticipant = this.getOrCreateParticipant(info.identity, info);
       }
     });
   };
 
-  private handleParticipantDisconnected(sid: string, participant?: RemoteParticipant) {
+  private handleParticipantDisconnected(identity: string, participant?: RemoteParticipant) {
     // remove and send event
-    this.participants.delete(sid);
+    this.remoteParticipants.delete(identity);
     if (!participant) {
       return;
     }
 
-    this.identityToSid.delete(participant.identity);
-    participant.tracks.forEach((publication) => {
+    participant.trackPublications.forEach((publication) => {
       participant.unpublishTrack(publication.trackSid, true);
     });
     this.emit(RoomEvent.ParticipantDisconnected, participant);
@@ -1314,7 +1328,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         this.localParticipant.setIsSpeaking(true);
         activeSpeakers.push(this.localParticipant);
       } else {
-        const p = this.participants.get(speaker.sid);
+        const p = this.getRemoteParticipantBySid(speaker.sid);
         if (p) {
           p.audioLevel = speaker.level;
           p.setIsSpeaking(true);
@@ -1327,7 +1341,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       this.localParticipant.audioLevel = 0;
       this.localParticipant.setIsSpeaking(false);
     }
-    this.participants.forEach((p) => {
+    this.remoteParticipants.forEach((p) => {
       if (!seenSids[p.sid]) {
         p.audioLevel = 0;
         p.setIsSpeaking(false);
@@ -1345,7 +1359,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       lastSpeakers.set(p.sid, p);
     });
     speakerUpdates.forEach((speaker) => {
-      let p: Participant | undefined = this.participants.get(speaker.sid);
+      let p: Participant | undefined = this.getRemoteParticipantBySid(speaker.sid);
       if (speaker.sid === this.localParticipant.sid) {
         p = this.localParticipant;
       }
@@ -1369,11 +1383,11 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
   private handleStreamStateUpdate = (streamStateUpdate: StreamStateUpdate) => {
     streamStateUpdate.streamStates.forEach((streamState) => {
-      const participant = this.participants.get(streamState.participantSid);
+      const participant = this.getRemoteParticipantBySid(streamState.participantSid);
       if (!participant) {
         return;
       }
-      const pub = participant.getTrackPublication(streamState.trackSid);
+      const pub = participant.getTrackPublicationBySid(streamState.trackSid);
       if (!pub || !pub.track) {
         return;
       }
@@ -1389,11 +1403,11 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   };
 
   private handleSubscriptionPermissionUpdate = (update: SubscriptionPermissionUpdate) => {
-    const participant = this.participants.get(update.participantSid);
+    const participant = this.getRemoteParticipantBySid(update.participantSid);
     if (!participant) {
       return;
     }
-    const pub = participant.getTrackPublication(update.trackSid);
+    const pub = participant.getTrackPublicationBySid(update.trackSid);
     if (!pub) {
       return;
     }
@@ -1402,13 +1416,13 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   };
 
   private handleSubscriptionError = (update: SubscriptionResponse) => {
-    const participant = Array.from(this.participants.values()).find((p) =>
-      p.tracks.has(update.trackSid),
+    const participant = Array.from(this.remoteParticipants.values()).find((p) =>
+      p.trackPublications.has(update.trackSid),
     );
     if (!participant) {
       return;
     }
-    const pub = participant.getTrackPublication(update.trackSid);
+    const pub = participant.getTrackPublicationBySid(update.trackSid);
     if (!pub) {
       return;
     }
@@ -1418,7 +1432,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
   private handleDataPacket = (userPacket: UserPacket, kind: DataPacket_Kind) => {
     // find the participant
-    const participant = this.participants.get(userPacket.participantSid);
+    const participant = this.remoteParticipants.get(userPacket.participantIdentity);
 
     this.emit(RoomEvent.DataReceived, userPacket.payload, participant, kind, userPacket.topic);
 
@@ -1478,7 +1492,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         this.localParticipant.setConnectionQuality(info.quality);
         return;
       }
-      const participant = this.participants.get(info.participantSid);
+      const participant = this.getRemoteParticipantBySid(info.participantSid);
       if (participant) {
         participant.setConnectionQuality(info.quality);
       }
@@ -1486,12 +1500,9 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   };
 
   private async acquireAudioContext() {
-    if (
-      typeof this.options.expWebAudioMix !== 'boolean' &&
-      this.options.expWebAudioMix.audioContext
-    ) {
+    if (typeof this.options.webAudioMix !== 'boolean' && this.options.webAudioMix.audioContext) {
       // override audio context with custom audio context if supplied by user
-      this.audioContext = this.options.expWebAudioMix.audioContext;
+      this.audioContext = this.options.webAudioMix.audioContext;
     } else if (!this.audioContext || this.audioContext.state === 'closed') {
       // by using an AudioContext, it reduces lag on audio elements
       // https://stackoverflow.com/questions/9811429/html5-audio-tag-on-safari-has-a-delay/54119854#54119854
@@ -1508,8 +1519,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       }
     }
 
-    if (this.options.expWebAudioMix) {
-      this.participants.forEach((participant) => participant.setAudioContext(this.audioContext));
+    if (this.options.webAudioMix) {
+      this.remoteParticipants.forEach((participant) =>
+        participant.setAudioContext(this.audioContext),
+      );
     }
 
     this.localParticipant.setAudioContext(this.audioContext);
@@ -1521,17 +1534,17 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
   }
 
-  private createParticipant(id: string, info?: ParticipantInfo): RemoteParticipant {
+  private createParticipant(identity: string, info?: ParticipantInfo): RemoteParticipant {
     let participant: RemoteParticipant;
     if (info) {
       participant = RemoteParticipant.fromParticipantInfo(this.engine.client, info);
     } else {
-      participant = new RemoteParticipant(this.engine.client, id, '', undefined, undefined, {
+      participant = new RemoteParticipant(this.engine.client, '', identity, undefined, undefined, {
         loggerContextCb: () => this.logContext,
         loggerName: this.options.loggerName,
       });
     }
-    if (this.options.expWebAudioMix) {
+    if (this.options.webAudioMix) {
       participant.setAudioContext(this.audioContext);
     }
     if (this.options.audioOutput?.deviceId) {
@@ -1542,14 +1555,21 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     return participant;
   }
 
-  private getOrCreateParticipant(id: string, info: ParticipantInfo): RemoteParticipant {
-    if (this.participants.has(id)) {
-      return this.participants.get(id) as RemoteParticipant;
+  private getOrCreateParticipant(identity: string, info: ParticipantInfo): RemoteParticipant {
+    if (this.remoteParticipants.has(identity)) {
+      const existingParticipant = this.remoteParticipants.get(identity)!;
+      if (info) {
+        const wasUpdated = existingParticipant.updateInfo(info);
+        if (wasUpdated) {
+          this.sidToIdentity.set(info.sid, info.identity);
+        }
+      }
+      return existingParticipant;
     }
-    const participant = this.createParticipant(id, info);
-    this.participants.set(id, participant);
+    const participant = this.createParticipant(identity, info);
+    this.remoteParticipants.set(identity, participant);
 
-    this.identityToSid.set(info.identity, info.sid);
+    this.sidToIdentity.set(info.sid, info.identity);
     // if we have valid info and the participant wasn't in the map before, we can assume the participant is new
     // firing here to make sure that `ParticipantConnected` fires before the initial track events
     this.emitWhenConnected(RoomEvent.ParticipantConnected, participant);
@@ -1635,11 +1655,11 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   }
 
   private sendSyncState() {
-    const remoteTracks = Array.from(this.participants.values()).reduce((acc, participant) => {
-      acc.push(...(participant.getTracks() as RemoteTrackPublication[])); // FIXME would be nice to have this return RemoteTrackPublications directly instead of the type cast
+    const remoteTracks = Array.from(this.remoteParticipants.values()).reduce((acc, participant) => {
+      acc.push(...(participant.getTrackPublications() as RemoteTrackPublication[])); // FIXME would be nice to have this return RemoteTrackPublications directly instead of the type cast
       return acc;
     }, [] as RemoteTrackPublication[]);
-    const localTracks = this.localParticipant.getTracks() as LocalTrackPublication[]; // FIXME would be nice to have this return LocalTrackPublications directly instead of the type cast
+    const localTracks = this.localParticipant.getTrackPublications() as LocalTrackPublication[]; // FIXME would be nice to have this return LocalTrackPublications directly instead of the type cast
     this.engine.sendSyncState(remoteTracks, localTracks);
   }
 
@@ -1648,8 +1668,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
    * subscription settings.
    */
   private updateSubscriptions() {
-    for (const p of this.participants.values()) {
-      for (const pub of p.videoTracks.values()) {
+    for (const p of this.remoteParticipants.values()) {
+      for (const pub of p.videoTrackPublications.values()) {
         if (pub.isSubscribed && pub instanceof RemoteTrackPublication) {
           pub.emitTrackUpdate();
         }
@@ -1657,6 +1677,13 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
   }
 
+  private getRemoteParticipantBySid(sid: string): RemoteParticipant | undefined {
+    const identity = this.sidToIdentity.get(sid);
+    if (identity) {
+      return this.remoteParticipants.get(identity);
+    }
+  }
+
   private registerConnectionReconcile() {
     this.clearConnectionReconcile();
     let consecutiveFailures = 0;
@@ -1707,11 +1734,26 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     return true;
   }
 
+  private emitBufferedEvents() {
+    this.bufferedEvents.forEach(([ev, args]) => {
+      this.emit(ev, ...args);
+    });
+    this.bufferedEvents = [];
+  }
+
   private emitWhenConnected<E extends keyof RoomEventCallbacks>(
     event: E,
     ...args: Parameters<RoomEventCallbacks[E]>
   ): boolean {
-    if (this.state === ConnectionState.Connected) {
+    if (
+      this.state === ConnectionState.Reconnecting ||
+      this.isResuming ||
+      !this.engine ||
+      this.engine.pendingReconnect
+    ) {
+      // in case the room is reconnecting, buffer the events by firing them later after emitting RoomEvent.Reconnected
+      this.bufferedEvents.push([event, args]);
+    } else if (this.state === ConnectionState.Connected) {
       return this.emit(event, ...args);
     }
     return false;
@@ -1943,8 +1985,6 @@ export type RoomEventCallbacks = {
   reconnecting: () => void;
   reconnected: () => void;
   disconnected: (reason?: DisconnectReason) => void;
-  /** @deprecated stateChanged has been renamed to connectionStateChanged */
-  stateChanged: (state: ConnectionState) => void;
   connectionStateChanged: (state: ConnectionState) => void;
   mediaDevicesChanged: () => void;
   participantConnected: (participant: RemoteParticipant) => void;