@stream-io/video-client 1.61.0 → 1.61.1

package/package.json

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

package/src/reporting/ClientEventReporter.ts

@@ -597,11 +597,16 @@ export class ClientEventReporter {
     }
 
     if (event.state === 'failed') {
+      const iceConnected =
+        event.iceConnectionState === 'connected' ||
+        event.iceConnectionState === 'completed';
       this.emitPeerConnectionFailure(
         cid,
         role,
-        'DTLS_CONNECTIVITY_FAILED',
-        'DTLS connectivity checks failed',
+        iceConnected ? 'DTLS_CONNECTIVITY_FAILED' : 'ICE_CONNECTIVITY_FAILED',
+        iceConnected
+          ? 'DTLS connectivity checks failed'
+          : 'ICE connectivity checks failed',
       );
       return;
     }

package/src/reporting/__tests__/ClientEventReporter.test.ts

@@ -755,7 +755,7 @@ describe('ClientEventReporter', () => {
     });
   });
 
-  it('reports a DTLS failure with the real ICE state (never connected)', async () => {
+  it('reports an ICE failure when the peer connection fails before ICE connected', async () => {
     reporter.startCorrelation(cid, 'first-attempt');
     reportPeerConnectionState(
       PeerType.PUBLISHER_UNSPECIFIED,
@@ -779,7 +779,7 @@ describe('ClientEventReporter', () => {
     expect(completed[0]).toMatchObject({
       outcome: 'failure',
       peer_connection: 'publish',
-      retry_failure_code: 'DTLS_CONNECTIVITY_FAILED',
+      retry_failure_code: 'ICE_CONNECTIVITY_FAILED',
       ice_state: 'NOT_CONNECTED',
     });
   });

package/src/rtc/BasePeerConnection.ts

@@ -344,9 +344,14 @@ export abstract class BasePeerConnection {
 
     // we can't recover from a failed connection state (contrary to ICE)
     if (state === 'failed') {
+      const reason = this.iceHasEverConnected
+        ? ReconnectReason.CONNECTION_FAILED
+        : ReconnectReason.ICE_NEVER_CONNECTED;
+      clearTimeout(this.preConnectStuckTimeout);
+      this.preConnectStuckTimeout = undefined;
       this.onReconnectionNeeded?.(
         WebsocketReconnectStrategy.REJOIN,
-        ReconnectReason.CONNECTION_FAILED,
+        reason,
         this.peerType,
       );
       return;

package/src/rtc/__tests__/Publisher.test.ts

@@ -931,6 +931,56 @@ describe('Publisher', () => {
       );
     });
 
+    it.each(['checking', 'failed'] as const)(
+      `connection-state 'failed' before ICE connects emits ICE_NEVER_CONNECTED when ICE is '%s'`,
+      async (iceState) => {
+        vi.spyOn(publisher, 'restartIce').mockResolvedValue();
+        publisher['onReconnectionNeeded'] = vi.fn();
+        // @ts-expect-error readonly field
+        publisher['pc'].iceConnectionState = iceState;
+        // @ts-expect-error readonly field
+        publisher['pc'].connectionState = 'failed';
+
+        // No ICE state-change event precedes the aggregate failure.
+        await publisher['onConnectionStateChange']();
+
+        expect(publisher.restartIce).not.toHaveBeenCalled();
+        expect(
+          publisher['onReconnectionNeeded'],
+        ).toHaveBeenCalledExactlyOnceWith(
+          WebsocketReconnectStrategy.REJOIN,
+          ReconnectReason.ICE_NEVER_CONNECTED,
+          PeerType.PUBLISHER_UNSPECIFIED,
+        );
+      },
+    );
+
+    it(`connection-state 'failed' cancels the pre-connect watchdog`, async () => {
+      vi.useFakeTimers();
+      publisher['onReconnectionNeeded'] = vi.fn();
+      const watchdogMs = publisher['iceRestartDelay'] * 2;
+
+      // @ts-expect-error readonly field
+      publisher['pc'].iceConnectionState = 'disconnected';
+      publisher['onIceConnectionStateChange']();
+      expect(publisher['preConnectStuckTimeout']).toBeDefined();
+      expect(publisher['onReconnectionNeeded']).not.toHaveBeenCalled();
+
+      // Keep ICE disconnected so an uncanceled watchdog would reconnect again.
+      // @ts-expect-error readonly field
+      publisher['pc'].connectionState = 'failed';
+      await publisher['onConnectionStateChange']();
+
+      expect(publisher['preConnectStuckTimeout']).toBeUndefined();
+      expect(publisher['onReconnectionNeeded']).toHaveBeenCalledExactlyOnceWith(
+        WebsocketReconnectStrategy.REJOIN,
+        ReconnectReason.ICE_NEVER_CONNECTED,
+        PeerType.PUBLISHER_UNSPECIFIED,
+      );
+      await vi.advanceTimersByTimeAsync(watchdogMs + 100);
+      expect(publisher['onReconnectionNeeded']).toHaveBeenCalledTimes(1);
+    });
+
     it(`connection-state 'failed' (distinct from ICE state) still fires REJOIN even after ICE was connected`, () => {
       // mark ICE as connected first
       // @ts-expect-error private api