@stream-io/video-client 1.48.0 → 1.50.0

package/dist/src/Call.d.ts

@@ -5,7 +5,11 @@ import type { AcceptCallResponse, BlockUserResponse, CallRingEvent, CallSettings
 import { AudioTrackType, CallConstructor, CallLeaveOptions, CallRecordingType, ClientPublishOptions, ClosedCaptionsSettings, JoinCallData, StartCallRecordingFnType, TrackMuteType, VideoTrackType } from './types';
 import { ClientCapability, TrackType, VideoDimension } from './gen/video/sfu/models/models';
 import { Tracer } from './stats';
+import { AudioBindingsWatchdog } from './helpers/AudioBindingsWatchdog';
+import { BlockedAudioTracker } from './helpers/BlockedAudioTracker';
+import { TrackSubscriptionManager } from './helpers/TrackSubscriptionManager';
 import { DynascaleManager } from './helpers/DynascaleManager';
+import { ViewportTracker } from './helpers/ViewportTracker';
 import { PermissionsContext } from './permissions';
 import { StreamClient } from './coordinator/connection/client';
 import { AllCallEvents, CallEventListener, RejectReason } from './coordinator/connection/types';
@@ -55,7 +59,28 @@ export declare class Call {
     /**
      * The DynascaleManager instance.
      */
-    readonly dynascaleManager: DynascaleManager;
+    readonly dynascaleManager: DynascaleManager | undefined;
+    /**
+     * Tracks viewport visibility for participant video elements.
+     * Available only in DOM environments.
+     */
+    readonly viewportTracker: ViewportTracker | undefined;
+    /**
+     * Owns the SFU-side video-subscription state (per-session and global overrides).
+     */
+    readonly trackSubscriptionManager: TrackSubscriptionManager;
+    /**
+     * Warns periodically when a remote participant is publishing audio, but no
+     * `<audio>` element has been bound for them.
+     */
+    readonly audioBindingsWatchdog: AudioBindingsWatchdog | undefined;
+    /**
+     * Tracks audio elements blocked by the browser's autoplay policy.
+     * Subscribe to `blockedAudioTracker.autoplayBlocked$` to react to the
+     * blocked state, and call {@link Call.resumeAudio} inside a user gesture
+     * to retry playback.
+     */
+    readonly blockedAudioTracker: BlockedAudioTracker;
     subscriber?: Subscriber;
     publisher?: Publisher;
     /**
@@ -92,6 +117,11 @@ export declare class Call {
     private disconnectionTimeoutSeconds;
     private lastOfflineTimestamp;
     private networkAvailableTask;
+    private readonly rejoinRateLimiter;
+    private maxIceFailuresWithoutConnect;
+    private iceFailuresWithoutConnect;
+    private maxConsecutiveNegotiationFailures;
+    private consecutiveNegotiationFailures;
     private trackPublishOrder;
     private joinResponseTimeout?;
     private rpcRequestTimeout?;
@@ -298,7 +328,9 @@ export declare class Call {
      * @internal
      *
      * @param strategy the reconnection strategy to use.
-     * @param reason the reason for the reconnection.
+     * @param reason the reason for the reconnection. Pass a `ReconnectReason.*`
+     *   constant when the SDK should react to it (e.g.
+     *   `ICE_NEVER_CONNECTED` increments the unsupported-network counter).
      */
     private reconnect;
     /**
@@ -369,6 +401,16 @@ export declare class Call {
      * @param trackTypes the track types to update the call state with.
      */
     private updateLocalStreamState;
+    /**
+     * Re-arms the encoder for a currently published track type. Useful for
+     * working around WebKit's stalled sender bug after an iOS audio session
+     * interruption (Siri, PSTN call).
+     *
+     * @internal
+     *
+     * @param trackType the track type to refresh.
+     */
+    refreshPublishedTrack: (trackType: TrackType) => Promise<void>;
     /**
      * Updates the preferred publishing options
      *
@@ -770,13 +812,13 @@ export declare class Call {
      * @param sessionId the session id.
      * @param trackType the video mode.
      */
-    trackElementVisibility: <T extends HTMLElement>(element: T, sessionId: string, trackType: VideoTrackType) => () => void;
+    trackElementVisibility: <T extends HTMLElement>(element: T, sessionId: string, trackType: VideoTrackType) => (() => void) | undefined;
     /**
      * Sets the viewport element to track bound video elements for visibility.
      *
      * @param element the viewport element.
      */
-    setViewport: <T extends HTMLElement>(element: T) => () => void;
+    setViewport: <T extends HTMLElement>(element: T) => (() => void) | undefined;
     /**
      * Binds a DOM <video> element to the given session id.
      * This method will make sure that the video element will play
@@ -806,6 +848,10 @@ export declare class Call {
     bindAudioElement: (audioElement: HTMLAudioElement, sessionId: string, trackType?: AudioTrackType) => (() => void) | undefined;
     /**
      * Plays all audio elements blocked by the browser's autoplay policy.
+     * Must be called from within a user gesture (e.g., click handler).
+     *
+     * Subscribe to `call.blockedAudioTracker.autoplayBlocked$` to know when a
+     * gesture is required.
      */
     resumeAudio: () => Promise<void>;
     /**
@@ -839,6 +885,33 @@ export declare class Call {
      * @param timeoutSeconds Timeout in seconds, or 0 to keep reconnecting indefinetely
      */
     setDisconnectionTimeout: (timeoutSeconds: number) => void;
+    /**
+     * Configures the rolling-window limit for REJOIN/MIGRATE attempts. Once
+     * `maxAttempts` rejoins have been registered inside `windowSeconds`, the
+     * SDK stops retrying and transitions the call to `LEFT` with the
+     * `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.
+     */
+    setRejoinAttemptLimit: (maxAttempts: number, windowSeconds: number) => void;
+    /**
+     * Configures how many peer-connection failures where ICE never reached
+     * `connected`/`completed` are tolerated before the SDK concludes that the
+     * current network cannot support WebRTC and transitions the call to
+     * `LEFT` with the `webrtc_unsupported_network` leave message.
+     *
+     * Default: 2. Clamped to a minimum of 1.
+     */
+    setMaxIceFailuresWithoutConnect: (n: number) => void;
+    /**
+     * Configures how many consecutive SDP `NegotiationError`s are tolerated
+     * before the SDK stops retrying and transitions the call to `LEFT` with
+     * the `repeated_negotiation_failures` leave message.
+     *
+     * Default: 3. Clamped to a minimum of 1.
+     */
+    setMaxConsecutiveNegotiationFailures: (n: number) => void;
     /**
      * Enables the provided client capabilities.
      */

package/dist/src/StreamSfuClient.d.ts

@@ -107,7 +107,8 @@ export declare class StreamSfuClient {
     private networkAvailableTask;
     /**
      * Promise that resolves when the JoinResponse is received.
-     * Rejects after a certain threshold if the response is not received.
+     * Rejects after a certain threshold if the response is not received,
+     * or when the SFU client is disposed before a join completes.
      */
     private joinResponseTask;
     /**
@@ -140,6 +141,12 @@ export declare class StreamSfuClient {
      * The close code used when the client fails to join the call (on the SFU).
      */
     static JOIN_FAILED: number;
+    /**
+     * Best-effort grace period in `leaveAndClose` for an in-flight join to
+     * complete before we give up and close without sending `leaveCallRequest`.
+     * Bounded so a stuck join can never hang the leave path.
+     */
+    static LEAVE_NOTIFY_GRACE_MS: number;
     /**
      * Constructs a new SFU client.
      */

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

@@ -113,7 +113,7 @@ export declare class StreamClient {
      */
     _setupConnectionIdPromise: () => void;
     get connectionIdPromise(): Promise<string | undefined> | undefined;
-    get isConnectionIsPromisePending(): boolean;
+    get isConnectionIdPromisePending(): boolean;
     get wsPromise(): Promise<ConnectedEvent | undefined> | undefined;
     _logApiRequest: (type: string, url: string, data: unknown, config: AxiosRequestConfig & {
         config?: AxiosRequestConfig & {

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

@@ -1,5 +1,5 @@
 import { StreamClient } from './client';
-import type { UR } from './types';
+import type { UR, WSConnectionError } from './types';
 import type { LogLevel } from '@stream-io/logger';
 import type { ConnectedEvent } from '../../gen/coordinator';
 /**
@@ -20,43 +20,48 @@ import type { ConnectedEvent } from '../../gen/coordinator';
  * - if the servers fails to publish a message to the client, the WS connection is destroyed
  */
 export declare class StableWSConnection {
+    client: StreamClient;
+    ws?: WebSocket;
+    /** Incremented when a new WS connection is made */
+    wsID: number;
+    /** We only make 1 attempt to reconnect at the same time.. */
+    isConnecting: boolean;
+    /** To avoid reconnect if client is disconnected */
+    isDisconnected: boolean;
+    /** Boolean that indicates if we have a working connection to the server */
+    isHealthy: boolean;
     connectionID?: string;
     private connectionOpenSafe?;
+    resolveConnectionOpen?: (value: ConnectedEvent) => void;
+    rejectConnectionOpen?: (reason?: WSConnectionError) => void;
+    /** Boolean that indicates if the connection promise is resolved */
+    isConnectionOpenResolved?: boolean;
+    /** consecutive failures influence the duration of the timeout */
     consecutiveFailures: number;
+    /** keep track of the total number of failures */
+    totalFailures: number;
+    /** Send a health check message every 25 seconds */
     pingInterval: number;
     healthCheckTimeoutRef?: number;
-    isConnecting: boolean;
-    isDisconnected: boolean;
-    isHealthy: boolean;
-    isConnectionOpenResolved?: boolean;
-    lastEvent: Date | null;
     connectionCheckTimeout: number;
     connectionCheckTimeoutRef?: NodeJS.Timeout;
-    rejectConnectionOpen?: (reason?: Error & {
-        code?: string | number;
-        isWSFailure?: boolean;
-        StatusCode?: string | number;
-    }) => void;
-    resolveConnectionOpen?: (value: ConnectedEvent) => void;
-    totalFailures: number;
-    ws?: WebSocket;
-    wsID: number;
-    client: StreamClient;
+    /** Store the last event time for health checks */
+    lastEvent: Date | null;
     constructor(client: StreamClient);
-    _log: (msg: string, extra?: UR, level?: LogLevel) => void;
+    _log: (msg: string, extra?: UR | Error, level?: LogLevel) => void;
     setClient: (client: StreamClient) => void;
     /**
      * connect - Connect to the WS URL
      * the default 15s timeout allows between 2~3 tries
-     * @return {ConnectAPIResponse<ConnectedEvent>} Promise that completes once the first health check message is received
+     * @return Promise that completes once the first health check message is received
      */
-    connect(timeout?: number): Promise<ConnectedEvent | undefined>;
+    connect: (timeout?: number) => Promise<ConnectedEvent | undefined>;
     /**
      * _waitForHealthy polls the promise connection to see if its resolved until it times out
      * the default 15s timeout allows between 2~3 tries
      * @param timeout duration(ms)
      */
-    _waitForHealthy(timeout?: number): Promise<ConnectedEvent | undefined>;
+    _waitForHealthy: (timeout?: number) => Promise<ConnectedEvent | undefined>;
     /**
      * Builds and returns the url for websocket.
      * @private
@@ -65,15 +70,17 @@ export declare class StableWSConnection {
     _buildUrl: () => string;
     /**
      * disconnect - Disconnect the connection and doesn't recover...
-     *
      */
-    disconnect(timeout?: number): Promise<void>;
+    disconnect: (timeout?: number) => Promise<void>;
     /**
      * _connect - Connect to the WS endpoint
      *
-     * @return {ConnectAPIResponse<ConnectedEvent>} Promise that completes once the first health check message is received
+     * @param timeoutMs handshake watchdog deadline in ms. Defaults to
+     *   `client.defaultWSTimeout` when not provided. Top-level `connect(timeout)`
+     *   passes its own timeout through so caller-supplied deadlines are honored.
+     * @return Promise that completes once the first health check message is received
      */
-    _connect(): Promise<ConnectedEvent | undefined>;
+    _connect: (timeoutMs?: number) => Promise<ConnectedEvent | undefined>;
     /**
      * _reconnect - Retry the connection to WS endpoint
      *
@@ -90,7 +97,6 @@ export declare class StableWSConnection {
      * onlineStatusChanged - this function is called when the browser connects or disconnects from the internet.
      *
      * @param {Event} event Event with type online or offline
-     *
      */
     onlineStatusChanged: (event: Event) => void;
     onopen: (wsID: number) => void;

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

@@ -36,6 +36,20 @@ export type APIErrorResponse = {
     details?: ErrorResponseDetails;
     unrecoverable?: boolean;
 };
+/**
+ * A standard `Error` augmented with the metadata that the coordinator
+ * WebSocket connection layer attaches to rejection causes.
+ * `isWSFailure: true` marks transient/retriable failures; absent or `false`
+ * indicates a permanent failure that should not be retried.
+ */
+export type WSConnectionError = Error & {
+    code?: string | number;
+    isWSFailure?: boolean;
+    StatusCode?: string | number;
+    reason?: string;
+    wasClean?: boolean;
+    target?: EventTarget | null;
+};
 export declare class ErrorFromResponse<T> extends Error {
     code: number | null;
     status: number;

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

@@ -2,6 +2,7 @@ import type { AxiosResponse } from 'axios';
 import type { APIErrorResponse } from './types';
 import type { ConnectionErrorEvent } from '../../gen/coordinator';
 export declare const sleep: (m: number) => Promise<unknown>;
+export declare const timeboxed: <T extends Promise<unknown>[]>(promises: [...T], ms: number) => Promise<{ [K in keyof T]: Awaited<T[K]>; }>;
 export declare function isFunction<T>(value: Function | T): value is Function;
 /**
  * A map of known error codes.

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

@@ -16,6 +16,7 @@ export declare abstract class DeviceManager<S extends DeviceManagerState<C>, C =
     protected readonly call: Call;
     protected readonly trackType: TrackType;
     protected subscriptions: (() => void)[];
+    protected currentStreamCleanups: (() => void)[];
     protected devicePersistence: Required<DevicePersistenceOptions>;
     protected areSubscriptionsSetUp: boolean;
     private isTrackStoppedDueToTrackEnd;
@@ -89,6 +90,7 @@ export declare abstract class DeviceManager<S extends DeviceManagerState<C>, C =
      * @internal
      */
     dispose: () => void;
+    private runCurrentStreamCleanups;
     protected applySettingsToStream(): Promise<void>;
     protected abstract getDevices(): Observable<MediaDeviceInfo[]>;
     protected abstract getStream(constraints: C): Promise<MediaStream>;
@@ -101,6 +103,7 @@ export declare abstract class DeviceManager<S extends DeviceManagerState<C>, C =
     private stopTracks;
     private muteLocalStream;
     protected unmuteStream(): Promise<void>;
+    private setLocalInterrupted;
     private get mediaDeviceKind();
     private handleDisconnectedOrReplacedDevices;
     protected findDevice(devices: MediaDeviceInfo[], deviceId: string): MediaDeviceInfo | undefined;

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

@@ -6,6 +6,7 @@ export declare abstract class DeviceManagerState<C = MediaTrackConstraints> {
     protected statusSubject: BehaviorSubject<InputDeviceStatus>;
     protected optimisticStatusSubject: BehaviorSubject<InputDeviceStatus>;
     protected mediaStreamSubject: BehaviorSubject<MediaStream | undefined>;
+    protected rootMediaStreamSubject: BehaviorSubject<MediaStream | undefined>;
     protected selectedDeviceSubject: BehaviorSubject<string | undefined>;
     protected defaultConstraintsSubject: BehaviorSubject<C | undefined>;
     /**
@@ -14,9 +15,14 @@ export declare abstract class DeviceManagerState<C = MediaTrackConstraints> {
     prevStatus: InputDeviceStatus;
     /**
      * An Observable that emits the current media stream, or `undefined` if the device is currently disabled.
-     *
      */
     mediaStream$: Observable<MediaStream | undefined>;
+    /**
+     * An Observable that emits the raw device media stream (before any filters are applied),
+     * or `undefined` if the device is currently disabled. When no filters are active, this
+     * emits the same stream as `mediaStream$`.
+     */
+    rootMediaStream$: Observable<MediaStream | undefined>;
     /**
      * An Observable that emits the currently selected device
      */
@@ -73,6 +79,12 @@ export declare abstract class DeviceManagerState<C = MediaTrackConstraints> {
      * The current media stream, or `undefined` if the device is currently disabled.
      */
     get mediaStream(): MediaStream | undefined;
+    /**
+     * The raw device media stream (before any filters are applied), or `undefined`
+     * if the device is currently disabled. When no filters are active, this is the
+     * same as `mediaStream`.
+     */
+    get rootMediaStream(): MediaStream | undefined;
     /**
      * @internal
      * @param status

package/dist/src/gen/video/sfu/event/events.d.ts

@@ -1,5 +1,5 @@
 import { MessageType } from '@protobuf-ts/runtime';
-import { CallEndedReason, CallGrants, CallState, ClientCapability, ClientDetails, Codec, ConnectionQuality, Error as Error$, GoAwayReason, ICETrickle as ICETrickle$, Participant, ParticipantCount, ParticipantSource, PeerType, Pin, PublishOption, SubscribeOption, TrackInfo, TrackType, TrackUnpublishReason, WebsocketReconnectStrategy } from '../models/models';
+import { CallEndedReason, CallGrants, CallState, ClientCapability, ClientDetails, Codec, ConnectionQuality, DegradationPreference, Error as Error$, GoAwayReason, ICETrickle as ICETrickle$, Participant, ParticipantCount, ParticipantSource, PeerType, Pin, PublishOption, SubscribeOption, TrackInfo, TrackType, TrackUnpublishReason, WebsocketReconnectStrategy } from '../models/models';
 import { TrackSubscriptionDetails } from '../signal_rpc/signal';
 /**
  * SFUEvent is a message that is sent from the SFU to the client.
@@ -785,6 +785,10 @@ export interface VideoSender {
      * @generated from protobuf field: int32 publish_option_id = 5;
      */
     publishOptionId: number;
+    /**
+     * @generated from protobuf field: stream.video.sfu.models.DegradationPreference degradation_preference = 6;
+     */
+    degradationPreference: DegradationPreference;
 }
 /**
  * sent to users when they need to change the quality of their video

package/dist/src/gen/video/sfu/models/models.d.ts

@@ -303,6 +303,12 @@ export interface PublishOption {
      * @generated from protobuf field: repeated stream.video.sfu.models.AudioBitrate audio_bitrate_profiles = 10;
      */
     audioBitrateProfiles: AudioBitrate[];
+    /**
+     * The degradation preference for video encoding.
+     *
+     * @generated from protobuf field: stream.video.sfu.models.DegradationPreference degradation_preference = 11;
+     */
+    degradationPreference: DegradationPreference;
 }
 /**
  * @generated from protobuf message stream.video.sfu.models.Codec
@@ -1168,6 +1174,34 @@ export declare enum ClientCapability {
      */
     SUBSCRIBER_VIDEO_PAUSE = 1
 }
+/**
+ * DegradationPreference represents the RTCDegradationPreference from WebRTC.
+ * See https://developer.mozilla.org/en-US/docs/Web/API/RTCRtpSender/setParameters#degradationpreference
+ *
+ * @generated from protobuf enum stream.video.sfu.models.DegradationPreference
+ */
+export declare enum DegradationPreference {
+    /**
+     * @generated from protobuf enum value: DEGRADATION_PREFERENCE_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from protobuf enum value: DEGRADATION_PREFERENCE_BALANCED = 1;
+     */
+    BALANCED = 1,
+    /**
+     * @generated from protobuf enum value: DEGRADATION_PREFERENCE_MAINTAIN_FRAMERATE = 2;
+     */
+    MAINTAIN_FRAMERATE = 2,
+    /**
+     * @generated from protobuf enum value: DEGRADATION_PREFERENCE_MAINTAIN_RESOLUTION = 3;
+     */
+    MAINTAIN_RESOLUTION = 3,
+    /**
+     * @generated from protobuf enum value: DEGRADATION_PREFERENCE_MAINTAIN_FRAMERATE_AND_RESOLUTION = 4;
+     */
+    MAINTAIN_FRAMERATE_AND_RESOLUTION = 4
+}
 declare class CallState$Type extends MessageType<CallState> {
     constructor();
 }

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

@@ -6,19 +6,19 @@ import { Tracer } from '../stats';
  * remote participants whose audio streams have no bound element.
  */
 export declare class AudioBindingsWatchdog {
-    private state;
-    private tracer;
     private bindings;
     private enabled;
     private watchdogInterval?;
     private readonly unsubscribeCallingState;
     private logger;
+    private readonly state;
+    private readonly tracer;
     constructor(state: CallState, tracer: Tracer);
     /**
      * Registers an audio element binding for the given session and track type.
      * Warns if a different element is already bound to the same key.
      */
-    register: (audioElement: HTMLAudioElement, sessionId: string, trackType: AudioTrackType) => void;
+    register: (element: HTMLAudioElement, sessionId: string, trackType: AudioTrackType) => void;
     /**
      * Removes the audio element binding for the given session and track type.
      */

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

@@ -0,0 +1,30 @@
+import { Tracer } from '../stats';
+/**
+ * Tracks audio elements that the browser's autoplay policy has blocked.
+ */
+export declare class BlockedAudioTracker {
+    private logger;
+    private tracer;
+    private blockedElementsSubject;
+    /**
+     * Whether the browser's autoplay policy is blocking audio playback.
+     * Will be `true` when at least one audio element is currently blocked.
+     * Use {@link resumeAudio} within a user gesture to unblock.
+     */
+    autoplayBlocked$: import("rxjs").Observable<boolean>;
+    constructor(tracer: Tracer);
+    /**
+     * Registers an audio element as blocked by the browser's autoplay policy.
+     */
+    markBlocked: (audioElement: HTMLAudioElement, blocked: boolean) => void;
+    /**
+     * Returns whether the given audio element is currently flagged as blocked
+     * by the browser's autoplay policy.
+     */
+    isBlocked: (audioElement: HTMLAudioElement) => boolean;
+    /**
+     * Plays all audio elements blocked by the browser's autoplay policy.
+     * Must be called from within a user gesture (e.g., click handler).
+     */
+    resumeAudio: () => Promise<void>;
+}

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

@@ -1,102 +1,32 @@
-import { AudioTrackType, DebounceType, VideoTrackType } from '../types';
-import { VideoDimension } from '../gen/video/sfu/models/models';
-import { ViewportTracker } from './ViewportTracker';
-import { AudioBindingsWatchdog } from './AudioBindingsWatchdog';
-import type { TrackSubscriptionDetails } from '../gen/video/sfu/signal_rpc/signal';
+import { AudioTrackType, VideoTrackType } from '../types';
+import type { BlockedAudioTracker } from './BlockedAudioTracker';
+import type { TrackSubscriptionManager } from './TrackSubscriptionManager';
 import { CallState } from '../store';
-import type { StreamSfuClient } from '../StreamSfuClient';
 import { SpeakerManager } from '../devices';
 import { Tracer } from '../stats';
-type VideoTrackSubscriptionOverride = {
-    enabled: true;
-    dimension: VideoDimension;
-} | {
-    enabled: false;
-};
-declare const globalOverrideKey: unique symbol;
-interface VideoTrackSubscriptionOverrides {
-    [sessionId: string]: VideoTrackSubscriptionOverride | undefined;
-    [globalOverrideKey]?: VideoTrackSubscriptionOverride;
-}
 /**
  * A manager class that handles dynascale related tasks like:
  *
  * - binding video elements to session ids
  * - binding audio elements to session ids
- * - tracking element visibility
- * - updating subscriptions based on viewport visibility
- * - updating subscriptions based on video element dimensions
- * - updating subscriptions based on published tracks
  */
 export declare class DynascaleManager {
-    /**
-     * The viewport tracker instance.
-     */
-    readonly viewportTracker: ViewportTracker;
     private logger;
     private callState;
     private speaker;
-    private tracer;
+    private readonly tracer;
     private useWebAudio;
     private audioContext;
-    private sfuClient;
-    private pendingSubscriptionsUpdate;
-    readonly audioBindingsWatchdog: AudioBindingsWatchdog | undefined;
-    /**
-     * Audio elements that were blocked by the browser's autoplay policy.
-     * These can be retried by calling `resumeAudio()` from a user gesture.
-     */
-    private blockedAudioElementsSubject;
-    /**
-     * Whether the browser's autoplay policy is blocking audio playback.
-     * Will be `true` when the browser blocks autoplay (e.g., no prior user interaction).
-     * Use `resumeAudio()` within a user gesture to unblock.
-     */
-    autoplayBlocked$: import("rxjs").Observable<boolean>;
-    private addBlockedAudioElement;
-    private removeBlockedAudioElement;
-    private videoTrackSubscriptionOverridesSubject;
-    videoTrackSubscriptionOverrides$: import("rxjs").Observable<VideoTrackSubscriptionOverrides>;
-    incomingVideoSettings$: import("rxjs").Observable<{
-        enabled: boolean;
-        preferredResolution: VideoDimension | undefined;
-        participants: {
-            [k: string]: {
-                enabled: boolean;
-                preferredResolution: VideoDimension | undefined;
-            };
-        };
-        isParticipantVideoEnabled: (sessionId: string) => boolean;
-    }>;
+    private trackSubscriptionManager;
+    private blockedAudioTracker;
     /**
      * Creates a new DynascaleManager instance.
      */
-    constructor(callState: CallState, speaker: SpeakerManager, tracer: Tracer);
+    constructor(callState: CallState, speaker: SpeakerManager, tracer: Tracer, trackSubscriptionManager: TrackSubscriptionManager, blockedAudioTracker: BlockedAudioTracker);
     /**
-     * Disposes the allocated resources and closes the audio context if it was created.
+     * Closes the audio context if it was created.
      */
     dispose: () => Promise<void>;
-    setSfuClient(sfuClient: StreamSfuClient | undefined): void;
-    get trackSubscriptions(): TrackSubscriptionDetails[];
-    get videoTrackSubscriptionOverrides(): VideoTrackSubscriptionOverrides;
-    setVideoTrackSubscriptionOverrides: (override: VideoTrackSubscriptionOverride | undefined, sessionIds?: string[]) => VideoTrackSubscriptionOverrides;
-    applyTrackSubscriptions: (debounceType?: DebounceType) => void;
-    /**
-     * Will begin tracking the given element for visibility changes within the
-     * configured viewport element (`call.setViewport`).
-     *
-     * @param element the element to track.
-     * @param sessionId the session id.
-     * @param trackType the kind of video.
-     * @returns Untrack.
-     */
-    trackElementVisibility: <T extends HTMLElement>(element: T, sessionId: string, trackType: VideoTrackType) => () => void;
-    /**
-     * Sets the viewport element to track bound video elements for visibility.
-     *
-     * @param element the viewport element.
-     */
-    setViewport: <T extends HTMLElement>(element: T) => () => void;
     /**
      * Sets whether to use WebAudio API for audio playback.
      * Must be set before joining the call.
@@ -134,14 +64,6 @@ export declare class DynascaleManager {
      * @returns a cleanup function that will unbind the audio element.
      */
     bindAudioElement: (audioElement: HTMLAudioElement, sessionId: string, trackType: AudioTrackType) => (() => void) | undefined;
-    /**
-     * Plays all audio elements blocked by the browser's autoplay policy.
-     * Must be called from within a user gesture (e.g., click handler).
-     *
-     * @returns a promise that resolves when all blocked elements have been retried.
-     */
-    resumeAudio: () => Promise<void>;
     private getOrCreateAudioContext;
     private resumeAudioContext;
 }
-export {};

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

@@ -0,0 +1,32 @@
+import { Tracer } from '../stats';
+type MediaKind = 'audio' | 'video';
+export type MediaPlaybackWatchdogOptions = {
+    element: HTMLMediaElement;
+    kind: MediaKind;
+    tracer: Tracer;
+    isBlocked?: () => boolean;
+};
+/**
+ * Watches a single audio or video element and attempts to recover playback
+ * after the element transitions to a paused or suspended state unexpectedly.
+ */
+export declare class MediaPlaybackWatchdog {
+    private logger;
+    private readonly kind;
+    private readonly isBlocked;
+    private element;
+    private tracer;
+    private controller;
+    private pendingTimer;
+    private attempt;
+    private disposed;
+    constructor(opts: MediaPlaybackWatchdogOptions);
+    private attach;
+    dispose: () => void;
+    private onPlaying;
+    private onPauseOrSuspend;
+    private scheduleRecovery;
+    private computeSkipReason;
+    private attemptPlay;
+}
+export {};