@stream-io/video-client 1.55.0 → 1.55.1

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

@@ -40,6 +40,7 @@ export declare class StableWSConnection {
     consecutiveFailures: number;
     /** keep track of the total number of failures */
     totalFailures: number;
+    lastConnectionError?: WSConnectionError;
     /** Send a health check message every 25 seconds */
     pingInterval: number;
     healthCheckTimeoutRef?: number;

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

@@ -83,6 +83,7 @@ export type PublishBundle = {
     transceiver: RTCRtpTransceiver;
     options: TrackPublishOptions;
     videoSender?: VideoSender;
+    negotiated?: boolean;
 };
 export type TrackLayersCache = {
     publishOption: PublishOption;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.55.0",
+  "version": "1.55.1",
   "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.34.0",
     "@rollup/plugin-replace": "^6.0.3",
     "@rollup/plugin-typescript": "^12.3.0",
-    "@stream-io/audio-filters-web": "^0.9.0",
+    "@stream-io/audio-filters-web": "^0.9.1",
     "@stream-io/node-sdk": "^0.7.59",
     "@stream-io/typescript-config": "^0.0.0",
     "@total-typescript/shoehorn": "^0.1.2",

package/src/coordinator/connection/__tests__/connection.test.ts

@@ -215,6 +215,53 @@ describe('StableWSConnection - silent handshake hang', () => {
     expect(outcome.kind).toBe('rejected');
   });
 
+  it('preserves an initial WS close reason when reconnect cannot get healthy', async () => {
+    const client = new StreamClient('test-key', {
+      browser: false,
+      defaultWsTimeout: 5000,
+      WebSocketImpl: ManualWebSocket as unknown as typeof WebSocket,
+      timeout: 1000,
+    });
+    vi.spyOn(client.tokenManager, 'tokenReady').mockResolvedValue('fake-token');
+    vi.spyOn(client.tokenManager, 'loadToken').mockResolvedValue('fake-token');
+    vi.spyOn(client.tokenManager, 'getToken').mockReturnValue('fake-token');
+
+    client._setUser({ id: 'test-user' });
+    client.userID = 'test-user';
+    client.clientID = 'test-user--abcdef';
+    client._setupConnectionIdPromise();
+
+    const wsConnection = new StableWSConnection(client);
+    client.wsConnection = wsConnection;
+
+    const connectAttemptOutcome = wsConnection.connect(5000).then(
+      () => ({ kind: 'resolved' as const }),
+      (error: Error) => ({ kind: 'rejected' as const, error }),
+    );
+
+    await vi.advanceTimersByTimeAsync(0);
+    const ws = ManualWebSocket.instances.at(-1)!;
+    expect(ws).toBeDefined();
+
+    ws.onclose?.({
+      code: 1006,
+      reason: 'specific ws close reason',
+      wasClean: false,
+      target: ws,
+    });
+
+    await vi.advanceTimersByTimeAsync(20000);
+    const outcome = await connectAttemptOutcome;
+
+    expect(outcome.kind).toBe('rejected');
+    if (outcome.kind === 'rejected') {
+      expect(outcome.error.message).toContain('specific ws close reason');
+      expect(outcome.error.message).not.toContain(
+        'initial WS connection could not be established',
+      );
+    }
+  });
+
   it('does not schedule a reconnect (and leaves connectionIdPromise rejected) on a permanent, non-WS failure', async () => {
     const client = new StreamClient('test-key', {
       browser: false,

package/src/coordinator/connection/connection.ts

@@ -66,6 +66,7 @@ export class StableWSConnection {
   consecutiveFailures = 0;
   /** keep track of the total number of failures */
   totalFailures = 0;
+  lastConnectionError?: WSConnectionError;
 
   // Health-check pings + connection-staleness check.
   /** Send a health check message every 25 seconds */
@@ -102,6 +103,7 @@ export class StableWSConnection {
     }
 
     this.isDisconnected = false;
+    this.lastConnectionError = undefined;
 
     try {
       const healthCheck = await this._connect(timeout);
@@ -140,6 +142,7 @@ export class StableWSConnection {
         // _connect()'s catch) keeps a single failure from spawning two
         // parallel chains - one from this catch and one from _reconnect's
         // own catch when _connect was called from there.
+        this.lastConnectionError = error;
         this._reconnect();
       }
     }
@@ -179,14 +182,22 @@ export class StableWSConnection {
       (async () => {
         await sleep(timeout);
         this.isConnecting = false;
-        throw new Error(
-          JSON.stringify({
-            code: '',
-            StatusCode: '',
-            message: 'initial WS connection could not be established',
-            isWSFailure: true,
-          }),
-        );
+        const e = this.lastConnectionError;
+        const errorPayload = e
+          ? {
+              code: e.code,
+              StatusCode: e.StatusCode,
+              message: e.message,
+              isWSFailure: e.isWSFailure,
+            }
+          : {
+              code: '',
+              StatusCode: '',
+              message: 'initial WS connection could not be established',
+              isWSFailure: true,
+            };
+
+        throw new Error(JSON.stringify(errorPayload));
       })(),
     ]);
   };
@@ -376,6 +387,7 @@ export class StableWSConnection {
       return undefined;
     } catch (caught) {
       const err = caught as WSConnectionError;
+      this.lastConnectionError = err;
       this.isConnecting = false;
       this._log(`_connect() - Error - `, err);
       // Reject THIS attempt's connection-id promise (P1) directly via the

package/src/rtc/Publisher.ts

@@ -187,6 +187,9 @@ export class Publisher extends BasePeerConnection {
     if (isAudioTrackType(trackType)) {
       await this.updateAudioPublishOptions(trackType, options);
     }
+    if (track && !bundle.negotiated) {
+      await this.negotiate();
+    }
   };
 
   /**
@@ -490,6 +493,10 @@ export class Publisher extends BasePeerConnection {
 
         const { sdp: answerSdp } = response;
         await this.pc.setRemoteDescription({ type: 'answer', sdp: answerSdp });
+
+        for (const bundle of this.transceiverCache.items()) {
+          if (bundle.transceiver.sender.track) bundle.negotiated = true;
+        }
       } catch (err) {
         // negotiation failed, rollback to the previous state
         if (this.pc.signalingState === 'have-local-offer') {

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

@@ -157,6 +157,7 @@ describe('Publisher', () => {
         publishOption: publisher['publishOptions'][0],
         transceiver,
         options: {},
+        negotiated: true,
       });
 
       await publisher.publish(track, TrackType.VIDEO);
@@ -166,6 +167,75 @@ describe('Publisher', () => {
       expect(transceiver.sender.replaceTrack).toHaveBeenCalledWith(clone);
       expect(track.stop).toHaveBeenCalled();
     });
+
+    it('should not renegotiate when reusing an already-negotiated transceiver', async () => {
+      const track = new MediaStreamTrack();
+      const clone = new MediaStreamTrack();
+      vi.spyOn(track, 'clone').mockReturnValue(clone);
+
+      const transceiver = new RTCRtpTransceiver();
+      // @ts-expect-error test setup
+      transceiver.sender.track = track;
+      publisher['transceiverCache'].add({
+        publishOption: publisher['publishOptions'][0],
+        transceiver,
+        options: {},
+        negotiated: true,
+      });
+
+      // @ts-expect-error - private method
+      const negotiateSpy = vi.spyOn(publisher, 'negotiate').mockResolvedValue();
+
+      await publisher.publish(track, TrackType.VIDEO);
+
+      expect(transceiver.sender.replaceTrack).toHaveBeenCalledWith(clone);
+      expect(negotiateSpy).not.toHaveBeenCalled();
+    });
+
+    it('should renegotiate on republish when a previous negotiation never reached the SFU (SetPublisher timeout)', async () => {
+      const track = new MediaStreamTrack();
+      const transceiver = new RTCRtpTransceiver();
+      // @ts-expect-error test setup
+      transceiver.sender.track = track;
+      const bundle = {
+        publishOption: publisher['publishOptions'][0],
+        transceiver,
+        options: {},
+        negotiated: false,
+      };
+      publisher['transceiverCache'].add(bundle);
+
+      vi.spyOn(publisher['pc'], 'createOffer')
+        // @ts-expect-error TS picks up the wrong overload
+        .mockResolvedValue({ sdp: 'offer-sdp', type: 'offer' });
+      vi.spyOn(publisher['pc'], 'setLocalDescription').mockResolvedValue();
+      vi.spyOn(publisher['pc'], 'setRemoteDescription').mockResolvedValue();
+      vi.spyOn(publisher, 'getAnnouncedTracks').mockReturnValue([
+        // @ts-expect-error incomplete data
+        { trackId: '123' },
+      ]);
+
+      sfuClient.setPublisher = vi
+        .fn()
+        .mockRejectedValue(new Error('SetPublisherTimeout'));
+      await expect(publisher['negotiate']()).rejects.toThrow(
+        'SetPublisherTimeout',
+      );
+      expect(bundle.negotiated).toBe(false);
+
+      const clone = new MediaStreamTrack();
+      vi.spyOn(track, 'clone').mockReturnValue(clone);
+      sfuClient.setPublisher = vi
+        .fn()
+        .mockResolvedValue({ response: { sdp: 'answer-sdp' } });
+
+      await publisher.publish(track, TrackType.VIDEO);
+
+      expect(publisher['pc'].addTransceiver).not.toHaveBeenCalled();
+      expect(transceiver.sender.replaceTrack).toHaveBeenCalledWith(clone);
+      expect(sfuClient.setPublisher).toHaveBeenCalled();
+      expect(bundle.negotiated).toBe(true);
+    });
   });
 
   describe('Event Handling', () => {
@@ -1457,6 +1527,7 @@ describe('Publisher', () => {
         publishOption: publisher['publishOptions'][0],
         transceiver,
         options: {},
+        negotiated: true,
       });
 
       // stopping seeds the bundle's videoSender from the current encoder
@@ -1515,11 +1586,13 @@ describe('Publisher', () => {
         publishOption: publisher['publishOptions'][0],
         transceiver: vp8Transceiver,
         options: {},
+        negotiated: true,
       });
       publisher['transceiverCache'].add({
         publishOption: publisher['publishOptions'][1],
         transceiver: vp9Transceiver,
         options: {},
+        negotiated: true,
       });
 
       await publisher.stopTracks(TrackType.VIDEO);
@@ -1589,6 +1662,7 @@ describe('Publisher', () => {
         publishOption,
         transceiver,
         options: {},
+        negotiated: true,
       });
 
       // SFU sends a changePublishQuality while we are not publishing.

package/src/rtc/types.ts

@@ -112,6 +112,7 @@ export type PublishBundle = {
   transceiver: RTCRtpTransceiver;
   options: TrackPublishOptions;
   videoSender?: VideoSender;
+  negotiated?: boolean;
 };
 
 export type TrackLayersCache = {