@stream-io/video-client 1.31.0 → 1.33.0

package/dist/index.cjs.js

@@ -115,6 +115,7 @@ const OwnCapability = {
     REMOVE_CALL_MEMBER: 'remove-call-member',
     SCREENSHARE: 'screenshare',
     SEND_AUDIO: 'send-audio',
+    SEND_CLOSED_CAPTIONS_CALL: 'send-closed-captions-call',
     SEND_VIDEO: 'send-video',
     START_BROADCAST_CALL: 'start-broadcast-call',
     START_CLOSED_CAPTIONS_CALL: 'start-closed-captions-call',
@@ -960,6 +961,24 @@ var ParticipantSource;
      */
     ParticipantSource[ParticipantSource["SRT"] = 5] = "SRT";
 })(ParticipantSource || (ParticipantSource = {}));
+/**
+ * @generated from protobuf enum stream.video.sfu.models.AudioBitrateProfile
+ */
+var AudioBitrateProfile;
+(function (AudioBitrateProfile) {
+    /**
+     * @generated from protobuf enum value: AUDIO_BITRATE_PROFILE_VOICE_STANDARD_UNSPECIFIED = 0;
+     */
+    AudioBitrateProfile[AudioBitrateProfile["VOICE_STANDARD_UNSPECIFIED"] = 0] = "VOICE_STANDARD_UNSPECIFIED";
+    /**
+     * @generated from protobuf enum value: AUDIO_BITRATE_PROFILE_VOICE_HIGH_QUALITY = 1;
+     */
+    AudioBitrateProfile[AudioBitrateProfile["VOICE_HIGH_QUALITY"] = 1] = "VOICE_HIGH_QUALITY";
+    /**
+     * @generated from protobuf enum value: AUDIO_BITRATE_PROFILE_MUSIC_HIGH_QUALITY = 2;
+     */
+    AudioBitrateProfile[AudioBitrateProfile["MUSIC_HIGH_QUALITY"] = 2] = "MUSIC_HIGH_QUALITY";
+})(AudioBitrateProfile || (AudioBitrateProfile = {}));
 /**
  * @generated from protobuf enum stream.video.sfu.models.ErrorCode
  */
@@ -1573,6 +1592,13 @@ class PublishOption$Type extends runtime.MessageType {
                 kind: 'scalar',
                 T: 8 /*ScalarType.BOOL*/,
             },
+            {
+                no: 10,
+                name: 'audio_bitrate_profiles',
+                kind: 'message',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: () => AudioBitrate,
+            },
         ]);
     }
 }
