livekit-client 2.13.4 → 2.13.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "2.13.4",
+  "version": "2.13.6",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",
@@ -37,7 +37,7 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@livekit/mutex": "1.1.1",
-    "@livekit/protocol": "1.38.0",
+    "@livekit/protocol": "1.39.2",
     "events": "^3.3.0",
     "loglevel": "^1.9.2",
     "sdp-transform": "^2.15.0",
@@ -50,13 +50,13 @@
     "@types/dom-mediacapture-record": "^1"
   },
   "devDependencies": {
-    "@babel/core": "7.27.1",
+    "@babel/core": "7.27.4",
     "@babel/preset-env": "7.27.2",
     "@bufbuild/protoc-gen-es": "^1.10.0",
     "@changesets/cli": "2.29.4",
     "@livekit/changesets-changelog-github": "^0.0.4",
     "@rollup/plugin-babel": "6.0.4",
-    "@rollup/plugin-commonjs": "28.0.3",
+    "@rollup/plugin-commonjs": "28.0.5",
     "@rollup/plugin-json": "6.1.0",
     "@rollup/plugin-node-resolve": "16.0.1",
     "@rollup/plugin-terser": "^0.4.4",
@@ -64,25 +64,25 @@
     "@size-limit/webpack": "^11.2.0",
     "@trivago/prettier-plugin-sort-imports": "^5.0.0",
     "@types/events": "^3.0.3",
-    "@types/sdp-transform": "2.4.9",
+    "@types/sdp-transform": "2.4.10",
     "@types/ua-parser-js": "0.7.39",
     "@typescript-eslint/eslint-plugin": "7.18.0",
     "@typescript-eslint/parser": "7.18.0",
     "downlevel-dts": "^0.11.0",
     "eslint": "8.57.1",
     "eslint-config-airbnb-typescript": "18.0.0",
-    "eslint-config-prettier": "9.1.0",
+    "eslint-config-prettier": "10.1.5",
     "eslint-plugin-ecmascript-compat": "^3.2.1",
     "eslint-plugin-import": "2.31.0",
     "gh-pages": "6.3.0",
     "happy-dom": "^17.2.0",
     "jsdom": "^26.1.0",
     "prettier": "^3.4.2",
-    "rollup": "4.41.0",
+    "rollup": "4.43.0",
     "rollup-plugin-delete": "^2.1.0",
     "rollup-plugin-typescript2": "0.36.0",
     "size-limit": "^11.2.0",
-    "typedoc": "0.28.4",
+    "typedoc": "0.28.5",
     "typedoc-plugin-no-inherit": "1.6.1",
     "typescript": "5.8.3",
     "vite": "5.4.19",

package/src/api/SignalClient.ts

@@ -110,9 +110,9 @@ export class SignalClient {
 
   onClose?: (reason: string) => void;
 
-  onAnswer?: (sd: RTCSessionDescriptionInit) => void;
+  onAnswer?: (sd: RTCSessionDescriptionInit, offerId: number) => void;
 
-  onOffer?: (sd: RTCSessionDescriptionInit) => void;
+  onOffer?: (sd: RTCSessionDescriptionInit, offerId: number) => void;
 
   // when a new ICE candidate is made available
   onTrickle?: (sd: RTCIceCandidateInit, target: SignalTarget) => void;
@@ -246,12 +246,12 @@ export class SignalClient {
     // clear ping interval and restart it once reconnected
     this.clearPingInterval();
 
-    const res = await this.connect(url, token, {
+    const res = (await this.connect(url, token, {
       ...this.options,
       reconnect: true,
       sid,
       reconnectReason: reason,
-    });
+    })) as ReconnectResponse;
     return res;
   }
 
@@ -506,20 +506,20 @@ export class SignalClient {
   }
 
   // initial offer after joining
-  sendOffer(offer: RTCSessionDescriptionInit) {
+  sendOffer(offer: RTCSessionDescriptionInit, offerId: number) {
     this.log.debug('sending offer', { ...this.logContext, offerSdp: offer.sdp });
     this.sendRequest({
       case: 'offer',
-      value: toProtoSessionDescription(offer),
+      value: toProtoSessionDescription(offer, offerId),
     });
   }
 
   // answer a server-initiated offer
-  sendAnswer(answer: RTCSessionDescriptionInit) {
+  sendAnswer(answer: RTCSessionDescriptionInit, offerId: number) {
     this.log.debug('sending answer', { ...this.logContext, answerSdp: answer.sdp });
     return this.sendRequest({
       case: 'answer',
-      value: toProtoSessionDescription(answer),
+      value: toProtoSessionDescription(answer, offerId),
     });
   }
 
@@ -700,12 +700,12 @@ export class SignalClient {
     if (msg.case === 'answer') {
       const sd = fromProtoSessionDescription(msg.value);
       if (this.onAnswer) {
-        this.onAnswer(sd);
+        this.onAnswer(sd, msg.value.id);
       }
     } else if (msg.case === 'offer') {
       const sd = fromProtoSessionDescription(msg.value);
       if (this.onOffer) {
-        this.onOffer(sd);
+        this.onOffer(sd, msg.value.id);
       }
     } else if (msg.case === 'trickle') {
       const candidate: RTCIceCandidateInit = JSON.parse(msg.value.candidateInit!);
@@ -888,10 +888,12 @@ function fromProtoSessionDescription(sd: SessionDescription): RTCSessionDescript
 
 export function toProtoSessionDescription(
   rsd: RTCSessionDescription | RTCSessionDescriptionInit,
+  id?: number,
 ): SessionDescription {
   const sd = new SessionDescription({
     sdp: rsd.sdp!,
     type: rsd.type!,
+    id,
   });
   return sd;
 }

package/src/connectionHelper/checks/publishVideo.ts

@@ -83,6 +83,7 @@ export class PublishVideoCheck extends Checker {
       video.play();
     });
 
+    stream.getTracks().forEach((t) => t.stop());
     video.remove();
   }
 }

package/src/e2ee/E2eeManager.ts

@@ -371,6 +371,7 @@ export class E2EEManager
       let writable: WritableStream = receiver.writableStream;
       // @ts-ignore
       let readable: ReadableStream = receiver.readableStream;
+
       if (!writable || !readable) {
         // @ts-ignore
         const receiverStreams = receiver.createEncodedStreams();
@@ -390,6 +391,7 @@ export class E2EEManager
           trackId: trackId,
           codec,
           participantIdentity: participantIdentity,
+          isReuse: E2EE_FLAG in receiver,
         },
       };
       this.worker.postMessage(msg, [readable, writable]);
@@ -435,6 +437,7 @@ export class E2EEManager
           codec,
           trackId,
           participantIdentity: this.room.localParticipant.identity,
+          isReuse: false,
         },
       };
       this.worker.postMessage(msg, [senderStreams.readable, senderStreams.writable]);

