@stream-io/video-client 1.54.0 → 1.55.0

package/dist/src/Call.d.ts

@@ -129,6 +129,7 @@ export declare class Call {
     private joinResponseTimeout?;
     private rpcRequestTimeout?;
     private joinCallData?;
+    private allowOwnTracksLoopback;
     private hasJoinedOnce;
     private deviceSettingsAppliedOnce;
     private credentials?;
@@ -192,6 +193,16 @@ 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 isOwnTracksLoopbackAllowed(): 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.
      */
@@ -264,10 +275,11 @@ export declare class Call {
      *
      * @returns a promise which resolves once the call join-flow has finished.
      */
-    join: ({ maxJoinRetries, joinResponseTimeout, rpcRequestTimeout, ...data }?: JoinCallData & {
+    join: ({ maxJoinRetries, joinResponseTimeout, rpcRequestTimeout, allowOwnTracksLoopback, ...data }?: JoinCallData & {
         maxJoinRetries?: number;
         joinResponseTimeout?: number;
         rpcRequestTimeout?: number;
+        allowOwnTracksLoopback?: boolean;
     }) => Promise<void>;
     /**
      * Will make a single attempt to watch for call related WebSocket events

package/dist/src/StreamSfuClient.d.ts

@@ -87,12 +87,20 @@ export declare class StreamSfuClient {
      * trigger a reconnection attempt.
      */
     isClosingClean: boolean;
+    /**
+     * One-shot latch guarding `onSignalClose`. The signal connection can be
+     * detected as dead by more than one source (the health watchdog and the
+     * WebSocket `close` event, which on a wedged socket can arrive seconds
+     * apart). This ensures revival is triggered at most once per client.
+     */
+    private signalClosed;
     private readonly rpc;
     private keepAliveInterval?;
-    private connectionCheckTimeout?;
+    private connectionCheckInterval?;
     private migrateAwayTimeout?;
     private readonly pingIntervalInMs;
     private readonly unhealthyTimeoutInMs;
+    private readonly connectionCheckIntervalInMs;
     private lastMessageTimestamp?;
     private readonly tracer?;
     private readonly unsubscribeIceTrickle;
@@ -127,7 +135,7 @@ export declare class StreamSfuClient {
     /**
      * The error code used when the SFU connection is unhealthy.
      * Usually, this means that no message has been received from the SFU for
-     * a certain amount of time (`connectionCheckTimeout`).
+     * a certain amount of time (`unhealthyTimeoutInMs`).
      */
     static ERROR_CONNECTION_UNHEALTHY: number;
     /**
@@ -154,7 +162,7 @@ export declare class StreamSfuClient {
     private createWebSocket;
     get isHealthy(): boolean;
     get joinTask(): Promise<JoinResponse>;
-    private handleWebSocketClose;
+    private notifySignalClose;
     close: (code?: number, reason?: string) => void;
     private dispose;
     getTrace: () => TraceSlice | undefined;

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

@@ -44,7 +44,7 @@ export declare class StableWSConnection {
     pingInterval: number;
     healthCheckTimeoutRef?: number;
     connectionCheckTimeout: number;
-    connectionCheckTimeoutRef?: NodeJS.Timeout;
+    connectionCheckTimeoutRef?: number;
     /** Store the last event time for health checks */
     lastEvent: Date | null;
     constructor(client: StreamClient);

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

@@ -1,4 +1,6 @@
-import type { JsonReadOptions, JsonValue, JsonWriteOptions } from '@protobuf-ts/runtime';
+import type { JsonValue } from '@protobuf-ts/runtime';
+import type { JsonReadOptions } from '@protobuf-ts/runtime';
+import type { 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,4 +1,6 @@
-import type { JsonReadOptions, JsonValue, JsonWriteOptions } from '@protobuf-ts/runtime';
+import type { JsonValue } from '@protobuf-ts/runtime';
+import type { JsonReadOptions } from '@protobuf-ts/runtime';
+import type { 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,6 +1,27 @@
 import { MessageType } from '@protobuf-ts/runtime';
-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 { 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 { 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,6 +411,10 @@ 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,6 +1,27 @@
-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 { 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 { 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/reporting/ClientEventReporter.d.ts

@@ -82,5 +82,6 @@ export declare class ClientEventReporter {
     private sessionIdField;
     private buildCommon;
     private send;
+    private sendForCall;
     private sendWithRetry;
 }

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, OnRemoteTrackUnmute } from './types';
+import { BasePeerConnectionOpts, OnReconnectionNeeded, OnRemoteTrackUnmute } from './types';
 import type { ClientPublishOptions } from '../types';
 /**
  * A base class for the `Publisher` and `Subscriber` classes.
@@ -20,7 +20,7 @@ export declare abstract class BasePeerConnection {
     protected readonly clientPublishOptions?: ClientPublishOptions;
     protected tag: string;
     protected sfuClient: StreamSfuClient;
-    private onReconnectionNeeded?;
+    protected onReconnectionNeeded?: OnReconnectionNeeded;
     private onIceConnected?;
     private onPeerConnectionStateChange?;
     protected onRemoteTrackUnmute?: OnRemoteTrackUnmute;
@@ -95,21 +95,11 @@ 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.
      */
     private onIceCandidate;
-    /**
-     * Converts the ICE candidate to a JSON string.
-     */
-    private asJSON;
     /**
      * Handles the ConnectionStateChange event.
      */

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

@@ -1,12 +1,50 @@
-import { ReplaySubject } from 'rxjs';
+import { Observable } from 'rxjs';
 import { ICETrickle } from '../gen/video/sfu/event/events';
+import { PeerType } from '../gen/video/sfu/models/models';
 /**
  * A buffer for ICE Candidates. Used for ICE Trickle:
  * - https://bloggeek.me/webrtcglossary/trickle-ice/
+ *
+ * The buffer is generation-aware: each peer connection tells it which ICE
+ * generation is current via `updateActiveGeneration` (whenever it applies an
+ * offer/answer). Candidate streams then emit only candidates of the active
+ * generation, hold candidates of a not-yet-applied (future) generation until
+ * it becomes active, and drop candidates of a superseded generation so they
+ * are never replayed. Candidates with no detectable generation, or before any
+ * generation is set, are emitted as-is (fail open).
  */
 export declare class IceTrickleBuffer {
-    readonly subscriberCandidates: ReplaySubject<RTCIceCandidateInit>;
-    readonly publisherCandidates: ReplaySubject<RTCIceCandidateInit>;
+    readonly subscriber: CandidateGenerationBuffer;
+    readonly publisher: CandidateGenerationBuffer;
     push: (iceTrickle: ICETrickle) => void;
+    /**
+     * Declares the ICE generation that is now current for the given peer type,
+     * derived from the `ice-ufrag` of the just-applied remote description.
+     * Candidates of superseded generations are evicted; candidates of the active
+     * generation flow to subscribers.
+     */
+    updateActiveGeneration: (peerType: PeerType, sdp: string | undefined) => void;
     dispose: () => void;
 }
+/**
+ * Per-peer-connection generation-aware candidate store. Retains trickled
+ * candidates and replays the active generation to each new subscriber, then
+ * forwards matching live candidates.
+ */
+declare class CandidateGenerationBuffer {
+    private readonly store;
+    private readonly live;
+    private readonly seenUfrags;
+    private activeUfrag;
+    readonly candidates: Observable<RTCIceCandidateInit>;
+    push: (candidate: RTCIceCandidateInit) => void;
+    updateActiveGeneration: (ufrag: string | undefined) => void;
+    dispose: () => void;
+    /**
+     * A candidate belongs to the current generation when its ufrag matches the
+     * active one. Fail open when either the candidate's generation or the active
+     * generation is unknown, so untagged candidates are never withheld.
+     */
+    private isCurrent;
+}
+export {};

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

@@ -1,6 +1,6 @@
+import { PublishOption, TrackInfo, TrackType } from '../gen/video/sfu/models/models';
 import { BasePeerConnection } from './BasePeerConnection';
 import type { BasePeerConnectionOpts, TrackPublishOptions } from './types';
-import { PublishOption, TrackInfo, TrackType } from '../gen/video/sfu/models/models';
 /**
  * The `Publisher` is responsible for publishing/unpublishing media streams to/from the SFU
  *
@@ -10,10 +10,13 @@ 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[]);
+    constructor(baseOptions: BasePeerConnectionOpts, publishOptions: PublishOption[], opts?: {
+        selfSubEnabled?: boolean;
+    });
     /**
      * Disposes this Publisher instance.
      */

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

@@ -7,6 +7,14 @@ 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?;
+    private negotiationFailures;
     /**
      * Constructs a new `Subscriber` instance.
      */

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

@@ -0,0 +1,12 @@
+/**
+ * Converts the ICE candidate to a JSON string.
+ */
+export declare const toJSON: (candidate: RTCIceCandidate) => string;
+/**
+ * Extracts the ICE ufrag from an SDP, or `undefined` when absent.
+ */
+export declare const parseIceUfrag: (sdp: string | undefined) => string | undefined;
+/**
+ * Extracts the ICE ufrag (generation) a trickled candidate was gathered under.
+ */
+export declare const getCandidateUfrag: (ice: RTCIceCandidateInit) => string | undefined;

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

@@ -21,6 +21,8 @@ export declare const ReconnectReason: {
     readonly CONNECTION_FAILED: "connection_failed";
     /** `restartIce()` rejected. */
     readonly RESTART_ICE_FAILED: "restart_ice_failed";
+    /** Subscriber renegotiation kept failing, escalate to REJOIN. */
+    readonly SUBSCRIBER_NEGOTIATION_FAILED: "subscriber_negotiation_failed";
     /** SFU `goAway` event, migrate to a new SFU. */
     readonly GO_AWAY: "go_away";
     /** Network came back online after going offline. */

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

@@ -36,14 +36,45 @@ export declare class SfuStatsReporter {
     private readonly sdkVersion;
     private readonly webRTCVersion;
     private readonly inputDevices;
+    private readonly statsConcurrencyTag;
+    private isStopped;
     constructor(sfuClient: StreamSfuClient, { options, clientDetails, subscriber, publisher, microphone, camera, state, tracer, unifiedSessionId, }: SfuStatsReporterOptions);
     private observeDevice;
     sendConnectionTime: (connectionTimeSeconds: number) => void;
     sendReconnectionTime: (strategy: WebsocketReconnectStrategy, timeSeconds: number) => void;
     private sendTelemetryData;
+    /**
+     * Samples both peer connections. Each `StatsTracer.takeSample()` is serialized
+     * internally, so this is safe even if it overlaps another sample (e.g. the
+     * connection-state-change handler). Kept separate from `send()` so an
+     * explicit flush can capture the sample from live peer connections before
+     * they are disposed, without waiting for an in-flight send.
+     */
+    private sample;
+    private send;
+    /**
+     * Samples and sends one report. Used by the scheduler and the telemetry path.
+     * Bails if the reporter has been stopped so it never samples disposed peer
+     * connections.
+     */
     private run;
     private scheduleNextReport;
     start: () => void;
     stop: () => void;
-    flush: () => void;
+    /**
+     * Explicit/final flush (leave, migration, re-init). Time-boxes the sampling
+     * step and swallows its failures, so a slow or failing `getStats()` on a
+     * degraded or closing peer connection can never block or reject call teardown
+     * or reconnect setup. On a successful sample it fires the send best-effort;
+     * the returned promise resolves once the sample is taken (or the time-box
+     * elapses / sampling fails), never when the sending completes. No-op once the
+     * reporter has been stopped.
+     */
+    flush: () => Promise<void>;
+    /**
+     * Flush entry for the periodic scheduler. Skips when the reporter is stopped
+     * or a send is already in flight so ticks can't pile up under slow sends (the
+     * next sample's delta spans the skipped interval).
+     */
+    private scheduledFlush;
 }

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

@@ -1,5 +1,5 @@
 import { PeerType, TrackType } from '../../gen/video/sfu/models/models';
-import type { ComputedStats } from './types';
+import type { ComputedStats, PendingDelta } from './types';
 /**
  * StatsTracer is a class that collects and processes WebRTC stats.
  * It is used to track the performance of the WebRTC connection
@@ -13,23 +13,53 @@ export declare class StatsTracer {
     private readonly peerType;
     private readonly trackIdToTrackType;
     private readonly driftThresholdMs;
+    private readonly maxPendingDeltas;
+    private readonly sampleTag;
     private costOverrides?;
-    private previousStats;
+    private previousSample;
     private frameTimeHistory;
     private fpsHistory;
+    /**
+     * The un-acked, delta-compressed samples awaiting delivery confirmation.
+     * Each entry's delta is computed against the immediately preceding sample,
+     * so the list forms a chain the server applies in order. The delivery
+     * baseline advances only when the reporter calls `commitDeltas` after a
+     * successful send; until then the chain is re-sent in full.
+     */
+    private pendingDeltas;
     /**
      * Creates a new StatsTracer instance.
      */
-    constructor(pc: RTCPeerConnection, peerType: PeerType, trackIdToTrackType: Map<string, TrackType>, statsTimestampDriftThresholdMs?: number);
+    constructor(pc: RTCPeerConnection, peerType: PeerType, trackIdToTrackType: Map<string, TrackType>, statsTimestampDriftThresholdMs?: number, maxPendingDeltas?: number);
+    /**
+     * Samples the RTCPeerConnection: returns the current stats report and the
+     * derived performance stats, and appends the delta-compressed sample to the
+     * un-acked delivery chain (retrieved via `getPendingDeltas`).
+     *
+     * @internal
+     */
+    takeSample: () => Promise<ComputedStats>;
+    /**
+     * Returns a stable copy of the un-acked delta chain to transmit, oldest first.
+     *
+     * @internal
+     */
+    getPendingDeltas: () => PendingDelta[];
+    /**
+     * Advances the delivery baseline by dropping exactly the deltas that were
+     * confirmed delivered. Matching is by object identity, so a stale commit
+     * that arrives after a re-anchor (which replaced the chain) is a safe no-op.
+     *
+     * @internal
+     */
+    commitDeltas: (sent: PendingDelta[]) => void;
     /**
-     * Get the stats from the RTCPeerConnection.
-     * When called, it will return the stats for the current connection.
-     * It will also return the delta between the current stats and the previous stats.
-     * This is used to track the performance of the connection.
+     * Drops the un-acked chain without sending it. Used when delta reporting is
+     * disabled so the chain can't grow unbounded.
      *
      * @internal
      */
-    get: () => Promise<ComputedStats>;
+    clearPendingDeltas: () => void;
     /**
      * Collects encode stats from the RTCPeerConnection.
      */

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

@@ -2,13 +2,20 @@ import type { RTCStatsDataType, Trace, TraceKey, TraceSlice } from './types';
 export declare class Tracer {
     private buffer;
     private enabled;
-    private readonly id;
+    readonly id: string | null;
+    private readonly maxBuffer;
     private keys?;
-    constructor(id: string | null);
+    constructor(id: string | null, maxBuffer?: number);
     setEnabled: (enabled: boolean) => void;
     trace: Trace;
     traceOnce: (key: TraceKey, tag: string, data: RTCStatsDataType) => void;
     resetTrace: (key: TraceKey) => void;
     take: () => TraceSlice;
     dispose: () => void;
+    /**
+     * Bounds the buffer to 2500 records by dropping the oldest ones,
+     * leaving a single `traceBufferOverflow` breadcrumb at the front so the
+     * consumer knows records were dropped.
+     */
+    private capBuffer;
 }

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

@@ -17,12 +17,18 @@ export type ComputedStats = {
      * Current stats from the RTCPeerConnection.
      */
     stats: RTCStatsReport;
-    /**
-     * Delta between the current stats and the previous stats.
-     */
-    delta: Record<any, any>;
     /**
      * The current iteration of the stats.
      */
     performanceStats: PerformanceStats[];
 };
+/**
+ * A single, not-yet-delivered delta-compressed stats sample.
+ * The `delta` is computed against the immediately preceding sample, so a
+ * sequence of `PendingDelta`s forms a chain that the server applies in order
+ * onto its running accumulator. `ts` is the wall-clock time the sample was taken.
+ */
+export type PendingDelta = {
+    delta: Record<any, any>;
+    ts: number;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.54.0",
+  "version": "1.55.0",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
   "browser": "dist/index.browser.es.js",
@@ -46,9 +46,11 @@
     "@openapitools/openapi-generator-cli": "^2.34.0",
     "@rollup/plugin-replace": "^6.0.3",
     "@rollup/plugin-typescript": "^12.3.0",
-    "@stream-io/audio-filters-web": "^0.8.2",
+    "@stream-io/audio-filters-web": "^0.9.0",
     "@stream-io/node-sdk": "^0.7.59",
+    "@stream-io/typescript-config": "^0.0.0",
     "@total-typescript/shoehorn": "^0.1.2",
+    "@types/node": "^25.9.3",
     "@types/sdp-transform": "^2.15.0",
     "@types/ua-parser-js": "^0.7.39",
     "@vitest/coverage-v8": "^4.1.7",
@@ -57,7 +59,7 @@
     "prettier": "^3.8.3",
     "rimraf": "^6.1.3",
     "rollup": "^4.60.4",
-    "typescript": "^5.9.3",
+    "typescript": "^6.0.3",
     "vitest": "^4.1.7",
     "vitest-mock-extended": "^4.0.0"
   }