@stream-io/video-client 1.6.0-rc.0 → 1.6.0-rc2.0

package/dist/index.browser.es.js

@@ -7313,6 +7313,169 @@ var rxUtils = /*#__PURE__*/Object.freeze({
     setCurrentValue: setCurrentValue
 });
 
+/**
+ * Represents the state of the current call.
+ */
+var CallingState;
+(function (CallingState) {
+    /**
+     * The call is in an unknown state.
+     */
+    CallingState["UNKNOWN"] = "unknown";
+    /**
+     * The call is in an idle state.
+     */
+    CallingState["IDLE"] = "idle";
+    /**
+     * The call is in the process of ringing.
+     * (User hasn't accepted nor rejected the call yet.)
+     */
+    CallingState["RINGING"] = "ringing";
+    /**
+     * The call is in the process of joining.
+     */
+    CallingState["JOINING"] = "joining";
+    /**
+     * The call is currently active.
+     */
+    CallingState["JOINED"] = "joined";
+    /**
+     * The call has been left.
+     */
+    CallingState["LEFT"] = "left";
+    /**
+     * The call is in the process of reconnecting.
+     */
+    CallingState["RECONNECTING"] = "reconnecting";
+    /**
+     * The call is in the process of migrating from one node to another.
+     */
+    CallingState["MIGRATING"] = "migrating";
+    /**
+     * The call has failed to reconnect.
+     */
+    CallingState["RECONNECTING_FAILED"] = "reconnecting-failed";
+    /**
+     * The call is in offline mode.
+     */
+    CallingState["OFFLINE"] = "offline";
+})(CallingState || (CallingState = {}));
+
+class StreamVideoWriteableStateStore {
+    constructor() {
+        /**
+         * A store keeping data of a successfully connected user over WS to the coordinator server.
+         */
+        this.connectedUserSubject = new BehaviorSubject(undefined);
+        /**
+         * A list of {@link Call} objects created/tracked by this client.
+         */
+        this.callsSubject = new BehaviorSubject([]);
+        /**
+         * Sets the currently connected user.
+         *
+         * @internal
+         * @param user the user to set as connected.
+         */
+        this.setConnectedUser = (user) => {
+            return setCurrentValue(this.connectedUserSubject, user);
+        };
+        /**
+         * Sets the list of {@link Call} objects created/tracked by this client.
+         * @param calls
+         */
+        this.setCalls = (calls) => {
+            return setCurrentValue(this.callsSubject, calls);
+        };
+        /**
+         * Adds a {@link Call} object to the list of {@link Call} objects created/tracked by this client.
+         *
+         * @param call the call to add.
+         */
+        this.registerCall = (call) => {
+            if (!this.calls.find((c) => c.cid === call.cid)) {
+                this.setCalls((calls) => [...calls, call]);
+            }
+        };
+        /**
+         * Removes a {@link Call} object from the list of {@link Call} objects created/tracked by this client.
+         *
+         * @param call the call to remove
+         */
+        this.unregisterCall = (call) => {
+            return this.setCalls((calls) => calls.filter((c) => c !== call));
+        };
+        /**
+         * Finds a {@link Call} object in the list of {@link Call} objects created/tracked by this client.
+         *
+         * @param type the type of call to find.
+         * @param id the id of the call to find.
+         */
+        this.findCall = (type, id) => {
+            return this.calls.find((c) => c.type === type && c.id === id);
+        };
+        this.connectedUserSubject.subscribe(async (user) => {
+            // leave all calls when the user disconnects.
+            if (!user) {
+                const logger = getLogger(['client-state']);
+                for (const call of this.calls) {
+                    if (call.state.callingState === CallingState.LEFT)
+                        continue;
+                    logger('info', `User disconnected, leaving call: ${call.cid}`);
+                    await call
+                        .leave({ reason: 'client.disconnectUser() called' })
+                        .catch((err) => {
+                        logger('error', `Error leaving call: ${call.cid}`, err);
+                    });
+                }
+            }
+        });
+    }
+    /**
+     * The currently connected user.
+     */
+    get connectedUser() {
+        return getCurrentValue(this.connectedUserSubject);
+    }
+    /**
+     * A list of {@link Call} objects created/tracked by this client.
+     */
+    get calls() {
+        return getCurrentValue(this.callsSubject);
+    }
+}
+/**
+ * A reactive store that exposes state variables in a reactive manner.
+ * You can subscribe to changes of the different state variables.
+ * This central store contains all the state variables related to [`StreamVideoClient`](./StreamVideClient.md) and [`Call`](./Call.md).
+ */
+class StreamVideoReadOnlyStateStore {
+    constructor(store) {
+        /**
+         * This method allows you the get the current value of a state variable.
+         *
+         * @param observable the observable to get the current value of.
+         * @returns the current value of the observable.
+         */
+        this.getCurrentValue = getCurrentValue;
+        // convert and expose subjects as observables
+        this.connectedUser$ = store.connectedUserSubject.asObservable();
+        this.calls$ = store.callsSubject.asObservable();
+    }
+    /**
+     * The current user connected over WS to the backend.
+     */
+    get connectedUser() {
+        return getCurrentValue(this.connectedUser$);
+    }
+    /**
+     * A list of {@link Call} objects created/tracked by this client.
+     */
+    get calls() {
+        return getCurrentValue(this.calls$);
+    }
+}
+
 /**
  * Creates a new combined {@link Comparator<T>} which sorts items by the given comparators.
  * The comparators are applied in the order they are given (left -> right).
@@ -7562,53 +7725,6 @@ const paginatedLayoutSortPreset = combineComparators(pinned, ifInvisibleOrUnknow
  */
 const livestreamOrAudioRoomSortPreset = combineComparators(ifInvisibleBy(combineComparators(dominantSpeaker, speaking, reactionType('raised-hand'), publishingVideo, publishingAudio)), role('admin', 'host', 'speaker'));
 
