@stream-io/video-client 1.54.1-beta.0 → 1.55.0

package/dist/src/Call.d.ts

@@ -129,7 +129,7 @@ export declare class Call {
     private joinResponseTimeout?;
     private rpcRequestTimeout?;
     private joinCallData?;
-    private selfSubEnabled;
+    private allowOwnTracksLoopback;
     private hasJoinedOnce;
     private deviceSettingsAppliedOnce;
     private credentials?;
@@ -196,7 +196,7 @@ export declare class Call {
     /**
      * A flag indicating whether self-subscription is enabled for the call.
      */
-    get isSelfSubEnabled(): boolean;
+    get isOwnTracksLoopbackAllowed(): boolean;
     /**
      * The largest video publish dimension across the current publish options.
      *
@@ -275,11 +275,11 @@ export declare class Call {
      *
      * @returns a promise which resolves once the call join-flow has finished.
      */
-    join: ({ maxJoinRetries, joinResponseTimeout, rpcRequestTimeout, selfSubEnabled, ...data }?: JoinCallData & {
+    join: ({ maxJoinRetries, joinResponseTimeout, rpcRequestTimeout, allowOwnTracksLoopback, ...data }?: JoinCallData & {
         maxJoinRetries?: number;
         joinResponseTimeout?: number;
         rpcRequestTimeout?: number;
-        selfSubEnabled?: boolean;
+        allowOwnTracksLoopback?: boolean;
     }) => Promise<void>;
     /**
      * Will make a single attempt to watch for call related WebSocket events

package/dist/src/StreamSfuClient.d.ts

@@ -87,12 +87,20 @@ export declare class StreamSfuClient {
      * trigger a reconnection attempt.
      */
     isClosingClean: boolean;
+    /**
+     * One-shot latch guarding `onSignalClose`. The signal connection can be
+     * detected as dead by more than one source (the health watchdog and the
+     * WebSocket `close` event, which on a wedged socket can arrive seconds
+     * apart). This ensures revival is triggered at most once per client.
+     */
+    private signalClosed;
     private readonly rpc;
     private keepAliveInterval?;
-    private connectionCheckTimeout?;
+    private connectionCheckInterval?;
     private migrateAwayTimeout?;
     private readonly pingIntervalInMs;
     private readonly unhealthyTimeoutInMs;
+    private readonly connectionCheckIntervalInMs;
     private lastMessageTimestamp?;
     private readonly tracer?;
     private readonly unsubscribeIceTrickle;
@@ -127,7 +135,7 @@ export declare class StreamSfuClient {
     /**
      * The error code used when the SFU connection is unhealthy.
      * Usually, this means that no message has been received from the SFU for
-     * a certain amount of time (`connectionCheckTimeout`).
+     * a certain amount of time (`unhealthyTimeoutInMs`).
      */
     static ERROR_CONNECTION_UNHEALTHY: number;
     /**
@@ -154,7 +162,7 @@ export declare class StreamSfuClient {
     private createWebSocket;
     get isHealthy(): boolean;
     get joinTask(): Promise<JoinResponse>;
-    private handleWebSocketClose;
+    private notifySignalClose;
     close: (code?: number, reason?: string) => void;
     private dispose;
     getTrace: () => TraceSlice | undefined;

package/dist/src/coordinator/connection/connection.d.ts

@@ -44,7 +44,7 @@ export declare class StableWSConnection {
     pingInterval: number;
     healthCheckTimeoutRef?: number;
     connectionCheckTimeout: number;
-    connectionCheckTimeoutRef?: NodeJS.Timeout;
+    connectionCheckTimeoutRef?: number;
     /** Store the last event time for health checks */
     lastEvent: Date | null;
     constructor(client: StreamClient);

package/dist/src/reporting/ClientEventReporter.d.ts

@@ -82,5 +82,6 @@ export declare class ClientEventReporter {
     private sessionIdField;
     private buildCommon;
     private send;
+    private sendForCall;
     private sendWithRetry;
 }

package/dist/src/rtc/BasePeerConnection.d.ts

@@ -5,7 +5,7 @@ import { PeerType, TrackType } from '../gen/video/sfu/models/models';
 import { StreamSfuClient } from '../StreamSfuClient';
 import { AllSfuEvents, Dispatcher } from './Dispatcher';
 import { StatsTracer, Tracer } from '../stats';
-import { BasePeerConnectionOpts, OnRemoteTrackUnmute } from './types';
+import { BasePeerConnectionOpts, OnReconnectionNeeded, OnRemoteTrackUnmute } from './types';
 import type { ClientPublishOptions } from '../types';
 /**
  * A base class for the `Publisher` and `Subscriber` classes.
@@ -20,7 +20,7 @@ export declare abstract class BasePeerConnection {
     protected readonly clientPublishOptions?: ClientPublishOptions;
     protected tag: string;
     protected sfuClient: StreamSfuClient;
-    private onReconnectionNeeded?;
+    protected onReconnectionNeeded?: OnReconnectionNeeded;
     private onIceConnected?;
     private onPeerConnectionStateChange?;
     protected onRemoteTrackUnmute?: OnRemoteTrackUnmute;
@@ -95,21 +95,11 @@ export declare abstract class BasePeerConnection {
      * it returns `false`, otherwise it returns `true`.
      */
     isHealthy: () => boolean;
-    /**
-     * Returns true only when the peer connection is currently fully established
-     * (ICE `connected`/`completed` AND connection state `connected`).
-     * Transient states like `disconnected`, `checking`, or `new` return false.
-     */
-    isStable: () => boolean;
     /**
      * Handles the ICECandidate event and
      * Initiates an ICE Trickle process with the SFU.
      */
     private onIceCandidate;
-    /**
-     * Converts the ICE candidate to a JSON string.
-     */
-    private asJSON;
     /**
      * Handles the ConnectionStateChange event.
      */

package/dist/src/rtc/IceTrickleBuffer.d.ts

@@ -1,12 +1,50 @@
-import { ReplaySubject } from 'rxjs';
+import { Observable } from 'rxjs';
 import { ICETrickle } from '../gen/video/sfu/event/events';
+import { PeerType } from '../gen/video/sfu/models/models';
 /**
  * A buffer for ICE Candidates. Used for ICE Trickle:
  * - https://bloggeek.me/webrtcglossary/trickle-ice/
+ *
+ * The buffer is generation-aware: each peer connection tells it which ICE
+ * generation is current via `updateActiveGeneration` (whenever it applies an
+ * offer/answer). Candidate streams then emit only candidates of the active
+ * generation, hold candidates of a not-yet-applied (future) generation until
+ * it becomes active, and drop candidates of a superseded generation so they
+ * are never replayed. Candidates with no detectable generation, or before any
+ * generation is set, are emitted as-is (fail open).
  */
 export declare class IceTrickleBuffer {
-    readonly subscriberCandidates: ReplaySubject<RTCIceCandidateInit>;
-    readonly publisherCandidates: ReplaySubject<RTCIceCandidateInit>;
+    readonly subscriber: CandidateGenerationBuffer;
+    readonly publisher: CandidateGenerationBuffer;
     push: (iceTrickle: ICETrickle) => void;
+    /**
+     * Declares the ICE generation that is now current for the given peer type,
+     * derived from the `ice-ufrag` of the just-applied remote description.
+     * Candidates of superseded generations are evicted; candidates of the active
+     * generation flow to subscribers.
+     */
+    updateActiveGeneration: (peerType: PeerType, sdp: string | undefined) => void;
     dispose: () => void;
 }
+/**
+ * Per-peer-connection generation-aware candidate store. Retains trickled
+ * candidates and replays the active generation to each new subscriber, then
+ * forwards matching live candidates.
+ */
+declare class CandidateGenerationBuffer {
+    private readonly store;
+    private readonly live;
+    private readonly seenUfrags;
+    private activeUfrag;
+    readonly candidates: Observable<RTCIceCandidateInit>;
+    push: (candidate: RTCIceCandidateInit) => void;
+    updateActiveGeneration: (ufrag: string | undefined) => void;
+    dispose: () => void;
+    /**
+     * A candidate belongs to the current generation when its ufrag matches the
+     * active one. Fail open when either the candidate's generation or the active
+     * generation is unknown, so untagged candidates are never withheld.
+     */
+    private isCurrent;
+}
+export {};

package/dist/src/rtc/Publisher.d.ts

@@ -1,6 +1,6 @@
+import { PublishOption, TrackInfo, TrackType } from '../gen/video/sfu/models/models';
 import { BasePeerConnection } from './BasePeerConnection';
 import type { BasePeerConnectionOpts, TrackPublishOptions } from './types';
-import { PublishOption, TrackInfo, TrackType } from '../gen/video/sfu/models/models';
 /**
  * The `Publisher` is responsible for publishing/unpublishing media streams to/from the SFU
  *

package/dist/src/rtc/Subscriber.d.ts

@@ -13,7 +13,8 @@ export declare class Subscriber extends BasePeerConnection {
      * The map will never contain local streams so we can safely use it to
      * check if the stream is remote and dispose it when needed.
      */
-    private trackedStreams;
+    private trackedStreams?;
+    private negotiationFailures;
     /**
      * Constructs a new `Subscriber` instance.
      */

package/dist/src/rtc/helpers/iceCandiates.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Converts the ICE candidate to a JSON string.
+ */
+export declare const toJSON: (candidate: RTCIceCandidate) => string;
+/**
+ * Extracts the ICE ufrag from an SDP, or `undefined` when absent.
+ */
+export declare const parseIceUfrag: (sdp: string | undefined) => string | undefined;
+/**
+ * Extracts the ICE ufrag (generation) a trickled candidate was gathered under.
+ */
+export declare const getCandidateUfrag: (ice: RTCIceCandidateInit) => string | undefined;

package/dist/src/rtc/types.d.ts

@@ -21,6 +21,8 @@ export declare const ReconnectReason: {
     readonly CONNECTION_FAILED: "connection_failed";
     /** `restartIce()` rejected. */
     readonly RESTART_ICE_FAILED: "restart_ice_failed";
+    /** Subscriber renegotiation kept failing, escalate to REJOIN. */
+    readonly SUBSCRIBER_NEGOTIATION_FAILED: "subscriber_negotiation_failed";
     /** SFU `goAway` event, migrate to a new SFU. */
     readonly GO_AWAY: "go_away";
     /** Network came back online after going offline. */

package/dist/src/stats/SfuStatsReporter.d.ts

@@ -36,14 +36,45 @@ export declare class SfuStatsReporter {
     private readonly sdkVersion;
     private readonly webRTCVersion;
     private readonly inputDevices;
+    private readonly statsConcurrencyTag;
+    private isStopped;
     constructor(sfuClient: StreamSfuClient, { options, clientDetails, subscriber, publisher, microphone, camera, state, tracer, unifiedSessionId, }: SfuStatsReporterOptions);
     private observeDevice;
     sendConnectionTime: (connectionTimeSeconds: number) => void;
     sendReconnectionTime: (strategy: WebsocketReconnectStrategy, timeSeconds: number) => void;
     private sendTelemetryData;
+    /**
+     * Samples both peer connections. Each `StatsTracer.takeSample()` is serialized
+     * internally, so this is safe even if it overlaps another sample (e.g. the
+     * connection-state-change handler). Kept separate from `send()` so an
+     * explicit flush can capture the sample from live peer connections before
+     * they are disposed, without waiting for an in-flight send.
+     */
+    private sample;
+    private send;
+    /**
+     * Samples and sends one report. Used by the scheduler and the telemetry path.
+     * Bails if the reporter has been stopped so it never samples disposed peer
+     * connections.
+     */
     private run;
     private scheduleNextReport;
     start: () => void;
     stop: () => void;
-    flush: () => void;
+    /**
+     * Explicit/final flush (leave, migration, re-init). Time-boxes the sampling
+     * step and swallows its failures, so a slow or failing `getStats()` on a
+     * degraded or closing peer connection can never block or reject call teardown
+     * or reconnect setup. On a successful sample it fires the send best-effort;
+     * the returned promise resolves once the sample is taken (or the time-box
+     * elapses / sampling fails), never when the sending completes. No-op once the
+     * reporter has been stopped.
+     */
+    flush: () => Promise<void>;
+    /**
+     * Flush entry for the periodic scheduler. Skips when the reporter is stopped
+     * or a send is already in flight so ticks can't pile up under slow sends (the
+     * next sample's delta spans the skipped interval).
+     */
+    private scheduledFlush;
 }

package/dist/src/stats/rtc/StatsTracer.d.ts

@@ -1,5 +1,5 @@
 import { PeerType, TrackType } from '../../gen/video/sfu/models/models';
-import type { ComputedStats } from './types';
+import type { ComputedStats, PendingDelta } from './types';
 /**
  * StatsTracer is a class that collects and processes WebRTC stats.
  * It is used to track the performance of the WebRTC connection
@@ -13,23 +13,53 @@ export declare class StatsTracer {
     private readonly peerType;
     private readonly trackIdToTrackType;
     private readonly driftThresholdMs;
+    private readonly maxPendingDeltas;
+    private readonly sampleTag;
     private costOverrides?;
-    private previousStats;
+    private previousSample;
     private frameTimeHistory;
     private fpsHistory;
+    /**
+     * The un-acked, delta-compressed samples awaiting delivery confirmation.
+     * Each entry's delta is computed against the immediately preceding sample,
+     * so the list forms a chain the server applies in order. The delivery
+     * baseline advances only when the reporter calls `commitDeltas` after a
+     * successful send; until then the chain is re-sent in full.
+     */
+    private pendingDeltas;
     /**
      * Creates a new StatsTracer instance.
      */
-    constructor(pc: RTCPeerConnection, peerType: PeerType, trackIdToTrackType: Map<string, TrackType>, statsTimestampDriftThresholdMs?: number);
+    constructor(pc: RTCPeerConnection, peerType: PeerType, trackIdToTrackType: Map<string, TrackType>, statsTimestampDriftThresholdMs?: number, maxPendingDeltas?: number);
+    /**
+     * Samples the RTCPeerConnection: returns the current stats report and the
+     * derived performance stats, and appends the delta-compressed sample to the
+     * un-acked delivery chain (retrieved via `getPendingDeltas`).
+     *
+     * @internal
+     */
+    takeSample: () => Promise<ComputedStats>;
+    /**
+     * Returns a stable copy of the un-acked delta chain to transmit, oldest first.
+     *
+     * @internal
+     */
+    getPendingDeltas: () => PendingDelta[];
+    /**
+     * Advances the delivery baseline by dropping exactly the deltas that were
+     * confirmed delivered. Matching is by object identity, so a stale commit
+     * that arrives after a re-anchor (which replaced the chain) is a safe no-op.
+     *
+     * @internal
+     */
+    commitDeltas: (sent: PendingDelta[]) => void;
     /**
-     * Get the stats from the RTCPeerConnection.
-     * When called, it will return the stats for the current connection.
-     * It will also return the delta between the current stats and the previous stats.
-     * This is used to track the performance of the connection.
+     * Drops the un-acked chain without sending it. Used when delta reporting is
+     * disabled so the chain can't grow unbounded.
      *
      * @internal
      */
-    get: () => Promise<ComputedStats>;
+    clearPendingDeltas: () => void;
     /**
      * Collects encode stats from the RTCPeerConnection.
      */

package/dist/src/stats/rtc/Tracer.d.ts

@@ -2,13 +2,20 @@ import type { RTCStatsDataType, Trace, TraceKey, TraceSlice } from './types';
 export declare class Tracer {
     private buffer;
     private enabled;
-    private readonly id;
+    readonly id: string | null;
+    private readonly maxBuffer;
     private keys?;
-    constructor(id: string | null);
+    constructor(id: string | null, maxBuffer?: number);
     setEnabled: (enabled: boolean) => void;
     trace: Trace;
     traceOnce: (key: TraceKey, tag: string, data: RTCStatsDataType) => void;
     resetTrace: (key: TraceKey) => void;
     take: () => TraceSlice;
     dispose: () => void;
+    /**
+     * Bounds the buffer to 2500 records by dropping the oldest ones,
+     * leaving a single `traceBufferOverflow` breadcrumb at the front so the
+     * consumer knows records were dropped.
+     */
+    private capBuffer;
 }

package/dist/src/stats/rtc/types.d.ts

@@ -17,12 +17,18 @@ export type ComputedStats = {
      * Current stats from the RTCPeerConnection.
      */
     stats: RTCStatsReport;
-    /**
-     * Delta between the current stats and the previous stats.
-     */
-    delta: Record<any, any>;
     /**
      * The current iteration of the stats.
      */
     performanceStats: PerformanceStats[];
 };
+/**
+ * A single, not-yet-delivered delta-compressed stats sample.
+ * The `delta` is computed against the immediately preceding sample, so a
+ * sequence of `PendingDelta`s forms a chain that the server applies in order
+ * onto its running accumulator. `ts` is the wall-clock time the sample was taken.
+ */
+export type PendingDelta = {
+    delta: Record<any, any>;
+    ts: number;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.54.1-beta.0",
+  "version": "1.55.0",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
   "browser": "dist/index.browser.es.js",
@@ -46,9 +46,11 @@
     "@openapitools/openapi-generator-cli": "^2.34.0",
     "@rollup/plugin-replace": "^6.0.3",
     "@rollup/plugin-typescript": "^12.3.0",
-    "@stream-io/audio-filters-web": "^0.8.2",
+    "@stream-io/audio-filters-web": "^0.9.0",
     "@stream-io/node-sdk": "^0.7.59",
+    "@stream-io/typescript-config": "^0.0.0",
     "@total-typescript/shoehorn": "^0.1.2",
+    "@types/node": "^25.9.3",
     "@types/sdp-transform": "^2.15.0",
     "@types/ua-parser-js": "^0.7.39",
     "@vitest/coverage-v8": "^4.1.7",
@@ -57,7 +59,7 @@
     "prettier": "^3.8.3",
     "rimraf": "^6.1.3",
     "rollup": "^4.60.4",
-    "typescript": "^5.9.3",
+    "typescript": "^6.0.3",
     "vitest": "^4.1.7",
     "vitest-mock-extended": "^4.0.0"
   }

package/src/Call.ts

@@ -325,7 +325,7 @@ export class Call {
   private joinResponseTimeout?: number;
   private rpcRequestTimeout?: number;
   private joinCallData?: JoinCallData;
-  private selfSubEnabled = false;
+  private allowOwnTracksLoopback = false;
   private hasJoinedOnce = false;
   private deviceSettingsAppliedOnce = false;
   private credentials?: Credentials;
@@ -741,7 +741,9 @@ export class Call {
 
       const leaveReason = message ?? reason ?? 'user is leaving the call';
       this.tracer.trace('call.leaveReason', leaveReason);
-      this.sfuStatsReporter?.flush();
+      // await the final sample so it's captured from the still-live peer
+      // connections (disposed below); the send itself stays best-effort.
+      await this.sfuStatsReporter?.flush();
       this.sfuStatsReporter?.stop();
       this.sfuStatsReporter = undefined;
       this.lastStatsOptions = undefined;
@@ -788,6 +790,7 @@ export class Call {
       this.leaveCallHooks.forEach((hook) => hook());
       this.initialized = false;
       this.hasJoinedOnce = false;
+      this.allowOwnTracksLoopback = false;
       this.unifiedSessionId = undefined;
       this.ringingSubject.next(false);
       this.cancelAutoDrop();
@@ -834,8 +837,8 @@ export class Call {
   /**
    * A flag indicating whether self-subscription is enabled for the call.
    */
-  get isSelfSubEnabled() {
-    return this.selfSubEnabled;
+  get isOwnTracksLoopbackAllowed() {
+    return this.allowOwnTracksLoopback;
   }
 
   /**
@@ -1074,13 +1077,13 @@ export class Call {
     maxJoinRetries = 3,
     joinResponseTimeout,
     rpcRequestTimeout,
-    selfSubEnabled = false,
+    allowOwnTracksLoopback = false,
     ...data
   }: JoinCallData & {
     maxJoinRetries?: number;
     joinResponseTimeout?: number;
     rpcRequestTimeout?: number;
-    selfSubEnabled?: boolean;
+    allowOwnTracksLoopback?: boolean;
   } = {}): Promise<void> => {
     const callingState = this.state.callingState;
 
@@ -1088,14 +1091,14 @@ export class Call {
       throw new Error(`Illegal State: call.join() shall be called only once`);
     }
 
+    // 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);
     }
 
-    // we need this to be set before the callingx.joinCall() is
-    // called to avoid registering the test call in the CallKit/Telecom
-    this.selfSubEnabled = selfSubEnabled;
-
     const callingX = globalThis.streamRNVideoSDK?.callingX;
     if (callingX) {
       // for Android/iOS, we need to start the call in the callingx library as soon as possible
@@ -1330,23 +1333,9 @@ export class Call {
     // when performing fast reconnect, or when we reuse the same SFU client,
     // (ws remained healthy), we just need to restore the ICE connection
     if (performingFastReconnect) {
-      // The SFU automatically issues an ICE restart on the subscriber,
-      // so we only need to decide about the publisher. If the publisher's
-      // peer connection is still stable (ICE still connected end-to-end),
-      // the signal WebSocket drop was the only problem — the new WS alone
-      // is enough, and restarting ICE would add unnecessary SDP/ICE churn.
-      const publisherIsStable = this.publisher?.isStable() ?? true;
-      const includePublisher =
-        !!this.publisher?.isPublishing() && !publisherIsStable;
-      if (!includePublisher && this.publisher?.isPublishing()) {
-        this.logger.info(
-          '[Reconnect] FAST: skipping publisher ICE restart, publisher PC is stable',
-        );
-      }
-      await this.restoreICE(sfuClient, {
-        includeSubscriber: false,
-        includePublisher,
-      });
+      // the SFU automatically issues an ICE restart on the subscriber
+      // we don't have to do it ourselves
+      await this.restoreICE(sfuClient, { includeSubscriber: false });
     } else {
       const connectionConfig = toRtcConfiguration(this.credentials.ice_servers);
       await this.initPublisherAndSubscriber({
@@ -1545,6 +1534,11 @@ export class Call {
       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();
+    this.sfuStatsReporter?.stop();
+    this.sfuStatsReporter = undefined;
     if (closePreviousInstances && this.subscriber) {
       await this.subscriber.dispose();
     }
@@ -1596,7 +1590,7 @@ export class Call {
         basePeerConnectionOptions,
         publishOptions,
         {
-          selfSubEnabled: this.selfSubEnabled,
+          selfSubEnabled: this.allowOwnTracksLoopback,
         },
       );
     }
@@ -1613,8 +1607,6 @@ export class Call {
     }
 
     this.tracer.setEnabled(enableTracing);
-    this.sfuStatsReporter?.flush();
-    this.sfuStatsReporter?.stop();
     if (statsOptions?.reporting_interval_ms > 0) {
       this.sfuStatsReporter = new SfuStatsReporter(sfuClient, {
         clientDetails,
@@ -1682,6 +1674,10 @@ export class Call {
     reason: string,
   ) => {
     this.logger.debug('[Reconnect] SFU signal connection closed');
+    // Ignore a close from a superseded client (e.g. an old socket's delayed
+    // `onclose` arriving after a reconnection already swapped in a new client).
+    // Only the currently active client's death may drive a reconnection.
+    if (sfuClient !== this.sfuClient) return;
     const { callingState } = this.state;
     if (
       // SFU WS closed before we finished current join,
@@ -1722,11 +1718,12 @@ export class Call {
     strategy: WebsocketReconnectStrategy,
     reason: ReconnectReason,
   ): Promise<void> => {
+    const { callingState } = this.state;
     if (
-      this.state.callingState === CallingState.JOINING ||
-      this.state.callingState === CallingState.RECONNECTING ||
-      this.state.callingState === CallingState.MIGRATING ||
-      this.state.callingState === CallingState.RECONNECTING_FAILED
+      callingState === CallingState.JOINING ||
+      callingState === CallingState.RECONNECTING ||
+      callingState === CallingState.MIGRATING ||
+      callingState === CallingState.RECONNECTING_FAILED
     )
       return;
 
@@ -2138,10 +2135,17 @@ export class Call {
         } else {
           if (!this.networkAvailableTask) return;
           this.logger.debug('[Reconnect] Going online');
-          this.sfuClient?.close(
-            StreamSfuClient.DISPOSE_OLD_SOCKET,
-            'Closing WS to reconnect after going online',
-          );
+          // Only discard the socket when no reconnect is already in flight. A
+          // running reconnect owns the SFU-client lifecycle (`doJoin` closes
+          // the previous client once the new session is up). Closing here would
+          // tear down the socket it's mid-join on, leaving the in-flight rejoin
+          // to spin on SIGNAL_LOST.
+          if (!hasPending(this.reconnectConcurrencyTag)) {
+            this.sfuClient?.close(
+              StreamSfuClient.DISPOSE_OLD_SOCKET,
+              'Closing WS to reconnect after going online',
+            );
+          }
           // we went online, release the previous waiters and reset the state
           this.networkAvailableTask?.resolve();
           this.networkAvailableTask = undefined;
@@ -2495,9 +2499,8 @@ export class Call {
    */
   muteSelf = (type: TrackMuteType) => {
     const myUserId = this.currentUserId;
-    if (myUserId) {
-      return this.muteUser(myUserId, type);
-    }
+    if (!myUserId) return undefined;
+    return this.muteUser(myUserId, type);
   };
 
   /**
@@ -2515,9 +2518,9 @@ export class Call {
       }
     }
 
-    if (userIdsToMute.length > 0) {
-      return this.muteUser(userIdsToMute, type);
-    }
+    return userIdsToMute.length > 0
+      ? this.muteUser(userIdsToMute, type)
+      : undefined;
   };
 
   /**