@stream-io/video-client 2.0.0-beta.0 → 2.0.0-beta.1

package/dist/index.es.js

@@ -7,7 +7,7 @@ import { TwirpFetchTransport, TwirpErrorCode } from '@protobuf-ts/twirp-transpor
 import * as scopedLogger from '@stream-io/logger';
 export { LogLevelEnum } from '@stream-io/logger';
 import { parse, write } from 'sdp-transform';
-import { Subject, Observable, combineLatest, BehaviorSubject, ReplaySubject, shareReplay, map, distinctUntilChanged, startWith, takeWhile, distinctUntilKeyChanged, fromEventPattern, concatMap, merge, from, fromEvent, tap, debounceTime, pairwise, firstValueFrom, of, Subscription } from 'rxjs';
+import { Subject, Observable, BehaviorSubject, distinctUntilChanged, shareReplay, ReplaySubject, map, combineLatest, startWith, takeWhile, distinctUntilKeyChanged, fromEventPattern, concatMap, merge, from, fromEvent, tap, debounceTime, pairwise, firstValueFrom, of, Subscription } from 'rxjs';
 import { UAParser } from 'ua-parser-js';
 import { WorkerTimer } from '@stream-io/worker-timer';
 import https from 'https';
@@ -5082,7 +5082,7 @@ const toIceCandidate = (iceTrickle) => {
     }
 };
 