@@ -1636,6 +1662,28 @@ let ICETrickle$Type$1 = class ICETrickle$Type extends runtime.MessageType {
  */
 const ICETrickle$1 = new ICETrickle$Type$1();
 // @generated message type with reflection information, may provide speed optimized methods
+class AudioBitrate$Type extends runtime.MessageType {
+    constructor() {
+        super('stream.video.sfu.models.AudioBitrate', [
+            {
+                no: 1,
+                name: 'profile',
+                kind: 'enum',
+                T: () => [
+                    'stream.video.sfu.models.AudioBitrateProfile',
+                    AudioBitrateProfile,
+                    'AUDIO_BITRATE_PROFILE_',
+                ],
+            },
+            { no: 2, name: 'bitrate', kind: 'scalar', T: 5 /*ScalarType.INT32*/ },
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.models.AudioBitrate
+ */
+const AudioBitrate = new AudioBitrate$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class TrackInfo$Type extends runtime.MessageType {
     constructor() {
         super('stream.video.sfu.models.TrackInfo', [
@@ -1986,6 +2034,8 @@ var models = /*#__PURE__*/Object.freeze({
     get AndroidThermalState () { return AndroidThermalState; },
     AppleState: AppleState,
     get AppleThermalState () { return AppleThermalState; },
+    AudioBitrate: AudioBitrate,
+    get AudioBitrateProfile () { return AudioBitrateProfile; },
     Browser: Browser,
     Call: Call$1,
     get CallEndedReason () { return CallEndedReason; },
@@ -2951,6 +3001,12 @@ class JoinRequest$Type extends runtime.MessageType {
         super('stream.video.sfu.event.JoinRequest', [
             { no: 1, name: 'token', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
             { no: 2, name: 'session_id', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+            {
+                no: 13,
+                name: 'unified_session_id',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
             {
                 no: 3,
                 name: 'subscriber_sdp',
@@ -4654,11 +4710,11 @@ const ifInvisibleOrUnknownBy = conditional((a, b) => a.viewportVisibilityState?.
 /**
  * The default sorting preset.
  */
-const defaultSortPreset = combineComparators(pinned, screenSharing, ifInvisibleBy(combineComparators(dominantSpeaker, speaking, reactionType('raised-hand'), publishingVideo, publishingAudio)));
+const defaultSortPreset = combineComparators(screenSharing, pinned, ifInvisibleBy(combineComparators(dominantSpeaker, speaking, reactionType('raised-hand'), publishingVideo, publishingAudio)));
 /**
  * The sorting preset for speaker layout.
  */
-const speakerLayoutSortPreset = combineComparators(pinned, screenSharing, dominantSpeaker, ifInvisibleBy(combineComparators(speaking, reactionType('raised-hand'), publishingVideo, publishingAudio)));
+const speakerLayoutSortPreset = combineComparators(screenSharing, pinned, dominantSpeaker, ifInvisibleBy(combineComparators(speaking, reactionType('raised-hand'), publishingVideo, publishingAudio)));
 /**
  * The sorting preset for layouts that don't render all participants but
  * instead, render them in pages.
@@ -5005,14 +5061,32 @@ class CallState {
          * @param pins the latest pins from the server.
          */
         this.setServerSidePins = (pins) => {
-            const pinsLookup = pins.reduce((lookup, pin) => {
-                lookup[pin.sessionId] = Date.now();
+            const now = Date.now();
+            const unknownSymbol = Symbol('unknown');
+            // generate a lookup table of pinnedAt timestamps by userId and sessionId
+            // if there are multiple pins for the same userId, then we set the pinnedAt
+            // to `unknown` (for that userId lookup) so that we don't apply any pin for that participant
+            // this is to avoid conflicts during reconstruction of the pin state after reconnections
+            // as sessionIds can change
+            const pinnedAtByIdentifier = pins.reduce((lookup, pin, index) => {
+                var _a;
+                const pinnedAt = now + (pins.length - index);
+                if (lookup[pin.userId]) {
+                    lookup[pin.userId] = unknownSymbol;
+                }
+                else {
+                    lookup[pin.userId] = pinnedAt;
+                }
+                lookup[_a = pin.sessionId] ?? (lookup[_a] = pinnedAt);
                 return lookup;
             }, {});
             return this.setParticipants((participants) => participants.map((participant) => {
-                const serverSidePinnedAt = pinsLookup[participant.sessionId];
+                // first check by sessionId as that is 100% correct, then by attempt reconstruction by userId
+                const serverSidePinnedAt = pinnedAtByIdentifier[participant.sessionId] ??
+                    pinnedAtByIdentifier[participant.userId];
                 // the participant is newly pinned
-                if (serverSidePinnedAt) {
+                if (typeof serverSidePinnedAt === 'number' &&
+                    typeof participant.pin?.pinnedAt !== 'number') {
                     return {
                         ...participant,
                         pin: {
@@ -5023,7 +5097,8 @@ class CallState {
                 }
                 // the participant is no longer pinned server side
                 // we need to reset the pin
-                if (participant.pin && !participant.pin.isLocalPin) {
+                if (typeof serverSidePinnedAt !== 'number' &&
+                    participant.pin?.isLocalPin === false) {
                     return {
                         ...participant,
                         pin: undefined,
@@ -5760,7 +5835,7 @@ const getSdkVersion = (sdk) => {
     return sdk ? `${sdk.major}.${sdk.minor}.${sdk.patch}` : '0.0.0-development';
 };
 
-const version = "1.31.0";
+const version = "1.33.0";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -6958,15 +7033,24 @@ class TransceiverCache {
         /**
          * Adds a transceiver to the cache.
          */
-        this.add = (publishOption, transceiver) => {
-            this.cache.push({ publishOption, transceiver });
-            this.transceiverOrder.push(transceiver);
+        this.add = (bundle) => {
+            this.cache.push(bundle);
+            this.transceiverOrder.push(bundle.transceiver);
         };
         /**
          * Gets the transceiver for the given publish option.
          */
         this.get = (publishOption) => {
-            return this.findTransceiver(publishOption)?.transceiver;
+            return this.cache.find((bundle) => bundle.publishOption.id === publishOption.id &&
+                bundle.publishOption.trackType === publishOption.trackType);
+        };
+        /**
+         * Updates the cached bundle with the given patch.
+         */
+        this.update = (publishOption, patch) => {
+            const bundle = this.get(publishOption);
+            if (bundle)
+                Object.assign(bundle, patch);
         };
         /**
          * Checks if the cache has the given publish option.
@@ -7012,10 +7096,6 @@ class TransceiverCache {
                 this.layers.push({ publishOption, layers });
             }
         };
-        this.findTransceiver = (publishOption) => {
-            return this.cache.find((item) => item.publishOption.id === publishOption.id &&
-                item.publishOption.trackType === publishOption.trackType);
-        };
         this.findLayer = (publishOption) => {
             return this.layers.find((item) => item.publishOption.id === publishOption.id &&
                 item.publishOption.trackType === publishOption.trackType);
@@ -7073,10 +7153,20 @@ const toTrackType = (trackType) => {
 };
 const isAudioTrackType = (trackType) => trackType === TrackType.AUDIO || trackType === TrackType.SCREEN_SHARE_AUDIO;
 
-const defaultBitratePerRid = {
-    q: 300000,
-    h: 750000,
-    f: 1250000,
+/**
+ * Prepares the audio layer for the given track.
+ * Based on the provided audio bitrate profile, we apply the appropriate bitrate.
+ */
+const computeAudioLayers = (publishOption, options) => {
+    const { audioBitrateProfile } = options;
+    const profileConfig = publishOption.audioBitrateProfiles?.find((config) => config.profile === audioBitrateProfile);
+    const maxBitrate = profileConfig?.bitrate ||
+        {
+            [AudioBitrateProfile.VOICE_STANDARD_UNSPECIFIED]: 64000,
+            [AudioBitrateProfile.VOICE_HIGH_QUALITY]: 128000,
+            [AudioBitrateProfile.MUSIC_HIGH_QUALITY]: 128000,
+        }[audioBitrateProfile || AudioBitrateProfile.VOICE_STANDARD_UNSPECIFIED];
+    return [{ maxBitrate }];
 };
 /**
  * In SVC, we need to send only one video encoding (layer).
@@ -7089,7 +7179,7 @@ const toSvcEncodings = (layers) => {
     if (!layers)
         return;
     // we take the highest quality layer, and we assign it to `q` encoder.
-    const withRid = (rid) => (l) => l.rid === rid;
+    const withRid = (rid) => (layer) => layer.rid === rid;
     const highestLayer = layers.find(withRid('f')) ||
         layers.find(withRid('h')) ||
         layers.find(withRid('q'));
@@ -7143,7 +7233,8 @@ const computeVideoLayers = (videoTrack, publishOption) => {
             rid,
             width: Math.round(width / downscaleFactor),
             height: Math.round(height / downscaleFactor),
-            maxBitrate: Math.round(maxBitrate / bitrateFactor) || defaultBitratePerRid[rid],
+            maxBitrate: Math.round(maxBitrate / bitrateFactor) ||
+                { q: 300000, h: 750000, f: 1250000 }[rid],
             maxFramerate: fps,
         };
         if (svcCodec) {
@@ -7309,8 +7400,9 @@ class Publisher extends BasePeerConnection {
          *
          * @param track the track to publish.
          * @param trackType the track type to publish.
+         * @param options the publish options to use.
          */
-        this.publish = async (track, trackType) => {
+        this.publish = async (track, trackType, options = {}) => {
             if (!this.publishOptions.some((o) => o.trackType === trackType)) {
                 throw new Error(`No publish options found for ${TrackType[trackType]}`);
             }
@@ -7320,13 +7412,13 @@ class Publisher extends BasePeerConnection {
                 // create a clone of the track as otherwise the same trackId will
                 // appear in the SDP in multiple transceivers
                 const trackToPublish = this.cloneTrack(track);
-                const transceiver = this.transceiverCache.get(publishOption);
+                const { transceiver } = this.transceiverCache.get(publishOption) || {};
                 if (!transceiver) {
-                    await this.addTransceiver(trackToPublish, publishOption);
+                    await this.addTransceiver(trackToPublish, publishOption, options);
                 }
                 else {
                     const previousTrack = transceiver.sender.track;
-                    await this.updateTransceiver(transceiver, trackToPublish, trackType);
+                    await this.updateTransceiver(transceiver, trackToPublish, trackType, options);
                     if (!isReactNative()) {
                         this.stopTrack(previousTrack);
                     }
@@ -7336,11 +7428,13 @@ class Publisher extends BasePeerConnection {
         /**
          * Adds a new transceiver carrying the given track to the peer connection.
          */
-        this.addTransceiver = async (track, publishOption) => {
-            const videoEncodings = computeVideoLayers(track, publishOption);
+        this.addTransceiver = async (track, publishOption, options) => {
+            const encodings = isAudioTrackType(publishOption.trackType)
+                ? computeAudioLayers(publishOption, options)
+                : computeVideoLayers(track, publishOption);
             const sendEncodings = isSvcCodec(publishOption.codec?.name)
-                ? toSvcEncodings(videoEncodings)
-                : videoEncodings;
+                ? toSvcEncodings(encodings)
+                : encodings;
             const transceiver = this.pc.addTransceiver(track, {
                 direction: 'sendonly',
                 sendEncodings,
@@ -7350,20 +7444,49 @@ class Publisher extends BasePeerConnection {
             await transceiver.sender.setParameters(params);
             const trackType = publishOption.trackType;
             this.logger('debug', `Added ${TrackType[trackType]} transceiver`);
-            this.transceiverCache.add(publishOption, transceiver);
+            this.transceiverCache.add({ publishOption, transceiver, options });
             this.trackIdToTrackType.set(track.id, trackType);
             await this.negotiate();
         };
         /**
          * Updates the transceiver with the given track and track type.
          */
-        this.updateTransceiver = async (transceiver, track, trackType) => {
+        this.updateTransceiver = async (transceiver, track, trackType, options = {}) => {
             const sender = transceiver.sender;
             if (sender.track)
                 this.trackIdToTrackType.delete(sender.track.id);
             await sender.replaceTrack(track);
             if (track)
                 this.trackIdToTrackType.set(track.id, trackType);
+            if (isAudioTrackType(trackType)) {
+                await this.updateAudioPublishOptions(trackType, options);
+            }
+        };
+        /**
+         * Updates the publish options for the given track type.
+         */
+        this.updateAudioPublishOptions = async (trackType, options) => {
+            for (const publishOption of this.publishOptions) {
+                if (publishOption.trackType !== trackType)
+                    continue;
+                const bundle = this.transceiverCache.get(publishOption);
+                if (!bundle)
+                    continue;
+                const { transceiver, options: current } = bundle;
+                if (current.audioBitrateProfile !== options.audioBitrateProfile) {
+                    const encodings = computeAudioLayers(publishOption, options);
+                    if (encodings && encodings.length > 0) {
+                        const params = transceiver.sender.getParameters();
+                        const [currentEncoding] = params.encodings;
+                        const [targetEncoding] = encodings;
+                        if (currentEncoding.maxBitrate !== targetEncoding.maxBitrate) {
+                            currentEncoding.maxBitrate = targetEncoding.maxBitrate;
+                        }
+                        await transceiver.sender.setParameters(params);
+                    }
+                }
+                this.transceiverCache.update(publishOption, { options });
+            }
         };
         /**
          * Synchronizes the current Publisher state with the provided publish options.
@@ -7378,12 +7501,12 @@ class Publisher extends BasePeerConnection {
                     continue;
                 const item = this.transceiverCache.find((i) => !!i.transceiver.sender.track &&
                     i.publishOption.trackType === trackType);
-                if (!item || !item.transceiver)
+                if (!item)
                     continue;
                 // take the track from the existing transceiver for the same track type,
                 // clone it and publish it with the new publish options
                 const track = this.cloneTrack(item.transceiver.sender.track);
-                await this.addTransceiver(track, publishOption);
+                await this.addTransceiver(track, publishOption, item.options);
             }
             // stop publishing with options not required anymore -> [vp9]
             for (const item of this.transceiverCache.items()) {
@@ -7563,11 +7686,9 @@ class Publisher extends BasePeerConnection {
         this.getAnnouncedTracks = (sdp) => {
             const trackInfos = [];
             for (const bundle of this.transceiverCache.items()) {
-                const { transceiver, publishOption } = bundle;
-                const track = transceiver.sender.track;
-                if (!track)
+                if (!bundle.transceiver.sender.track)
                     continue;
-                trackInfos.push(this.toTrackInfo(transceiver, publishOption, sdp));
+                trackInfos.push(this.toTrackInfo(bundle, sdp));
             }
             return trackInfos;
         };
@@ -7580,17 +7701,18 @@ class Publisher extends BasePeerConnection {
             const sdp = this.pc.localDescription?.sdp;
             const trackInfos = [];
             for (const publishOption of this.publishOptions) {
-                const transceiver = this.transceiverCache.get(publishOption);
-                if (!transceiver || !transceiver.sender.track)
+                const bundle = this.transceiverCache.get(publishOption);
+                if (!bundle || !bundle.transceiver.sender.track)
                     continue;
-                trackInfos.push(this.toTrackInfo(transceiver, publishOption, sdp));
+                trackInfos.push(this.toTrackInfo(bundle, sdp));
             }
             return trackInfos;
         };
         /**
          * Converts the given transceiver to a `TrackInfo` object.
          */
-        this.toTrackInfo = (transceiver, publishOption, sdp) => {
+        this.toTrackInfo = (bundle, sdp) => {
+            const { transceiver, publishOption } = bundle;
             const track = transceiver.sender.track;
             const isTrackLive = track.readyState === 'live';
             const layers = isTrackLive
@@ -7598,15 +7720,16 @@ class Publisher extends BasePeerConnection {
                 : this.transceiverCache.getLayers(publishOption);
             this.transceiverCache.setLayers(publishOption, layers);
             const isAudioTrack = isAudioTrackType(publishOption.trackType);
-            const isStereo = isAudioTrack && track.getSettings().channelCount === 2;
             const transceiverIndex = this.transceiverCache.indexOf(transceiver);
             const audioSettings = this.state.settings?.audio;
+            const stereo = publishOption.trackType === TrackType.SCREEN_SHARE_AUDIO ||
+                (isAudioTrack && !!audioSettings?.hifi_audio_enabled);
             return {
                 trackId: track.id,
                 layers: toVideoLayers(layers),
                 trackType: publishOption.trackType,
                 mid: extractMid(transceiver, transceiverIndex, sdp),
-                stereo: isStereo,
+                stereo,
                 dtx: isAudioTrack && !!audioSettings?.opus_dtx_enabled,
                 red: isAudioTrack && !!audioSettings?.redundant_coding_enabled,
                 muted: !isTrackLive,
@@ -9890,7 +10013,7 @@ function resolveDeviceId(deviceId, kind) {
  */
 const isMobile = () => /Mobi/i.test(navigator.userAgent);
 
-class InputMediaDeviceManager {
+class DeviceManager {
     constructor(call, state, trackType) {
         /**
          * if true, stops the media stream when call is left
@@ -10097,8 +10220,8 @@ class InputMediaDeviceManager {
             }
         });
     }
-    publishStream(stream) {
-        return this.call.publish(stream, this.trackType);
+    publishStream(stream, options) {
+        return this.call.publish(stream, this.trackType, options);
     }
     stopPublishStream() {
         return this.call.stopPublish(this.trackType);
@@ -10334,16 +10457,15 @@ class InputMediaDeviceManager {
     }
 }
 
-class InputMediaDeviceManagerState {
+class DeviceManagerState {
     /**
-     * Constructs new InputMediaDeviceManagerState instance.
+     * Constructs a new InputMediaDeviceManagerState instance.
      *
      * @param disableMode the disable mode to use.
      * @param permission the BrowserPermission to use for querying.
      * `undefined` means no permission is required.
      */
-    constructor(disableMode = 'stop-tracks', permission) {
-        this.disableMode = disableMode;
+    constructor(disableMode, permission) {
         this.statusSubject = new rxjs.BehaviorSubject(undefined);
         this.optimisticStatusSubject = new rxjs.BehaviorSubject(undefined);
         this.mediaStreamSubject = new rxjs.BehaviorSubject(undefined);
@@ -10374,6 +10496,7 @@ class InputMediaDeviceManagerState {
          * The default constraints for the device.
          */
         this.defaultConstraints$ = this.defaultConstraintsSubject.asObservable();
+        this.disableMode = disableMode;
         this.hasBrowserPermission$ = permission
             ? permission.asObservable().pipe(rxjs.shareReplay(1))
             : rxjs.of(true);
@@ -10460,10 +10583,15 @@ class InputMediaDeviceManagerState {
     }
 }
 
-class CameraManagerState extends InputMediaDeviceManagerState {
+class CameraManagerState extends DeviceManagerState {
     constructor() {
         super('stop-tracks', getVideoBrowserPermission());
         this.directionSubject = new rxjs.BehaviorSubject(undefined);
+        /**
+         * Observable that emits the preferred camera direction
+         * front - means the camera facing the user
+         * back - means the camera facing the environment
+         */
         this.direction$ = this.directionSubject
             .asObservable()
             .pipe(rxjs.distinctUntilChanged());
@@ -10503,7 +10631,7 @@ class CameraManagerState extends InputMediaDeviceManagerState {
     }
 }
 
-class CameraManager extends InputMediaDeviceManager {
+class CameraManager extends DeviceManager {
     /**
      * Constructs a new CameraManager.
      *
@@ -10649,18 +10777,87 @@ class CameraManager extends InputMediaDeviceManager {
     }
 }
 
-class MicrophoneManagerState extends InputMediaDeviceManagerState {
+/**
+ * Base class for High Fidelity enabled Device Managers.
+ */
+class AudioDeviceManager extends DeviceManager {
+    /**
+     * Sets the audio bitrate profile and stereo mode.
+     */
+    async setAudioBitrateProfile(profile) {
+        if (!this.call.state.settings?.audio.hifi_audio_enabled) {
+            throw new Error('High Fidelity audio is not enabled for this call');
+        }
+        this.doSetAudioBitrateProfile(profile);
+        this.state.setAudioBitrateProfile(profile);
+        if (this.enabled) {
+            await this.applySettingsToStream();
+        }
+    }
+    /**
+     * Overrides the default `publishStream` method to inject the audio bitrate profile.
+     */
+    publishStream(stream, options) {
+        return super.publishStream(stream, {
+            audioBitrateProfile: this.state.audioBitrateProfile,
+            ...options,
+        });
+    }
+}
+/**
+ * Prepares a new MediaTrackConstraints set based on the provided arguments.
+ */
+const createAudioConstraints = (profile) => {
+    const stereo = profile === AudioBitrateProfile.MUSIC_HIGH_QUALITY;
+    return {
+        echoCancellation: !stereo,
+        noiseSuppression: !stereo,
+        autoGainControl: !stereo,
+        channelCount: { ideal: stereo ? 2 : 1 },
+    };
+};
+
+/**
+ * Base state class for High Fidelity enabled device managers.
+ */
+class AudioDeviceManagerState extends DeviceManagerState {
+    /**
+     * Constructs a new AudioDeviceManagerState instance.
+     */
+    constructor(disableMode, permission, profile) {
+        super(disableMode, permission);
+        this.audioBitrateProfileSubject = new rxjs.BehaviorSubject(profile);
+        this.audioBitrateProfile$ = this.audioBitrateProfileSubject
+            .asObservable()
+            .pipe(rxjs.distinctUntilChanged());
+    }
+    /**
+     * Returns the current audio bitrate profile.
+     */
+    get audioBitrateProfile() {
+        return getCurrentValue(this.audioBitrateProfile$);
+    }
+    /**
+     * Sets the audio bitrate profile and stereo mode.
+     */
+    setAudioBitrateProfile(profile) {
+        setCurrentValue(this.audioBitrateProfileSubject, profile);
+    }
+}
+
+class MicrophoneManagerState extends AudioDeviceManagerState {
     constructor(disableMode) {
-        super(disableMode, getAudioBrowserPermission());
+        super(disableMode, getAudioBrowserPermission(), AudioBitrateProfile.VOICE_STANDARD_UNSPECIFIED);
         this.speakingWhileMutedSubject = new rxjs.BehaviorSubject(false);
+        /**
+         * An Observable that emits `true` if the user's microphone is muted, but they're speaking.
+         */
         this.speakingWhileMuted$ = this.speakingWhileMutedSubject
             .asObservable()
             .pipe(rxjs.distinctUntilChanged());
     }
     /**
-     * `true` if the user's microphone is muted but they'are speaking.
-     *
-     * This feature is not available in the React Native SDK.
+     * `true` if the user's microphone is muted but they're speaking.
      */
     get speakingWhileMuted() {
         return getCurrentValue(this.speakingWhileMuted$);
@@ -10893,7 +11090,7 @@ class RNSpeechDetector {
     }
 }
 
-class MicrophoneManager extends InputMediaDeviceManager {
+class MicrophoneManager extends AudioDeviceManager {
     constructor(call, disableMode = 'stop-tracks') {
         super(call, new MicrophoneManagerState(disableMode), TrackType.AUDIO);
         this.speakingWhileMutedNotificationEnabled = true;
@@ -11089,6 +11286,21 @@ class MicrophoneManager extends InputMediaDeviceManager {
     getStream(constraints) {
         return getAudioStream(constraints, this.call.tracer);
     }
+    doSetAudioBitrateProfile(profile) {
+        this.setDefaultConstraints({
+            ...this.state.defaultConstraints,
+            ...createAudioConstraints(profile),
+        });
+        if (this.noiseCancellation) {
+            const disableAudioProcessing = profile === AudioBitrateProfile.MUSIC_HIGH_QUALITY;
+            if (disableAudioProcessing) {
+                this.noiseCancellation.disable(); // disable for high quality music mode
+            }
+            else {
+                this.noiseCancellation.enable(); // restore it for other modes if available
+            }
+        }
+    }
     async startSpeakingWhileMutedDetection(deviceId) {
         await withoutConcurrency(this.soundDetectorConcurrencyTag, async () => {
             await this.stopSpeakingWhileMutedDetection();
@@ -11125,9 +11337,12 @@ class MicrophoneManager extends InputMediaDeviceManager {
     }
 }
 
-class ScreenShareState extends InputMediaDeviceManagerState {
+class ScreenShareState extends AudioDeviceManagerState {
+    /**
+     * Constructs a new ScreenShareState instance.
+     */
     constructor() {
-        super(...arguments);
+        super('stop-tracks', undefined, AudioBitrateProfile.MUSIC_HIGH_QUALITY);
         this.audioEnabledSubject = new rxjs.BehaviorSubject(true);
         this.settingsSubject = new rxjs.BehaviorSubject(undefined);
         /**
@@ -11176,7 +11391,7 @@ class ScreenShareState extends InputMediaDeviceManagerState {
     }
 }
 
-class ScreenShareManager extends InputMediaDeviceManager {
+class ScreenShareManager extends AudioDeviceManager {
     constructor(call) {
         super(call, new ScreenShareState(), TrackType.SCREEN_SHARE);
     }
@@ -11186,6 +11401,7 @@ class ScreenShareManager extends InputMediaDeviceManager {
             const maybeTargetResolution = settings?.screensharing.target_resolution;
             if (maybeTargetResolution) {
                 this.setDefaultConstraints({
+                    ...this.state.defaultConstraints,
                     video: {
                         width: maybeTargetResolution.width,
                         height: maybeTargetResolution.height,
@@ -11242,6 +11458,19 @@ class ScreenShareManager extends InputMediaDeviceManager {
         }
         return stream;
     }
+    doSetAudioBitrateProfile(profile) {
+        const { defaultConstraints } = this.state;
+        const baseAudioConstraints = typeof defaultConstraints?.audio !== 'boolean'
+            ? defaultConstraints?.audio
+            : null;
+        this.setDefaultConstraints({
+            ...defaultConstraints,
+            audio: {
+                ...baseAudioConstraints,
+                ...createAudioConstraints(profile),
+            },
+        });
+    }
     async stopPublishStream() {
         return this.call.stopPublish(TrackType.SCREEN_SHARE, TrackType.SCREEN_SHARE_AUDIO);
     }
@@ -11255,19 +11484,27 @@ class ScreenShareManager extends InputMediaDeviceManager {
 
 class SpeakerState {
     constructor(tracer) {
+        this.tracer = tracer;
         this.selectedDeviceSubject = new rxjs.BehaviorSubject('');
         this.volumeSubject = new rxjs.BehaviorSubject(1);
         /**
          * [Tells if the browser supports audio output change on 'audio' elements](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/setSinkId).
          */
         this.isDeviceSelectionSupported = checkIfAudioOutputChangeSupported();
-        this.tracer = tracer;
+        /**
+         * An Observable that emits the currently selected device
+         *
+         * Note: this feature is not supported in React Native
+         */
         this.selectedDevice$ = this.selectedDeviceSubject
             .asObservable()
             .pipe(rxjs.distinctUntilChanged());
-        this.volume$ = this.volumeSubject
-            .asObservable()
-            .pipe(rxjs.distinctUntilChanged());
+        /**
+         * An Observable that emits the currently selected volume
+         *
+         * Note: this feature is not supported in React Native
+         */
+        this.volume$ = this.volumeSubject.asObservable().pipe(rxjs.distinctUntilChanged());
     }
     /**
      * The currently selected device
@@ -11871,7 +12108,6 @@ class Call {
             if ([exports.CallingState.JOINED, exports.CallingState.JOINING].includes(callingState)) {
                 throw new Error(`Illegal State: call.join() shall be called only once`);
             }
-            this.state.setCallingState(exports.CallingState.JOINING);
             // we will count the number of join failures per SFU.
             // once the number of failures reaches 2, we will piggyback on the `migrating_from`
             // field to force the coordinator to provide us another SFU
@@ -11900,8 +12136,6 @@ class Call {
                         joinData.migrating_from = sfuId;
                     }
                     if (attempt === maxJoinRetries - 1) {
-                        // restore the previous call state if the join-flow fails
-                        this.state.setCallingState(callingState);
                         throw err;
                     }
                 }
@@ -11961,6 +12195,7 @@ class Call {
                 })
                 : previousSfuClient;
             this.sfuClient = sfuClient;
+            this.unifiedSessionId ?? (this.unifiedSessionId = sfuClient.sessionId);
             this.dynascaleManager.setSfuClient(sfuClient);
             const clientDetails = await getClientDetails();
             // we don't need to send JoinRequest if we are re-using an existing healthy SFU client
@@ -11984,6 +12219,7 @@ class Call {
                     : [];
                 try {
                     const { callState, fastReconnectDeadlineSeconds, publishOptions } = await sfuClient.join({
+                        unifiedSessionId: this.unifiedSessionId,
                         subscriberSdp,
                         publisherSdp,
                         clientDetails,
@@ -12029,6 +12265,7 @@ class Call {
                     statsOptions,
                     publishOptions: this.currentPublishOptions || [],
                     closePreviousInstances: !performingMigration,
+                    unifiedSessionId: this.unifiedSessionId,
                 });
             }
             // make sure we only track connection timing if we are not calling this method as part of a reconnection flow
@@ -12155,7 +12392,7 @@ class Call {
          * @internal
          */
         this.initPublisherAndSubscriber = (opts) => {
-            const { sfuClient, connectionConfig, clientDetails, statsOptions, publishOptions, closePreviousInstances, } = opts;
+            const { sfuClient, connectionConfig, clientDetails, statsOptions, publishOptions, closePreviousInstances, unifiedSessionId, } = opts;
             const { enable_rtc_stats: enableTracing } = statsOptions;
             if (closePreviousInstances && this.subscriber) {
                 this.subscriber.dispose();
@@ -12210,7 +12447,6 @@ class Call {
             this.tracer.setEnabled(enableTracing);
             this.sfuStatsReporter?.stop();
             if (statsOptions?.reporting_interval_ms > 0) {
-                this.unifiedSessionId ?? (this.unifiedSessionId = sfuClient.sessionId);
                 this.sfuStatsReporter = new SfuStatsReporter(sfuClient, {
                     clientDetails,
                     options: statsOptions,
@@ -12220,7 +12456,7 @@ class Call {
                     camera: this.camera,
                     state: this.state,
                     tracer: this.tracer,
-                    unifiedSessionId: this.unifiedSessionId,
+                    unifiedSessionId,
                 });
                 this.sfuStatsReporter.start();
             }
@@ -12593,10 +12829,11 @@ class Call {
          *
          * @param mediaStream the media stream to publish.
          * @param trackType the type of the track to announce.
+         * @param options the publish options.
          */
-        this.publish = async (mediaStream, trackType) => {
+        this.publish = async (mediaStream, trackType, options) => {
             if (!this.sfuClient)
-                throw new Error(`Call not joined yet.`);
+                throw new Error(`Call is not joined yet`);
             // joining is in progress, and we should wait until the client is ready
             await this.sfuClient.joinTask;
             if (!this.permissionsContext.canPublish(trackType)) {
@@ -12614,14 +12851,15 @@ class Call {
                 throw new Error(`Can't publish ended tracks.`);
             }
             pushToIfMissing(this.trackPublishOrder, trackType);
-            await this.publisher.publish(track, trackType);
+            await this.publisher.publish(track, trackType, options);
             const trackTypes = [trackType];
             if (trackType === TrackType.SCREEN_SHARE) {
                 const [audioTrack] = mediaStream.getAudioTracks();
                 if (audioTrack) {
-                    pushToIfMissing(this.trackPublishOrder, TrackType.SCREEN_SHARE_AUDIO);
-                    await this.publisher.publish(audioTrack, TrackType.SCREEN_SHARE_AUDIO);
-                    trackTypes.push(TrackType.SCREEN_SHARE_AUDIO);
+                    const screenShareAudio = TrackType.SCREEN_SHARE_AUDIO;
+                    pushToIfMissing(this.trackPublishOrder, screenShareAudio);
+                    await this.publisher.publish(audioTrack, screenShareAudio, options);
+                    trackTypes.push(screenShareAudio);
                 }
             }
             if (track.kind === 'video') {
@@ -14540,7 +14778,7 @@ class StreamClient {
         this.getUserAgent = () => {
             if (!this.cachedUserAgent) {
                 const { clientAppIdentifier = {} } = this.options;
-                const { sdkName = 'js', sdkVersion = "1.31.0", ...extras } = clientAppIdentifier;
+                const { sdkName = 'js', sdkVersion = "1.33.0", ...extras } = clientAppIdentifier;
                 this.cachedUserAgent = [
                     `stream-video-${sdkName}-v${sdkVersion}`,
                     ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),
@@ -14729,6 +14967,7 @@ class StreamVideoClient {
         this.effectsRegistered = false;
         this.eventHandlersToUnregister = [];
         this.connectionConcurrencyTag = Symbol('connectionConcurrencyTag');
+        this.rejectCallWhenBusy = false;
         this.registerClientInstance = (apiKey, user) => {
             const instanceKey = getInstanceKey(apiKey, user);
             if (StreamVideoClient._instances.has(instanceKey)) {
@@ -14774,7 +15013,16 @@ class StreamVideoClient {
                     let call = this.writeableStateStore.findCall(e.call.type, e.call.id);
                     if (call) {
                         if (ringing) {
-                            await call.updateFromRingingEvent(e);
+                            if (this.shouldRejectCall(call.cid)) {
+                                this.logger('info', `Leaving call with busy reject reason ${call.cid} because user is busy`);
+                                // remove the instance from the state store
+                                await call.leave();
+                                // explicitly reject the call with busy reason as calling state was not ringing before and leave would not call it therefore
+                                await call.reject('busy');
+                            }
+                            else {
+                                await call.updateFromRingingEvent(e);
+                            }
                         }
                         else {
                             call.state.updateFromCallResponse(e.call);
@@ -14789,11 +15037,19 @@ class StreamVideoClient {
                         clientStore: this.writeableStateStore,
                         ringing,
                     });
-                    call.state.updateFromCallResponse(e.call);
                     if (ringing) {
-                        await call.get();
+                        if (this.shouldRejectCall(call.cid)) {
+                            this.logger('info', `Rejecting call ${call.cid} because user is busy`);
+                            // call is not in the state store yet, so just reject api is enough
+                            await call.reject('busy');
+                        }
+                        else {
+                            await call.updateFromRingingEvent(e);
+                            await call.get();
+                        }
                     }
                     else {
+                        call.state.updateFromCallResponse(e.call);
                         this.writeableStateStore.registerCall(call);
                         this.logger('info', `New call created and registered: ${call.cid}`);
                     }
@@ -15060,6 +15316,16 @@ class StreamVideoClient {
         this.connectAnonymousUser = async (user, tokenOrProvider) => {
             return withoutConcurrency(this.connectionConcurrencyTag, () => this.streamClient.connectAnonymousUser(user, tokenOrProvider));
         };
+        this.shouldRejectCall = (currentCallId) => {
+            if (!this.rejectCallWhenBusy)
+                return false;
+            const hasOngoingRingingCall = this.state.calls.some((c) => c.cid !== currentCallId &&
+                c.ringing &&
+                c.state.callingState !== exports.CallingState.IDLE &&
+                c.state.callingState !== exports.CallingState.LEFT &&
+                c.state.callingState !== exports.CallingState.RECONNECTING_FAILED);
+            return hasOngoingRingingCall;
+        };
         const apiKey = typeof apiKeyOrArgs === 'string' ? apiKeyOrArgs : apiKeyOrArgs.apiKey;
         const clientOptions = typeof apiKeyOrArgs === 'string' ? opts : apiKeyOrArgs.options;
         if (clientOptions?.enableTimerWorker)
@@ -15067,6 +15333,7 @@ class StreamVideoClient {
         const rootLogger = clientOptions?.logger || logToConsole;
         setLogger(rootLogger, clientOptions?.logLevel || 'warn');
         this.logger = getLogger(['client']);
+        this.rejectCallWhenBusy = clientOptions?.rejectCallWhenBusy ?? false;
         this.streamClient = createCoordinatorClient(apiKey, clientOptions);
         this.writeableStateStore = new StreamVideoWriteableStateStore();
         this.readOnlyStateStore = new StreamVideoReadOnlyStateStore(this.writeableStateStore);
@@ -15122,6 +15389,8 @@ exports.CallTypes = CallTypes;
 exports.CameraManager = CameraManager;
 exports.CameraManagerState = CameraManagerState;
 exports.CreateDeviceRequestPushProviderEnum = CreateDeviceRequestPushProviderEnum;
+exports.DeviceManager = DeviceManager;
+exports.DeviceManagerState = DeviceManagerState;
 exports.DynascaleManager = DynascaleManager;
 exports.ErrorFromResponse = ErrorFromResponse;
 exports.FrameRecordingSettingsRequestModeEnum = FrameRecordingSettingsRequestModeEnum;
@@ -15129,8 +15398,6 @@ exports.FrameRecordingSettingsRequestQualityEnum = FrameRecordingSettingsRequest
 exports.FrameRecordingSettingsResponseModeEnum = FrameRecordingSettingsResponseModeEnum;
 exports.IngressAudioEncodingOptionsRequestChannelsEnum = IngressAudioEncodingOptionsRequestChannelsEnum;
 exports.IngressVideoLayerRequestCodecEnum = IngressVideoLayerRequestCodecEnum;
-exports.InputMediaDeviceManager = InputMediaDeviceManager;
-exports.InputMediaDeviceManagerState = InputMediaDeviceManagerState;
 exports.LayoutSettingsRequestNameEnum = LayoutSettingsRequestNameEnum;
 exports.MicrophoneManager = MicrophoneManager;
 exports.MicrophoneManagerState = MicrophoneManagerState;