@stream-io/video-client 1.48.0 → 1.50.0

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

@@ -0,0 +1,28 @@
+/**
+ * A generic sliding-window rate limiter.
+ *
+ * Allows at most `maxAttempts` registrations inside a rolling `windowMs`.
+ * Attempts spaced further apart than `windowMs` are always allowed.
+ */
+export declare class SlidingWindowRateLimiter {
+    private maxAttempts;
+    private windowMs;
+    private timestamps;
+    constructor(maxAttempts: number, windowMs: number);
+    /**
+     * Attempts to register a new event at `now`. Returns `true` if the attempt
+     * fits inside the budget (and records it), or `false` if the budget is
+     * exhausted (in which case no timestamp is recorded).
+     */
+    tryRegister: (now?: number) => boolean;
+    /**
+     * Clears the attempt history.
+     */
+    reset: () => void;
+    /**
+     * Updates the budget and window size. Existing timestamps are kept; they
+     * will be pruned by the next `tryRegister` call.
+     */
+    setLimits: (maxAttempts: number, windowMs: number) => void;
+    private prune;
+}

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

@@ -0,0 +1,114 @@
+import { DebounceType } from '../types';
+import type { TrackSubscriptionDetails } from '../gen/video/sfu/signal_rpc/signal';
+import { VideoDimension } from '../gen/video/sfu/models/models';
+import { CallState } from '../store';
+import type { StreamSfuClient } from '../StreamSfuClient';
+import { Tracer } from '../stats';
+/**
+ * Per-participant (or global) video-subscription override.
+ *
+ * - `{ enabled: true, dimension }`: request video at a specific
+ *   resolution. If set globally, applies to every remote participant
+ *   that doesn't have a per-session override.
+ * - `{ enabled: false }`: unsubscribe from video entirely. The SFU
+ *   sends nothing; bandwidth is saved.
+ */
+export type VideoTrackSubscriptionOverride = {
+    enabled: true;
+    dimension: VideoDimension;
+} | {
+    enabled: false;
+};
+/** Symbol key for the "applies to all participants" override slot. */
+declare const globalOverrideKey: unique symbol;
+/**
+ * Map of per-session overrides plus one optional global override under
+ * the `globalOverrideKey` symbol slot.
+ */
+export interface VideoTrackSubscriptionOverrides {
+    [sessionId: string]: VideoTrackSubscriptionOverride | undefined;
+    [globalOverrideKey]?: VideoTrackSubscriptionOverride;
+}
+/**
+ * Owns the SFU-side video-subscription machinery for a `Call`:
+ *
+ * - Holds the per-session / global override state in a
+ *   `BehaviorSubject<VideoTrackSubscriptionOverrides>`.
+ * - Derives the SFU subscription list from `CallState` participants +
+ *   current overrides via the `subscriptions` getter.
+ * - Debounces and pushes the list to the SFU through
+ *   `sfuClient.updateSubscriptions`.
+ * - Exposes `incomingVideoSettings$`: a consumer-friendly projection of
+ *   the override state for React hooks.
+ *
+ * Owned by `DynascaleManager` as `readonly trackSubscriptionManager`.
+ * `DynascaleManager.bindVideoElement` triggers `apply()` on every
+ * dimension / visibility change.
+ */
+export declare class TrackSubscriptionManager {
+    private logger;
+    private callState;
+    private tracer;
+    private sfuClient;
+    private pendingUpdate;
+    private overridesSubject;
+    overrides$: import("rxjs").Observable<VideoTrackSubscriptionOverrides>;
+    /**
+     * Consumer-friendly projection of the override state. Used by the
+     * `useIncomingVideoSettings()` React hook.
+     */
+    incomingVideoSettings$: import("rxjs").Observable<{
+        enabled: boolean;
+        preferredResolution: VideoDimension | undefined;
+        participants: {
+            [k: string]: {
+                enabled: boolean;
+                preferredResolution: VideoDimension | undefined;
+            };
+        };
+        isParticipantVideoEnabled: (sessionId: string) => boolean;
+    }>;
+    /**
+     * Constructs new TrackSubscriptionManager instance.
+     *
+     * @param callState the call state.
+     * @param tracer the tracer to use.
+     */
+    constructor(callState: CallState, tracer: Tracer);
+    /**
+     * Sets the SFU client used by `apply()` to push subscription updates.
+     * Called by the owner on call join; cleared on leave.
+     */
+    setSfuClient: (sfuClient: StreamSfuClient | undefined) => void;
+    /**
+     * Cancels any pending debounced subscription push. Idempotent.
+     */
+    dispose: () => void;
+    /**
+     * The current SFU subscription list, computed from `CallState`
+     * participants and the override state. Used by:
+     *
+     * - `apply()` to push to the SFU each time the set changes.
+     * - `Call.getReconnectDetails` to include the subscription list in
+     *   the reconnect payload.
+     */
+    get subscriptions(): TrackSubscriptionDetails[];
+    get overrides(): VideoTrackSubscriptionOverrides;
+    /**
+     * Sets video-subscription overrides. Called by
+     * `Call.setIncomingVideoEnabled` and
+     * `Call.setPreferredIncomingVideoResolution`.
+     *
+     * - `sessionIds` omitted → applies `override` globally (or clears the
+     *   global override if `override` is `undefined`).
+     * - `sessionIds` provided → applies `override` to each listed session.
+     */
+    setOverrides: (override: VideoTrackSubscriptionOverride | undefined, sessionIds?: string[]) => VideoTrackSubscriptionOverrides;
+    /**
+     * Pushes `subscriptions` to the SFU. Debounced by `debounceType`
+     * (SLOW by default). Multiple rapid calls coalesce into one RPC.
+     * Passing `0` fires synchronously.
+     */
+    apply: (debounceType?: DebounceType) => void;
+}
+export {};

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

