livekit-client 1.1.6 → 1.1.9

package/src/proto/livekit_models.ts

@@ -213,6 +213,68 @@ export function clientConfigSettingToJSON(object: ClientConfigSetting): string {
   }
 }
 
+export enum DisconnectReason {
+  UNKNOWN_REASON = 0,
+  CLIENT_INITIATED = 1,
+  DUPLICATE_IDENTITY = 2,
+  SERVER_SHUTDOWN = 3,
+  PARTICIPANT_REMOVED = 4,
+  ROOM_DELETED = 5,
+  STATE_MISMATCH = 6,
+  UNRECOGNIZED = -1,
+}
+
+export function disconnectReasonFromJSON(object: any): DisconnectReason {
+  switch (object) {
+    case 0:
+    case 'UNKNOWN_REASON':
+      return DisconnectReason.UNKNOWN_REASON;
+    case 1:
+    case 'CLIENT_INITIATED':
+      return DisconnectReason.CLIENT_INITIATED;
+    case 2:
+    case 'DUPLICATE_IDENTITY':
+      return DisconnectReason.DUPLICATE_IDENTITY;
+    case 3:
+    case 'SERVER_SHUTDOWN':
+      return DisconnectReason.SERVER_SHUTDOWN;
+    case 4:
+    case 'PARTICIPANT_REMOVED':
+      return DisconnectReason.PARTICIPANT_REMOVED;
+    case 5:
+    case 'ROOM_DELETED':
+      return DisconnectReason.ROOM_DELETED;
+    case 6:
+    case 'STATE_MISMATCH':
+      return DisconnectReason.STATE_MISMATCH;
+    case -1:
+    case 'UNRECOGNIZED':
+    default:
+      return DisconnectReason.UNRECOGNIZED;
+  }
+}
+
+export function disconnectReasonToJSON(object: DisconnectReason): string {
+  switch (object) {
+    case DisconnectReason.UNKNOWN_REASON:
+      return 'UNKNOWN_REASON';
+    case DisconnectReason.CLIENT_INITIATED:
+      return 'CLIENT_INITIATED';
+    case DisconnectReason.DUPLICATE_IDENTITY:
+      return 'DUPLICATE_IDENTITY';
+    case DisconnectReason.SERVER_SHUTDOWN:
+      return 'SERVER_SHUTDOWN';
+    case DisconnectReason.PARTICIPANT_REMOVED:
+      return 'PARTICIPANT_REMOVED';
+    case DisconnectReason.ROOM_DELETED:
+      return 'ROOM_DELETED';
+    case DisconnectReason.STATE_MISMATCH:
+      return 'STATE_MISMATCH';
+    default:
+      return 'UNKNOWN';
+  }
+}
+
 export interface Room {
   sid: string;
   name: string;
@@ -315,6 +377,7 @@ export interface SimulcastCodecInfo {
   mimeType: string;
   mid: string;
   cid: string;
+  layers: VideoLayer[];
 }
 
 export interface TrackInfo {
@@ -499,12 +562,17 @@ export interface ClientConfiguration {
   video?: VideoConfiguration;
   screen?: VideoConfiguration;
   resumeConnection: ClientConfigSetting;
+  disabledCodecs?: DisabledCodecs;
 }
 
 export interface VideoConfiguration {
   hardwareEncoder: ClientConfigSetting;
 }
 
+export interface DisabledCodecs {
+  codecs: Codec[];
+}
+
 export interface RTPStats {
   startTime?: Date;
   endTime?: Date;
@@ -531,7 +599,9 @@ export interface RTPStats {
   jitterMax: number;
   gapHistogram: { [key: number]: number };
   nacks: number;
+  nackAcks: number;
   nackMisses: number;
+  nackRepeated: number;
   plis: number;
   lastPli?: Date;
   firs: number;
@@ -1015,7 +1085,7 @@ export const ParticipantInfo = {
 };
 
 function createBaseSimulcastCodecInfo(): SimulcastCodecInfo {
-  return { mimeType: '', mid: '', cid: '' };
+  return { mimeType: '', mid: '', cid: '', layers: [] };
 }
 
 export const SimulcastCodecInfo = {
@@ -1029,6 +1099,9 @@ export const SimulcastCodecInfo = {
     if (message.cid !== '') {
       writer.uint32(26).string(message.cid);
     }
+    for (const v of message.layers) {
+      VideoLayer.encode(v!, writer.uint32(34).fork()).ldelim();
+    }
     return writer;
   },
 
@@ -1048,6 +1121,9 @@ export const SimulcastCodecInfo = {
         case 3:
           message.cid = reader.string();
           break;
+        case 4:
+          message.layers.push(VideoLayer.decode(reader, reader.uint32()));
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -1061,6 +1137,9 @@ export const SimulcastCodecInfo = {
       mimeType: isSet(object.mimeType) ? String(object.mimeType) : '',
       mid: isSet(object.mid) ? String(object.mid) : '',
       cid: isSet(object.cid) ? String(object.cid) : '',
+      layers: Array.isArray(object?.layers)
+        ? object.layers.map((e: any) => VideoLayer.fromJSON(e))
+        : [],
     };
   },
 
@@ -1069,6 +1148,11 @@ export const SimulcastCodecInfo = {
     message.mimeType !== undefined && (obj.mimeType = message.mimeType);
     message.mid !== undefined && (obj.mid = message.mid);
     message.cid !== undefined && (obj.cid = message.cid);
+    if (message.layers) {
+      obj.layers = message.layers.map((e) => (e ? VideoLayer.toJSON(e) : undefined));
+    } else {
+      obj.layers = [];
+    }
     return obj;
   },
 
@@ -1077,6 +1161,7 @@ export const SimulcastCodecInfo = {
     message.mimeType = object.mimeType ?? '';
     message.mid = object.mid ?? '';
     message.cid = object.cid ?? '';
+    message.layers = object.layers?.map((e) => VideoLayer.fromPartial(e)) || [];
     return message;
   },
 };
@@ -1820,7 +1905,7 @@ export const ClientInfo = {
 };
 
 function createBaseClientConfiguration(): ClientConfiguration {
-  return { video: undefined, screen: undefined, resumeConnection: 0 };
+  return { video: undefined, screen: undefined, resumeConnection: 0, disabledCodecs: undefined };
 }
 
 export const ClientConfiguration = {
@@ -1834,6 +1919,9 @@ export const ClientConfiguration = {
     if (message.resumeConnection !== 0) {
       writer.uint32(24).int32(message.resumeConnection);
     }
+    if (message.disabledCodecs !== undefined) {
+      DisabledCodecs.encode(message.disabledCodecs, writer.uint32(34).fork()).ldelim();
+    }
     return writer;
   },
 
@@ -1853,6 +1941,9 @@ export const ClientConfiguration = {
         case 3:
           message.resumeConnection = reader.int32() as any;
           break;
+        case 4:
+          message.disabledCodecs = DisabledCodecs.decode(reader, reader.uint32());
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -1868,6 +1959,9 @@ export const ClientConfiguration = {
       resumeConnection: isSet(object.resumeConnection)
         ? clientConfigSettingFromJSON(object.resumeConnection)
         : 0,
+      disabledCodecs: isSet(object.disabledCodecs)
+        ? DisabledCodecs.fromJSON(object.disabledCodecs)
+        : undefined,
     };
   },
 
@@ -1879,6 +1973,10 @@ export const ClientConfiguration = {
       (obj.screen = message.screen ? VideoConfiguration.toJSON(message.screen) : undefined);
     message.resumeConnection !== undefined &&
       (obj.resumeConnection = clientConfigSettingToJSON(message.resumeConnection));
+    message.disabledCodecs !== undefined &&
+      (obj.disabledCodecs = message.disabledCodecs
+        ? DisabledCodecs.toJSON(message.disabledCodecs)
+        : undefined);
     return obj;
   },
 
@@ -1895,6 +1993,10 @@ export const ClientConfiguration = {
         ? VideoConfiguration.fromPartial(object.screen)
         : undefined;
     message.resumeConnection = object.resumeConnection ?? 0;
+    message.disabledCodecs =
+      object.disabledCodecs !== undefined && object.disabledCodecs !== null
+        ? DisabledCodecs.fromPartial(object.disabledCodecs)
+        : undefined;
     return message;
   },
 };
@@ -1951,6 +2053,59 @@ export const VideoConfiguration = {
   },
 };
 
+function createBaseDisabledCodecs(): DisabledCodecs {
+  return { codecs: [] };
+}
+
+export const DisabledCodecs = {
+  encode(message: DisabledCodecs, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.codecs) {
+      Codec.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): DisabledCodecs {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDisabledCodecs();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.codecs.push(Codec.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): DisabledCodecs {
+    return {
+      codecs: Array.isArray(object?.codecs) ? object.codecs.map((e: any) => Codec.fromJSON(e)) : [],
+    };
+  },
+
+  toJSON(message: DisabledCodecs): unknown {
+    const obj: any = {};
+    if (message.codecs) {
+      obj.codecs = message.codecs.map((e) => (e ? Codec.toJSON(e) : undefined));
+    } else {
+      obj.codecs = [];
+    }
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<DisabledCodecs>, I>>(object: I): DisabledCodecs {
+    const message = createBaseDisabledCodecs();
+    message.codecs = object.codecs?.map((e) => Codec.fromPartial(e)) || [];
+    return message;
+  },
+};
+
 function createBaseRTPStats(): RTPStats {
   return {
     startTime: undefined,
@@ -1978,7 +2133,9 @@ function createBaseRTPStats(): RTPStats {
     jitterMax: 0,
     gapHistogram: {},
     nacks: 0,
+    nackAcks: 0,
     nackMisses: 0,
+    nackRepeated: 0,
     plis: 0,
     lastPli: undefined,
     firs: 0,
@@ -2072,9 +2229,15 @@ export const RTPStats = {
     if (message.nacks !== 0) {
       writer.uint32(200).uint32(message.nacks);
     }
+    if (message.nackAcks !== 0) {
+      writer.uint32(296).uint32(message.nackAcks);
+    }
     if (message.nackMisses !== 0) {
       writer.uint32(208).uint32(message.nackMisses);
     }
+    if (message.nackRepeated !== 0) {
+      writer.uint32(304).uint32(message.nackRepeated);
+    }
     if (message.plis !== 0) {
       writer.uint32(216).uint32(message.plis);
     }
@@ -2193,9 +2356,15 @@ export const RTPStats = {
         case 25:
           message.nacks = reader.uint32();
           break;
+        case 37:
+          message.nackAcks = reader.uint32();
+          break;
         case 26:
           message.nackMisses = reader.uint32();
           break;
+        case 38:
+          message.nackRepeated = reader.uint32();
+          break;
         case 27:
           message.plis = reader.uint32();
           break;
@@ -2273,7 +2442,9 @@ export const RTPStats = {
           )
         : {},
       nacks: isSet(object.nacks) ? Number(object.nacks) : 0,
+      nackAcks: isSet(object.nackAcks) ? Number(object.nackAcks) : 0,
       nackMisses: isSet(object.nackMisses) ? Number(object.nackMisses) : 0,
+      nackRepeated: isSet(object.nackRepeated) ? Number(object.nackRepeated) : 0,
       plis: isSet(object.plis) ? Number(object.plis) : 0,
       lastPli: isSet(object.lastPli) ? fromJsonTimestamp(object.lastPli) : undefined,
       firs: isSet(object.firs) ? Number(object.firs) : 0,
@@ -2327,7 +2498,9 @@ export const RTPStats = {
       });
     }
     message.nacks !== undefined && (obj.nacks = Math.round(message.nacks));
+    message.nackAcks !== undefined && (obj.nackAcks = Math.round(message.nackAcks));
     message.nackMisses !== undefined && (obj.nackMisses = Math.round(message.nackMisses));
+    message.nackRepeated !== undefined && (obj.nackRepeated = Math.round(message.nackRepeated));
     message.plis !== undefined && (obj.plis = Math.round(message.plis));
     message.lastPli !== undefined && (obj.lastPli = message.lastPli.toISOString());
     message.firs !== undefined && (obj.firs = Math.round(message.firs));
@@ -2376,7 +2549,9 @@ export const RTPStats = {
       return acc;
     }, {});
     message.nacks = object.nacks ?? 0;
+    message.nackAcks = object.nackAcks ?? 0;
     message.nackMisses = object.nackMisses ?? 0;
+    message.nackRepeated = object.nackRepeated ?? 0;
     message.plis = object.plis ?? 0;
     message.lastPli = object.lastPli ?? undefined;
     message.firs = object.firs ?? 0;
@@ -2480,9 +2655,9 @@ const btoa: (bin: string) => string =
   globalThis.btoa || ((bin) => globalThis.Buffer.from(bin, 'binary').toString('base64'));
 function base64FromBytes(arr: Uint8Array): string {
   const bin: string[] = [];
-  arr.forEach((byte) => {
+  for (const byte of arr) {
     bin.push(String.fromCharCode(byte));
-  });
+  }
   return btoa(bin.join(''));
 }
 

package/src/proto/livekit_rtc.ts

@@ -9,6 +9,7 @@ import {
   ClientConfiguration,
   TrackInfo,
   VideoQuality,
+  DisconnectReason,
   ConnectionQuality,
   VideoLayer,
   ParticipantTracks,
@@ -19,6 +20,8 @@ import {
   trackSourceToJSON,
   videoQualityFromJSON,
   videoQualityToJSON,
+  disconnectReasonFromJSON,
+  disconnectReasonToJSON,
   connectionQualityFromJSON,
   connectionQualityToJSON,
 } from './livekit_models';
@@ -283,6 +286,7 @@ export interface LeaveRequest {
    * indicates clients should attempt full-reconnect sequence
    */
   canReconnect: boolean;
+  reason: DisconnectReason;
 }
 
 /** message to indicate published video track dimensions are changing */
@@ -1836,7 +1840,7 @@ export const UpdateTrackSettings = {
 };
 
 function createBaseLeaveRequest(): LeaveRequest {
-  return { canReconnect: false };
+  return { canReconnect: false, reason: 0 };
 }
 
 export const LeaveRequest = {
@@ -1844,6 +1848,9 @@ export const LeaveRequest = {
     if (message.canReconnect === true) {
       writer.uint32(8).bool(message.canReconnect);
     }
+    if (message.reason !== 0) {
+      writer.uint32(16).int32(message.reason);
+    }
     return writer;
   },
 
@@ -1857,6 +1864,9 @@ export const LeaveRequest = {
         case 1:
           message.canReconnect = reader.bool();
           break;
+        case 2:
+          message.reason = reader.int32() as any;
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -1868,18 +1878,21 @@ export const LeaveRequest = {
   fromJSON(object: any): LeaveRequest {
     return {
       canReconnect: isSet(object.canReconnect) ? Boolean(object.canReconnect) : false,
+      reason: isSet(object.reason) ? disconnectReasonFromJSON(object.reason) : 0,
     };
   },
 
   toJSON(message: LeaveRequest): unknown {
     const obj: any = {};
     message.canReconnect !== undefined && (obj.canReconnect = message.canReconnect);
+    message.reason !== undefined && (obj.reason = disconnectReasonToJSON(message.reason));
     return obj;
   },
 
   fromPartial<I extends Exact<DeepPartial<LeaveRequest>, I>>(object: I): LeaveRequest {
     const message = createBaseLeaveRequest();
     message.canReconnect = object.canReconnect ?? false;
+    message.reason = object.reason ?? 0;
     return message;
   },
 };

package/src/room/RTCEngine.ts

@@ -7,6 +7,7 @@ import {
   ClientConfiguration,
   DataPacket,
   DataPacket_Kind,
+  DisconnectReason,
   SpeakerInfo,
   TrackInfo,
   UserPacket,
@@ -360,9 +361,10 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         this.fullReconnectOnNext = true;
         this.primaryPC = undefined;
       } else {
-        this.emit(EngineEvent.Disconnected);
+        this.emit(EngineEvent.Disconnected, leave?.reason);
         this.close();
       }
+      log.trace('leave request', { leave });
     };
   }
 
@@ -715,7 +717,7 @@ class SignalReconnectError extends Error {}
 
 export type EngineEventCallbacks = {
   connected: () => void;
-  disconnected: () => void;
+  disconnected: (reason?: DisconnectReason) => void;
   resuming: () => void;
   resumed: () => void;
   restarting: () => void;

package/src/room/Room.ts

@@ -5,6 +5,7 @@ import log from '../logger';
 import { RoomConnectOptions, RoomOptions } from '../options';
 import {
   DataPacket_Kind,
+  DisconnectReason,
   ParticipantInfo,
   ParticipantInfo_State,
   ParticipantPermission,
@@ -150,8 +151,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
           this.onTrackAdded(mediaTrack, stream, receiver);
         },
       )
-      .on(EngineEvent.Disconnected, () => {
-        this.handleDisconnect();
+      .on(EngineEvent.Disconnected, (reason?: DisconnectReason) => {
+        this.handleDisconnect(this.options.stopLocalTrackOnUnpublish, reason);
       })
       .on(EngineEvent.ActiveSpeakersUpdate, this.handleActiveSpeakersUpdate)
       .on(EngineEvent.DataPacketReceived, this.handleDataPacket)
@@ -288,7 +289,17 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
       // populate remote participants, these should not trigger new events
       joinResponse.otherParticipants.forEach((info) => {
-        this.getOrCreateParticipant(info.sid, 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.name = joinResponse.room!.name;
@@ -390,6 +401,12 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     let postAction = () => {};
     let req: SimulateScenario | undefined;
     switch (scenario) {
+      case 'signal-reconnect':
+        this.engine.client.close();
+        if (this.engine.client.onClose) {
+          this.engine.client.onClose('simulate disconnect');
+        }
+        break;
       case 'speaker':
         req = SimulateScenario.fromPartial({
           speakerUpdate: 3,
@@ -535,21 +552,27 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     // at that time, ICE connectivity has not been established so the track is not
     // technically subscribed.
     // We'll defer these events until when the room is connected or eventually disconnected.
-    if (this.state === ConnectionState.Connecting || this.state === ConnectionState.Reconnecting) {
-      setTimeout(() => {
+    if (this.connectFuture) {
+      this.connectFuture.promise.then(() => {
         this.onTrackAdded(mediaTrack, stream, receiver);
-      }, 50);
+      });
       return;
     }
     if (this.state === ConnectionState.Disconnected) {
       log.warn('skipping incoming track after Room disconnected');
+      return;
     }
     const parts = unpackStreamId(stream.id);
     const participantId = parts[0];
     let trackId = parts[1];
     if (!trackId || trackId === '') trackId = mediaTrack.id;
 
+    if (participantId === this.localParticipant.sid) {
+      log.warn('tried to create RemoteParticipant for local participant');
+      return;
+    }
     const participant = this.getOrCreateParticipant(participantId);
+
     let adaptiveStreamSettings: AdaptiveStreamSettings | undefined;
     if (this.options.adaptiveStream) {
       if (typeof this.options.adaptiveStream === 'object') {
@@ -623,7 +646,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     );
   };
 
-  private handleDisconnect(shouldStopTracks = true) {
+  private handleDisconnect(shouldStopTracks = true, reason?: DisconnectReason) {
     this.participants.forEach((p) => {
       p.tracks.forEach((pub) => {
         p.unpublishTrack(pub.trackSid);
@@ -651,7 +674,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       navigator.mediaDevices?.removeEventListener('devicechange', this.handleDeviceChange);
     }
     this.setAndEmitConnectionState(ConnectionState.Disconnected);
-    this.emit(RoomEvent.Disconnected);
+    this.emit(RoomEvent.Disconnected, reason);
   }
 
   private handleParticipantUpdates = (participantInfos: ParticipantInfo[]) => {
@@ -1069,7 +1092,7 @@ export default Room;
 export type RoomEventCallbacks = {
   reconnecting: () => void;
   reconnected: () => void;
-  disconnected: () => void;
+  disconnected: (reason?: DisconnectReason) => void;
   /** @deprecated stateChanged has been renamed to connectionStateChanged */
   stateChanged: (state: ConnectionState) => void;
   connectionStateChanged: (state: ConnectionState) => void;

package/src/room/participant/LocalParticipant.ts

@@ -1,6 +1,11 @@
 import log from '../../logger';
 import { RoomOptions } from '../../options';
-import { DataPacket, DataPacket_Kind, ParticipantPermission } from '../../proto/livekit_models';
+import {
+  DataPacket,
+  DataPacket_Kind,
+  ParticipantInfo,
+  ParticipantPermission,
+} from '../../proto/livekit_models';
 import {
   AddTrackRequest,
   DataChannelInfo,
@@ -787,6 +792,29 @@ export default class LocalParticipant extends Participant {
     }
   }
 
+  /** @internal */
+  updateInfo(info: ParticipantInfo) {
+    super.updateInfo(info);
+
+    // reconcile track mute status.
+    // if server's track mute status doesn't match actual, we'll have to update
+    // the server's copy
+    info.tracks.forEach((ti) => {
+      const pub = this.tracks.get(ti.sid);
+
+      if (pub) {
+        const mutedOnServer = pub.isMuted || (pub.track?.isUpstreamPaused ?? false);
+        if (mutedOnServer !== ti.muted) {
+          log.debug('updating server mute state after reconcile', {
+            sid: ti.sid,
+            muted: mutedOnServer,
+          });
+          this.engine.client.sendMuteTrack(ti.sid, mutedOnServer);
+        }
+      }
+    });
+  }
+
   private updateTrackSubscriptionPermissions = () => {
     log.debug('updating track subscription permissions', {
       allParticipantsAllowed: this.allParticipantsAllowedToSubscribe,
@@ -947,7 +975,7 @@ export default class LocalParticipant extends Participant {
     this.tracks.forEach((track: LocalTrackPublication) => {
       if (track.track !== undefined) {
         infos.push({
-          cid: track.track.mediaStreamTrack.id,
+          cid: track.track.mediaStreamID,
           track: track.trackInfo,
         });
       }

package/src/room/participant/Participant.ts

@@ -12,6 +12,7 @@ import RemoteTrackPublication from '../track/RemoteTrackPublication';
 import { Track } from '../track/Track';
 import { TrackPublication } from '../track/TrackPublication';
 import { RemoteTrack } from '../track/types';
+import log from '../../logger';
 
 export enum ConnectionQuality {
   Excellent = 'excellent',
@@ -179,6 +180,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 });
   }
 
   /** @internal */

package/src/room/participant/RemoteParticipant.ts

@@ -218,6 +218,10 @@ export default class RemoteParticipant extends Participant {
     // detect removed tracks
     this.tracks.forEach((publication) => {
       if (!validTracks.has(publication.trackSid)) {
+        log.trace('detected removed track on remote participant, unpublishing', {
+          publication,
+          participantSid: this.sid,
+        });
         this.unpublishTrack(publication.trackSid, true);
       }
     });

package/src/room/track/LocalAudioTrack.ts

@@ -35,22 +35,26 @@ export default class LocalAudioTrack extends LocalTrack {
   }
 
   async mute(): Promise<LocalAudioTrack> {
-    // disabled special handling as it will cause BT headsets to switch communication modes
-    if (this.source === Track.Source.Microphone && this.stopOnMute) {
-      log.debug('stopping mic track');
-      // also stop the track, so that microphone indicator is turned off
-      this._mediaStreamTrack.stop();
-    }
-    await super.mute();
+    await this.muteQueue.run(async () => {
+      // disabled special handling as it will cause BT headsets to switch communication modes
+      if (this.source === Track.Source.Microphone && this.stopOnMute && !this.isUserProvided) {
+        log.debug('stopping mic track');
+        // also stop the track, so that microphone indicator is turned off
+        this._mediaStreamTrack.stop();
+      }
+      await super.mute();
+    });
     return this;
   }
 
   async unmute(): Promise<LocalAudioTrack> {
-    if (this.source === Track.Source.Microphone && this.stopOnMute && !this.isUserProvided) {
-      log.debug('reacquiring mic track');
-      await this.restartTrack();
-    }
-    await super.unmute();
+    await this.muteQueue.run(async () => {
+      if (this.source === Track.Source.Microphone && this.stopOnMute && !this.isUserProvided) {
+        log.debug('reacquiring mic track');
+        await this.restartTrack();
+      }
+      await super.unmute();
+    });
     return this;
   }