-const version = "2.0.0-beta.0";
+const version = "2.0.0-beta.1";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -5462,11 +5462,14 @@ const isFunctionPatch = (update) => typeof update === 'function';
  * @param observable$ the observable to get the value from.
  */
 const getCurrentValue = (observable$) => {
+    if (observable$ instanceof BehaviorSubject) {
+        return observable$.getValue();
+    }
     let value;
     let err = undefined;
-    combineLatest([observable$])
+    observable$
         .subscribe({
-        next: ([v]) => {
+        next: (v) => {
             value = v;
         },
         error: (e) => {
@@ -5615,38 +5618,39 @@ var CallingState;
     CallingState["OFFLINE"] = "offline";
 })(CallingState || (CallingState = {}));
 
-class StreamVideoWriteableStateStore {
-    /**
-     * A store keeping data of a successfully connected user over WS to the coordinator server.
-     */
-    connectedUserSubject = new BehaviorSubject(undefined);
-    /**
-     * A list of {@link Call} objects created/tracked by this client.
-     */
-    callsSubject = new BehaviorSubject([]);
-    constructor() {
-        this.connectedUserSubject.subscribe(async (user) => {
-            // leave all calls when the user disconnects.
-            if (!user) {
-                const logger = videoLoggerSystem.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({ message: 'client.disconnectUser() called' })
-                        .catch((err) => {
-                        logger.error(`Error leaving call: ${call.cid}`, err);
-                    });
-                }
-            }
-        });
-    }
-    /**
-     * The currently connected user.
-     */
+function subject(initialValue) {
+    return new BehaviorSubject(initialValue);
+}
+/**
+ * Creates an Observable from the given subject by piping it to the
+ * `distinctUntilChanged()` operator.
+ */
+const duc = (source, comparator) => source.pipe(distinctUntilChanged(comparator));
+/**
+ * Multicasts the given Observable, replaying the latest computed value to
+ * every new subscriber instead of re-running the pipeline for each of them.
+ */
+const shared = (source) => source.pipe(shareReplay({ bufferSize: 1, refCount: true }));
+
+/**
+ * Holds the state of the client, and the calls it created or tracks.
+ * You can subscribe to the exposed observables to get notified about changes.
+ */
+class ClientState {
+    logger = videoLoggerSystem.getLogger('ClientState');
+    connectedUserSubject = subject();
+    callsSubject = subject([]);
+    /** Data describing a user successfully connected over WS to the coordinator. */
+    connectedUser$ = this.connectedUserSubject.asObservable();
+    /** A list of {@link Call} objects created/tracked by this client. */
+    calls$ = this.callsSubject.asObservable();
+    /** The currently connected user. */
     get connectedUser() {
-        return this.connectedUserSubject.getValue();
+        return getCurrentValue(this.connectedUserSubject);
+    }
+    /** A list of {@link Call} objects created/tracked by this client. */
+    get calls() {
+        return getCurrentValue(this.callsSubject);
     }
     /**
      * Sets the currently connected user.
@@ -5657,22 +5661,19 @@ class StreamVideoWriteableStateStore {
     setConnectedUser = (user) => {
         return setCurrentValue(this.connectedUserSubject, user);
     };
-    /**
-     * A list of {@link Call} objects created/tracked by this client.
-     */
-    get calls() {
-        return getCurrentValue(this.callsSubject);
-    }
     /**
      * Sets the list of {@link Call} objects created/tracked by this client.
-     * @param calls
+     *
+     * @internal
+     * @param calls the calls to set.
      */
     setCalls = (calls) => {
         return setCurrentValue(this.callsSubject, calls);
     };
     /**
-     * Adds a {@link Call} object to the list of {@link Call} objects created/tracked by this client.
+     * Adds a {@link Call} object to the list of calls tracked by this client.
      *
+     * @internal
      * @param call the call to add.
      */
     registerCall = (call) => {
@@ -5683,6 +5684,7 @@ class StreamVideoWriteableStateStore {
     /**
      * Registers a {@link Call} object if it doesn't exist, otherwise updates it.
      *
+     * @internal
      * @param call the call to register or update.
      */
     registerOrUpdateCall = (call) => {
@@ -5694,17 +5696,17 @@ class StreamVideoWriteableStateStore {
         }
     };
     /**
-     * Removes a {@link Call} object from the list of {@link Call} objects created/tracked by this client.
+     * Removes a {@link Call} object from the list of calls tracked by this client.
      *
-     * @param call the call to remove
+     * @internal
+     * @param call the call to remove.
      */
     unregisterCall = (call) => {
-        const logger = videoLoggerSystem.getLogger('client-state');
-        logger.trace(`Unregistering call: ${call.cid}`);
+        this.logger.trace(`Unregistering call: ${call.cid}`);
         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.
+     * Finds a {@link Call} object in the list of calls tracked by this client.
      *
      * @param type the type of call to find.
      * @param id the id of the call to find.
@@ -5713,38 +5715,6 @@ class StreamVideoWriteableStateStore {
         return this.calls.find((c) => c.type === type && c.id === id);
     };
 }
-/**
- * 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 {
-    /**
-     * Data describing a user successfully connected over WS to coordinator server.
-     */
-    connectedUser$;
-    /**
-     * A list of {@link Call} objects created/tracked by this client.
-     */
-    calls$;
-    constructor(store) {
-        // 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.
@@ -6077,9 +6047,7 @@ const paginatedLayoutSortPreset = combineComparators(pinned, ifInvisibleOrUnknow
  */
 const livestreamOrAudioRoomSortPreset = combineComparators(publishing, ifInvisibleOrUnknownBy(combineComparators(dominantSpeaker, speaking, reactionType('raised-hand'), withVideoIngressSource, publishingVideo, publishingAudio)), role('admin', 'host', 'speaker'));
 
-/**
- * Returns the default egress object - when no egress data is available.
- */
+/** Returns the default egress object - when no egress data is available. */
 const defaultEgress = {
     broadcasting: false,
     hls: { playlist_url: '', status: '' },
@@ -6090,93 +6058,120 @@ const defaultEgress = {
  * @react You don't have to use this class directly, as we are exposing the state through Hooks.
  */
 class CallState {
-    backstageSubject = new BehaviorSubject(true);
-    blockedUserIdsSubject = new BehaviorSubject([]);
-    createdAtSubject = new BehaviorSubject(new Date());
-    endedAtSubject = new BehaviorSubject(undefined);
-    startsAtSubject = new BehaviorSubject(undefined);
-    updatedAtSubject = new BehaviorSubject(new Date());
-    createdBySubject = new BehaviorSubject(undefined);
-    customSubject = new BehaviorSubject({});
-    egressSubject = new BehaviorSubject(undefined);
-    ingressSubject = new BehaviorSubject(undefined);
-    recordingSubject = new BehaviorSubject(false);
-    individualRecordingSubject = new BehaviorSubject(false);
-    rawRecordingSubject = new BehaviorSubject(false);
-    sessionSubject = new BehaviorSubject(undefined);
-    settingsSubject = new BehaviorSubject(undefined);
-    transcribingSubject = new BehaviorSubject(false);
-    captioningSubject = new BehaviorSubject(false);
-    e2eeEnabledSubject = new BehaviorSubject(false);
-    endedBySubject = new BehaviorSubject(undefined);
-    thumbnailsSubject = new BehaviorSubject(undefined);
-    membersSubject = new BehaviorSubject([]);
-    ownCapabilitiesSubject = new BehaviorSubject([]);
-    callingStateSubject = new BehaviorSubject(CallingState.UNKNOWN);
-    startedAtSubject = new BehaviorSubject(undefined);
-    participantCountSubject = new BehaviorSubject(0);
-    anonymousParticipantCountSubject = new BehaviorSubject(0);
-    participantsSubject = new BehaviorSubject([]);
-    callStatsReportSubject = new BehaviorSubject(undefined);
-    closedCaptionsSubject = new BehaviorSubject([]);
-    // These are tracks that were delivered to the Subscriber's onTrack event
-    // that we couldn't associate with a participant yet.
-    // This happens when the participantJoined event hasn't been received yet.
-    // We keep these tracks around until we can associate them with a participant.
-    orphanedTracks = [];
+    logger = videoLoggerSystem.getLogger('CallState');
+    /** A list of comparators that are used to sort the participants. */
+    sortParticipantsBy = defaultSortPreset;
+    backstageSubject = subject(true);
+    blockedUserIdsSubject = subject([]);
+    createdAtSubject = subject(new Date());
+    endedAtSubject = subject();
+    startsAtSubject = subject();
+    updatedAtSubject = subject(new Date());
+    createdBySubject = subject();
+    customSubject = subject({});
+    egressSubject = subject();
+    ingressSubject = subject();
+    recordingSubject = subject(false);
+    individualRecordingSubject = subject(false);
+    rawRecordingSubject = subject(false);
+    sessionSubject = subject();
+    settingsSubject = subject();
+    transcribingSubject = subject(false);
+    captioningSubject = subject(false);
+    e2eeEnabledSubject = subject(false);
+    endedBySubject = subject();
+    thumbnailsSubject = subject();
+    membersSubject = subject([]);
+    ownCapabilitiesSubject = subject([]);
+    callingStateSubject = subject(CallingState.UNKNOWN);
+    startedAtSubject = subject();
+    participantCountSubject = subject(0);
+    anonymousParticipantCountSubject = subject(0);
+    participantsSubject = subject([]);
+    callStatsReportSubject = subject();
+    closedCaptionsSubject = subject([]);
     callGrantsSubject = new ReplaySubject(1);
-    // Derived state
+    /** The backstage state. */
+    backstage$ = duc(this.backstageSubject);
+    /** Will provide the list of blocked user IDs. */
+    blockedUserIds$ = duc(this.blockedUserIdsSubject, isShallowArrayEqual);
+    /** Will provide the time when this call has been created. */
+    createdAt$ = this.createdAtSubject.asObservable();
+    /** Will provide the time when this call has been ended. */
+    endedAt$ = this.endedAtSubject.asObservable();
+    /** Will provide the time when this call has been scheduled to start. */
+    startsAt$ = this.startsAtSubject.asObservable();
+    /** Will provide the time when this call has been updated. */
+    updatedAt$ = this.updatedAtSubject.asObservable();
+    /** Will provide the user who created this call. */
+    createdBy$ = this.createdBySubject.asObservable();
+    /** Will provide the custom data of this call. */
+    custom$ = this.customSubject.asObservable();
+    /** Will provide the egress data of this call. */
+    egress$ = this.egressSubject.asObservable();
+    /** Will provide the ingress data of this call. */
+    ingress$ = this.ingressSubject.asObservable();
+    /** Will provide the recording state of this call. */
+    recording$ = duc(this.recordingSubject);
+    /** Will provide the recording state of this call. */
+    individualRecording$ = duc(this.individualRecordingSubject);
+    /** Will provide the recording state of this call. */
+    rawRecording$ = duc(this.rawRecordingSubject);
+    /** Will provide the session data of this call. */
+    session$ = this.sessionSubject.asObservable();
+    /** Will provide the settings of this call. */
+    settings$ = this.settingsSubject.asObservable();
+    /** Will provide the transcribing state of this call. */
+    transcribing$ = duc(this.transcribingSubject);
+    /** Will provide the closed captioning state of this call. */
+    captioning$ = duc(this.captioningSubject);
+    /**
+     * Whether end-to-end encryption is active for this call, as reported by the
+     * SFU in the join response.
+     */
+    e2eeEnabled$ = duc(this.e2eeEnabledSubject);
+    /** Will provide the user who ended this call. */
+    endedBy$ = this.endedBySubject.asObservable();
+    /** Will provide the thumbnails of this call. */
+    thumbnails$ = this.thumbnailsSubject.asObservable();
+    /** The list of members in the current call. */
+    members$ = this.membersSubject.asObservable();
+    /** The calling state. */
+    callingState$ = duc(this.callingStateSubject);
     /**
      * The time the call session actually started.
      * Useful for displaying the call duration.
      */
-    startedAt$;
+    startedAt$ = this.startedAtSubject.asObservable();
     /**
      * The server-side counted number of participants connected to the current call.
      * This number includes the anonymous participants as well.
      */
-    participantCount$;
+    participantCount$ = duc(this.participantCountSubject);
     /**
      * The server-side counted number of anonymous participants connected to the current call.
      * This number excludes the regular participants.
      */
-    anonymousParticipantCount$;
+    anonymousParticipantCount$ = duc(this.anonymousParticipantCountSubject);
     /**
      * All participants of the current call (this includes the current user and other participants as well),
      * unsorted. This observable only updates when participants join or leave the call.
      */
-    rawParticipants$;
-    /**
-     * All participants of the current call (this includes the current user and other participants as well),
-     * sorted according to the current `sortByParticipantsBy` setting
-     */
-    participants$;
-    /**
-     * Remote participants of the current call (this includes every participant except the logged-in user).
-     */
-    remoteParticipants$;
-    /**
-     * The local participant of the current call (the logged-in user).
-     */
-    localParticipant$;
-    /**
-     * Pinned participants of the current call.
-     */
-    pinnedParticipants$;
-    /**
-     * The currently elected dominant speaker in the current call.
-     */
-    dominantSpeaker$;
-    /**
-     * Emits true whenever there is an active screen sharing session within
-     * the current call. Useful for displaying a "screen sharing" indicator and
-     * switching the layout to a screen sharing layout.
-     *
-     * The actual screen sharing track isn't exposed here, but can be retrieved
-     * from the list of call participants. We also don't want to be limiting
-     * to the number of share screen tracks are displayed in a call.
-     */
-    hasOngoingScreenShare$;
+    rawParticipants$ = shared(this.participantsSubject.asObservable());
+    /** All participants of the current call sorted according to the current `sortByParticipantsBy` setting. */
+    participants$ = shared(this.participantsSubject.asObservable().pipe(
+    // maintain stable-sort by mutating the participants stored in the original subject
+    map((ps) => ps.sort(this.sortParticipantsBy))));
+    /** The local participant of the current call. */
+    localParticipant$ = shared(this.participants$.pipe(map((ps) => ps.find((p) => p.isLocalParticipant))));
+    /** Remote participants of the current call (all except the local participant). */
+    remoteParticipants$ = shared(this.participants$.pipe(map((ps) => ps.filter((p) => !p.isLocalParticipant))));
+    /** Pinned participants of the current call. */
+    pinnedParticipants$ = shared(this.participants$.pipe(map((ps) => ps.filter((p) => !!p.pin))));
+    /** The currently elected dominant speaker in the current call. */
+    dominantSpeaker$ = shared(this.participants$.pipe(map((ps) => ps.find((p) => p.isDominantSpeaker))));
+    /** Emits true whenever there is an active screen sharing session within the current call. */
+    hasOngoingScreenShare$ = shared(this.participants$.pipe(map((ps) => ps.some((p) => hasScreenShare(p))), distinctUntilChanged()));
     /**
      * The latest stats report of the current call.
      * When stats gathering is enabled, this observable will emit a new value
@@ -6185,232 +6180,66 @@ class CallState {
      * Consumers of this observable can implement their own batching logic
      * in case they want to show historical stats data.
      */
-    callStatsReport$;
-    /**
-     * The list of members in the current call.
-     */
-    members$;
-    /**
-     * The list of capabilities of the current user.
-     */
-    ownCapabilities$;
-    /**
-     * The calling state.
-     */
-    callingState$;
-    /**
-     * The backstage state.
-     */
-    backstage$;
-    /**
-     * Will provide the list of blocked user IDs.
-     */
-    blockedUserIds$;
-    /**
-     * Will provide the time when this call has been created.
-     */
-    createdAt$;
-    /**
-     * Will provide the time when this call has been ended.
-     */
-    endedAt$;
-    /**
-     * Will provide the time when this call has been scheduled to start.
-     */
-    startsAt$;
-    /**
-     * Will provide the time when this call has been updated.
-     */
-    updatedAt$;
-    /**
-     * Will provide the user who created this call.
-     */
-    createdBy$;
-    /**
-     * Will provide the custom data of this call.
-     */
-    custom$;
-    /**
-     * Will provide the egress data of this call.
-     */
-    egress$;
-    /**
-     * Will provide the ingress data of this call.
-     */
-    ingress$;
-    /**
-     * Will provide the recording state of this call.
-     */
-    recording$;
-    /**
-     * Will provide the recording state of this call.
-     */
-    individualRecording$;
-    /**
-     * Will provide the recording state of this call.
-     */
-    rawRecording$;
-    /**
-     * Will provide the session data of this call.
-     */
-    session$;
-    /**
-     * Will provide the settings of this call.
-     */
-    settings$;
-    /**
-     * Will provide the transcribing state of this call.
-     */
-    transcribing$;
-    /**
-     * Will provide the closed captioning state of this call.
-     */
-    captioning$;
-    /**
-     * Whether end-to-end encryption is active for this call, as reported by the
-     * SFU in the join response.
-     */
-    e2eeEnabled$;
-    /**
-     * Will provide the user who ended this call.
-     */
-    endedBy$;
-    /**
-     * Will provide the thumbnails of this call.
-     */
-    thumbnails$;
-    /**
-     * The queue of closed captions.
-     */
-    closedCaptions$;
-    logger = videoLoggerSystem.getLogger('CallState');
-    /**
-     * A list of comparators that are used to sort the participants.
-     */
-    sortParticipantsBy = defaultSortPreset;
-    /**
-     * The closed captions configuration.
-     */
+    callStatsReport$ = this.callStatsReportSubject.asObservable();
+    /** The queue of closed captions. */
+    closedCaptions$ = this.closedCaptionsSubject.asObservable();
+    /** The list of capabilities of the current user. */
+    ownCapabilities$ = shared(combineLatest([
+        this.ownCapabilitiesSubject,
+        this.callGrantsSubject.pipe(startWith(undefined)),
+    ]).pipe(map(([capabilities, grants]) => {
+        if (!grants)
+            return capabilities;
+        const { canPublishAudio, canPublishVideo, canScreenshare } = grants;
+        const update = {
+            [OwnCapability.SEND_AUDIO]: canPublishAudio,
+            [OwnCapability.SEND_VIDEO]: canPublishVideo,
+            [OwnCapability.SCREENSHARE]: canScreenshare,
+        };
+        const nextCapabilities = [...capabilities];
+        for (const _capability in update) {
+            const capability = _capability;
+            const allowed = update[capability];
+            // grants take precedence over capabilities, reconstruct the capabilities
+            if (allowed && !nextCapabilities.includes(capability)) {
+                nextCapabilities.push(capability);
+            }
+            else if (!allowed && nextCapabilities.includes(capability)) {
+                const index = nextCapabilities.indexOf(capability);
+                nextCapabilities.splice(index, 1);
+            }
+        }
+        return nextCapabilities;
+    }), distinctUntilChanged(isShallowArrayEqual)));
+    // These are tracks that were delivered to the Subscriber's onTrack event
+    // that we couldn't associate with a participant yet.
+    // This happens when the participantJoined event hasn't been received yet.
+    // We keep these tracks around until we can associate them with a participant.
+    orphanedTracks = [];
+    /** The closed captions configuration. */
     closedCaptionsSettings;
     closedCaptionsTasks = new Map();
     eventHandlers;
-    /**
-     * Creates a new instance of the CallState class.
-     *
-     */
+    /** Creates a new instance of the CallState class. */
     constructor() {
-        this.rawParticipants$ = this.participantsSubject
-            .asObservable()
-            .pipe(shareReplay({ bufferSize: 1, refCount: true }));
-        this.participants$ = this.participantsSubject.asObservable().pipe(
-        // maintain stable-sort by mutating the participants stored
-        // in the original subject
-        map((ps) => ps.sort(this.sortParticipantsBy)), shareReplay({ bufferSize: 1, refCount: true }));
-        this.localParticipant$ = this.participants$.pipe(map((participants) => participants.find((p) => p.isLocalParticipant)), shareReplay({ bufferSize: 1, refCount: true }));
-        this.remoteParticipants$ = this.participants$.pipe(map((participants) => participants.filter((p) => !p.isLocalParticipant)), shareReplay({ bufferSize: 1, refCount: true }));
-        this.pinnedParticipants$ = this.participants$.pipe(map((participants) => participants.filter((p) => !!p.pin)), shareReplay({ bufferSize: 1, refCount: true }));
-        this.dominantSpeaker$ = this.participants$.pipe(map((participants) => participants.find((p) => p.isDominantSpeaker)), shareReplay({ bufferSize: 1, refCount: true }));
-        this.hasOngoingScreenShare$ = this.participants$.pipe(map((participants) => participants.some((p) => hasScreenShare(p))), distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true }));
-        // dates
-        this.createdAt$ = this.createdAtSubject.asObservable();
-        this.endedAt$ = this.endedAtSubject.asObservable();
-        this.startsAt$ = this.startsAtSubject.asObservable();
-        this.startedAt$ = this.startedAtSubject.asObservable();
-        this.updatedAt$ = this.updatedAtSubject.asObservable();
-        this.callStatsReport$ = this.callStatsReportSubject.asObservable();
-        this.members$ = this.membersSubject.asObservable();
-        // complex objects should work as streams of data
-        this.createdBy$ = this.createdBySubject.asObservable();
-        this.custom$ = this.customSubject.asObservable();
-        this.egress$ = this.egressSubject.asObservable();
-        this.ingress$ = this.ingressSubject.asObservable();
-        this.session$ = this.sessionSubject.asObservable();
-        this.settings$ = this.settingsSubject.asObservable();
-        this.endedBy$ = this.endedBySubject.asObservable();
-        this.thumbnails$ = this.thumbnailsSubject.asObservable();
-        this.closedCaptions$ = this.closedCaptionsSubject.asObservable();
-        /**
-         * Creates an Observable from the given subject by piping to the
-         * `distinctUntilChanged()` operator.
-         */
-        const duc = (subject, comparator) => subject.pipe(distinctUntilChanged(comparator));
-        // primitive values should only emit once the value they hold changes
-        this.anonymousParticipantCount$ = duc(this.anonymousParticipantCountSubject);
-        this.blockedUserIds$ = duc(this.blockedUserIdsSubject, isShallowArrayEqual);
-        this.backstage$ = duc(this.backstageSubject);
-        this.callingState$ = duc(this.callingStateSubject);
-        this.ownCapabilities$ = combineLatest([
-            this.ownCapabilitiesSubject,
-            this.callGrantsSubject.pipe(startWith(undefined)),
-        ]).pipe(map(([capabilities, grants]) => {
-            if (!grants)
-                return capabilities;
-            const { canPublishAudio, canPublishVideo, canScreenshare } = grants;
-            const update = {
-                [OwnCapability.SEND_AUDIO]: canPublishAudio,
-                [OwnCapability.SEND_VIDEO]: canPublishVideo,
-                [OwnCapability.SCREENSHARE]: canScreenshare,
-            };
-            const nextCapabilities = [...capabilities];
-            for (const _capability in update) {
-                const capability = _capability;
-                const allowed = update[capability];
-                // grants take precedence over capabilities, reconstruct the capabilities
-                if (allowed && !nextCapabilities.includes(capability)) {
-                    nextCapabilities.push(capability);
-                }
-                else if (!allowed && nextCapabilities.includes(capability)) {
-                    const index = nextCapabilities.indexOf(capability);
-                    nextCapabilities.splice(index, 1);
-                }
-            }
-            return nextCapabilities;
-        }), distinctUntilChanged(isShallowArrayEqual), shareReplay({ bufferSize: 1, refCount: true }));
-        this.participantCount$ = duc(this.participantCountSubject);
-        this.recording$ = duc(this.recordingSubject);
-        this.individualRecording$ = duc(this.individualRecordingSubject);
-        this.rawRecording$ = duc(this.rawRecordingSubject);
-        this.transcribing$ = duc(this.transcribingSubject);
-        this.captioning$ = duc(this.captioningSubject);
-        this.e2eeEnabled$ = duc(this.e2eeEnabledSubject);
         this.eventHandlers = {
-            // these events are not updating the call state:
-            'call.frame_recording_ready': undefined,
-            'call.kicked_user': undefined,
-            'call.moderation_blur': undefined,
-            'call.moderation_warning': undefined,
-            'call.permission_request': undefined,
-            'call.recording_ready': undefined,
-            'call.rtmp_broadcast_failed': undefined,
-            'call.rtmp_broadcast_started': undefined,
-            'call.rtmp_broadcast_stopped': undefined,
-            'call.stats_report_ready': undefined,
-            'call.transcription_ready': undefined,
-            'call.user_feedback_submitted': undefined,
-            'call.user_muted': undefined,
-            'connection.error': undefined,
-            'connection.ok': undefined,
-            'health.check': undefined,
-            'user.updated': undefined,
-            custom: undefined,
-            // events that update call state:
             'call.accepted': (e) => this.updateFromCallResponse(e.call),
             'call.blocked_user': this.blockUser,
             'call.closed_caption': this.updateFromClosedCaptions,
             'call.closed_captions_failed': () => {
-                this.setCurrentValue(this.captioningSubject, false);
+                setCurrentValue(this.captioningSubject, false);
             },
             'call.closed_captions_started': () => {
-                this.setCurrentValue(this.captioningSubject, true);
+                setCurrentValue(this.captioningSubject, true);
             },
             'call.closed_captions_stopped': () => {
-                this.setCurrentValue(this.captioningSubject, false);
+                setCurrentValue(this.captioningSubject, false);
             },
             'call.created': (e) => this.updateFromCallResponse(e.call),
             'call.deleted': (e) => this.updateFromCallResponse(e.call),
             'call.ended': (e) => {
                 this.updateFromCallResponse(e.call);
-                this.setCurrentValue(this.endedBySubject, e.user);
+                setCurrentValue(this.endedBySubject, e.user);
             },
             'call.frame_recording_failed': (e) => {
                 this.updateFromCallResponse(e.call);
@@ -6455,21 +6284,19 @@ class CallState {
             'call.session_participant_left': this.updateFromSessionParticipantLeft,
             'call.session_started': (e) => this.updateFromCallResponse(e.call),
             'call.transcription_started': () => {
-                this.setCurrentValue(this.transcribingSubject, true);
+                setCurrentValue(this.transcribingSubject, true);
             },
             'call.transcription_stopped': () => {
-                this.setCurrentValue(this.transcribingSubject, false);
+                setCurrentValue(this.transcribingSubject, false);
             },
             'call.transcription_failed': () => {
-                this.setCurrentValue(this.transcribingSubject, false);
+                setCurrentValue(this.transcribingSubject, false);
             },
             'call.unblocked_user': this.unblockUser,
             'call.updated': (e) => this.updateFromCallResponse(e.call),
         };
     }
-    /**
-     * Runs the cleanup tasks.
-     */
+    /** Runs the cleanup tasks. */
     dispose = () => {
         for (const [ccKey, taskId] of this.closedCaptionsTasks.entries()) {
             clearTimeout(taskId);
@@ -6486,39 +6313,18 @@ class CallState {
     setSortParticipantsBy = (comparator) => {
         this.sortParticipantsBy = comparator;
         // trigger re-sorting of participants
-        this.setCurrentValue(this.participantsSubject, (ps) => ps);
+        setCurrentValue(this.participantsSubject, (ps) => ps);
     };
-    /**
-     * Returns the comparator currently used to sort the participants.
-     */
+    /** Returns the comparator currently used to sort the participants. */
     getSortParticipantsBy = () => {
         return this.sortParticipantsBy;
     };
-    /**
-     * 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.
-     */
-    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.
-     *
-     * @internal
-     *
-     * @param subject the subject to update.
-     * @param update the update to apply to the subject.
-     * @return the updated value.
-     */
-    setCurrentValue = setCurrentValue;
     /**
      * The server-side counted number of participants connected to the current call.
      * This number includes the anonymous participants as well.
      */
     get participantCount() {
-        return this.getCurrentValue(this.participantCount$);
+        return getCurrentValue(this.participantCountSubject);
     }
     /**
      * Sets the number of participants in the current call.
@@ -6527,14 +6333,14 @@ class CallState {
      * @param count the number of participants.
      */
     setParticipantCount = (count) => {
-        return this.setCurrentValue(this.participantCountSubject, count);
+        return setCurrentValue(this.participantCountSubject, count);
     };
     /**
      * The time the call session actually started.
      * Useful for displaying the call duration.
      */
     get startedAt() {
-        return this.getCurrentValue(this.startedAt$);
+        return getCurrentValue(this.startedAtSubject);
     }
     /**
      * Sets the time the call session actually started.
@@ -6543,13 +6349,11 @@ class CallState {
      * @param startedAt the time the call session actually started.
      */
     setStartedAt = (startedAt) => {
-        return this.setCurrentValue(this.startedAtSubject, startedAt);
+        return setCurrentValue(this.startedAtSubject, startedAt);
     };
-    /**
-     * Returns whether closed captions are enabled in the current call.
-     */
+    /** Returns whether closed captions are enabled in the current call. */
     get captioning() {
-        return this.getCurrentValue(this.captioning$);
+        return getCurrentValue(this.captioningSubject);
     }
     /**
      * Sets the closed captioning state of the current call.
@@ -6565,7 +6369,7 @@ class CallState {
      * This number includes the anonymous participants as well.
      */
     get anonymousParticipantCount() {
-        return this.getCurrentValue(this.anonymousParticipantCount$);
+        return getCurrentValue(this.anonymousParticipantCountSubject);
     }
     /**
      * Sets the number of anonymous participants in the current call.
@@ -6574,19 +6378,15 @@ class CallState {
      * @param count the number of anonymous participants.
      */
     setAnonymousParticipantCount = (count) => {
-        return this.setCurrentValue(this.anonymousParticipantCountSubject, count);
+        return setCurrentValue(this.anonymousParticipantCountSubject, count);
     };
-    /**
-     * The list of participants in the current call.
-     */
+    /** The list of participants in the current call. */
     get participants() {
-        return this.getCurrentValue(this.participants$);
+        return getCurrentValue(this.participants$);
     }
-    /**
-     * The stable list of participants in the current call, unsorted.
-     */
+    /** The stable list of participants in the current call, unsorted. */
     get rawParticipants() {
-        return this.getCurrentValue(this.rawParticipants$);
+        return getCurrentValue(this.rawParticipants$);
     }
     /**
      * Returns the current participants array directly from the BehaviorSubject.
@@ -6607,43 +6407,31 @@ class CallState {
      * @param participants the list of participants.
      */
     setParticipants = (participants) => {
-        return this.setCurrentValue(this.participantsSubject, participants);
+        return setCurrentValue(this.participantsSubject, participants);
     };
-    /**
-     * The local participant in the current call.
-     */
+    /** The local participant in the current call. */
     get localParticipant() {
-        return this.getCurrentValue(this.localParticipant$);
+        return getCurrentValue(this.localParticipant$);
     }
-    /**
-     * The list of remote participants in the current call.
-     */
+    /** The list of remote participants in the current call. */
     get remoteParticipants() {
-        return this.getCurrentValue(this.remoteParticipants$);
+        return getCurrentValue(this.remoteParticipants$);
     }
-    /**
-     * The dominant speaker in the current call.
-     */
+    /** The dominant speaker in the current call. */
     get dominantSpeaker() {
-        return this.getCurrentValue(this.dominantSpeaker$);
+        return getCurrentValue(this.dominantSpeaker$);
     }
-    /**
-     * The list of pinned participants in the current call.
-     */
+    /** The list of pinned participants in the current call. */
     get pinnedParticipants() {
-        return this.getCurrentValue(this.pinnedParticipants$);
+        return getCurrentValue(this.pinnedParticipants$);
     }
-    /**
-     * Tell if there is an ongoing screen share in this call.
-     */
+    /** Tell if there is an ongoing screen share in this call. */
     get hasOngoingScreenShare() {
-        return this.getCurrentValue(this.hasOngoingScreenShare$);
+        return getCurrentValue(this.hasOngoingScreenShare$);
     }
-    /**
-     * The calling state.
-     */
+    /** The calling state. */
     get callingState() {
-        return this.getCurrentValue(this.callingState$);
+        return getCurrentValue(this.callingStateSubject);
     }
     /**
      * Sets the calling state.
@@ -6652,13 +6440,11 @@ class CallState {
      * @param state the new calling state.
      */
     setCallingState = (state) => {
-        return this.setCurrentValue(this.callingStateSubject, state);
+        return setCurrentValue(this.callingStateSubject, state);
     };
-    /**
-     * The call stats report.
-     */
+    /** The call stats report. */
     get callStatsReport() {
-        return this.getCurrentValue(this.callStatsReport$);
+        return getCurrentValue(this.callStatsReportSubject);
     }
     /**
      * Returns whether the call stats report is being observed or not.
@@ -6674,13 +6460,11 @@ class CallState {
      * @param report the report to set.
      */
     setCallStatsReport = (report) => {
-        return this.setCurrentValue(this.callStatsReportSubject, report);
+        return setCurrentValue(this.callStatsReportSubject, report);
     };
-    /**
-     * The members of the current call.
-     */
+    /** The members of the current call. */
     get members() {
-        return this.getCurrentValue(this.members$);
+        return getCurrentValue(this.membersSubject);
     }
     /**
      * Sets the members of the current call.
@@ -6689,13 +6473,11 @@ class CallState {
      * @param members the members to set.
      */
     setMembers = (members) => {
-        this.setCurrentValue(this.membersSubject, members);
+        setCurrentValue(this.membersSubject, members);
     };
-    /**
-     * The capabilities of the current user for the current call.
-     */
+    /** The capabilities of the current user for the current call. */
     get ownCapabilities() {
-        return this.getCurrentValue(this.ownCapabilities$);
+        return getCurrentValue(this.ownCapabilities$);
     }
     /**
      * Sets the own capabilities.
@@ -6704,7 +6486,7 @@ class CallState {
      * @param capabilities the capabilities to set.
      */
     setOwnCapabilities = (capabilities) => {
-        return this.setCurrentValue(this.ownCapabilitiesSubject, capabilities);
+        return setCurrentValue(this.ownCapabilitiesSubject, capabilities);
     };
     /**
      * Sets the call grants (used for own capabilities).
@@ -6713,141 +6495,105 @@ class CallState {
      * @param grants the grants to set.
      */
     setCallGrants = (grants) => {
-        return this.setCurrentValue(this.callGrantsSubject, grants);
+        return setCurrentValue(this.callGrantsSubject, grants);
     };
-    /**
-     * The backstage state.
-     */
+    /** The backstage state. */
     get backstage() {
-        return this.getCurrentValue(this.backstage$);
+        return getCurrentValue(this.backstageSubject);
     }
     /**
      * Sets the backstage state.
      * @param backstage the backstage state.
      */
     setBackstage = (backstage) => {
-        return this.setCurrentValue(this.backstageSubject, backstage);
+        return setCurrentValue(this.backstageSubject, backstage);
     };
-    /**
-     * Will provide the list of blocked user IDs.
-     */
+    /** Will provide the list of blocked user IDs. */
     get blockedUserIds() {
-        return this.getCurrentValue(this.blockedUserIds$);
+        return getCurrentValue(this.blockedUserIdsSubject);
     }
-    /**
-     * Will provide the time when this call has been created.
-     */
+    /** Will provide the time when this call has been created. */
     get createdAt() {
-        return this.getCurrentValue(this.createdAt$);
+        return getCurrentValue(this.createdAtSubject);
     }
-    /**
-     * Will provide the time when this call has been ended.
-     */
+    /** Will provide the time when this call has been ended. */
     get endedAt() {
-        return this.getCurrentValue(this.endedAt$);
+        return getCurrentValue(this.endedAtSubject);
     }
     /**
      * Sets the time when this call has been ended.
      * @param endedAt the time when this call has been ended.
      */
     setEndedAt = (endedAt) => {
-        return this.setCurrentValue(this.endedAtSubject, endedAt);
+        return setCurrentValue(this.endedAtSubject, endedAt);
     };
-    /**
-     * Will provide the time when this call has been scheduled to start.
-     */
+    /** Will provide the time when this call has been scheduled to start. */
     get startsAt() {
-        return this.getCurrentValue(this.startsAt$);
+        return getCurrentValue(this.startsAtSubject);
     }
-    /**
-     * Will provide the time when this call has been updated.
-     */
+    /** Will provide the time when this call has been updated. */
     get updatedAt() {
-        return this.getCurrentValue(this.updatedAt$);
+        return getCurrentValue(this.updatedAtSubject);
     }
-    /**
-     * Will provide the user who created this call.
-     */
+    /** Will provide the user who created this call. */
     get createdBy() {
-        return this.getCurrentValue(this.createdBy$);
+        return getCurrentValue(this.createdBySubject);
     }
-    /**
-     * Will provide the custom data of this call.
-     */
+    /** Will provide the custom data of this call. */
     get custom() {
-        return this.getCurrentValue(this.custom$);
+        return getCurrentValue(this.customSubject);
     }
     /**
      * Will provide the egress data of this call.
      */
     get egress() {
-        return this.getCurrentValue(this.egress$);
+        return getCurrentValue(this.egressSubject);
     }
-    /**
-     * Will provide the ingress data of this call.
-     */
+    /** Will provide the ingress data of this call. */
     get ingress() {
-        return this.getCurrentValue(this.ingress$);
+        return getCurrentValue(this.ingressSubject);
     }
-    /**
-     * Will provide the composite recording state of this call.
-     */
+    /** Will provide the composite recording state of this call. */
     get recording() {
-        return this.getCurrentValue(this.recording$);
+        return getCurrentValue(this.recordingSubject);
     }
-    /**
-     * Will provide the individual recording state of this call.
-     */
+    /** Will provide the individual recording state of this call. */
     get individualRecording() {
-        return this.getCurrentValue(this.individualRecording$);
+        return getCurrentValue(this.individualRecordingSubject);
     }
-    /**
-     * Will provide the raw recording state of this call.
-     */
+    /** Will provide the raw recording state of this call. */
     get rawRecording() {
-        return this.getCurrentValue(this.rawRecording$);
+        return getCurrentValue(this.rawRecordingSubject);
     }
-    /**
-     * Will provide the session data of this call.
-     */
+    /** Will provide the session data of this call. */
     get session() {
-        return this.getCurrentValue(this.session$);
+        return getCurrentValue(this.sessionSubject);
     }
-    /**
-     * Will provide the settings of this call.
-     */
+    /** Will provide the settings of this call. */
     get settings() {
-        return this.getCurrentValue(this.settings$);
+        return getCurrentValue(this.settingsSubject);
     }
-    /**
-     * Will provide the transcribing state of this call.
-     */
+    /** Will provide the transcribing state of this call. */
     get transcribing() {
-        return this.getCurrentValue(this.transcribing$);
+        return getCurrentValue(this.transcribingSubject);
     }
-    /**
-     * Whether end-to-end encryption is active for this call.
-     */
+    /** Whether end-to-end encryption is active for this call. */
     get e2eeEnabled() {
-        return this.getCurrentValue(this.e2eeEnabled$);
+        return getCurrentValue(this.e2eeEnabledSubject);
     }
-    /**
-     * Will provide the user who ended this call.
-     */
+    /** Will provide the user who ended this call. */
     get endedBy() {
-        return this.getCurrentValue(this.endedBy$);
+        return getCurrentValue(this.endedBySubject);
     }
     /**
      * Will provide the thumbnails of this call, if enabled in the call settings.
      */
     get thumbnails() {
-        return this.getCurrentValue(this.thumbnails$);
+        return getCurrentValue(this.thumbnailsSubject);
     }
-    /**
-     * Returns the current queue of closed captions.
-     */
+    /** Returns the current queue of closed captions. */
     get closedCaptions() {
-        return this.getCurrentValue(this.closedCaptions$);
+        return getCurrentValue(this.closedCaptionsSubject);
     }
     /**
      * Will try to find the participant with the given sessionId in the current call.
@@ -6858,9 +6604,7 @@ class CallState {
     findParticipantBySessionId = (sessionId) => {
         return this.participants.find((p) => p.sessionId === sessionId);
     };
-    /**
-     * Returns a new lookup table of participants indexed by their session ID.
-     */
+    /** Returns a new lookup table of participants indexed by their session ID. */
     getParticipantLookupBySessionId = () => {
         return this.participants.reduce((lookupTable, participant) => {
             lookupTable[participant.sessionId] = participant;
@@ -7095,25 +6839,49 @@ class CallState {
      */
     updateFromCallResponse = (call) => {
         this.setBackstage(call.backstage);
-        this.setCurrentValue(this.blockedUserIdsSubject, call.blocked_user_ids);
-        this.setCurrentValue(this.createdAtSubject, new Date(call.created_at));
-        this.setCurrentValue(this.updatedAtSubject, new Date(call.updated_at));
-        this.setCurrentValue(this.startsAtSubject, call.starts_at ? new Date(call.starts_at) : undefined);
+        setCurrentValue(this.blockedUserIdsSubject, call.blocked_user_ids);
+        setCurrentValue(this.createdAtSubject, new Date(call.created_at));
+        setCurrentValue(this.updatedAtSubject, new Date(call.updated_at));
+        setCurrentValue(this.startsAtSubject, call.starts_at ? new Date(call.starts_at) : undefined);
         this.setEndedAt(call.ended_at ? new Date(call.ended_at) : undefined);
-        this.setCurrentValue(this.createdBySubject, call.created_by);
-        this.setCurrentValue(this.customSubject, call.custom);
-        this.setCurrentValue(this.egressSubject, call.egress);
-        this.setCurrentValue(this.ingressSubject, call.ingress);
+        setCurrentValue(this.createdBySubject, call.created_by);
+        setCurrentValue(this.customSubject, call.custom);
+        setCurrentValue(this.egressSubject, call.egress);
+        setCurrentValue(this.ingressSubject, call.ingress);
         const { individual_recording, composite_recording, raw_recording } = call.egress;
-        this.setCurrentValue(this.recordingSubject, call.recording || composite_recording?.status === 'running');
-        this.setCurrentValue(this.individualRecordingSubject, individual_recording?.status === 'running');
-        this.setCurrentValue(this.rawRecordingSubject, raw_recording?.status === 'running');
-        const s = this.setCurrentValue(this.sessionSubject, call.session);
+        setCurrentValue(this.recordingSubject, call.recording || composite_recording?.status === 'running');
+        setCurrentValue(this.individualRecordingSubject, individual_recording?.status === 'running');
+        setCurrentValue(this.rawRecordingSubject, raw_recording?.status === 'running');
+        const s = setCurrentValue(this.sessionSubject, call.session);
         this.updateParticipantCountFromSession(s);
-        this.setCurrentValue(this.settingsSubject, call.settings);
-        this.setCurrentValue(this.transcribingSubject, call.transcribing);
-        this.setCurrentValue(this.captioningSubject, call.captioning);
-        this.setCurrentValue(this.thumbnailsSubject, call.thumbnails);
+        setCurrentValue(this.settingsSubject, call.settings);
+        setCurrentValue(this.transcribingSubject, call.transcribing);
+        setCurrentValue(this.captioningSubject, call.captioning);
+        setCurrentValue(this.thumbnailsSubject, call.thumbnails);
+    };
+    /**
+     * Merges a polled ring state into the current session. Only the ring fields
+     * are touched: the endpoint does not return the session roster.
+     *
+     * @internal
+     *
+     * @param ringState the ring state as returned by the coordinator.
+     */
+    updateFromRingState = (ringState) => {
+        setCurrentValue(this.sessionSubject, (session) => {
+            if (!session || session.id !== ringState.session_id)
+                return session;
+            return {
+                ...session,
+                accepted_by: ringState.accepted_by,
+                rejected_by: ringState.rejected_by,
+                missed_by: ringState.missed_by,
+                ended_at: ringState.session_ended_at ?? session.ended_at,
+            };
+        });
+        if (ringState.call_ended_at) {
+            this.setEndedAt(new Date(ringState.call_ended_at));
+        }
     };
     /**
      * Updates the call state with the data received from the SFU server.
@@ -7151,21 +6919,21 @@ class CallState {
         this.setAnonymousParticipantCount(participantCount?.anonymous || 0);
         this.setStartedAt(startedAt ? Timestamp.toDate(startedAt) : new Date());
         this.setServerSidePins(pins);
-        this.setCurrentValue(this.e2eeEnabledSubject, e2EeEnabled);
+        setCurrentValue(this.e2eeEnabledSubject, e2EeEnabled);
     };
     updateFromMemberRemoved = (event) => {
         this.updateFromCallResponse(event.call);
-        this.setCurrentValue(this.membersSubject, (members) => members.filter((m) => event.members.indexOf(m.user_id) === -1));
+        setCurrentValue(this.membersSubject, (members) => members.filter((m) => event.members.indexOf(m.user_id) === -1));
     };
     updateFromMemberAdded = (event) => {
         this.updateFromCallResponse(event.call);
-        this.setCurrentValue(this.membersSubject, (members) => [
+        setCurrentValue(this.membersSubject, (members) => [
             ...members,
             ...event.members,
         ]);
     };
     updateFromHLSBroadcastStopped = () => {
-        this.setCurrentValue(this.egressSubject, (egress = defaultEgress) => ({
+        setCurrentValue(this.egressSubject, (egress = defaultEgress) => ({
             ...egress,
             broadcasting: false,
             hls: {
@@ -7175,7 +6943,7 @@ class CallState {
         }));
     };
     updateFromHLSBroadcastingFailed = () => {
-        this.setCurrentValue(this.egressSubject, (egress = defaultEgress) => ({
+        setCurrentValue(this.egressSubject, (egress = defaultEgress) => ({
             ...egress,
             broadcasting: false,
             hls: {
@@ -7187,13 +6955,13 @@ class CallState {
     updateFromRecordingEvent = (type, running) => {
         // handle the legacy format, where `type` is absent in the emitted events
         if (type === undefined || type === 'composite') {
-            this.setCurrentValue(this.recordingSubject, running);
+            setCurrentValue(this.recordingSubject, running);
         }
         else if (type === 'individual') {
-            this.setCurrentValue(this.individualRecordingSubject, running);
+            setCurrentValue(this.individualRecordingSubject, running);
         }
         else if (type === 'raw') {
-            this.setCurrentValue(this.rawRecordingSubject, running);
+            setCurrentValue(this.rawRecordingSubject, running);
         }
         else {
             ensureExhausted(type, 'Unknown recording type');
@@ -7210,7 +6978,7 @@ class CallState {
         this.setAnonymousParticipantCount(session.anonymous_participant_count || 0);
     };
     updateFromSessionParticipantCountUpdate = (event) => {
-        const s = this.setCurrentValue(this.sessionSubject, (session) => {
+        const s = setCurrentValue(this.sessionSubject, (session) => {
             if (!session)
                 return session;
             return {
@@ -7222,7 +6990,7 @@ class CallState {
         this.updateParticipantCountFromSession(s);
     };
     updateFromSessionParticipantLeft = (event) => {
-        const s = this.setCurrentValue(this.sessionSubject, (session) => {
+        const s = setCurrentValue(this.sessionSubject, (session) => {
             if (!session)
                 return session;
             const { participants, participants_count_by_role } = session;
@@ -7239,7 +7007,7 @@ class CallState {
         this.updateParticipantCountFromSession(s);
     };
     updateFromSessionParticipantJoined = (event) => {
-        const s = this.setCurrentValue(this.sessionSubject, (session) => {
+        const s = setCurrentValue(this.sessionSubject, (session) => {
             if (!session)
                 return session;
             const { participants, participants_count_by_role } = session;
@@ -7276,7 +7044,7 @@ class CallState {
     };
     updateMembers = (event) => {
         this.updateFromCallResponse(event.call);
-        this.setCurrentValue(this.membersSubject, (members) => members.map((member) => {
+        setCurrentValue(this.membersSubject, (members) => members.map((member) => {
             const memberUpdate = event.members.find((m) => m.user_id === member.user_id);
             return memberUpdate ? memberUpdate : member;
         }));
@@ -7301,14 +7069,14 @@ class CallState {
         });
     };
     unblockUser = (event) => {
-        this.setCurrentValue(this.blockedUserIdsSubject, (current) => {
+        setCurrentValue(this.blockedUserIdsSubject, (current) => {
             if (!current)
                 return current;
             return current.filter((id) => id !== event.user.id);
         });
     };
     blockUser = (event) => {
-        this.setCurrentValue(this.blockedUserIdsSubject, (current) => [
+        setCurrentValue(this.blockedUserIdsSubject, (current) => [
             ...(current || []),
             event.user.id,
         ]);
@@ -7319,7 +7087,7 @@ class CallState {
         }
     };
     updateFromClosedCaptions = (event) => {
-        this.setCurrentValue(this.closedCaptionsSubject, (queue) => {
+        setCurrentValue(this.closedCaptionsSubject, (queue) => {
             const { closed_caption } = event;
             const keyOf = (c) => `${c.speaker_id}/${c.start_time}`;
             const currentKey = keyOf(closed_caption);
@@ -7331,7 +7099,7 @@ class CallState {
             // schedule the removal of the closed caption after the retention time
             if (visibilityDurationMs > 0) {
                 const taskId = setTimeout(() => {
-                    this.setCurrentValue(this.closedCaptionsSubject, (captions) => captions.filter((caption) => caption !== closed_caption));
+                    setCurrentValue(this.closedCaptionsSubject, (captions) => captions.filter((caption) => caption !== closed_caption));
                     this.closedCaptionsTasks.delete(currentKey);
                 }, visibilityDurationMs);
                 this.closedCaptionsTasks.set(currentKey, taskId);
@@ -7426,6 +7194,19 @@ const getSdkName = (sdk) => {
 const getSdkVersion = (sdk) => {
     return sdk ? `${sdk.major}.${sdk.minor}.${sdk.patch}` : '0.0.0-development';
 };
+/**
+ * Returns the identifier the SFU receives in the `X-Stream-Client` header,
+ * e.g. `stream-video-react-v1.43.1`. Matches the format the coordinator
+ * already gets through the client's user agent.
+ */
+const getStreamClientId = (sdk) => {
+    const sdkPlatforms = {
+        [SdkType.REACT]: 'react',
+        [SdkType.REACT_NATIVE]: 'react-native',
+    };
+    const platform = (sdk && sdkPlatforms[sdk.type]) || 'js';
+    return `stream-video-${platform}-v${getSdkVersion(sdk)}`;
+};
 
 /**
  * Creates a new StatsReporter instance that collects metrics about the ongoing call and reports them to the state store
@@ -9110,6 +8891,25 @@ class TransceiverCache {
         this.cache.push(bundle);
         this.transceiverOrder.push(bundle.transceiver);
     };
+    /**
+     * Retires a failed sender from the reusable cache.
+     *
+     * A transceiver that never reached an m-section also leaves the creation
+     * history: once stopped, it is left out of every later offer, so counting
+     * it would shift the `mid` index of every transceiver added after it. One
+     * that is already associated keeps its slot, since its m-section survives
+     * as a rejected one.
+     */
+    remove = (transceiver) => {
+        const index = this.cache.findIndex((b) => b.transceiver === transceiver);
+        if (index !== -1)
+            this.cache.splice(index, 1);
+        if (transceiver.mid)
+            return;
+        const orderIndex = this.transceiverOrder.indexOf(transceiver);
+        if (orderIndex !== -1)
+            this.transceiverOrder.splice(orderIndex, 1);
+    };
     /**
      * Gets the transceiver for the given publish option.
      */
@@ -9281,7 +9081,9 @@ class Publisher extends BasePeerConnection {
         const sendEncodings = isSvcCodec(publishOption.codec?.name)
             ? toSvcEncodings(encodings)
             : encodings;
-        const transceiver = this.pc.addTransceiver(track, {
+        // An E2EE sender must never have media before its transform is attached,
+        // including when another track or an ICE restart negotiates this PC.
+        const transceiver = this.pc.addTransceiver(this.e2ee ? track.kind : track, {
             direction: 'sendonly',
             sendEncodings,
         });
@@ -9291,16 +9093,63 @@ class Publisher extends BasePeerConnection {
         this.transceiverCache.add({ publishOption, transceiver, options });
         this.trackIdToTrackType.set(track.id, trackType);
         this.logger.debug(`Added ${TrackType[trackType]} transceiver`);
-        const params = transceiver.sender.getParameters();
+        if (this.e2ee) {
+            await this.initEncryptedSender(transceiver, track, publishOption);
+        }
+        else {
+            await this.setDegradationPreference(transceiver.sender, publishOption);
+        }
+        await this.negotiate();
+    };
+    /**
+     * Attaches the encryptor, applies sender parameters, then attaches the track.
+     *
+     * `encrypt` must run before the first await: Chrome short-circuits a sender
+     * whose encoded streams aren't created in the task that created it, and the
+     * track goes on last so the sender has no media until both steps succeed.
+     */
+    initEncryptedSender = async (transceiver, track, publishOption) => {
+        try {
+            const { sender } = transceiver;
+            const codec = publishOption.codec?.name.toLowerCase();
+            this.e2ee.encrypt(sender, codec, TrackType[publishOption.trackType]);
+            this.logger.debug('E2EE encryptor attached to sender');
+            await this.setDegradationPreference(sender, publishOption);
+            await sender.replaceTrack(track);
+        }
+        catch (err) {
+            this.retireTransceiver(transceiver, track);
+            throw err;
+        }
+    };
+    setDegradationPreference = async (sender, publishOption) => {
+        const params = sender.getParameters();
         params.degradationPreference =
             toRTCDegradationPreference(publishOption.degradationPreference) ??
                 'maintain-framerate';
-        await transceiver.sender.setParameters(params);
-        if (this.e2ee) {
-            this.e2ee.encrypt(transceiver.sender, publishOption.codec?.name.toLowerCase(), TrackType[publishOption.trackType]);
-            this.logger.debug('E2EE encryptor attached to sender');
+        await sender.setParameters(params);
+    };
+    /**
+     * Discards a sender whose E2EE initialization failed.
+     *
+     * A partially initialized sender may carry no transform, so publish() must
+     * not reuse it: retiring it from the cache is what keeps a later publish or
+     * ICE restart from putting cleartext on the wire. Cleanup cannot throw, so
+     * the initialization failure is what reaches the caller.
+     */
+    retireTransceiver = (transceiver, track) => {
+        this.transceiverCache.remove(transceiver);
+        this.trackIdToTrackType.delete(track.id);
+        // on React Native a clone shares its native source, so stopping it here
+        // would stop the track the caller passed in. dispose() releases it.
+        if (!isReactNative())
+            this.stopTrack(track);
+        try {
+            transceiver.stop();
+        }
+        catch (err) {
+            this.logger.debug('Failed to stop a retired transceiver', err);
         }
-        await this.negotiate();
     };
     /**
      * Updates the transceiver with the given track and track type.
@@ -10307,7 +10156,10 @@ class StreamSfuClient {
         this.rpc = createSignalClient({
             baseUrl: server.url,
             interceptors: [
-                withHeaders({ Authorization: `Bearer ${token}` }),
+                withHeaders({
+                    Authorization: `Bearer ${token}`,
+                    'X-Stream-Client': getStreamClientId(getSdkInfo()),
+                }),
                 this.tracer && withRequestTracer(this.tracer.trace),
                 this.logger.getLogLevel() === 'trace' && withRequestLogger(this.logger),
                 withTimeout(rpcRequestTimeout, this.tracer?.trace),
@@ -10610,98 +10462,404 @@ class StreamSfuClient {
             },
         }));
     };
-    send = async (message) => {
-        await this.signalReady(); // wait for the signal ws to be open
-        const msgJson = SfuRequest.toJson(message);
-        if (this.signalWs.readyState !== WebSocket.OPEN) {
-            this.logger.debug('Signal WS is not open. Skipping message', msgJson);
+    send = async (message) => {
+        await this.signalReady(); // wait for the signal ws to be open
+        const msgJson = SfuRequest.toJson(message);
+        if (this.signalWs.readyState !== WebSocket.OPEN) {
+            this.logger.debug('Signal WS is not open. Skipping message', msgJson);
+            return;
+        }
+        this.logger.debug(`Sending message to: ${this.edgeName}`, msgJson);
+        this.signalWs.send(SfuRequest.toBinary(message));
+    };
+    keepAlive = () => {
+        const timers = getTimers();
+        timers.clearInterval(this.keepAliveInterval);
+        this.keepAliveInterval = timers.setInterval(() => {
+            this.ping().catch((e) => {
+                this.logger.error('Error sending healthCheckRequest to SFU', e);
+            });
+        }, this.pingIntervalInMs);
+    };
+    scheduleConnectionCheck = () => {
+        const timers = getTimers();
+        timers.clearInterval(this.connectionCheckInterval);
+        this.connectionCheckInterval = timers.setInterval(() => {
+            if (this.lastMessageTimestamp) {
+                const timeSinceLastMessage = Date.now() - this.lastMessageTimestamp;
+                if (timeSinceLastMessage > this.unhealthyTimeoutInMs) {
+                    this.close(StreamSfuClient.ERROR_CONNECTION_UNHEALTHY, `SFU connection unhealthy. Didn't receive any message for ${this.unhealthyTimeoutInMs}ms`);
+                }
+            }
+        }, this.connectionCheckIntervalInMs);
+    };
+}
+
+/**
+ * Decides what a ringing call should do next, based on the current call state.
+ *
+ * The `call.accepted`, `call.rejected` and `call.missed` handlers and the ring
+ * state poller both run this. They differ only in how the state got there: the
+ * handlers rely on `CallState.updateFromEvent`, which runs before them, and the
+ * poller applies the polled ring state itself.
+ *
+ * @param call the call to reconcile.
+ * @param joinSource which of the two triggered this run, reported on the
+ * caller's join: `ring-ws` for the event handlers, `ring-poll-api` for the
+ * poller.
+ * @returns whether the ring reached a terminal state. A failed join is not
+ * terminal: the caller should keep trying while the ring is open.
+ */
+const reconcileRingState = async (call, joinSource) => {
+    if (call.state.callingState !== CallingState.RINGING)
+        return true;
+    return call.isCreatedByMe
+        ? reconcileAsCaller(call, joinSource)
+        : reconcileAsCallee(call);
+};
+const reconcileAsCaller = async (call, joinSource) => {
+    const { session, members, endedAt } = call.state;
+    const currentUserId = call.currentUserId;
+    // checked before `accepted_by`: an ended session cannot be joined
+    if (endedAt || session?.ended_at) {
+        call.logger.info('ring: the call has ended, leaving');
+        // `leave` reports the remote end to callingx off `reason: 'ended'`
+        return leave(call, {
+            reject: false,
+            reason: 'ended',
+            message: 'ring: call ended',
+        });
+    }
+    const acceptedBy = session?.accepted_by ?? {};
+    if (Object.keys(acceptedBy).some((userId) => userId !== currentUserId)) {
+        call.logger.info('ring: the call was accepted, joining');
+        try {
+            await call.join({ joinSource });
+        }
+        catch (err) {
+            // `doJoin` restores the ringing state when a join fails, so the ring is
+            // still open. Report it unsettled and let the next poll retry.
+            call.logger.error('Failed to join an accepted call', err);
+            return false;
+        }
+        return true;
+    }
+    const otherMembers = members
+        .filter((member) => member.user_id !== currentUserId)
+        .map((member) => member.user_id);
+    if (otherMembers.length === 0)
+        return false;
+    const rejectedBy = session?.rejected_by ?? {};
+    if (otherMembers.every((userId) => rejectedBy[userId])) {
+        call.logger.info('ring: everyone rejected, leaving');
+        return leave(call, {
+            reject: true,
+            reason: 'cancel',
+            message: 'ring: everyone rejected',
+        });
+    }
+    return false;
+};
+// the current user's own accept or reject, on this or another device, is
+// handled by `resolveOwnRingOutcome`, and `call.ended` by `watchCallEnded`.
+const reconcileAsCallee = async (call) => {
+    const createdById = call.state.createdBy?.id;
+    const rejectedBy = call.state.session?.rejected_by ?? {};
+    if (createdById && rejectedBy[createdById]) {
+        call.logger.info('ring: the caller cancelled, leaving');
+        return leave(call, {
+            reason: 'ended',
+            message: 'ring: creator rejected',
+        });
+    }
+    return false;
+};
+// `false` when the call could not be left, so the ring stays open for a retry.
+const leave = async (call, options) => {
+    try {
+        await call.leave(options);
+        return true;
+    }
+    catch (err) {
+        call.logger.error('Failed to leave a ringing call', err);
+        return false;
+    }
+};
+
+// `doJoin` restores the previous calling state when a join fails, so JOINING can
+// go back to RINGING. Only a state the ring cannot return from ends the poller.
+const ringIsOver = (callingState) => callingState !== CallingState.RINGING &&
+    callingState !== CallingState.JOINING;
+/**
+ * Polls the coordinator for the outcome of a ring the current user started.
+ *
+ * `call.accepted`, `call.rejected` and `call.missed` are delivered best-effort,
+ * with no store-and-forward, so a caller that drops one is left on a ringing
+ * screen while the callee is already in the call. After a quiet period this
+ * reads the ring state until a terminal outcome or the end of the ring window.
+ */
+class RingStatePoller {
+    logger = videoLoggerSystem.getLogger('RingStatePoller');
+    call;
+    startAfterMs;
+    intervalMs;
+    sessionId;
+    deadlineAt = 0;
+    idleTimeoutId;
+    intervalId;
+    stopped = false;
+    wasPolling = false;
+    inFlight = false;
+    unsubscribe = [];
+    constructor(call, options = {}) {
+        this.call = call;
+        this.startAfterMs = options.startAfterMs ?? 15_000;
+        this.intervalMs = options.intervalMs ?? 5_000;
+    }
+    /**
+     * Starts polling. Does nothing when the call has no session yet.
+     */
+    start = () => {
+        if (this.stopped || this.sessionId)
+            return;
+        if (this.call.state.callingState !== CallingState.RINGING)
+            return;
+        // captured once: `call.ended` clears the call's current session
+        const sessionId = this.call.state.session?.id;
+        if (!sessionId) {
+            this.logger.warn('the call has no session');
+            return;
+        }
+        this.sessionId = sessionId;
+        const ring = this.call.state.settings?.ring;
+        const maxDurationMs = ring?.auto_cancel_timeout_ms || ring?.missed_call_timeout_ms || 30_000;
+        this.deadlineAt = Date.now() + maxDurationMs;
+        // an incoming event proves the socket is alive, so the quiet period starts
+        // over: in a group ring a single rejection does not settle the ring.
+        this.unsubscribe.push(this.call.on('call.accepted', () => this.armIdleWindow()), this.call.on('call.rejected', () => this.armIdleWindow()), this.call.on('call.missed', () => this.armIdleWindow()), 
+        // the ring is over, whichever way it went. Joining an accepted call
+        // never goes through `leave`, so this is the only signal for it.
+        createSubscription(this.call.state.callingState$, (callingState) => {
+            if (ringIsOver(callingState))
+                this.stop();
+        }));
+        this.armIdleWindow();
+    };
+    /**
+     * Pauses polling, keeping the captured session, the deadline and the event
+     * subscriptions. Resuming does not extend the ring window.
+     */
+    pause = () => {
+        if (this.stopped)
+            return;
+        this.wasPolling = this.intervalId !== undefined;
+        const timers = getTimers();
+        timers.clearTimeout(this.idleTimeoutId);
+        timers.clearInterval(this.intervalId);
+        this.idleTimeoutId = undefined;
+        this.intervalId = undefined;
+    };
+    /**
+     * Resumes a paused poller. Goes straight back to polling if it was already
+     * past the quiet period, so a pause does not buy the ring another one.
+     */
+    resume = () => {
+        if (this.stopped || !this.sessionId)
+            return;
+        if (this.idleTimeoutId !== undefined || this.intervalId !== undefined) {
             return;
         }
-        this.logger.debug(`Sending message to: ${this.edgeName}`, msgJson);
-        this.signalWs.send(SfuRequest.toBinary(message));
+        if (!this.wasPolling) {
+            this.armIdleWindow();
+            return;
+        }
+        this.intervalId = getTimers().setInterval(this.runTick, this.intervalMs);
+        this.runTick();
     };
-    keepAlive = () => {
+    /**
+     * Stops polling. The poller cannot be restarted.
+     */
+    stop = () => {
+        if (this.stopped)
+            return;
+        this.stopped = true;
         const timers = getTimers();
-        timers.clearInterval(this.keepAliveInterval);
-        this.keepAliveInterval = timers.setInterval(() => {
-            this.ping().catch((e) => {
-                this.logger.error('Error sending healthCheckRequest to SFU', e);
-            });
-        }, this.pingIntervalInMs);
+        timers.clearTimeout(this.idleTimeoutId);
+        timers.clearInterval(this.intervalId);
+        this.idleTimeoutId = undefined;
+        this.intervalId = undefined;
+        this.unsubscribe.forEach((off) => off());
+        this.unsubscribe = [];
     };
-    scheduleConnectionCheck = () => {
+    armIdleWindow = () => {
+        if (this.stopped)
+            return;
         const timers = getTimers();
-        timers.clearInterval(this.connectionCheckInterval);
-        this.connectionCheckInterval = timers.setInterval(() => {
-            if (this.lastMessageTimestamp) {
-                const timeSinceLastMessage = Date.now() - this.lastMessageTimestamp;
-                if (timeSinceLastMessage > this.unhealthyTimeoutInMs) {
-                    this.close(StreamSfuClient.ERROR_CONNECTION_UNHEALTHY, `SFU connection unhealthy. Didn't receive any message for ${this.unhealthyTimeoutInMs}ms`);
-                }
-            }
-        }, this.connectionCheckIntervalInMs);
+        timers.clearTimeout(this.idleTimeoutId);
+        timers.clearInterval(this.intervalId);
+        this.intervalId = undefined;
+        this.idleTimeoutId = timers.setTimeout(() => {
+            this.idleTimeoutId = undefined;
+            if (this.stopped)
+                return;
+            this.intervalId = timers.setInterval(this.runTick, this.intervalMs);
+            this.runTick();
+        }, this.startAfterMs);
     };
-}
-
-/**
- * Event handler that watched the delivery of `call.accepted`.
- * Once the event is received, the call is joined.
- */
-const watchCallAccepted = (call) => {
-    return async function onCallAccepted(event) {
-        // We want to discard the event if it's from the current user
-        if (event.user.id === call.currentUserId)
-            return;
-        const { state } = call;
-        if (event.call.created_by.id === call.currentUserId &&
-            state.callingState === CallingState.RINGING) {
-            await call.join();
-        }
+    runTick = () => {
+        this.tick().catch((err) => {
+            this.logger.warn('Failed to poll the ring state', err);
+        });
     };
-};
-/**
- * Event handler that watches delivery of `call.rejected` Websocket event.
- * Once the event is received, the call is left.
- */
-const watchCallRejected = (call) => {
-    return async function onCallRejected(event) {
-        // We want to discard the event if it's from the current user
-        if (event.user.id === call.currentUserId)
+    tick = async () => {
+        if (this.stopped || this.inFlight || !this.sessionId)
             return;
-        const { call: eventCall } = event;
-        const { session: callSession } = eventCall;
-        if (!callSession) {
-            call.logger.warn('No call session provided. Ignoring call.rejected event.', event);
+        const { callingState } = this.call.state;
+        if (ringIsOver(callingState) || Date.now() >= this.deadlineAt) {
+            this.stop();
             return;
         }
-        const rejectedBy = callSession.rejected_by;
-        const { members, callingState } = call.state;
-        if (callingState !== CallingState.RINGING) {
-            call.logger.info('Call is not in ringing mode (it is either accepted or rejected already). Ignoring call.rejected event.', event);
+        // mid-join: nothing to reconcile until we know whether it succeeded
+        if (callingState !== CallingState.RINGING)
             return;
+        this.inFlight = true;
+        try {
+            const ringState = await this.call.getRingState(this.sessionId);
+            if (this.stopped)
+                return;
+            this.call.state.updateFromRingState(ringState);
+            if (await reconcileRingState(this.call, 'ring-poll-api'))
+                this.stop();
         }
-        if (call.isCreatedByMe) {
-            const everyoneElseRejected = members
-                .filter((m) => m.user_id !== call.currentUserId)
-                .every((m) => rejectedBy[m.user_id]);
-            if (everyoneElseRejected) {
-                call.logger.info('everyone rejected, leaving the call');
-                await call.leave({
-                    reject: true,
-                    reason: 'cancel',
-                    message: 'ring: everyone rejected',
-                });
+        catch (err) {
+            // a missing session, or one of another call, will never resolve
+            const status = err instanceof ErrorFromResponse ? err.status : undefined;
+            if (status === 400 || status === 404) {
+                this.logger.warn('Stopped polling the ring state', err);
+                this.stop();
             }
-        }
-        else {
-            if (rejectedBy[eventCall.created_by.id]) {
-                call.logger.info('call creator rejected, leaving call');
-                globalThis.streamRNVideoSDK?.callingX?.endCall(call, 'remote');
-                await call.leave({ message: 'ring: creator rejected' });
+            else {
+                this.logger.debug('Failed to poll the ring state', err);
             }
         }
+        finally {
+            this.inFlight = false;
+        }
+    };
+}
+
+/**
+ * Drops a call that has been ringing for too long: the caller cancels after
+ * `auto_cancel_timeout_ms`, a callee after `incoming_call_timeout_ms`.
+ *
+ * Either timeout being `0` means the call rings until something else settles it.
+ */
+class RingTimeout {
+    call;
+    timeoutId;
+    deadlineAt;
+    stopped = false;
+    constructor(call) {
+        this.call = call;
+    }
+    /**
+     * Schedules an auto-drop timeout based on the call settings.
+     * Applicable only for ringing calls.
+     */
+    start = () => {
+        if (this.stopped || this.timeoutId !== undefined)
+            return;
+        // ignore if the call is not ringing
+        if (this.call.state.callingState !== CallingState.RINGING)
+            return;
+        const ring = this.call.state.settings?.ring;
+        if (!ring)
+            return;
+        const isCaller = this.call.isCreatedByMe;
+        const timeoutMs = isCaller
+            ? ring.auto_cancel_timeout_ms
+            : ring.incoming_call_timeout_ms;
+        // 0 means no auto-drop
+        if (timeoutMs <= 0)
+            return;
+        const now = Date.now();
+        this.deadlineAt ??= now + timeoutMs;
+        const delayMs = Math.max(0, this.deadlineAt - now);
+        const timers = getTimers();
+        this.timeoutId = timers.setTimeout(() => {
+            this.timeoutId = undefined;
+            // A failed timeout-triggered leave can arm a fresh retry window.
+            this.deadlineAt = undefined;
+            if (this.stopped)
+                return;
+            // the call might have stopped ringing by this point, e.g. it was already
+            // accepted and joined
+            if (this.call.state.callingState !== CallingState.RINGING)
+                return;
+            this.call
+                .leave({
+                reject: true,
+                reason: 'timeout',
+                message: `ringing timeout - ${isCaller
+                    ? 'no one accepted'
+                    : `user didn't interact with incoming call screen`}`,
+            })
+                .catch((err) => {
+                videoLoggerSystem
+                    .getLogger('RingTimeout')
+                    .error('Failed to drop the call', err);
+            });
+        }, delayMs);
+    };
+    /**
+     * Pauses the timeout while preserving its original deadline.
+     */
+    pause = () => {
+        if (this.stopped || this.timeoutId === undefined)
+            return;
+        getTimers().clearTimeout(this.timeoutId);
+        this.timeoutId = undefined;
+    };
+    /**
+     * Cancels a scheduled auto-drop timeout. It cannot be armed again.
+     */
+    stop = () => {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        getTimers().clearTimeout(this.timeoutId);
+        this.timeoutId = undefined;
+        this.deadlineAt = undefined;
+    };
+}
+
+/**
+ * Decides what a ringing call should do about the current user's own accept or
+ * reject, which may have happened on another device.
+ *
+ * Accepting on *this* device also lands in `accepted_by`, so an acceptance only
+ * means another device took the call when this one is still ringing.
+ *
+ * Only meaningful for a ringing call; the caller checks that.
+ */
+const resolveOwnRingOutcome = ({ session, currentUserId, callingState, }) => {
+    if (!currentUserId)
+        return { settledByMe: false };
+    const acceptedByMe = Boolean(session?.accepted_by[currentUserId]);
+    const rejectedByMe = Boolean(session?.rejected_by[currentUserId]);
+    if (!acceptedByMe && !rejectedByMe)
+        return { settledByMe: false };
+    const answeredElsewhere = acceptedByMe && callingState === CallingState.RINGING;
+    return {
+        settledByMe: true,
+        leaveReason: answeredElsewhere
+            ? 'answeredElsewhere'
+            : rejectedByMe
+                ? 'rejected'
+                : undefined,
     };
 };
+
 /**
  * Event handler that watches the delivery of `call.ended` Websocket event.
  */
@@ -11102,14 +11260,18 @@ const registerEventHandlers = (call, dispatcher) => {
  * @param call the call to register event handlers for.
  */
 const registerRingingCallEventHandlers = (call) => {
-    const coordinatorRingEvents = {
-        'call.accepted': watchCallAccepted(call),
-        'call.rejected': watchCallRejected(call),
+    const reconcile = () => {
+        reconcileRingState(call, 'ring-ws').catch((err) => {
+            call.logger.error('Failed to reconcile the ring state', err);
+        });
     };
-    const eventHandlers = Object.keys(coordinatorRingEvents).map((event) => {
-        const eventName = event;
-        return call.on(eventName, coordinatorRingEvents[eventName]);
-    });
+    // each event needs its own closure. `call.missed` is deliberately absent:
+    // nothing in the reconciler acts on `missed_by`, so the auto-drop owns the
+    // "nobody answered" case until the server-owned ring timeout lands.
+    const eventHandlers = [
+        call.on('call.accepted', () => reconcile()),
+        call.on('call.rejected', () => reconcile()),
+    ];
     return () => {
         eventHandlers.forEach((unsubscribe) => unsubscribe());
     };
@@ -15157,8 +15319,9 @@ class Call {
     statsReporter;
     sfuStatsReporter;
     lastStatsOptions;
-    dropTimeout;
-    clientStore;
+    ringTimeout;
+    ringStatePoller;
+    clientState;
     streamClient;
     clientEventReporter;
     sfuClient;
@@ -15225,7 +15388,7 @@ class Call {
      * Use the [`StreamVideoClient.call`](./StreamVideoClient.md/#call)
      * method to construct a `Call` instance.
      */
-    constructor({ type, id, streamClient, clientEventReporter, members, ownCapabilities, sortParticipantsBy, clientStore, ringing = false, watching = false, }) {
+    constructor({ type, id, streamClient, clientEventReporter, members, ownCapabilities, sortParticipantsBy, clientState, ringing = false, watching = false, }) {
         this.type = type;
         this.id = id;
         this.cid = `${type}:${id}`;
@@ -15233,7 +15396,7 @@ class Call {
         this.watching = watching;
         this.streamClient = streamClient;
         this.clientEventReporter = clientEventReporter;
-        this.clientStore = clientStore;
+        this.clientState = clientState;
         this.streamClientBasePath = `/call/${this.type}/${this.id}`;
         this.logger = videoLoggerSystem.getLogger('Call');
         const callTypeConfig = CallTypes.get(type);
@@ -15335,27 +15498,24 @@ class Call {
         createSubscription(this.state.session$, (session) => {
             if (!this.ringing)
                 return;
-            const receiverId = this.clientStore.connectedUser?.id;
-            if (!receiverId)
-                return;
-            const isAcceptedByMe = Boolean(session?.accepted_by[receiverId]);
-            const isRejectedByMe = Boolean(session?.rejected_by[receiverId]);
-            if (isAcceptedByMe || isRejectedByMe) {
+            const { settledByMe, leaveReason } = resolveOwnRingOutcome({
+                session,
+                currentUserId: this.currentUserId,
+                callingState: this.state.callingState,
+            });
+            if (settledByMe)
                 this.cancelAutoDrop();
-            }
-            const isAcceptedElsewhere = isAcceptedByMe && this.state.callingState === CallingState.RINGING;
-            if ((isAcceptedElsewhere || isRejectedByMe) &&
-                !hasPending(this.joinLeaveConcurrencyTag)) {
-                globalThis.streamRNVideoSDK?.callingX?.endCall(this, isAcceptedElsewhere ? 'answeredElsewhere' : 'rejected');
-                this.leave().catch(() => {
-                    this.logger.error('Could not leave a call that was accepted or rejected elsewhere');
-                });
-            }
+            if (!leaveReason || hasPending(this.joinLeaveConcurrencyTag))
+                return;
+            globalThis.streamRNVideoSDK?.callingX?.endCall(this, leaveReason);
+            this.leave().catch(() => {
+                this.logger.error('Could not leave a call that was accepted or rejected elsewhere');
+            });
         }));
     };
     handleRingingCall = () => {
         const callSession = this.state.session;
-        const receiver_id = this.clientStore.connectedUser?.id;
+        const receiver_id = this.clientState.connectedUser?.id;
         const ended_at = callSession?.ended_at;
         const created_by_id = this.state.createdBy?.id;
         if (this.currentUserId && created_by_id === this.currentUserId) {
@@ -15396,6 +15556,7 @@ class Call {
                 this.state.setCallingState(CallingState.RINGING);
             }
             this.scheduleAutoDrop();
+            this.scheduleRingStatePolling();
             this.leaveCallHooks.add(registerRingingCallEventHandlers(this));
         }
     };
@@ -15482,6 +15643,12 @@ class Call {
         if (this.state.callingState === CallingState.LEFT) {
             throw new Error('Cannot leave call that has already been left.');
         }
+        // before the first await: the calling state stays RINGING well into the
+        // teardown, so pause both watchdogs before they can race this leave. They
+        // keep their deadlines, so a failed leave resumes them without handing the
+        // ring another window.
+        this.ringTimeout?.pause();
+        this.ringStatePoller?.pause();
         await withoutConcurrency(this.joinLeaveConcurrencyTag, async () => {
             const callingState = this.state.callingState;
             if (callingState === CallingState.LEFT) {
@@ -15548,6 +15715,11 @@ class Call {
             this.audioBindingsWatchdog?.dispose();
             await this.dynascaleManager?.dispose();
             this.state.setCallingState(CallingState.LEFT);
+            // `ringingSubject` is cleared further down, so this still reads true for
+            // a call that was ringing.
+            if (this.ringing) {
+                globalThis.streamRNVideoSDK?.ringingCallLifecycle?.onLeave(this);
+            }
             this.state.setParticipants([]);
             this.state.dispose();
             // Reset reconnect-related accumulators so a future `call.join()` on the
@@ -15571,7 +15743,8 @@ class Call {
             this.unifiedSessionId = undefined;
             this.ringingSubject.next(false);
             this.cancelAutoDrop();
-            this.clientStore.unregisterCall(this);
+            this.cancelRingStatePolling();
+            this.clientState.unregisterCall(this);
             globalThis.streamRNVideoSDK?.callManager.stop({
                 isRingingTypeCall: this.ringing,
                 shouldStopCallManager: this.callManagerStarted,
@@ -15609,6 +15782,15 @@ class Call {
                     this.logger.warn('Failed to dispose media engine', err);
                 });
             }
+        }).catch((err) => {
+            if (!hasPending(this.joinLeaveConcurrencyTag) &&
+                this.state.callingState === CallingState.RINGING) {
+                // resume, never re-arm: a fresh watchdog would restart the ring
+                // window this leave was already most of the way through
+                this.ringTimeout?.start();
+                this.ringStatePoller?.resume();
+            }
+            throw err;
         });
     };
     /**
@@ -15621,7 +15803,7 @@ class Call {
      * Retrieves the current user ID.
      */
     get currentUserId() {
-        return this.clientStore.connectedUser?.id;
+        return this.clientState.connectedUser?.id;
     }
     /**
      * A flag indicating whether self-subscription is enabled for the call.
@@ -15682,8 +15864,8 @@ class Call {
         this.ringingSubject.next(true);
         // we remove the instance from the calls list to enable the following filter in useCalls hook
         // const calls = useCalls().filter((c) => c.ringing);
-        const calls = this.clientStore.calls.filter((c) => c.cid !== this.cid);
-        this.clientStore.setCalls([this, ...calls]);
+        const calls = this.clientState.calls.filter((c) => c.cid !== this.cid);
+        this.clientState.setCalls([this, ...calls]);
         await this.applyDeviceConfig(settings, { publish: false });
     };
     /**
@@ -15706,15 +15888,18 @@ class Call {
      * @param params.video if set to true, in a ringing scenario, mobile SDKs will show "incoming video call", audio only otherwise.
      */
     get = async (params) => {
+        const getLeaveGeneration = this.leaveGeneration;
         await this.setup();
         const response = await this.streamClient.get(this.streamClientBasePath, params);
+        if (this.leaveGeneration !== getLeaveGeneration)
+            return response;
         this.updateFromCallStateResponse(response);
         if (params?.ring) {
             this.ringingSubject.next(true);
         }
         if (this.streamClient._hasConnectionID()) {
             this.watching = true;
-            this.clientStore.registerOrUpdateCall(this);
+            this.clientState.registerOrUpdateCall(this);
         }
         await this.applyDeviceConfig(response.call.settings, { publish: false });
         return response;
@@ -15733,7 +15918,7 @@ class Call {
         }
         if (this.streamClient._hasConnectionID()) {
             this.watching = true;
-            this.clientStore.registerOrUpdateCall(this);
+            this.clientState.registerOrUpdateCall(this);
         }
         await this.applyDeviceConfig(response.call.settings, { publish: false });
         return response;
@@ -15759,6 +15944,21 @@ class Call {
     ring = async (data = {}) => {
         return this.streamClient.post(`${this.streamClientBasePath}/ring`, data);
     };
+    /**
+     * Returns who accepted, rejected or missed the ring for a call session.
+     * Safe to poll: it performs no writes and emits no events.
+     *
+     * @param callSessionId the call session to read. Defaults to the current one.
+     * Pass it explicitly to read a session that has already ended, as ending a
+     * call clears its current session.
+     */
+    getRingState = async (callSessionId) => {
+        const sessionId = callSessionId ?? this.state.session?.id;
+        if (!sessionId) {
+            throw new Error('Cannot read the ring state: the call has no session');
+        }
+        return this.streamClient.get(`${this.streamClientBasePath}/ring_state`, { call_session_id: sessionId });
+    };
     /**
      * A shortcut for {@link Call.get} with `notify` parameter set to `true`.
      * Will send a `call.notification` event to the call members.
@@ -15797,42 +15997,80 @@ class Call {
     /**
      * Will start to watch for call related WebSocket events and initiate a call session with the server.
      *
+     * One instance is one call flow: discard it after leaving, cancelling, or a
+     * failed join, and create a fresh one for a later flow. Reconnection inside a
+     * live call is handled here and needs no new instance.
+     *
      * @returns a promise which resolves once the call join-flow has finished.
      */
-    join = singleFlight(async ({ maxJoinRetries = 3, joinResponseTimeout, rpcRequestTimeout, allowOwnTracksLoopback = false, ...data } = {}) => {
+    join = singleFlight(async ({ maxJoinRetries = 3, joinResponseTimeout, rpcRequestTimeout, allowOwnTracksLoopback = false, joinSource, ...data } = {}) => {
         const callingState = this.state.callingState;
+        // Ahead of the failure boundary below on purpose: a duplicate join on a
+        // live call is refused without tearing that call down.
         if ([CallingState.JOINED, CallingState.JOINING].includes(callingState)) {
             throw new Error(`Illegal State: call.join() shall be called only once`);
         }
+        // snapshot before the first await: a leave() landing at any point from
+        // here on supersedes this join, and the retry loop must bail out instead
+        // of resurrecting a call that leave() already tore down.
+        const joinLeaveGeneration = this.leaveGeneration;
+        const supersededByLeave = () => this.leaveGeneration !== joinLeaveGeneration;
         // we need this to be set before the callingx.joinCall() is
         // called to avoid registering the test call in the CallKit/Telecom
         this.allowOwnTracksLoopback = allowOwnTracksLoopback;
         if (data?.ring) {
             this.ringingSubject.next(true);
         }
+        // A ringing call is joined by the SDK rather than by app code, so React
+        // Native prepares it from in here - there is no earlier point at which the
+        // app holds the call. Read after `data.ring` above, which is what makes an
+        // outgoing call ringing in the first place.
+        const ringingLifecycle = this.ringing
+            ? globalThis.streamRNVideoSDK?.ringingCallLifecycle
+            : undefined;
         const callingX = globalThis.streamRNVideoSDK?.callingX;
-        if (callingX) {
-            // for Android/iOS, we need to start the call in the callingx library as soon as possible
-            await callingX.joinCall(this, this.clientStore.calls);
-        }
-        await this.setup();
-        this.clientEventReporter.registerCall(this.cid, {
-            callType: this.type,
-            callId: this.id,
-            getCallSessionId: () => this.state.session?.id ?? '',
-            getSfuId: () => this.credentials?.server.edge_name ?? '',
-        });
-        this.joinResponseTimeout = joinResponseTimeout;
-        this.rpcRequestTimeout = rpcRequestTimeout;
-        // we will count the number of join failures per SFU.
-        // once the number of failures reaches 2, we will piggyback on the `migrating_from`
-        // field to force the coordinator to provide us another SFU
-        const sfuJoinFailures = new Map();
-        const joinData = data;
-        maxJoinRetries = Math.max(maxJoinRetries, 1);
         try {
-            await this.clientEventReporter.withJoinLifecycle(this.cid, 'first-attempt', async () => {
+            if (ringingLifecycle) {
+                await ringingLifecycle.beforeJoin(this);
+                if (supersededByLeave()) {
+                    this.logger.debug('Join superseded by leave; not joining');
+                    return;
+                }
+            }
+            if (callingX) {
+                // for Android/iOS, we need to start the call in the callingx library as soon as possible
+                await callingX.joinCall(this, this.clientState.calls, supersededByLeave);
+                if (supersededByLeave()) {
+                    this.logger.debug('Join superseded by leave; not setting up');
+                    return;
+                }
+            }
+            await this.setup();
+            if (supersededByLeave()) {
+                this.logger.debug('Join superseded by leave; not registering');
+                return;
+            }
+            this.clientEventReporter.registerCall(this.cid, {
+                callType: this.type,
+                callId: this.id,
+                getCallSessionId: () => this.state.session?.id ?? '',
+                getSfuId: () => this.credentials?.server.edge_name ?? '',
+            });
+            this.joinResponseTimeout = joinResponseTimeout;
+            this.rpcRequestTimeout = rpcRequestTimeout;
+            // we will count the number of join failures per SFU.
+            // once the number of failures reaches 2, we will piggyback on the `migrating_from`
+            // field to force the coordinator to provide us another SFU
+            const sfuJoinFailures = new Map();
+            const joinData = data;
+            maxJoinRetries = Math.max(maxJoinRetries, 1);
+            await this.clientEventReporter.withJoinLifecycle(this.cid, { joinReason: 'first-attempt', joinSource }, async () => {
                 for (let attempt = 0; attempt < maxJoinRetries; attempt++) {
+                    // Also covers a leave that lands during the backoff below.
+                    if (supersededByLeave()) {
+                        this.logger.debug('Join superseded by leave; not attempting');
+                        return;
+                    }
                     try {
                         this.logger.trace(`Joining call (${attempt})`, this.cid);
                         await this.doJoin(data);
@@ -15841,6 +16079,10 @@ class Call {
                         return;
                     }
                     catch (err) {
+                        if (supersededByLeave()) {
+                            this.logger.debug('Join superseded by leave; not retrying');
+                            return;
+                        }
                         this.logger.warn(`Failed to join call (${attempt})`, this.cid);
                         if ((err instanceof ErrorFromResponse && err.unrecoverable) ||
                             (err instanceof SfuJoinError && err.unrecoverable)) {
@@ -15870,6 +16112,9 @@ class Call {
         }
         catch (error) {
             callingX?.endCall(this, 'error');
+            // Ends the failed ringing flow and releases what its setup installed.
+            // Never rejects, so `error` is what the caller sees.
+            await ringingLifecycle?.onJoinFailed(this);
             throw error;
         }
     });
@@ -15892,6 +16137,10 @@ class Call {
         // globals resolve to the call's factory. Idempotent across
         // reconnect/migration attempts.
         await this.ensureMediaFactory();
+        if (supersededByLeave()) {
+            this.logger.debug('Join superseded by leave; not wiring media');
+            return;
+        }
         const callingX = globalThis.streamRNVideoSDK?.callingX;
         if (callingX) {
             callingX.wireAudioEngineSubscription();
@@ -15907,11 +16156,17 @@ class Call {
             data?.migrating_from) {
             try {
                 const joinResponse = await this.clientEventReporter.track(this.cid, 'CoordinatorJoin', () => this.doJoinRequest(data));
+                if (!joinResponse || supersededByLeave()) {
+                    this.logger.debug('Join superseded by leave; not creating SFU client');
+                    return;
+                }
                 this.credentials = joinResponse.credentials;
                 statsOptions = joinResponse.stats_options;
                 this.lastStatsOptions = statsOptions;
             }
             catch (error) {
+                if (supersededByLeave())
+                    return;
                 // prevent triggering reconnect flow if the state is OFFLINE
                 const avoidRestoreState = this.state.callingState === CallingState.OFFLINE;
                 if (!avoidRestoreState) {
@@ -15959,6 +16214,10 @@ class Call {
                 getGenericSdp('recvonly', dangerouslyForceCodec, subscriberFmtpLine),
                 getGenericSdp('sendonly', dangerouslyForceCodec, fmtpLine),
             ]);
+            if (supersededByLeave()) {
+                this.logger.debug('Join superseded by leave; not joining SFU');
+                return;
+            }
             const isReconnecting = this.reconnectStrategy !== WebsocketReconnectStrategy.UNSPECIFIED;
             const reconnectDetails = isReconnecting
                 ? this.getReconnectDetails(previousSfuClient?.edgeName, previousSessionId)
@@ -15984,6 +16243,10 @@ class Call {
                     capabilities,
                     source: ParticipantSource.WEBRTC_UNSPECIFIED,
                 }));
+                if (supersededByLeave()) {
+                    this.logger.debug('Join superseded by leave; not applying SFU response');
+                    return;
+                }
                 this.currentPublishOptions = publishOptions;
                 this.fastReconnectDeadlineSeconds = fastReconnectDeadlineSeconds;
                 if (callState) {
@@ -15991,6 +16254,10 @@ class Call {
                 }
             }
             catch (error) {
+                if (supersededByLeave()) {
+                    this.logger.debug('Join superseded by leave; ignoring SFU failure');
+                    return;
+                }
                 this.logger.warn('Join SFU request failed', error);
                 sfuClient.close(StreamSfuClient.JOIN_FAILED, 'Join request failed, connection considered unhealthy');
                 // restore the previous call state if the join-flow fails
@@ -15998,8 +16265,8 @@ class Call {
                 throw error;
             }
         }
-        // If the user left while this join was in flight, bail before re-setting JOINED and before
-        // peer-connection setup below (both run synchronously after this, so one check covers them).
+        // If the user left while this join was in flight, bail before re-setting JOINED
+        // or starting peer-connection setup below.
         if (supersededByLeave()) {
             this.logger.debug('Join superseded by leave; aborting join flow');
             return;
@@ -16028,6 +16295,10 @@ class Call {
                 unifiedSessionId: this.unifiedSessionId,
             });
         }
+        if (supersededByLeave()) {
+            this.logger.debug('Join superseded by leave; not completing join flow');
+            return;
+        }
         // make sure we only track connection timing if we are not calling this method as part of a reconnection flow
         if (!performingRejoin && !performingFastReconnect && !performingMigration) {
             this.sfuStatsReporter?.sendConnectionTime((Date.now() - connectStartTime) / 1000);
@@ -16173,15 +16444,20 @@ class Call {
      * @internal
      */
     initPublisherAndSubscriber = async (opts) => {
+        const joinLeaveGeneration = this.leaveGeneration;
         const { sfuClient, connectionConfig, clientDetails, statsOptions, publishOptions, closePreviousInstances, unifiedSessionId, } = opts;
         const { enable_rtc_stats: enableTracing, reporting_interval_ms: reportingIntervalMs, } = statsOptions;
         // Flush the previous reporter's final sample while its peer connections are
         // still alive, before we dispose them below. Awaits only the sampling step.
         await this.sfuStatsReporter?.flush();
+        if (this.leaveGeneration !== joinLeaveGeneration)
+            return;
         this.sfuStatsReporter?.stop();
         this.sfuStatsReporter = undefined;
         if (closePreviousInstances && this.subscriber) {
             await this.subscriber.dispose();
+            if (this.leaveGeneration !== joinLeaveGeneration)
+                return;
             this.state.removeAllOrphanedTracks();
         }
         const basePeerConnectionOptions = {
@@ -16224,6 +16500,8 @@ class Call {
         if (!isAnonymous) {
             if (closePreviousInstances && this.publisher) {
                 await this.publisher.dispose();
+                if (this.leaveGeneration !== joinLeaveGeneration)
+                    return;
             }
             this.publisher = new Publisher(basePeerConnectionOptions, publishOptions, {
                 selfSubEnabled: this.allowOwnTracksLoopback,
@@ -16260,12 +16538,22 @@ class Call {
      *
      * @internal
      * @param data the join call data.
+     * @returns The coordinator response, or undefined if leave superseded the request before it was sent.
      */
     doJoinRequest = async (data) => {
+        const joinLeaveGeneration = this.leaveGeneration;
         const location = await this.streamClient.getLocationHint();
+        if (this.leaveGeneration !== joinLeaveGeneration) {
+            this.logger.debug('Join superseded by leave; not sending coordinator request');
+            return;
+        }
         const e2ee = !!this.e2eeManager;
         const request = { ...data, location, e2ee };
         const joinResponse = await this.streamClient.post(`${this.streamClientBasePath}/join`, request);
+        if (this.leaveGeneration !== joinLeaveGeneration) {
+            this.logger.debug('Join superseded by leave; not applying coordinator response');
+            return joinResponse;
+        }
         this.state.updateFromCallResponse(joinResponse.call);
         this.state.setMembers(joinResponse.members);
         this.state.setOwnCapabilities(joinResponse.own_capabilities);
@@ -16276,10 +16564,12 @@ class Call {
         if (!isReconnecting && this.ringing && !this.isCreatedByMe) {
             // signals other users that I have accepted the incoming call.
             await this.accept();
+            if (this.leaveGeneration !== joinLeaveGeneration)
+                return joinResponse;
         }
         if (this.streamClient._hasConnectionID()) {
             this.watching = true;
-            this.clientStore.registerOrUpdateCall(this);
+            this.clientState.registerOrUpdateCall(this);
         }
         return joinResponse;
     };
@@ -16365,6 +16655,7 @@ class Call {
         if (callingState === CallingState.JOINING ||
             callingState === CallingState.RECONNECTING ||
             callingState === CallingState.MIGRATING ||
+            callingState === CallingState.LEFT ||
             callingState === CallingState.RECONNECTING_FAILED)
             return;
         // Drop redundant reconnect calls. If a reconnect is already queued or
@@ -16373,19 +16664,27 @@ class Call {
         // `POST /join` per entry) once the call is already healthy again.
         if (hasPending(this.reconnectConcurrencyTag))
             return;
+        const reconnectLeaveGeneration = this.leaveGeneration;
+        const supersededByLeave = () => this.leaveGeneration !== reconnectLeaveGeneration;
         return withoutConcurrency(this.reconnectConcurrencyTag, async () => {
+            if (supersededByLeave())
+                return;
             const reconnectStartTime = Date.now();
             this.reconnectStrategy = strategy;
             this.reconnectReason = reason;
             const sfuRejoinFailures = new Map();
             const markAsReconnectingFailed = async () => {
+                if (supersededByLeave())
+                    return;
                 try {
                     // attempt to fetch the call data from the server, as the call
                     // state might have changed while we were reconnecting or were offline
                     await this.get();
                 }
                 finally {
-                    this.state.setCallingState(CallingState.RECONNECTING_FAILED);
+                    if (!supersededByLeave()) {
+                        this.state.setCallingState(CallingState.RECONNECTING_FAILED);
+                    }
                 }
             };
             const giveUpAndLeave = async (message) => {
@@ -16441,6 +16740,8 @@ class Call {
                 try {
                     // wait until the network is available
                     await this.networkAvailableTask?.promise;
+                    if (supersededByLeave())
+                        return;
                     this.logger.info(`[Reconnect] Reconnecting with strategy ${WebsocketReconnectStrategy[this.reconnectStrategy]}`);
                     switch (this.reconnectStrategy) {
                         case WebsocketReconnectStrategy.UNSPECIFIED:
@@ -16480,6 +16781,8 @@ class Call {
                     break; // do-while loop, reconnection worked, exit the loop
                 }
                 catch (error) {
+                    if (supersededByLeave())
+                        return;
                     if (attemptedStrategy === WebsocketReconnectStrategy.REJOIN) {
                         const failedSfu = this.credentials?.server.edge_name;
                         if (failedSfu) {
@@ -16510,6 +16813,8 @@ class Call {
                     }
                     // exponential backoff with jitter, capped at 5 s
                     await sleep(retryInterval(attempt));
+                    if (supersededByLeave())
+                        return;
                     const wasMigrating = this.reconnectStrategy === WebsocketReconnectStrategy.MIGRATE;
                     const mustPerformRejoin = (Date.now() - reconnectStartTime) / 1000 >
                         this.fastReconnectDeadlineSeconds;
@@ -16528,7 +16833,8 @@ class Call {
                     this.reconnectStrategy = nextStrategy;
                     this.logger.info(`[Reconnect] ${currentStrategy} (${this.reconnectAttempts}) failed. Attempting with ${WebsocketReconnectStrategy[nextStrategy]}`, error);
                 }
-            } while (this.state.callingState !== CallingState.JOINED &&
+            } while (!supersededByLeave() &&
+                this.state.callingState !== CallingState.JOINED &&
                 this.state.callingState !== CallingState.RECONNECTING_FAILED &&
                 this.state.callingState !== CallingState.LEFT);
             this.logger.info('[Reconnect] Reconnection flow finished');
@@ -16539,10 +16845,13 @@ class Call {
      * @internal
      */
     reconnectFast = async () => {
+        const reconnectLeaveGeneration = this.leaveGeneration;
         const reconnectStartTime = Date.now();
         this.reconnectStrategy = WebsocketReconnectStrategy.FAST;
         this.state.setCallingState(CallingState.RECONNECTING);
         await this.doJoin(this.joinCallData);
+        if (this.leaveGeneration !== reconnectLeaveGeneration)
+            return;
         await this.get(); // fetch the latest call state, as it might have changed
         this.sfuStatsReporter?.sendReconnectionTime(WebsocketReconnectStrategy.FAST, (Date.now() - reconnectStartTime) / 1000);
     };
@@ -16551,14 +16860,19 @@ class Call {
      * @internal
      */
     reconnectRejoin = async () => {
+        const reconnectLeaveGeneration = this.leaveGeneration;
         const reconnectStartTime = Date.now();
         this.reconnectStrategy = WebsocketReconnectStrategy.REJOIN;
         this.state.setCallingState(CallingState.RECONNECTING);
         const joinReason = this.reconnectReason === ReconnectReason.NETWORK_BACK_ONLINE
             ? 'network-available'
             : 'full-rejoin';
-        await this.clientEventReporter.withJoinLifecycle(this.cid, joinReason, () => this.doJoin(this.joinCallData));
+        await this.clientEventReporter.withJoinLifecycle(this.cid, { joinReason }, () => this.doJoin(this.joinCallData));
+        if (this.leaveGeneration !== reconnectLeaveGeneration)
+            return;
         await this.restorePublishedTracks();
+        if (this.leaveGeneration !== reconnectLeaveGeneration)
+            return;
         this.restoreSubscribedTracks();
         this.sfuStatsReporter?.sendReconnectionTime(WebsocketReconnectStrategy.REJOIN, (Date.now() - reconnectStartTime) / 1000);
     };
@@ -16567,6 +16881,7 @@ class Call {
      * @internal
      */
     reconnectMigrate = async () => {
+        const reconnectLeaveGeneration = this.leaveGeneration;
         const reconnectStartTime = Date.now();
         const currentSfuClient = this.sfuClient;
         if (!currentSfuClient) {
@@ -16580,26 +16895,32 @@ class Call {
         currentPublisher?.detachEventHandlers();
         const migrationTask = makeSafePromise(currentSfuClient.enterMigration());
         try {
-            const currentSfu = currentSfuClient.edgeName;
-            await this.clientEventReporter.withJoinLifecycle(this.cid, 'migration', () => 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();
-        try {
+            try {
+                const currentSfu = currentSfuClient.edgeName;
+                await this.clientEventReporter.withJoinLifecycle(this.cid, { joinReason: 'migration' }, () => 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;
+            }
+            if (this.leaveGeneration !== reconnectLeaveGeneration)
+                return;
+            await this.restorePublishedTracks();
+            if (this.leaveGeneration !== reconnectLeaveGeneration)
+                return;
+            this.restoreSubscribedTracks();
             // Wait for the migration to complete, then close the previous SFU client
             // and the peer connection instances. In case of failure, the migration
             // task would throw an error and REJOIN would be attempted.
             await migrationTask();
+            if (this.leaveGeneration !== reconnectLeaveGeneration)
+                return;
             // in MIGRATE, we can consider the call as joined only after
             // `participantMigrationComplete` event is received, signaled by
             // the `migrationTask`
@@ -16884,10 +17205,11 @@ class Call {
      * Must be called before {@link join} so the RTCPeerConnection can be
      * configured for E2EE.
      *
-     * The manager is kept across {@link leave} so a rejoin of this same instance
-     * stays encrypted: do not dispose it while this call may be joined again.
-     * A disposed manager throws from `encrypt`/`decrypt` rather than silently
-     * publishing nothing, so re-attach a fresh one instead of reusing it.
+     * The application owns the manager's lifetime - the SDK never disposes it, and
+     * closing the peer connections does not release it. Discard the manager
+     * together with this call instance once its flow has ended, and create a fresh
+     * pair for a later flow: a disposed manager throws from `encrypt`/`decrypt`
+     * rather than silently publishing nothing.
      *
      * @param e2ee - Any `E2EEManager`. Use `EncryptionManager.create()` for the
      *         built-in AES-GCM scheme, or pass your own implementation.
@@ -16935,7 +17257,7 @@ class Call {
         });
     };
     /**
-     * Will enhance the reported stats with additional participant-specific information (`callStatsReport$` state [store variable](./StreamVideoClient.md/#readonlystatestore)).
+     * Will enhance the reported stats with additional participant-specific information (the `callStatsReport$` state variable).
      * This is usually helpful when detailed stats for a specific participant are needed.
      *
      * @param sessionId the sessionId to start reporting for.
@@ -17354,40 +17676,36 @@ class Call {
      */
     scheduleAutoDrop = () => {
         this.cancelAutoDrop();
-        const settings = this.state.settings;
-        if (!settings)
-            return;
-        // ignore if the call is not ringing
-        if (this.state.callingState !== CallingState.RINGING)
-            return;
-        const timeoutInMs = this.isCreatedByMe
-            ? settings.ring.auto_cancel_timeout_ms
-            : settings.ring.incoming_call_timeout_ms;
-        // 0 means no auto-drop
-        if (timeoutInMs <= 0)
-            return;
-        this.dropTimeout = setTimeout(() => {
-            // the call might have stopped ringing by this point,
-            // e.g. it was already accepted and joined
-            if (this.state.callingState !== CallingState.RINGING)
-                return;
-            this.leave({
-                reject: true,
-                reason: 'timeout',
-                message: `ringing timeout - ${this.isCreatedByMe
-                    ? 'no one accepted'
-                    : `user didn't interact with incoming call screen`}`,
-            }).catch((err) => {
-                this.logger.error('Failed to drop call', err);
-            });
-        }, timeoutInMs);
+        this.ringTimeout = new RingTimeout(this);
+        this.ringTimeout.start();
     };
     /**
      * Cancels a scheduled auto-drop timeout.
      */
     cancelAutoDrop = () => {
-        clearTimeout(this.dropTimeout);
-        this.dropTimeout = undefined;
+        this.ringTimeout?.stop();
+        this.ringTimeout = undefined;
+    };
+    /**
+     * Starts polling for the ring outcome. Applicable only to ringing calls the
+     * current user created.
+     */
+    scheduleRingStatePolling = () => {
+        this.cancelRingStatePolling();
+        if (!this.isCreatedByMe)
+            return;
+        const options = this.streamClient.options.ringStatePolling;
+        if (options === false)
+            return;
+        this.ringStatePoller = new RingStatePoller(this, options);
+        this.ringStatePoller.start();
+    };
+    /**
+     * Cancels the ring state polling.
+     */
+    cancelRingStatePolling = () => {
+        this.ringStatePoller?.stop();
+        this.ringStatePoller = undefined;
     };
     /**
      * Retrieves the list of recordings for the current call or call session.
@@ -19058,11 +19376,11 @@ class StreamClient {
         return await this.wsConnection.connect(this.defaultWSTimeout);
     };
     getSdkVersion = () => this.options.clientAppIdentifier?.sdkVersion ||
-        "2.0.0-beta.0";
+        "2.0.0-beta.1";
     getUserAgent = () => {
         if (!this.cachedUserAgent) {
             const { clientAppIdentifier = {} } = this.options;
-            const { sdkName = 'js', sdkVersion = "2.0.0-beta.0", ...extras } = clientAppIdentifier;
+            const { sdkName = 'js', sdkVersion = "2.0.0-beta.1", ...extras } = clientAppIdentifier;
             this.cachedUserAgent = [
                 `stream-video-${sdkName}-v${sdkVersion}`,
                 ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),
@@ -19195,6 +19513,7 @@ class ClientEventReporter {
     callContexts = new Map();
     joinAttemptIds = new Map();
     joinReasons = new Map();
+    joinSources = new Map();
     coordinatorPairs = new Map();
     wsPairs = new Map();
     peerConnectionPairs = new Map();
@@ -19309,6 +19628,7 @@ class ClientEventReporter {
         this.callContexts.delete(cid);
         this.joinAttemptIds.delete(cid);
         this.joinReasons.delete(cid);
+        this.joinSources.delete(cid);
         this.coordinatorPairs.delete(cid);
         this.wsPairs.delete(cid);
         this.firstFrameReported.delete(`${cid}:FirstVideoFrame`);
@@ -19333,7 +19653,12 @@ class ClientEventReporter {
             this.logger.warn('Failed to start join correlation', err);
         }
     };
-    withJoinLifecycle = async (cid, joinReason, op) => {
+    withJoinLifecycle = async (cid, options, op) => {
+        const { joinReason, joinSource } = options;
+        if (joinSource)
+            this.joinSources.set(cid, joinSource);
+        else
+            this.joinSources.delete(cid);
         this.startCorrelation(cid, joinReason);
         try {
             return await op();
@@ -19342,6 +19667,9 @@ class ClientEventReporter {
             this.closeCallPairs(cid);
             throw err;
         }
+        finally {
+            this.joinSources.delete(cid);
+        }
     };
     track = async (cid, stage, op) => {
         this.beginAttempt(cid, stage);
@@ -19465,6 +19793,7 @@ class ClientEventReporter {
                 startedAt: Date.now(),
                 joinAttemptIdSnapshot: this.joinAttemptIds.get(cid),
                 joinReasonSnapshot: this.joinReasons.get(cid),
+                joinSourceSnapshot: this.joinSources.get(cid),
             };
             this.coordinatorPairs.set(cid, pair);
             this.sendForCall(cid, {
@@ -19472,6 +19801,7 @@ class ClientEventReporter {
                 ...(pair.joinReasonSnapshot && {
                     join_reason: pair.joinReasonSnapshot,
                 }),
+                ...(pair.joinSourceSnapshot && { source: pair.joinSourceSnapshot }),
                 event_type: 'initiated',
             });
         }
@@ -19486,6 +19816,7 @@ class ClientEventReporter {
             ...this.buildCommon(cid, 'CoordinatorJoin', pair),
             ...this.sessionIdField(cid),
             ...(pair.joinReasonSnapshot && { join_reason: pair.joinReasonSnapshot }),
+            ...(pair.joinSourceSnapshot && { source: pair.joinSourceSnapshot }),
             event_type: 'completed',
             outcome: 'success',
             retry_count_attempt: pair.attempts - 1,
@@ -19504,6 +19835,7 @@ class ClientEventReporter {
             ...this.buildCommon(cid, 'CoordinatorJoin', pair),
             ...this.sessionIdField(cid),
             ...(pair.joinReasonSnapshot && { join_reason: pair.joinReasonSnapshot }),
+            ...(pair.joinSourceSnapshot && { source: pair.joinSourceSnapshot }),
             event_type: 'completed',
             outcome: 'failure',
             retry_count_attempt: pair.attempts - 1,
@@ -19804,16 +20136,11 @@ const mapWsJoinError = (err) => {
  */
 class StreamVideoClient {
     /**
-     * A reactive store that exposes all the state variables reactively.
+     * The reactive state of this client.
      * You can subscribe to changes of the different state variables.
-     * Our library is built in a way that all state changes are exposed in this store,
-     * o all UI changes in your application should be handled by subscribing to these variables.
-     *
-     * @deprecated use the `client.state` getter.
      */
-    readOnlyStateStore;
+    state = new ClientState();
     logger;
-    writeableStateStore;
     streamClient;
     clientEventReporter;
     effectsRegistered = false;
@@ -19838,8 +20165,6 @@ class StreamVideoClient {
             streamClient: this.streamClient,
             enabled: clientOptions?.clientEventsReportingEnabled ?? true,
         });
-        this.writeableStateStore = new StreamVideoWriteableStateStore();
-        this.readOnlyStateStore = new StreamVideoReadOnlyStateStore(this.writeableStateStore);
         if (typeof apiKeyOrArgs !== 'string' && apiKeyOrArgs.user) {
             const user = apiKeyOrArgs.user;
             if (user.type === 'anonymous')
@@ -19876,19 +20201,13 @@ class StreamVideoClient {
         }
         StreamVideoClient._instances.set(instanceKey, this);
     };
-    /**
-     * Return the reactive state store, use this if you want to be notified about changes to the client state
-     */
-    get state() {
-        return this.readOnlyStateStore;
-    }
     registerEffects = () => {
         if (this.effectsRegistered)
             return;
         this.eventHandlersToUnregister.push(this.on('call.created', (event) => this.initCallFromEvent(event)), this.on('call.ring', (event) => this.initCallFromEvent(event)), this.on('connection.changed', (event) => {
             if (!event.online)
                 return;
-            const callsToReWatch = this.writeableStateStore.calls
+            const callsToReWatch = this.state.calls
                 .filter((call) => call.watching)
                 .map((call) => call.cid);
             if (callsToReWatch.length <= 0)
@@ -19908,7 +20227,7 @@ class StreamVideoClient {
             const concurrencyTag = getCallInitConcurrencyTag(e.call_cid);
             await withoutConcurrency(concurrencyTag, async () => {
                 const ringing = e.type === 'call.ring';
-                let call = this.writeableStateStore.findCall(e.call.type, e.call.id);
+                let call = this.state.findCall(e.call.type, e.call.id);
                 if (call) {
                     if (ringing) {
                         if (this.shouldRejectCall(call.cid)) {
@@ -19934,7 +20253,7 @@ class StreamVideoClient {
                     type: e.call.type,
                     id: e.call.id,
                     members: e.members,
-                    clientStore: this.writeableStateStore,
+                    clientState: this.state,
                     ringing,
                 });
                 if (ringing) {
@@ -19950,7 +20269,7 @@ class StreamVideoClient {
                 }
                 else {
                     call.state.updateFromCallResponse(e.call);
-                    this.writeableStateStore.registerCall(call);
+                    this.state.registerCall(call);
                     this.logger.info(`New call created and registered: ${call.cid}`);
                 }
             });
@@ -19981,7 +20300,7 @@ class StreamVideoClient {
                     filter_conditions: { cid: { $in: callsToReWatch } },
                 });
                 for (const c of response.calls) {
-                    const call = this.writeableStateStore.findCall(c.call.type, c.call.id);
+                    const call = this.state.findCall(c.call.type, c.call.id);
                     if (call) {
                         call.updateFromCallStateResponse(c);
                     }
@@ -20002,8 +20321,6 @@ class StreamVideoClient {
     };
     /**
      * Connects the given user to the client.
-     * Only one user can connect at a time, if you want to change users, call `disconnectUser` before connecting a new user.
-     * If the connection is successful, the connected user [state variable](#readonlystatestore) will be updated accordingly.
      *
      * @param user the user to connect.
      * @param tokenOrProvider a token or a function that returns a token.
@@ -20047,24 +20364,40 @@ class StreamVideoClient {
         });
         // connectUserResponse will be void if connectUser called twice for the same user
         if (connectUserResponse?.me) {
-            this.writeableStateStore.setConnectedUser(connectUserResponse.me);
+            this.state.setConnectedUser(connectUserResponse.me);
         }
         this.registerEffects();
         return connectUserResponse;
     };
+    /**
+     * Leaves every call this client still tracks. Runs while the coordinator
+     * connection is alive, so that the leave requests each call sends reach the
+     * backend.
+     */
+    leaveAllCalls = async () => {
+        for (const call of this.state.calls) {
+            if (call.state.callingState === CallingState.LEFT)
+                continue;
+            this.logger.info(`User disconnected, leaving call: ${call.cid}`);
+            await call
+                .leave({ message: 'client.disconnectUser() called' })
+                .catch((err) => {
+                this.logger.error(`Error leaving call: ${call.cid}`, err);
+            });
+        }
+    };
     /**
      * Disconnects the currently connected user from the client.
-     *
-     * If the connection is successfully disconnected, the connected user [state variable](#readonlystatestore) will be updated accordingly
+     * Leaves every call the user is still in, and updates `client.state`accordingly.
      *
      * @param timeout Max number of ms, to wait for close event of websocket, before forcefully assuming successful disconnection.
-     *                https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent
      */
     disconnectUser = async (timeout) => {
         await withoutConcurrency(this.connectionConcurrencyTag, async () => {
             const { user, key } = this.streamClient;
             if (!user)
                 return;
+            await this.leaveAllCalls();
             await this.streamClient.disconnectUser(timeout);
             if (user.id) {
                 StreamVideoClient._instances.delete(getInstanceKey(key, user));
@@ -20072,13 +20405,15 @@ class StreamVideoClient {
             this.eventHandlersToUnregister.forEach((unregister) => unregister());
             this.eventHandlersToUnregister = [];
             this.effectsRegistered = false;
-            this.writeableStateStore.setConnectedUser(undefined);
+            this.state.setConnectedUser(undefined);
         });
     };
     /**
      * You can subscribe to WebSocket events provided by the API.
      * To remove a subscription, call the `off` method or, execute the returned unsubscribe function.
-     * Please note that subscribing to WebSocket events is an advanced use-case, for most use-cases it should be enough to watch for changes in the reactive [state store](#readonlystatestore).
+     * Please note that subscribing to WebSocket events is an advanced use-case,
+     * for most use-cases it should be enough to watch for changes in the reactive
+     * `client.state`.
      *
      * @param eventName the event name or 'all'.
      * @param callback the callback which will be called when the event is emitted.
@@ -20105,7 +20440,7 @@ class StreamVideoClient {
      */
     call = (type, id, options = {}) => {
         const call = options.reuseInstance
-            ? this.writeableStateStore.findCall(type, id)
+            ? this.state.findCall(type, id)
             : undefined;
         return (call ??
             new Call({
@@ -20113,7 +20448,7 @@ class StreamVideoClient {
                 clientEventReporter: this.clientEventReporter,
                 id: id,
                 type: type,
-                clientStore: this.writeableStateStore,
+                clientState: this.state,
             }));
     };
     /**
@@ -20143,7 +20478,7 @@ class StreamVideoClient {
                 members: c.members,
                 ownCapabilities: c.own_capabilities,
                 watching: data.watch,
-                clientStore: this.writeableStateStore,
+                clientState: this.state,
             });
             call.state.updateFromCallResponse(c.call);
             await call.applyDeviceConfig(c.call.settings, {
@@ -20152,7 +20487,7 @@ class StreamVideoClient {
             });
             if (data.watch) {
                 await call.setup();
-                this.writeableStateStore.registerCall(call);
+                this.state.registerCall(call);
             }
             calls.push(call);
         }
@@ -20251,7 +20586,7 @@ class StreamVideoClient {
                     clientEventReporter: this.clientEventReporter,
                     type: callType,
                     id: callId,
-                    clientStore: this.writeableStateStore,
+                    clientState: this.state,
                     ringing: true,
                 });
                 await call.get();
@@ -20757,9 +21092,9 @@ class EncryptionManager extends TypedEventEmitter {
         }
         if ((this.piped ??= new WeakSet()).has(target))
             return;
-        this.piped.add(target);
         // @ts-expect-error createEncodedStreams is not in the standard typedefs
         const { readable, writable } = target.createEncodedStreams();
+        this.piped.add(target);
         this.worker.postMessage({ type: 'cmd.setup_transform', ...options, readable, writable }, [readable, writable]);
     };
     /**
@@ -20848,5 +21183,5 @@ var e2eeWorker$1 = /*#__PURE__*/Object.freeze({
     e2eeWorker: e2eeWorker
 });
 
-export { AudioSettingsRequestDefaultDeviceEnum, AudioSettingsResponseDefaultDeviceEnum, browsers as Browsers, Call, CallRecordingFailedEventRecordingTypeEnum, CallRecordingReadyEventRecordingTypeEnum, CallRecordingStartedEventRecordingTypeEnum, CallRecordingStoppedEventRecordingTypeEnum, CallState, CallType, CallTypes, CallingState, CameraManager, CameraManagerState, CreateDeviceRequestPushProviderEnum, DEFAULT_LOOPBACK_RECORDING_DURATION_MS, DebounceType, DeviceManager, DeviceManagerState, DynascaleManager, EncryptionManager, EncryptionSettingsRequestModeEnum, EncryptionSettingsResponseModeEnum, ErrorFromResponse, FrameRecordingSettingsRequestModeEnum, FrameRecordingSettingsRequestQualityEnum, FrameRecordingSettingsResponseModeEnum, HLSSettingsRequestQualityTracksEnum, IndividualRecordingSettingsRequestModeEnum, IndividualRecordingSettingsRequestOutputTypesEnum, IndividualRecordingSettingsResponseModeEnum, IngressAudioEncodingOptionsRequestChannelsEnum, IngressSourceRequestFpsEnum, IngressVideoLayerRequestCodecEnum, LOOPBACK_STREAMS_WAIT_TIMEOUT_MS, LayoutSettingsRequestNameEnum, LoopbackStreamsTimeoutError, MAX_LOOPBACK_RECORDING_DURATION_MS, MIN_LOOPBACK_RECORDING_DURATION_MS, MediaStreamRecorder, MicrophoneManager, MicrophoneManagerState, NoiseCancellationSettingsModeEnum, OwnCapability, RTMPBroadcastRequestQualityEnum, RTMPSettingsRequestQualityEnum, RawRecordingSettingsRequestModeEnum, RawRecordingSettingsResponseModeEnum, RecordSettingsRequestModeEnum, RecordSettingsRequestQualityEnum, RequestPermissionRequestPermissionsEnum, rxUtils as RxUtils, ScreenShareManager, ScreenShareState, events as SfuEvents, SfuJoinError, models as SfuModels, SfuTimeoutError, SpeakerManager, SpeakerState, StartClosedCaptionsRequestLanguageEnum, StartTranscriptionRequestLanguageEnum, StreamSfuClient, StreamVideoClient, StreamVideoReadOnlyStateStore, StreamVideoWriteableStateStore, TranscriptionSettingsRequestClosedCaptionModeEnum, TranscriptionSettingsRequestLanguageEnum, TranscriptionSettingsRequestModeEnum, TranscriptionSettingsResponseClosedCaptionModeEnum, TranscriptionSettingsResponseLanguageEnum, TranscriptionSettingsResponseModeEnum, TranslationSettingsLanguagesEnum, UpdateUserPermissionsRequestGrantPermissionsEnum, UpdateUserPermissionsRequestRevokePermissionsEnum, VideoSettingsRequestCameraFacingEnum, VideoSettingsResponseCameraFacingEnum, ViewportTracker, VisibilityState, WSAuthMessageProductsEnum, checkIfAudioOutputChangeSupported, clampLoopbackRecordingDuration, combineComparators, conditional, createSoundDetector, defaultSortPreset, descending, deviceIds$, disposeOfMediaStream, dominantSpeaker, enableLoopbackAudio, getAudioBrowserPermission, getAudioDevices, getAudioOutputDevices, getAudioStream, getCallMediaEngineProvider, getClientDetails, getDeviceState, getLoopbackStreams, getLoopbackTracks, getScreenShareStream, getSdkInfo, getVideoBrowserPermission, getVideoDevices, getVideoStream, getWebRTCInfo, hasAudio$1 as hasAudio, hasInterruptedTrack, hasPausedTrack, hasScreenShare, hasScreenShareAudio, hasVideo, humanize, isPinned, livestreamOrAudioRoomSortPreset, logToConsole, name, noopComparator, paginatedLayoutSortPreset, pinned, publishing, publishingAudio, publishingVideo, reactionType, resolveDeviceId, role, screenSharing, setCallMediaEngineProvider, setDeviceInfo, setOSInfo, setPowerState, setSdkInfo, setThermalState, setWebRTCInfo, speakerLayoutSortPreset, speaking, videoLoggerSystem, waitForLoopbackStreams, withLoopbackAudioEnabled, withParticipantSource };
+export { AudioSettingsRequestDefaultDeviceEnum, AudioSettingsResponseDefaultDeviceEnum, browsers as Browsers, Call, CallRecordingFailedEventRecordingTypeEnum, CallRecordingReadyEventRecordingTypeEnum, CallRecordingStartedEventRecordingTypeEnum, CallRecordingStoppedEventRecordingTypeEnum, CallState, CallType, CallTypes, CallingState, CameraManager, CameraManagerState, ClientState, CreateDeviceRequestPushProviderEnum, DEFAULT_LOOPBACK_RECORDING_DURATION_MS, DebounceType, DeviceManager, DeviceManagerState, DynascaleManager, EncryptionManager, EncryptionSettingsRequestModeEnum, EncryptionSettingsResponseModeEnum, ErrorFromResponse, FrameRecordingSettingsRequestModeEnum, FrameRecordingSettingsRequestQualityEnum, FrameRecordingSettingsResponseModeEnum, HLSSettingsRequestQualityTracksEnum, IndividualRecordingSettingsRequestModeEnum, IndividualRecordingSettingsRequestOutputTypesEnum, IndividualRecordingSettingsResponseModeEnum, IngressAudioEncodingOptionsRequestChannelsEnum, IngressSourceRequestFpsEnum, IngressVideoLayerRequestCodecEnum, LOOPBACK_STREAMS_WAIT_TIMEOUT_MS, LayoutSettingsRequestNameEnum, LoopbackStreamsTimeoutError, MAX_LOOPBACK_RECORDING_DURATION_MS, MIN_LOOPBACK_RECORDING_DURATION_MS, MediaStreamRecorder, MicrophoneManager, MicrophoneManagerState, NoiseCancellationSettingsModeEnum, OwnCapability, RTMPBroadcastRequestQualityEnum, RTMPSettingsRequestQualityEnum, RawRecordingSettingsRequestModeEnum, RawRecordingSettingsResponseModeEnum, RecordSettingsRequestModeEnum, RecordSettingsRequestQualityEnum, RequestPermissionRequestPermissionsEnum, rxUtils as RxUtils, ScreenShareManager, ScreenShareState, events as SfuEvents, SfuJoinError, models as SfuModels, SfuTimeoutError, SpeakerManager, SpeakerState, StartClosedCaptionsRequestLanguageEnum, StartTranscriptionRequestLanguageEnum, StreamSfuClient, StreamVideoClient, TranscriptionSettingsRequestClosedCaptionModeEnum, TranscriptionSettingsRequestLanguageEnum, TranscriptionSettingsRequestModeEnum, TranscriptionSettingsResponseClosedCaptionModeEnum, TranscriptionSettingsResponseLanguageEnum, TranscriptionSettingsResponseModeEnum, TranslationSettingsLanguagesEnum, TypedEventEmitter, UpdateUserPermissionsRequestGrantPermissionsEnum, UpdateUserPermissionsRequestRevokePermissionsEnum, VideoSettingsRequestCameraFacingEnum, VideoSettingsResponseCameraFacingEnum, ViewportTracker, VisibilityState, WSAuthMessageProductsEnum, checkIfAudioOutputChangeSupported, clampLoopbackRecordingDuration, combineComparators, conditional, createSoundDetector, defaultSortPreset, descending, deviceIds$, disposeOfMediaStream, dominantSpeaker, enableLoopbackAudio, getAudioBrowserPermission, getAudioDevices, getAudioOutputDevices, getAudioStream, getCallMediaEngineProvider, getClientDetails, getDeviceState, getLoopbackStreams, getLoopbackTracks, getScreenShareStream, getSdkInfo, getVideoBrowserPermission, getVideoDevices, getVideoStream, getWebRTCInfo, hasAudio$1 as hasAudio, hasInterruptedTrack, hasPausedTrack, hasScreenShare, hasScreenShareAudio, hasVideo, humanize, isPinned, livestreamOrAudioRoomSortPreset, logToConsole, name, noopComparator, paginatedLayoutSortPreset, pinned, publishing, publishingAudio, publishingVideo, reactionType, resolveDeviceId, role, screenSharing, setCallMediaEngineProvider, setDeviceInfo, setOSInfo, setPowerState, setSdkInfo, setThermalState, setWebRTCInfo, speakerLayoutSortPreset, speaking, videoLoggerSystem, waitForLoopbackStreams, withLoopbackAudioEnabled, withParticipantSource };
 //# sourceMappingURL=index.es.js.map