livekit-client 2.13.8 → 2.15.0

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

@@ -21,6 +21,8 @@ export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
     private subscribedCodecs?;
     private senderLock;
     private degradationPreference;
+    private isCpuConstrained;
+    private optimizeForPerformance;
     get sender(): RTCRtpSender | undefined;
     set sender(sender: RTCRtpSender | undefined);
     /**
@@ -56,6 +58,11 @@ export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
      * Sets layers that should be publishing
      */
     setPublishingLayers(isSvc: boolean, qualities: SubscribedQuality[]): Promise<void>;
+    /**
+     * Designed for lower powered devices, reduces video publishing quality and disables simulcast.
+     * @experimental
+     */
+    prioritizePerformance(): Promise<void>;
     protected monitorSender: () => Promise<void>;
     protected handleAppVisibilityChanged(): Promise<void>;
 }

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

@@ -8,9 +8,11 @@ export default class RemoteTrackPublication extends TrackPublication {
     /** @internal */
     protected allowed: boolean;
     protected subscribed?: boolean;
-    protected disabled: boolean;
-    protected currentVideoQuality?: VideoQuality;
-    protected videoDimensions?: Track.Dimensions;
+    protected requestedDisabled: boolean | undefined;
+    protected visible: boolean;
+    protected videoDimensionsAdaptiveStream?: Track.Dimensions;
+    protected requestedVideoDimensions?: Track.Dimensions;
+    protected requestedMaxQuality?: VideoQuality;
     protected fps?: number;
     protected subscriptionError?: SubscriptionError;
     constructor(kind: Track.Kind, ti: TrackInfo, autoSubscribe: boolean | undefined, loggerOptions?: LoggerOptions);
@@ -43,6 +45,13 @@ export default class RemoteTrackPublication extends TrackPublication {
      * optimize for uninterrupted video
      */
     setVideoQuality(quality: VideoQuality): void;
+    /**
+     * Explicitly set the video dimensions for this track.
+     *
+     * This will take precedence over adaptive stream dimensions.
+     *
+     * @param dimensions The video dimensions to set.
+     */
     setVideoDimensions(dimensions: Track.Dimensions): void;
     setVideoFPS(fps: number): void;
     get videoQuality(): VideoQuality | undefined;

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

@@ -146,6 +146,7 @@ export type TrackEventCallbacks = {
         rtpTimestamp: number;
     }) => void;
     preConnectBufferFlushed: (buffer: Uint8Array[]) => void;
+    cpuConstrained: () => void;
 };
 export {};
 //# sourceMappingURL=Track.d.ts.map

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

@@ -75,6 +75,7 @@ export type PublicationEventCallbacks = {
     subscriptionFailed: (error: SubscriptionError) => void;
     transcriptionReceived: (transcription: TranscriptionSegment[]) => void;
     timeSyncUpdate: (timestamp: number) => void;
+    cpuConstrained: (track: LocalVideoTrack) => void;
 };
 export {};
 //# sourceMappingURL=TrackPublication.d.ts.map

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

@@ -149,6 +149,10 @@ export interface VideoCaptureOptions {
      * IDs which are acceptable and/or required.
      */
     deviceId?: ConstrainDOMString;
+    /**
+     * A ConstrainDouble specifying the frame rate or range of frame rates which are acceptable and/or required.
+     */
+    frameRate?: ConstrainDouble;
     /**
      * a facing or an array of facings which are acceptable and/or required.
      */
@@ -295,7 +299,8 @@ export declare const videoCodecs: readonly [
     "vp8",
     "h264",
     "vp9",
-    "av1"
+    "av1",
+    "h265"
 ];
 export type VideoCodec = (typeof videoCodecs)[number];
 export type BackupVideoCodec = (typeof backupCodecs)[number];

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

@@ -1,4 +1,4 @@
-import { TrackPublishedResponse, TrackSource } from '@livekit/protocol';
+import { TrackInfo, TrackPublishedResponse, TrackSource, VideoQuality } from '@livekit/protocol';
 import type { AudioProcessorOptions, TrackProcessor, VideoProcessorOptions } from '../..';
 import { Track } from './Track';
 import type { TrackPublication } from './TrackPublication';
@@ -42,4 +42,6 @@ export declare function extractProcessorsFromOptions(options: CreateLocalTracksO
     };
 };
 export declare function getTrackSourceFromProto(source: TrackSource): Track.Source;
