livekit-client 2.1.5 → 2.2.0

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

@@ -5,7 +5,7 @@ import { Track } from '../track/Track';
 import type { AudioOutputOptions } from '../track/options';
 import type { AdaptiveStreamSettings } from '../track/types';
 import type { LoggerOptions } from '../types';
-import Participant from './Participant';
+import Participant, { ParticipantKind } from './Participant';
 import type { ParticipantEventCallbacks } from './Participant';
 export default class RemoteParticipant extends Participant {
     audioTrackPublications: Map<string, RemoteTrackPublication>;
@@ -15,13 +15,13 @@ export default class RemoteParticipant extends Participant {
     private volumeMap;
     private audioOutput?;
     /** @internal */
-    static fromParticipantInfo(signalClient: SignalClient, pi: ParticipantInfo): RemoteParticipant;
+    static fromParticipantInfo(signalClient: SignalClient, pi: ParticipantInfo, loggerOptions: LoggerOptions): RemoteParticipant;
     protected get logContext(): {
         rpID: string;
         remoteParticipant: string;
     };
     /** @internal */
-    constructor(signalClient: SignalClient, sid: string, identity?: string, name?: string, metadata?: string, loggerOptions?: LoggerOptions);
+    constructor(signalClient: SignalClient, sid: string, identity?: string, name?: string, metadata?: string, loggerOptions?: LoggerOptions, kind?: ParticipantKind);
     protected addTrackPublication(publication: RemoteTrackPublication): void;
     getTrackPublication(source: Track.Source): RemoteTrackPublication | undefined;
     getTrackPublicationByName(name: string): RemoteTrackPublication | undefined;

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

@@ -91,7 +91,7 @@ export default abstract class LocalTrack<TrackKind extends Track.Kind = Track.Ki
      * @experimental
      * @returns
      */
-    stopProcessor(): Promise<void>;
+    stopProcessor(keepElement?: boolean): Promise<void>;
     protected abstract monitorSender(): void;
 }
 //# sourceMappingURL=LocalTrack.d.ts.map

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

@@ -42,7 +42,7 @@ export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
     setPublishingQuality(maxQuality: VideoQuality): void;
     setDeviceId(deviceId: ConstrainDOMString): Promise<boolean>;
     restartTrack(options?: VideoCaptureOptions): Promise<void>;
-    setProcessor(processor: TrackProcessor<Track.Kind>, showProcessedStreamLocally?: boolean): Promise<void>;
+    setProcessor(processor: TrackProcessor<Track.Kind.Video>, showProcessedStreamLocally?: boolean): Promise<void>;
     setDegradationPreference(preference: RTCDegradationPreference): Promise<void>;
     addSimulcastTrack(codec: VideoCodec, encodings?: RTCRtpEncodingParameters[]): SimulcastTrackInfo | undefined;
     setSimulcastTrackSender(codec: VideoCodec, sender: RTCRtpSender): void;

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

@@ -1,4 +1,5 @@
 import type { Track } from './Track';
+import type { AudioProcessorOptions, TrackProcessor, VideoProcessorOptions } from './processor/types';
 export interface TrackPublishDefaults {
     /**
      * encoding parameters for camera track
@@ -133,6 +134,10 @@ export interface VideoCaptureOptions {
      */
     facingMode?: 'user' | 'environment' | 'left' | 'right';
     resolution?: VideoResolution;
+    /**
+     * initialize the track with a given processor
+     */
+    processor?: TrackProcessor<Track.Kind.Video, VideoProcessorOptions>;
 }
 export interface ScreenShareCaptureOptions {
     /**
@@ -210,6 +215,10 @@ export interface AudioCaptureOptions {
      * sample size or range of sample sizes which are acceptable and/or required.
      */
     sampleSize?: ConstrainULong;
+    /**
+     * initialize the track with a given processor
+     */
+    processor?: TrackProcessor<Track.Kind.Audio, AudioProcessorOptions>;
 }
 export interface AudioOutputOptions {
     /**

package/package.json

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

package/src/index.ts

@@ -3,7 +3,7 @@ import { LogLevel, LoggerNames, getLogger, setLogExtension, setLogLevel } from '
 import DefaultReconnectPolicy from './room/DefaultReconnectPolicy';
 import Room, { ConnectionState } from './room/Room';
 import LocalParticipant from './room/participant/LocalParticipant';
-import Participant, { ConnectionQuality } from './room/participant/Participant';
+import Participant, { ConnectionQuality, ParticipantKind } from './room/participant/Participant';
 import type { ParticipantTrackPermission } from './room/participant/ParticipantTrackPermission';
 import RemoteParticipant from './room/participant/RemoteParticipant';
 import CriticalTimers from './room/timers';
@@ -63,6 +63,7 @@ export {
   Participant,
   RemoteAudioTrack,
   RemoteParticipant,
+  ParticipantKind,
   RemoteTrack,
   RemoteTrackPublication,
   RemoteVideoTrack,

package/src/room/RTCEngine.ts

@@ -26,7 +26,7 @@ import {
   TrackUnpublishedResponse,
   Transcription,
   UpdateSubscription,
-  UserPacket,
+  type UserPacket,
 } from '@livekit/protocol';
 import { EventEmitter } from 'events';
 import type { MediaAttributes } from 'sdp-transform';
@@ -648,10 +648,12 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       if (dp.value?.case === 'speaker') {
         // dispatch speaker updates
         this.emit(EngineEvent.ActiveSpeakersUpdate, dp.value.value.speakers);
-      } else if (dp.value?.case === 'user') {
-        this.emit(EngineEvent.DataPacketReceived, dp.value.value, dp.kind);
-      } else if (dp.value?.case === 'transcription') {
-        this.emit(EngineEvent.TranscriptionReceived, dp.value.value);
+      } else {
+        if (dp.value?.case === 'user') {
+          // compatibility
+          applyUserDataCompat(dp, dp.value.value);
+        }
+        this.emit(EngineEvent.DataPacketReceived, dp);
       }
     } finally {
       unlock();
@@ -1392,7 +1394,7 @@ export type EngineEventCallbacks = {
     receiver?: RTCRtpReceiver,
   ) => void;
   activeSpeakersUpdate: (speakers: Array<SpeakerInfo>) => void;
-  dataPacketReceived: (userPacket: UserPacket, kind: DataPacket_Kind) => void;
+  dataPacketReceived: (packet: DataPacket) => void;
   transcriptionReceived: (transcription: Transcription) => void;
   transportsCreated: (publisher: PCTransport, subscriber: PCTransport) => void;
   /** @internal */
@@ -1415,3 +1417,18 @@ export type EngineEventCallbacks = {
 function supportOptionalDatachannel(protocol: number | undefined): boolean {
   return protocol !== undefined && protocol > 13;
 }
+
+function applyUserDataCompat(newObj: DataPacket, oldObj: UserPacket) {
+  const participantIdentity = newObj.participantIdentity
+    ? newObj.participantIdentity
+    : oldObj.participantIdentity;
+  newObj.participantIdentity = participantIdentity;
+  oldObj.participantIdentity = participantIdentity;
+
+  const destinationIdentities =
+    newObj.destinationIdentities.length !== 0
+      ? newObj.destinationIdentities
+      : oldObj.destinationIdentities;
+  newObj.destinationIdentities = destinationIdentities;
+  oldObj.destinationIdentities = destinationIdentities;
+}

package/src/room/Room.ts

@@ -1,5 +1,6 @@
 import {
   ConnectionQualityUpdate,
+  type DataPacket,
   DataPacket_Kind,
   DisconnectReason,
   JoinResponse,
@@ -11,6 +12,7 @@ import {
   Room as RoomModel,
   ServerInfo,
   SimulateScenario,
+  SipDTMF,
   SpeakerInfo,
   StreamStateUpdate,
   SubscriptionError,
@@ -334,7 +336,6 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       })
       .on(EngineEvent.ActiveSpeakersUpdate, this.handleActiveSpeakersUpdate)
       .on(EngineEvent.DataPacketReceived, this.handleDataPacket)
-      .on(EngineEvent.TranscriptionReceived, this.handleTranscription)
       .on(EngineEvent.Resuming, () => {
         this.clearConnectionReconcile();
         this.isResuming = true;
@@ -1085,11 +1086,12 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         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.remoteParticipants.values()).map((p) => p.setAudioOutput({ deviceId })),
-          );
         }
+        // also set audio output on all audio elements, even if webAudioMix is enabled in order to workaround echo cancellation not working on chrome with non-default output devices
+        // see https://issues.chromium.org/issues/40252911#comment7
+        await Promise.all(
+          Array.from(this.remoteParticipants.values()).map((p) => p.setAudioOutput({ deviceId })),
+        );
       } catch (e) {
         this.options.audioOutput.deviceId = prevDeviceId;
         throw e;
@@ -1472,24 +1474,47 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     pub.setSubscriptionError(update.err);
   };
 
-  private handleDataPacket = (userPacket: UserPacket, kind: DataPacket_Kind) => {
+  private handleDataPacket = (packet: DataPacket) => {
     // find the participant
-    const participant = this.remoteParticipants.get(userPacket.participantIdentity);
+    const participant = this.remoteParticipants.get(packet.participantIdentity);
+    if (packet.value.case === 'user') {
+      this.handleUserPacket(participant, packet.value.value, packet.kind);
+    } else if (packet.value.case === 'transcription') {
+      this.handleTranscription(participant, packet.value.value);
+    } else if (packet.value.case === 'sipDtmf') {
+      this.handleSipDtmf(participant, packet.value.value);
+    }
+  };
 
+  private handleUserPacket = (
+    participant: RemoteParticipant | undefined,
+    userPacket: UserPacket,
+    kind: DataPacket_Kind,
+  ) => {
     this.emit(RoomEvent.DataReceived, userPacket.payload, participant, kind, userPacket.topic);
 
     // also emit on the participant
     participant?.emit(ParticipantEvent.DataReceived, userPacket.payload, kind);
   };
 
+  private handleSipDtmf = (participant: RemoteParticipant | undefined, dtmf: SipDTMF) => {
+    this.emit(RoomEvent.SipDTMFReceived, dtmf, participant);
+
+    // also emit on the participant
+    participant?.emit(ParticipantEvent.SipDTMFReceived, dtmf);
+  };
+
   bufferedSegments: Map<string, TranscriptionSegmentModel> = new Map();
 
-  private handleTranscription = (transcription: TranscriptionModel) => {
+  private handleTranscription = (
+    remoteParticipant: RemoteParticipant | undefined,
+    transcription: TranscriptionModel,
+  ) => {
     // find the participant
     const participant =
       transcription.participantIdentity === this.localParticipant.identity
         ? this.localParticipant
-        : this.remoteParticipants.get(transcription.participantIdentity);
+        : remoteParticipant;
     const publication = participant?.trackPublications.get(transcription.trackId);
 
     const segments = extractTranscriptionSegments(transcription);
@@ -1596,7 +1621,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   private createParticipant(identity: string, info?: ParticipantInfo): RemoteParticipant {
     let participant: RemoteParticipant;
     if (info) {
-      participant = RemoteParticipant.fromParticipantInfo(this.engine.client, info);
+      participant = RemoteParticipant.fromParticipantInfo(this.engine.client, info, {
+        loggerContextCb: () => this.logContext,
+        loggerName: this.options.loggerName,
+      });
     } else {
       participant = new RemoteParticipant(this.engine.client, '', identity, undefined, undefined, {
         loggerContextCb: () => this.logContext,
@@ -2099,6 +2127,7 @@ export type RoomEventCallbacks = {
     kind?: DataPacket_Kind,
     topic?: string,
   ) => void;
+  sipDTMFReceived: (dtmf: SipDTMF, participant?: RemoteParticipant) => void;
   transcriptionReceived: (
     transcription: TranscriptionSegment[],
     participant?: Participant,

package/src/room/events.ts

@@ -197,6 +197,13 @@ export enum RoomEvent {
    */
   DataReceived = 'dataReceived',
 
+  /**
+   * SIP DTMF tones received from another participant.
+   *
+   * args: (participant: [[Participant]], dtmf: [[DataPacket_Kind]])
+   */
+  SipDTMFReceived = 'sipDTMFReceived',
+
   /**
    * Transcription received from a participant's track.
    * @beta
@@ -408,6 +415,13 @@ export enum ParticipantEvent {
    */
   DataReceived = 'dataReceived',
 
+  /**
+   * SIP DTMF tones received from this participant as sender.
+   *
+   * args: (dtmf: [[DataPacket_Kind]])
+   */
+  SipDTMFReceived = 'sipDTMFReceived',
+
   /**
    * Transcription received from this participant as data source.
    * @beta
@@ -491,7 +505,6 @@ export enum EngineEvent {
   MediaTrackAdded = 'mediaTrackAdded',
   ActiveSpeakersUpdate = 'activeSpeakersUpdate',
   DataPacketReceived = 'dataPacketReceived',
-  TranscriptionReceived = 'transcriptionReceived',
   RTPVideoMapUpdate = 'rtpVideoMapUpdate',
   DCBufferStatusChanged = 'dcBufferStatusChanged',
   ParticipantUpdate = 'participantUpdate',

package/src/room/participant/LocalParticipant.ts

@@ -30,6 +30,7 @@ import type {
   VideoCaptureOptions,
 } from '../track/options';
 import { ScreenSharePresets, VideoPresets, isBackupCodec } from '../track/options';
+import type { TrackProcessor } from '../track/processor/types';
 import {
   constraintsForOptions,
   getLogContextFromTrack,
@@ -394,13 +395,13 @@ export default class LocalParticipant extends Participant {
    * @returns
    */
   async createTracks(options?: CreateLocalTracksOptions): Promise<LocalTrack[]> {
-    const opts = mergeDefaultOptions(
+    const mergedOptions = mergeDefaultOptions(
       options,
       this.roomOptions?.audioCaptureDefaults,
       this.roomOptions?.videoCaptureDefaults,
     );
 
-    const constraints = constraintsForOptions(opts);
+    const constraints = constraintsForOptions(mergedOptions);
     let stream: MediaStream | undefined;
     try {
       stream = await navigator.mediaDevices.getUserMedia(constraints);
@@ -425,29 +426,39 @@ export default class LocalParticipant extends Participant {
       this.cameraError = undefined;
     }
 
-    return stream.getTracks().map((mediaStreamTrack) => {
-      const isAudio = mediaStreamTrack.kind === 'audio';
-      let trackOptions = isAudio ? options!.audio : options!.video;
-      if (typeof trackOptions === 'boolean' || !trackOptions) {
-        trackOptions = {};
-      }
-      let trackConstraints: MediaTrackConstraints | undefined;
-      const conOrBool = isAudio ? constraints.audio : constraints.video;
-      if (typeof conOrBool !== 'boolean') {
-        trackConstraints = conOrBool;
-      }
-      const track = mediaTrackToLocalTrack(mediaStreamTrack, trackConstraints, {
-        loggerName: this.roomOptions.loggerName,
-        loggerContextCb: () => this.logContext,
-      });
-      if (track.kind === Track.Kind.Video) {
-        track.source = Track.Source.Camera;
-      } else if (track.kind === Track.Kind.Audio) {
-        track.source = Track.Source.Microphone;
-      }
-      track.mediaStream = stream;
-      return track;
-    });
+    return Promise.all(
+      stream.getTracks().map(async (mediaStreamTrack) => {
+        const isAudio = mediaStreamTrack.kind === 'audio';
+        let trackOptions = isAudio ? mergedOptions!.audio : mergedOptions!.video;
+        if (typeof trackOptions === 'boolean' || !trackOptions) {
+          trackOptions = {};
+        }
+        let trackConstraints: MediaTrackConstraints | undefined;
+        const conOrBool = isAudio ? constraints.audio : constraints.video;
+        if (typeof conOrBool !== 'boolean') {
+          trackConstraints = conOrBool;
+        }
+        const track = mediaTrackToLocalTrack(mediaStreamTrack, trackConstraints, {
+          loggerName: this.roomOptions.loggerName,
+          loggerContextCb: () => this.logContext,
+        });
+        if (track.kind === Track.Kind.Video) {
+          track.source = Track.Source.Camera;
+        } else if (track.kind === Track.Kind.Audio) {
+          track.source = Track.Source.Microphone;
+          track.setAudioContext(this.audioContext);
+        }
+        track.mediaStream = stream;
+        if (trackOptions.processor) {
+          if (track instanceof LocalAudioTrack) {
+            await track.setProcessor(trackOptions.processor as TrackProcessor<Track.Kind.Audio>);
+          } else {
+            await track.setProcessor(trackOptions.processor as TrackProcessor<Track.Kind.Video>);
+          }
+        }
+        return track;
+      }),
+    );
   }
 
   /**

package/src/room/participant/Participant.ts

@@ -1,8 +1,10 @@
 import {
   DataPacket_Kind,
   ParticipantInfo,
+  ParticipantInfo_Kind as ParticipantKind,
   ParticipantPermission,
   ConnectionQuality as ProtoQuality,
+  type SipDTMF,
   SubscriptionError,
 } from '@livekit/protocol';
 import { EventEmitter } from 'events';
@@ -45,6 +47,8 @@ function qualityFromProto(q: ProtoQuality): ConnectionQuality {
   }
 }
 
+export { ParticipantKind };
+
 export default class Participant extends (EventEmitter as new () => TypedEmitter<ParticipantEventCallbacks>) {
   protected participantInfo?: ParticipantInfo;
 
@@ -77,6 +81,8 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
 
   permissions?: ParticipantPermission;
 
+  protected _kind: ParticipantKind;
+
   private _connectionQuality: ConnectionQuality = ConnectionQuality.Unknown;
 
   protected audioContext?: AudioContext;
@@ -99,7 +105,11 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
   }
 
   get isAgent() {
-    return this.permissions?.agent ?? false;
+    return this.permissions?.agent || this.kind === ParticipantKind.AGENT;
+  }
+
+  get kind() {
+    return this._kind;
   }
 
   /** @internal */
@@ -109,6 +119,7 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
     name?: string,
     metadata?: string,
     loggerOptions?: LoggerOptions,
+    kind: ParticipantKind = ParticipantKind.STANDARD,
   ) {
     super();
 
@@ -123,6 +134,7 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
     this.audioTrackPublications = new Map();
     this.videoTrackPublications = new Map();
     this.trackPublications = new Map();
+    this._kind = kind;
   }
 
   getTrackPublications(): TrackPublication[] {
@@ -329,6 +341,7 @@ export type ParticipantEventCallbacks = {
   participantMetadataChanged: (prevMetadata: string | undefined, participant?: any) => void;
   participantNameChanged: (name: string) => void;
   dataReceived: (payload: Uint8Array, kind: DataPacket_Kind) => void;
+  sipDTMFReceived: (dtmf: SipDTMF) => void;
   transcriptionReceived: (
     transcription: TranscriptionSegment[],
     publication?: TrackPublication,

package/src/room/participant/RemoteParticipant.ts

@@ -16,7 +16,7 @@ import type { AudioOutputOptions } from '../track/options';
 import type { AdaptiveStreamSettings } from '../track/types';
 import { getLogContextFromTrack } from '../track/utils';
 import type { LoggerOptions } from '../types';
-import Participant from './Participant';
+import Participant, { ParticipantKind } from './Participant';
 import type { ParticipantEventCallbacks } from './Participant';
 
 export default class RemoteParticipant extends Participant {
@@ -33,8 +33,20 @@ export default class RemoteParticipant extends Participant {
   private audioOutput?: AudioOutputOptions;
 
   /** @internal */
-  static fromParticipantInfo(signalClient: SignalClient, pi: ParticipantInfo): RemoteParticipant {
-    return new RemoteParticipant(signalClient, pi.sid, pi.identity, pi.name, pi.metadata);
+  static fromParticipantInfo(
+    signalClient: SignalClient,
+    pi: ParticipantInfo,
+    loggerOptions: LoggerOptions,
+  ): RemoteParticipant {
+    return new RemoteParticipant(
+      signalClient,
+      pi.sid,
+      pi.identity,
+      pi.name,
+      pi.metadata,
+      loggerOptions,
+      pi.kind,
+    );
   }
 
   protected get logContext() {
@@ -53,8 +65,9 @@ export default class RemoteParticipant extends Participant {
     name?: string,
     metadata?: string,
     loggerOptions?: LoggerOptions,
+    kind: ParticipantKind = ParticipantKind.STANDARD,
   ) {
-    super(sid, identity || '', name, metadata, loggerOptions);
+    super(sid, identity || '', name, metadata, loggerOptions, kind);
     this.signalClient = signalClient;
     this.trackPublications = new Map();
     this.audioTrackPublications = new Map();

package/src/room/participant/publishUtils.ts

@@ -149,6 +149,10 @@ export function computeVideoEncodings(
     const browser = getBrowser();
     if (
       isSafari() ||
+      // Even tho RN runs M114, it does not produce SVC layers when a single encoding
+      // is provided. So we'll use the legacy SVC specification for now.
+      // TODO: when we upstream libwebrtc, this will need additional verification
+      isReactNative() ||
       (browser?.name === 'Chrome' && compareVersions(browser?.version, '113') < 0)
     ) {
       const bitratesRatio = sm.suffix == 'h' ? 2 : 3;

package/src/room/track/LocalTrack.ts

@@ -468,16 +468,17 @@ export default abstract class LocalTrack<
     try {
       this.log.debug('setting up processor', this.logContext);
 
-      this.processorElement =
-        this.processorElement ?? (document.createElement(this.kind) as HTMLMediaElement);
+      const processorElement = document.createElement(this.kind) as HTMLMediaElement;
 
       const processorOptions = {
         kind: this.kind,
         track: this._mediaStreamTrack,
-        element: this.processorElement,
+        element: processorElement,
         audioContext: this.audioContext,
       };
       await processor.init(processorOptions);
+      this.log.debug('processor initialized', this.logContext);
+
       if (this.processor) {
         await this.stopProcessor();
       }
@@ -485,16 +486,17 @@ export default abstract class LocalTrack<
         throw TypeError('cannot set processor on track of unknown kind');
       }
 
-      attachToElement(this._mediaStreamTrack, this.processorElement);
-      this.processorElement.muted = true;
+      attachToElement(this._mediaStreamTrack, processorElement);
+      processorElement.muted = true;
 
-      this.processorElement
+      processorElement
         .play()
         .catch((error) =>
           this.log.error('failed to play processor element', { ...this.logContext, error }),
         );
 
       this.processor = processor;
+      this.processorElement = processorElement;
       if (this.processor.processedTrack) {
         for (const el of this.attachedElements) {
           if (el !== this.processorElement && showProcessedStreamLocally) {
@@ -521,15 +523,17 @@ export default abstract class LocalTrack<
    * @experimental
    * @returns
    */
-  async stopProcessor() {
+  async stopProcessor(keepElement = true) {
     if (!this.processor) return;
 
     this.log.debug('stopping processor', this.logContext);
     this.processor.processedTrack?.stop();
     await this.processor.destroy();
     this.processor = undefined;
-    this.processorElement?.remove();
-    this.processorElement = undefined;
+    if (!keepElement) {
+      this.processorElement?.remove();
+      this.processorElement = undefined;
+    }
     // apply original track constraints in case the processor changed them
     await this._mediaStreamTrack.applyConstraints(this._constraints);
     // force re-setting of the mediaStreamTrack on the sender

package/src/room/track/LocalVideoTrack.ts

@@ -276,7 +276,10 @@ export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
     }
   }
 
-  async setProcessor(processor: TrackProcessor<Track.Kind>, showProcessedStreamLocally = true) {
+  async setProcessor(
+    processor: TrackProcessor<Track.Kind.Video>,
+    showProcessedStreamLocally = true,
+  ) {
     await super.setProcessor(processor, showProcessedStreamLocally);
 
     if (this.processor?.processedTrack) {