@stream-io/video-client 1.52.1-beta.0 → 1.53.1

package/dist/src/Call.d.ts

@@ -5,6 +5,7 @@ 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 type { ClientEventReporter } from './reporting';
 import { AudioBindingsWatchdog } from './helpers/AudioBindingsWatchdog';
 import { BlockedAudioTracker } from './helpers/BlockedAudioTracker';
 import { TrackSubscriptionManager } from './helpers/TrackSubscriptionManager';
@@ -107,6 +108,7 @@ export declare class Call {
     private dropTimeout;
     private readonly clientStore;
     readonly streamClient: StreamClient;
+    readonly clientEventReporter: ClientEventReporter;
     private sfuClient?;
     private sfuClientTag;
     private unifiedSessionId?;
@@ -127,7 +129,6 @@ export declare class Call {
     private joinResponseTimeout?;
     private rpcRequestTimeout?;
     private joinCallData?;
-    private selfSubEnabled;
     private hasJoinedOnce;
     private deviceSettingsAppliedOnce;
     private credentials?;
@@ -153,7 +154,7 @@ export declare class Call {
      * Use the [`StreamVideoClient.call`](./StreamVideoClient.md/#call)
      * method to construct a `Call` instance.
      */
-    constructor({ type, id, streamClient, members, ownCapabilities, sortParticipantsBy, clientStore, ringing, watching, }: CallConstructor);
+    constructor({ type, id, streamClient, clientEventReporter, members, ownCapabilities, sortParticipantsBy, clientStore, ringing, watching, }: CallConstructor);
     /**
      * Sets up the call instance.
      *
@@ -191,16 +192,6 @@ export declare class Call {
      * Retrieves the current user ID.
      */
     get currentUserId(): string | undefined;
-    /**
-     * A flag indicating whether self-subscription is enabled for the call.
-     */
-    get isSelfSubEnabled(): boolean;
-    /**
-     * The largest video publish dimension across the current publish options.
-     *
-     * @internal
-     */
-    getMaxVideoPublishDimension: () => VideoDimension | undefined;
     /**
      * A flag indicating whether the call was created by the current user.
      */
@@ -273,11 +264,10 @@ export declare class Call {
      *
      * @returns a promise which resolves once the call join-flow has finished.
      */
-    join: ({ maxJoinRetries, joinResponseTimeout, rpcRequestTimeout, selfSubEnabled, ...data }?: JoinCallData & {
+    join: ({ maxJoinRetries, joinResponseTimeout, rpcRequestTimeout, ...data }?: JoinCallData & {
         maxJoinRetries?: number;
         joinResponseTimeout?: number;
         rpcRequestTimeout?: number;
-        selfSubEnabled?: boolean;
     }) => Promise<void>;
     /**
      * Will make a single attempt to watch for call related WebSocket events
@@ -848,6 +838,8 @@ export declare class Call {
      * @param trackType the kind of video.
      */
     bindVideoElement: (videoElement: HTMLVideoElement, sessionId: string, trackType: VideoTrackType) => (() => void) | undefined;
+    private bindFirstVideoFrameDetector;
+    private reportFirstRenderedVideoFrame;
     /**
      * Binds a DOM <audio> element to the given session id.
      *

package/dist/src/StreamVideoClient.d.ts

@@ -5,6 +5,7 @@ import type { ConnectedEvent, CreateDeviceRequest, CreateGuestRequest, CreateGue
 import { AllClientEvents, ClientEventListener, StreamClientOptions, TokenOrProvider, User } from './coordinator/connection/types';
 import type { StreamVideoClientOptions } from './types';
 import { ScopedLogger } from './logger';
+import { ClientEventReporter } from './reporting';
 /**
  * A `StreamVideoClient` instance lets you communicate with our API, and authenticate users.
  */
@@ -21,6 +22,7 @@ export declare class StreamVideoClient {
     readonly logger: ScopedLogger;
     protected readonly writeableStateStore: StreamVideoWriteableStateStore;
     streamClient: StreamClient;
+    readonly clientEventReporter: ClientEventReporter;
     private effectsRegistered;
     private eventHandlersToUnregister;
     private readonly connectionConcurrencyTag;

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

@@ -137,6 +137,7 @@ export declare class StreamClient {
      * @private
      */
     connect: () => Promise<ConnectedEvent | undefined>;
+    getSdkVersion: () => string;
     getUserAgent: () => string;
     _enrichAxiosOptions: (options?: AxiosRequestConfig & {
         config?: AxiosRequestConfig;

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

@@ -71,5 +71,11 @@ export declare class MicrophoneManager extends AudioDeviceManager<MicrophoneMana
     private startSpeakingWhileMutedDetection;
     private stopSpeakingWhileMutedDetection;
     private teardownSpeakingWhileMutedDetection;
+    /**
+     * iOS-only: keep the mic-input chain prepared while muted
+     * so the `AVAudioEngine` stays full-duplex and remote audio renders on a
+     * muted join.
+     */
+    private setMutedRecordingPrepared;
     private hasPermission;
 }

package/dist/src/errors/SfuTimeoutError.d.ts

@@ -0,0 +1,8 @@
+/**
+ * An error thrown when a client-side SFU deadline (e.g., waiting for the
+ * signaling WS to open or for the `joinResponse` to arrive) fires before
+ * the awaited operation resolves. Allows consumers (e.g., the client event
+ * reporter) to classify timeouts without relying on message wording.
+ */
+export declare class SfuTimeoutError extends Error {
+}

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

@@ -1 +1,2 @@
 export * from './SfuJoinError';
+export * from './SfuTimeoutError';

package/dist/src/gen/google/protobuf/struct.d.ts

@@ -1,6 +1,4 @@
-import type { JsonValue } from '@protobuf-ts/runtime';
-import type { JsonReadOptions } from '@protobuf-ts/runtime';
-import type { JsonWriteOptions } from '@protobuf-ts/runtime';
+import type { JsonReadOptions, JsonValue, JsonWriteOptions } from '@protobuf-ts/runtime';
 import { MessageType } from '@protobuf-ts/runtime';
 /**
  * `Struct` represents a structured data value, consisting of fields

package/dist/src/gen/google/protobuf/timestamp.d.ts

@@ -1,6 +1,4 @@
-import type { JsonValue } from '@protobuf-ts/runtime';
-import type { JsonReadOptions } from '@protobuf-ts/runtime';
-import type { JsonWriteOptions } from '@protobuf-ts/runtime';
+import type { JsonReadOptions, JsonValue, JsonWriteOptions } from '@protobuf-ts/runtime';
 import { MessageType } from '@protobuf-ts/runtime';
 /**
  * A Timestamp represents a point in time independent of any time zone or local

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

@@ -1,27 +1,6 @@
 import { MessageType } from '@protobuf-ts/runtime';
-import { CallEndedReason } from '../models/models';
-import { GoAwayReason } from '../models/models';
-import { CallGrants } from '../models/models';
-import { DegradationPreference } from '../models/models';
-import { Codec } from '../models/models';
-import { ConnectionQuality } from '../models/models';
-import { CallState } 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';
-import { TrackInfo } from '../models/models';
-import { ParticipantSource } from '../models/models';
-import { ClientCapability } from '../models/models';
-import { SubscribeOption } from '../models/models';
-import { ClientDetails } from '../models/models';
-import { TrackUnpublishReason } from '../models/models';
-import { Participant } from '../models/models';
-import { TrackType } from '../models/models';
-import { ParticipantCount } from '../models/models';
-import { PeerType } from '../models/models';
-import { WebsocketReconnectStrategy } from '../models/models';
-import { Error as Error$ } from '../models/models';
-import { Pin } from '../models/models';
-import { PublishOption } from '../models/models';
-import { ICETrickle as ICETrickle$ } from '../models/models';
 /**
  * SFUEvent is a message that is sent from the SFU to the client.
  *

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

@@ -411,10 +411,6 @@ export interface TrackInfo {
      * @generated from protobuf field: int32 publish_option_id = 12;
      */
     publishOptionId: number;
-    /**
-     * @generated from protobuf field: bool self_sub_audio_video = 13;
-     */
-    selfSubAudioVideo: boolean;
 }
 /**
  * @generated from protobuf message stream.video.sfu.models.Error

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

@@ -1,27 +1,6 @@
-import type { RpcTransport } from '@protobuf-ts/runtime-rpc';
-import type { ServiceInfo } from '@protobuf-ts/runtime-rpc';
-import type { StopNoiseCancellationResponse } from './signal';
-import type { StopNoiseCancellationRequest } from './signal';
-import type { StartNoiseCancellationResponse } from './signal';
-import type { StartNoiseCancellationRequest } from './signal';
-import type { SendMetricsResponse } from './signal';
-import type { SendMetricsRequest } from './signal';
-import type { SendStatsResponse } from './signal';
-import type { SendStatsRequest } from './signal';
-import type { ICERestartResponse } from './signal';
-import type { ICERestartRequest } from './signal';
-import type { UpdateMuteStatesResponse } from './signal';
-import type { UpdateMuteStatesRequest } from './signal';
-import type { UpdateSubscriptionsResponse } from './signal';
-import type { UpdateSubscriptionsRequest } from './signal';
-import type { ICETrickleResponse } from './signal';
+import type { RpcOptions, RpcTransport, ServiceInfo, UnaryCall } from '@protobuf-ts/runtime-rpc';
+import type { ICERestartRequest, ICERestartResponse, ICETrickleResponse, SendAnswerRequest, SendAnswerResponse, SendMetricsRequest, SendMetricsResponse, SendStatsRequest, SendStatsResponse, SetPublisherRequest, SetPublisherResponse, StartNoiseCancellationRequest, StartNoiseCancellationResponse, StopNoiseCancellationRequest, StopNoiseCancellationResponse, UpdateMuteStatesRequest, UpdateMuteStatesResponse, UpdateSubscriptionsRequest, UpdateSubscriptionsResponse } from './signal';
 import type { ICETrickle } from '../models/models';
-import type { SendAnswerResponse } from './signal';
-import type { SendAnswerRequest } from './signal';
-import type { SetPublisherResponse } from './signal';
-import type { SetPublisherRequest } from './signal';
-import type { UnaryCall } from '@protobuf-ts/runtime-rpc';
-import type { RpcOptions } from '@protobuf-ts/runtime-rpc';
 /**
  * @generated from protobuf service stream.video.sfu.signal.SignalServer
  */

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

@@ -0,0 +1,7 @@
+/**
+ * Invokes `onFirstFrame` once when the video element renders a frame.
+ *
+ * Uses `requestVideoFrameCallback` when available, falling back to `loadeddata`
+ * for browsers that don't support it.
+ */
+export declare const createFirstVideoFrameDetector: (videoElement: HTMLVideoElement, onFirstFrame: () => void) => () => void;

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

@@ -0,0 +1,84 @@
+import { TrackType } from '../gen/video/sfu/models/models';
+import type { StreamClient } from '../coordinator/connection/client';
+import type { PeerConnectionStateChangeEvent } from '../rtc';
+export type ClientEventPeerConnection = 'publish' | 'subscribe';
+export type ClientEventStage = 'JoinInitiated' | 'CoordinatorWS' | 'MediaDevicePermission' | 'CoordinatorJoin' | 'WSJoin' | 'PeerConnectionConnect' | 'FirstVideoFrame' | 'FirstAudioFrame';
+export type MediaPermissionState = 'INITIATED' | 'FAILED' | 'GRANTED' | 'NOT_INITIATED';
+export type JoinReason = 'first-attempt' | 'network-available' | 'migration' | 'full-rejoin';
+export type ClientEventStandardCode = 'CLIENT_ABORTED' | 'BACKEND_LEAVE' | 'REQUEST_TIMEOUT' | 'NETWORK_ERROR' | 'SFU_ERROR' | 'SFU_GO_AWAY' | 'ICE_CONNECTIVITY_FAILED' | 'DTLS_CONNECTIVITY_FAILED';
+export type CallReportContext = {
+    callType: string;
+    callId: string;
+    getSfuId: () => string;
+    getCallSessionId: () => string;
+    getUserSessionId: () => string;
+};
+export type ClientEventReporterOptions = {
+    streamClient: StreamClient;
+};
+export declare class ClientEventReporter {
+    private readonly logger;
+    private streamClient;
+    private coordinatorConnectId?;
+    private coordinatorConnectUserId?;
+    private coordinatorWsPair?;
+    private callContexts;
+    private joinAttemptIds;
+    private joinReasons;
+    private coordinatorPairs;
+    private wsPairs;
+    private peerConnectionPairs;
+    private pcEverConnected;
+    private firstFrameReported;
+    constructor(options: ClientEventReporterOptions);
+    /**
+     * Starts a new coordinator connection correlation scope.
+     *
+     * @param userId the id of the user being connected. Captured here because
+     * the `CoordinatorWS` stage emits before the connection flow assigns
+     * the user to the client, so it can't be read from the client yet.
+     */
+    startCoordinatorConnection: (userId?: string) => string;
+    trackCoordinatorWs: <T>(op: () => Promise<T>) => Promise<T>;
+    private beginCoordinatorWs;
+    private succeedCoordinatorWs;
+    closeCoordinatorWs: () => void;
+    private buildCoordinatorWsCommon;
+    private emitMediaPermission;
+    registerCall: (cid: string, ctx: CallReportContext) => void;
+    unregisterCall: (cid: string) => void;
+    startCorrelation: (cid: string, joinReason: JoinReason) => void;
+    withJoinLifecycle: <T>(cid: string, joinReason: JoinReason, op: () => Promise<T>) => Promise<T>;
+    track: <T>(cid: string, stage: "CoordinatorJoin" | "WSJoin", op: () => Promise<T>) => Promise<T>;
+    reportFirstFrame: (cid: string, trackType: TrackType, trackId: string) => void;
+    captureWsError: (cid: string, opts: {
+        code: string;
+        reason: string;
+    }) => void;
+    close: (cid: string) => void;
+    abort: (cid: string, opts: {
+        code: "CLIENT_ABORTED" | "BACKEND_LEAVE";
+        reason: string;
+    }) => void;
+    private closeCallPairs;
+    private emitJoinInitiated;
+    private beginAttempt;
+    private succeedAttempt;
+    private applyStageError;
+    private beginCoordinatorAttempt;
+    private succeedCoordinator;
+    private failCoordinator;
+    private beginWsAttempt;
+    private succeedWs;
+    private failWs;
+    onPeerConnectionStateChange: (cid: string, event: PeerConnectionStateChangeEvent) => void;
+    private openPeerConnectionPair;
+    private emitPeerConnectionSuccess;
+    private emitPeerConnectionFailure;
+    private getSfuId;
+    private getUserSessionId;
+    private sessionIdField;
+    private buildCommon;
+    private send;
+    private sendWithRetry;
+}

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

@@ -0,0 +1 @@
+export * from './ClientEventReporter';

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

@@ -5,7 +5,7 @@ import { PeerType, TrackType } from '../gen/video/sfu/models/models';
 import { StreamSfuClient } from '../StreamSfuClient';
 import { AllSfuEvents, Dispatcher } from './Dispatcher';
 import { StatsTracer, Tracer } from '../stats';
-import { BasePeerConnectionOpts } from './types';
+import { BasePeerConnectionOpts, OnRemoteTrackUnmute } from './types';
 import type { ClientPublishOptions } from '../types';
 /**
  * A base class for the `Publisher` and `Subscriber` classes.
@@ -22,6 +22,8 @@ export declare abstract class BasePeerConnection {
     protected sfuClient: StreamSfuClient;
     private onReconnectionNeeded?;
     private onIceConnected?;
+    private onPeerConnectionStateChange?;
+    protected onRemoteTrackUnmute?: OnRemoteTrackUnmute;
     private readonly iceRestartDelay;
     private iceHasEverConnected;
     private iceRestartTimeout?;
@@ -37,7 +39,7 @@ export declare abstract class BasePeerConnection {
     /**
      * Constructs a new `BasePeerConnection` instance.
      */
-    protected constructor(peerType: PeerType, { sfuClient, connectionConfig, state, dispatcher, onReconnectionNeeded, onIceConnected, tag, enableTracing, clientPublishOptions, iceRestartDelay, statsTimestampDriftThresholdMs, }: BasePeerConnectionOpts);
+    protected constructor(peerType: PeerType, { sfuClient, connectionConfig, state, dispatcher, onReconnectionNeeded, onIceConnected, onPeerConnectionStateChange, onRemoteTrackUnmute, tag, enableTracing, clientPublishOptions, iceRestartDelay, statsTimestampDriftThresholdMs, }: BasePeerConnectionOpts);
     private createPeerConnection;
     /**
      * Disposes the `RTCPeerConnection` instance.
@@ -116,6 +118,7 @@ export declare abstract class BasePeerConnection {
      * Handles the ICE connection state change event.
      */
     private onIceConnectionStateChange;
+    private fireOnPeerConnectionStateChange;
     private handleConnectionStateUpdate;
     /**
      * Handles the ICE candidate error event.

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

@@ -10,13 +10,10 @@ export declare class Publisher extends BasePeerConnection {
     private readonly transceiverCache;
     private readonly clonedTracks;
     private publishOptions;
-    private readonly selfSubEnabled;
     /**
      * Constructs a new `Publisher` instance.
      */
-    constructor(baseOptions: BasePeerConnectionOpts, publishOptions: PublishOption[], opts?: {
-        selfSubEnabled?: boolean;
-    });
+    constructor(baseOptions: BasePeerConnectionOpts, publishOptions: PublishOption[]);
     /**
      * Disposes this Publisher instance.
      */

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

@@ -7,13 +7,6 @@ import { BasePeerConnectionOpts } from './types';
  * @internal
  */
 export declare class Subscriber extends BasePeerConnection {
-    /**
-     * Remote streams received from the SFU. For a self-sub case
-     * we need to be able to distinguish between the local capture stream.
-     * The map will never contain local streams so we can safely use it to
-     * check if the stream is remote and dispose it when needed.
-     */
-    private trackedStreams;
     /**
      * Constructs a new `Subscriber` instance.
      */

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

@@ -1,4 +1,4 @@
-import { AudioBitrateProfile, PeerType, PublishOption, WebsocketReconnectStrategy } from '../gen/video/sfu/models/models';
+import { AudioBitrateProfile, PeerType, PublishOption, TrackType, WebsocketReconnectStrategy } from '../gen/video/sfu/models/models';
 import { StreamSfuClient } from '../StreamSfuClient';
 import { CallState } from '../store';
 import { Dispatcher } from './Dispatcher';
@@ -37,6 +37,27 @@ export type OnReconnectionNeeded = (kind: WebsocketReconnectStrategy, reason: Re
  * recovered, not merely when the SFU join handshake succeeded.
  */
 export type OnIceConnected = (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
+ * either `iceConnectionState` or `peerConnectionState`.
+ */
+export type PeerConnectionStateChangeEvent = {
+    peerType: PeerType;
+    stateType: 'ice';
+    state: RTCIceConnectionState;
+} | {
+    peerType: PeerType;
+    stateType: 'peerConnection';
+    state: RTCPeerConnectionState;
+};
+export type OnPeerConnectionStateChange = (event: PeerConnectionStateChangeEvent) => void;
+/**
+ * Fired when a remote track starts receiving media (`unmute`). Used by
+ * telemetry to report the `FirstVideoFrame` / `FirstAudioFrame` stage; the
+ * consumer decides which track types are relevant.
+ */
+export type OnRemoteTrackUnmute = (trackType: TrackType, trackId: string) => void;
 export type BasePeerConnectionOpts = {
     sfuClient: StreamSfuClient;
     state: CallState;
@@ -44,6 +65,8 @@ export type BasePeerConnectionOpts = {
     dispatcher: Dispatcher;
     onReconnectionNeeded?: OnReconnectionNeeded;
     onIceConnected?: OnIceConnected;
+    onPeerConnectionStateChange?: OnPeerConnectionStateChange;
+    onRemoteTrackUnmute?: OnRemoteTrackUnmute;
     tag: string;
     enableTracing: boolean;
     iceRestartDelay?: number;

package/dist/src/types.d.ts

@@ -1,6 +1,7 @@
 import type { Participant, TrackType, VideoDimension } from './gen/video/sfu/models/models';
 import type { AudioSettingsRequestDefaultDeviceEnum, CallRecordingStartedEventRecordingTypeEnum, JoinCallRequest, MemberResponse, OwnCapability, ReactionResponse, StartRecordingRequest, StartRecordingResponse } from './gen/coordinator';
 import type { StreamClient } from './coordinator/connection/client';
+import type { ClientEventReporter } from './reporting';
 import type { RejectReason, StreamClientOptions, TokenProvider, User } from './coordinator/connection/types';
 import type { Comparator } from './sorting';
 import type { StreamVideoWriteableStateStore } from './store';
@@ -252,6 +253,10 @@ export type CallConstructor = {
      * The streamClient instance to use.
      */
     streamClient: StreamClient;
+    /**
+     * The shared client event reporter, owned by `StreamVideoClient`.
+     */
+    clientEventReporter: ClientEventReporter;
     /**
      * The Call type.
      */
@@ -382,6 +387,17 @@ export type StreamRNVideoSDKGlobals = {
          * Stops the in call manager.
          */
         stop({ isRingingTypeCall }: StreamRNVideoSDKCallManagerRingingParams): void;
+        /**
+         * iOS-only. Keeps the audio engine's microphone-input (voice-processing)
+         * chain prepared while the mic is muted, so the `AVAudioEngine` stays full-duplex
+         * meaning: mic going out and speaker coming in, simultaneously
+         *
+         * Without this, joining muted builds an output-only engine under the
+         * `PlayAndRecord`/`VoiceChat` (VPIO) session, which makes the remote audio
+         * not audible when joining muted. As echo cancellation expects the mic to be
+         * prepared.
+         */
+        setMutedRecordingPrepared?(enabled: boolean): void;
     };
     permissions: {
         /**

package/package.json

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