-/**
- * Represents the state of the current call.
- */
-var CallingState;
-(function (CallingState) {
-    /**
-     * The call is in an unknown state.
-     */
-    CallingState["UNKNOWN"] = "unknown";
-    /**
-     * The call is in an idle state.
-     */
-    CallingState["IDLE"] = "idle";
-    /**
-     * The call is in the process of ringing.
-     * (User hasn't accepted nor rejected the call yet.)
-     */
-    CallingState["RINGING"] = "ringing";
-    /**
-     * The call is in the process of joining.
-     */
-    CallingState["JOINING"] = "joining";
-    /**
-     * The call is currently active.
-     */
-    CallingState["JOINED"] = "joined";
-    /**
-     * The call has been left.
-     */
-    CallingState["LEFT"] = "left";
-    /**
-     * The call is in the process of reconnecting.
-     */
-    CallingState["RECONNECTING"] = "reconnecting";
-    /**
-     * The call is in the process of migrating from one node to another.
-     */
-    CallingState["MIGRATING"] = "migrating";
-    /**
-     * The call has failed to reconnect.
-     */
-    CallingState["RECONNECTING_FAILED"] = "reconnecting-failed";
-    /**
-     * The call is in offline mode.
-     */
-    CallingState["OFFLINE"] = "offline";
-})(CallingState || (CallingState = {}));
 /**
  * Returns the default egress object - when no egress data is available.
  */
@@ -7958,7 +8074,8 @@ class CallState {
             this.setCurrentValue(this.egressSubject, call.egress);
             this.setCurrentValue(this.ingressSubject, call.ingress);
             this.setCurrentValue(this.recordingSubject, call.recording);
-            this.setCurrentValue(this.sessionSubject, call.session);
+            const s = this.setCurrentValue(this.sessionSubject, call.session);
+            this.updateParticipantCountFromSession(s);
             this.setCurrentValue(this.settingsSubject, call.settings);
             this.setCurrentValue(this.transcribingSubject, call.transcribing);
             this.setCurrentValue(this.thumbnailsSubject, call.thumbnails);
@@ -8033,12 +8150,32 @@ class CallState {
                 },
             }));
         };
