@stream-io/video-client 1.42.1 → 1.42.3

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 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
+
+- improve the handling of join errors and prevent cross-socket event leaking ([#2121](https://github.com/GetStream/stream-video-js/issues/2121)) ([72d0834](https://github.com/GetStream/stream-video-js/commit/72d08343243990f14f29103734eea6f7cb6092c9))
+
 ## [1.42.1](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.42.0...@stream-io/video-client-1.42.1) (2026-02-10)
 
 ### Bug Fixes

package/dist/index.browser.es.js

@@ -4271,6 +4271,12 @@ const sfuEventKinds = {
     changePublishOptions: undefined,
     inboundStateNotification: undefined,
 };
+/**
+ * Determines if a given event name belongs to the category of SFU events.
+ *
+ * @param eventName the name of the event to check.
+ * @returns true if the event name is an SFU event, otherwise false.
+ */
 const isSfuEvent = (eventName) => {
     return Object.prototype.hasOwnProperty.call(sfuEventKinds, eventName);
 };
@@ -4278,33 +4284,70 @@ class Dispatcher {
     constructor() {
         this.logger = videoLoggerSystem.getLogger('Dispatcher');
         this.subscribers = {};
-        this.dispatch = (message, tag = '0') => {
+        /**
+         * Dispatch an event to all subscribers.
+         *
+         * @param message the event payload to dispatch.
+         * @param tag for scoping events to a specific tag. Use `*` dispatch to every tag.
+         */
+        this.dispatch = (message, tag = '*') => {
             const eventKind = message.eventPayload.oneofKind;
             if (!eventKind)
                 return;
             const payload = message.eventPayload[eventKind];
             this.logger.debug(`Dispatching ${eventKind}, tag=${tag}`, payload);
-            const listeners = this.subscribers[eventKind];
-            if (!listeners)
+            const handlers = this.subscribers[eventKind];
+            if (!handlers)
                 return;
-            for (const fn of listeners) {
+            this.emit(payload, handlers[tag]);
+            if (tag !== '*')
+                this.emit(payload, handlers['*']);
+        };
+        /**
+         * Emit an event to a list of listeners.
+         *
+         * @param payload the event payload to emit.
+         * @param listeners the list of listeners to emit the event to.
+         */
+        this.emit = (payload, listeners = []) => {
+            for (const listener of listeners) {
                 try {
-                    fn(payload);
+                    listener(payload);
                 }
                 catch (e) {
                     this.logger.warn('Listener failed with error', e);
                 }
             }
         };
-        this.on = (eventName, fn) => {
+        /**
+         * Subscribe to an event.
+         *
+         * @param eventName the name of the event to subscribe to.
+         * @param tag for scoping events to a specific tag. Use `*` dispatch to every tag.
+         * @param fn the callback function to invoke when the event is emitted.
+         * @returns a function that can be called to unsubscribe from the event.
+         */
+        this.on = (eventName, tag, fn) => {
             var _a;
-            ((_a = this.subscribers)[eventName] ?? (_a[eventName] = [])).push(fn);
+            const bucket = ((_a = this.subscribers)[eventName] ?? (_a[eventName] = {}));
+            (bucket[tag] ?? (bucket[tag] = [])).push(fn);
             return () => {
-                this.off(eventName, fn);
+                this.off(eventName, tag, fn);
             };
         };
-        this.off = (eventName, fn) => {
-            this.subscribers[eventName] = (this.subscribers[eventName] || []).filter((f) => f !== fn);
+        /**
+         * Unsubscribe from an event.
+         *
+         * @param eventName the name of the event to unsubscribe from.
+         * @param tag for scoping events to a specific tag. Use `*` dispatch to every tag.
+         * @param fn the callback function to remove from the event listeners.
+         */
+        this.off = (eventName, tag, fn) => {
+            const bucket = this.subscribers[eventName];
+            const listeners = bucket?.[tag];
+            if (!listeners)
+                return;
+            bucket[tag] = listeners.filter((f) => f !== fn);
         };
     }
 }
@@ -6188,7 +6231,7 @@ const getSdkVersion = (sdk) => {
     return sdk ? `${sdk.major}.${sdk.minor}.${sdk.patch}` : '0.0.0-development';
 };
 
-const version = "1.42.1";
+const version = "1.42.3";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -7255,7 +7298,7 @@ class BasePeerConnection {
          * Consecutive events are queued and executed one after the other.
          */
         this.on = (event, fn) => {
-            this.subscriptions.push(this.dispatcher.on(event, (e) => {
+            this.subscriptions.push(this.dispatcher.on(event, this.tag, (e) => {
                 const lockKey = `pc.${this.lock}.${event}`;
                 withoutConcurrency(lockKey, async () => fn(e)).catch((err) => {
                     if (this.isDisposed)
@@ -7440,6 +7483,7 @@ class BasePeerConnection {
         this.dispatcher = dispatcher;
         this.iceRestartDelay = iceRestartDelay;
         this.clientPublishOptions = clientPublishOptions;
+        this.tag = tag;
         this.onReconnectionNeeded = onReconnectionNeeded;
         this.logger = videoLoggerSystem.getLogger(peerType === PeerType.SUBSCRIBER ? 'Subscriber' : 'Publisher', { tags: [tag] });
         this.pc = this.createPeerConnection(connectionConfig);
@@ -8442,6 +8486,21 @@ const getTimers = lazy(() => {
     return new WorkerTimer({ useWorker: timerWorkerEnabled });
 });
 
+class SfuJoinError extends Error {
+    constructor(event) {
+        super(event.error?.message || 'Join Error');
+        this.errorEvent = event;
+        this.unrecoverable =
+            event.reconnectStrategy === WebsocketReconnectStrategy.DISCONNECT;
+    }
+    static isJoinErrorCode(event) {
+        const code = event.error?.code;
+        return (code === ErrorCode.SFU_FULL ||
+            code === ErrorCode.SFU_SHUTTING_DOWN ||
+            code === ErrorCode.CALL_PARTICIPANT_LIMIT_REACHED);
+    }
+}
+
 /**
  * The client used for exchanging information with the SFU.
  */
@@ -8618,7 +8677,7 @@ class StreamSfuClient {
             const { timeout = 7 * 1000 } = opts;
             this.migrationTask?.reject(new Error('Cancelled previous migration'));
             const task = (this.migrationTask = promiseWithResolvers());
-            const unsubscribe = this.dispatcher.on('participantMigrationComplete', () => {
+            const unsubscribe = this.dispatcher.on('participantMigrationComplete', this.tag, () => {
                 unsubscribe();
                 clearTimeout(this.migrateAwayTimeout);
                 task.resolve();
@@ -8644,27 +8703,29 @@ class StreamSfuClient {
             // be replaced with a new one in case a second join request is made
             const current = this.joinResponseTask;
             let timeoutId = undefined;
-            const unsubscribeJoinErrorEvents = this.dispatcher.on('error', (event) => {
-                const { error, reconnectStrategy } = event;
-                if (!error)
-                    return;
-                if (reconnectStrategy === WebsocketReconnectStrategy.DISCONNECT) {
-                    clearTimeout(timeoutId);
-                    unsubscribe?.();
-                    unsubscribeJoinErrorEvents();
+            let unsubscribeJoinResponse = undefined;
+            let unsubscribeJoinErrorEvents = undefined;
+            const cleanupJoinSubscriptions = () => {
+                clearTimeout(timeoutId);
+                timeoutId = undefined;
+                unsubscribeJoinErrorEvents?.();
+                unsubscribeJoinErrorEvents = undefined;
+                unsubscribeJoinResponse?.();
+                unsubscribeJoinResponse = undefined;
+            };
+            unsubscribeJoinErrorEvents = this.dispatcher.on('error', this.tag, (event) => {
+                if (SfuJoinError.isJoinErrorCode(event)) {
+                    cleanupJoinSubscriptions();
                     current.reject(new SfuJoinError(event));
                 }
             });
-            const unsubscribe = this.dispatcher.on('joinResponse', (joinResponse) => {
-                clearTimeout(timeoutId);
-                unsubscribe();
-                unsubscribeJoinErrorEvents();
+            unsubscribeJoinResponse = this.dispatcher.on('joinResponse', this.tag, (joinResponse) => {
+                cleanupJoinSubscriptions();
                 this.keepAlive();
                 current.resolve(joinResponse);
             });
             timeoutId = setTimeout(() => {
-                unsubscribe();
-                unsubscribeJoinErrorEvents();
+                cleanupJoinSubscriptions();
                 const message = `Waiting for "joinResponse" has timed out after ${this.joinResponseTimeout}ms`;
                 this.tracer?.trace('joinRequestTimeout', message);
                 current.reject(new Error(message));
@@ -8759,8 +8820,8 @@ class StreamSfuClient {
         // In that case, those events (ICE candidates) need to be buffered
         // and later added to the appropriate PeerConnection
         // once the remoteDescription is known and set.
-        this.unsubscribeIceTrickle = dispatcher.on('iceTrickle', (iceTrickle) => {
-            this.iceTrickleBuffer.push(iceTrickle);
+        this.unsubscribeIceTrickle = dispatcher.on('iceTrickle', tag, (t) => {
+            this.iceTrickleBuffer.push(t);
         });
         // listen to network changes to handle offline state
         // we shouldn't attempt to recover websocket connection when offline
@@ -8809,14 +8870,6 @@ StreamSfuClient.DISPOSE_OLD_SOCKET = 4100;
  * The close code used when the client fails to join the call (on the SFU).
  */
 StreamSfuClient.JOIN_FAILED = 4101;
-class SfuJoinError extends Error {
-    constructor(event) {
-        super(event.error?.message || 'Join Error');
-        this.errorEvent = event;
-        this.unrecoverable =
-            event.reconnectStrategy === WebsocketReconnectStrategy.DISCONNECT;
-    }
-}
 
 /**
  * Event handler that watched the delivery of `call.accepted`.
@@ -8965,7 +9018,7 @@ const removeFromIfPresent = (arr, ...values) => {
 };
 
 const watchConnectionQualityChanged = (dispatcher, state) => {
-    return dispatcher.on('connectionQualityChanged', (e) => {
+    return dispatcher.on('connectionQualityChanged', '*', (e) => {
         const { connectionQualityUpdates } = e;
         if (!connectionQualityUpdates)
             return;
@@ -8983,7 +9036,7 @@ const watchConnectionQualityChanged = (dispatcher, state) => {
  * health check events that our SFU sends.
  */
 const watchParticipantCountChanged = (dispatcher, state) => {
-    return dispatcher.on('healthCheckResponse', (e) => {
+    return dispatcher.on('healthCheckResponse', '*', (e) => {
         const { participantCount } = e;
         if (participantCount) {
             state.setParticipantCount(participantCount.total);
@@ -8992,7 +9045,7 @@ const watchParticipantCountChanged = (dispatcher, state) => {
     });
 };
 const watchLiveEnded = (dispatcher, call) => {
-    return dispatcher.on('error', (e) => {
+    return dispatcher.on('error', '*', (e) => {
         if (e.error && e.error.code !== ErrorCode.LIVE_ENDED)
             return;
         call.state.setBackstage(true);
@@ -9007,7 +9060,7 @@ const watchLiveEnded = (dispatcher, call) => {
  * Watches and logs the errors reported by the currently connected SFU.
  */
 const watchSfuErrorReports = (dispatcher) => {
-    return dispatcher.on('error', (e) => {
+    return dispatcher.on('error', '*', (e) => {
         if (!e.error)
             return;
         const logger = videoLoggerSystem.getLogger('SfuClient');
@@ -9206,7 +9259,7 @@ const reconcileOrphanedTracks = (state, participant) => {
  * Watches for `dominantSpeakerChanged` events.
  */
 const watchDominantSpeakerChanged = (dispatcher, state) => {
-    return dispatcher.on('dominantSpeakerChanged', (e) => {
+    return dispatcher.on('dominantSpeakerChanged', '*', (e) => {
         const { sessionId } = e;
         if (sessionId === state.dominantSpeaker?.sessionId)
             return;
@@ -9233,7 +9286,7 @@ const watchDominantSpeakerChanged = (dispatcher, state) => {
  * Watches for `audioLevelChanged` events.
  */
 const watchAudioLevelChanged = (dispatcher, state) => {
-    return dispatcher.on('audioLevelChanged', (e) => {
+    return dispatcher.on('audioLevelChanged', '*', (e) => {
         const { audioLevels } = e;
         state.updateParticipants(audioLevels.reduce((patches, current) => {
             patches[current.sessionId] = {
@@ -12393,6 +12446,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.
@@ -12589,7 +12643,7 @@ class Call {
          */
         this.on = (eventName, fn) => {
             if (isSfuEvent(eventName)) {
-                return this.dispatcher.on(eventName, fn);
+                return this.dispatcher.on(eventName, '*', fn);
             }
             const offHandler = this.streamClient.on(eventName, (e) => {
                 const event = e;
@@ -12611,7 +12665,7 @@ class Call {
          */
         this.off = (eventName, fn) => {
             if (isSfuEvent(eventName)) {
-                return this.dispatcher.off(eventName, fn);
+                return this.dispatcher.off(eventName, '*', fn);
             }
             // unsubscribe from the stream client event by using the 'off' reference
             const registeredOffHandler = this.streamClientEventHandlers.get(fn);
@@ -12807,8 +12861,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.
@@ -12820,8 +12876,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.
@@ -12847,6 +12905,7 @@ class Call {
                     this.logger.trace(`Joining call (${attempt})`, this.cid);
                     await this.doJoin(data);
                     delete joinData.migrating_from;
+                    delete joinData.migrating_from_list;
                     break;
                 }
                 catch (err) {
@@ -12858,11 +12917,15 @@ class Call {
                         // 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 (failures >= 2) {
+                    if (switchSfu || failures >= 2) {
                         joinData.migrating_from = sfuId;
+                        joinData.migrating_from_list = Array.from(sfuJoinFailures.keys());
                     }
                     if (attempt === maxJoinRetries - 1) {
                         throw err;
@@ -13390,12 +13453,17 @@ class Call {
             const migrationTask = makeSafePromise(currentSfuClient.enterMigration());
             try {
                 const currentSfu = currentSfuClient.edgeName;
-                await this.doJoin({ ...this.joinCallData, migrating_from: currentSfu });
+                await this.doJoin({
+                    ...this.joinCallData,
+                    migrating_from: currentSfu,
+                    migrating_from_list: [currentSfu],
+                });
             }
             finally {
                 // cleanup the migration_from field after the migration is complete or failed
                 // as we don't want to keep dirty data in the join call data
                 delete this.joinCallData?.migrating_from;
+                delete this.joinCallData?.migrating_from_list;
             }
             await this.restorePublishedTracks();
             this.restoreSubscribedTracks();
@@ -13430,6 +13498,11 @@ class Call {
             // handles the "error" event, through which the SFU can request a reconnect
             const unregisterOnError = this.on('error', (e) => {
                 const { reconnectStrategy: strategy, error } = e;
+                // SFU_FULL is a join error, and when emitted, although it specifies a
+                // `migrate` strategy, we should actually perform a REJOIN to a new SFU.
+                // This is now handled separately in the `call.join()` method.
+                if (SfuJoinError.isJoinErrorCode(e))
+                    return;
                 if (strategy === WebsocketReconnectStrategy.UNSPECIFIED)
                     return;
                 if (strategy === WebsocketReconnectStrategy.DISCONNECT) {
@@ -15528,7 +15601,7 @@ class StreamClient {
         this.getUserAgent = () => {
             if (!this.cachedUserAgent) {
                 const { clientAppIdentifier = {} } = this.options;
-                const { sdkName = 'js', sdkVersion = "1.42.1", ...extras } = clientAppIdentifier;
+                const { sdkName = 'js', sdkVersion = "1.42.3", ...extras } = clientAppIdentifier;
                 this.cachedUserAgent = [
                     `stream-video-${sdkName}-v${sdkVersion}`,
                     ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),