livekit-client 1.12.1 → 1.12.3

package/src/room/participant/LocalParticipant.ts

@@ -6,15 +6,17 @@ import {
   Encryption_Type,
   ParticipantInfo,
   ParticipantPermission,
-} from '../../proto/livekit_models';
+  UserPacket,
+} from '../../proto/livekit_models_pb';
 import {
   AddTrackRequest,
   DataChannelInfo,
   SignalTarget,
+  SimulcastCodec,
   SubscribedQualityUpdate,
   TrackPublishedResponse,
   TrackUnpublishedResponse,
-} from '../../proto/livekit_rtc';
+} from '../../proto/livekit_rtc_pb';
 import type RTCEngine from '../RTCEngine';
 import { DeviceUnsupportedError, TrackInvalidError, UnexpectedConnectionState } from '../errors';
 import { EngineEvent, ParticipantEvent, TrackEvent } from '../events';
@@ -32,7 +34,11 @@ import type {
   VideoCaptureOptions,
 } from '../track/options';
 import { ScreenSharePresets, VideoPresets, isBackupCodec, isCodecEqual } from '../track/options';
-import { constraintsForOptions, mergeDefaultOptions } from '../track/utils';
+import {
+  constraintsForOptions,
+  mergeDefaultOptions,
+  screenCaptureToDisplayMediaStreamOptions,
+} from '../track/utils';
 import type { DataPublishOptions } from '../types';
 import { Future, isFireFox, isSVCCodec, isSafari, isWeb, supportsAV1, supportsVP9 } from '../utils';
 import Participant from './Participant';
