@stream-io/video-client 1.49.0 → 1.51.0

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 {};

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

@@ -27,7 +27,7 @@ export declare abstract class BasePeerConnection {
     private iceRestartTimeout?;
     private preConnectStuckTimeout?;
     protected isIceRestarting: boolean;
-    private isDisposed;
+    protected isDisposed: boolean;
     protected trackIdToTrackType: Map<string, TrackType>;
     readonly tracer?: Tracer;
     readonly stats: StatsTracer;
@@ -42,7 +42,7 @@ export declare abstract class BasePeerConnection {
     /**
      * Disposes the `RTCPeerConnection` instance.
      */
-    dispose(): void;
+    dispose(): Promise<void>;
     /**
      * Detaches the event handlers from the `RTCPeerConnection`.
      */
@@ -62,6 +62,11 @@ export declare abstract class BasePeerConnection {
      * Consecutive events are queued and executed one after the other.
      */
     protected on: <E extends keyof AllSfuEvents>(event: E, fn: CallEventListener<E>) => void;
+    /**
+     * Returns the per-event `withoutConcurrency` tag used to serialize the
+     * dispatcher handler for `event` on this peer connection.
+     */
+    protected eventLockKey: (event: keyof AllSfuEvents) => string;
     /**
      * Appends the trickled ICE candidates to the `RTCPeerConnection`.
      */

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

@@ -17,7 +17,7 @@ export declare class Publisher extends BasePeerConnection {
     /**
      * Disposes this Publisher instance.
      */
-    dispose(): void;
+    dispose(): Promise<void>;
     /**
      * Starts publishing the given track of the given media stream.
      *
@@ -51,14 +51,31 @@ 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.
      */
-    stopTracks: (...trackTypes: TrackType[]) => void;
+    stopTracks: (...trackTypes: TrackType[]) => Promise<void>;
     /**
      * Stops all the cloned tracks that are being published to the SFU.
      */
-    stopAllTracks: () => void;
+    stopAllTracks: () => Promise<void>;
     private changePublishQuality;
     /**
      * Restarts the ICE connection and renegotiates with the SFU.
@@ -91,4 +108,22 @@ export declare class Publisher extends BasePeerConnection {
     private toTrackInfo;
     private cloneTrack;
     private stopTrack;
+    /**
+     * Silences a Firefox sender on the wire during unpublish.
+     *
+     * Firefox keeps emitting RTP after track.stop(), but the right lever
+     * differs by track type:
+     *   - audio: `replaceTrack(null)` is the only reliable silencer;
+     *     `setParameters({encodings:[...active:false]})` does NOT stop
+     *     the Opus encoder.
+     *   - video: `setParameters({encodings:[...active:false]})` pauses
+     *     the encoder; `replaceTrack(null)` does NOT reliably stop the
+     *     video encoder. The prior active=true configuration is captured
+     *     onto `bundle.videoSender` so `updateTransceiver` can restore
+     *     it on the next publish.
+     *
+     * No-op on non-Firefox browsers and during teardown.
+     */
+    private silenceSenderOnFirefox;
+    private disableAllEncodings;
 }

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/TransceiverCache.d.ts

@@ -1,4 +1,4 @@
-import { PublishOption } from '../gen/video/sfu/models/models';
+import { PublishOption, TrackType } from '../gen/video/sfu/models/models';
 import type { OptimalVideoLayer } from './layers';
 import type { PublishBundle } from './types';
 export declare class TransceiverCache {
@@ -18,6 +18,10 @@ export declare class TransceiverCache {
      * Gets the transceiver for the given publish option.
      */
     get: (publishOption: PublishOption) => PublishBundle | undefined;
+    /**
+     * Gets the transceiver for the given publish option id and track type.
+     */
+    getBy: (publishOptionId: number, trackType: TrackType) => PublishBundle | undefined;
     /**
      * Updates the cached bundle with the given patch.
      */

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

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

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

@@ -4,6 +4,7 @@ import { CallState } from '../store';
 import { Dispatcher } from './Dispatcher';
 import type { OptimalVideoLayer } from './layers';
 import type { ClientPublishOptions } from '../types';
+import type { VideoSender } from '../gen/video/sfu/event/events';
 /**
  * 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
@@ -55,6 +56,7 @@ export type PublishBundle = {
     publishOption: PublishOption;
     transceiver: RTCRtpTransceiver;
     options: TrackPublishOptions;
+    videoSender?: VideoSender;
 };
 export type TrackLayersCache = {
     publishOption: PublishOption;

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.49.0",
+  "version": "1.51.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.1",
     "@stream-io/node-sdk": "^0.7.28",
     "@total-typescript/shoehorn": "^0.1.2",
     "@types/sdp-transform": "^2.15.0",