@@ -1,36 +1,30 @@
+import type { CallState } from '../store';
+import { VideoTrackType } from '../types';
 export type EntryHandler = (entry: IntersectionObserverEntry) => void;
 export type Unobserve = () => void;
 export type Observe = (element: HTMLElement, entryHandler: EntryHandler) => Unobserve;
 export declare class ViewportTracker {
-    /**
-     * @private
-     */
+    private callState;
     private elementHandlerMap;
-    /**
-     * @private
-     */
     private observer;
-    /**
-     * @private
-     */
     private queueSet;
+    constructor(callState: CallState);
     /**
      * Method to set scrollable viewport as root for the IntersectionObserver, returns
      * cleanup function to be invoked upon disposing of the DOM element to prevent memory leaks
-     *
-     * @param viewportElement
-     * @param options
-     * @returns Unobserve
      */
     setViewport: (viewportElement: HTMLElement, options?: Pick<IntersectionObserverInit, "threshold" | "rootMargin">) => () => void;
     /**
      * Method to set element to observe and handler to be triggered whenever IntersectionObserver
      * detects a possible change in element's visibility within specified viewport, returns
      * cleanup function to be invoked upon disposing of the DOM element to prevent memory leaks
-     *
-     * @param element
-     * @param handler
-     * @returns Unobserve
      */
     observe: Observe;
+    /**
+     * Tracks the given element for visibility changes and mirrors the result
+     * into `participant.viewportVisibilityState[trackType]` in `CallState`.
+     * Returns a function that unobserves the element and resets the visibility
+     * state back to `UNKNOWN`.
+     */
+    trackElementVisibility: <T extends HTMLElement>(element: T, sessionId: string, trackType: VideoTrackType) => () => void;
 }

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

@@ -2,6 +2,19 @@
  * Checks whether the current browser is Safari.
  */
 export declare const isSafari: () => boolean;
+/**
+ * Checks whether the current runtime is a WebKit-engine browser.
+ *
+ * Returns true for desktop Safari, iOS Safari, bare iOS WKWebView hosts
+ * (in-app browsers, React Native WebView, Tauri-on-macOS, etc.), and for
+ * Chromium / Gecko-branded iOS browsers (`CriOS`, `EdgiOS`, `OPiOS`,
+ * `FxiOS`) since Apple forces every iOS browser onto WKWebView and they
+ * share the underlying WebKit quirks.
+ *
+ * Returns false for desktop Chromium-based browsers (which reuse the
+ * `AppleWebKit/` token in their UA) and Android.
+ */
+export declare const isWebKit: () => boolean;
 /**
  * Checks whether the current browser is Firefox.
  */

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

@@ -1,3 +1,4 @@
+type TagKey = string | symbol | object;
 /**
  * Runs async functions serially. Useful for wrapping async actions that
  * should never run simultaneously: if marked with the same tag, functions
@@ -8,7 +9,7 @@
  * @param cb Async function to run.
  * @returns Promise that resolves when async functions returns.
  */
-export declare const withoutConcurrency: <T>(tag: string | symbol, cb: () => Promise<T>) => Promise<T>;
+export declare const withoutConcurrency: <T>(tag: TagKey, cb: () => Promise<T>) => Promise<T>;
 /**
  * Runs async functions serially, and cancels all other actions with the same tag
  * when a new action is scheduled. Useful for wrapping async actions that override
@@ -25,6 +26,7 @@ export declare const withoutConcurrency: <T>(tag: string | symbol, cb: () => Pro
  * start and was canceled, will resolve with 'canceled'. If the function started to run,
  * it's up to the function to decide how to react to cancelation.
  */