package/src/e2ee/types.ts

@@ -49,6 +49,7 @@ export interface EncodeMessage extends BaseMessage {
     writableStream: WritableStream;
     trackId: string;
     codec?: VideoCodec;
+    isReuse: boolean;
   };
 }
 

package/src/e2ee/worker/FrameCryptor.ts

@@ -69,6 +69,8 @@ export class FrameCryptor extends BaseFrameCryptor {
 
   private detectedCodec?: VideoCodec;
 
+  private isTransformActive: boolean = false;
+
   constructor(opts: {
     keys: ParticipantKeyHandler;
     participantIdentity: string;
@@ -159,6 +161,7 @@ export class FrameCryptor extends BaseFrameCryptor {
     readable: ReadableStream<RTCEncodedVideoFrame | RTCEncodedAudioFrame>,
     writable: WritableStream<RTCEncodedVideoFrame | RTCEncodedAudioFrame>,
     trackId: string,
+    isReuse: boolean,
     codec?: VideoCodec,
   ) {
     if (codec) {
@@ -173,11 +176,20 @@ export class FrameCryptor extends BaseFrameCryptor {
       ...this.logContext,
     });
 
+    if (isReuse && this.isTransformActive) {
+      workerLogger.debug('reuse transform', {
+        ...this.logContext,
+      });
+      return;
+    }
+
     const transformFn = operation === 'encode' ? this.encodeFunction : this.decodeFunction;
     const transformStream = new TransformStream({
       transform: transformFn.bind(this),
     });
 
+    this.isTransformActive = true;
+
     readable
       .pipeThrough(transformStream)
       .pipeTo(writable)
@@ -189,6 +201,9 @@ export class FrameCryptor extends BaseFrameCryptor {
             ? e
             : new CryptorError(e.message, undefined, this.participantIdentity),
         );
+      })
+      .finally(() => {
+        this.isTransformActive = false;
       });
     this.trackId = trackId;
   }

package/src/e2ee/worker/e2ee.worker.ts

@@ -65,6 +65,7 @@ onmessage = (ev) => {
           data.readableStream,
           data.writableStream,
           data.trackId,
+          data.isReuse,
           data.codec,
         );
         break;
@@ -75,6 +76,7 @@ onmessage = (ev) => {
           data.readableStream,
           data.writableStream,
           data.trackId,
+          data.isReuse,
           data.codec,
         );
         break;

package/src/room/PCTransport.ts

@@ -50,6 +50,8 @@ export default class PCTransport extends EventEmitter {
 
   private ddExtID = 0;
 
+  private latestOfferId: number = 0;
+
   pendingCandidates: RTCIceCandidateInit[] = [];
 
   restartingIce: boolean = false;
@@ -62,7 +64,7 @@ export default class PCTransport extends EventEmitter {
 
   remoteNackMids: string[] = [];
 
-  onOffer?: (offer: RTCSessionDescriptionInit) => void;
+  onOffer?: (offer: RTCSessionDescriptionInit, offerId: number) => void;
 
   onIceCandidate?: (candidate: RTCIceCandidate) => void;
 
@@ -137,7 +139,20 @@ export default class PCTransport extends EventEmitter {
     this.pendingCandidates.push(candidate);
   }
 
-  async setRemoteDescription(sd: RTCSessionDescriptionInit): Promise<void> {
+  async setRemoteDescription(sd: RTCSessionDescriptionInit, offerId: number): Promise<boolean> {
+    if (
+      sd.type === 'answer' &&
+      this.latestOfferId > 0 &&
+      offerId > 0 &&
+      offerId !== this.latestOfferId
+    ) {
+      this.log.warn('ignoring answer for old offer', {
+        ...this.logContext,
+        offerId,
+        latestOfferId: this.latestOfferId,
+      });
+      return false;
+    }
     let mungedSDP: string | undefined = undefined;
     if (sd.type === 'offer') {
       let { stereoMids, nackMids } = extractStereoAndNackAudioFromOffer(sd);
@@ -218,6 +233,7 @@ export default class PCTransport extends EventEmitter {
         });
       }
     }
+    return true;
   }
 
   // debounced negotiate interface
@@ -235,6 +251,9 @@ export default class PCTransport extends EventEmitter {
   }, debounceInterval);
 
   async createAndSendOffer(options?: RTCOfferOptions) {
+    // increase the offer id at the start to ensure the offer is always > 0 so that we can use 0 as a default value for legacy behavior
+    const offerId = this.latestOfferId + 1;
+    this.latestOfferId = offerId;
     if (this.onOffer === undefined) {
       return;
     }
@@ -317,9 +336,16 @@ export default class PCTransport extends EventEmitter {
         });
       }
     });
