livekit-client 1.9.1 → 1.9.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "1.9.1",
+  "version": "1.9.3",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",
@@ -51,8 +51,8 @@
     "webrtc-adapter": "^8.1.1"
   },
   "devDependencies": {
-    "@babel/core": "7.21.4",
-    "@babel/preset-env": "7.21.4",
+    "@babel/core": "7.21.8",
+    "@babel/preset-env": "7.21.5",
     "@changesets/cli": "2.26.1",
     "@livekit/changesets-changelog-github": "^0.0.4",
     "@rollup/plugin-babel": "6.0.3",
@@ -61,31 +61,31 @@
     "@rollup/plugin-node-resolve": "15.0.2",
     "@rollup/plugin-terser": "^0.4.0",
     "@trivago/prettier-plugin-sort-imports": "^4.1.1",
-    "@types/jest": "29.5.0",
+    "@types/jest": "29.5.1",
     "@types/sdp-transform": "2.4.6",
     "@types/ua-parser-js": "0.7.36",
     "@types/ws": "8.5.4",
-    "@typescript-eslint/eslint-plugin": "5.58.0",
-    "@typescript-eslint/parser": "5.58.0",
+    "@typescript-eslint/eslint-plugin": "5.59.2",
+    "@typescript-eslint/parser": "5.59.2",
     "downlevel-dts": "^0.11.0",
-    "eslint": "8.38.0",
+    "eslint": "8.39.0",
     "eslint-config-airbnb-typescript": "17.0.0",
     "eslint-config-prettier": "8.8.0",
     "eslint-plugin-import": "2.27.5",
     "gh-pages": "5.0.0",
     "jest": "29.5.0",
     "prettier": "^2.8.8",
-    "rollup": "3.20.2",
+    "rollup": "3.21.3",
     "rollup-plugin-delete": "^2.0.0",
     "rollup-plugin-filesize": "10.0.0",
     "rollup-plugin-re": "1.0.7",
     "rollup-plugin-typescript2": "0.34.1",
     "ts-jest": "29.1.0",
-    "ts-proto": "1.146.0",
-    "typedoc": "0.24.1",
+    "ts-proto": "1.147.1",
+    "typedoc": "0.24.6",
     "typedoc-plugin-no-inherit": "1.4.0",
-    "typescript": "4.9.5",
-    "vite": "4.2.1"
+    "typescript": "5.0.4",
+    "vite": "4.3.4"
   },
   "browserslist": [
     "safari >= 11",

package/src/api/SignalClient.ts

@@ -321,14 +321,8 @@ export class SignalClient {
       };
 
       this.ws.onclose = (ev: CloseEvent) => {
-        if (!this.isConnected) return;
-
-        log.debug(`websocket connection closed: ${ev.reason}`);
-        this.isConnected = false;
-        if (this.onClose) {
-          this.onClose(ev.reason);
-        }
-        this.ws = undefined;
+        log.warn(`websocket closed`, { ev });
+        this.handleOnClose(ev.reason);
       };
     });
   }
@@ -351,12 +345,14 @@ export class SignalClient {
           }
         });
 
-        this.ws.close();
-        // 250ms grace period for ws to close gracefully
-        await Promise.race([closePromise, sleep(250)]);
+        if (this.ws.readyState < this.ws.CLOSING) {
+          this.ws.close();
+          // 250ms grace period for ws to close gracefully
+          await Promise.race([closePromise, sleep(250)]);
+        }
+        this.ws = undefined;
+        this.clearPingInterval();
       }
-      this.ws = undefined;
-      this.clearPingInterval();
     } finally {
       unlock();
     }
@@ -618,6 +614,15 @@ export class SignalClient {
     this.isReconnecting = false;
   }
 
+  private async handleOnClose(reason: string) {
+    if (!this.isConnected) return;
+    await this.close();
+    log.debug(`websocket connection closed: ${reason}`);
+    if (this.onClose) {
+      this.onClose(reason);
+    }
+  }
+
   private handleWSError(ev: Event) {
     log.error('websocket error', ev);
   }