-export declare const withCancellation: <T>(tag: string | symbol, cb: (signal: AbortSignal) => Promise<T | "canceled">) => Promise<T | "canceled">;
-export declare function hasPending(tag: string | symbol): boolean;
-export declare function settled(tag: string | symbol): Promise<void>;
+export declare const withCancellation: <T>(tag: TagKey, cb: (signal: AbortSignal) => Promise<T | "canceled">) => Promise<T | "canceled">;
+export declare function hasPending(tag: TagKey): boolean;
+export declare function settled(tag: TagKey): Promise<void>;
+export {};

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 type { BasePeerConnectionOpts } from './types';
+import { BasePeerConnectionOpts } from './types';
 import type { ClientPublishOptions } from '../types';
 /**
  * A base class for the `Publisher` and `Subscriber` classes.
@@ -21,8 +21,11 @@ export declare abstract class BasePeerConnection {
     protected tag: string;
     protected sfuClient: StreamSfuClient;
     private onReconnectionNeeded?;
+    private onIceConnected?;
     private readonly iceRestartDelay;
+    private iceHasEverConnected;
     private iceRestartTimeout?;
+    private preConnectStuckTimeout?;
     protected isIceRestarting: boolean;
     private isDisposed;
     protected trackIdToTrackType: Map<string, TrackType>;
@@ -34,7 +37,7 @@ export declare abstract class BasePeerConnection {
     /**
      * Constructs a new `BasePeerConnection` instance.
      */
-    protected constructor(peerType: PeerType, { sfuClient, connectionConfig, state, dispatcher, onReconnectionNeeded, tag, enableTracing, clientPublishOptions, iceRestartDelay, }: BasePeerConnectionOpts);
+    protected constructor(peerType: PeerType, { sfuClient, connectionConfig, state, dispatcher, onReconnectionNeeded, onIceConnected, tag, enableTracing, clientPublishOptions, iceRestartDelay, }: BasePeerConnectionOpts);
     private createPeerConnection;
     /**
      * Disposes the `RTCPeerConnection` instance.
@@ -85,6 +88,12 @@ 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.

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

@@ -51,6 +51,23 @@ export declare class Publisher extends BasePeerConnection {
      * @param trackType the track type to check. If omitted, checks if any track is being published.
      */
     isPublishing: (trackType?: TrackType) => boolean;
+    /**
+     * Re-arms the encoder for the given track type by detaching and
+     * reattaching the currently published track on each matching sender.
+     *
+     * Workaround for a WebKit / iOS Safari quirk: after a system audio
+     * session interruption (Siri, PSTN call), the `RTCRtpSender` encoder
+     * can stop producing RTP packets even though the underlying
+     * `MediaStreamTrack` is `live` and `track.muted === false`.
+     * `replaceTrack(null)` followed by `replaceTrack(track)` resets the
+     * sender's encoder pipeline without renegotiation, restoring packet
+     * flow with the same SSRC.
+     *
+     * No-op when nothing is published for the given track type.
+     *
+     * @param trackType the track type to refresh.
+     */
+    refreshTrack: (trackType: TrackType) => Promise<void>;
     /**
      * Stops the cloned track that is being published to the SFU.
      */

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

@@ -22,5 +22,6 @@ export declare class Subscriber extends BasePeerConnection {
      */
     restartIce: () => Promise<void>;
     private handleOnTrack;
+    private setRemoteTrackInterrupted;
     private negotiate;
 }

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

@@ -0,0 +1,2 @@
+import { DegradationPreference } from '../../gen/video/sfu/models/models';
+export declare const toRTCDegradationPreference: (preference: DegradationPreference) => RTCDegradationPreference | undefined;

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

@@ -1,5 +1,6 @@
 export * from './codecs';
 export * from './Dispatcher';
+export * from './NegotiationError';
 export * from './IceTrickleBuffer';
 export * from './Publisher';
 export * from './Subscriber';

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

@@ -4,13 +4,45 @@ import { CallState } from '../store';
 import { Dispatcher } from './Dispatcher';
 import type { OptimalVideoLayer } from './layers';
 import type { ClientPublishOptions } from '../types';