@@ -311,6 +317,9 @@ export default class LocalParticipant extends Participant {
           // revisit if we want to return an array of tracks instead for v2
           [track] = publishedTracks;
         } catch (e) {
+          localTracks?.forEach((tr) => {
+            tr.stop();
+          });
           if (e instanceof Error && !(e instanceof TrackInvalidError)) {
             this.emit(ParticipantEvent.MediaDevicesError, e);
           }
@@ -433,36 +442,12 @@ export default class LocalParticipant extends Participant {
       options.resolution = ScreenSharePresets.h1080fps15.resolution;
     }
 
-    let videoConstraints: MediaTrackConstraints | boolean = true;
-    if (options.resolution) {
-      if (isSafari()) {
-        videoConstraints = {
-          width: { max: options.resolution.width },
-          height: { max: options.resolution.height },
-          frameRate: options.resolution.frameRate,
-        };
-      } else {
-        videoConstraints = {
-          width: { ideal: options.resolution.width },
-          height: { ideal: options.resolution.height },
-          frameRate: options.resolution.frameRate,
-        };
-      }
-    }
-
     if (navigator.mediaDevices.getDisplayMedia === undefined) {
       throw new DeviceUnsupportedError('getDisplayMedia not supported');
     }
 
-    const stream: MediaStream = await navigator.mediaDevices.getDisplayMedia({
-      audio: options.audio ?? false,
-      video: videoConstraints,
-      // @ts-expect-error support for experimental display media features
-      controller: options.controller,
-      selfBrowserSurface: options.selfBrowserSurface,
-      surfaceSwitching: options.surfaceSwitching,
-      systemAudio: options.systemAudio,
-    });
+    const constraints = screenCaptureToDisplayMediaStreamOptions(options);
+    const stream: MediaStream = await navigator.mediaDevices.getDisplayMedia(constraints);
 
     const tracks = stream.getVideoTracks();
     if (tracks.length === 0) {
@@ -585,7 +570,7 @@ export default class LocalParticipant extends Participant {
     if (opts.source) {
       track.source = opts.source;
     }
-    const publishPromise = this.publish(track, opts, options, isStereo);
+    const publishPromise = this.publish(track, opts, isStereo);
     this.pendingPublishPromises.set(track, publishPromise);
     try {
       const publication = await publishPromise;
@@ -597,12 +582,7 @@ export default class LocalParticipant extends Participant {
     }
   }
 
-  private async publish(
-    track: LocalTrack,
-    opts: TrackPublishOptions,
-    options: TrackPublishOptions | undefined,
-    isStereo: boolean,
-  ) {
+  private async publish(track: LocalTrack, opts: TrackPublishOptions, isStereo: boolean) {
     const existingTrackOfSource = Array.from(this.tracks.values()).find(
       (publishedTrack) => track instanceof LocalTrack && publishedTrack.source === track.source,
     );
@@ -646,10 +626,10 @@ export default class LocalParticipant extends Participant {
     track.on(TrackEvent.UpstreamResumed, this.onTrackUpstreamResumed);
 
     // create track publication from track
-    const req = AddTrackRequest.fromPartial({
+    const req = new AddTrackRequest({
       // get local track id for use during publishing
       cid: track.mediaStreamTrack.id,
-      name: options?.name,
+      name: opts.name,
       type: Track.kindToProto(track.kind),
       muted: track.isMuted,
       source: Track.sourceToProto(track.source),
@@ -698,26 +678,26 @@ export default class LocalParticipant extends Participant {
           simEncodings = computeTrackBackupEncodings(track, opts.backupCodec.codec, simOpts);
 
           req.simulcastCodecs = [
-            {
+            new SimulcastCodec({
               codec: opts.videoCodec,
               cid: track.mediaStreamTrack.id,
               enableSimulcastLayers: true,
-            },
-            {
+            }),
+            new SimulcastCodec({
               codec: opts.backupCodec.codec,
               cid: '',
               enableSimulcastLayers: true,
-            },
+            }),
           ];
         } else if (opts.videoCodec) {
           // pass codec info to sfu so it can prefer codec for the client which don't support
           // setCodecPreferences
           req.simulcastCodecs = [
-            {
+            new SimulcastCodec({
               codec: opts.videoCodec,
               cid: track.mediaStreamTrack.id,
               enableSimulcastLayers: opts.simulcast ?? false,
-            },
+            }),
           ];
         }
       }
@@ -879,7 +859,7 @@ export default class LocalParticipant extends Participant {
       return;
     }
     const simulcastTrack = track.addSimulcastTrack(videoCodec, encodings);
-    const req = AddTrackRequest.fromPartial({
+    const req = new AddTrackRequest({
       cid: simulcastTrack.mediaStreamTrack.id,
       type: Track.kindToProto(track.kind),
       muted: track.isMuted,
@@ -1099,18 +1079,18 @@ export default class LocalParticipant extends Participant {
       });
     }
 
-    const packet: DataPacket = {
+    const packet = new DataPacket({
       kind,
       value: {
-        $case: 'user',
-        user: {
+        case: 'user',
+        value: new UserPacket({
           participantSid: this.sid,
           payload: data,
           destinationSids: destinationSids,
           topic,
-        },
+        }),
       },
-    };
+    });
 
     await this.engine.sendDataPacket(packet, kind);
   }
@@ -1333,10 +1313,12 @@ export default class LocalParticipant extends Participant {
     const infos: TrackPublishedResponse[] = [];
     this.tracks.forEach((track: LocalTrackPublication) => {
       if (track.track !== undefined) {
-        infos.push({
-          cid: track.track.mediaStreamID,
-          track: track.trackInfo,
-        });
+        infos.push(
+          new TrackPublishedResponse({
+            cid: track.track.mediaStreamID,
+            track: track.trackInfo,
+          }),
+        );
       }
     });
     return infos;
@@ -1347,11 +1329,13 @@ export default class LocalParticipant extends Participant {
     const infos: DataChannelInfo[] = [];
     const getInfo = (dc: RTCDataChannel | undefined, target: SignalTarget) => {
       if (dc?.id !== undefined && dc.id !== null) {
-        infos.push({
-          label: dc.label,
-          id: dc.id,
-          target,
-        });
+        infos.push(
+          new DataChannelInfo({
+            label: dc.label,
+            id: dc.id,
+            target,
+          }),
+        );
       }
     };
     getInfo(this.engine.dataChannelForKind(DataPacket_Kind.LOSSY), SignalTarget.PUBLISHER);

package/src/room/participant/Participant.ts

@@ -1,4 +1,5 @@
-import EventEmitter from 'eventemitter3';
+import { EventEmitter } from 'events';
+import type TypedEmitter from 'typed-emitter';
 import log from '../../logger';
 import {
   DataPacket_Kind,
@@ -6,7 +7,7 @@ import {
   ParticipantPermission,
   ConnectionQuality as ProtoQuality,
   SubscriptionError,
-} from '../../proto/livekit_models';
+} from '../../proto/livekit_models_pb';
 import { ParticipantEvent, TrackEvent } from '../events';
 import type LocalTrackPublication from '../track/LocalTrackPublication';
 import type RemoteTrack from '../track/RemoteTrack';
@@ -34,7 +35,7 @@ function qualityFromProto(q: ProtoQuality): ConnectionQuality {
   }
 }
 
-export default class Participant extends EventEmitter<ParticipantEventCallbacks> {
+export default class Participant extends (EventEmitter as new () => TypedEmitter<ParticipantEventCallbacks>) {
   protected participantInfo?: ParticipantInfo;
 
   audioTracks: Map<string, TrackPublication>;
@@ -75,6 +76,7 @@ export default class Participant extends EventEmitter<ParticipantEventCallbacks>
   /** @internal */
   constructor(sid: string, identity: string, name?: string, metadata?: string) {
     super();
+    this.setMaxListeners(100);
     this.sid = sid;
     this.identity = identity;
     this.name = name;
@@ -141,7 +143,7 @@ export default class Participant extends EventEmitter<ParticipantEventCallbacks>
   /** when participant joined the room */
   get joinedAt(): Date | undefined {
     if (this.participantInfo) {
-      return new Date(this.participantInfo.joinedAt * 1000);
+      return new Date(Number.parseInt(this.participantInfo.joinedAt.toString()) * 1000);
     }
     return new Date();
   }

package/src/room/participant/ParticipantTrackPermission.ts

@@ -1,4 +1,4 @@
-import type { TrackPermission } from '../../proto/livekit_rtc';
+import { TrackPermission } from '../../proto/livekit_rtc_pb';
 
 export interface ParticipantTrackPermission {
   /**
@@ -33,10 +33,10 @@ export function trackPermissionToProto(perms: ParticipantTrackPermission): Track
       'Invalid track permission, must provide at least one of participantIdentity and participantSid',
     );
   }
-  return {
+  return new TrackPermission({
     participantIdentity: perms.participantIdentity ?? '',
     participantSid: perms.participantSid ?? '',
     allTracks: perms.allowAll ?? false,
     trackSids: perms.allowedTrackSids || [],
-  };
+  });
 }

package/src/room/participant/RemoteParticipant.ts

@@ -1,8 +1,7 @@
-import type EventEmitter from 'eventemitter3';
 import type { SignalClient } from '../../api/SignalClient';
 import log from '../../logger';
-import type { ParticipantInfo, SubscriptionError } from '../../proto/livekit_models';
-import type { UpdateSubscription, UpdateTrackSettings } from '../../proto/livekit_rtc';
+import type { ParticipantInfo, SubscriptionError } from '../../proto/livekit_models_pb';
+import type { UpdateSubscription, UpdateTrackSettings } from '../../proto/livekit_rtc_pb';
 import { ParticipantEvent, TrackEvent } from '../events';
 import RemoteAudioTrack from '../track/RemoteAudioTrack';
 import type RemoteTrack from '../track/RemoteTrack';
@@ -350,9 +349,9 @@ export default class RemoteParticipant extends Participant {
   }
 
   /** @internal */
-  emit<T extends EventEmitter.EventNames<ParticipantEventCallbacks>>(
-    event: T,
-    ...args: EventEmitter.EventArgs<ParticipantEventCallbacks, T>
+  emit<E extends keyof ParticipantEventCallbacks>(
+    event: E,
+    ...args: Parameters<ParticipantEventCallbacks[E]>
   ): boolean {
     log.trace('participant event', { participant: this.sid, event, args });
     return super.emit(event, ...args);

package/src/room/participant/publishUtils.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from 'vitest';
 import { ScreenSharePresets, VideoPreset, VideoPresets, VideoPresets43 } from '../track/options';
 import {
   computeDefaultScreenShareSimulcastPresets,

package/src/room/participant/publishUtils.ts

@@ -3,13 +3,13 @@ import { TrackInvalidError } from '../errors';
 import LocalAudioTrack from '../track/LocalAudioTrack';
 import LocalVideoTrack from '../track/LocalVideoTrack';
 import { Track } from '../track/Track';
-import { ScreenSharePresets, VideoPreset, VideoPresets, VideoPresets43 } from '../track/options';
 import type {
   BackupVideoCodec,
   TrackPublishOptions,
   VideoCodec,
   VideoEncoding,
 } from '../track/options';
+import { ScreenSharePresets, VideoPreset, VideoPresets, VideoPresets43 } from '../track/options';
 import { getReactNativeOs, isFireFox, isReactNative, isSVCCodec } from '../utils';
 
 /** @internal */
@@ -240,7 +240,9 @@ export function determineAppropriateEncoding(
   }
   // presets are based on the assumption of vp8 as a codec
   // for other codecs we adjust the maxBitrate if no specific videoEncoding has been provided
-  // TODO make the bitrate multipliers configurable per codec
+  // users should override these with ones that are optimized for their use case
+  // NOTE: SVC codec bitrates are inclusive of all scalability layers. while
+  // bitrate for non-SVC codecs does not include other simulcast layers.
   if (codec) {
     switch (codec) {
       case 'av1':

package/src/room/track/LocalTrack.ts

@@ -1,3 +1,4 @@
+import { debounce } from 'ts-debounce';
 import log from '../../logger';
 import { getBrowser } from '../../utils/browserParser';
 import DeviceManager from '../DeviceManager';
@@ -108,8 +109,8 @@ export default abstract class LocalTrack extends Track {
         detachTrack(this._mediaStreamTrack, el);
       });
       this._mediaStreamTrack.removeEventListener('ended', this.handleEnded);
-      this._mediaStreamTrack.removeEventListener('mute', this.pauseUpstream);
-      this._mediaStreamTrack.removeEventListener('unmute', this.resumeUpstream);
+      this._mediaStreamTrack.removeEventListener('mute', this.handleTrackMuteEvent);
+      this._mediaStreamTrack.removeEventListener('unmute', this.handleTrackUnmuteEvent);
       if (!this.providedByUser && this._mediaStreamTrack !== newTrack) {
         this._mediaStreamTrack.stop();
       }
@@ -123,8 +124,8 @@ export default abstract class LocalTrack extends Track {
       // the track is "muted"
       // note this is different from LocalTrack.mute because we do not want to
       // touch MediaStreamTrack.enabled
-      newTrack.addEventListener('mute', this.pauseUpstream);
-      newTrack.addEventListener('unmute', this.resumeUpstream);
+      newTrack.addEventListener('mute', this.handleTrackMuteEvent);
+      newTrack.addEventListener('unmute', this.handleTrackUnmuteEvent);
       this._constraints = newTrack.getConstraints();
     }
     if (this.sender) {
@@ -274,18 +275,32 @@ export default abstract class LocalTrack extends Track {
     log.debug(`visibility changed, is in Background: ${this.isInBackground}`);
 
     if (!this.isInBackground && this.needsReAcquisition && !this.isUserProvided && !this.isMuted) {
-      log.debug(`track needs to be reaquired, restarting ${this.source}`);
+      log.debug(`track needs to be reacquired, restarting ${this.source}`);
       await this.restart();
       this.reacquireTrack = false;
     }
   }
 
+  private handleTrackMuteEvent = () =>
+    this.debouncedTrackMuteHandler().catch(() =>
+      log.debug('track mute bounce got cancelled by an unmute event'),
+    );
+
+  private debouncedTrackMuteHandler = debounce(async () => {
+    await this.pauseUpstream();
+  }, 5000);
+
+  private handleTrackUnmuteEvent = async () => {
+    this.debouncedTrackMuteHandler.cancel('unmute');
+    await this.resumeUpstream();
+  };
+
   private handleEnded = () => {
     if (this.isInBackground) {
       this.reacquireTrack = true;
     }
-    this._mediaStreamTrack.removeEventListener('mute', this.pauseUpstream);
-    this._mediaStreamTrack.removeEventListener('unmute', this.resumeUpstream);
+    this._mediaStreamTrack.removeEventListener('mute', this.handleTrackMuteEvent);
+    this._mediaStreamTrack.removeEventListener('unmute', this.handleTrackUnmuteEvent);
     this.emit(TrackEvent.Ended, this);
   };
 
@@ -293,8 +308,8 @@ export default abstract class LocalTrack extends Track {
     super.stop();
 
     this._mediaStreamTrack.removeEventListener('ended', this.handleEnded);
-    this._mediaStreamTrack.removeEventListener('mute', this.pauseUpstream);
-    this._mediaStreamTrack.removeEventListener('unmute', this.resumeUpstream);
+    this._mediaStreamTrack.removeEventListener('mute', this.handleTrackMuteEvent);
+    this._mediaStreamTrack.removeEventListener('unmute', this.handleTrackUnmuteEvent);
     this.processor?.destroy();
     this.processor = undefined;
   }

package/src/room/track/LocalTrackPublication.ts

@@ -1,4 +1,4 @@
-import type { TrackInfo } from '../../proto/livekit_models';
+import type { TrackInfo } from '../../proto/livekit_models_pb';
 import { TrackEvent } from '../events';
 import type LocalAudioTrack from './LocalAudioTrack';
 import type LocalTrack from './LocalTrack';

package/src/room/track/LocalVideoTrack.test.ts

@@ -1,4 +1,5 @@
-import { VideoQuality } from '../../proto/livekit_models';
+import { describe, expect, it } from 'vitest';
+import { VideoQuality } from '../../proto/livekit_models_pb';
 import { videoLayersFromEncodings } from './LocalVideoTrack';
 
 describe('videoLayersFromEncodings', () => {

package/src/room/track/LocalVideoTrack.ts

@@ -1,10 +1,10 @@
 import type { SignalClient } from '../../api/SignalClient';
 import log from '../../logger';
-import { VideoLayer, VideoQuality } from '../../proto/livekit_models';
-import type { SubscribedCodec, SubscribedQuality } from '../../proto/livekit_rtc';
+import { VideoLayer, VideoQuality } from '../../proto/livekit_models_pb';
+import { SubscribedCodec, SubscribedQuality } from '../../proto/livekit_rtc_pb';
 import { ScalabilityMode } from '../participant/publishUtils';
-import { computeBitrate, monitorFrequency } from '../stats';
 import type { VideoSenderStats } from '../stats';
+import { computeBitrate, monitorFrequency } from '../stats';
 import { Mutex, isFireFox, isMobile, isWeb, unwrapConstraint } from '../utils';
 import LocalTrack from './LocalTrack';
 import { Track } from './Track';
@@ -173,10 +173,12 @@ export default class LocalVideoTrack extends LocalTrack {
   setPublishingQuality(maxQuality: VideoQuality) {
     const qualities: SubscribedQuality[] = [];
     for (let q = VideoQuality.LOW; q <= VideoQuality.HIGH; q += 1) {
-      qualities.push({
-        quality: q,
-        enabled: q <= maxQuality,
-      });
+      qualities.push(
+        new SubscribedQuality({
+          quality: q,
+          enabled: q <= maxQuality,
+        }),
+      );
     }
     log.debug(`setting publishing quality. max quality ${maxQuality}`);
     this.setPublishingLayers(qualities);
@@ -358,7 +360,7 @@ async function setPublishingLayersForSender(
     let hasChanged = false;
 
     /* disable closable spatial layer as it has video blur / frozen issue with current server / client
-    1. chrome 113: when switching to up layer with scalability Mode change, it will generate a 
+    1. chrome 113: when switching to up layer with scalability Mode change, it will generate a
           low resolution frame and recover very quickly, but noticable
     2. livekit sfu: additional pli request cause video frozen for a few frames, also noticable */
     const closableSpatial = false;
@@ -456,7 +458,7 @@ export function videoQualityForRid(rid: string): VideoQuality {
     case 'q':
       return VideoQuality.LOW;
     default:
-      return VideoQuality.UNRECOGNIZED;
+      return VideoQuality.HIGH;
   }
 }
 
@@ -469,29 +471,32 @@ export function videoLayersFromEncodings(
   // default to a single layer, HQ
   if (!encodings) {
     return [
-      {
+      new VideoLayer({
         quality: VideoQuality.HIGH,
         width,
         height,
         bitrate: 0,
         ssrc: 0,
-      },
+      }),
     ];
   }
 
   if (svc) {
     // svc layers
     /* @ts-ignore */
-    const sm = new ScalabilityMode(encodings[0].scalabilityMode);
+    const encodingSM = encodings[0].scalabilityMode as string;
+    const sm = new ScalabilityMode(encodingSM);
     const layers = [];
     for (let i = 0; i < sm.spatial; i += 1) {
-      layers.push({
-        quality: VideoQuality.HIGH - i,
-        width: width / 2 ** i,
-        height: height / 2 ** i,
-        bitrate: encodings[0].maxBitrate ? encodings[0].maxBitrate / 3 ** i : 0,
-        ssrc: 0,
-      });
+      layers.push(
+        new VideoLayer({
+          quality: VideoQuality.HIGH - i,
+          width: Math.ceil(width / 2 ** i),
+          height: Math.ceil(height / 2 ** i),
+          bitrate: encodings[0].maxBitrate ? Math.ceil(encodings[0].maxBitrate / 3 ** i) : 0,
+          ssrc: 0,
+        }),
+      );
     }
     return layers;
   }
@@ -499,15 +504,12 @@ export function videoLayersFromEncodings(
   return encodings.map((encoding) => {
     const scale = encoding.scaleResolutionDownBy ?? 1;
     let quality = videoQualityForRid(encoding.rid ?? '');
-    if (quality === VideoQuality.UNRECOGNIZED && encodings.length === 1) {
-      quality = VideoQuality.HIGH;
-    }
-    return {
+    return new VideoLayer({
       quality,
-      width: width / scale,
-      height: height / scale,
+      width: Math.ceil(width / scale),
+      height: Math.ceil(height / scale),
       bitrate: encoding.maxBitrate ?? 0,
       ssrc: 0,
-    };
+    });
   });
 }

package/src/room/track/RemoteTrackPublication.ts

@@ -1,6 +1,11 @@
 import log from '../../logger';
-import { SubscriptionError, TrackInfo, VideoQuality } from '../../proto/livekit_models';
-import { UpdateSubscription, UpdateTrackSettings } from '../../proto/livekit_rtc';
+import {
+  ParticipantTracks,
+  SubscriptionError,
+  TrackInfo,
+  VideoQuality,
+} from '../../proto/livekit_models_pb';
+import { UpdateSubscription, UpdateTrackSettings } from '../../proto/livekit_rtc_pb';
 import { TrackEvent } from '../events';
 import type RemoteTrack from './RemoteTrack';
 import RemoteVideoTrack from './RemoteVideoTrack';
@@ -46,18 +51,18 @@ export default class RemoteTrackPublication extends TrackPublication {
       this.allowed = true;
     }
 
-    const sub: UpdateSubscription = {
+    const sub = new UpdateSubscription({
       trackSids: [this.trackSid],
       subscribe: this.subscribed,
       participantTracks: [
-        {
+        new ParticipantTracks({
           // sending an empty participant id since TrackPublication doesn't keep it
           // this is filled in by the participant that receives this message
           participantSid: '',
           trackSids: [this.trackSid],
-        },
+        }),
       ],
-    };
+    });
     this.emit(TrackEvent.UpdateSubscription, sub);
     this.emitSubscriptionUpdateIfChanged(prevStatus);
     this.emitPermissionUpdateIfChanged(prevPermission);
@@ -286,7 +291,7 @@ export default class RemoteTrackPublication extends TrackPublication {
 
   /* @internal */
   emitTrackUpdate() {
-    const settings: UpdateTrackSettings = UpdateTrackSettings.fromPartial({
+    const settings: UpdateTrackSettings = new UpdateTrackSettings({
       trackSids: [this.trackSid],
       disabled: this.disabled,
       fps: this.fps,

package/src/room/track/RemoteVideoTrack.test.ts

@@ -1,9 +1,10 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import MockMediaStreamTrack from '../../test/MockMediaStreamTrack';
 import { TrackEvent } from '../events';
 import RemoteVideoTrack, { ElementInfo } from './RemoteVideoTrack';
 import type { Track } from './Track';
 
-jest.useFakeTimers();
+vi.useFakeTimers();
 
 describe('RemoteVideoTrack', () => {
   let track: RemoteVideoTrack;
@@ -73,7 +74,7 @@ describe('RemoteVideoTrack', () => {
       elementInfo.setDimensions(100, 100);
 
       track.observeElementInfo(elementInfo);
-      jest.runAllTimers();
+      vi.runAllTimers();
 
       expect(events).toHaveLength(1);
       expect(events[0].width).toBe(100);
@@ -85,10 +86,10 @@ describe('RemoteVideoTrack', () => {
       elementInfo.setDimensions(100, 100);
 
       track.observeElementInfo(elementInfo);
-      jest.runAllTimers();
+      vi.runAllTimers();
 
       elementInfo.setDimensions(200, 200);
-      jest.runAllTimers();
+      vi.runAllTimers();
 
       expect(events).toHaveLength(2);
       expect(events[1].width).toBe(200);

package/src/room/track/Track.ts

@@ -1,8 +1,9 @@
-import EventEmitter from 'eventemitter3';
+import { EventEmitter } from 'events';
+import type TypedEventEmitter from 'typed-emitter';
 import type { SignalClient } from '../../api/SignalClient';
 import log from '../../logger';
-import { TrackSource, TrackType } from '../../proto/livekit_models';
-import { StreamState as ProtoStreamState } from '../../proto/livekit_rtc';
+import { TrackSource, TrackType } from '../../proto/livekit_models_pb';
+import { StreamState as ProtoStreamState } from '../../proto/livekit_rtc_pb';
 import { TrackEvent } from '../events';
 import { isFireFox, isSafari, isWeb } from '../utils';
 
@@ -12,7 +13,7 @@ const BACKGROUND_REACTION_DELAY = 5000;
 // Safari tracks which audio elements have been "blessed" by the user.
 const recycledElements: Array<HTMLAudioElement> = [];
 
-export abstract class Track extends EventEmitter<TrackEventCallbacks> {
+export abstract class Track extends (EventEmitter as new () => TypedEventEmitter<TrackEventCallbacks>) {
   kind: Track.Kind;
 
   attachedElements: HTMLMediaElement[] = [];
@@ -51,6 +52,7 @@ export abstract class Track extends EventEmitter<TrackEventCallbacks> {
 
   protected constructor(mediaTrack: MediaStreamTrack, kind: Track.Kind) {
     super();
+    this.setMaxListeners(100);
     this.kind = kind;
     this._mediaStreamTrack = mediaTrack;
     this._mediaStreamID = mediaTrack.id;
@@ -368,7 +370,8 @@ export namespace Track {
       case Kind.Video:
         return TrackType.VIDEO;
       default:
-        return TrackType.UNRECOGNIZED;
+        // FIXME this was UNRECOGNIZED before
+        return TrackType.DATA;
     }
   }
 
@@ -396,7 +399,7 @@ export namespace Track {
       case Source.ScreenShareAudio:
         return TrackSource.SCREEN_SHARE_AUDIO;
       default:
-        return TrackSource.UNRECOGNIZED;
+        return TrackSource.UNKNOWN;
     }
   }