+export declare function areDimensionsSmaller(a: Track.Dimensions, b: Track.Dimensions): boolean;
+export declare function layerDimensionsFor(trackInfo: TrackInfo, quality: VideoQuality): Track.Dimensions | undefined;
 //# sourceMappingURL=utils.d.ts.map

package/dist/ts4.2/src/room/utils.d.ts

@@ -27,6 +27,7 @@ export declare function supportsAdaptiveStream(): boolean;
 export declare function supportsDynacast(): boolean;
 export declare function supportsAV1(): boolean;
 export declare function supportsVP9(): boolean;
+export declare function supportsH265(): boolean;
 export declare function isSVCCodec(codec?: string): boolean;
 export declare function supportsSetSinkId(elm?: HTMLMediaElement): boolean;
 export declare function isBrowserSupported(): boolean;
@@ -34,7 +35,7 @@ export declare function isFireFox(): boolean;
 export declare function isChromiumBased(): boolean;
 export declare function isSafari(): boolean;
 export declare function isSafariBased(): boolean;
-export declare function isSafari17(): boolean;
+export declare function isSafari17Based(): boolean;
 export declare function isSafariSvcApi(browser?: BrowserDetails): boolean;
 export declare function isMobile(): boolean;
 export declare function isE2EESimulcastSupported(): boolean | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "2.13.8",
+  "version": "2.15.0",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",
@@ -37,7 +37,7 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@livekit/mutex": "1.1.1",
-    "@livekit/protocol": "1.39.2",
+    "@livekit/protocol": "1.39.3",
     "events": "^3.3.0",
     "loglevel": "^1.9.2",
     "sdp-transform": "^2.15.0",
@@ -50,13 +50,13 @@
     "@types/dom-mediacapture-record": "^1"
   },
   "devDependencies": {
-    "@babel/core": "7.27.4",
-    "@babel/preset-env": "7.27.2",
+    "@babel/core": "7.28.0",
+    "@babel/preset-env": "7.28.0",
     "@bufbuild/protoc-gen-es": "^1.10.0",
-    "@changesets/cli": "2.29.4",
+    "@changesets/cli": "2.29.5",
     "@livekit/changesets-changelog-github": "^0.0.4",
     "@rollup/plugin-babel": "6.0.4",
-    "@rollup/plugin-commonjs": "28.0.5",
+    "@rollup/plugin-commonjs": "28.0.6",
     "@rollup/plugin-json": "6.1.0",
     "@rollup/plugin-node-resolve": "16.0.1",
     "@rollup/plugin-terser": "^0.4.4",
@@ -73,20 +73,20 @@
     "eslint-config-airbnb-typescript": "18.0.0",
     "eslint-config-prettier": "10.1.5",
     "eslint-plugin-ecmascript-compat": "^3.2.1",
-    "eslint-plugin-import": "2.31.0",
+    "eslint-plugin-import": "2.32.0",
     "gh-pages": "6.3.0",
     "happy-dom": "^17.2.0",
     "jsdom": "^26.1.0",
     "prettier": "^3.4.2",
-    "rollup": "4.43.0",
+    "rollup": "4.44.1",
     "rollup-plugin-delete": "^2.1.0",
     "rollup-plugin-typescript2": "0.36.0",
     "size-limit": "^11.2.0",
-    "typedoc": "0.28.5",
+    "typedoc": "0.28.7",
     "typedoc-plugin-no-inherit": "1.6.1",
     "typescript": "5.8.3",
-    "vite": "5.4.19",
-    "vitest": "^1.6.0"
+    "vite": "7.0.0",
+    "vitest": "^3.0.0"
   },
   "scripts": {
     "build": "rollup --config --bundleConfigAsCjs && rollup --config rollup.config.worker.js --bundleConfigAsCjs && pnpm downlevel-dts",

package/src/e2ee/E2eeManager.ts

@@ -221,8 +221,9 @@ export class E2EEManager
           this.room.localParticipant.identity,
         );
       });
