@stream-io/video-client 1.61.1 → 1.62.0

package/dist/src/Call.d.ts

@@ -124,6 +124,9 @@ export declare class Call {
     private lastOfflineTimestamp;
     private networkAvailableTask;
     private readonly rejoinRateLimiter;
+    private rejoinLongWindowRateLimiter?;
+    private readonly joinTasks;
+    private noLocalCandidatesCheckScheduled;
     private maxIceFailuresWithoutConnect;
     private iceFailuresWithoutConnect;
     private maxConsecutiveNegotiationFailures;
@@ -321,6 +324,7 @@ export declare class Call {
      * @returns a promise which resolves once the call join-flow has finished.
      */
     private doJoin;
+    private performJoin;
     /**
      * Prepares Reconnect Details object.
      * @internal
@@ -354,6 +358,21 @@ export declare class Call {
      * @internal
      */
     private initPublisherAndSubscriber;
+    /**
+     * Escalates to REJOIN with `ICE_NEVER_CONNECTED` when the current peer
+     * connections never connected and one of them completed ICE gathering
+     * without a single local candidate, which means WebRTC networking is
+     * blocked on this device.
+     *
+     * `reconnect` ignores requests while a join or another reconnect is in
+     * flight, so the check is postponed until those settle and then re-run
+     * against the peer connections current at that time.
+     */
+    private checkNoLocalCandidates;
+    /**
+     * Resolves once no `doJoin` run and no reconnect is in flight.
+     */
+    private waitForJoinsAndReconnects;
     /**
      * Retrieves credentials for joining the call.
      *
@@ -996,7 +1015,8 @@ export declare class Call {
      * `rejoin_attempt_limit_exceeded` leave message.
      *
      * Defaults: 10 attempts per 120 seconds (aligned with the Swift SDK).
-     * Both arguments are clamped to a minimum of 1.
+     * Both arguments are clamped to a minimum of 1. Unless this method is
+     * called, an additional cap of 20 REJOIN attempts per 30 minutes applies.
      */
     setRejoinAttemptLimit: (maxAttempts: number, windowSeconds: number) => void;
     /**

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

@@ -138,7 +138,7 @@ export type CallEventListener<E extends keyof AllCallEvents> = (event: AllCallEv
 export type Logger = (logLevel: LogLevel, message: string, ...args: unknown[]) => void;
 export type RingStatePollingOptions = {
     /**
-     * Quiet time after the ring starts, before the first poll. Defaults to 15_000.
+     * Quiet time after the ring starts, before the first poll. Defaults to 9_000.
      */
     startAfterMs?: number;
     /**

package/dist/src/devices/DeviceManager.d.ts

@@ -130,6 +130,12 @@ export declare abstract class DeviceManager<S extends DeviceManagerState<C>, C =
     protected findDevice(devices: MediaDeviceInfo[], deviceId: string): MediaDeviceInfo | undefined;
     private dispatchDeviceDisconnectedEvent;
     private persistPreference;
+    /**
+     * Returns the label of the active track if it was captured from the given
+     * device. Used as a fallback when the device list hasn't been enumerated yet,
+     * so the persisted preference still carries the device label.
+     */
+    private getActiveTrackLabel;
     protected applyPersistedPreferences(enabledInCallType: boolean, forceDisabled?: boolean): Promise<boolean>;
     private applyMutedState;
 }

package/dist/src/devices/DeviceManagerState.d.ts

@@ -9,6 +9,7 @@ export declare abstract class DeviceManagerState<C = MediaTrackConstraints> {
     protected rootMediaStreamSubject: BehaviorSubject<MediaStream | undefined>;
     protected selectedDeviceSubject: BehaviorSubject<string | undefined>;
     protected defaultConstraintsSubject: BehaviorSubject<C | undefined>;
+    protected errorSubject: BehaviorSubject<Error | undefined>;
     /**
      * @internal
      */
@@ -39,6 +40,13 @@ export declare abstract class DeviceManagerState<C = MediaTrackConstraints> {
      * The default constraints for the device.
      */
     defaultConstraints$: Observable<C | undefined>;
+    /**
+     * An Observable that emits the error of the last failed attempt to start
+     * the device (e.g. the device is in use by another app), or `undefined`.
+     * For screen share, this includes the user dismissing the picker.
+     * Cleared when the device is started again or disabled.
+     */
+    error$: Observable<Error | undefined>;
     /**
      * An observable that will emit `true` if browser/system permission
      * is granted (or at least hasn't been denied), `false` otherwise.
@@ -85,6 +93,15 @@ export declare abstract class DeviceManagerState<C = MediaTrackConstraints> {
      * same as `mediaStream`.
      */
     get rootMediaStream(): MediaStream | undefined;
+    /**
+     * The error of the last failed attempt to start the device, or `undefined`.
+     */
+    get error(): Error | undefined;
+    /**
+     * @internal
+     * @param error the error to set.
+     */
+    setError(error: Error | undefined): void;
     /**
      * @internal
      * @param status

package/dist/src/devices/MicrophoneManager.d.ts

@@ -74,6 +74,17 @@ export declare class MicrophoneManager extends AudioDeviceManager<MicrophoneMana
     apply(settings: AudioSettingsResponse, publish: boolean, forceDisabled?: boolean): Promise<void>;
     protected getDevices(): Observable<MediaDeviceInfo[]>;
     protected getStream(constraints: MediaTrackConstraints): Promise<MediaStream>;
+    /**
+     * On mute, hands a clone of the live mic track to the speaking while muted
+     * detection, so the device stays captured after the mic tracks are stopped.
+     * Releasing and re-acquiring the mic flips Bluetooth headsets between audio
+     * profiles.
+     */
+    protected muteStream(stopTracks?: boolean): Promise<void>;
+    /**
+     * Whether a mute can hand the mic over to the speaking while muted detection.
+     */
+    private canHandOffMic;
     protected doSetAudioBitrateProfile(profile: AudioBitrateProfile): void;
     private startSpeakingWhileMutedDetection;
     private stopSpeakingWhileMutedDetection;

package/dist/src/devices/devices.d.ts

@@ -3,6 +3,11 @@ import { Tracer } from '../stats';
 /**
  * Tells if the browser supports audio output change on 'audio' elements,
  * see https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/setSinkId.
+ *
+ * WebKit (Safari, iOS browsers, WKWebView) is reported as unsupported:
+ * setSinkId requires a user gesture, a per-device output can run at a
+ * different sample rate than the remote audio mixer (pitched/slowed audio),
+ * and audio goes silent when the selected device disconnects.
  */
 export declare const checkIfAudioOutputChangeSupported: () => boolean;
 /**

package/dist/src/gen/video/sfu/signal_rpc/signal.d.ts

@@ -8,7 +8,6 @@ import { PerformanceStats } from '../models/models';
 import { RTMPIngress } from '../models/models';
 import { AppleState } from '../models/models';
 import { AndroidState } from '../models/models';
-import { InputDevices } from '../models/models';
 import { RemoteOutboundRtp } from '../models/models';
 import { RemoteInboundRtp } from '../models/models';
 import { OutboundRtp } from '../models/models';
@@ -129,14 +128,6 @@ export interface SendStatsRequest {
      * @generated from protobuf field: string session_id = 1;
      */
     sessionId: string;
-    /**
-     * @generated from protobuf field: string subscriber_stats = 2;
-     */
-    subscriberStats: string;
-    /**
-     * @generated from protobuf field: string publisher_stats = 3;
-     */
-    publisherStats: string;
     /**
      * @generated from protobuf field: string webrtc_version = 4;
      */
@@ -149,14 +140,6 @@ export interface SendStatsRequest {
      * @generated from protobuf field: string sdk_version = 6;
      */
     sdkVersion: string;
-    /**
-     * @generated from protobuf field: stream.video.sfu.models.InputDevices audio_devices = 7;
-     */
-    audioDevices?: InputDevices;
-    /**
-     * @generated from protobuf field: stream.video.sfu.models.InputDevices video_devices = 8;
-     */
-    videoDevices?: InputDevices;
     /**
      * @generated from protobuf oneof: device_state
      */
@@ -183,16 +166,6 @@ export interface SendStatsRequest {
      * @generated from protobuf field: stream.video.sfu.models.RTMPIngress rtmp = 12;
      */
     rtmp?: RTMPIngress;
-    /**
-     * @deprecated
-     * @generated from protobuf field: string subscriber_rtc_stats = 13 [deprecated = true];
-     */
-    subscriberRtcStats: string;
-    /**
-     * @deprecated
-     * @generated from protobuf field: string publisher_rtc_stats = 14 [deprecated = true];
-     */
-    publisherRtcStats: string;
     /**
      * @generated from protobuf field: string rtc_stats = 15;
      */

package/dist/src/helpers/AudioBindingsWatchdog.d.ts

@@ -4,9 +4,12 @@ import { Tracer } from '../stats';
 /**
  * Tracks audio element bindings and periodically warns about
  * remote participants whose audio streams have no bound element.
+ * On the same tick, it traces the playback state of the bound elements,
+ * limited to the bindings whose state changed since the previous trace.
  */
 export declare class AudioBindingsWatchdog {
     private bindings;
+    private tracedStates;
     private enabled;
     private watchdogInterval?;
     private readonly unsubscribeCallingState;
@@ -24,8 +27,8 @@ export declare class AudioBindingsWatchdog {
      */
     unregister: (sessionId: string, trackType: AudioTrackType) => void;
     /**
-     * Enables or disables the watchdog.
-     * When disabled, the periodic check stops but bindings are still tracked.
+     * Enables or disables the dangling binding warnings.
+     * Bindings are still tracked and their playback state is still traced.
      */
     setEnabled: (enabled: boolean) => void;
     /**
@@ -33,5 +36,7 @@ export declare class AudioBindingsWatchdog {
      */
     dispose: () => void;
     private start;
+    private warnAboutDanglingBindings;
+    private traceBindingStates;
     private stop;
 }

package/dist/src/helpers/DynascaleManager.d.ts

@@ -17,6 +17,9 @@ export declare class DynascaleManager {
     private readonly tracer;
     private useWebAudio;
     private audioContext;
+    private playbackWatchdogs;
+    private stopWatchingInterruptions;
+    private stopTracingAudioSession;
     private trackSubscriptionManager;
     private blockedAudioTracker;
     /**
@@ -64,6 +67,18 @@ export declare class DynascaleManager {
      * @returns a cleanup function that will unbind the audio element.
      */
     bindAudioElement: (audioElement: HTMLAudioElement, sessionId: string, trackType: AudioTrackType) => (() => void) | undefined;
+    /**
+     * Creates a playback watchdog that is re-armed whenever a media
+     * interruption (backgrounding, phone call, Siri) ends.
+     */
+    private createPlaybackWatchdog;
+    private disposePlaybackWatchdog;
+    private rearmPlayback;
+    /**
+     * Traces the WebKit audio session state (initial value and changes) in
+     * both playback modes, as it explains most iOS playback interruptions.
+     */
+    private traceAudioSessionState;
     private getOrCreateAudioContext;
     private resumeAudioContext;
 }

package/dist/src/helpers/MediaPlaybackWatchdog.d.ts

@@ -4,7 +4,10 @@ export type MediaPlaybackWatchdogOptions = {
     element: HTMLMediaElement;
     kind: MediaKind;
     tracer: Tracer;
+    sessionId?: string;
+    trackType?: string;
     isBlocked?: () => boolean;
+    onGiveUp?: () => void;
 };
 /**
  * Watches a single audio or video element and attempts to recover playback
@@ -13,7 +16,9 @@ export type MediaPlaybackWatchdogOptions = {
 export declare class MediaPlaybackWatchdog {
     private logger;
     private readonly kind;
+    private readonly traceInfo;
     private readonly isBlocked;
+    private readonly onGiveUp;
     private element;
     private tracer;
     private controller;
@@ -25,9 +30,22 @@ export declare class MediaPlaybackWatchdog {
     constructor(opts: MediaPlaybackWatchdogOptions);
     private attach;
     dispose: () => void;
+    /**
+     * Starts a fresh recovery cycle, e.g. after a media interruption ended.
+     * Unlike a regular pause-triggered recovery, it also tries elements that
+     * were skipped as blocked or not ready, since those conditions may have
+     * cleared together with the interruption.
+     */
+    rearm: () => void;
     private clearTimers;
     private onPlaying;
     private onSettled;
+    /**
+     * Media elements backed by a MediaStream fire `suspend` routinely (after
+     * the initial load, on source swaps, on layer switches), so a `suspend`
+     * that needs no recovery is ignored without a trace. An explicit `pause`
+     * is rare and always traced, along with the reason recovery was skipped.
+     */
     private onPauseOrSuspend;
     private scheduleRecovery;
     private computeSkipReason;

package/dist/src/helpers/mediaInterruptions.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Checks whether media playback and capture are likely interrupted: the page
+ * is hidden, or WebKit reports the audio session as interrupted (a phone
+ * call, Siri, or another app taking over audio).
+ */
+export declare const isMediaInterrupted: () => boolean;
+/**
+ * Invokes `onResumed` every time the page leaves a media interruption,
+ * as defined by {@link isMediaInterrupted}.
+ *
+ * @param onResumed the callback to invoke.
+ * @returns a function that stops watching.
+ */
+export declare const watchMediaInterruptions: (onResumed: () => void) => (() => void);

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

@@ -9,7 +9,7 @@ export type JoinReason = 'first-attempt' | 'network-available' | 'migration' | '
 /**
  * What triggered an automatic join, reported as `source` on the call's
  * CoordinatorJoin events. `ring-ws` is a ring WebSocket event, `ring-poll-api`
- * is the ring state poller.
+ * is the ring state poller, or the call refresh after a WS reconnect.
  */
 export type JoinSource = 'ring-ws' | 'ring-poll-api';
 export type ClientEventStandardCode = 'CLIENT_ABORTED' | 'BACKEND_LEAVE' | 'REQUEST_TIMEOUT' | 'NETWORK_ERROR' | 'SFU_ERROR' | 'SFU_GO_AWAY' | 'ICE_CONNECTIVITY_FAILED' | 'DTLS_CONNECTIVITY_FAILED';

package/dist/src/ringing/reconcileRingState.d.ts

@@ -3,15 +3,16 @@ import type { JoinSource } from '../reporting';
 /**
  * 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.
+ * The `call.accepted` and `call.rejected` handlers, the ring state poller and
+ * the rewatch after a WS reconnect all run this. They differ only in how the
+ * state got there: the handlers rely on `CallState.updateFromEvent`, which runs
+ * before them, while the poller applies the polled ring state itself and the
+ * rewatch applies the queried call state.
  *
  * @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.
+ * @param joinSource what triggered this run, reported on the caller's join:
+ * `ring-ws` for the event handlers, `ring-poll-api` for the poller and the
+ * rewatch (both come from an API response).
  * @returns whether the ring reached a terminal state. A failed join is not
  * terminal: the caller should keep trying while the ring is open.
  */

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

@@ -24,10 +24,12 @@ export declare abstract class BasePeerConnection {
     protected sfuClient: StreamSfuClient;
     protected onReconnectionNeeded?: OnReconnectionNeeded;
     private onIceConnected?;
+    private onNoLocalCandidates?;
     private onPeerConnectionStateChange?;
     protected onRemoteTrackUnmute?: OnRemoteTrackUnmute;
     private readonly iceRestartDelay;
     private iceHasEverConnected;
+    private localCandidatesGathered;
     private iceRestartTimeout?;
     private preConnectStuckTimeout?;
     protected isIceRestarting: boolean;
@@ -41,7 +43,7 @@ export declare abstract class BasePeerConnection {
     /**
      * Constructs a new `BasePeerConnection` instance.
      */
-    protected constructor(peerType: PeerType, { sfuClient, connectionConfig, state, dispatcher, onReconnectionNeeded, onIceConnected, onPeerConnectionStateChange, onRemoteTrackUnmute, tag, enableTracing, clientPublishOptions, e2ee, iceRestartDelay, statsTimestampDriftThresholdMs, }: BasePeerConnectionOpts);
+    protected constructor(peerType: PeerType, { sfuClient, connectionConfig, state, dispatcher, onReconnectionNeeded, onIceConnected, onNoLocalCandidates, onPeerConnectionStateChange, onRemoteTrackUnmute, tag, enableTracing, clientPublishOptions, e2ee, iceRestartDelay, statsTimestampDriftThresholdMs, }: BasePeerConnectionOpts);
     private createPeerConnection;
     /**
      * Disposes the `RTCPeerConnection` instance.
@@ -90,6 +92,16 @@ export declare abstract class BasePeerConnection {
      * Maps the given track ID to the corresponding track type.
      */
     getTrackType: (trackId: string) => TrackType | undefined;
+    /**
+     * Returns `true` once ICE has reached `connected`/`completed` at least
+     * once during the lifetime of this peer connection.
+     */
+    hasIceEverConnected: () => boolean;
+    /**
+     * Returns `true` when the latest ICE gathering round completed without
+     * producing a single local candidate.
+     */
+    hasNoLocalCandidates: () => boolean;
     /**
      * Checks if the `RTCPeerConnection` is healthy.
      * It checks the ICE connection state and the peer connection state.

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

@@ -40,6 +40,12 @@ export type OnReconnectionNeeded = (kind: WebsocketReconnectStrategy, reason: Re
  * recovered, not merely when the SFU join handshake succeeded.
  */
 export type OnIceConnected = (peerType: PeerType) => void;
+/**
+ * Fires when an ICE gathering round completes without producing a single
+ * local candidate on a peer connection that never connected. Used by `Call`
+ * to detect devices whose WebRTC networking is blocked.
+ */
+export type OnNoLocalCandidates = (peerType: PeerType) => void;
 /**
  * Snapshot of the peer connection's ICE and DTLS state surfaced to telemetry
  * consumers (e.g. `ClientEventReporter`). Fired on every transition of
@@ -75,6 +81,7 @@ export type BasePeerConnectionOpts = {
     dispatcher: Dispatcher;
     onReconnectionNeeded?: OnReconnectionNeeded;
     onIceConnected?: OnIceConnected;
+    onNoLocalCandidates?: OnNoLocalCandidates;
     onPeerConnectionStateChange?: OnPeerConnectionStateChange;
     onRemoteTrackUnmute?: OnRemoteTrackUnmute;
     tag: string;

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

@@ -3,16 +3,11 @@ import { StatsOptions } from '../gen/coordinator';
 import { Publisher, Subscriber } from '../rtc';
 import { Tracer } from './rtc';
 import { ClientDetails, WebsocketReconnectStrategy } from '../gen/video/sfu/models/models';
-import { CameraManager, MicrophoneManager } from '../devices';
-import { CallState } from '../store';
 export type SfuStatsReporterOptions = {
     options: StatsOptions;
     clientDetails: ClientDetails;
     subscriber: Subscriber;
     publisher?: Publisher;
-    microphone: MicrophoneManager;
-    camera: CameraManager;
-    state: CallState;
     tracer: Tracer;
     unifiedSessionId: string;
 };
@@ -22,24 +17,17 @@ export declare class SfuStatsReporter {
     private readonly sfuClient;
     private readonly subscriber;
     private readonly publisher?;
-    private readonly microphone;
-    private readonly camera;
-    private readonly state;
     private readonly tracer;
     private readonly unifiedSessionId;
     private intervalId;
     private timeoutId;
     private reportCount;
-    private unsubscribeDevicePermissionsSubscription?;
-    private unsubscribeListDevicesSubscription?;
     private readonly sdkName;
     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;
+    constructor(sfuClient: StreamSfuClient, { options, clientDetails, subscriber, publisher, tracer, unifiedSessionId, }: SfuStatsReporterOptions);
     sendConnectionTime: (connectionTimeSeconds: number) => void;
     sendReconnectionTime: (strategy: WebsocketReconnectStrategy, timeSeconds: number) => void;
     private sendTelemetryData;

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

@@ -1,5 +1,5 @@
-import { PeerType, TrackType } from '../../gen/video/sfu/models/models';
-import type { ComputedStats, PendingDelta } from './types';
+import { PeerType, PerformanceStats, TrackType } from '../../gen/video/sfu/models/models';
+import type { PendingDelta } from './types';
 /**
  * StatsTracer is a class that collects and processes WebRTC stats.
  * It is used to track the performance of the WebRTC connection
@@ -32,13 +32,13 @@ export declare class StatsTracer {
      */
     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`).
+     * Samples the RTCPeerConnection: returns the derived performance stats and
+     * appends the delta-compressed sample to the un-acked delivery chain
+     * (retrieved via `getPendingDeltas`).
      *
      * @internal
      */
-    takeSample: () => Promise<ComputedStats>;
+    takeSample: () => Promise<PerformanceStats[]>;
     /**
      * Returns a stable copy of the un-acked delta chain to transmit, oldest first.
      *

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

@@ -1,4 +1,3 @@
-import type { PerformanceStats } from '../../gen/video/sfu/models/models';
 export type RTCStatsDataType = RTCConfiguration | RTCIceCandidate | RTCSignalingState | RTCIceConnectionState | RTCIceGatheringState | RTCPeerConnectionState | [number | null | string] | string | boolean | RTCOfferOptions | [string | RTCDataChannelInit | undefined] | (RTCOfferOptions | undefined) | RTCSessionDescriptionInit | (RTCIceCandidateInit | RTCIceCandidate) | object | number | null | undefined;
 export type TraceKey = 'device-enumeration' | (string & {});
 export type Trace = (tag: string, data: RTCStatsDataType) => void;
@@ -12,16 +11,6 @@ export type TraceSlice = {
     snapshot: TraceRecord[];
     rollback: () => void;
 };
-export type ComputedStats = {
-    /**
-     * Current stats from the RTCPeerConnection.
-     */
-    stats: RTCStatsReport;
-    /**
-     * 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.61.1",
+  "version": "1.62.0",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
   "browser": "dist/index.browser.es.js",