+        this.updateParticipantCountFromSession = (session) => {
+            // when in JOINED state, we should use the participant count coming through
+            // the SFU healthcheck event, as it's more accurate.
+            if (!session || this.callingState === CallingState.JOINED)
+                return;
+            const byRoleCount = Object.values(session.participants_count_by_role).reduce((total, countByRole) => total + countByRole, 0);
+            const participantCount = Math.max(byRoleCount, session.participants.length);
+            this.setParticipantCount(participantCount);
+            this.setAnonymousParticipantCount(session.anonymous_participant_count || 0);
+        };
+        this.updateFromSessionParticipantCountUpdate = (event) => {
+            const s = this.setCurrentValue(this.sessionSubject, (session) => {
+                if (!session)
+                    return session;
+                return {
+                    ...session,
+                    anonymous_participant_count: event.anonymous_participant_count,
+                    participants_count_by_role: event.participants_count_by_role,
+                };
+            });
+            this.updateParticipantCountFromSession(s);
+        };
         this.updateFromSessionParticipantLeft = (event) => {
-            this.setCurrentValue(this.sessionSubject, (session) => {
-                if (!session) {
-                    this.logger('warn', `Received call.session_participant_left event but no session is available.`, event);
+            const s = this.setCurrentValue(this.sessionSubject, (session) => {
+                if (!session)
                     return session;
-                }
                 const { participants, participants_count_by_role } = session;
                 const { user, user_session_id } = event.participant;
                 return {
@@ -8050,13 +8187,12 @@ class CallState {
                     },
                 };
             });
+            this.updateParticipantCountFromSession(s);
         };
         this.updateFromSessionParticipantJoined = (event) => {
-            this.setCurrentValue(this.sessionSubject, (session) => {
-                if (!session) {
-                    this.logger('warn', `Received call.session_participant_joined event but no session is available.`, event);
+            const s = this.setCurrentValue(this.sessionSubject, (session) => {
+                if (!session)
                     return session;
-                }
                 const { participants, participants_count_by_role } = session;
                 const { user, user_session_id } = event.participant;
                 // It could happen that the backend delivers the same participant more than once.
@@ -8087,6 +8223,7 @@ class CallState {
                     },
                 };
             });
+            this.updateParticipantCountFromSession(s);
         };
         this.updateMembers = (event) => {
             this.updateFromCallResponse(event.call);
@@ -8236,6 +8373,7 @@ class CallState {
             'call.ring': (e) => this.updateFromCallResponse(e.call),
             'call.missed': (e) => this.updateFromCallResponse(e.call),
             'call.session_ended': (e) => this.updateFromCallResponse(e.call),
+            'call.session_participant_count_updated': this.updateFromSessionParticipantCountUpdate,
             'call.session_participant_joined': this.updateFromSessionParticipantJoined,
             'call.session_participant_left': this.updateFromSessionParticipantLeft,
             'call.session_started': (e) => this.updateFromCallResponse(e.call),
@@ -8431,138 +8569,6 @@ class CallState {
     }
 }
 
-class StreamVideoWriteableStateStore {
-    constructor() {
-        /**
-         * A store keeping data of a successfully connected user over WS to the coordinator server.
-         */
-        this.connectedUserSubject = new BehaviorSubject(undefined);
-        /**
-         * A list of {@link Call} objects created/tracked by this client.
-         */
-        this.callsSubject = new BehaviorSubject([]);
-        /**
-         * Gets the current value of an observable, or undefined if the observable has
-         * not emitted a value yet.
-         *
-         * @param observable$ the observable to get the value from.
-         */
-        this.getCurrentValue = getCurrentValue;
-        /**
-         * Updates the value of the provided Subject.
-         * An `update` can either be a new value or a function which takes
-         * the current value and returns a new value.
-         *
-         * @param subject the subject to update.
-         * @param update the update to apply to the subject.
-         * @return the updated value.
-         */
-        this.setCurrentValue = setCurrentValue;
-        /**
-         * Sets the currently connected user.
-         *
-         * @internal
-         * @param user the user to set as connected.
-         */
-        this.setConnectedUser = (user) => {
-            return this.setCurrentValue(this.connectedUserSubject, user);
-        };
-        /**
-         * Sets the list of {@link Call} objects created/tracked by this client.
-         * @param calls
-         */
-        this.setCalls = (calls) => {
-            return this.setCurrentValue(this.callsSubject, calls);
-        };
-        /**
-         * Adds a {@link Call} object to the list of {@link Call} objects created/tracked by this client.
-         *
-         * @param call the call to add.
-         */
-        this.registerCall = (call) => {
-            if (!this.calls.find((c) => c.cid === call.cid)) {
-                this.setCalls((calls) => [...calls, call]);
-            }
-        };
-        /**
-         * Removes a {@link Call} object from the list of {@link Call} objects created/tracked by this client.
-         *
-         * @param call the call to remove
-         */
-        this.unregisterCall = (call) => {
-            return this.setCalls((calls) => calls.filter((c) => c !== call));
-        };
-        /**
-         * Finds a {@link Call} object in the list of {@link Call} objects created/tracked by this client.
-         *
-         * @param type the type of call to find.
-         * @param id the id of the call to find.
-         */
-        this.findCall = (type, id) => {
-            return this.calls.find((c) => c.type === type && c.id === id);
-        };
-        this.connectedUserSubject.subscribe(async (user) => {
-            // leave all calls when the user disconnects.
-            if (!user) {
-                const logger = getLogger(['client-state']);
-                for (const call of this.calls) {
-                    if (call.state.callingState === CallingState.LEFT)
-                        continue;
-                    logger('info', `User disconnected, leaving call: ${call.cid}`);
-                    await call
-                        .leave({ reason: 'client.disconnectUser() called' })
-                        .catch((err) => {
-                        logger('error', `Error leaving call: ${call.cid}`, err);
-                    });
-                }
-            }
-        });
-    }
-    /**
-     * The currently connected user.
-     */
-    get connectedUser() {
-        return this.getCurrentValue(this.connectedUserSubject);
-    }
-    /**
-     * A list of {@link Call} objects created/tracked by this client.
-     */
-    get calls() {
-        return this.getCurrentValue(this.callsSubject);
-    }
-}
-/**
- * A reactive store that exposes state variables in a reactive manner.
- * You can subscribe to changes of the different state variables.
- * This central store contains all the state variables related to [`StreamVideoClient`](./StreamVideClient.md) and [`Call`](./Call.md).
- */
-class StreamVideoReadOnlyStateStore {
-    constructor(store) {
-        /**
-         * This method allows you the get the current value of a state variable.
-         *
-         * @param observable the observable to get the current value of.
-         * @returns the current value of the observable.
-         */
-        this.getCurrentValue = getCurrentValue;
-        // convert and expose subjects as observables
-        this.connectedUser$ = store.connectedUserSubject.asObservable();
-        this.calls$ = store.callsSubject.asObservable();
-    }
-    /**
-     * The current user connected over WS to the backend.
-     */
-    get connectedUser() {
-        return getCurrentValue(this.connectedUser$);
-    }
-    /**
-     * A list of {@link Call} objects created/tracked by this client.
-     */
-    get calls() {
-        return getCurrentValue(this.calls$);
-    }
-}
-
 const getRtpMap = (line) => {
     // Example: a=rtpmap:110 opus/48000/2
     const rtpRegex = /^a=rtpmap:(\d*) ([\w\-.]*)(?:\s*\/(\d*)(?:\s*\/(\S*))?)?/;
@@ -8711,7 +8717,7 @@ const enableHighQualityAudio = (sdp, trackMid, maxBitrate = 510000) => {
     return SDP.write(parsedSdp);
 };
 
-const version = "1.6.0-rc.0" ;
+const version = "1.6.0-rc2.0" ;
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -8783,16 +8789,6 @@ const getClientDetails = () => {
  * @internal
  */
 class Publisher {
-    /**
-     * Returns the current connection configuration.
-     *
-     * @internal
-     */
-    get connectionConfiguration() {
-        if (this.pc.getConfiguration)
-            return this.pc.getConfiguration();
-        return this._connectionConfiguration;
-    }
     /**
      * Constructs a new `Publisher` instance.
      *
@@ -8840,7 +8836,6 @@ class Publisher {
         this.isIceRestarting = false;
         this.createPeerConnection = (connectionConfig) => {
             const pc = new RTCPeerConnection(connectionConfig);
-            this._connectionConfiguration = connectionConfig;
             pc.addEventListener('icecandidate', this.onIceCandidate);
             pc.addEventListener('negotiationneeded', this.onNegotiationNeeded);
             pc.addEventListener('icecandidateerror', this.onIceCandidateError);
@@ -8905,11 +8900,11 @@ class Publisher {
              * An event handler which listens for the 'ended' event on the track.
              * Once the track has ended, it will notify the SFU and update the state.
              */
-            const handleTrackEnded = async () => {
-                this.logger('info', `Track ${TrackType[trackType]} has ended, notifying the SFU`);
-                await this.notifyTrackMuteStateChanged(mediaStream, trackType, true);
-                // clean-up, this event listener needs to run only once.
+            const handleTrackEnded = () => {
+                this.logger('info', `Track ${TrackType[trackType]} has ended abruptly, notifying the SFU`);
+                // cleanup, this event listener needs to run only once.
                 track.removeEventListener('ended', handleTrackEnded);
+                this.notifyTrackMuteStateChanged(mediaStream, trackType, true).catch((err) => this.logger('warn', `Couldn't notify track mute state`, err));
             };
             if (!transceiver) {
                 const { settings } = this.state;
@@ -9367,16 +9362,6 @@ class Publisher {
  * @internal
  */
 class Subscriber {
-    /**
-     * Returns the current connection configuration.
-     *
-     * @internal
-     */
-    get connectionConfiguration() {
-        if (this.pc.getConfiguration)
-            return this.pc.getConfiguration();
-        return this._connectionConfiguration;
-    }
     /**
      * Constructs a new `Subscriber` instance.
      *
@@ -9397,7 +9382,6 @@ class Subscriber {
          */
         this.createPeerConnection = (connectionConfig) => {
             const pc = new RTCPeerConnection(connectionConfig);
-            this._connectionConfiguration = connectionConfig;
             pc.addEventListener('icecandidate', this.onIceCandidate);
             pc.addEventListener('track', this.handleOnTrack);
             pc.addEventListener('icecandidateerror', this.onIceCandidateError);
@@ -9755,7 +9739,7 @@ class StreamSfuClient {
             this.migrationTask?.resolve();
         };
         this.leaveAndClose = async (reason) => {
-            await this.joinResponseTask.promise;
+            await this.joinTask;
             try {
                 this.isLeaving = true;
                 await this.notifyLeave(reason);
@@ -9766,43 +9750,43 @@ class StreamSfuClient {
             this.close(StreamSfuClient.NORMAL_CLOSURE, reason.substring(0, 115));
         };
         this.updateSubscriptions = async (tracks) => {
-            await this.joinResponseTask.promise;
+            await this.joinTask;
             return retryable(() => this.rpc.updateSubscriptions({ sessionId: this.sessionId, tracks }), this.abortController.signal);
         };
         this.setPublisher = async (data) => {
-            await this.joinResponseTask.promise;
+            await this.joinTask;
             return retryable(() => this.rpc.setPublisher({ ...data, sessionId: this.sessionId }), this.abortController.signal);
         };
         this.sendAnswer = async (data) => {
-            await this.joinResponseTask.promise;
+            await this.joinTask;
             return retryable(() => this.rpc.sendAnswer({ ...data, sessionId: this.sessionId }), this.abortController.signal);
         };
         this.iceTrickle = async (data) => {
-            await this.joinResponseTask.promise;
+            await this.joinTask;
             return retryable(() => this.rpc.iceTrickle({ ...data, sessionId: this.sessionId }), this.abortController.signal);
         };
         this.iceRestart = async (data) => {
-            await this.joinResponseTask.promise;
+            await this.joinTask;
             return retryable(() => this.rpc.iceRestart({ ...data, sessionId: this.sessionId }), this.abortController.signal);
         };
         this.updateMuteState = async (trackType, muted) => {
-            await this.joinResponseTask.promise;
+            await this.joinTask;
             return this.updateMuteStates({ muteStates: [{ trackType, muted }] });
         };
         this.updateMuteStates = async (data) => {
-            await this.joinResponseTask.promise;
+            await this.joinTask;
             return retryable(() => this.rpc.updateMuteStates({ ...data, sessionId: this.sessionId }), this.abortController.signal);
         };
         this.sendStats = async (stats) => {
-            await this.joinResponseTask.promise;
+            await this.joinTask;
             return retryable(() => this.rpc.sendStats({ ...stats, sessionId: this.sessionId }), this.abortController.signal);
         };
         this.startNoiseCancellation = async () => {
-            await this.joinResponseTask.promise;
+            await this.joinTask;
             return retryable(() => this.rpc.startNoiseCancellation({ sessionId: this.sessionId }), this.abortController.signal);
         };
         this.stopNoiseCancellation = async () => {
-            await this.joinResponseTask.promise;
+            await this.joinTask;
             return retryable(() => this.rpc.stopNoiseCancellation({ sessionId: this.sessionId }), this.abortController.signal);
         };
         this.enterMigration = async (opts = {}) => {
@@ -9938,6 +9922,9 @@ class StreamSfuClient {
     get isHealthy() {
         return this.signalWs.readyState === WebSocket.OPEN;
     }
+    get joinTask() {
+        return this.joinResponseTask.promise;
+    }
 }
 /**
  * The normal closure code. Used for controlled shutdowns.
@@ -11874,9 +11861,6 @@ class InputMediaDeviceManager {
         if (this.call.state.callingState === CallingState.JOINED) {
             await this.publishStream(stream);
         }
-        else {
-            this.logger('debug', 'Stream is not published as the call is not joined');
-        }
         if (this.state.mediaStream !== stream) {
             this.state.setMediaStream(stream, await rootStream);
             this.getTracks().forEach((track) => {
@@ -12993,7 +12977,14 @@ class Call {
                     throw new Error('Cannot leave call that has already been left.');
                 }
                 if (callingState === CallingState.JOINING) {
-                    await this.waitUntilCallJoined();
+                    const waitUntilCallJoined = () => {
+                        return new Promise((resolve) => {
+                            this.state.callingState$
+                                .pipe(takeWhile((state) => state !== CallingState.JOINED, true))
+                                .subscribe(() => resolve());
+                        });
+                    };
+                    await waitUntilCallJoined();
                 }
                 if (this.ringing) {
                     // I'm the one who started the call, so I should cancel it.
@@ -13237,6 +13228,11 @@ class Call {
                 await this.applyDeviceConfig(true);
                 this.deviceSettingsAppliedOnce = true;
             }
+            // We shouldn't persist the `ring` state after joining the call as it's a one-time event
+            // and clashes with the potential reconnection attempts. When reconnecting,
+            // if provided with `ring: true`, we will spam the other participants with
+            // push notifications and `call.ring` events.
+            delete this.joinCallData?.ring;
             this.logger('info', `Joined call ${this.cid}`);
         };
         /**
@@ -13296,7 +13292,7 @@ class Call {
                 dispatcher: this.dispatcher,
                 state: this.state,
                 connectionConfig,
-                logTag: String(this.reconnectAttempts),
+                logTag: String(this.sfuClientTag),
                 onUnrecoverableError: () => {
                     this.reconnect(WebsocketReconnectStrategy.REJOIN).catch((err) => {
                         this.logger('warn', '[Reconnect] Error reconnecting after a subscriber error', err);
@@ -13320,7 +13316,7 @@ class Call {
                     connectionConfig,
                     isDtxEnabled,
                     isRedEnabled,
-                    logTag: String(this.reconnectAttempts),
+                    logTag: String(this.sfuClientTag),
                     onUnrecoverableError: () => {
                         this.reconnect(WebsocketReconnectStrategy.REJOIN).catch((err) => {
                             this.logger('warn', '[Reconnect] Error reconnecting after a publisher error', err);
@@ -13373,6 +13369,21 @@ class Call {
             }
             return joinResponse;
         };
+        /**
+         * Handles the closing of the SFU signal connection.
+         *
+         * @internal
+         * @param sfuClient the SFU client instance that was closed.
+         */
+        this.handleSfuSignalClose = (sfuClient) => {
+            this.logger('debug', '[Reconnect] SFU signal connection closed');
+            // normal close, no need to reconnect
+            if (sfuClient.isLeaving)
+                return;
+            this.reconnect(WebsocketReconnectStrategy.REJOIN).catch((err) => {
+                this.logger('warn', '[Reconnect] Error reconnecting', err);
+            });
+        };
         /**
          * Handles the reconnection flow.
          *
@@ -13385,7 +13396,10 @@ class Call {
                 this.logger('info', `[Reconnect] Reconnecting with strategy ${WebsocketReconnectStrategy[strategy]}`);
                 this.reconnectStrategy = strategy;
                 do {
-                    this.reconnectAttempts++;
+                    // we don't increment reconnect attempts for the FAST strategy.
+                    if (this.reconnectStrategy !== WebsocketReconnectStrategy.FAST) {
+                        this.reconnectAttempts++;
+                    }
                     const current = WebsocketReconnectStrategy[this.reconnectStrategy];
                     try {
                         // wait until the network is available
@@ -13411,11 +13425,17 @@ class Call {
                         break; // do-while loop, reconnection worked, exit the loop
                     }
                     catch (error) {
-                        this.logger('warn', `[Reconnect] ${current}(${this.reconnectAttempts}) failed. Attempting with REJOIN`, error);
+                        if (error instanceof ErrorFromResponse && error.unrecoverable) {
+                            this.logger('warn', `[Reconnect] Can't reconnect due to coordinator unrecoverable error`, error);
+                            this.state.setCallingState(CallingState.RECONNECTING_FAILED);
+                            return;
+                        }
+                        this.logger('warn', `[Reconnect] ${current} (${this.reconnectAttempts}) failed. Attempting with REJOIN`, error);
                         await sleep(500);
                         this.reconnectStrategy = WebsocketReconnectStrategy.REJOIN;
                     }
                 } while (this.state.callingState !== CallingState.JOINED &&
+                    this.state.callingState !== CallingState.RECONNECTING_FAILED &&
                     this.state.callingState !== CallingState.LEFT);
             });
         };
@@ -13530,7 +13550,7 @@ class Call {
                             }
                         }
                         this.reconnect(strategy).catch((err) => {
-                            this.logger('warn', '[Reconnect] Error restoring connection after going online', err);
+                            this.logger('warn', '[Reconnect] Error reconnecting after going online', err);
                         });
                     });
                     this.networkAvailableTask = networkAvailableTask;
@@ -13613,18 +13633,15 @@ class Call {
          * @param opts the options to use when publishing the stream.
          */
         this.publishVideoStream = async (videoStream, opts = {}) => {
-            // we should wait until we get a JoinResponse from the SFU,
-            // otherwise we risk breaking the ICETrickle flow.
-            await this.waitUntilCallJoined();
-            if (!this.publisher) {
-                this.logger('error', 'Trying to publish video before join is completed');
+            if (!this.sfuClient)
                 throw new Error(`Call not joined yet.`);
-            }
+            // joining is in progress, and we should wait until the client is ready
+            await this.sfuClient.joinTask;
+            if (!this.publisher)
+                throw new Error('Publisher is not initialized');
             const [videoTrack] = videoStream.getVideoTracks();
-            if (!videoTrack) {
-                this.logger('error', `There is no video track to publish in the stream.`);
-                return;
-            }
+            if (!videoTrack)
+                throw new Error('There is no video track in the stream');
             if (!this.trackPublishOrder.includes(TrackType.VIDEO)) {
                 this.trackPublishOrder.push(TrackType.VIDEO);
             }
@@ -13640,18 +13657,15 @@ class Call {
          * @param audioStream the audio stream to publish.
          */
         this.publishAudioStream = async (audioStream) => {
-            // we should wait until we get a JoinResponse from the SFU,
-            // otherwise we risk breaking the ICETrickle flow.
-            await this.waitUntilCallJoined();
-            if (!this.publisher) {
-                this.logger('error', 'Trying to publish audio before join is completed');
+            if (!this.sfuClient)
                 throw new Error(`Call not joined yet.`);
-            }
+            // joining is in progress, and we should wait until the client is ready
+            await this.sfuClient.joinTask;
+            if (!this.publisher)
+                throw new Error('Publisher is not initialized');
             const [audioTrack] = audioStream.getAudioTracks();
-            if (!audioTrack) {
-                this.logger('error', `There is no audio track in the stream to publish`);
-                return;
-            }
+            if (!audioTrack)
+                throw new Error('There is no audio track in the stream');
             if (!this.trackPublishOrder.includes(TrackType.AUDIO)) {
                 this.trackPublishOrder.push(TrackType.AUDIO);
             }
@@ -13667,17 +13681,15 @@ class Call {
          * @param opts the options to use when publishing the stream.
          */
         this.publishScreenShareStream = async (screenShareStream, opts = {}) => {
-            // we should wait until we get a JoinResponse from the SFU,
-            // otherwise we risk breaking the ICETrickle flow.
-            await this.waitUntilCallJoined();
-            if (!this.publisher) {
-                this.logger('error', 'Trying to publish screen share before join is completed');
+            if (!this.sfuClient)
                 throw new Error(`Call not joined yet.`);
-            }
+            // joining is in progress, and we should wait until the client is ready
+            await this.sfuClient.joinTask;
+            if (!this.publisher)
+                throw new Error('Publisher is not initialized');
             const [screenShareTrack] = screenShareStream.getVideoTracks();
             if (!screenShareTrack) {
-                this.logger('error', `There is no video track in the screen share stream to publish`);
-                return;
+                throw new Error('There is no screen share track in the stream');
             }
             if (!this.trackPublishOrder.includes(TrackType.SCREEN_SHARE)) {
                 this.trackPublishOrder.push(TrackType.SCREEN_SHARE);
@@ -13832,18 +13844,6 @@ class Call {
         this.updatePublishQuality = async (enabledLayers) => {
             return this.publisher?.updateVideoPublishQuality(enabledLayers);
         };
-        this.waitUntilCallJoined = () => {
-            if (this.sfuClient) {
-                // if we have an SFU client, we can wait for the join response
-                return this.sfuClient.joinResponseTask.promise;
-            }
-            // otherwise, fall back to the calling state
-            return new Promise((resolve) => {
-                this.state.callingState$
-                    .pipe(takeWhile((state) => state !== CallingState.JOINED, true))
-                    .subscribe(() => resolve());
-            });
-        };
         /**
          * Sends a reaction to the other call participants.
          *
@@ -14465,12 +14465,12 @@ class Call {
                 return;
             const callSession = this.state.session;
             const receiver_id = this.clientStore.connectedUser?.id;
-            const endedAt = this.state.endedAt;
+            const ended_at = callSession?.ended_at;
             const created_by_id = this.state.createdBy?.id;
             const rejected_by = callSession?.rejected_by;
             const accepted_by = callSession?.accepted_by;
             let leaveCallIdle = false;
-            if (endedAt) {
+            if (ended_at) {
                 // call was ended before it was accepted or rejected so we should leave it to idle
                 leaveCallIdle = true;
             }
@@ -14498,10 +14498,10 @@ class Call {
                 }
             }
             else {
-                this.scheduleAutoDrop();
                 if (this.state.callingState === CallingState.IDLE) {
                     this.state.setCallingState(CallingState.RINGING);
                 }
+                this.scheduleAutoDrop();
                 this.leaveCallHooks.add(registerRingingCallEventHandlers(this));
             }
         }));
@@ -14524,21 +14524,6 @@ class Call {
     get isCreatedByMe() {
         return this.state.createdBy?.id === this.currentUserId;
     }
-    /**
-     * Handles the closing of the SFU signal connection.
-     *
-     * @internal
-     * @param sfuClient the SFU client instance that was closed.
-     */
-    handleSfuSignalClose(sfuClient) {
-        this.logger('debug', '[Reconnect] SFU signal connection closed');
-        // normal close, no need to reconnect
-        if (sfuClient.isLeaving)
-            return;
-        this.reconnect(WebsocketReconnectStrategy.REJOIN).catch((err) => {
-            this.logger('warn', '[Reconnect] Error reconnecting', err);
-        });
-    }
 }
 
 var https = null;
@@ -15641,7 +15626,6 @@ class StreamClient {
      */
     constructor(key, options) {
         this.listeners = {};
-        this.nextRequestAbortController = null;
         this.devToken = (userID) => {
             return DevToken(userID);
         };
@@ -15772,15 +15756,6 @@ class StreamClient {
             this.wsPromise = this.connect();
             return this.wsPromise;
         };
-        this._normalizeDate = (before) => {
-            if (before instanceof Date) {
-                before = before.toISOString();
-            }
-            if (before === '') {
-                throw new Error("Don't pass blank string for since, use null instead if resetting the token revoke");
-            }
-            return before;
-        };
         /**
          * Disconnects the websocket and removes the user from client.
          *
@@ -15957,14 +15932,13 @@ class StreamClient {
             });
         };
         this.errorFromResponse = (response) => {
-            let err;
-            err = new ErrorFromResponse(`Stream error HTTP code: ${response.status}`);
-            if (response.data && response.data.code) {
-                err = new Error(`Stream error code ${response.data.code}: ${response.data.message}`);
-                err.code = response.data.code;
-            }
+            const { data, status } = response;
+            const err = new ErrorFromResponse();
+            err.message = `Stream error code ${data.code}: ${data.message}`;
+            err.code = data.code;
+            err.unrecoverable = data.unrecoverable;
             err.response = response;
-            err.status = response.status;
+            err.status = status;
             return err;
         };
         this.handleResponse = (response) => {
@@ -16065,7 +16039,7 @@ class StreamClient {
             });
         };
         this.getUserAgent = () => {
-            const version = "1.6.0-rc.0" ;
+            const version = "1.6.0-rc2.0" ;
             return (this.userAgent ||
                 `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${version}`);
         };
@@ -16083,11 +16057,6 @@ class StreamClient {
         }) => {
             const token = options.publicEndpoint && !this.user ? undefined : this._getToken();
             const authorization = token ? { Authorization: token } : undefined;
-            let signal = null;
-            if (this.nextRequestAbortController !== null) {
-                signal = this.nextRequestAbortController.signal;
-                this.nextRequestAbortController = null;
-            }
             if (!options.headers?.['x-client-request-id']) {
                 options.headers = {
                     ...options.headers,
@@ -16109,7 +16078,6 @@ class StreamClient {
                     'X-Stream-Client': this.getUserAgent(),
                     ...options.headers,
                 },
-                ...(signal ? { signal } : {}),
                 ...options.config,
                 ...this.options.axiosRequestConfig,
             };
@@ -16551,7 +16519,7 @@ class StreamVideoClient {
                 }
                 if (id) {
                     if (StreamVideoClient._instanceMap.has(apiKeyOrArgs.apiKey + id)) {
-                        this.logger('warn', `A StreamVideoClient already exists for ${user.type === 'anonymous' ? 'an anyonymous user' : id}; Prefer using getOrCreateInstance method`);
+                        this.logger('warn', `A StreamVideoClient already exists for ${user.type === 'anonymous' ? 'an anonymous user' : id}; Prefer using getOrCreateInstance method`);
                     }
                     user.id = id;
                     StreamVideoClient._instanceMap.set(apiKeyOrArgs.apiKey + id, this);