-
+    if (this.latestOfferId > offerId) {
+      this.log.warn('latestOfferId mismatch', {
+        ...this.logContext,
+        latestOfferId: this.latestOfferId,
+        offerId,
+      });
+      return;
+    }
     await this.setMungedSDP(offer, write(sdpParsed));
-    this.onOffer(offer);
+    this.onOffer(offer, this.latestOfferId);
   }
 
   async createAndSetAnswer(): Promise<RTCSessionDescriptionInit> {

package/src/room/PCTransportManager.ts

@@ -48,7 +48,7 @@ export class PCTransportManager {
 
   public onTrack?: (ev: RTCTrackEvent) => void;
 
-  public onPublisherOffer?: (offer: RTCSessionDescriptionInit) => void;
+  public onPublisherOffer?: (offer: RTCSessionDescriptionInit, offerId: number) => void;
 
   private isPublisherConnectionRequired: boolean;
 
@@ -96,8 +96,8 @@ export class PCTransportManager {
     this.subscriber.onTrack = (ev) => {
       this.onTrack?.(ev);
     };
-    this.publisher.onOffer = (offer) => {
-      this.onPublisherOffer?.(offer);
+    this.publisher.onOffer = (offer, offerId) => {
+      this.onPublisherOffer?.(offer, offerId);
     };
 
     this.state = PCTransportState.NEW;
@@ -126,8 +126,8 @@ export class PCTransportManager {
     return this.publisher.createAndSendOffer(options);
   }
 
-  setPublisherAnswer(sd: RTCSessionDescriptionInit) {
-    return this.publisher.setRemoteDescription(sd);
+  setPublisherAnswer(sd: RTCSessionDescriptionInit, offerId: number) {
+    return this.publisher.setRemoteDescription(sd, offerId);
   }
 
   removeTrack(sender: RTCRtpSender) {
@@ -168,7 +168,7 @@ export class PCTransportManager {
     }
   }
 
-  async createSubscriberAnswerFromOffer(sd: RTCSessionDescriptionInit) {
+  async createSubscriberAnswerFromOffer(sd: RTCSessionDescriptionInit, offerId: number) {
     this.log.debug('received server offer', {
       ...this.logContext,
       RTCSdpType: sd.type,
@@ -177,7 +177,10 @@ export class PCTransportManager {
     });
     const unlock = await this.remoteOfferLock.lock();
     try {
-      await this.subscriber.setRemoteDescription(sd);
+      const success = await this.subscriber.setRemoteDescription(sd, offerId);
+      if (!success) {
+        return undefined;
+      }
 
       // answer the offer
       const answer = await this.subscriber.createAndSetAnswer();

package/src/room/RTCEngine.ts

@@ -5,6 +5,7 @@ import {
   ClientConfiguration,
   type ConnectionQualityUpdate,
   DataChannelInfo,
+  DataChannelReceiveState,
   DataPacket,
   DataPacket_Kind,
   DisconnectReason,
@@ -44,6 +45,8 @@ import {
 } from '../api/SignalClient';
 import log, { LoggerNames, getLogger } from '../logger';
 import type { InternalRoomOptions } from '../options';
+import { DataPacketBuffer } from '../utils/dataPacketBuffer';
+import { TTLMap } from '../utils/ttlmap';
 import PCTransport, { PCEvents } from './PCTransport';
 import { PCTransportManager, PCTransportState } from './PCTransportManager';
 import type { ReconnectContext, ReconnectPolicy } from './ReconnectPolicy';
@@ -81,6 +84,7 @@ const lossyDataChannel = '_lossy';
 const reliableDataChannel = '_reliable';
 const minReconnectWait = 2 * 1000;
 const leaveReconnect = 'leave-reconnect';
+const reliabeReceiveStateTTL = 30_000;
 
 enum PCState {
   New,
@@ -107,6 +111,11 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
    */
   latestJoinResponse?: JoinResponse;
 
+  /**
+   * @internal
+   */
+  latestRemoteOfferId: number = 0;
+
   get isClosed() {
     return this._isClosed;
   }
@@ -178,6 +187,12 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
   private publisherConnectionPromise: Promise<void> | undefined;
 
+  private reliableDataSequence: number = 1;
+
+  private reliableMessageBuffer = new DataPacketBuffer();
+
+  private reliableReceivedState: TTLMap<string, number> = new TTLMap(reliabeReceiveStateTTL);
+
   constructor(private options: InternalRoomOptions) {
     super();
     this.log = getLogger(options.loggerName ?? LoggerNames.Engine);
@@ -310,6 +325,9 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     this.lossyDCSub = undefined;
     this.reliableDC = undefined;
     this.reliableDCSub = undefined;
+    this.reliableMessageBuffer = new DataPacketBuffer();
+    this.reliableDataSequence = 1;
+    this.reliableReceivedState.clear();
   }
 
   async cleanupClient() {
@@ -407,8 +425,8 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       this.client.sendIceCandidate(candidate, target);
     };
 
-    this.pcManager.onPublisherOffer = (offer) => {
-      this.client.sendOffer(offer);
+    this.pcManager.onPublisherOffer = (offer, offerId) => {
+      this.client.sendOffer(offer, offerId);
     };
 
     this.pcManager.onDataChannel = this.handleDataChannel;
@@ -463,12 +481,12 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
   private setupSignalClientCallbacks() {
     // configure signaling client
-    this.client.onAnswer = async (sd) => {
+    this.client.onAnswer = async (sd, offerId) => {
       if (!this.pcManager) {
         return;
       }
       this.log.debug('received server answer', { ...this.logContext, RTCSdpType: sd.type });
-      await this.pcManager.setPublisherAnswer(sd);
+      await this.pcManager.setPublisherAnswer(sd, offerId);
     };
 
     // add candidate on trickle
@@ -481,12 +499,15 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     };
 
     // when server creates an offer for the client
-    this.client.onOffer = async (sd) => {
+    this.client.onOffer = async (sd, offerId) => {
+      this.latestRemoteOfferId = offerId;
       if (!this.pcManager) {
         return;
       }
-      const answer = await this.pcManager.createSubscriberAnswerFromOffer(sd);
-      this.client.sendAnswer(answer);
+      const answer = await this.pcManager.createSubscriberAnswerFromOffer(sd, offerId);
+      if (answer) {
+        this.client.sendAnswer(answer, offerId);
+      }
     };
 
     this.client.onLocalTrackPublished = (res: TrackPublishedResponse) => {
@@ -677,6 +698,15 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       }
       const dp = DataPacket.fromBinary(new Uint8Array(buffer));
 
+      if (dp.sequence > 0 && dp.participantSid !== '') {
+        const lastSeq = this.reliableReceivedState.get(dp.participantSid);
+        if (lastSeq && dp.sequence <= lastSeq) {
+          // ignore duplicate or out-of-order packets in reliable channel
+          return;
+        }
+        this.reliableReceivedState.set(dp.participantSid, dp.sequence);
+      }
+
       if (dp.value?.case === 'speaker') {
         // dispatch speaker updates
         this.emit(EngineEvent.ActiveSpeakersUpdate, dp.value.value.speakers);
@@ -1033,6 +1063,9 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     if (res) {
       const rtcConfig = this.makeRTCConfiguration(res);
       this.pcManager.updateConfiguration(rtcConfig);
+      if (this.latestJoinResponse) {
+        this.latestJoinResponse.serverInfo = res.serverInfo;
+      }
     } else {
       this.log.warn('Did not receive reconnect response', this.logContext);
     }
@@ -1059,6 +1092,10 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       this.createDataChannels();
     }
 
+    if (res?.lastMessageSeq) {
+      this.resendReliableMessagesForResume(res.lastMessageSeq);
+    }
+
     // resume success
     this.emit(EngineEvent.Resumed);
   }
@@ -1151,19 +1188,42 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
   /* @internal */
   async sendDataPacket(packet: DataPacket, kind: DataPacket_Kind) {
-    const msg = packet.toBinary();
-
     // make sure we do have a data connection
     await this.ensurePublisherConnected(kind);
 
+    if (kind === DataPacket_Kind.RELIABLE) {
+      packet.sequence = this.reliableDataSequence;
+      this.reliableDataSequence += 1;
+    }
+    const msg = packet.toBinary();
     const dc = this.dataChannelForKind(kind);
     if (dc) {
+      if (kind === DataPacket_Kind.RELIABLE) {
+        this.reliableMessageBuffer.push({ data: msg, sequence: packet.sequence });
+      }
+
+      if (this.attemptingReconnect) {
+        return;
+      }
+
       dc.send(msg);
     }
 
     this.updateAndEmitDCBufferStatus(kind);
   }
 
+  private async resendReliableMessagesForResume(lastMessageSeq: number) {
+    await this.ensurePublisherConnected(DataPacket_Kind.RELIABLE);
+    const dc = this.dataChannelForKind(DataPacket_Kind.RELIABLE);
+    if (dc) {
+      this.reliableMessageBuffer.popToSequence(lastMessageSeq);
+      this.reliableMessageBuffer.getAll().forEach((msg) => {
+        dc.send(msg.data);
+      });
+    }
+    this.updateAndEmitDCBufferStatus(DataPacket_Kind.RELIABLE);
+  }
+
   private updateAndEmitDCBufferStatus = (kind: DataPacket_Kind) => {
     const status = this.isBufferStatusLow(kind);
     if (typeof status !== 'undefined' && status !== this.dcBufferStatus.get(kind)) {
@@ -1175,6 +1235,9 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
   private isBufferStatusLow = (kind: DataPacket_Kind): boolean | undefined => {
     const dc = this.dataChannelForKind(kind);
     if (dc) {
+      if (kind === DataPacket_Kind.RELIABLE) {
+        this.reliableMessageBuffer.alignBufferedAmount(dc.bufferedAmount);
+      }
       return dc.bufferedAmount <= dc.bufferedAmountLowThreshold;
     }
   };
@@ -1409,6 +1472,12 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         publishTracks: getTrackPublicationInfo(localTracks),
         dataChannels: this.dataChannelsInfo(),
         trackSidsDisabled,
+        datachannelReceiveStates: this.reliableReceivedState.map((seq, sid) => {
+          return new DataChannelReceiveState({
+            publisherSid: sid,
+            lastSeq: seq,
+          });
+        }),
       }),
     );
   }

package/src/room/Room.ts

@@ -601,7 +601,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
           this.handleParticipantDisconnected(identity, participant);
         });
 
-        this.emit(RoomEvent.Moved, roomMoved.room!.name, roomMoved.token);
+        this.emit(RoomEvent.Moved, roomMoved.room!.name);
 
         if (roomMoved.participant) {
           this.handleParticipantUpdates([roomMoved.participant, ...roomMoved.otherParticipants]);
@@ -1301,10 +1301,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
    */
   async switchActiveDevice(kind: MediaDeviceKind, deviceId: string, exact: boolean = true) {
     let success = true;
-    let needsUpdateWithoutTracks = false;
+    let shouldTriggerImmediateDeviceChange = false;
     const deviceConstraint = exact ? { exact: deviceId } : deviceId;
     if (kind === 'audioinput') {
-      needsUpdateWithoutTracks = this.localParticipant.audioTrackPublications.size === 0;
+      shouldTriggerImmediateDeviceChange = this.localParticipant.audioTrackPublications.size === 0;
       const prevDeviceId =
         this.getActiveDevice(kind) ?? this.options.audioCaptureDefaults!.deviceId;
       this.options.audioCaptureDefaults!.deviceId = deviceConstraint;
@@ -1319,8 +1319,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         this.options.audioCaptureDefaults!.deviceId = prevDeviceId;
         throw e;
       }
+      const isMuted = tracks.some((t) => t.track?.isMuted ?? false);
+      if (success && isMuted) shouldTriggerImmediateDeviceChange = true;
     } else if (kind === 'videoinput') {
-      needsUpdateWithoutTracks = this.localParticipant.videoTrackPublications.size === 0;
+      shouldTriggerImmediateDeviceChange = this.localParticipant.videoTrackPublications.size === 0;
       const prevDeviceId =
         this.getActiveDevice(kind) ?? this.options.videoCaptureDefaults!.deviceId;
       this.options.videoCaptureDefaults!.deviceId = deviceConstraint;
@@ -1336,6 +1338,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         throw e;
       }
     } else if (kind === 'audiooutput') {
+      shouldTriggerImmediateDeviceChange = true;
       if (
         (!supportsSetSinkId() && !this.options.webAudioMix) ||
         (this.options.webAudioMix && this.audioContext && !('setSinkId' in this.audioContext))
@@ -1367,12 +1370,9 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         throw e;
       }
     }
-    if (needsUpdateWithoutTracks || kind === 'audiooutput') {
-      // if there are not active tracks yet or we're switching audiooutput, we need to manually update the active device map here as changing audio output won't result in a track restart
-      this.localParticipant.activeDeviceMap.set(
-        kind,
-        (kind === 'audiooutput' && this.options.audioOutput?.deviceId) || deviceId,
-      );
+
+    if (shouldTriggerImmediateDeviceChange) {
+      this.localParticipant.activeDeviceMap.set(kind, deviceId);
       this.emit(RoomEvent.ActiveDeviceChanged, kind, deviceId);
     }
 
@@ -2649,7 +2649,7 @@ export type RoomEventCallbacks = {
   reconnected: () => void;
   disconnected: (reason?: DisconnectReason) => void;
   connectionStateChanged: (state: ConnectionState) => void;
-  moved: (name: string, token: string) => void;
+  moved: (name: string) => void;
   mediaDevicesChanged: () => void;
   participantConnected: (participant: RemoteParticipant) => void;
   participantDisconnected: (participant: RemoteParticipant) => void;