-export type OnReconnectionNeeded = (kind: WebsocketReconnectStrategy, reason: string, peerType: PeerType) => void;
+/**
+ * Canonical reasons the SDK uses to trigger a reconnection. Free-form strings
+ * are still accepted at the callback boundary (e.g. when forwarding an SFU
+ * error message), but only the members below influence reconnect-loop
+ * behavior. In particular, `Call.reconnect` programmatically inspects
+ * `ICE_NEVER_CONNECTED` to drive the unsupported-network detector — pass a
+ * canonical member when you want the SDK to react to the reason; pass a
+ * free-form string when the value is purely diagnostic.
+ */
+export declare const ReconnectReason: {
+    /** ICE never reached `connected`/`completed`, escalate to REJOIN. */
+    readonly ICE_NEVER_CONNECTED: "ice_never_connected";
+    /** RTCPeerConnection.connectionState became `failed`. */
+    readonly CONNECTION_FAILED: "connection_failed";
+    /** `restartIce()` rejected. */
+    readonly RESTART_ICE_FAILED: "restart_ice_failed";
+    /** SFU `goAway` event, migrate to a new SFU. */
+    readonly GO_AWAY: "go_away";
+    /** Network came back online after going offline. */
+    readonly NETWORK_BACK_ONLINE: "network_back_online";
+    /** SFU error event with no descriptive message. */
+    readonly SFU_ERROR: "sfu_error";
+};
+export type ReconnectReason = (typeof ReconnectReason)[keyof typeof ReconnectReason] | (string & {});
+export type OnReconnectionNeeded = (kind: WebsocketReconnectStrategy, reason: ReconnectReason, peerType: PeerType) => void;
+/**
+ * Fires the first time a peer connection's ICE transport reaches
+ * `connected` or `completed` during its lifetime. Used by `Call` to reset
+ * the "ICE never connected" failure counter only when WebRTC has actually
+ * recovered, not merely when the SFU join handshake succeeded.
+ */
+export type OnIceConnected = (peerType: PeerType) => void;
 export type BasePeerConnectionOpts = {
     sfuClient: StreamSfuClient;
     state: CallState;
     connectionConfig?: RTCConfiguration;
     dispatcher: Dispatcher;
     onReconnectionNeeded?: OnReconnectionNeeded;
+    onIceConnected?: OnIceConnected;
     tag: string;
     enableTracing: boolean;
     iceRestartDelay?: number;

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

@@ -1,5 +1,5 @@
 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 | null | undefined;
+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;
 export type TraceRecord = [

package/dist/src/store/rxUtils.d.ts

@@ -1,5 +1,6 @@
 import { BehaviorSubject, Observable, Subject } from 'rxjs';
 type FunctionPatch<T> = (currentValue: T) => T;
+type AsyncFunctionPatch<T> = (currentValue: T) => Promise<T>;
 /**
  * A value or a function which takes the current value and returns a new value.
  */
@@ -21,6 +22,14 @@ export declare const getCurrentValue: <T>(observable$: Observable<T>) => T;
  * @return the updated value.
  */
 export declare const setCurrentValue: <T>(subject: Subject<T>, update: Patch<T>) => T;
+/**
+ * Updates the value of the provided Subject asynchronously.
+ * Locks the subject to prevent concurrent updates.
+ *
+ * @param subject the subject to update.
+ * @param update the update to apply to the subject.
+ */
+export declare const setCurrentValueAsync: <T>(subject: Subject<T>, update: AsyncFunctionPatch<T>) => Promise<T>;
 /**
  * Updates the value of the provided Subject and returns the previous value
  * and a function to roll back the update.

package/dist/src/types.d.ts

@@ -58,6 +58,24 @@ export interface StreamVideoParticipant extends Participant {
      * This is useful to avoid any unwanted video and audio artifacts.
      */
     pausedTracks?: TrackType[];
+    /**
+     * The list of tracks that are currently not producing media.
+     *
+     * For remote participants this is currently surfaced for `TrackType.AUDIO`
+     * only and reflects the receiver-side `RTCRtpReceiver` track `mute`/`unmute`
+     * state, so it covers system mute on the sender (OS audio session
+     * interruption, etc.), the sender pausing its track, sustained RTP stalls,
+     * and SFU drops. Remote video and screen-share interruption is not tracked.
+     *
+     * For the local participant it reflects the local track `mute`/`unmute`
+     * events surfaced by the browser (e.g. bluetooth disconnect, OS-level
+     * mic/camera kill switch, iOS audio session interruption).
+     *
+     * Orthogonal to `publishedTracks`: a track can be in `publishedTracks`
+     * AND in `interruptedTracks` (the participant intends to publish, but
+     * no media is flowing right now).
+     */
+    interruptedTracks?: TrackType[];
     /**
      * True if the participant is the local participant.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.48.0",
+  "version": "1.50.0",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
   "browser": "dist/index.browser.es.js",
@@ -46,7 +46,7 @@
     "@openapitools/openapi-generator-cli": "^2.25.0",
     "@rollup/plugin-replace": "^6.0.2",
     "@rollup/plugin-typescript": "^12.1.4",
-    "@stream-io/audio-filters-web": "^0.7.3",
+    "@stream-io/audio-filters-web": "^0.8.0",
     "@stream-io/node-sdk": "^0.7.28",
     "@total-typescript/shoehorn": "^0.1.2",
     "@types/sdp-transform": "^2.15.0",