@stream-io/video-client 1.31.0 → 1.33.0

package/dist/index.browser.es.js

@@ -113,6 +113,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',
@@ -958,6 +959,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
  */
@@ -1571,6 +1590,13 @@ class PublishOption$Type extends MessageType {
                 kind: 'scalar',
                 T: 8 /*ScalarType.BOOL*/,
             },
+            {
+                no: 10,
+                name: 'audio_bitrate_profiles',
+                kind: 'message',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: () => AudioBitrate,
+            },
         ]);
     }
 }
@@ -1634,6 +1660,28 @@ let ICETrickle$Type$1 = class ICETrickle$Type extends MessageType {
  */
 const ICETrickle$1 = new ICETrickle$Type$1();
 // @generated message type with reflection information, may provide speed optimized methods
+class AudioBitrate$Type extends 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 MessageType {
     constructor() {
         super('stream.video.sfu.models.TrackInfo', [
@@ -1984,6 +2032,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; },
@@ -2949,6 +2999,12 @@ class JoinRequest$Type extends 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',
@@ -4652,11 +4708,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.
@@ -5003,14 +5059,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: {
@@ -5021,7 +5095,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,
@@ -5758,7 +5833,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,
@@ -6956,15 +7031,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.
@@ -7010,10 +7094,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);
@@ -7071,10 +7151,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).
@@ -7087,7 +7177,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'));
@@ -7141,7 +7231,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) {
@@ -7307,8 +7398,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]}`);
             }
@@ -7318,13 +7410,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);
                     }
@@ -7334,11 +7426,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,
@@ -7348,20 +7442,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.
@@ -7376,12 +7499,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()) {
@@ -7561,11 +7684,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;
         };
@@ -7578,17 +7699,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
@@ -7596,15 +7718,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,
@@ -9888,7 +10011,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
@@ -10095,8 +10218,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);
@@ -10332,16 +10455,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 BehaviorSubject(undefined);
         this.optimisticStatusSubject = new BehaviorSubject(undefined);
         this.mediaStreamSubject = new BehaviorSubject(undefined);
@@ -10372,6 +10494,7 @@ class InputMediaDeviceManagerState {
          * The default constraints for the device.
          */
         this.defaultConstraints$ = this.defaultConstraintsSubject.asObservable();
+        this.disableMode = disableMode;
         this.hasBrowserPermission$ = permission
             ? permission.asObservable().pipe(shareReplay(1))
             : of(true);
@@ -10458,10 +10581,15 @@ class InputMediaDeviceManagerState {
     }
 }
 
-class CameraManagerState extends InputMediaDeviceManagerState {
+class CameraManagerState extends DeviceManagerState {
     constructor() {
         super('stop-tracks', getVideoBrowserPermission());
         this.directionSubject = new 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(distinctUntilChanged());
@@ -10501,7 +10629,7 @@ class CameraManagerState extends InputMediaDeviceManagerState {
     }
 }
 
-class CameraManager extends InputMediaDeviceManager {
+class CameraManager extends DeviceManager {
     /**
      * Constructs a new CameraManager.
      *
@@ -10647,18 +10775,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 BehaviorSubject(profile);
+        this.audioBitrateProfile$ = this.audioBitrateProfileSubject
+            .asObservable()
+            .pipe(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 BehaviorSubject(false);
+        /**
+         * An Observable that emits `true` if the user's microphone is muted, but they're speaking.
+         */
         this.speakingWhileMuted$ = this.speakingWhileMutedSubject
             .asObservable()
             .pipe(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$);
@@ -10891,7 +11088,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;
@@ -11087,6 +11284,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();
@@ -11123,9 +11335,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 BehaviorSubject(true);
         this.settingsSubject = new BehaviorSubject(undefined);
         /**
@@ -11174,7 +11389,7 @@ class ScreenShareState extends InputMediaDeviceManagerState {
     }
 }
 
-class ScreenShareManager extends InputMediaDeviceManager {
+class ScreenShareManager extends AudioDeviceManager {
     constructor(call) {
         super(call, new ScreenShareState(), TrackType.SCREEN_SHARE);
     }
@@ -11184,6 +11399,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,
@@ -11240,6 +11456,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);
     }
@@ -11253,19 +11482,27 @@ class ScreenShareManager extends InputMediaDeviceManager {
 
 class SpeakerState {
     constructor(tracer) {
+        this.tracer = tracer;
         this.selectedDeviceSubject = new BehaviorSubject('');
         this.volumeSubject = new 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(distinctUntilChanged());
-        this.volume$ = this.volumeSubject
-            .asObservable()
-            .pipe(distinctUntilChanged());
+        /**
+         * An Observable that emits the currently selected volume
+         *
+         * Note: this feature is not supported in React Native
+         */
+        this.volume$ = this.volumeSubject.asObservable().pipe(distinctUntilChanged());
     }
     /**
      * The currently selected device
@@ -11869,7 +12106,6 @@ class Call {
             if ([CallingState.JOINED, CallingState.JOINING].includes(callingState)) {
                 throw new Error(`Illegal State: call.join() shall be called only once`);
             }
-            this.state.setCallingState(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
@@ -11898,8 +12134,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;
                     }
                 }
@@ -11959,6 +12193,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
@@ -11982,6 +12217,7 @@ class Call {
                     : [];
                 try {
                     const { callState, fastReconnectDeadlineSeconds, publishOptions } = await sfuClient.join({
+                        unifiedSessionId: this.unifiedSessionId,
                         subscriberSdp,
                         publisherSdp,
                         clientDetails,
@@ -12027,6 +12263,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
@@ -12153,7 +12390,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();
@@ -12208,7 +12445,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,
@@ -12218,7 +12454,7 @@ class Call {
                     camera: this.camera,
                     state: this.state,
                     tracer: this.tracer,
-                    unifiedSessionId: this.unifiedSessionId,
+                    unifiedSessionId,
                 });
                 this.sfuStatsReporter.start();
             }
@@ -12591,10 +12827,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)) {
@@ -12612,14 +12849,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 !== CallingState.IDLE &&
+                c.state.callingState !== CallingState.LEFT &&
+                c.state.callingState !== 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);
@@ -15108,5 +15375,5 @@ class StreamVideoClient {
 }
 StreamVideoClient._instances = new Map();
 
-export { AudioSettingsRequestDefaultDeviceEnum, AudioSettingsResponseDefaultDeviceEnum, browsers as Browsers, Call, CallState, CallType, CallTypes, CallingState, CameraManager, CameraManagerState, CreateDeviceRequestPushProviderEnum, DebounceType, DynascaleManager, ErrorFromResponse, FrameRecordingSettingsRequestModeEnum, FrameRecordingSettingsRequestQualityEnum, FrameRecordingSettingsResponseModeEnum, IngressAudioEncodingOptionsRequestChannelsEnum, IngressVideoLayerRequestCodecEnum, InputMediaDeviceManager, InputMediaDeviceManagerState, LayoutSettingsRequestNameEnum, MicrophoneManager, MicrophoneManagerState, NoiseCancellationSettingsModeEnum, OwnCapability, RNSpeechDetector, RTMPBroadcastRequestQualityEnum, RTMPSettingsRequestQualityEnum, RecordSettingsRequestModeEnum, RecordSettingsRequestQualityEnum, rxUtils as RxUtils, ScreenShareManager, ScreenShareState, events as SfuEvents, models as SfuModels, SpeakerManager, SpeakerState, StartClosedCaptionsRequestLanguageEnum, StartTranscriptionRequestLanguageEnum, StreamSfuClient, StreamVideoClient, StreamVideoReadOnlyStateStore, StreamVideoWriteableStateStore, TranscriptionSettingsRequestClosedCaptionModeEnum, TranscriptionSettingsRequestLanguageEnum, TranscriptionSettingsRequestModeEnum, TranscriptionSettingsResponseClosedCaptionModeEnum, TranscriptionSettingsResponseLanguageEnum, TranscriptionSettingsResponseModeEnum, VideoSettingsRequestCameraFacingEnum, VideoSettingsResponseCameraFacingEnum, ViewportTracker, VisibilityState, checkIfAudioOutputChangeSupported, combineComparators, conditional, createSoundDetector, defaultSortPreset, descending, deviceIds$, disposeOfMediaStream, dominantSpeaker, getAudioBrowserPermission, getAudioDevices, getAudioOutputDevices, getAudioStream, getClientDetails, getDeviceState, getLogLevel, getLogger, getScreenShareStream, getSdkInfo, getVideoBrowserPermission, getVideoDevices, getVideoStream, getWebRTCInfo, hasAudio, hasPausedTrack, hasScreenShare, hasScreenShareAudio, hasVideo, isPinned, livestreamOrAudioRoomSortPreset, logLevels, logToConsole, name, noopComparator, paginatedLayoutSortPreset, pinned, publishingAudio, publishingVideo, reactionType, resolveDeviceId, role, screenSharing, setDeviceInfo, setLogLevel, setLogger, setOSInfo, setPowerState, setSdkInfo, setThermalState, setWebRTCInfo, speakerLayoutSortPreset, speaking, withParticipantSource };
+export { AudioSettingsRequestDefaultDeviceEnum, AudioSettingsResponseDefaultDeviceEnum, browsers as Browsers, Call, CallState, CallType, CallTypes, CallingState, CameraManager, CameraManagerState, CreateDeviceRequestPushProviderEnum, DebounceType, DeviceManager, DeviceManagerState, DynascaleManager, ErrorFromResponse, FrameRecordingSettingsRequestModeEnum, FrameRecordingSettingsRequestQualityEnum, FrameRecordingSettingsResponseModeEnum, IngressAudioEncodingOptionsRequestChannelsEnum, IngressVideoLayerRequestCodecEnum, LayoutSettingsRequestNameEnum, MicrophoneManager, MicrophoneManagerState, NoiseCancellationSettingsModeEnum, OwnCapability, RNSpeechDetector, RTMPBroadcastRequestQualityEnum, RTMPSettingsRequestQualityEnum, RecordSettingsRequestModeEnum, RecordSettingsRequestQualityEnum, rxUtils as RxUtils, ScreenShareManager, ScreenShareState, events as SfuEvents, models as SfuModels, SpeakerManager, SpeakerState, StartClosedCaptionsRequestLanguageEnum, StartTranscriptionRequestLanguageEnum, StreamSfuClient, StreamVideoClient, StreamVideoReadOnlyStateStore, StreamVideoWriteableStateStore, TranscriptionSettingsRequestClosedCaptionModeEnum, TranscriptionSettingsRequestLanguageEnum, TranscriptionSettingsRequestModeEnum, TranscriptionSettingsResponseClosedCaptionModeEnum, TranscriptionSettingsResponseLanguageEnum, TranscriptionSettingsResponseModeEnum, VideoSettingsRequestCameraFacingEnum, VideoSettingsResponseCameraFacingEnum, ViewportTracker, VisibilityState, checkIfAudioOutputChangeSupported, combineComparators, conditional, createSoundDetector, defaultSortPreset, descending, deviceIds$, disposeOfMediaStream, dominantSpeaker, getAudioBrowserPermission, getAudioDevices, getAudioOutputDevices, getAudioStream, getClientDetails, getDeviceState, getLogLevel, getLogger, getScreenShareStream, getSdkInfo, getVideoBrowserPermission, getVideoDevices, getVideoStream, getWebRTCInfo, hasAudio, hasPausedTrack, hasScreenShare, hasScreenShareAudio, hasVideo, isPinned, livestreamOrAudioRoomSortPreset, logLevels, logToConsole, name, noopComparator, paginatedLayoutSortPreset, pinned, publishingAudio, publishingVideo, reactionType, resolveDeviceId, role, screenSharing, setDeviceInfo, setLogLevel, setLogger, setOSInfo, setPowerState, setSdkInfo, setThermalState, setWebRTCInfo, speakerLayoutSortPreset, speaking, withParticipantSource };
 //# sourceMappingURL=index.browser.es.js.map