-    room.localParticipant.on(ParticipantEvent.LocalTrackPublished, async (publication) => {
-      this.setupE2EESender(publication.track!, publication.track!.sender!);
+
+    room.localParticipant.on(ParticipantEvent.LocalSenderCreated, async (sender, track) => {
+      this.setupE2EESender(track, sender);
     });
 
     keyProvider

package/src/room/PCTransport.ts

@@ -1,3 +1,4 @@
+import { Mutex } from '@livekit/mutex';
 import { EventEmitter } from 'events';
 import type { MediaDescription, SessionDescription } from 'sdp-transform';
 import { parse, write } from 'sdp-transform';
@@ -52,6 +53,8 @@ export default class PCTransport extends EventEmitter {
 
   private latestOfferId: number = 0;
 
+  private offerLock: Mutex;
+
   pendingCandidates: RTCIceCandidateInit[] = [];
 
   restartingIce: boolean = false;
@@ -86,6 +89,7 @@ export default class PCTransport extends EventEmitter {
     this.loggerOptions = loggerOptions;
     this.config = config;
     this._pc = this.createPC();
+    this.offerLock = new Mutex();
   }
 
   private createPC() {
@@ -251,101 +255,108 @@ export default class PCTransport extends EventEmitter {
   }, debounceInterval);
 
   async createAndSendOffer(options?: RTCOfferOptions) {
-    // increase the offer id at the start to ensure the offer is always > 0 so that we can use 0 as a default value for legacy behavior
-    const offerId = this.latestOfferId + 1;
-    this.latestOfferId = offerId;
-    if (this.onOffer === undefined) {
-      return;
-    }
+    const unlock = await this.offerLock.lock();
 
-    if (options?.iceRestart) {
-      this.log.debug('restarting ICE', this.logContext);
-      this.restartingIce = true;
-    }
+    try {
+      // increase the offer id at the start to ensure the offer is always > 0 so that we can use 0 as a default value for legacy behavior
+      const offerId = this.latestOfferId + 1;
+      this.latestOfferId = offerId;
 
-    if (this._pc && this._pc.signalingState === 'have-local-offer') {
-      // we're waiting for the peer to accept our offer, so we'll just wait
-      // the only exception to this is when ICE restart is needed
-      const currentSD = this._pc.remoteDescription;
-      if (options?.iceRestart && currentSD) {
-        // TODO: handle when ICE restart is needed but we don't have a remote description
-        // the best thing to do is to recreate the peerconnection
-        await this._pc.setRemoteDescription(currentSD);
-      } else {
-        this.renegotiate = true;
+      if (this.onOffer === undefined) {
         return;
       }
-    } else if (!this._pc || this._pc.signalingState === 'closed') {
-      this.log.warn('could not createOffer with closed peer connection', this.logContext);
-      return;
-    }
 
-    // actually negotiate
-    this.log.debug('starting to negotiate', this.logContext);
-    const offer = await this.pc.createOffer(options);
-    this.log.debug('original offer', { sdp: offer.sdp, ...this.logContext });
+      if (options?.iceRestart) {
+        this.log.debug('restarting ICE', this.logContext);
+        this.restartingIce = true;
+      }
 
-    const sdpParsed = parse(offer.sdp ?? '');
-    sdpParsed.media.forEach((media) => {
-      ensureIPAddrMatchVersion(media);
-      if (media.type === 'audio') {
-        ensureAudioNackAndStereo(media, [], []);
-      } else if (media.type === 'video') {
-        this.trackBitrates.some((trackbr): boolean => {
-          if (!media.msid || !trackbr.cid || !media.msid.includes(trackbr.cid)) {
-            return false;
-          }
+      if (this._pc && this._pc.signalingState === 'have-local-offer') {
+        // we're waiting for the peer to accept our offer, so we'll just wait
+        // the only exception to this is when ICE restart is needed
+        const currentSD = this._pc.remoteDescription;
+        if (options?.iceRestart && currentSD) {
+          // TODO: handle when ICE restart is needed but we don't have a remote description
+          // the best thing to do is to recreate the peerconnection
+          await this._pc.setRemoteDescription(currentSD);
+        } else {
+          this.renegotiate = true;
+          return;
+        }
+      } else if (!this._pc || this._pc.signalingState === 'closed') {
+        this.log.warn('could not createOffer with closed peer connection', this.logContext);
+        return;
+      }
 
-          let codecPayload = 0;
-          media.rtp.some((rtp): boolean => {
-            if (rtp.codec.toUpperCase() === trackbr.codec.toUpperCase()) {
-              codecPayload = rtp.payload;
-              return true;
+      // actually negotiate
+      this.log.debug('starting to negotiate', this.logContext);
+      const offer = await this.pc.createOffer(options);
+      this.log.debug('original offer', { sdp: offer.sdp, ...this.logContext });
+
+      const sdpParsed = parse(offer.sdp ?? '');
+      sdpParsed.media.forEach((media) => {
+        ensureIPAddrMatchVersion(media);
+        if (media.type === 'audio') {
+          ensureAudioNackAndStereo(media, [], []);
+        } else if (media.type === 'video') {
+          this.trackBitrates.some((trackbr): boolean => {
+            if (!media.msid || !trackbr.cid || !media.msid.includes(trackbr.cid)) {
+              return false;
             }
-            return false;
-          });
 
-          if (codecPayload === 0) {
-            return true;
-          }
+            let codecPayload = 0;
+            media.rtp.some((rtp): boolean => {
+              if (rtp.codec.toUpperCase() === trackbr.codec.toUpperCase()) {
+                codecPayload = rtp.payload;
+                return true;
+              }
+              return false;
+            });
 
-          if (isSVCCodec(trackbr.codec)) {
-            this.ensureVideoDDExtensionForSVC(media, sdpParsed);
-          }
+            if (codecPayload === 0) {
+              return true;
+            }
 
-          // TODO: av1 slow starting issue already fixed in chrome 124, clean this after some versions
-          // mung sdp for av1 bitrate setting that can't apply by sendEncoding
-          if (trackbr.codec !== 'av1') {
-            return true;
-          }
+            if (isSVCCodec(trackbr.codec)) {
+              this.ensureVideoDDExtensionForSVC(media, sdpParsed);
+            }
+
+            // TODO: av1 slow starting issue already fixed in chrome 124, clean this after some versions
+            // mung sdp for av1 bitrate setting that can't apply by sendEncoding
+            if (trackbr.codec !== 'av1') {
+              return true;
+            }
 
-          const startBitrate = Math.round(trackbr.maxbr * startBitrateForSVC);
+            const startBitrate = Math.round(trackbr.maxbr * startBitrateForSVC);
 
-          for (const fmtp of media.fmtp) {
-            if (fmtp.payload === codecPayload) {
-              // if another track's fmtp already is set, we cannot override the bitrate
-              // this has the unfortunate consequence of being forced to use the
-              // initial track's bitrate for all tracks
-              if (!fmtp.config.includes('x-google-start-bitrate')) {
-                fmtp.config += `;x-google-start-bitrate=${startBitrate}`;
+            for (const fmtp of media.fmtp) {
+              if (fmtp.payload === codecPayload) {
+                // if another track's fmtp already is set, we cannot override the bitrate
+                // this has the unfortunate consequence of being forced to use the
+                // initial track's bitrate for all tracks
+                if (!fmtp.config.includes('x-google-start-bitrate')) {
+                  fmtp.config += `;x-google-start-bitrate=${startBitrate}`;
+                }
+                break;
               }
-              break;
             }
-          }
-          return true;
+            return true;
+          });
+        }
+      });
+      if (this.latestOfferId > offerId) {
+        this.log.warn('latestOfferId mismatch', {
+          ...this.logContext,
+          latestOfferId: this.latestOfferId,
+          offerId,
         });
+        return;
       }
-    });
-    if (this.latestOfferId > offerId) {
-      this.log.warn('latestOfferId mismatch', {
-        ...this.logContext,
-        latestOfferId: this.latestOfferId,
-        offerId,
-      });
-      return;
+      await this.setMungedSDP(offer, write(sdpParsed));
+      this.onOffer(offer, this.latestOfferId);
+    } finally {
+      unlock();
     }
-    await this.setMungedSDP(offer, write(sdpParsed));
-    this.onOffer(offer, this.latestOfferId);
   }
 
   async createAndSetAnswer(): Promise<RTCSessionDescriptionInit> {

package/src/room/Room.ts

@@ -1337,6 +1337,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         this.options.videoCaptureDefaults!.deviceId = prevDeviceId;
         throw e;
       }
+      const isMuted = tracks.some((t) => t.track?.isMuted ?? false);
+      if (success && isMuted) shouldTriggerImmediateDeviceChange = true;
     } else if (kind === 'audiooutput') {
       shouldTriggerImmediateDeviceChange = true;
       if (

package/src/room/events.ts

@@ -429,6 +429,21 @@ export enum ParticipantEvent {
    */
   LocalTrackUnpublished = 'localTrackUnpublished',
 
+  /**
+   * A local track has been constrained by cpu.
+   * This event is useful to know when to reduce the capture resolution of the track.
+   *
+   * This event is emitted on the local participant.
+   *
+   * args: ([[LocalVideoTrack]], [[LocalTrackPublication]])
+   */
+  LocalTrackCpuConstrained = 'localTrackCpuConstrained',
+
+  /**
+   * @internal
+   */
+  LocalSenderCreated = 'localSenderCreated',
+
   /**
    * Participant metadata is a simple way for app-specific state to be pushed to
    * all users.
@@ -515,6 +530,11 @@ export enum ParticipantEvent {
    */
   TrackSubscriptionStatusChanged = 'trackSubscriptionStatusChanged',
 
+  /**
+   * a local track has been constrained by cpu
+   */
+  TrackCpuConstrained = 'trackCpuConstrained',
+
   // fired only on LocalParticipant
   /** @internal */
   MediaDevicesError = 'mediaDevicesError',
@@ -599,6 +619,7 @@ export enum TrackEvent {
   Ended = 'ended',
   Subscribed = 'subscribed',
   Unsubscribed = 'unsubscribed',
+  CpuConstrained = 'cpuConstrained',
   /** @internal */
   UpdateSettings = 'updateSettings',
   /** @internal */

package/src/room/participant/LocalParticipant.ts

@@ -93,7 +93,7 @@ import {
   isLocalTrack,
   isLocalVideoTrack,
   isSVCCodec,
-  isSafari17,
+  isSafari17Based,
   isVideoTrack,
   isWeb,
   numberToBigInt,
@@ -708,7 +708,7 @@ export default class LocalParticipant extends Participant {
       throw new DeviceUnsupportedError('getDisplayMedia not supported');
     }
 
-    if (options.resolution === undefined && !isSafari17()) {
+    if (options.resolution === undefined && !isSafari17Based()) {
       // we need to constrain the dimensions, otherwise it could lead to low bitrate
       // due to encoding a huge video. Encoding such large surfaces is really expensive
       // unfortunately Safari 17 has a but and cannot be constrained by default
@@ -1169,6 +1169,7 @@ export default class LocalParticipant extends Participant {
       }
 
       track.sender = await this.engine.createSender(track, opts, encodings);
+      this.emit(ParticipantEvent.LocalSenderCreated, track.sender, track);
 
       if (isLocalVideoTrack(track)) {
         opts.degradationPreference ??= getDefaultDegradationPreference(track);
@@ -1271,6 +1272,9 @@ export default class LocalParticipant extends Participant {
       loggerName: this.roomOptions.loggerName,
       loggerContextCb: () => this.logContext,
     });
+    publication.on(TrackEvent.CpuConstrained, (constrainedTrack) =>
+      this.onTrackCpuConstrained(constrainedTrack, publication),
+    );
     // save options for when it needs to be republished again
     publication.options = opts;
     track.sid = ti.sid;
@@ -2329,6 +2333,14 @@ export default class LocalParticipant extends Participant {
     this.engine.client.sendUpdateLocalAudioTrack(pub.trackSid, pub.getTrackFeatures());
   };
 
+  private onTrackCpuConstrained = (track: LocalVideoTrack, publication: LocalTrackPublication) => {
+    this.log.debug('track cpu constrained', {
+      ...this.logContext,
+      ...getLogContextFromTrack(publication),
+    });
+    this.emit(ParticipantEvent.LocalTrackCpuConstrained, track, publication);
+  };
+
   private handleSubscribedQualityUpdate = async (update: SubscribedQualityUpdate) => {
     if (!this.roomOptions?.dynacast) {
       return;

package/src/room/participant/Participant.ts

@@ -13,6 +13,7 @@ import type TypedEmitter from 'typed-emitter';
 import log, { LoggerNames, type StructuredLogger, getLogger } from '../../logger';
 import { ParticipantEvent, TrackEvent } from '../events';
 import type LocalTrackPublication from '../track/LocalTrackPublication';
+import type LocalVideoTrack from '../track/LocalVideoTrack';
 import type RemoteTrack from '../track/RemoteTrack';
 import type RemoteTrackPublication from '../track/RemoteTrackPublication';
 import { Track } from '../track/Track';
@@ -403,6 +404,8 @@ export type ParticipantEventCallbacks = {
   trackUnmuted: (publication: TrackPublication) => void;
   localTrackPublished: (publication: LocalTrackPublication) => void;
   localTrackUnpublished: (publication: LocalTrackPublication) => void;
+  localTrackCpuConstrained: (track: LocalVideoTrack, publication: LocalTrackPublication) => void;
+  localSenderCreated: (sender: RTCRtpSender, track: Track) => void;
   participantMetadataChanged: (prevMetadata: string | undefined, participant?: any) => void;
   participantNameChanged: (name: string) => void;
   dataReceived: (payload: Uint8Array, kind: DataPacket_Kind) => void;

package/src/room/participant/RemoteParticipant.ts

@@ -86,6 +86,7 @@ export default class RemoteParticipant extends Participant {
       this.log.debug('send update settings', {
         ...this.logContext,
         ...getLogContextFromTrack(publication),
+        settings,
       });
       this.signalClient.sendUpdateTrackSettings(settings);
     });

package/src/room/participant/publishUtils.ts

@@ -18,7 +18,7 @@ import {
   isFireFox,
   isReactNative,
   isSVCCodec,
-  isSafari,
+  isSafariBased,
   isSafariSvcApi,
   unwrapConstraint,
 } from '../utils';
@@ -151,7 +151,7 @@ export function computeVideoEncodings(
     // Announced here: https://groups.google.com/g/discuss-webrtc/c/-QQ3pxrl-fw?pli=1
     const browser = getBrowser();
     if (
-      isSafari() ||
+      isSafariBased() ||
       // 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
@@ -302,6 +302,7 @@ export function determineAppropriateEncoding(
   if (codec) {
     switch (codec) {
       case 'av1':
+      case 'h265':
         encoding = { ...encoding };
         encoding.maxBitrate = encoding.maxBitrate * 0.7;
         break;

package/src/room/track/LocalTrackPublication.ts

@@ -1,7 +1,7 @@
 import { AudioTrackFeature, TrackInfo } from '@livekit/protocol';
 import { TrackEvent } from '../events';
 import type { LoggerOptions } from '../types';
-import { isAudioTrack } from '../utils';
+import { isAudioTrack, isVideoTrack } from '../utils';
 import LocalAudioTrack from './LocalAudioTrack';
 import type LocalTrack from './LocalTrack';
 import type LocalVideoTrack from './LocalVideoTrack';
@@ -28,12 +28,14 @@ export default class LocalTrackPublication extends TrackPublication {
   setTrack(track?: Track) {
     if (this.track) {
       this.track.off(TrackEvent.Ended, this.handleTrackEnded);
+      this.track.off(TrackEvent.CpuConstrained, this.handleCpuConstrained);
     }
 
     super.setTrack(track);
 
     if (track) {
       track.on(TrackEvent.Ended, this.handleTrackEnded);
+      track.on(TrackEvent.CpuConstrained, this.handleCpuConstrained);
     }
   }
 
@@ -116,4 +118,10 @@ export default class LocalTrackPublication extends TrackPublication {
   handleTrackEnded = () => {
     this.emit(TrackEvent.Ended);
   };
+
+  private handleCpuConstrained = () => {
+    if (this.track && isVideoTrack(this.track)) {
+      this.emit(TrackEvent.CpuConstrained, this.track);
+    }
+  };
 }