@stream-io/video-client 1.42.2 → 1.43.0-beta.0

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+## [1.42.3](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.42.2...@stream-io/video-client-1.42.3) (2026-02-16)
+
+### Bug Fixes
+
+- guard from parallel accept/reject invocations ([#2127](https://github.com/GetStream/stream-video-js/issues/2127)) ([621218f](https://github.com/GetStream/stream-video-js/commit/621218f4ab6b4623370fd66f1b02b8cb7cb1baad))
+
 ## [1.42.2](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.42.1...@stream-io/video-client-1.42.2) (2026-02-13)
 
 ### Bug Fixes

package/dist/index.browser.es.js

@@ -6231,7 +6231,7 @@ const getSdkVersion = (sdk) => {
     return sdk ? `${sdk.major}.${sdk.minor}.${sdk.patch}` : '0.0.0-development';
 };
 
-const version = "1.42.2";
+const version = "1.43.0-beta.0";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -8924,6 +8924,7 @@ const watchCallRejected = (call) => {
         else {
             if (rejectedBy[eventCall.created_by.id]) {
                 call.logger.info('call creator rejected, leaving call');
+                globalThis.streamRNVideoSDK?.callingX?.endCall(call, 'remote');
                 await call.leave({ message: 'ring: creator rejected' });
             }
         }
@@ -8937,6 +8938,7 @@ const watchCallEnded = (call) => {
         const { callingState } = call.state;
         if (callingState !== CallingState.IDLE &&
             callingState !== CallingState.LEFT) {
+            globalThis.streamRNVideoSDK?.callingX?.endCall(call, 'remote');
             call
                 .leave({ message: 'call.ended event received', reject: false })
                 .catch((err) => {
@@ -8965,6 +8967,7 @@ const watchSfuCallEnded = (call) => {
             // update the call state to reflect the call has ended.
             call.state.setEndedAt(new Date());
             const reason = CallEndedReason[e.reason];
+            globalThis.streamRNVideoSDK?.callingX?.endCall(call, 'remote');
             await call.leave({ message: `callEnded received: ${reason}` });
         }
         catch (err) {
@@ -11480,12 +11483,21 @@ const createSoundDetector = (audioStream, onSoundDetectedStateChanged, options =
 };
 
 /**
- * Analyzes frequency data to determine if audio is being captured.
+ * Analyzes time-domain waveform data to determine if audio is being captured.
+ * Uses the waveform RMS around the 128 midpoint for robust silence detection.
  */
-const hasAudio = (analyser, threshold) => {
-    const data = new Uint8Array(analyser.frequencyBinCount);
-    analyser.getByteFrequencyData(data);
-    return data.some((value) => value > threshold);
+const hasAudio = (analyser) => {
+    const data = new Uint8Array(analyser.fftSize);
+    analyser.getByteTimeDomainData(data);
+    let squareSum = 0;
+    for (const sample of data) {
+        const centered = sample - 128;
+        // Ignore tiny quantization/jitter around midpoint (e.g. 127/128 samples).
+        const signal = Math.abs(centered) <= 1 ? 0 : centered;
+        squareSum += signal * signal;
+    }
+    const rms = Math.sqrt(squareSum / data.length);
+    return rms > 0;
 };
 /** Helper for "no event" transitions */
 const noEmit = (nextState) => ({
@@ -11499,9 +11511,9 @@ const emit = (capturesAudio, nextState) => ({ shouldEmit: true, nextState, captu
  */
 const transitionState = (state, audioDetected, options) => {
     if (audioDetected) {
-        return state.kind === 'IDLE' || state.kind === 'EMITTING'
-            ? emit(true, state)
-            : noEmit(state);
+        // Any observed audio means the microphone is capturing.
+        // Emit recovery/success and let the caller stop the detector.
+        return emit(true, { kind: 'IDLE' });
     }
     const { noAudioThresholdMs, emitIntervalMs } = options;
     const now = Date.now();
@@ -11542,16 +11554,17 @@ const createAudioAnalyzer = (audioStream, fftSize) => {
  * @returns a cleanup function which once invoked stops the no-audio detector.
  */
 const createNoAudioDetector = (audioStream, options) => {
-    const { detectionFrequencyInMs = 350, audioLevelThreshold = 0, fftSize = 256, onCaptureStatusChange, } = options;
+    const { detectionFrequencyInMs = 350, fftSize = 512, onCaptureStatusChange, } = options;
     let state = { kind: 'IDLE' };
     const { audioContext, analyser } = createAudioAnalyzer(audioStream, fftSize);
     const detectionIntervalId = setInterval(() => {
-        const [audioTrack] = audioStream.getAudioTracks();
-        if (!audioTrack?.enabled || audioTrack.readyState === 'ended') {
+        const [track] = audioStream.getAudioTracks();
+        if (track && !track.enabled) {
             state = { kind: 'IDLE' };
             return;
         }
-        const audioDetected = hasAudio(analyser, audioLevelThreshold);
+        // Missing or ended track is treated as no-audio to surface abrupt capture loss.
+        const audioDetected = track?.readyState === 'live' && hasAudio(analyser);
         const transition = transitionState(state, audioDetected, options);
         state = transition.nextState;
         if (!transition.shouldEmit)
@@ -12024,6 +12037,9 @@ class MicrophoneManager extends AudioDeviceManager {
     }
     async startSpeakingWhileMutedDetection(deviceId) {
         await withoutConcurrency(this.soundDetectorConcurrencyTag, async () => {
+            if (this.soundDetectorCleanup && this.soundDetectorDeviceId === deviceId)
+                return;
+            await this.teardownSpeakingWhileMutedDetection();
             if (isReactNative()) {
                 this.rnSpeechDetector = new RNSpeechDetector();
                 const unsubscribe = await this.rnSpeechDetector.start((event) => {
@@ -12044,16 +12060,23 @@ class MicrophoneManager extends AudioDeviceManager {
                     this.state.setSpeakingWhileMuted(event.isSoundDetected);
                 });
             }
+            this.soundDetectorDeviceId = deviceId;
         });
     }
     async stopSpeakingWhileMutedDetection() {
         await withoutConcurrency(this.soundDetectorConcurrencyTag, async () => {
-            if (!this.soundDetectorCleanup)
-                return;
-            const soundDetectorCleanup = this.soundDetectorCleanup;
-            this.soundDetectorCleanup = undefined;
-            this.state.setSpeakingWhileMuted(false);
-            await soundDetectorCleanup();
+            return this.teardownSpeakingWhileMutedDetection();
+        });
+    }
+    async teardownSpeakingWhileMutedDetection() {
+        const soundDetectorCleanup = this.soundDetectorCleanup;
+        this.soundDetectorCleanup = undefined;
+        this.soundDetectorDeviceId = undefined;
+        this.state.setSpeakingWhileMuted(false);
+        if (!soundDetectorCleanup)
+            return;
+        await soundDetectorCleanup().catch((err) => {
+            this.logger.warn('Failed to stop speaking while muted detector', err);
         });
     }
     async hasPermission(permissionState) {
@@ -12322,6 +12345,7 @@ class SpeakerManager {
             this.defaultDevice = defaultDevice;
             globalThis.streamRNVideoSDK?.callManager.setup({
                 defaultDevice,
+                isRingingTypeCall: this.call.ringing,
             });
         }
     }
@@ -12446,6 +12470,7 @@ class Call {
         this.hasJoinedOnce = false;
         this.deviceSettingsAppliedOnce = false;
         this.initialized = false;
+        this.acceptRejectConcurrencyTag = Symbol('acceptRejectTag');
         this.joinLeaveConcurrencyTag = Symbol('joinLeaveConcurrencyTag');
         /**
          * A list hooks/functions to invoke when the call is left.
@@ -12511,6 +12536,7 @@ class Call {
                 const currentUserId = this.currentUserId;
                 if (currentUserId && blockedUserIds.includes(currentUserId)) {
                     this.logger.info('Leaving call because of being blocked');
+                    globalThis.streamRNVideoSDK?.callingX?.endCall(this, 'restricted');
                     await this.leave({ message: 'user blocked' }).catch((err) => {
                         this.logger.error('Error leaving call after being blocked', err);
                     });
@@ -12547,6 +12573,7 @@ class Call {
                 const isAcceptedElsewhere = isAcceptedByMe && this.state.callingState === CallingState.RINGING;
                 if ((isAcceptedElsewhere || isRejectedByMe) &&
                     !hasPending(this.joinLeaveConcurrencyTag)) {
+                    globalThis.streamRNVideoSDK?.callingX?.endCall(this, isAcceptedElsewhere ? 'answeredElsewhere' : 'rejected');
                     this.leave().catch(() => {
                         this.logger.error('Could not leave a call that was accepted or rejected elsewhere');
                     });
@@ -12696,17 +12723,28 @@ class Call {
                 }
                 if (callingState === CallingState.RINGING && reject !== false) {
                     if (reject) {
-                        await this.reject(reason ?? 'decline');
+                        const reasonToEndCallReason = {
+                            timeout: 'missed',
+                            cancel: 'canceled',
+                            busy: 'busy',
+                            decline: 'rejected',
+                        };
+                        const rejectReason = reason ?? 'decline';
+                        const endCallReason = reasonToEndCallReason[rejectReason] ?? 'rejected';
+                        globalThis.streamRNVideoSDK?.callingX?.endCall(this, endCallReason);
+                        await this.reject(rejectReason);
                     }
                     else {
                         // if reject was undefined, we still have to cancel the call automatically
                         // when I am the creator and everyone else left the call
                         const hasOtherParticipants = this.state.remoteParticipants.length > 0;
                         if (this.isCreatedByMe && !hasOtherParticipants) {
+                            globalThis.streamRNVideoSDK?.callingX?.endCall(this, 'canceled');
                             await this.reject('cancel');
                         }
                     }
                 }
+                globalThis.streamRNVideoSDK?.callingX?.endCall(this);
                 this.statsReporter?.stop();
                 this.statsReporter = undefined;
                 const leaveReason = message ?? reason ?? 'user is leaving the call';
@@ -12733,7 +12771,9 @@ class Call {
                 this.ringingSubject.next(false);
                 this.cancelAutoDrop();
                 this.clientStore.unregisterCall(this);
-                globalThis.streamRNVideoSDK?.callManager.stop();
+                globalThis.streamRNVideoSDK?.callManager.stop({
+                    isRingingTypeCall: this.ringing,
+                });
                 this.camera.dispose();
                 this.microphone.dispose();
                 this.screenShare.dispose();
@@ -12860,8 +12900,10 @@ class Call {
          * Unless you are implementing a custom "ringing" flow, you should not use this method.
          */
         this.accept = async () => {
-            this.tracer.trace('call.accept', '');
-            return this.streamClient.post(`${this.streamClientBasePath}/accept`);
+            return withoutConcurrency(this.acceptRejectConcurrencyTag, () => {
+                this.tracer.trace('call.accept', '');
+                return this.streamClient.post(`${this.streamClientBasePath}/accept`);
+            });
         };
         /**
          * Marks the incoming call as rejected.
@@ -12873,8 +12915,10 @@ class Call {
          * @param reason the reason for rejecting the call.
          */
         this.reject = async (reason = 'decline') => {
-            this.tracer.trace('call.reject', reason);
-            return this.streamClient.post(`${this.streamClientBasePath}/reject`, { reason: reason });
+            return withoutConcurrency(this.acceptRejectConcurrencyTag, () => {
+                this.tracer.trace('call.reject', reason);
+                return this.streamClient.post(`${this.streamClientBasePath}/reject`, { reason });
+            });
         };
         /**
          * Will start to watch for call related WebSocket events and initiate a call session with the server.
@@ -12882,11 +12926,19 @@ class Call {
          * @returns a promise which resolves once the call join-flow has finished.
          */
         this.join = async ({ maxJoinRetries = 3, joinResponseTimeout, rpcRequestTimeout, ...data } = {}) => {
-            await this.setup();
             const callingState = this.state.callingState;
             if ([CallingState.JOINED, CallingState.JOINING].includes(callingState)) {
                 throw new Error(`Illegal State: call.join() shall be called only once`);
             }
+            if (data?.ring) {
+                this.ringingSubject.next(true);
+            }
+            const callingX = globalThis.streamRNVideoSDK?.callingX;
+            if (callingX) {
+                // for Android/iOS, we need to start the call in the callingx library as soon as possible
+                await callingX.startCall(this);
+            }
+            await this.setup();
             this.joinResponseTimeout = joinResponseTimeout;
             this.rpcRequestTimeout = rpcRequestTimeout;
             // we will count the number of join failures per SFU.
@@ -12895,38 +12947,44 @@ class Call {
             const sfuJoinFailures = new Map();
             const joinData = data;
             maxJoinRetries = Math.max(maxJoinRetries, 1);
-            for (let attempt = 0; attempt < maxJoinRetries; attempt++) {
-                try {
-                    this.logger.trace(`Joining call (${attempt})`, this.cid);
-                    await this.doJoin(data);
-                    delete joinData.migrating_from;
-                    delete joinData.migrating_from_list;
-                    break;
-                }
-                catch (err) {
-                    this.logger.warn(`Failed to join call (${attempt})`, this.cid);
-                    if ((err instanceof ErrorFromResponse && err.unrecoverable) ||
-                        (err instanceof SfuJoinError && err.unrecoverable)) {
-                        // if the error is unrecoverable, we should not retry as that signals
-                        // that connectivity is good, but the coordinator doesn't allow the user
-                        // to join the call due to some reason (e.g., ended call, expired token...)
-                        throw err;
-                    }
-                    // immediately switch to a different SFU in case of recoverable join error
-                    const switchSfu = err instanceof SfuJoinError &&
-                        SfuJoinError.isJoinErrorCode(err.errorEvent);
-                    const sfuId = this.credentials?.server.edge_name || '';
-                    const failures = (sfuJoinFailures.get(sfuId) || 0) + 1;
-                    sfuJoinFailures.set(sfuId, failures);
-                    if (switchSfu || failures >= 2) {
-                        joinData.migrating_from = sfuId;
-                        joinData.migrating_from_list = Array.from(sfuJoinFailures.keys());
+            try {
+                for (let attempt = 0; attempt < maxJoinRetries; attempt++) {
+                    try {
+                        this.logger.trace(`Joining call (${attempt})`, this.cid);
+                        await this.doJoin(data);
+                        delete joinData.migrating_from;
+                        delete joinData.migrating_from_list;
+                        break;
                     }
-                    if (attempt === maxJoinRetries - 1) {
-                        throw err;
+                    catch (err) {
+                        this.logger.warn(`Failed to join call (${attempt})`, this.cid);
+                        if ((err instanceof ErrorFromResponse && err.unrecoverable) ||
+                            (err instanceof SfuJoinError && err.unrecoverable)) {
+                            // if the error is unrecoverable, we should not retry as that signals
+                            // that connectivity is good, but the coordinator doesn't allow the user
+                            // to join the call due to some reason (e.g., ended call, expired token...)
+                            throw err;
+                        }
+                        // immediately switch to a different SFU in case of recoverable join error
+                        const switchSfu = err instanceof SfuJoinError &&
+                            SfuJoinError.isJoinErrorCode(err.errorEvent);
+                        const sfuId = this.credentials?.server.edge_name || '';
+                        const failures = (sfuJoinFailures.get(sfuId) || 0) + 1;
+                        sfuJoinFailures.set(sfuId, failures);
+                        if (switchSfu || failures >= 2) {
+                            joinData.migrating_from = sfuId;
+                            joinData.migrating_from_list = Array.from(sfuJoinFailures.keys());
+                        }
+                        if (attempt === maxJoinRetries - 1) {
+                            throw err;
+                        }
                     }
+                    await sleep(retryInterval(attempt));
                 }
-                await sleep(retryInterval(attempt));
+            }
+            catch (error) {
+                callingX?.endCall(this, 'error');
+                throw error;
             }
         };
         /**
@@ -13073,7 +13131,9 @@ class Call {
             // re-apply them on later reconnections or server-side data fetches
             if (!this.deviceSettingsAppliedOnce && this.state.settings) {
                 await this.applyDeviceConfig(this.state.settings, true);
-                globalThis.streamRNVideoSDK?.callManager.start();
+                globalThis.streamRNVideoSDK?.callManager.start({
+                    isRingingTypeCall: this.ringing,
+                });
                 this.deviceSettingsAppliedOnce = true;
             }
             // We shouldn't persist the `ring` and `notify` state after joining the call
@@ -13501,6 +13561,7 @@ class Call {
                 if (strategy === WebsocketReconnectStrategy.UNSPECIFIED)
                     return;
                 if (strategy === WebsocketReconnectStrategy.DISCONNECT) {
+                    globalThis.streamRNVideoSDK?.callingX?.endCall(this, 'error');
                     this.leave({ message: 'SFU instructed to disconnect' }).catch((err) => {
                         this.logger.warn(`Can't leave call after disconnect request`, err);
                     });
@@ -15596,7 +15657,7 @@ class StreamClient {
         this.getUserAgent = () => {
             if (!this.cachedUserAgent) {
                 const { clientAppIdentifier = {} } = this.options;
-                const { sdkName = 'js', sdkVersion = "1.42.2", ...extras } = clientAppIdentifier;
+                const { sdkName = 'js', sdkVersion = "1.43.0-beta.0", ...extras } = clientAppIdentifier;
                 this.cachedUserAgent = [
                     `stream-video-${sdkName}-v${sdkVersion}`,
                     ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),