@stream-io/video-client 1.50.0 → 1.51.0

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+## [1.51.0](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.50.0...@stream-io/video-client-1.51.0) (2026-05-26)
+
+### Features
+
+- **client:** Register virtual devices ([#2220](https://github.com/GetStream/stream-video-js/issues/2220)) ([c663e2d](https://github.com/GetStream/stream-video-js/commit/c663e2df9f82cf64c38a9d3e6a1e86282107b27d))
+
+### Bug Fixes
+
+- **client:** bail reconnects during in-flight lifecycles and clean up listeners ([#2257](https://github.com/GetStream/stream-video-js/issues/2257)) ([f6fa17e](https://github.com/GetStream/stream-video-js/commit/f6fa17e041cef1aebeba38b06d6cfba5c085e5a6))
+- **client:** stop sending RTP after track.stop() on Firefox ([#2237](https://github.com/GetStream/stream-video-js/issues/2237)) ([5b7e9b8](https://github.com/GetStream/stream-video-js/commit/5b7e9b8bd17c43f17d66586dd88617ae91bac609))
+
 ## [1.50.0](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.49.0...@stream-io/video-client-1.50.0) (2026-05-18)
 
 ### Features

package/dist/index.browser.es.js

@@ -6359,7 +6359,7 @@ const getSdkVersion = (sdk) => {
     return sdk ? `${sdk.major}.${sdk.minor}.${sdk.patch}` : '0.0.0-development';
 };
 
-const version = "1.50.0";
+const version = "1.51.0";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -7478,7 +7478,7 @@ class BasePeerConnection {
         this.on = (event, fn) => {
             const getTag = () => this.tag;
             this.subscriptions.push(this.dispatcher.on(event, getTag, (e) => {
-                const lockKey = `pc.${this.lock}.${event}`;
+                const lockKey = this.eventLockKey(event);
                 withoutConcurrency(lockKey, async () => fn(e)).catch((err) => {
                     if (this.isDisposed)
                         return;
@@ -7486,6 +7486,13 @@ class BasePeerConnection {
                 });
             }));
         };
+        /**
+         * Returns the per-event `withoutConcurrency` tag used to serialize the
+         * dispatcher handler for `event` on this peer connection.
+         */
+        this.eventLockKey = (event) => {
+            return `pc.${this.lock}.${event}`;
+        };
         /**
          * Appends the trickled ICE candidates to the `RTCPeerConnection`.
          */
@@ -7739,7 +7746,7 @@ class BasePeerConnection {
     /**
      * Disposes the `RTCPeerConnection` instance.
      */
-    dispose() {
+    async dispose() {
         clearTimeout(this.iceRestartTimeout);
         this.iceRestartTimeout = undefined;
         clearTimeout(this.preConnectStuckTimeout);
@@ -7761,6 +7768,7 @@ class BasePeerConnection {
         pc.removeEventListener('signalingstatechange', this.onSignalingChange);
         pc.removeEventListener('iceconnectionstatechange', this.onIceConnectionStateChange);
         pc.removeEventListener('icegatheringstatechange', this.onIceGatherChange);
+        pc.removeEventListener('connectionstatechange', this.onConnectionStateChange);
         this.unsubscribeIceTrickle?.();
         this.subscriptions.forEach((unsubscribe) => unsubscribe());
         this.subscriptions = [];
@@ -7788,8 +7796,14 @@ class TransceiverCache {
          * Gets the transceiver for the given publish option.
          */
         this.get = (publishOption) => {
-            return this.cache.find((bundle) => bundle.publishOption.id === publishOption.id &&
-                bundle.publishOption.trackType === publishOption.trackType);
+            return this.getBy(publishOption.id, publishOption.trackType);
+        };
+        /**
+         * Gets the transceiver for the given publish option id and track type.
+         */
+        this.getBy = (publishOptionId, trackType) => {
+            return this.cache.find((bundle) => bundle.publishOption.id === publishOptionId &&
+                bundle.publishOption.trackType === trackType);
         };
         /**
          * Updates the cached bundle with the given patch.
@@ -8074,6 +8088,21 @@ const toRTCDegradationPreference = (preference) => {
             ensureExhausted(preference, 'Unknown degradation preference');
     }
 };
+const fromRTCDegradationPreference = (preference) => {
+    switch (preference) {
+        case 'balanced':
+            return DegradationPreference.BALANCED;
+        case 'maintain-framerate':
+            return DegradationPreference.MAINTAIN_FRAMERATE;
+        case 'maintain-resolution':
+            return DegradationPreference.MAINTAIN_RESOLUTION;
+        // @ts-expect-error not in the typedefs yet
+        case 'maintain-framerate-and-resolution':
+            return DegradationPreference.MAINTAIN_FRAMERATE_AND_RESOLUTION;
+        default:
+            return DegradationPreference.UNSPECIFIED;
+    }
+};
 
 /**
  * The `Publisher` is responsible for publishing/unpublishing media streams to/from the SFU
@@ -8108,13 +8137,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) || {};
-                if (!transceiver) {
+                const bundle = this.transceiverCache.get(publishOption);
+                if (!bundle) {
                     await this.addTransceiver(trackToPublish, publishOption, options);
                 }
                 else {
-                    const previousTrack = transceiver.sender.track;
-                    await this.updateTransceiver(transceiver, trackToPublish, trackType, options);
+                    const previousTrack = bundle.transceiver.sender.track;
+                    await this.updateTransceiver(bundle, trackToPublish, options);
                     if (!isReactNative()) {
                         this.stopTrack(previousTrack);
                     }
@@ -8149,13 +8178,20 @@ class Publisher extends BasePeerConnection {
         /**
          * Updates the transceiver with the given track and track type.
          */
-        this.updateTransceiver = async (transceiver, track, trackType, options = {}) => {
+        this.updateTransceiver = async (bundle, track, options = {}) => {
+            const { transceiver, publishOption } = bundle;
+            const trackType = publishOption.trackType;
             const sender = transceiver.sender;
             if (sender.track)
                 this.trackIdToTrackType.delete(sender.track.id);
             await sender.replaceTrack(track);
-            if (track)
+            if (track) {
                 this.trackIdToTrackType.set(track.id, trackType);
+                if (isFirefox() && bundle.videoSender) {
+                    // restore the encoding config from the cache, if any
+                    await this.changePublishQuality(bundle.videoSender, bundle);
+                }
+            }
             if (isAudioTrackType(trackType)) {
                 await this.updateAudioPublishOptions(trackType, options);
             }
@@ -8215,7 +8251,7 @@ class Publisher extends BasePeerConnection {
                     continue;
                 // it is safe to stop the track here, it is a clone
                 this.stopTrack(transceiver.sender.track);
-                await this.updateTransceiver(transceiver, null, publishOption.trackType);
+                await this.updateTransceiver(item, null);
             }
         };
         /**
@@ -8272,33 +8308,38 @@ class Publisher extends BasePeerConnection {
         /**
          * Stops the cloned track that is being published to the SFU.
          */
-        this.stopTracks = (...trackTypes) => {
-            for (const item of this.transceiverCache.items()) {
-                const { publishOption, transceiver } = item;
-                if (!trackTypes.includes(publishOption.trackType))
-                    continue;
-                this.stopTrack(transceiver.sender.track);
-            }
+        this.stopTracks = async (...trackTypes) => {
+            return withoutConcurrency(this.eventLockKey('changePublishQuality'), async () => {
+                for (const item of this.transceiverCache.items()) {
+                    const { publishOption, transceiver } = item;
+                    if (!trackTypes.includes(publishOption.trackType))
+                        continue;
+                    const track = transceiver.sender.track;
+                    await this.silenceSenderOnFirefox(item);
+                    this.stopTrack(track);
+                }
+            });
         };
         /**
          * Stops all the cloned tracks that are being published to the SFU.
          */
-        this.stopAllTracks = () => {
-            for (const { transceiver } of this.transceiverCache.items()) {
-                this.stopTrack(transceiver.sender.track);
-            }
-            for (const track of this.clonedTracks) {
-                this.stopTrack(track);
-            }
+        this.stopAllTracks = async () => {
+            return withoutConcurrency(this.eventLockKey('changePublishQuality'), async () => {
+                for (const item of this.transceiverCache.items()) {
+                    const track = item.transceiver.sender.track;
+                    await this.silenceSenderOnFirefox(item);
+                    this.stopTrack(track);
+                }
+                for (const track of this.clonedTracks) {
+                    this.stopTrack(track);
+                }
+            });
         };
-        this.changePublishQuality = async (videoSender) => {
-            const { trackType, layers, publishOptionId } = videoSender;
-            const enabledLayers = layers.filter((l) => l.active);
+        this.changePublishQuality = async (videoSender, bundle) => {
+            const enabledLayers = videoSender.layers.filter((l) => l.active);
             const tag = 'Update publish quality:';
             this.logger.info(`${tag} requested layers by SFU:`, enabledLayers);
-            const transceiverId = this.transceiverCache.find((t) => t.publishOption.id === publishOptionId &&
-                t.publishOption.trackType === trackType);
-            const sender = transceiverId?.transceiver.sender;
+            const sender = bundle?.transceiver.sender;
             if (!sender) {
                 return this.logger.warn(`${tag} no video sender found.`);
             }
@@ -8306,7 +8347,7 @@ class Publisher extends BasePeerConnection {
             if (params.encodings.length === 0) {
                 return this.logger.warn(`${tag} there are no encodings set.`);
             }
-            const codecInUse = transceiverId?.publishOption.codec?.name;
+            const codecInUse = bundle?.publishOption.codec?.name;
             const usesSvcCodec = codecInUse && isSvcCodec(codecInUse);
             let changed = false;
             for (const encoder of params.encodings) {
@@ -8506,6 +8547,72 @@ class Publisher extends BasePeerConnection {
             track.stop();
             this.clonedTracks.delete(track);
         };
+        /**
+         * Silences a Firefox sender on the wire during unpublish.
+         *
+         * Firefox keeps emitting RTP after track.stop(), but the right lever
+         * differs by track type:
+         *   - audio: `replaceTrack(null)` is the only reliable silencer;
+         *     `setParameters({encodings:[...active:false]})` does NOT stop
+         *     the Opus encoder.
+         *   - video: `setParameters({encodings:[...active:false]})` pauses
+         *     the encoder; `replaceTrack(null)` does NOT reliably stop the
+         *     video encoder. The prior active=true configuration is captured
+         *     onto `bundle.videoSender` so `updateTransceiver` can restore
+         *     it on the next publish.
+         *
+         * No-op on non-Firefox browsers and during teardown.
+         */
+        this.silenceSenderOnFirefox = async (bundle) => {
+            if (this.isDisposed || !isFirefox())
+                return;
+            const { transceiver, publishOption } = bundle;
+            if (isAudioTrackType(publishOption.trackType)) {
+                await transceiver.sender.replaceTrack(null).catch((err) => {
+                    this.logger.warn('Failed to clear audio sender track', err);
+                });
+                return;
+            }
+            await this.disableAllEncodings(bundle);
+        };
+        this.disableAllEncodings = async (bundle) => {
+            const { transceiver, publishOption } = bundle;
+            const sender = transceiver.sender;
+            const params = sender.getParameters();
+            if (!params.encodings || params.encodings.length === 0)
+                return;
+            if (!bundle.videoSender) {
+                this.transceiverCache.update(publishOption, {
+                    videoSender: {
+                        trackType: publishOption.trackType,
+                        publishOptionId: publishOption.id,
+                        codec: publishOption.codec,
+                        degradationPreference: fromRTCDegradationPreference(params.degradationPreference),
+                        layers: params.encodings.map((e) => ({
+                            name: e.rid ?? 'q',
+                            active: e.active ?? true,
+                            maxBitrate: e.maxBitrate ?? 0,
+                            scaleResolutionDownBy: e.scaleResolutionDownBy ?? 0,
+                            maxFramerate: e.maxFramerate ?? 0,
+                            // @ts-expect-error scalabilityMode is not in the typedefs yet
+                            scalabilityMode: e.scalabilityMode ?? '',
+                        })),
+                    },
+                });
+            }
+            let changed = false;
+            for (const encoding of params.encodings) {
+                if (encoding.active !== false) {
+                    encoding.active = false;
+                    changed = true;
+                }
+            }
+            if (!changed)
+                return;
+            await sender.setParameters(params).catch((err) => {
+                this.logger.error('Failed to disable video sender encodings:', err);
+            });
+        };
         this.publishOptions = publishOptions;
         this.on('iceRestart', (iceRestart) => {
             if (iceRestart.peerType !== PeerType.PUBLISHER_UNSPECIFIED)
@@ -8514,7 +8621,16 @@ class Publisher extends BasePeerConnection {
         });
         this.on('changePublishQuality', async (event) => {
             for (const videoSender of event.videoSenders) {
-                await this.changePublishQuality(videoSender);
+                // if not publishing, update the encodingConfigCache and don't modify the state.
+                // we'll apply this config on the next publish/unmute.
+                const { trackType, publishOptionId } = videoSender;
+                const bundle = this.transceiverCache.getBy(publishOptionId, trackType);
+                if (bundle) {
+                    this.transceiverCache.update(bundle.publishOption, { videoSender });
+                }
+                if (isFirefox() && !this.isPublishing(trackType))
+                    continue;
+                await this.changePublishQuality(videoSender, bundle);
             }
         });
         this.on('changePublishOptions', (event) => {
@@ -8525,9 +8641,14 @@ class Publisher extends BasePeerConnection {
     /**
      * Disposes this Publisher instance.
      */
-    dispose() {
-        super.dispose();
-        this.stopAllTracks();
+    async dispose() {
+        await super.dispose();
+        try {
+            await this.stopAllTracks();
+        }
+        catch (err) {
+            this.logger.warn('Failed to stop tracks during dispose', err);
+        }
         this.clonedTracks.clear();
     }
 }
@@ -11311,8 +11432,8 @@ const normalize = (options) => {
             : false,
     };
 };
-const createSyntheticDevice = (deviceId, kind) => {
-    return { deviceId, kind, label: '', groupId: '' };
+const createSyntheticDevice = (deviceId, kind, label = '') => {
+    return { deviceId, kind, label, groupId: '' };
 };
 const readPreferences = (storageKey) => {
     try {
@@ -11366,6 +11487,8 @@ class DeviceManager {
         this.areSubscriptionsSetUp = false;
         this.isTrackStoppedDueToTrackEnd = false;
         this.filters = [];
+        this.virtualDevicesSubject = new BehaviorSubject([]);
+        this.virtualDeviceConcurrencyTag = Symbol('virtualDeviceConcurrencyTag');
         this.statusChangeConcurrencyTag = Symbol('statusChangeConcurrencyTag');
         this.filterRegistrationConcurrencyTag = Symbol('filterRegistrationConcurrencyTag');
         /**
@@ -11378,6 +11501,7 @@ class DeviceManager {
             this.subscriptions.forEach((s) => s());
             this.subscriptions = [];
             this.areSubscriptionsSetUp = false;
+            this.virtualDevicesSubject.next([]);
         };
         this.runCurrentStreamCleanups = () => {
             this.currentStreamCleanups.forEach((c) => c());
@@ -11436,7 +11560,93 @@ class DeviceManager {
      * @returns an Observable that will be updated if a device is connected or disconnected
      */
     listDevices() {
-        return this.getDevices();
+        return combineLatest([this.getDevices(), this.virtualDevicesSubject]).pipe(map(([real, virtual]) => [
+            ...real,
+            ...virtual.map((d) => createSyntheticDevice(d.deviceId, d.kind, d.label)),
+        ]));
+    }
+    /**
+     * Registers a virtual camera or microphone backed by a caller-supplied
+     * stream factory. The device appears in `listDevices()` and can be selected
+     * via `select()` like any real device.
+     *
+     * Web only. React Native is not supported.
+     *
+     * Only supported for camera and microphone managers; calling on any other
+     * manager throws.
+     */
+    registerVirtualDevice(virtualDevice) {
+        if (isReactNative()) {
+            throw new Error('Virtual devices are not supported on React Native.');
+        }
+        if (this.trackType !== TrackType.AUDIO &&
+            this.trackType !== TrackType.VIDEO) {
+            throw new Error('Virtual devices are only supported for camera and microphone.');
+        }
+        const deviceId = `stream-virtual:${generateUUIDv4()}`;
+        const entry = {
+            deviceId,
+            kind: this.mediaDeviceKind,
+            ...virtualDevice,
+        };
+        setCurrentValue(this.virtualDevicesSubject, (current) => [
+            ...current,
+            entry,
+        ]);
+        return {
+            deviceId: entry.deviceId,
+            unregister: async () => {
+                await withoutConcurrency(this.virtualDeviceConcurrencyTag, async () => {
+                    setCurrentValue(this.virtualDevicesSubject, (current) => current.filter((d) => d !== entry));
+                    if (this.activeVirtualSession?.deviceId === deviceId) {
+                        await this.stopActiveVirtualSession();
+                    }
+                });
+                if (this.state.selectedDevice === deviceId) {
+                    await this.statusChangeSettled();
+                    await this.disable({ forceStop: true });
+                    await this.select(undefined);
+                }
+            },
+        };
+    }
+    sanitizeVirtualStream(stream) {
+        stream.getTracks().forEach((track) => {
+            const originalGetSettings = track.getSettings.bind(track);
+            track.getSettings = () => {
+                const settings = originalGetSettings();
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { deviceId, ...rest } = settings;
+                return rest;
+            };
+        });
+        return stream;
+    }
+    findVirtualDevice(deviceId) {
+        if (!deviceId)
+            return undefined;
+        return getCurrentValue(this.virtualDevicesSubject).find((d) => d.deviceId === deviceId);
+    }
+    async stopActiveVirtualSession() {
+        const session = this.activeVirtualSession;
+        this.activeVirtualSession = undefined;
+        await session?.stop?.();
+    }
+    async getSelectedStream(constraints) {
+        const deviceId = this.state.selectedDevice;
+        if (!deviceId?.startsWith('stream-virtual')) {
+            return this.getStream(constraints);
+        }
+        return withoutConcurrency(this.virtualDeviceConcurrencyTag, async () => {
+            const virtualDevice = this.findVirtualDevice(deviceId);
+            if (!virtualDevice) {
+                throw new Error(`Virtual device is not registered: ${deviceId}`);
+            }
+            await this.stopActiveVirtualSession();
+            const { stream, stop } = await virtualDevice.getUserMedia(constraints);
+            this.activeVirtualSession = { deviceId, stop };
+            return this.sanitizeVirtualStream(stream);
+        });
     }
     /**
      * Returns `true` when this device is in enabled state.
@@ -11596,6 +11806,9 @@ class DeviceManager {
             }
         });
     }
+    getResolvedConstraints(constraints) {
+        return constraints;
+    }
     publishStream(stream, options) {
         return this.call.publish(stream, this.trackType, options);
     }
@@ -11616,6 +11829,7 @@ class DeviceManager {
         this.muteLocalStream(stopTracks);
         const allEnded = this.getTracks().every((t) => t.readyState === 'ended');
         if (allEnded) {
+            await this.stopActiveVirtualSession();
             // @ts-expect-error release() is present in react-native-webrtc
             if (typeof mediaStream.release === 'function') {
                 // @ts-expect-error called to dispose the stream in RN
@@ -11671,12 +11885,12 @@ class DeviceManager {
             // before chainWith below registers new ones for the new chain.
             this.runCurrentStreamCleanups();
             const defaultConstraints = this.state.defaultConstraints;
-            const constraints = {
+            const constraints = this.getResolvedConstraints({
                 ...defaultConstraints,
                 deviceId: this.state.selectedDevice
                     ? { exact: this.state.selectedDevice }
                     : undefined,
-            };
+            });
             /**
              * Chains two media streams together.
              *
@@ -11733,7 +11947,7 @@ class DeviceManager {
             };
             // the rootStream represents the stream coming from the actual device
             // e.g. camera or microphone stream
-            rootStreamPromise = this.getStream(constraints);
+            rootStreamPromise = this.getSelectedStream(constraints);
             // we publish the last MediaStream of the chain
             stream = await this.filters.reduce((parent, entry) => parent
                 .then((inputStream) => {
@@ -12050,7 +12264,10 @@ class DeviceManagerState {
         setCurrentValue(this.mediaStreamSubject, stream);
         setCurrentValue(this.rootMediaStreamSubject, rootStream);
         if (rootStream) {
-            this.setDevice(this.getDeviceIdFromStream(rootStream));
+            const derived = this.getDeviceIdFromStream(rootStream);
+            if (derived) {
+                this.setDevice(derived);
+            }
         }
     }
     /**
@@ -12263,7 +12480,7 @@ class CameraManager extends DeviceManager {
     getDevices() {
         return getVideoDevices(this.call.tracer);
     }
-    getStream(constraints) {
+    getResolvedConstraints(constraints) {
         constraints.width = this.targetResolution.width;
         constraints.height = this.targetResolution.height;
         // We can't set both device id and facing mode
@@ -12274,6 +12491,9 @@ class CameraManager extends DeviceManager {
             constraints.facingMode =
                 this.state.direction === 'front' ? 'user' : 'environment';
         }
+        return constraints;
+    }
+    getStream(constraints) {
         return getVideoStream(constraints, this.call.tracer);
     }
 }
@@ -13601,9 +13821,10 @@ class Call {
                 this.sfuStatsReporter?.flush();
                 this.sfuStatsReporter?.stop();
                 this.sfuStatsReporter = undefined;
-                this.subscriber?.dispose();
+                this.lastStatsOptions = undefined;
+                await this.subscriber?.dispose();
                 this.subscriber = undefined;
-                this.publisher?.dispose();
+                await this.publisher?.dispose();
                 this.publisher = undefined;
                 await this.sfuClient?.leaveAndClose(leaveReason);
                 this.sfuClient = undefined;
@@ -13879,15 +14100,17 @@ class Call {
             const performingMigration = this.reconnectStrategy === WebsocketReconnectStrategy.MIGRATE;
             const performingRejoin = this.reconnectStrategy === WebsocketReconnectStrategy.REJOIN;
             const performingFastReconnect = this.reconnectStrategy === WebsocketReconnectStrategy.FAST;
-            let statsOptions = this.sfuStatsReporter?.options;
+            let statsOptions = this.lastStatsOptions;
             if (!this.credentials ||
                 !statsOptions ||
                 performingRejoin ||
-                performingMigration) {
+                performingMigration ||
+                data?.migrating_from) {
                 try {
                     const joinResponse = await this.doJoinRequest(data);
                     this.credentials = joinResponse.credentials;
                     statsOptions = joinResponse.stats_options;
+                    this.lastStatsOptions = statsOptions;
                 }
                 catch (error) {
                     // prevent triggering reconnect flow if the state is OFFLINE
@@ -13994,7 +14217,7 @@ class Call {
             }
             else {
                 const connectionConfig = toRtcConfiguration(this.credentials.ice_servers);
-                this.initPublisherAndSubscriber({
+                await this.initPublisherAndSubscriber({
                     sfuClient,
                     connectionConfig,
                     clientDetails,
@@ -14139,11 +14362,11 @@ class Call {
          * Initializes the Publisher and Subscriber Peer Connections.
          * @internal
          */
-        this.initPublisherAndSubscriber = (opts) => {
+        this.initPublisherAndSubscriber = async (opts) => {
             const { sfuClient, connectionConfig, clientDetails, statsOptions, publishOptions, closePreviousInstances, unifiedSessionId, } = opts;
             const { enable_rtc_stats: enableTracing } = statsOptions;
             if (closePreviousInstances && this.subscriber) {
-                this.subscriber.dispose();
+                await this.subscriber.dispose();
             }
             const basePeerConnectionOptions = {
                 sfuClient,
@@ -14172,7 +14395,7 @@ class Call {
             const isAnonymous = this.streamClient.user?.type === 'anonymous';
             if (!isAnonymous) {
                 if (closePreviousInstances && this.publisher) {
-                    this.publisher.dispose();
+                    await this.publisher.dispose();
                 }
                 this.publisher = new Publisher(basePeerConnectionOptions, publishOptions);
             }
@@ -14275,10 +14498,17 @@ class Call {
          *   `ICE_NEVER_CONNECTED` increments the unsupported-network counter).
          */
         this.reconnect = async (strategy, reason) => {
-            if (this.state.callingState === CallingState.RECONNECTING ||
+            if (this.state.callingState === CallingState.JOINING ||
+                this.state.callingState === CallingState.RECONNECTING ||
                 this.state.callingState === CallingState.MIGRATING ||
                 this.state.callingState === CallingState.RECONNECTING_FAILED)
                 return;
+            // Drop redundant reconnect calls. If a reconnect is already queued or
+            // running for this Call, that entry will resolve whatever broke;
+            // queueing more entries just replays the full REJOIN cycle (one extra
+            // `POST /join` per entry) once the call is already healthy again.
+            if (hasPending(this.reconnectConcurrencyTag))
+                return;
             return withoutConcurrency(this.reconnectConcurrencyTag, async () => {
                 const reconnectStartTime = Date.now();
                 this.reconnectStrategy = strategy;
@@ -14483,8 +14713,8 @@ class Call {
                 this.state.setCallingState(CallingState.JOINED);
             }
             finally {
-                currentSubscriber?.dispose();
-                currentPublisher?.dispose();
+                await currentSubscriber?.dispose();
+                await currentPublisher?.dispose();
                 // and close the previous SFU client, without specifying close code
                 currentSfuClient.close(StreamSfuClient.NORMAL_CLOSURE, 'Migrating away');
             }
@@ -14673,7 +14903,7 @@ class Call {
         this.stopPublish = async (...trackTypes) => {
             if (!this.sfuClient || !this.publisher)
                 return;
-            this.publisher.stopTracks(...trackTypes);
+            await this.publisher.stopTracks(...trackTypes);
             await this.updateLocalStreamState(undefined, ...trackTypes);
         };
         /**
@@ -16788,7 +17018,7 @@ class StreamClient {
         this.getUserAgent = () => {
             if (!this.cachedUserAgent) {
                 const { clientAppIdentifier = {} } = this.options;
-                const { sdkName = 'js', sdkVersion = "1.50.0", ...extras } = clientAppIdentifier;
+                const { sdkName = 'js', sdkVersion = "1.51.0", ...extras } = clientAppIdentifier;
                 this.cachedUserAgent = [
                     `stream-video-${sdkName}-v${sdkVersion}`,
                     ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),