@stream-io/video-client 1.48.0 → 1.49.0

package/src/helpers/__tests__/SlidingWindowRateLimiter.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest';
+import { SlidingWindowRateLimiter } from '../SlidingWindowRateLimiter';
+
+describe('SlidingWindowRateLimiter', () => {
+  it('allows up to the configured number of attempts inside the window', () => {
+    const limiter = new SlidingWindowRateLimiter(3, 1000);
+    expect(limiter.tryRegister(0)).toBe(true);
+    expect(limiter.tryRegister(10)).toBe(true);
+    expect(limiter.tryRegister(20)).toBe(true);
+    // fourth attempt inside the same window is denied
+    expect(limiter.tryRegister(30)).toBe(false);
+  });
+
+  it('prunes timestamps outside the rolling window so attempts after it pass', () => {
+    const limiter = new SlidingWindowRateLimiter(2, 1000);
+    expect(limiter.tryRegister(0)).toBe(true);
+    expect(limiter.tryRegister(500)).toBe(true);
+    expect(limiter.tryRegister(900)).toBe(false);
+    // at t=1501 cutoff=501, so both 0 and 500 fall out of window
+    expect(limiter.tryRegister(1501)).toBe(true);
+  });
+
+  it('reset() clears the attempt history', () => {
+    const limiter = new SlidingWindowRateLimiter(2, 1000);
+    limiter.tryRegister(0);
+    limiter.tryRegister(100);
+    expect(limiter.tryRegister(200)).toBe(false);
+    limiter.reset();
+    expect(limiter.tryRegister(300)).toBe(true);
+    expect(limiter.tryRegister(400)).toBe(true);
+    expect(limiter.tryRegister(500)).toBe(false);
+  });
+
+  it('setLimits() updates the budget and window in place', () => {
+    const limiter = new SlidingWindowRateLimiter(2, 1000);
+    limiter.tryRegister(0);
+    limiter.tryRegister(100);
+    expect(limiter.tryRegister(200)).toBe(false);
+    // raising the limit lets the next attempt through without reset
+    limiter.setLimits(5, 1000);
+    expect(limiter.tryRegister(300)).toBe(true);
+  });
+});

package/src/rpc/retryable.ts