@@ -638,9 +643,7 @@ export class SignalClient {
           Date.now() - this.pingTimeoutDuration! * 1000,
         ).toUTCString()}`,
       );
-      if (this.onClose) {
-        this.onClose('ping timeout');
-      }
+      this.handleOnClose('ping timeout');
     }, this.pingTimeoutDuration * 1000);
   }
 

package/src/connectionHelper/ConnectionCheck.ts

@@ -1,6 +1,7 @@
 import EventEmitter from 'events';
 import type TypedEmitter from 'typed-emitter';
-import { CheckInfo, CheckStatus, Checker, InstantiableCheck } from './checks/Checker';
+import { CheckStatus, Checker } from './checks/Checker';
+import type { CheckInfo, InstantiableCheck } from './checks/Checker';
 import { PublishAudioCheck } from './checks/publishAudio';
 import { PublishVideoCheck } from './checks/publishVideo';
 import { ReconnectCheck } from './checks/reconnect';

package/src/index.ts

@@ -14,11 +14,12 @@ import LocalVideoTrack from './room/track/LocalVideoTrack';
 import RemoteAudioTrack from './room/track/RemoteAudioTrack';
 import RemoteTrack from './room/track/RemoteTrack';
 import RemoteTrackPublication from './room/track/RemoteTrackPublication';
-import RemoteVideoTrack, { type ElementInfo } from './room/track/RemoteVideoTrack';
+import type { ElementInfo } from './room/track/RemoteVideoTrack';
+import RemoteVideoTrack from './room/track/RemoteVideoTrack';
 import { TrackPublication } from './room/track/TrackPublication';
 import type { LiveKitReactNativeInfo } from './room/types';
+import type { AudioAnalyserOptions } from './room/utils';
 import {
-  type AudioAnalyserOptions,
   createAudioAnalyser,
   getEmptyAudioStreamTrack,
   getEmptyVideoStreamTrack,
@@ -26,18 +27,19 @@ import {
   supportsAV1,
   supportsAdaptiveStream,
   supportsDynacast,
+  supportsVP9,
 } from './room/utils';
 
+export * from './connectionHelper/ConnectionCheck';
 export * from './options';
 export * from './room/errors';
 export * from './room/events';
-export type { DataPublishOptions, SimulationScenario } from './room/types';
+export * from './room/track/Track';
 export * from './room/track/create';
 export * from './room/track/options';
-export * from './room/track/Track';
 export * from './room/track/types';
+export type { DataPublishOptions, SimulationScenario } from './room/types';
 export * from './version';
-export * from './connectionHelper/ConnectionCheck';
 export {
   setLogLevel,
   setLogExtension,
@@ -47,8 +49,8 @@ export {
   supportsAdaptiveStream,
   supportsDynacast,
   supportsAV1,
+  supportsVP9,
   createAudioAnalyser,
-  AudioAnalyserOptions,
   LogLevel,
   Room,
   ConnectionState,
@@ -66,12 +68,15 @@ export {
   RemoteAudioTrack,
   RemoteVideoTrack,
   RemoteTrackPublication,
-  ParticipantTrackPermission,
   TrackPublication,
   VideoQuality,
   ConnectionQuality,
-  ElementInfo,
   DefaultReconnectPolicy,
   CriticalTimers,
+};
+export type {
+  ElementInfo,
+  ParticipantTrackPermission,
+  AudioAnalyserOptions,
   LiveKitReactNativeInfo,
 };

package/src/room/PCTransport.ts

@@ -1,9 +1,10 @@
 import EventEmitter from 'events';
-import { MediaDescription, parse, write } from 'sdp-transform';
+import { parse, write } from 'sdp-transform';
+import type { MediaDescription } from 'sdp-transform';
 import { debounce } from 'ts-debounce';
 import log from '../logger';
 import { NegotiationError } from './errors';
-import { ddExtensionURI, isSVCCodec } from './utils';
+import { ddExtensionURI, isChromiumBased, isSVCCodec } from './utils';
 
 /** @internal */
 interface TrackBitrateInfo {
@@ -35,9 +36,12 @@ export default class PCTransport extends EventEmitter {
 
   onOffer?: (offer: RTCSessionDescriptionInit) => void;
 
-  constructor(config?: RTCConfiguration) {
+  constructor(config?: RTCConfiguration, mediaConstraints: Record<string, unknown> = {}) {
     super();
-    this.pc = new RTCPeerConnection(config);
+    this.pc = isChromiumBased()
+      ? // @ts-expect-error chrome allows additional media constraints to be passed into the RTCPeerConnection constructor
+        new RTCPeerConnection(config, mediaConstraints)
+      : new RTCPeerConnection(config);
   }
 
   get isICEConnected(): boolean {
@@ -289,7 +293,7 @@ function ensureVideoDDExtensionForSVC(
     payloads?: string | undefined;
   } & MediaDescription,
 ) {
-  const codec = media.rtp.at(0)?.codec?.toLowerCase();
+  const codec = media.rtp[0]?.codec?.toLowerCase();
   if (!isSVCCodec(codec)) {
     return;
   }

package/src/room/RTCEngine.ts

@@ -1,6 +1,7 @@
 import { EventEmitter } from 'events';
 import type TypedEventEmitter from 'typed-emitter';
-import { SignalClient, SignalOptions } from '../api/SignalClient';
+import { SignalClient } from '../api/SignalClient';
+import type { SignalOptions } from '../api/SignalClient';
 import log from '../logger';
 import type { InternalRoomOptions } from '../options';
 import {
@@ -77,6 +78,11 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
   fullReconnectOnNext: boolean = false;
 
+  /**
+   * @internal
+   */
+  latestJoinResponse?: JoinResponse;
+
   get isClosed() {
     return this._isClosed;
   }
@@ -171,6 +177,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       this.joinAttempts += 1;
       const joinResponse = await this.client.join(url, token, opts, abortSignal);
       this._isClosed = false;
+      this.latestJoinResponse = joinResponse;
 
       this.subscriberPrimary = joinResponse.subscriberPrimary;
       if (!this.publisher) {
@@ -307,8 +314,8 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     this.participantSid = joinResponse.participant?.sid;
 
     const rtcConfig = this.makeRTCConfiguration(joinResponse);
-
-    this.publisher = new PCTransport(rtcConfig);
+    const googConstraints = { optional: [{ googDscp: true }] };
+    this.publisher = new PCTransport(rtcConfig, googConstraints);
     this.subscriber = new PCTransport(rtcConfig);
 
     this.emit(EngineEvent.TransportsCreated, this.publisher, this.subscriber);
@@ -821,7 +828,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
           }ms. giving up`,
         );
         this.emit(EngineEvent.Disconnected);
