@stream-io/video-client 1.59.1 → 1.61.0

package/dist/index.browser.es.js

@@ -5081,7 +5081,7 @@ const toIceCandidate = (iceTrickle) => {
     }
 };
 
-const version = "1.59.1";
+const version = "1.61.0";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -7114,6 +7114,30 @@ class CallState {
         this.setCurrentValue(this.captioningSubject, call.captioning);
         this.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) => {
+        this.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.
      *
@@ -7425,6 +7449,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
@@ -9109,6 +9146,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.
      */
@@ -9280,7 +9336,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,
         });
@@ -9290,16 +9348,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.
@@ -10306,7 +10411,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),
@@ -10643,64 +10751,370 @@ class StreamSfuClient {
 }
 
 /**
- * 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();
+ * 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;
 /**
- * Event handler that watches delivery of `call.rejected` Websocket event.
- * Once the event is received, the call is left.
+ * 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.
  */
-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)
+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;
-        const { call: eventCall } = event;
-        const { session: callSession } = eventCall;
-        if (!callSession) {
-            call.logger.warn('No call session provided. Ignoring call.rejected event.', event);
+        // 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;
         }
-        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);
+        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;
         }
-        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',
-                });
-            }
+        if (!this.wasPolling) {
+            this.armIdleWindow();
+            return;
         }
-        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' });
+        this.intervalId = getTimers().setInterval(this.runTick, this.intervalMs);
+        this.runTick();
+    };
+    /**
+     * Stops polling. The poller cannot be restarted.
+     */
+    stop = () => {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        const timers = getTimers();
+        timers.clearTimeout(this.idleTimeoutId);
+        timers.clearInterval(this.intervalId);
+        this.idleTimeoutId = undefined;
+        this.intervalId = undefined;
+        this.unsubscribe.forEach((off) => off());
+        this.unsubscribe = [];
+    };
+    armIdleWindow = () => {
+        if (this.stopped)
+            return;
+        const timers = getTimers();
+        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);
+    };
+    runTick = () => {
+        this.tick().catch((err) => {
+            this.logger.warn('Failed to poll the ring state', err);
+        });
+    };
+    tick = async () => {
+        if (this.stopped || this.inFlight || !this.sessionId)
+            return;
+        const { callingState } = this.call.state;
+        if (ringIsOver(callingState) || Date.now() >= this.deadlineAt) {
+            this.stop();
+            return;
+        }
+        // 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();
+        }
+        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 {
+                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.
  */
@@ -11101,14 +11515,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());
     };
@@ -15156,7 +15574,8 @@ class Call {
     statsReporter;
     sfuStatsReporter;
     lastStatsOptions;
-    dropTimeout;
+    ringTimeout;
+    ringStatePoller;
     clientStore;
     streamClient;
     clientEventReporter;
@@ -15334,22 +15753,19 @@ 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 = () => {
@@ -15395,6 +15811,7 @@ class Call {
                 this.state.setCallingState(CallingState.RINGING);
             }
             this.scheduleAutoDrop();
+            this.scheduleRingStatePolling();
             this.leaveCallHooks.add(registerRingingCallEventHandlers(this));
         }
     };
@@ -15481,6 +15898,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) {
@@ -15547,6 +15970,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
@@ -15570,6 +15998,7 @@ class Call {
             this.unifiedSessionId = undefined;
             this.ringingSubject.next(false);
             this.cancelAutoDrop();
+            this.cancelRingStatePolling();
             this.clientStore.unregisterCall(this);
             globalThis.streamRNVideoSDK?.callManager.stop({
                 isRingingTypeCall: this.ringing,
@@ -15608,6 +16037,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;
         });
     };
     /**
@@ -15705,8 +16143,11 @@ 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);
@@ -15758,6 +16199,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.
@@ -15796,42 +16252,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.clientStore.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);
@@ -15840,6 +16334,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)) {
@@ -15869,6 +16367,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;
         }
     });
@@ -15891,6 +16392,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();
@@ -15906,11 +16411,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) {
@@ -15958,6 +16469,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)
@@ -15983,6 +16498,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) {
@@ -15990,6 +16509,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
@@ -15997,8 +16520,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;
@@ -16027,6 +16550,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);
@@ -16172,15 +16699,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 = {
@@ -16223,6 +16755,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,
@@ -16259,12 +16793,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);
@@ -16275,6 +16819,8 @@ 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;
@@ -16364,6 +16910,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
@@ -16372,19 +16919,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) => {
@@ -16440,6 +16995,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:
@@ -16479,6 +17036,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) {
@@ -16509,6 +17068,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;
@@ -16527,7 +17088,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');
@@ -16538,10 +17100,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);
     };
@@ -16550,14 +17115,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);
     };
@@ -16566,6 +17136,7 @@ class Call {
      * @internal
      */
     reconnectMigrate = async () => {
+        const reconnectLeaveGeneration = this.leaveGeneration;
         const reconnectStartTime = Date.now();
         const currentSfuClient = this.sfuClient;
         if (!currentSfuClient) {
@@ -16579,26 +17150,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`
@@ -16883,10 +17460,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.
@@ -17353,40 +17931,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.
@@ -19059,11 +19633,11 @@ class StreamClient {
         return await this.wsConnection.connect(this.defaultWSTimeout);
     };
     getSdkVersion = () => this.options.clientAppIdentifier?.sdkVersion ||
-        "1.59.1";
+        "1.61.0";
     getUserAgent = () => {
         if (!this.cachedUserAgent) {
             const { clientAppIdentifier = {} } = this.options;
-            const { sdkName = 'js', sdkVersion = "1.59.1", ...extras } = clientAppIdentifier;
+            const { sdkName = 'js', sdkVersion = "1.61.0", ...extras } = clientAppIdentifier;
             this.cachedUserAgent = [
                 `stream-video-${sdkName}-v${sdkVersion}`,
                 ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),
@@ -19196,6 +19770,7 @@ class ClientEventReporter {
     callContexts = new Map();
     joinAttemptIds = new Map();
     joinReasons = new Map();
+    joinSources = new Map();
     coordinatorPairs = new Map();
     wsPairs = new Map();
     peerConnectionPairs = new Map();
@@ -19310,6 +19885,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`);
@@ -19334,7 +19910,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();
@@ -19343,6 +19924,9 @@ class ClientEventReporter {
             this.closeCallPairs(cid);
             throw err;
         }
+        finally {
+            this.joinSources.delete(cid);
+        }
     };
     track = async (cid, stage, op) => {
         this.beginAttempt(cid, stage);
@@ -19466,6 +20050,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, {
@@ -19473,6 +20058,7 @@ class ClientEventReporter {
                 ...(pair.joinReasonSnapshot && {
                     join_reason: pair.joinReasonSnapshot,
                 }),
+                ...(pair.joinSourceSnapshot && { source: pair.joinSourceSnapshot }),
                 event_type: 'initiated',
             });
         }
@@ -19487,6 +20073,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,
@@ -19505,6 +20092,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,
@@ -20758,9 +21346,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]);
     };
     /**
@@ -20816,5 +21404,5 @@ class EncryptionManager extends TypedEventEmitter {
     };
 }
 
-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, 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, 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.browser.es.js.map