@@ -44,7 +44,6 @@ export const retryable = async <
   let result: FinishedUnaryCall<I, O> | undefined = undefined;
   do {
     if (attempt > 0) await sleep(retryInterval(attempt));
-    if (signal?.aborted) throw new Error(signal.reason);
 
     try {
       result = await rpc({ attempt });

package/src/rtc/BasePeerConnection.ts

@@ -13,7 +13,12 @@ import { StreamSfuClient } from '../StreamSfuClient';
 import { AllSfuEvents, Dispatcher } from './Dispatcher';
 import { withoutConcurrency } from '../helpers/concurrency';
 import { StatsTracer, Tracer, traceRTCPeerConnection } from '../stats';
-import type { BasePeerConnectionOpts, OnReconnectionNeeded } from './types';
+import {
+  BasePeerConnectionOpts,
+  OnIceConnected,
+  OnReconnectionNeeded,
+  ReconnectReason,
+} from './types';
 import type { ClientPublishOptions } from '../types';
 
 /**
@@ -31,8 +36,11 @@ export abstract class BasePeerConnection {
   protected sfuClient: StreamSfuClient;
 
   private onReconnectionNeeded?: OnReconnectionNeeded;
+  private onIceConnected?: OnIceConnected;
   private readonly iceRestartDelay: number;
+  private iceHasEverConnected = false;
   private iceRestartTimeout?: NodeJS.Timeout;
+  private preConnectStuckTimeout?: NodeJS.Timeout;
   protected isIceRestarting = false;
   private isDisposed = false;
 
@@ -56,6 +64,7 @@ export abstract class BasePeerConnection {
       state,
       dispatcher,
       onReconnectionNeeded,
+      onIceConnected,
       tag,
       enableTracing,
       clientPublishOptions,
@@ -70,6 +79,7 @@ export abstract class BasePeerConnection {
     this.clientPublishOptions = clientPublishOptions;
     this.tag = tag;
     this.onReconnectionNeeded = onReconnectionNeeded;
+    this.onIceConnected = onIceConnected;
     this.logger = videoLoggerSystem.getLogger(
       peerType === PeerType.SUBSCRIBER ? 'Subscriber' : 'Publisher',
       { tags: [tag] },
@@ -108,7 +118,10 @@ export abstract class BasePeerConnection {
   dispose() {
     clearTimeout(this.iceRestartTimeout);
     this.iceRestartTimeout = undefined;
+    clearTimeout(this.preConnectStuckTimeout);
+    this.preConnectStuckTimeout = undefined;
     this.onReconnectionNeeded = undefined;
+    this.onIceConnected = undefined;
     this.isDisposed = true;
     this.detachEventHandlers();
     this.pc.close();
@@ -145,14 +158,17 @@ export abstract class BasePeerConnection {
    */
   protected tryRestartIce = () => {
     this.restartIce().catch((e) => {
-      const reason = 'restartICE() failed, initiating reconnect';
-      this.logger.error(reason, e);
+      this.logger.error('restartICE() failed, initiating reconnect', e);
       const strategy =
         e instanceof NegotiationError &&
         e.error.code === ErrorCode.PARTICIPANT_SIGNAL_LOST
           ? WebsocketReconnectStrategy.FAST
           : WebsocketReconnectStrategy.REJOIN;
-      this.onReconnectionNeeded?.(strategy, reason, this.peerType);
+      this.onReconnectionNeeded?.(
+        strategy,
+        ReconnectReason.RESTART_ICE_FAILED,
+        this.peerType,
+      );
     });
   };
 
@@ -239,6 +255,20 @@ export abstract class BasePeerConnection {
     return !failedStates.has(iceState) && !failedStates.has(connectionState);
   };
 
+  /**
+   * 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 = () => {
+    const iceState = this.pc.iceConnectionState;
+    const connectionState = this.pc.connectionState;
+    return (
+      (iceState === 'connected' || iceState === 'completed') &&
+      connectionState === 'connected'
+    );
+  };
+
   /**
    * Handles the ICECandidate event and
    * Initiates an ICE Trickle process with the SFU.
@@ -292,7 +322,7 @@ export abstract class BasePeerConnection {
     if (state === 'failed') {
       this.onReconnectionNeeded?.(
         WebsocketReconnectStrategy.REJOIN,
-        'Connection failed',
+        ReconnectReason.CONNECTION_FAILED,
         this.peerType,
       );
       return;
@@ -320,6 +350,54 @@ export abstract class BasePeerConnection {
     // do nothing when ICE is restarting
     if (this.isIceRestarting) return;
 
+    // Pre-connect handling: ICE has never reached `connected`/`completed`.
+    // Restart is futile here (the data plane was never established), but
+    // these two terminal-ish states need different treatment:
+    // - `failed` is terminal, escalate to REJOIN so a new SFU/credentials
+    //   /PC configuration gets a chance, and let `Call.reconnect` count
+    //   this toward the unsupported-network budget.
+    // - `disconnected` is transient, the browser may yet move back to
+    //   `checking`/`connected`. Don't restart, don't escalate; wait it
+    //   out. If it ultimately fails, ICE will transition to `failed` and
+    //   the branch above will take over.
+    if (!this.iceHasEverConnected) {
+      if (state === 'failed') {
+        this.logger.info('ICE failed before connected, escalating to REJOIN');
+        clearTimeout(this.preConnectStuckTimeout);
+        this.preConnectStuckTimeout = undefined;
+        this.onReconnectionNeeded?.(
+          WebsocketReconnectStrategy.REJOIN,
+          ReconnectReason.ICE_NEVER_CONNECTED,
+          this.peerType,
+        );
+        return;
+      }
+      if (state === 'disconnected') {
+        this.logger.info('ICE disconnected before connected, wait to recover');
+        // Watchdog: if the browser stays in `disconnected` without ever
+        // reaching `connected` or transitioning to `failed`, escalate to
+        // REJOIN ourselves so we don't wait silently forever. Rare but
+        // observed on flaky mobile networks.
+        clearTimeout(this.preConnectStuckTimeout);
+        this.preConnectStuckTimeout = setTimeout(() => {
+          if (
+            !this.iceHasEverConnected &&
+            this.pc.iceConnectionState === 'disconnected'
+          ) {
+            this.logger.info(
+              'ICE stuck in pre-connect disconnected, escalating to REJOIN',
+            );
+            this.onReconnectionNeeded?.(
+              WebsocketReconnectStrategy.REJOIN,
+              ReconnectReason.ICE_NEVER_CONNECTED,
+              this.peerType,
+            );
+          }
+        }, this.iceRestartDelay * 2);
+        return;
+      }
+    }
+
     switch (state) {
       case 'failed':
         // in the `failed` state, we try to restart ICE immediately
@@ -341,12 +419,24 @@ export abstract class BasePeerConnection {
         break;
 
       case 'connected':
-        // in the `connected` state, we clear the ice restart timeout if it exists
+      case 'completed':
+        // Fire `onIceConnected` exactly once per peer-connection lifetime —
+        // the first time ICE reaches `connected`/`completed` end-to-end.
+        // Used by `Call` to reset the unsupported-network failure counter
+        // only after WebRTC has actually recovered, not merely on SFU join.
+        if (!this.iceHasEverConnected) {
+          this.iceHasEverConnected = true;
+          this.onIceConnected?.(this.peerType);
+        }
+        // clear any scheduled restartICE since the connection is healthy
         if (this.iceRestartTimeout) {
           this.logger.info('connected connection, canceling restartICE');
           clearTimeout(this.iceRestartTimeout);
           this.iceRestartTimeout = undefined;
         }
+        // clear the pre-connect watchdog if it was armed
+        clearTimeout(this.preConnectStuckTimeout);
+        this.preConnectStuckTimeout = undefined;
         break;
     }
   };

package/src/rtc/Publisher.ts

@@ -460,7 +460,8 @@ export class Publisher extends BasePeerConnection {
     const trackInfos: TrackInfo[] = [];
     for (const publishOption of this.publishOptions) {
       const bundle = this.transceiverCache.get(publishOption);
-      if (!bundle || !bundle.transceiver.sender.track) continue;
+      const track = bundle?.transceiver.sender.track;
+      if (!bundle || !track || track.readyState !== 'live') continue;
       trackInfos.push(this.toTrackInfo(bundle, sdp));
     }
     return trackInfos;