@stream-io/video-react-native-sdk 1.41.0 → 1.43.0

package/ios/StreamInCallManager.swift

@@ -17,6 +17,20 @@ enum DefaultAudioDevice {
     case earpiece
 }
 
+/// An explicit output route chosen via the device picker.
+///
+/// `nil` (no explicit pick) means the call uses the category-driven default
+/// (`.defaultToSpeaker` when the default device is the speaker), which keeps the
+/// default route headphone-aware. Once the user picks a device we drive the route
+/// explicitly instead — `.defaultToSpeaker` is dropped so `overrideOutputAudioPort(.none)`
+/// can reach the earpiece (with `.defaultToSpeaker` present it resolves to the speaker).
+private enum OutputRouting {
+    case speaker
+    /// Built-in earpiece (the built-in mic uid), wired headset, or Bluetooth — all
+    /// reached via `overrideOutputAudioPort(.none)` + `setPreferredInput(port)`.
+    case input(uid: String)
+}
+
 private enum Constants {
     /// Debounce interval for refreshing stereo playout state after audio route changes.
     ///
@@ -32,6 +46,14 @@ private enum Constants {
 
 private enum StreamInCallManagerEvents {
     static let audioInterruption = "StreamInCallManagerAudioInterruption"
+    static let audioDeviceChanged = "onAudioDeviceChanged"
+}
+
+/// Stable device-id scheme for the JS layer. The built-in speaker is synthetic; every
+/// other device is keyed by its `AVAudioSessionPortDescription.uid` (the
+/// built-in earpiece is the built-in mic input routed with `.none`).
+private enum AudioDeviceId {
+    static let speaker = "speaker"
 }
 
 @objc(StreamInCallManager)
@@ -42,6 +64,9 @@ class StreamInCallManager: RCTEventEmitter {
     private var audioManagerActivated = false
     private var callAudioRole: CallAudioRole = .communicator
     private var defaultAudioDevice: DefaultAudioDevice = .speaker
+    /// The user's explicit output pick, or `nil` to use the category default.
+    /// Re-applied on every engine rebuild so the pick survives interruptions.
+    private var selectedOutput: OutputRouting?
     private var enableStereo: Bool = false
     private var previousVolume: Float = 0.75
 
@@ -101,7 +126,7 @@ class StreamInCallManager: RCTEventEmitter {
     }
     
     /// Builds the audio config for the current role/device and sets it as WebRTC's default.
-    private func makeAudioConfiguration() -> RTCAudioSessionConfiguration {
+    private func makeAudioConfiguration(for routing: OutputRouting?) -> RTCAudioSessionConfiguration {
         let category: AVAudioSession.Category
         let mode: AVAudioSession.Mode
         let options: AVAudioSession.CategoryOptions
@@ -127,7 +152,7 @@ class StreamInCallManager: RCTEventEmitter {
             // only exists under .playAndRecord.
             category = .playback
             mode = .spokenAudio
-            options = []
+            options = [.mixWithOthers]
         } else {
             // XCode 16 and older don't expose .allowBluetoothHFP
             // https://forums.swift.org/t/xcode-26-avaudiosession-categoryoptions-allowbluetooth-deprecated/80956
@@ -138,7 +163,14 @@ class StreamInCallManager: RCTEventEmitter {
             #endif
             category = .playAndRecord
             mode = .voiceChat
-            options = defaultAudioDevice == .speaker ? [bluetoothOption, .defaultToSpeaker] : [bluetoothOption]
+            
+            var mustSetDefaultToSpeaker = defaultAudioDevice == .speaker
+            if case .input(let uid) = routing, isBuiltInMicUid(uid) {
+                // the selected output is a built-in mic
+                // then we always can't use defaultToSpeaker
+                mustSetDefaultToSpeaker = false
+            }
+            options = mustSetDefaultToSpeaker ? [bluetoothOption, .defaultToSpeaker, .mixWithOthers] : [bluetoothOption, .mixWithOthers]
         }
 
         let rtcConfig = RTCAudioSessionConfiguration.webRTC()
@@ -162,16 +194,21 @@ class StreamInCallManager: RCTEventEmitter {
     func setup() {
         audioSessionQueue.async { [self] in
             let adm = getAudioDeviceModule()
+            selectedOutput = nil
+
+            // This path (no CallKit) owns audio-session activation itself, so the
+            // engine must be allowed to start. Restores availability in case a
+            // prior CallKit call had gated it off.
+            _ = adm.setEngineAvailability(.default)
 
             // Stereo is listener-only and applies live. Cleared by stop()'s reset().
             if callAudioRole == .listener && enableStereo {
                 adm.setStereoPlayoutPreference(true)
             }
 
-            let rtcConfig = makeAudioConfiguration()
+            let rtcConfig = makeAudioConfiguration(for: selectedOutput)
             log("Setup with category: \(rtcConfig.category), mode: \(rtcConfig.mode), options: \(rtcConfig.categoryOptions)")
 
-            // Set category only — the sink owns setActive().
             let session = RTCAudioSession.sharedInstance()
             session.lockForConfiguration()
             defer { session.unlockForConfiguration() }
@@ -223,13 +260,16 @@ class StreamInCallManager: RCTEventEmitter {
             return
         }
 
-        let rtcConfig = makeAudioConfiguration()
+        let rtcConfig = makeAudioConfiguration(for: selectedOutput)
         let session = RTCAudioSession.sharedInstance()
         session.lockForConfiguration()
         defer { session.unlockForConfiguration() }
         do {
-            try session.setConfiguration(rtcConfig)
-            try session.setActive(true)
+            try session.setConfiguration(rtcConfig, active: true)
+            // Re-apply the explicit pick (if any) so it survives the engine rebuild.
+            if let selectedOutput {
+                try applyOutputRouting(selectedOutput)
+            }
             log("engineWillEnable: applied category=\(rtcConfig.category) mode=\(rtcConfig.mode) activated=true")
         } catch {
             log("engineWillEnable error: \(String(describing: error))")
@@ -252,6 +292,21 @@ class StreamInCallManager: RCTEventEmitter {
         }
     }
 
+    private func clearOutputRouting() {
+        if Self.callingxOwnsSession() {
+            return
+        }
+        let session = RTCAudioSession.sharedInstance()
+        session.lockForConfiguration()
+        defer { session.unlockForConfiguration() }
+        do {
+            try session.overrideOutputAudioPort(.none)
+            try AVAudioSession.sharedInstance().setPreferredInput(nil)
+        } catch {
+            log("clearOutputRouting error: \(String(describing: error))")
+        }
+    }
+
     /// Runtime KVC lookup of `CallingxSessionOwnership.callingxOwnsSession`.
     /// `@stream-io/react-native-callingx` is an optional peer dep, so a direct
     /// Swift `import` is not safe
@@ -303,6 +358,7 @@ class StreamInCallManager: RCTEventEmitter {
             }
             let adm = getAudioDeviceModule()
             adm.reset()
+            clearOutputRouting()
             // Deactivate directly: the .didDisableAudioEngine sink is async and we cancel it below.
             applyConfigForEngineDisable()
             // Tear down the engine-observer subscription so a re-setup wires a fresh one.
@@ -313,6 +369,7 @@ class StreamInCallManager: RCTEventEmitter {
             stereoRefreshWorkItem = nil
             callAudioRole = .communicator
             defaultAudioDevice = .speaker
+            selectedOutput = nil
             enableStereo = false
             audioManagerActivated = false
         }
@@ -345,18 +402,21 @@ class StreamInCallManager: RCTEventEmitter {
 
     @objc(setForceSpeakerphoneOn:)
     func setForceSpeakerphoneOn(enable: Bool) {
-        audioSessionQueue.async { [weak self] in
+        audioSessionQueue.async { [self] in
             let session = RTCAudioSession.sharedInstance()
             session.lockForConfiguration()
             defer {
                 session.unlockForConfiguration()
             }
-            let avAudioSession = AVAudioSession.sharedInstance()
             do {
-                try avAudioSession.overrideOutputAudioPort(enable ? .speaker : .none)
-                try avAudioSession.setActive(true)
+                if enable {
+                    try applyOutputRouting(.speaker)
+                } else {
+                    try session.overrideOutputAudioPort(.none)
+                    try AVAudioSession.sharedInstance().setPreferredInput(nil)
+                }
             } catch {
-                self?.log("Error setting speakerphone: \(error)")
+                self.log("Error setting speakerphone: \(error)")
             }
         }
     }
@@ -367,6 +427,174 @@ class StreamInCallManager: RCTEventEmitter {
         log("iOS does not support setMicrophoneMute()")
     }
 
+    // MARK: - Audio Device Picker
+
+    @objc(getAudioDeviceStatus:reject:)
+    func getAudioDeviceStatus(resolve: @escaping RCTPromiseResolveBlock,
+                              reject: @escaping RCTPromiseRejectBlock) {
+        audioSessionQueue.async { [weak self] in
+            guard let self else {
+                resolve(["devices": [], "currentEndpointType": "Unknown"])
+                return
+            }
+            resolve(self.buildAudioDevicesState())
+        }
+    }
+
+    /// Switches the audio output to the device with the given id.
+    @objc(chooseAudioDeviceEndpoint:)
+    func chooseAudioDeviceEndpoint(id: String) {
+        audioSessionQueue.async { [self] in
+            guard callAudioRole == .communicator else {
+                log("chooseAudioDeviceEndpoint ignored: only supported in communicator role")
+                return
+            }
+
+            let routing: OutputRouting = id == AudioDeviceId.speaker ? .speaker : .input(uid: id)
+
+            let session = RTCAudioSession.sharedInstance()
+            session.lockForConfiguration()
+            defer { session.unlockForConfiguration() }
+            do {
+                // Reconfigure first so the live category matches the pick (e.g. the earpiece
+                // drops `.defaultToSpeaker`, otherwise overrideOutputAudioPort(.none) would
+                // resolve back to the speaker). Then drive the route.
+                try session.setConfiguration(makeAudioConfiguration(for: routing))
+                try applyOutputRouting(routing)
+                selectedOutput = routing
+            } catch {
+                // a failure leaves the previous route intact.
+                log("chooseAudioDeviceEndpoint error: \(String(describing: error))")
+            }
+        }
+    }
+
+    /// Re-applies the current output pick (`selectedOutput`) — category untouched, no setActive.
+    /// Called on interruption-end (via callingx's interruption event, forwarded from JS) to
+    /// restore a Bluetooth/wired route
+    @objc(reapplyAudioRoute)
+    func reapplyAudioRoute() {
+        audioSessionQueue.async { [self] in
+            guard callAudioRole == .communicator, let routing = selectedOutput else { return }
+            let session = RTCAudioSession.sharedInstance()
+            session.lockForConfiguration()
+            defer { session.unlockForConfiguration() }
+            do {
+                try applyOutputRouting(routing)
+            } catch {
+                log("reapplyAudioRoute error: \(String(describing: error))")
+            }
+        }
+    }
+
+    /// Whether `uid` is the built-in microphone (i.e. an earpiece pick, in our id scheme).
+    private func isBuiltInMicUid(_ uid: String) -> Bool {
+        AVAudioSession.sharedInstance().availableInputs?
+            .contains { $0.uid == uid && $0.portType == .builtInMic } ?? false
+    }
+
+    /// Drives the audio route. Throws if a session command fails, so callers can gate
+    /// committed state (e.g. `selectedOutput`) on the route actually being applied.
+    private func applyOutputRouting(_ routing: OutputRouting) throws {
+        let rtcSession = RTCAudioSession.sharedInstance()
+        let availableInputs = AVAudioSession.sharedInstance().availableInputs
+        switch routing {
+            case .speaker:
+                if let builtInMic = availableInputs?.first(where: { $0.portType == .builtInMic }) {
+                    try rtcSession.setPreferredInput(builtInMic)
+                }
+                try rtcSession.overrideOutputAudioPort(.speaker)
+            case .input(let uid):
+                try rtcSession.overrideOutputAudioPort(.none)
+                if let port = availableInputs?.first(where: { $0.uid == uid }) {
+                    try rtcSession.setPreferredInput(port)
+                } else {
+                    log("applyOutputRouting: no input found for id \(uid)")
+                }
+        }
+    }
+
+    /// Canonical endpoint-type string shared with the JS layer.M ust match with the Android implementation.
+    private func endpointType(for portType: AVAudioSession.Port) -> String {
+        switch portType {
+        case .builtInSpeaker: return "Speaker"
+        case .builtInMic, .builtInReceiver: return "Earpiece"
+        case .headphones, .headsetMic: return "Wired Headset"
+        case .bluetoothA2DP, .bluetoothHFP, .bluetoothLE, .carAudio: return "Bluetooth Device"
+        default: return "Unknown"
+        }
+    }
+
+    private func hasExternalAudioDevice(_ session: AVAudioSession) -> Bool {
+        let external: Set<AVAudioSession.Port> = [
+            .headphones, .headsetMic, .bluetoothHFP, .bluetoothA2DP, .bluetoothLE, .carAudio,
+        ]
+        if session.availableInputs?.contains(where: { external.contains($0.portType) }) == true {
+            return true
+        }
+        return session.currentRoute.outputs.contains { external.contains($0.portType) }
+    }
+
+    private func buildAudioDevicesState() -> [String: Any] {
+        let session = AVAudioSession.sharedInstance()
+        let inputs = session.availableInputs ?? []
+        let hasExternal = hasExternalAudioDevice(session)
+
+        var devices: [[String: String]] = [
+            ["id": AudioDeviceId.speaker, "name": "Speaker", "type": "Speaker"]
+        ]
+        for port in inputs {
+            let isBuiltInMic = port.portType == .builtInMic
+            // Hide the earpiece when a wired/BT device is present — it can't be routed to
+            // while one is connected, so listing it would be a dead, duplicate option.
+            if isBuiltInMic && hasExternal { continue }
+            devices.append([
+                "id": port.uid,
+                "name": isBuiltInMic ? "Earpiece" : port.portName,
+                "type": endpointType(for: port.portType),
+            ])
+        }
+
+        let output = session.currentRoute.outputs.first
+        let currentEndpointType = output.map { endpointType(for: $0.portType) } ?? "Unknown"
+
+        // Output-only routes (e.g. wired headphones without a mic) never appear in
+        // availableInputs. Add the active output when no listed device already represents
+        // its endpoint type, so it stays visible and selectable in the picker.
+        if let output,
+           output.portType != .builtInSpeaker,
+           !devices.contains(where: { $0["type"] == currentEndpointType }) {
+            devices.append([
+                "id": output.uid,
+                "name": output.portName,
+                "type": currentEndpointType,
+            ])
+        }
+
+        let selectedDeviceId: String?
+        if output?.portType == .builtInSpeaker {
+            selectedDeviceId = AudioDeviceId.speaker
+        } else if let inputUid = session.currentRoute.inputs.first?.uid,
+                  devices.contains(where: { $0["id"] == inputUid }) {
+            // The active input maps to a listed device (earpiece / wired / BT).
+            selectedDeviceId = inputUid
+        } else {
+            // Output is on a device whose active input differs from a listed one — e.g. BT is
+            // the output while the input stayed built-in mic. Match by the output's endpoint
+            // type so the picker highlights the actual output (not the earpiece).
+            selectedDeviceId = devices.first(where: { $0["type"] == currentEndpointType })?["id"]
+        }
+
+        var result: [String: Any] = [
+            "devices": devices,
+            "currentEndpointType": currentEndpointType,
+        ]
+        if let selectedDeviceId {
+            result["selectedDeviceId"] = selectedDeviceId
+        }
+        return result
+    }
+
     @objc
     func logAudioState() {
         log(getAudioStateLog())
@@ -580,7 +808,19 @@ class StreamInCallManager: RCTEventEmitter {
         }
 
         logAudioState()
-        
+
+        // Notify JS of the updated device list / selection.
+        audioSessionQueue.async { [weak self] in
+            guard let self,
+                  self.audioManagerActivated,
+                  self.callAudioRole == .communicator,
+                  !Self.callingxOwnsSession() else { return }
+            self.sendEvent(
+                withName: StreamInCallManagerEvents.audioDeviceChanged,
+                body: self.buildAudioDevicesState()
+            )
+        }
+
         // Route changes can arrive on arbitrary queues; ensure UI-safe work on main
         DispatchQueue.main.async { [weak self] in
             self?.updateProximityMonitoring()
@@ -616,7 +856,10 @@ class StreamInCallManager: RCTEventEmitter {
     // MARK: - RCTEventEmitter
 
     override func supportedEvents() -> [String]! {
-        return [StreamInCallManagerEvents.audioInterruption]
+        return [
+            StreamInCallManagerEvents.audioInterruption,
+            StreamInCallManagerEvents.audioDeviceChanged,
+        ]
     }
 
     // MARK: - Helper Methods

package/ios/StreamVideoReactNative.m

@@ -51,6 +51,7 @@ void broadcastNotificationCallback(CFNotificationCenterRef center,
     bool hasListeners;
     CFNotificationCenterRef _notificationCenter;
     AVAudioPlayer *_busyTonePlayer; // Instance variable
+    ScreenAudioCapture *_screenAudioCapture; // Broadcast screen-share audio receiver
 }
 
 RCT_EXPORT_MODULE();
@@ -647,19 +648,25 @@ RCT_EXPORT_METHOD(startScreenShareAudioMixing:(RCTPromiseResolveBlock)resolve
     if (apmId && [apmId isKindOfClass:[RTCDefaultAudioProcessingModule class]]) {
         RTCDefaultAudioProcessingModule *apm = (RTCDefaultAudioProcessingModule *)apmId;
         apm.capturePostProcessingDelegate = mixer;
-        NSLog(@"[SSAMixer] Set capturePostProcessingDelegate on APM");
     } else {
-        NSLog(@"[SSAMixer] WARNING: No RTCDefaultAudioProcessingModule available, mixing will not work");
+        NSLog(@"[SSAudio][Native] WARNING: No RTCDefaultAudioProcessingModule available, screen-share audio mixing will not work");
     }
 
     [mixer startMixing];
 
-    // Wire audio buffer handler on the active capturer → mixer.enqueue
     InAppScreenCapturer *capturer = options.activeInAppScreenCapturer;
     if (capturer) {
         capturer.audioBufferHandler = ^(CMSampleBufferRef sampleBuffer) {
             [mixer enqueue:sampleBuffer];
         };
+    } else {
+        if (!_screenAudioCapture) {
+            _screenAudioCapture = [ScreenAudioCapture new];
+        }
+        _screenAudioCapture.onAudioBuffer = ^(AVAudioPCMBuffer *pcmBuffer) {
+            [mixer enqueuePCM:pcmBuffer];
+        };
+        [_screenAudioCapture start];
     }
 
     resolve(nil);
@@ -671,12 +678,16 @@ RCT_EXPORT_METHOD(stopScreenShareAudioMixing:(RCTPromiseResolveBlock)resolve
     WebRTCModule *webrtcModule = [self.moduleRegistry moduleForName:"WebRTCModule"];
     WebRTCModuleOptions *options = [WebRTCModuleOptions sharedInstance];
 
-    // Stop feeding audio to the mixer
     InAppScreenCapturer *capturer = options.activeInAppScreenCapturer;
     if (capturer) {
         capturer.audioBufferHandler = nil;
     }
 
+    if (_screenAudioCapture) {
+        _screenAudioCapture.onAudioBuffer = nil;
+        [_screenAudioCapture stop];
+    }
+
     // Stop mixing
     ScreenShareAudioMixer *mixer = webrtcModule.audioDeviceModule.screenShareAudioMixer;
     [mixer stopMixing];
@@ -686,7 +697,6 @@ RCT_EXPORT_METHOD(stopScreenShareAudioMixing:(RCTPromiseResolveBlock)resolve
     if (apmId && [apmId isKindOfClass:[RTCDefaultAudioProcessingModule class]]) {
         RTCDefaultAudioProcessingModule *apm = (RTCDefaultAudioProcessingModule *)apmId;
         apm.capturePostProcessingDelegate = nil;
-        NSLog(@"[SSAMixer] Cleared capturePostProcessingDelegate on APM");
     }
 
     resolve(nil);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-react-native-sdk",
-  "version": "1.41.0",
+  "version": "1.43.0",
   "description": "Stream Video SDK for React Native",
   "author": "https://getstream.io",
   "homepage": "https://getstream.io/video/docs/react-native/",
@@ -16,7 +16,7 @@
     "build:expo-plugin": "rimraf expo-config-plugin/dist && tsc --project expo-config-plugin/tsconfig.json",
     "build": "yarn copy-version && bob build && yarn build:expo-plugin",
     "test:expo-plugin": "jest --config=expo-config-plugin/jest.config.js --coverage",
-    "test": "yarn copy-version && jest --coverage && yarn test:expo-plugin",
+    "test": "yarn copy-version && jest --coverage && yarn test:types && yarn test:expo-plugin",
     "test:types": "yarn copy-version && tsc -p tsconfig.spec.json",
     "copy-version": "echo \"export const version = '$npm_package_version';\" > ./src/version.ts"
   },
@@ -52,8 +52,8 @@
     "!**/.*"
   ],
   "dependencies": {
-    "@stream-io/video-client": "1.55.2",
-    "@stream-io/video-react-bindings": "1.18.3",
+    "@stream-io/video-client": "1.57.0",
+    "@stream-io/video-react-bindings": "1.19.2",
     "intl-pluralrules": "2.0.1",
     "react-native-url-polyfill": "^3.0.0",
     "rxjs": "~7.8.2",
@@ -65,7 +65,7 @@
     "@react-native-firebase/messaging": ">=17.5.0",
     "@stream-io/noise-cancellation-react-native": ">=0.1.0",
     "@stream-io/react-native-callingx": ">=0.1.0",
-    "@stream-io/react-native-webrtc": "^145.0.0",
+    "@stream-io/react-native-webrtc": "^145.2.0",
     "@stream-io/video-filters-react-native": ">=0.1.0",
     "expo": ">=47.0.0",
     "expo-notifications": "*",
@@ -106,37 +106,39 @@
   },
   "devDependencies": {
     "@babel/core": "^7.29.7",
-    "@expo/config-plugins": "56.0.8",
-    "@expo/config-types": "^56.0.5",
+    "@babel/preset-env": "^7.29.7",
+    "@babel/preset-typescript": "^7.29.7",
+    "@expo/config-plugins": "^57.0.6",
+    "@expo/config-types": "^57.0.2",
     "@expo/plist": "^0.7.0",
     "@react-native-community/netinfo": "12.0.1",
-    "@react-native-firebase/app": "^24.0.0",
-    "@react-native-firebase/messaging": "^24.0.0",
-    "@react-native/babel-preset": "0.85.3",
-    "@react-native/metro-config": "0.85.3",
-    "@stream-io/noise-cancellation-react-native": "^0.9.3",
-    "@stream-io/react-native-callingx": "^0.7.0",
-    "@stream-io/react-native-webrtc": "145.0.0",
+    "@react-native-firebase/app": "^24.1.1",
+    "@react-native-firebase/messaging": "^24.1.1",
+    "@react-native/babel-preset": "0.86.2",
+    "@react-native/jest-preset": "0.86.2",
+    "@react-native/metro-config": "0.86.2",
+    "@stream-io/noise-cancellation-react-native": "^0.10.0",
+    "@stream-io/react-native-callingx": "^0.9.0",
+    "@stream-io/react-native-webrtc": "145.2.0",
     "@stream-io/typescript-config": "^0.0.0",
-    "@stream-io/video-filters-react-native": "^0.14.3",
+    "@stream-io/video-filters-react-native": "^0.15.0",
     "@testing-library/jest-native": "^5.4.3",
     "@testing-library/react-native": "13.3.3",
     "@tsconfig/node18": "^18.2.6",
     "@types/jest": "^29.5.14",
-    "@types/node": "^25.9.3",
-    "@types/react": "~19.2.15",
+    "@types/node": "^25.9.5",
+    "@types/react": "~19.2.18",
     "@types/react-test-renderer": "^19.1.0",
-    "expo": "~56.0.9",
-    "expo-module-scripts": "^56.0.3",
-    "expo-notifications": "~56.0.16",
+    "expo": "~57.0.9",
+    "expo-notifications": "~57.0.8",
     "jest": "^29.7.0",
     "react": "19.2.3",
-    "react-native": "0.85.3",
-    "react-native-builder-bob": "^0.41.0",
-    "react-native-gesture-handler": "~2.31.2",
-    "react-native-reanimated": "4.3.1",
+    "react-native": "0.86.2",
+    "react-native-builder-bob": "^0.43.0",
+    "react-native-gesture-handler": "~2.32.0",
+    "react-native-reanimated": "4.5.3",
     "react-native-svg": "15.15.5",
-    "react-native-worklets": "0.8.3",
+    "react-native-worklets": "0.10.1",
     "react-test-renderer": "19.2.3",
     "rimraf": "^6.1.3",
     "typescript": "^6.0.3"

package/src/components/Call/RingingCallContent/OutgoingCall.tsx

@@ -109,8 +109,7 @@ const Background = () => {
   const { useCameraState } = useCallStateHooks();
   const { isMute, camera } = useCameraState();
   const localVideoStream = camera.state.mediaStream as unknown as
-    | MediaStream
-    | undefined;
+    MediaStream | undefined;
 
   if (isMute || !localVideoStream) {
     return (

package/src/components/Participant/FloatingParticipantView/index.tsx

@@ -25,10 +25,7 @@ import { useFloatingVideoDimensions } from './useFloatingVideoDimensions';
 import { type StreamVideoParticipant } from '@stream-io/video-client';
 
 export type FloatingParticipantViewAlignment =
-  | 'top-left'
-  | 'top-right'
-  | 'bottom-left'
-  | 'bottom-right';
+  'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
 
 /**
  * Props to be passed for the LocalVideoView component.

package/src/contexts/ThemeContext.tsx

@@ -7,8 +7,17 @@ import React, {
 
 import { defaultTheme, type Theme } from '../theme/theme';
 
+/**
+ * Recursively marks every property of `T` as optional.
+ *
+ * The `extends object` guard is required, not cosmetic: `Theme` carries a
+ * `[component: string]: any` index signature, which the mapped type inherits.
+ * Without the guard that index signature becomes `DeepPartial<any>`, an
+ * all-object type that no primitive leaf can satisfy, and every theme override
+ * fails to typecheck. Guarding short-circuits `any` back to `any`.
+ */
 export type DeepPartial<T> = {
-  [P in keyof T]?: DeepPartial<T[P]>;
+  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
 };
 
 export type StreamThemeInputValue = {

package/src/hooks/index.ts

@@ -11,3 +11,4 @@ export * from './useLoopbackRecording';
 export * from './useTrackDimensions';
 export * from './useScreenshot';
 export * from './useModeration';
+export * from './useAudioDeviceStatus';