livekit-client 2.0.3 → 2.0.5

package/dist/ts4.2/src/room/participant/Participant.d.ts

@@ -44,8 +44,7 @@ export default class Participant extends Participant_base {
     protected log: StructuredLogger;
     protected loggerOptions?: LoggerOptions;
     protected get logContext(): {
-        participantSid: string;
-        participantId: string;
+        [x: string]: unknown;
     };
     get isEncrypted(): boolean;
     get isAgent(): boolean;

package/dist/ts4.2/src/room/participant/RemoteParticipant.d.ts

@@ -16,6 +16,10 @@ export default class RemoteParticipant extends Participant {
     private audioOutput?;
     /** @internal */
     static fromParticipantInfo(signalClient: SignalClient, pi: ParticipantInfo): RemoteParticipant;
+    protected get logContext(): {
+        rpID: string;
+        remoteParticipant: string;
+    };
     /** @internal */
     constructor(signalClient: SignalClient, sid: string, identity?: string, name?: string, metadata?: string, loggerOptions?: LoggerOptions);
     protected addTrackPublication(publication: RemoteTrackPublication): void;

package/dist/ts4.2/src/room/track/LocalTrack.d.ts

@@ -3,6 +3,7 @@ import { Mutex } from '../utils';
 import { Track } from './Track';
 import type { VideoCodec } from './options';
 import type { TrackProcessor } from './processor/types';
+import type { ReplaceTrackOptions } from './types';
 export default abstract class LocalTrack<TrackKind extends Track.Kind = Track.Kind> extends Track<TrackKind> {
     /** @internal */
     sender?: RTCRtpSender;
@@ -41,7 +42,8 @@ export default abstract class LocalTrack<TrackKind extends Track.Kind = Track.Ki
     getDeviceId(): Promise<string | undefined>;
     mute(): Promise<this>;
     unmute(): Promise<this>;
-    replaceTrack(track: MediaStreamTrack, userProvidedTrack?: boolean): Promise<this>;
+    replaceTrack(track: MediaStreamTrack, options?: ReplaceTrackOptions): Promise<typeof this>;
+    replaceTrack(track: MediaStreamTrack, userProvidedTrack?: boolean): Promise<typeof this>;
     protected restart(constraints?: MediaTrackConstraints): Promise<this>;
     protected setTrackMuted(muted: boolean): void;
     protected get needsReAcquisition(): boolean;

package/dist/ts4.2/src/room/track/options.d.ts

@@ -220,10 +220,20 @@ export interface VideoEncoding {
     maxFramerate?: number;
     priority?: RTCPriorityType;
 }
+export interface VideoPresetOptions {
+    width: number;
+    height: number;
+    aspectRatio?: number;
+    maxBitrate: number;
+    maxFramerate?: number;
+    priority?: RTCPriorityType;
+}
 export declare class VideoPreset {
     encoding: VideoEncoding;
     width: number;
     height: number;
+    aspectRatio?: number;
+    constructor(videoPresetOptions: VideoPresetOptions);
     constructor(width: number, height: number, maxBitrate: number, maxFramerate?: number, priority?: RTCPriorityType);
     get resolution(): VideoResolution;
 }

package/dist/ts4.2/src/room/track/types.d.ts

@@ -21,4 +21,8 @@ export type AdaptiveStreamSettings = {
      */
     pauseVideoInBackground?: boolean;
 };
+export interface ReplaceTrackOptions {
+    userProvidedTrack?: boolean;
+    stopProcessor?: boolean;
+}
 //# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",

package/src/api/SignalClient.ts

@@ -216,7 +216,7 @@ export class SignalClient {
     token: string,
     sid?: string,
     reason?: ReconnectReason,
-  ): Promise<ReconnectResponse | void> {
+  ): Promise<ReconnectResponse | undefined> {
     if (!this.options) {
       this.log.warn(
         'attempted to reconnect without signal options being set, ignoring',
@@ -242,7 +242,7 @@ export class SignalClient {
     token: string,
     opts: ConnectOpts,
     abortSignal?: AbortSignal,
-  ): Promise<JoinResponse | ReconnectResponse | void> {
+  ): Promise<JoinResponse | ReconnectResponse | undefined> {
     this.connectOptions = opts;
     url = toWebsocketUrl(url);
     // strip trailing slash
@@ -252,7 +252,7 @@ export class SignalClient {
     const clientInfo = getClientInfo();
     const params = createConnectionParams(token, clientInfo, opts);
 
-    return new Promise<JoinResponse | ReconnectResponse | void>(async (resolve, reject) => {
+    return new Promise<JoinResponse | ReconnectResponse | undefined>(async (resolve, reject) => {
       const unlock = await this.connectionLock.lock();
       try {
         const abortHandler = async () => {
@@ -283,6 +283,7 @@ export class SignalClient {
 
         this.ws.onerror = async (ev: Event) => {
           if (this.state !== SignalConnectionState.CONNECTED) {
+            this.state = SignalConnectionState.DISCONNECTED;
             clearTimeout(wsTimeout);
             try {
               const resp = await fetch(`http${url.substring(2)}/validate${params}`);
@@ -355,9 +356,13 @@ export class SignalClient {
               abortSignal?.removeEventListener('abort', abortHandler);
               this.startPingInterval();
               if (resp.message?.case === 'reconnect') {
-                resolve(resp.message?.value);
+                resolve(resp.message.value);
               } else {
-                resolve();
+                this.log.debug(
+                  'declaring signal reconnected without reconnect response received',
+                  this.logContext,
+                );
+                resolve(undefined);
                 shouldProcessMessage = true;
               }
             } else if (this.isEstablishingConnection && resp.message.case === 'leave') {

package/src/e2ee/E2eeManager.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'events';
 import type TypedEventEmitter from 'typed-emitter';
-import log from '../logger';
+import log, { LogLevel, workerLogger } from '../logger';
 import { Encryption_Type, TrackInfo } from '../proto/livekit_models_pb';
 import type RTCEngine from '../room/RTCEngine';
 import type Room from '../room/Room';
@@ -68,6 +68,7 @@ export class E2EEManager extends (EventEmitter as new () => TypedEventEmitter<E2
         kind: 'init',
         data: {
           keyProviderOptions: this.keyProvider.getOptions(),
+          loglevel: workerLogger.getLevel() as LogLevel,
         },
       };
       if (this.worker) {

package/src/e2ee/types.ts

@@ -1,3 +1,4 @@
+import type { LogLevel } from '../logger';
 import type { VideoCodec } from '../room/track/options';
 import type { BaseKeyProvider } from './KeyProvider';
 
@@ -10,6 +11,7 @@ export interface InitMessage extends BaseMessage {
   kind: 'init';
   data: {
     keyProviderOptions: KeyProviderOptions;
+    loglevel: LogLevel;
   };
 }
 

package/src/e2ee/worker/FrameCryptor.ts

@@ -67,6 +67,8 @@ export class FrameCryptor extends BaseFrameCryptor {
 
   private sifGuard: SifGuard;
 
+  private detectedCodec?: VideoCodec;
+
   constructor(opts: {
     keys: ParticipantKeyHandler;
     participantIdentity: string;
@@ -85,8 +87,8 @@ export class FrameCryptor extends BaseFrameCryptor {
 
   private get logContext() {
     return {
-      identity: this.participantIdentity,
-      trackId: this.trackId,
+      participant: this.participantIdentity,
+      mediaTrackId: this.trackId,
       fallbackCodec: this.videoCodec,
     };
   }
@@ -229,7 +231,6 @@ export class FrameCryptor extends BaseFrameCryptor {
         encodedFrame.timestamp,
       );
       let frameInfo = this.getUnencryptedBytes(encodedFrame);
-      workerLogger.debug('frameInfo for encoded frame', { ...frameInfo, ...this.logContext });
 
       // Thіs is not encrypted and contains the VP8 payload descriptor or the Opus TOC byte.
       const frameHeader = new Uint8Array(encodedFrame.data, 0, frameInfo.unencryptedBytes);
@@ -334,7 +335,6 @@ export class FrameCryptor extends BaseFrameCryptor {
         const decodedFrame = await this.decryptFrame(encodedFrame, keyIndex);
         this.keys.decryptionSuccess();
         if (decodedFrame) {
-          workerLogger.debug('enqueue decrypted frame', this.logContext);
           return controller.enqueue(decodedFrame);
         }
       } catch (error) {
@@ -375,7 +375,6 @@ export class FrameCryptor extends BaseFrameCryptor {
       throw new TypeError(`no encryption key found for decryption of ${this.participantIdentity}`);
     }
     let frameInfo = this.getUnencryptedBytes(encodedFrame);
-    workerLogger.debug('frameInfo for decoded frame', { ...frameInfo, ...this.logContext });
 
     // Construct frame trailer. Similar to the frame header described in
     // https://tools.ietf.org/html/draft-omara-sframe-00#section-4.2
@@ -534,6 +533,14 @@ export class FrameCryptor extends BaseFrameCryptor {
     var frameInfo = { unencryptedBytes: 0, isH264: false };
     if (isVideoFrame(frame)) {
       let detectedCodec = this.getVideoCodec(frame) ?? this.videoCodec;
+      if (detectedCodec !== this.detectedCodec) {
+        workerLogger.debug('detected different codec', {
+          detectedCodec,
+          oldCodec: this.detectedCodec,
+          ...this.logContext,
+        });
+        this.detectedCodec = detectedCodec;
+      }
 
       if (detectedCodec === 'av1' || detectedCodec === 'vp9') {
         throw new Error(`${detectedCodec} is not yet supported for end to end encryption`);
@@ -591,7 +598,6 @@ export class FrameCryptor extends BaseFrameCryptor {
     // @ts-expect-error payloadType is not yet part of the typescript definition and currently not supported in Safari
     const payloadType = frame.getMetadata().payloadType;
     const codec = payloadType ? this.rtpMap.get(payloadType) : undefined;
-    workerLogger.debug('reading codec from frame', { codec, ...this.logContext });
     return codec;
   }
 }

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

@@ -32,6 +32,7 @@ onmessage = (ev) => {
 
   switch (kind) {
     case 'init':
+      workerLogger.setLevel(data.loglevel);
       workerLogger.info('worker initialized');
       keyProviderOptions = data.keyProviderOptions;
       useSharedKey = !!data.keyProviderOptions.sharedKey;

package/src/index.ts

@@ -1,4 +1,4 @@
-import { LogLevel, getLogger, setLogExtension, setLogLevel } from './logger';
+import { LogLevel, LoggerNames, getLogger, setLogExtension, setLogLevel } from './logger';
 import { DataPacket_Kind, DisconnectReason } from './proto/livekit_models_pb';
 import DefaultReconnectPolicy from './room/DefaultReconnectPolicy';
 import Room, { ConnectionState } from './room/Room';
@@ -55,6 +55,7 @@ export {
   supportsVP9,
   createAudioAnalyser,
   LogLevel,
+  LoggerNames,
   getLogger,
   Room,
   ConnectionState,

package/src/logger.ts

@@ -24,16 +24,19 @@ export enum LoggerNames {
 
 type LogLevelString = keyof typeof LogLevel;
 
-export type StructuredLogger = {
+export type StructuredLogger = log.Logger & {
   trace: (msg: string, context?: object) => void;
   debug: (msg: string, context?: object) => void;
   info: (msg: string, context?: object) => void;
   warn: (msg: string, context?: object) => void;
   error: (msg: string, context?: object) => void;
   setDefaultLevel: (level: log.LogLevelDesc) => void;
+  setLevel: (level: log.LogLevelDesc) => void;
+  getLevel: () => number;
 };
 
 let livekitLogger = log.getLogger('livekit');
+const livekitLoggers = Object.values(LoggerNames).map((name) => log.getLogger(name));
 
 livekitLogger.setDefaultLevel(LogLevel.info);
 
@@ -52,9 +55,7 @@ export function setLogLevel(level: LogLevel | LogLevelString, loggerName?: Logge
   if (loggerName) {
     log.getLogger(loggerName).setLevel(level);
   }
-  for (const logger of Object.entries(log.getLoggers())
-    .filter(([logrName]) => logrName.startsWith('livekit'))
-    .map(([, logr]) => logr)) {
+  for (const logger of livekitLoggers) {
     logger.setLevel(level);
   }
 }
@@ -65,24 +66,28 @@ export type LogExtension = (level: LogLevel, msg: string, context?: object) => v
  * use this to hook into the logging function to allow sending internal livekit logs to third party services
  * if set, the browser logs will lose their stacktrace information (see https://github.com/pimterry/loglevel#writing-plugins)
  */
-export function setLogExtension(extension: LogExtension, logger = livekitLogger) {
-  const originalFactory = logger.methodFactory;
+export function setLogExtension(extension: LogExtension, logger?: StructuredLogger) {
+  const loggers = logger ? [logger] : livekitLoggers;
 
-  logger.methodFactory = (methodName, configLevel, loggerName) => {
-    const rawMethod = originalFactory(methodName, configLevel, loggerName);
+  loggers.forEach((logR) => {
+    const originalFactory = logR.methodFactory;
 
-    const logLevel = LogLevel[methodName as LogLevelString];
-    const needLog = logLevel >= configLevel && logLevel < LogLevel.silent;
+    logR.methodFactory = (methodName, configLevel, loggerName) => {
+      const rawMethod = originalFactory(methodName, configLevel, loggerName);
 
-    return (msg, context?: [msg: string, context: object]) => {
-      if (context) rawMethod(msg, context);
-      else rawMethod(msg);
-      if (needLog) {
-        extension(logLevel, msg, context);
-      }
+      const logLevel = LogLevel[methodName as LogLevelString];
+      const needLog = logLevel >= configLevel && logLevel < LogLevel.silent;
+
+      return (msg, context?: [msg: string, context: object]) => {
+        if (context) rawMethod(msg, context);
+        else rawMethod(msg);
+        if (needLog) {
+          extension(logLevel, msg, context);
+        }
+      };
     };
-  };
-  logger.setLevel(logger.getLevel()); // Be sure to call setLevel method in order to apply plugin
+    logR.setLevel(logR.getLevel());
+  });
 }
 
 export const workerLogger = log.getLogger('lk-e2ee') as StructuredLogger;

package/src/room/DeviceManager.ts

@@ -80,7 +80,16 @@ export default class DeviceManager {
     // device has been chosen
     const devices = await this.getDevices(kind);
 
-    const device = devices.find((d) => d.groupId === groupId && d.deviceId !== defaultId);
+    // `default` devices will have the same groupId as the entry with the actual device id so we store the counts for each group id
+    const groupIdCounts = new Map(devices.map((d) => [d.groupId, 0]));
+
+    devices.forEach((d) => groupIdCounts.set(d.groupId, (groupIdCounts.get(d.groupId) ?? 0) + 1));
+
+    const device = devices.find(
+      (d) =>
+        (groupId === d.groupId || (groupIdCounts.get(d.groupId) ?? 0) > 1) &&
+        d.deviceId !== defaultId,
+    );
 
     return device?.deviceId;
   }

package/src/room/RTCEngine.ts

@@ -205,8 +205,9 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
   get logContext() {
     return {
       room: this.latestJoinResponse?.room?.name,
-      roomSid: this.latestJoinResponse?.room?.sid,
-      identity: this.latestJoinResponse?.participant?.identity,
+      roomID: this.latestJoinResponse?.room?.sid,
+      participant: this.latestJoinResponse?.participant?.identity,
+      pID: this.latestJoinResponse?.participant?.sid,
     };
   }
 
@@ -418,6 +419,19 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
           );
         }
       }
+
+      // detect cases where both signal client and peer connection are severed and assume that user has lost network connection
+      const isSignalSevered =
+        this.client.isDisconnected ||
+        this.client.currentState === SignalConnectionState.RECONNECTING;
+      const isPCSevered = [
+        PCTransportState.FAILED,
+        PCTransportState.CLOSING,
+        PCTransportState.CLOSED,
+      ].includes(connectionState);
+      if (isSignalSevered && isPCSevered && !this._isClosed) {
+        this.emit(EngineEvent.Offline);
+      }
     };
     this.pcManager.onTrack = (ev: RTCTrackEvent) => {
       this.emit(EngineEvent.MediaTrackAdded, ev.track, ev.streams[0], ev.receiver);
@@ -992,14 +1006,10 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
     this.log.info(`resuming signal connection, attempt ${this.reconnectAttempts}`, this.logContext);
     this.emit(EngineEvent.Resuming);
-
+    let res: ReconnectResponse | undefined;
     try {
       this.setupSignalClientCallbacks();
-      const res = await this.client.reconnect(this.url, this.token, this.participantSid, reason);
-      if (res) {
-        const rtcConfig = this.makeRTCConfiguration(res);
-        this.pcManager.updateConfiguration(rtcConfig);
-      }
+      res = await this.client.reconnect(this.url, this.token, this.participantSid, reason);
     } catch (error) {
       let message = '';
       if (error instanceof Error) {
@@ -1016,6 +1026,13 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     }
     this.emit(EngineEvent.SignalResumed);
 
+    if (res) {
+      const rtcConfig = this.makeRTCConfiguration(res);
+      this.pcManager.updateConfiguration(rtcConfig);
+    } else {
+      this.log.warn('Did not receive reconnect response', this.logContext);
+    }
+
     if (this.shouldFailNext) {
       this.shouldFailNext = false;
       throw new Error('simulated failure');
@@ -1400,4 +1417,5 @@ export type EngineEventCallbacks = {
   subscribedQualityUpdate: (update: SubscribedQualityUpdate) => void;
   localTrackUnpublished: (unpublishedResponse: TrackUnpublishedResponse) => void;
   remoteMute: (trackSid: string, muted: boolean) => void;
+  offline: () => void;
 };

package/src/room/Room.ts

@@ -69,7 +69,9 @@ import {
   Mutex,
   createDummyVideoStreamTrack,
   getEmptyAudioStreamTrack,
+  isBrowserSupported,
   isCloud,
+  isReactNative,
   isWeb,
   supportsSetSinkId,
   toHttpUrl,
@@ -247,8 +249,9 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   private get logContext() {
     return {
       room: this.name,
-      roomSid: this.roomInfo?.sid,
-      identity: this.localParticipant.identity,
+      roomID: this.roomInfo?.sid,
+      participant: this.localParticipant.identity,
+      pID: this.localParticipant.sid,
     };
   }
 
@@ -349,6 +352,11 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       })
       .on(EngineEvent.Restarting, this.handleRestarting)
       .on(EngineEvent.SignalRestarted, this.handleSignalRestarted)
+      .on(EngineEvent.Offline, () => {
+        if (this.setAndEmitConnectionState(ConnectionState.Reconnecting)) {
+          this.emit(RoomEvent.Reconnecting);
+        }
+      })
       .on(EngineEvent.DCBufferStatusChanged, (status, kind) => {
         this.emit(RoomEvent.DCBufferStatusChanged, status, kind);
       });
@@ -410,6 +418,16 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   }
 
   connect = async (url: string, token: string, opts?: RoomConnectOptions): Promise<void> => {
+    if (!isBrowserSupported()) {
+      if (isReactNative()) {
+        throw Error("WebRTC isn't detected, have you called registerGlobals?");
+      } else {
+        throw Error(
+          "LiveKit doesn't seem to be supported on this browser. Try to update your browser and make sure no browser extensions are disabling webRTC.",
+        );
+      }
+    }
+
     // In case a disconnect called happened right before the connect call, make sure the disconnect is completed first by awaiting its lock
     const unlockDisconnect = await this.disconnectLock.lock();
 
@@ -865,6 +883,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   }
 
   private onPageLeave = async () => {
+    this.log.info('Page leave detected, disconnecting', this.logContext);
     await this.disconnect();
   };
 
@@ -1042,6 +1061,11 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       ) {
         throw new Error('cannot switch audio output, setSinkId not supported');
       }
+      if (this.options.webAudioMix) {
+        // setting `default` for web audio output doesn't work, so we need to normalize the id before
+        deviceId =
+          (await DeviceManager.getInstance().normalizeDeviceId('audiooutput', deviceId)) ?? '';
+      }
       this.options.audioOutput ??= {};
       const prevDeviceId = this.options.audioOutput.deviceId;
       this.options.audioOutput.deviceId = deviceId;

package/src/room/events.ts

@@ -491,6 +491,7 @@ export enum EngineEvent {
   RemoteMute = 'remoteMute',
   SubscribedQualityUpdate = 'subscribedQualityUpdate',
   LocalTrackUnpublished = 'localTrackUnpublished',
+  Offline = 'offline',
 }
 
 export enum TrackEvent {

package/src/room/participant/LocalParticipant.ts

@@ -513,6 +513,10 @@ export default class LocalParticipant extends Participant {
     track: LocalTrack | MediaStreamTrack,
     options?: TrackPublishOptions,
   ): Promise<LocalTrackPublication> {
+    if (track instanceof LocalAudioTrack) {
+      track.setAudioContext(this.audioContext);
+    }
+
     await this.reconnectFuture?.promise;
     if (track instanceof LocalTrack && this.pendingPublishPromises.has(track)) {
       await this.pendingPublishPromises.get(track);
@@ -566,10 +570,6 @@ export default class LocalParticipant extends Participant {
       });
     }
 
-    if (track instanceof LocalAudioTrack) {
-      track.setAudioContext(this.audioContext);
-    }
-
     // is it already published? if so skip
     let existingPublication: LocalTrackPublication | undefined;
     this.trackPublications.forEach((publication) => {

package/src/room/participant/Participant.ts

@@ -88,8 +88,6 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
   protected get logContext() {
     return {
       ...this.loggerOptions?.loggerContextCb?.(),
-      participantSid: this.sid,
-      participantId: this.identity,
     };
   }
 

package/src/room/participant/RemoteParticipant.ts

@@ -33,6 +33,14 @@ export default class RemoteParticipant extends Participant {
     return new RemoteParticipant(signalClient, pi.sid, pi.identity, pi.name, pi.metadata);
   }
 
+  protected get logContext() {
+    return {
+      ...super.logContext,
+      rpID: this.sid,
+      remoteParticipant: this.identity,
+    };
+  }
+
   /** @internal */
   constructor(
     signalClient: SignalClient,

package/src/room/track/LocalAudioTrack.ts

@@ -51,6 +51,11 @@ export default class LocalAudioTrack extends LocalTrack<Track.Kind.Audio> {
   async mute(): Promise<typeof this> {
     const unlock = await this.muteLock.lock();
     try {
+      if (this.isMuted) {
+        this.log.debug('Track already muted', this.logContext);
+        return this;
+      }
+
       // disabled special handling as it will cause BT headsets to switch communication modes
       if (this.source === Track.Source.Microphone && this.stopOnMute && !this.isUserProvided) {
         this.log.debug('stopping mic track', this.logContext);
@@ -67,6 +72,11 @@ export default class LocalAudioTrack extends LocalTrack<Track.Kind.Audio> {
   async unmute(): Promise<typeof this> {
     const unlock = await this.muteLock.lock();
     try {
+      if (!this.isMuted) {
+        this.log.debug('Track already unmuted', this.logContext);
+        return this;
+      }
+
       const deviceHasChanged =
         this._constraints.deviceId &&
         this._mediaStreamTrack.getSettings().deviceId !==

package/src/room/track/LocalTrack.ts

@@ -8,6 +8,7 @@ import { Mutex, compareVersions, isMobile, sleep } from '../utils';
 import { Track, attachToElement, detachTrack } from './Track';
 import type { VideoCodec } from './options';
 import type { TrackProcessor } from './processor/types';
+import type { ReplaceTrackOptions } from './types';
 
 const defaultDimensionsTimeout = 1000;
 
@@ -224,18 +225,34 @@ export default abstract class LocalTrack<
     return this;
   }
 
-  async replaceTrack(track: MediaStreamTrack, userProvidedTrack = true) {
+  async replaceTrack(track: MediaStreamTrack, options?: ReplaceTrackOptions): Promise<typeof this>;
+  async replaceTrack(track: MediaStreamTrack, userProvidedTrack?: boolean): Promise<typeof this>;
+  async replaceTrack(
+    track: MediaStreamTrack,
+    userProvidedOrOptions: boolean | ReplaceTrackOptions | undefined,
+  ) {
     if (!this.sender) {
       throw new TrackInvalidError('unable to replace an unpublished track');
     }
 
+    let userProvidedTrack: boolean | undefined;
+    let stopProcessor: boolean | undefined;
+
+    if (typeof userProvidedOrOptions === 'boolean') {
+      userProvidedTrack = userProvidedOrOptions;
+    } else if (userProvidedOrOptions !== undefined) {
+      userProvidedTrack = userProvidedOrOptions.userProvidedTrack;
+      stopProcessor = userProvidedOrOptions.stopProcessor;
+    }
+
+    this.providedByUser = userProvidedTrack ?? true;
+
     this.log.debug('replace MediaStreamTrack', this.logContext);
     await this.setMediaStreamTrack(track);
     // this must be synced *after* setting mediaStreamTrack above, since it relies
     // on the previous state in order to cleanup
-    this.providedByUser = userProvidedTrack;
 
-    if (this.processor) {
+    if (stopProcessor && this.processor) {
       await this.stopProcessor();
     }
     return this;

package/src/room/track/LocalVideoTrack.ts

@@ -118,6 +118,11 @@ export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
   async mute(): Promise<typeof this> {
     const unlock = await this.muteLock.lock();
     try {
+      if (this.isMuted) {
+        this.log.debug('Track already muted', this.logContext);
+        return this;
+      }
+
       if (this.source === Track.Source.Camera && !this.isUserProvided) {
         this.log.debug('stopping camera track', this.logContext);
         // also stop the track, so that camera indicator is turned off
@@ -133,6 +138,11 @@ export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
   async unmute(): Promise<typeof this> {
     const unlock = await this.muteLock.lock();
     try {
+      if (!this.isMuted) {
+        this.log.debug('Track already unmuted', this.logContext);
+        return this;
+      }
+
       if (this.source === Track.Source.Camera && !this.isUserProvided) {
         this.log.debug('reacquiring camera track', this.logContext);
         await this.restartTrack();
@@ -414,7 +424,11 @@ async function setPublishingLayersForSender(
     }
 
     if (encodings.length !== senderEncodings.length) {
-      log.warn('cannot set publishing layers, encodings mismatch');
+      log.warn('cannot set publishing layers, encodings mismatch', {
+        ...logContext,
+        encodings,
+        senderEncodings,
+      });
       return;
     }