-        this.close();
+        await this.close();
       }
     } finally {
       this.attemptingReconnect = false;
@@ -1120,6 +1127,39 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     await this.ensureDataTransportConnected(kind, false);
   }
 
+  /* @internal */
+  verifyTransport(): boolean {
+    // primary connection
+    if (!this.primaryPC) {
+      return false;
+    }
+    if (
+      this.primaryPC.connectionState === 'closed' ||
+      this.primaryPC.connectionState === 'failed'
+    ) {
+      return false;
+    }
+
+    // also verify publisher connection if it's needed or different
+    if (this.hasPublished && this.subscriberPrimary) {
+      if (!this.publisher) {
+        return false;
+      }
+      if (
+        this.publisher.pc.connectionState === 'closed' ||
+        this.publisher.pc.connectionState === 'failed'
+      ) {
+        return false;
+      }
+    }
+
+    // ensure signal is connected
+    if (!this.client.ws || this.client.ws.readyState === WebSocket.CLOSED) {
+      return false;
+    }
+    return true;
+  }
+
   /** @internal */
   negotiate(): Promise<void> {
     // observe signal state

package/src/room/Room.ts

@@ -45,6 +45,7 @@ import LocalParticipant from './participant/LocalParticipant';
 import type Participant from './participant/Participant';
 import type { ConnectionQuality } from './participant/Participant';
 import RemoteParticipant from './participant/RemoteParticipant';
+import CriticalTimers from './timers';
 import LocalAudioTrack from './track/LocalAudioTrack';
 import LocalTrackPublication from './track/LocalTrackPublication';
 import LocalVideoTrack from './track/LocalVideoTrack';
@@ -73,6 +74,8 @@ export enum ConnectionState {
   Reconnecting = 'reconnecting',
 }
 
+const connectionReconcileFrequency = 2 * 1000;
+
 /** @deprecated RoomState has been renamed to [[ConnectionState]] */
 export const RoomState = ConnectionState;
 
@@ -126,6 +129,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
   private cachedParticipantSids: Array<string>;
 
+  private connectionReconcileInterval?: ReturnType<typeof setInterval>;
+
   /**
    * Creates a new Room, the primary construct for a LiveKit session.
    * @param options
@@ -189,7 +194,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   }
 
   private maybeCreateEngine() {
-    if (this.engine) {
+    if (this.engine && !this.engine.isClosed) {
       return;
     }
 
@@ -215,6 +220,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       .on(EngineEvent.ActiveSpeakersUpdate, this.handleActiveSpeakersUpdate)
       .on(EngineEvent.DataPacketReceived, this.handleDataPacket)
       .on(EngineEvent.Resuming, () => {
+        this.clearConnectionReconcile();
         if (this.setAndEmitConnectionState(ConnectionState.Reconnecting)) {
           this.emit(RoomEvent.Reconnecting);
         }
@@ -223,6 +229,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       .on(EngineEvent.Resumed, () => {
         this.setAndEmitConnectionState(ConnectionState.Connected);
         this.emit(RoomEvent.Reconnected);
+        this.registerConnectionReconcile();
         this.updateSubscriptions();
 
         // once reconnected, figure out if any participants connected during reconnect and emit events for it
@@ -488,6 +495,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
     this.setAndEmitConnectionState(ConnectionState.Connected);
     this.emit(RoomEvent.Connected);
+    this.registerConnectionReconcile();
   };
 
   /**
@@ -829,6 +837,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   }
 
   private handleRestarting = () => {
+    this.clearConnectionReconcile();
     // also unwind existing participants & existing subscriptions
     for (const p of this.participants.values()) {
       this.handleParticipantDisconnected(p.sid, p);
@@ -894,6 +903,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
     this.setAndEmitConnectionState(ConnectionState.Connected);
     this.emit(RoomEvent.Reconnected);
+    this.registerConnectionReconcile();
 
     // emit participant connected events after connection has been re-established
     this.participants.forEach((participant) => {
@@ -902,57 +912,61 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   };
 
   private handleDisconnect(shouldStopTracks = true, reason?: DisconnectReason) {
+    this.clearConnectionReconcile();
     if (this.state === ConnectionState.Disconnected) {
       return;
     }
 
-    this.participants.forEach((p) => {
-      p.tracks.forEach((pub) => {
-        p.unpublishTrack(pub.trackSid);
+    try {
+      this.participants.forEach((p) => {
+        p.tracks.forEach((pub) => {
+          p.unpublishTrack(pub.trackSid);
+        });
       });
-    });
 
-    this.localParticipant.tracks.forEach((pub) => {
-      if (pub.track) {
-        this.localParticipant.unpublishTrack(pub.track, shouldStopTracks);
-      }
-      if (shouldStopTracks) {
-        pub.track?.detach();
-        pub.track?.stop();
-      }
-    });
+      this.localParticipant.tracks.forEach((pub) => {
+        if (pub.track) {
+          this.localParticipant.unpublishTrack(pub.track, shouldStopTracks);
+        }
+        if (shouldStopTracks) {
+          pub.track?.detach();
+          pub.track?.stop();
+        }
+      });
 
-    this.localParticipant
-      .off(ParticipantEvent.ParticipantMetadataChanged, this.onLocalParticipantMetadataChanged)
-      .off(ParticipantEvent.ParticipantNameChanged, this.onLocalParticipantNameChanged)
-      .off(ParticipantEvent.TrackMuted, this.onLocalTrackMuted)
-      .off(ParticipantEvent.TrackUnmuted, this.onLocalTrackUnmuted)
-      .off(ParticipantEvent.LocalTrackPublished, this.onLocalTrackPublished)
-      .off(ParticipantEvent.LocalTrackUnpublished, this.onLocalTrackUnpublished)
-      .off(ParticipantEvent.ConnectionQualityChanged, this.onLocalConnectionQualityChanged)
-      .off(ParticipantEvent.MediaDevicesError, this.onMediaDevicesError)
-      .off(
-        ParticipantEvent.ParticipantPermissionsChanged,
-        this.onLocalParticipantPermissionsChanged,
-      );
+      this.localParticipant
+        .off(ParticipantEvent.ParticipantMetadataChanged, this.onLocalParticipantMetadataChanged)
+        .off(ParticipantEvent.ParticipantNameChanged, this.onLocalParticipantNameChanged)
+        .off(ParticipantEvent.TrackMuted, this.onLocalTrackMuted)
+        .off(ParticipantEvent.TrackUnmuted, this.onLocalTrackUnmuted)
+        .off(ParticipantEvent.LocalTrackPublished, this.onLocalTrackPublished)
+        .off(ParticipantEvent.LocalTrackUnpublished, this.onLocalTrackUnpublished)
+        .off(ParticipantEvent.ConnectionQualityChanged, this.onLocalConnectionQualityChanged)
+        .off(ParticipantEvent.MediaDevicesError, this.onMediaDevicesError)
+        .off(
+          ParticipantEvent.ParticipantPermissionsChanged,
+          this.onLocalParticipantPermissionsChanged,
+        );
 
-    this.localParticipant.tracks.clear();
-    this.localParticipant.videoTracks.clear();
-    this.localParticipant.audioTracks.clear();
+      this.localParticipant.tracks.clear();
+      this.localParticipant.videoTracks.clear();
+      this.localParticipant.audioTracks.clear();
 
-    this.participants.clear();
-    this.activeSpeakers = [];
-    if (this.audioContext && typeof this.options.expWebAudioMix === 'boolean') {
-      this.audioContext.close();
-      this.audioContext = undefined;
-    }
-    if (isWeb()) {
-      window.removeEventListener('beforeunload', this.onPageLeave);
-      window.removeEventListener('pagehide', this.onPageLeave);
-      navigator.mediaDevices?.removeEventListener('devicechange', this.handleDeviceChange);
+      this.participants.clear();
+      this.activeSpeakers = [];
+      if (this.audioContext && typeof this.options.expWebAudioMix === 'boolean') {
+        this.audioContext.close();
+        this.audioContext = undefined;
+      }
+      if (isWeb()) {
+        window.removeEventListener('beforeunload', this.onPageLeave);
+        window.removeEventListener('pagehide', this.onPageLeave);
+        navigator.mediaDevices?.removeEventListener('devicechange', this.handleDeviceChange);
+      }
+    } finally {
+      this.setAndEmitConnectionState(ConnectionState.Disconnected);
+      this.emit(RoomEvent.Disconnected, reason);
     }
-    this.setAndEmitConnectionState(ConnectionState.Disconnected);
-    this.emit(RoomEvent.Disconnected, reason);
   }
 
   private handleParticipantUpdates = (participantInfos: ParticipantInfo[]) => {
@@ -1341,6 +1355,37 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
   }
 
+  private registerConnectionReconcile() {
+    this.clearConnectionReconcile();
+    let consecutiveFailures = 0;
+    this.connectionReconcileInterval = CriticalTimers.setInterval(() => {
+      if (
+        // ensure we didn't tear it down
+        !this.engine ||
+        // engine detected close, but Room missed it
+        this.engine.isClosed ||
+        // transports failed without notifying engine
+        !this.engine.verifyTransport()
+      ) {
+        consecutiveFailures++;
+        log.warn('detected connection state mismatch', { numFailures: consecutiveFailures });
+        if (consecutiveFailures >= 3)
+          this.handleDisconnect(
+            this.options.stopLocalTrackOnUnpublish,
+            DisconnectReason.UNKNOWN_REASON,
+          );
+      } else {
+        consecutiveFailures = 0;
+      }
+    }, connectionReconcileFrequency);
+  }
+
+  private clearConnectionReconcile() {
+    if (this.connectionReconcileInterval) {
+      CriticalTimers.clearInterval(this.connectionReconcileInterval);
+    }
+  }
+
   private setAndEmitConnectionState(state: ConnectionState): boolean {
     if (state === this.state) {
       // unchanged

package/src/room/defaults.ts

@@ -1,16 +1,18 @@
 import type { InternalRoomConnectOptions, InternalRoomOptions } from '../options';
 import DefaultReconnectPolicy from './DefaultReconnectPolicy';
-import {
+import { AudioPresets, ScreenSharePresets, VideoPresets } from './track/options';
+import type {
   AudioCaptureOptions,
-  AudioPresets,
-  ScreenSharePresets,
   TrackPublishDefaults,
   VideoCaptureOptions,
-  VideoPresets,
 } from './track/options';
 
 export const publishDefaults: TrackPublishDefaults = {
+  /**
+   * @deprecated
+   */
   audioBitrate: AudioPresets.music.maxBitrate,
+  audioPreset: AudioPresets.music,
   dtx: true,
   red: true,
   forceStereo: false,

package/src/room/participant/LocalParticipant.ts

@@ -18,22 +18,21 @@ import LocalTrack from '../track/LocalTrack';
 import LocalTrackPublication from '../track/LocalTrackPublication';
 import LocalVideoTrack, { videoLayersFromEncodings } from '../track/LocalVideoTrack';
 import { Track } from '../track/Track';
-import {
+import { ScreenSharePresets, isBackupCodec, isCodecEqual } from '../track/options';
+import type {
   AudioCaptureOptions,
   BackupVideoCodec,
   CreateLocalTracksOptions,
   ScreenShareCaptureOptions,
-  ScreenSharePresets,
   TrackPublishOptions,
   VideoCaptureOptions,
-  isBackupCodec,
-  isCodecEqual,
 } from '../track/options';
 import { constraintsForOptions, mergeDefaultOptions } from '../track/utils';
 import type { DataPublishOptions } from '../types';
 import { Future, isFireFox, isSVCCodec, isSafari, isWeb, supportsAV1, supportsVP9 } from '../utils';
 import Participant from './Participant';
-import { ParticipantTrackPermission, trackPermissionToProto } from './ParticipantTrackPermission';
+import { trackPermissionToProto } from './ParticipantTrackPermission';
+import type { ParticipantTrackPermission } from './ParticipantTrackPermission';
 import RemoteParticipant from './RemoteParticipant';
 import {
   computeTrackBackupEncodings,
@@ -151,7 +150,7 @@ export default class LocalParticipant extends Participant {
 
   /**
    * Sets and updates the metadata of the local participant.
-   * Note: this requires `CanUpdateOwnMetadata` permission encoded in the token.
+   * Note: this requires `canUpdateOwnMetadata` permission encoded in the token.
    * @param metadata
    */
   setMetadata(metadata: string): void {
@@ -161,7 +160,7 @@ export default class LocalParticipant extends Participant {
 
   /**
    * Sets and updates the name of the local participant.
-   * Note: this requires `CanUpdateOwnMetadata` permission encoded in the token.
+   * Note: this requires `canUpdateOwnMetadata` permission encoded in the token.
    * @param metadata
    */
   setName(name: string): void {
@@ -651,10 +650,12 @@ export default class LocalParticipant extends Participant {
         opts,
       );
       req.layers = videoLayersFromEncodings(req.width, req.height, simEncodings ?? encodings);
-    } else if (track.kind === Track.Kind.Audio && opts.audioBitrate) {
+    } else if (track.kind === Track.Kind.Audio) {
       encodings = [
         {
-          maxBitrate: opts.audioBitrate,
+          maxBitrate: opts.audioPreset?.maxBitrate ?? opts.audioBitrate,
+          priority: opts.audioPreset?.priority ?? 'high',
+          networkPriority: opts.audioPreset?.priority ?? 'high',
         },
       ];
     }

package/src/room/participant/RemoteParticipant.ts

@@ -11,7 +11,8 @@ import { Track } from '../track/Track';
 import type { TrackPublication } from '../track/TrackPublication';
 import type { AudioOutputOptions } from '../track/options';
 import type { AdaptiveStreamSettings } from '../track/types';
-import Participant, { ParticipantEventCallbacks } from './Participant';
+import Participant from './Participant';
+import type { ParticipantEventCallbacks } from './Participant';
 
 export default class RemoteParticipant extends Participant {
   audioTracks: Map<string, RemoteTrackPublication>;

package/src/room/participant/publishUtils.ts

@@ -3,15 +3,12 @@ import { TrackInvalidError } from '../errors';
 import LocalAudioTrack from '../track/LocalAudioTrack';
 import LocalVideoTrack from '../track/LocalVideoTrack';
 import { Track } from '../track/Track';
-import {
+import { ScreenSharePresets, VideoPreset, VideoPresets, VideoPresets43 } from '../track/options';
+import type {
   BackupVideoCodec,
-  ScreenSharePresets,
   TrackPublishOptions,
   VideoCodec,
   VideoEncoding,
-  VideoPreset,
-  VideoPresets,
-  VideoPresets43,
 } from '../track/options';
 import { isSVCCodec } from '../utils';
 
@@ -61,6 +58,7 @@ export const computeDefaultScreenShareSimulcastPresets = (fromPreset: VideoPrese
           ),
         ),
         t.fps,
+        fromPreset.encoding.priority,
       ),
   );
 };
@@ -317,6 +315,10 @@ function encodingsFromPresets(
     if (preset.encoding.maxFramerate) {
       encoding.maxFramerate = preset.encoding.maxFramerate;
     }
+    if (preset.encoding.priority) {
+      encoding.priority = preset.encoding.priority;
+      encoding.networkPriority = preset.encoding.priority;
+    }
     encodings.push(encoding);
   });
   return encodings;