@stream-io/video-client 1.42.2 → 1.43.0

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+## [1.43.0](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.42.3...@stream-io/video-client-1.43.0) (2026-02-20)
+
+- **client:** trace updatePublishOptions overrides ([#2136](https://github.com/GetStream/stream-video-js/issues/2136)) ([bcc1e92](https://github.com/GetStream/stream-video-js/commit/bcc1e92ac89374324a57d1df85be38a2661a4c53))
+
+### Features
+
+- **client:** add list recording APIs and deprecate query methods ([#2135](https://github.com/GetStream/stream-video-js/issues/2135)) ([5331cb5](https://github.com/GetStream/stream-video-js/commit/5331cb5205466dc052c729fb07d84209208af362))
+
+### Bug Fixes
+
+- **client:** harden flat-line no-audio detection ([#2131](https://github.com/GetStream/stream-video-js/issues/2131)) ([9c2aa22](https://github.com/GetStream/stream-video-js/commit/9c2aa222b189c5e24510430dfddbf164555abf1c))
+- **client:** prevent stale speaking-while-muted detector ([#2130](https://github.com/GetStream/stream-video-js/issues/2130)) ([e5c408d](https://github.com/GetStream/stream-video-js/commit/e5c408d73de1b8f20e775642b0b19eb0ffd979a8))
+
+## [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";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -11480,12 +11480,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 +11508,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 +11551,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 +12034,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 +12057,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) {
@@ -12446,6 +12466,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.
@@ -12860,8 +12881,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 +12896,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.
@@ -13701,6 +13726,7 @@ class Call {
             if (this.state.callingState === CallingState.JOINED) {
                 this.logger.warn('Updating publish options after joining the call does not have an effect');
             }
+            this.tracer.trace('updatePublishOptions', options);
             this.clientPublishOptions = { ...this.clientPublishOptions, ...options };
         };
         /**
@@ -14126,6 +14152,15 @@ class Call {
                 type: this.type,
             });
         };
+        /**
+         * Query call participants with optional filters.
+         *
+         * @param data the request data.
+         * @param params optional query parameters.
+         */
+        this.queryParticipants = async (data = {}, params = {}) => {
+            return this.streamClient.post(`${this.streamClientBasePath}/participants`, data, params);
+        };
         /**
          * Will update the call members.
          *
@@ -14180,20 +14215,59 @@ class Call {
          * Otherwise, all recordings for the current call will be returned.
          *
          * @param callSessionId the call session id to retrieve recordings for.
+         * @deprecated use {@link listRecordings} instead.
          */
         this.queryRecordings = async (callSessionId) => {
+            return this.listRecordings(callSessionId);
+        };
+        /**
+         * Retrieves the list of recordings for the current call or call session.
+         *
+         * If `callSessionId` is provided, it will return the recordings for that call session.
+         * Otherwise, all recordings for the current call will be returned.
+         *
+         * @param callSessionId the call session id to retrieve recordings for.
+         */
+        this.listRecordings = async (callSessionId) => {
             let endpoint = this.streamClientBasePath;
             if (callSessionId) {
                 endpoint = `${endpoint}/${callSessionId}`;
             }
             return this.streamClient.get(`${endpoint}/recordings`);
         };
+        /**
+         * Deletes a recording for the given call session.
+         *
+         * @param callSessionId the call session id that the recording belongs to.
+         * @param filename the recording filename.
+         */
+        this.deleteRecording = async (callSessionId, filename) => {
+            return this.streamClient.delete(`${this.streamClientBasePath}/${encodeURIComponent(callSessionId)}/recordings/${encodeURIComponent(filename)}`);
+        };
+        /**
+         * Deletes a transcription for the given call session.
+         *
+         * @param callSessionId the call session id that the transcription belongs to.
+         * @param filename the transcription filename.
+         */
+        this.deleteTranscription = async (callSessionId, filename) => {
+            return this.streamClient.delete(`${this.streamClientBasePath}/${encodeURIComponent(callSessionId)}/transcriptions/${encodeURIComponent(filename)}`);
+        };
         /**
          * Retrieves the list of transcriptions for the current call.
          *
          * @returns the list of transcriptions.
+         * @deprecated use {@link listTranscriptions} instead.
          */
         this.queryTranscriptions = async () => {
+            return this.listTranscriptions();
+        };
+        /**
+         * Retrieves the list of transcriptions for the current call.
+         *
+         * @returns the list of transcriptions.
+         */
+        this.listTranscriptions = async () => {
             return this.streamClient.get(`${this.streamClientBasePath}/transcriptions`);
         };
         /**
@@ -15596,7 +15670,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", ...extras } = clientAppIdentifier;
                 this.cachedUserAgent = [
                     `stream-video-${sdkName}-v${sdkVersion}`,
                     ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),