livekit-client 2.0.1 → 2.0.3

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

@@ -3,7 +3,7 @@ import { Mutex } from '../utils';
 import { Track } from './Track';
 import type { VideoCodec } from './options';
 import type { TrackProcessor } from './processor/types';
-export default abstract class LocalTrack extends Track {
+export default abstract class LocalTrack<TrackKind extends Track.Kind = Track.Kind> extends Track<TrackKind> {
     /** @internal */
     sender?: RTCRtpSender;
     /** @internal */
@@ -15,8 +15,10 @@ export default abstract class LocalTrack extends Track {
     protected muteLock: Mutex;
     protected pauseUpstreamLock: Mutex;
     protected processorElement?: HTMLMediaElement;
-    protected processor?: TrackProcessor<this['kind']>;
+    protected processor?: TrackProcessor<TrackKind, any>;
     protected processorLock: Mutex;
+    protected audioContext?: AudioContext;
+    private restartLock;
     /**
      *
      * @param mediaTrack
@@ -24,7 +26,7 @@ export default abstract class LocalTrack extends Track {
      * @param constraints MediaTrackConstraints that are being used when restarting or reacquiring tracks
      * @param userProvidedTrack Signals to the SDK whether or not the mediaTrack should be managed (i.e. released and reacquired) internally by the SDK
      */
-    protected constructor(mediaTrack: MediaStreamTrack, kind: Track.Kind, constraints?: MediaTrackConstraints, userProvidedTrack?: boolean, loggerOptions?: LoggerOptions);
+    protected constructor(mediaTrack: MediaStreamTrack, kind: TrackKind, constraints?: MediaTrackConstraints, userProvidedTrack?: boolean, loggerOptions?: LoggerOptions);
     get id(): string;
     get dimensions(): Track.Dimensions | undefined;
     private _isUpstreamPaused;
@@ -37,10 +39,10 @@ export default abstract class LocalTrack extends Track {
      * @returns DeviceID of the device that is currently being used for this track
      */
     getDeviceId(): Promise<string | undefined>;
-    mute(): Promise<LocalTrack>;
-    unmute(): Promise<LocalTrack>;
-    replaceTrack(track: MediaStreamTrack, userProvidedTrack?: boolean): Promise<LocalTrack>;
-    protected restart(constraints?: MediaTrackConstraints): Promise<LocalTrack>;
+    mute(): Promise<this>;
+    unmute(): Promise<this>;
+    replaceTrack(track: MediaStreamTrack, userProvidedTrack?: boolean): Promise<this>;
+    protected restart(constraints?: MediaTrackConstraints): Promise<this>;
     protected setTrackMuted(muted: boolean): void;
     protected get needsReAcquisition(): boolean;
     protected handleAppVisibilityChanged(): Promise<void>;
@@ -74,8 +76,8 @@ export default abstract class LocalTrack extends Track {
      * @param showProcessedStreamLocally
      * @returns
      */
-    setProcessor(processor: TrackProcessor<this['kind']>, showProcessedStreamLocally?: boolean): Promise<void>;
-    getProcessor(): TrackProcessor<this["kind"], import("./processor/types").ProcessorOptions<this["kind"]>> | undefined;
+    setProcessor(processor: TrackProcessor<TrackKind>, showProcessedStreamLocally?: boolean): Promise<void>;
+    getProcessor(): TrackProcessor<TrackKind, any> | undefined;
     /**
      * Stops the track processor
      * See https://github.com/livekit/track-processors-js for example usage

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

@@ -18,11 +18,11 @@ export default class LocalTrackPublication extends TrackPublication {
     /**
      * Mute the track associated with this publication
      */
-    mute(): Promise<LocalTrack | undefined>;
+    mute(): Promise<LocalTrack<Track.Kind> | undefined>;
     /**
      * Unmute track associated with this publication
      */
-    unmute(): Promise<LocalTrack | undefined>;
+    unmute(): Promise<LocalTrack<Track.Kind> | undefined>;
     /**
      * Pauses the media stream track associated with this publication from being sent to the server
      * and signals "muted" event to other participants

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

@@ -14,7 +14,7 @@ export declare class SimulcastTrackInfo {
     encodings?: RTCRtpEncodingParameters[];
     constructor(codec: VideoCodec, mediaStreamTrack: MediaStreamTrack);
 }
-export default class LocalVideoTrack extends LocalTrack {
+export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
     signalClient?: SignalClient;
     private prevStats?;
     private encodings?;
@@ -33,8 +33,8 @@ export default class LocalVideoTrack extends LocalTrack {
     stop(): void;
     pauseUpstream(): Promise<void>;
     resumeUpstream(): Promise<void>;
-    mute(): Promise<LocalVideoTrack>;
-    unmute(): Promise<LocalVideoTrack>;
+    mute(): Promise<typeof this>;
+    unmute(): Promise<typeof this>;
     protected setTrackMuted(muted: boolean): void;
     getSenderStats(): Promise<VideoSenderStats[]>;
     setPublishingQuality(maxQuality: VideoQuality): void;

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

@@ -1,8 +1,9 @@
 import type { AudioReceiverStats } from '../stats';
 import type { LoggerOptions } from '../types';
 import RemoteTrack from './RemoteTrack';
+import { Track } from './Track';
 import type { AudioOutputOptions } from './options';
-export default class RemoteAudioTrack extends RemoteTrack {
+export default class RemoteAudioTrack extends RemoteTrack<Track.Kind.Audio> {
     private prevStats?;
     private elementVolume;
     private audioContext?;

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

@@ -1,9 +1,9 @@
 import type { LoggerOptions } from '../types';
 import { Track } from './Track';
-export default abstract class RemoteTrack extends Track {
+export default abstract class RemoteTrack<TrackKind extends Track.Kind = Track.Kind> extends Track<TrackKind> {
     /** @internal */
     receiver?: RTCRtpReceiver;
-    constructor(mediaTrack: MediaStreamTrack, sid: string, kind: Track.Kind, receiver?: RTCRtpReceiver, loggerOptions?: LoggerOptions);
+    constructor(mediaTrack: MediaStreamTrack, sid: string, kind: TrackKind, receiver?: RTCRtpReceiver, loggerOptions?: LoggerOptions);
     /** @internal */
     setMuted(muted: boolean): void;
     /** @internal */

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

@@ -1,7 +1,8 @@
 import type { LoggerOptions } from '../types';
 import RemoteTrack from './RemoteTrack';
+import { Track } from './Track';
 import type { AdaptiveStreamSettings } from './types';
-export default class RemoteVideoTrack extends RemoteTrack {
+export default class RemoteVideoTrack extends RemoteTrack<Track.Kind.Video> {
     private prevStats?;
     private elementInfos;
     private adaptiveStreamSettings?;

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

@@ -4,14 +4,15 @@ import { StructuredLogger } from '../../logger';
 import { TrackSource, TrackType } from '../../proto/livekit_models_pb';
 import { StreamState as ProtoStreamState } from '../../proto/livekit_rtc_pb';
 import type { LoggerOptions } from '../types';
+import type { TrackProcessor } from './processor/types';
 export declare enum VideoQuality {
     LOW = 0,
     MEDIUM = 1,
     HIGH = 2
 }
 declare const Track_base: new () => TypedEventEmitter<TrackEventCallbacks>;
-export declare abstract class Track extends Track_base {
-    kind: Track.Kind;
+export declare abstract class Track<TrackKind extends Track.Kind = Track.Kind> extends Track_base {
+    readonly kind: TrackKind;
     attachedElements: HTMLMediaElement[];
     isMuted: boolean;
     source: Track.Source;
@@ -36,7 +37,7 @@ export declare abstract class Track extends Track_base {
     protected _currentBitrate: number;
     protected monitorInterval?: ReturnType<typeof setInterval>;
     protected log: StructuredLogger;
-    protected constructor(mediaTrack: MediaStreamTrack, kind: Track.Kind, loggerOptions?: LoggerOptions);
+    protected constructor(mediaTrack: MediaStreamTrack, kind: TrackKind, loggerOptions?: LoggerOptions);
     protected get logContext(): {
         [x: string]: unknown;
     };
@@ -135,6 +136,7 @@ export type TrackEventCallbacks = {
     elementDetached: (element: HTMLMediaElement) => void;
     upstreamPaused: (track: any) => void;
     upstreamResumed: (track: any) => void;
+    trackProcessorUpdate: (processor?: TrackProcessor<Track.Kind, any>) => void;
 };
 export {};
 //# sourceMappingURL=Track.d.ts.map

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

@@ -1,3 +1,4 @@
+import type Room from '../../Room';
 import type { Track } from '../Track';
 /**
  * @experimental
@@ -6,6 +7,7 @@ export type ProcessorOptions<T extends Track.Kind> = {
     kind: T;
     track: MediaStreamTrack;
     element?: HTMLMediaElement;
+    audioContext?: AudioContext;
 };
 /**
  * @experimental
@@ -27,5 +29,7 @@ export interface TrackProcessor<T extends Track.Kind, U extends ProcessorOptions
     restart: (opts: U) => Promise<void>;
     destroy: () => Promise<void>;
     processedTrack?: MediaStreamTrack;
+    onPublish?: (room: Room) => Promise<void>;
+    onUnpublish?: () => Promise<void>;
 }
 //# sourceMappingURL=types.d.ts.map

package/package.json

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

package/src/api/SignalClient.ts

@@ -317,7 +317,7 @@ export class SignalClient {
           let resp: SignalResponse;
           if (typeof ev.data === 'string') {
             const json = JSON.parse(ev.data);
-            resp = SignalResponse.fromJson(json);
+            resp = SignalResponse.fromJson(json, { ignoreUnknownFields: true });
           } else if (ev.data instanceof ArrayBuffer) {
             resp = SignalResponse.fromBinary(new Uint8Array(ev.data));
           } else {

package/src/e2ee/KeyProvider.ts

@@ -12,7 +12,7 @@ import { createKeyMaterialFromBuffer, createKeyMaterialFromString } from './util
 export class BaseKeyProvider extends (EventEmitter as new () => TypedEventEmitter<KeyProviderCallbacks>) {
   private keyInfoMap: Map<string, KeyInfo>;
 
-  private options: KeyProviderOptions;
+  private readonly options: KeyProviderOptions;
 
   constructor(options: Partial<KeyProviderOptions> = {}) {
     super();
@@ -29,6 +29,11 @@ export class BaseKeyProvider extends (EventEmitter as new () => TypedEventEmitte
    */
   protected onSetEncryptionKey(key: CryptoKey, participantIdentity?: string, keyIndex?: number) {
     const keyInfo: KeyInfo = { key, participantIdentity, keyIndex };
+    if (!this.options.sharedKey && !participantIdentity) {
+      throw new Error(
+        'participant identity needs to be passed for encryption key if sharedKey option is false',
+      );
+    }
     this.keyInfoMap.set(`${participantIdentity ?? 'shared'}-${keyIndex ?? 0}`, keyInfo);
     this.emit(KeyProviderEvent.SetKey, keyInfo);
   }

package/src/e2ee/worker/FrameCryptor.ts

@@ -83,6 +83,14 @@ export class FrameCryptor extends BaseFrameCryptor {
     this.sifGuard = new SifGuard();
   }
 
+  private get logContext() {
+    return {
+      identity: this.participantIdentity,
+      trackId: this.trackId,
+      fallbackCodec: this.videoCodec,
+    };
+  }
+
   /**
    * Assign a different participant to the cryptor.
    * useful for transceiver re-use
@@ -96,6 +104,7 @@ export class FrameCryptor extends BaseFrameCryptor {
   }
 
   unsetParticipant() {
+    workerLogger.debug('unsetting participant', this.logContext);
     this.participantIdentity = undefined;
   }
 
@@ -143,6 +152,13 @@ export class FrameCryptor extends BaseFrameCryptor {
       this.videoCodec = codec;
     }
 
+    workerLogger.debug('Setting up frame cryptor transform', {
+      operation,
+      passedTrackId: trackId,
+      codec,
+      ...this.logContext,
+    });
+
     const transformFn = operation === 'encode' ? this.encodeFunction : this.decodeFunction;
     const transformStream = new TransformStream({
       transform: transformFn.bind(this),
@@ -159,6 +175,7 @@ export class FrameCryptor extends BaseFrameCryptor {
   }
 
   setSifTrailer(trailer: Uint8Array) {
+    workerLogger.debug('setting SIF trailer', { ...this.logContext, trailer });
     this.sifTrailer = trailer;
   }
 
@@ -212,6 +229,8 @@ 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);
 
@@ -262,6 +281,7 @@ export class FrameCryptor extends BaseFrameCryptor {
         workerLogger.error(e);
       }
     } else {
+      workerLogger.debug('failed to decrypt, emitting error', this.logContext);
       this.emit(
         CryptorEvent.Error,
         new CryptorError(`encryption key missing for encoding`, CryptorErrorReason.MissingKey),
@@ -284,11 +304,13 @@ export class FrameCryptor extends BaseFrameCryptor {
       // skip for decryption for empty dtx frames
       encodedFrame.data.byteLength === 0
     ) {
+      workerLogger.debug('skipping empty frame', this.logContext);
       this.sifGuard.recordUserFrame();
       return controller.enqueue(encodedFrame);
     }
 
     if (isFrameServerInjected(encodedFrame.data, this.sifTrailer)) {
+      workerLogger.debug('enqueue SIF', this.logContext);
       this.sifGuard.recordSif();
 
       if (this.sifGuard.isSifAllowed()) {
@@ -312,6 +334,7 @@ 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) {
@@ -352,6 +375,8 @@ 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
     // but we put it at the end.
@@ -566,6 +591,7 @@ 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/ParticipantKeyHandler.ts

@@ -133,15 +133,19 @@ export class ParticipantKeyHandler extends (EventEmitter as new () => TypedEvent
 
   /**
    * takes in a key material with `deriveBits` and `deriveKey` set as key usages
-   * and derives encryption keys from the material and sets it on the key ring buffer
+   * and derives encryption keys from the material and sets it on the key ring buffers
    * together with the material
    * also updates the currentKeyIndex
    */
-  async setKeyFromMaterial(material: CryptoKey, keyIndex = 0, emitRatchetEvent = false) {
-    const newIndex = keyIndex >= 0 ? keyIndex % this.cryptoKeyRing.length : -1;
-    workerLogger.debug(`setting new key with index ${newIndex}`);
+  async setKeyFromMaterial(material: CryptoKey, keyIndex: number, emitRatchetEvent = false) {
     const keySet = await deriveKeys(material, this.keyProviderOptions.ratchetSalt);
-    this.setKeySet(keySet, newIndex >= 0 ? newIndex : this.currentKeyIndex, emitRatchetEvent);
+    const newIndex = keyIndex >= 0 ? keyIndex % this.cryptoKeyRing.length : this.currentKeyIndex;
+    workerLogger.debug(`setting new key with index ${keyIndex}`, {
+      usage: material.usages,
+      algorithm: material.algorithm,
+      ratchetSalt: this.keyProviderOptions.ratchetSalt,
+    });
+    this.setKeySet(keySet, newIndex, emitRatchetEvent);
     if (newIndex >= 0) this.currentKeyIndex = newIndex;
   }
 

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

@@ -21,8 +21,6 @@ let isEncryptionEnabled: boolean = false;
 
 let useSharedKey: boolean = false;
 
-let sharedKey: CryptoKey | undefined;
-
 let sifTrailer: Uint8Array | undefined;
 
 let keyProviderOptions: KeyProviderOptions = KEY_PROVIDER_DEFAULTS;
@@ -72,10 +70,9 @@ onmessage = (ev) => {
       break;
     case 'setKey':
       if (useSharedKey) {
-        workerLogger.warn('set shared key');
         setSharedKey(data.key, data.keyIndex);
       } else if (data.participantIdentity) {
-        workerLogger.warn(
+        workerLogger.info(
           `set participant sender key ${data.participantIdentity} index ${data.keyIndex}`,
         );
         getParticipantKeyHandler(data.participantIdentity).setKey(data.key, data.keyIndex);
@@ -84,7 +81,7 @@ onmessage = (ev) => {
       }
       break;
     case 'removeTransform':
-      unsetCryptorParticipant(data.trackId);
+      unsetCryptorParticipant(data.trackId, data.participantIdentity);
       break;
     case 'updateCodec':
       getTrackCryptor(data.participantIdentity, data.trackId).setVideoCodec(data.codec);
@@ -144,8 +141,7 @@ function getTrackCryptor(participantIdentity: string, trackId: string) {
     // assign new participant id to track cryptor and pass in correct key handler
     cryptor.setParticipant(participantIdentity, getParticipantKeyHandler(participantIdentity));
   }
-  if (sharedKey) {
-  }
+
   return cryptor;
 }
 
@@ -156,9 +152,6 @@ function getParticipantKeyHandler(participantIdentity: string) {
   let keys = participantKeys.get(participantIdentity);
   if (!keys) {
     keys = new ParticipantKeyHandler(participantIdentity, keyProviderOptions);
-    if (sharedKey) {
-      keys.setKey(sharedKey);
-    }
     keys.on(KeyHandlerEvent.KeyRatcheted, emitRatchetedKeys);
     participantKeys.set(participantIdentity, keys);
   }
@@ -167,22 +160,32 @@ function getParticipantKeyHandler(participantIdentity: string) {
 
 function getSharedKeyHandler() {
   if (!sharedKeyHandler) {
+    workerLogger.debug('creating new shared key handler');
     sharedKeyHandler = new ParticipantKeyHandler('shared-key', keyProviderOptions);
   }
   return sharedKeyHandler;
 }
 
-function unsetCryptorParticipant(trackId: string) {
-  participantCryptors.find((c) => c.getTrackId() === trackId)?.unsetParticipant();
+function unsetCryptorParticipant(trackId: string, participantIdentity: string) {
+  const cryptor = participantCryptors.find(
+    (c) => c.getParticipantIdentity() === participantIdentity && c.getTrackId() === trackId,
+  );
+  if (!cryptor) {
+    workerLogger.warn('Could not unset participant on cryptor', { trackId, participantIdentity });
+  } else {
+    cryptor.unsetParticipant();
+  }
 }
 
 function setEncryptionEnabled(enable: boolean, participantIdentity: string) {
+  workerLogger.debug(`setting encryption enabled for all tracks of ${participantIdentity}`, {
+    enable,
+  });
   encryptionEnabledMap.set(participantIdentity, enable);
 }
 
 function setSharedKey(key: CryptoKey, index?: number) {
-  workerLogger.debug('setting shared key');
-  sharedKey = key;
+  workerLogger.info('set shared key', { index });
   getSharedKeyHandler().setKey(key, index);
 }
 

package/src/room/Room.ts

@@ -60,6 +60,7 @@ import type RemoteTrack from './track/RemoteTrack';
 import RemoteTrackPublication from './track/RemoteTrackPublication';
 import { Track } from './track/Track';
 import type { TrackPublication } from './track/TrackPublication';
+import type { TrackProcessor } from './track/processor/types';
 import type { AdaptiveStreamSettings } from './track/types';
 import { getNewAudioContext, sourceToKind } from './track/utils';
 import type { SimulationOptions, SimulationScenario } from './types';
@@ -573,16 +574,23 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.localParticipant.sid = pi.sid;
     this.localParticipant.identity = pi.identity;
 
+    if (this.options.e2ee && this.e2eeManager) {
+      try {
+        this.e2eeManager.setSifTrailer(joinResponse.sifTrailer);
+      } catch (e: any) {
+        this.log.error(e instanceof Error ? e.message : 'Could not set SifTrailer', {
+          ...this.logContext,
+          error: e,
+        });
+      }
+    }
+
     // populate remote participants, these should not trigger new events
     this.handleParticipantUpdates([pi, ...joinResponse.otherParticipants]);
 
     if (joinResponse.room) {
       this.handleRoomUpdate(joinResponse.room);
     }
-
-    if (this.options.e2ee && this.e2eeManager) {
-      this.e2eeManager.setSifTrailer(joinResponse.sifTrailer);
-    }
   };
 
   private attemptConnection = async (
@@ -1775,8 +1783,16 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.emit(RoomEvent.TrackUnmuted, pub, this.localParticipant);
   };
 
+  private onTrackProcessorUpdate = (processor?: TrackProcessor<Track.Kind, any>) => {
+    processor?.onPublish?.(this);
+  };
+
   private onLocalTrackPublished = async (pub: LocalTrackPublication) => {
+    pub.track?.on(TrackEvent.TrackProcessorUpdate, this.onTrackProcessorUpdate);
+    pub.track?.getProcessor()?.onPublish?.(this);
+
     this.emit(RoomEvent.LocalTrackPublished, pub, this.localParticipant);
+
     if (pub.track instanceof LocalAudioTrack) {
       const trackIsSilent = await pub.track.checkForSilence();
       if (trackIsSilent) {
@@ -1796,6 +1812,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   };
 
   private onLocalTrackUnpublished = (pub: LocalTrackPublication) => {
+    pub.track?.off(TrackEvent.TrackProcessorUpdate, this.onTrackProcessorUpdate);
     this.emit(RoomEvent.LocalTrackUnpublished, pub, this.localParticipant);
   };
 

package/src/room/events.ts

@@ -552,4 +552,8 @@ export enum TrackEvent {
    * Fires on RemoteTrackPublication
    */
   SubscriptionFailed = 'subscriptionFailed',
+  /**
+   * @internal
+   */
+  TrackProcessorUpdate = 'trackProcessorUpdate',
 }

package/src/room/participant/LocalParticipant.ts

@@ -888,7 +888,6 @@ export default class LocalParticipant extends Participant {
     }
 
     this.addTrackPublication(publication);
-
     // send event for publication
     this.emit(ParticipantEvent.LocalTrackPublished, publication);
     return publication;

package/src/room/track/LocalAudioTrack.ts

@@ -6,17 +6,17 @@ import { isWeb, unwrapConstraint } from '../utils';
 import LocalTrack from './LocalTrack';
 import { Track } from './Track';
 import type { AudioCaptureOptions } from './options';
-import type { TrackProcessor } from './processor/types';
+import type { AudioProcessorOptions, TrackProcessor } from './processor/types';
 import { constraintsForOptions, detectSilence } from './utils';
 
-export default class LocalAudioTrack extends LocalTrack {
+export default class LocalAudioTrack extends LocalTrack<Track.Kind.Audio> {
   /** @internal */
   stopOnMute: boolean = false;
 
-  private audioContext?: AudioContext;
-
   private prevStats?: AudioSenderStats;
 
+  protected processor?: TrackProcessor<Track.Kind.Audio, AudioProcessorOptions> | undefined;
+
   /**
    *
    * @param mediaTrack
@@ -48,7 +48,7 @@ export default class LocalAudioTrack extends LocalTrack {
     );
   }
 
-  async mute(): Promise<LocalAudioTrack> {
+  async mute(): Promise<typeof this> {
     const unlock = await this.muteLock.lock();
     try {
       // disabled special handling as it will cause BT headsets to switch communication modes
@@ -64,7 +64,7 @@ export default class LocalAudioTrack extends LocalTrack {
     }
   }
 
-  async unmute(): Promise<LocalAudioTrack> {
+  async unmute(): Promise<typeof this> {
     const unlock = await this.muteLock.lock();
     try {
       const deviceHasChanged =
@@ -99,7 +99,7 @@ export default class LocalAudioTrack extends LocalTrack {
     await this.restart(constraints);
   }
 
-  protected async restart(constraints?: MediaTrackConstraints): Promise<LocalTrack> {
+  protected async restart(constraints?: MediaTrackConstraints): Promise<typeof this> {
     const track = await super.restart(constraints);
     this.checkForSilence();
     return track;
@@ -139,7 +139,7 @@ export default class LocalAudioTrack extends LocalTrack {
     this.prevStats = stats;
   };
 
-  async setProcessor(processor: TrackProcessor<this['kind']>) {
+  async setProcessor(processor: TrackProcessor<Track.Kind.Audio, AudioProcessorOptions>) {
     const unlock = await this.processorLock.lock();
     try {
       if (!this.audioContext) {
@@ -150,9 +150,6 @@ export default class LocalAudioTrack extends LocalTrack {
       if (this.processor) {
         await this.stopProcessor();
       }
-      if (this.kind === 'unknown') {
-        throw TypeError('cannot set processor on track of unknown kind');
-      }
 
       const processorOptions = {
         kind: this.kind,
@@ -166,6 +163,7 @@ export default class LocalAudioTrack extends LocalTrack {
       if (this.processor.processedTrack) {
         await this.sender?.replaceTrack(this.processor.processedTrack);
       }
+      this.emit(TrackEvent.TrackProcessorUpdate, this.processor);
     } finally {
       unlock();
     }