@stream-io/video-client 2.0.0-beta.0 → 2.0.0-beta.1

package/src/rtc/TransceiverCache.ts

@@ -21,6 +21,23 @@ export class TransceiverCache {
     this.transceiverOrder.push(bundle.transceiver);
   };
 
+  /**
+   * Retires a failed sender from the reusable cache.
+   *
+   * A transceiver that never reached an m-section also leaves the creation
+   * history: once stopped, it is left out of every later offer, so counting
+   * it would shift the `mid` index of every transceiver added after it. One
+   * that is already associated keeps its slot, since its m-section survives
+   * as a rejected one.
+   */
+  remove = (transceiver: RTCRtpTransceiver) => {
+    const index = this.cache.findIndex((b) => b.transceiver === transceiver);
+    if (index !== -1) this.cache.splice(index, 1);
+    if (transceiver.mid) return;
+    const orderIndex = this.transceiverOrder.indexOf(transceiver);
+    if (orderIndex !== -1) this.transceiverOrder.splice(orderIndex, 1);
+  };
+
   /**
    * Gets the transceiver for the given publish option.
    */

package/src/rtc/__tests__/Call.reconnect.test.ts

@@ -4,7 +4,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { Call } from '../../Call';
 import { StreamClient } from '../../coordinator/connection/client';
 import { ClientEventReporter } from '../../reporting';
-import { StreamVideoWriteableStateStore } from '../../store';
+import { ClientState } from '../../store';
 import { CallingState } from '../../store';
 import { NegotiationError } from '../NegotiationError';
 import { ReconnectReason } from '../types';
@@ -27,7 +27,7 @@ vi.mock('../../StreamSfuClient', () => ({
 
 const makeCall = ({ reportingEnabled = false } = {}) => {
   const streamClient = new StreamClient('test-key');
-  const clientStore = new StreamVideoWriteableStateStore();
+  const clientState = new ClientState();
   return new Call({
     type: 'default',
     id: 'test-call',
@@ -36,7 +36,7 @@ const makeCall = ({ reportingEnabled = false } = {}) => {
       streamClient,
       enabled: reportingEnabled,
     }),
-    clientStore,
+    clientState,
     ringing: false,
     watching: false,
   });
@@ -729,13 +729,13 @@ describe('Call reconnect wiring (PC event → leave)', () => {
     sfuClient.iceTrickleBuffer = new IceTrickleBuffer();
 
     const streamClient = new StreamClient('test-key');
-    const clientStore = new StreamVideoWriteableStateStore();
+    const clientState = new ClientState();
     call = new Call({
       type: 'default',
       id: 'test-call',
       streamClient,
       clientEventReporter: new ClientEventReporter({ streamClient }),
-      clientStore,
+      clientState,
       ringing: false,
       watching: false,
     });

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

@@ -26,6 +26,7 @@ import { TransceiverCache } from '../TransceiverCache';
 import { promiseWithResolvers } from '../../helpers/promise';
 import { settled } from '../../helpers/concurrency';
 import { isFirefox } from '../../helpers/browsers';
+import { isReactNative } from '../../helpers/platforms';
 
 vi.mock('../../StreamSfuClient', () => {
   console.log('MOCKING StreamSfuClient');
@@ -40,6 +41,12 @@ vi.mock('../../helpers/browsers', async (importOriginal) => {
   return { ...actual, isFirefox: vi.fn().mockReturnValue(false) };
 });
 
+vi.mock('../../helpers/platforms', async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import('../../helpers/platforms')>();
+  return { ...actual, isReactNative: vi.fn().mockReturnValue(false) };
+});
+
 describe('Publisher', () => {
   const sessionId = 'session-id-test';
   let publisher: Publisher;
@@ -106,6 +113,208 @@ describe('Publisher', () => {
   });
 
   describe('Publishing', () => {
+    describe('E2EE initialization failures', () => {
+      afterEach(() => {
+        vi.mocked(isReactNative).mockReturnValue(false);
+      });
+
+      const setup = async () => {
+        await publisher.dispose();
+        const e2ee = { encrypt: vi.fn(), decrypt: vi.fn() };
+        publisher = new Publisher(
+          {
+            sfuClient,
+            dispatcher,
+            state,
+            tag: 'test',
+            enableTracing: false,
+            e2ee,
+          },
+          [
+            fromPartial<PublishOption>({
+              id: 1,
+              trackType: TrackType.VIDEO,
+              codec: { name: 'vp9' },
+            }),
+          ],
+        );
+        const transceivers: RTCRtpTransceiver[] = [];
+        vi.mocked(publisher['pc'].addTransceiver).mockImplementation((kind) => {
+          expect(kind).toBe('video');
+          const transceiver = new RTCRtpTransceiver();
+          vi.mocked(transceiver.sender.replaceTrack).mockImplementation(
+            async (track) => {
+              expect(e2ee.encrypt).toHaveBeenCalledWith(
+                transceiver.sender,
+                'vp9',
+                'VIDEO',
+              );
+              Object.assign(transceiver.sender, { track });
+            },
+          );
+          transceivers.push(transceiver);
+          return transceiver;
+        });
+        const track = new MediaStreamTrack();
+        vi.mocked(track.clone).mockImplementation(() => new MediaStreamTrack());
+        const realNegotiate = publisher['negotiate'];
+        const negotiate = vi.fn<Publisher['negotiate']>().mockResolvedValue();
+        publisher['negotiate'] = negotiate;
+        return { e2ee, transceivers, track, negotiate, realNegotiate };
+      };
+
+      it.each([
+        'encrypt',
+        'getParameters',
+        'setParameters',
+        'replaceTrack',
+      ] as const)(
+        'retires the sender after %s fails and attaches encryption on retry',
+        async (failurePoint) => {
+          const { e2ee, transceivers, track, negotiate } = await setup();
+          const error = new Error('initialization failed');
+          e2ee.encrypt.mockImplementationOnce((sender: RTCRtpSender) => {
+            expect(sender.track).toBeNull();
+            if (failurePoint === 'encrypt') throw error;
+            if (failurePoint === 'getParameters') {
+              vi.mocked(sender.getParameters).mockImplementationOnce(() => {
+                throw error;
+              });
+            } else {
+              vi.mocked(sender[failurePoint]).mockRejectedValueOnce(error);
+            }
+          });
+          await expect(publisher.publish(track, TrackType.VIDEO)).rejects.toBe(
+            error,
+          );
+          const failed = transceivers[0];
+          expect(failed.sender.track).toBeNull();
+          expect(failed.stop).toHaveBeenCalledOnce();
+          expect(publisher['transceiverCache'].items()).toHaveLength(0);
+          expect(publisher['clonedTracks'].size).toBe(0);
+          expect(negotiate).not.toHaveBeenCalled();
+
+          await publisher.publish(track, TrackType.VIDEO);
+          expect(transceivers).toHaveLength(2);
+          expect(e2ee.encrypt).toHaveBeenLastCalledWith(
+            transceivers[1].sender,
+            'vp9',
+            'VIDEO',
+          );
+          expect(transceivers[1].sender.track).not.toBeNull();
+          expect(publisher['transceiverCache'].indexOf(failed)).toBe(-1);
+          expect(publisher['transceiverCache'].indexOf(transceivers[1])).toBe(
+            0,
+          );
+          expect(negotiate).toHaveBeenCalledOnce();
+        },
+      );
+
+      it('keeps the mid index of a retired sender that reached an m-section', async () => {
+        const { e2ee, transceivers, track } = await setup();
+        const error = new Error('initialization failed');
+        e2ee.encrypt.mockImplementationOnce((sender: RTCRtpSender) => {
+          Object.assign(transceivers[0], { mid: '0' });
+          vi.mocked(sender.replaceTrack).mockRejectedValueOnce(error);
+        });
+        await expect(publisher.publish(track, TrackType.VIDEO)).rejects.toBe(
+          error,
+        );
+        expect(publisher['transceiverCache'].items()).toHaveLength(0);
+        expect(publisher['transceiverCache'].indexOf(transceivers[0])).toBe(0);
+
+        await publisher.publish(track, TrackType.VIDEO);
+        expect(publisher['transceiverCache'].indexOf(transceivers[1])).toBe(1);
+      });
+
+      it('reports the initialization failure even when cleanup throws', async () => {
+        const { e2ee, transceivers, track } = await setup();
+        const error = new Error('initialization failed');
+        e2ee.encrypt.mockImplementationOnce(() => {
+          vi.mocked(transceivers[0].stop).mockImplementationOnce(() => {
+            throw new Error('peer connection is closed');
+          });
+          throw error;
+        });
+        await expect(publisher.publish(track, TrackType.VIDEO)).rejects.toBe(
+          error,
+        );
+        expect(publisher['transceiverCache'].items()).toHaveLength(0);
+        expect(publisher['clonedTracks'].size).toBe(0);
+      });
+
+      it('leaves the cloned track alone on React Native', async () => {
+        vi.mocked(isReactNative).mockReturnValue(true);
+        const { e2ee, transceivers, track } = await setup();
+        const error = new Error('initialization failed');
+        e2ee.encrypt.mockImplementationOnce(() => {
+          throw error;
+        });
+        await expect(publisher.publish(track, TrackType.VIDEO)).rejects.toBe(
+          error,
+        );
+        const [clone] = publisher['clonedTracks'];
+        expect(clone.stop).not.toHaveBeenCalled();
+        expect(transceivers[0].stop).toHaveBeenCalledOnce();
+        expect(publisher['transceiverCache'].items()).toHaveLength(0);
+      });
+
+      it('reuses an encrypted sender when only negotiation failed', async () => {
+        const { e2ee, transceivers, track, negotiate } = await setup();
+        const error = new Error('negotiation failed');
+        negotiate.mockRejectedValueOnce(error);
+        await expect(publisher.publish(track, TrackType.VIDEO)).rejects.toBe(
+          error,
+        );
+        expect(transceivers[0].sender.track).not.toBeNull();
+        expect(transceivers[0].stop).not.toHaveBeenCalled();
+        await publisher.publish(track, TrackType.VIDEO);
+        expect(transceivers).toHaveLength(1);
+        expect(e2ee.encrypt).toHaveBeenCalledOnce();
+        expect(negotiate).toHaveBeenCalledTimes(2);
+      });
+
+      it('has no media to expose if ICE restart negotiates during parameter setup', async () => {
+        const { e2ee, transceivers, track, negotiate, realNegotiate } =
+          await setup();
+        negotiate.mockImplementation(realNegotiate);
+        publisher['publishOptions'].push(
+          fromPartial<PublishOption>({
+            id: 2,
+            trackType: TrackType.VIDEO,
+            codec: { name: 'vp9' },
+          }),
+        );
+        sfuClient.setPublisher = vi
+          .fn()
+          .mockResolvedValue({ response: { sdp: 'answer-sdp' } });
+        const parameters = promiseWithResolvers<void>();
+        e2ee.encrypt
+          .mockImplementationOnce(() => {})
+          .mockImplementationOnce((sender: RTCRtpSender) => {
+            vi.mocked(sender.setParameters).mockReturnValueOnce(
+              parameters.promise,
+            );
+          });
+        const publish = publisher.publish(track, TrackType.VIDEO);
+        await vi.waitFor(() => expect(e2ee.encrypt).toHaveBeenCalledTimes(2));
+        const [published, pending] = transceivers;
+        expect(pending.sender.track).toBeNull();
+        expect(pending.sender.replaceTrack).not.toHaveBeenCalled();
+
+        await publisher.restartIce();
+        const restart = vi.mocked(sfuClient.setPublisher).mock.calls[1][0];
+        expect(restart.tracks.map((t) => t.trackId)).toEqual([
+          published.sender.track!.id,
+        ]);
+
+        parameters.resolve();
+        await publish;
+        expect(pending.sender.track).not.toBeNull();
+        expect(sfuClient.setPublisher).toHaveBeenCalledTimes(3);
+      });
+    });
+
     it('should throw when publishing ended tracks', async () => {
       const track = new MediaStreamTrack();
       // @ts-expect-error readonly field

package/src/rtc/__tests__/mocks/webrtc.mocks.ts

@@ -60,6 +60,7 @@ const RTCRtpTransceiverMock = vi.fn(function (): Partial<RTCRtpTransceiver> {
       transform: null,
     },
     setCodecPreferences: vi.fn(),
+    stop: vi.fn(),
     mid: '',
   };
 });

package/src/rtc/e2ee/E2EEManager.ts

@@ -5,7 +5,16 @@
  * attaching their own encoded transform in these two methods.
  */
 export interface E2EEManager {
-  /** `trackType` only groups perf stats, keeping a camera and screen share apart. */
+  /**
+   * Synchronously attach a transform that encrypts the sender's outgoing frames.
+   * Must support a sender without a track, and throw if attachment fails.
+   *
+   * `sender.track` is always null here: the track is attached only after this
+   * returns, so implementations must not read it. Use `codec` and `trackType`
+   * instead.
+   *
+   * `trackType` only groups perf stats, keeping a camera and screen share apart.
+   */
   encrypt(sender: RTCRtpSender, codec?: string, trackType?: string): void;
   /** `trackType` only groups perf stats, keeping a peer's audio and video apart. */
   decrypt(receiver: RTCRtpReceiver, userId: string, trackType?: string): void;

package/src/rtc/e2ee/EncryptionManager.ts

@@ -263,9 +263,9 @@ export class EncryptionManager
     }
 
     if ((this.piped ??= new WeakSet()).has(target)) return;
-    this.piped.add(target);
     // @ts-expect-error createEncodedStreams is not in the standard typedefs
     const { readable, writable } = target.createEncodedStreams();
+    this.piped.add(target);
     this.worker.postMessage(
       { type: 'cmd.setup_transform', ...options, readable, writable },
       [readable, writable],

package/src/rtc/e2ee/SPEC.md

@@ -79,7 +79,7 @@ await call.join();
 - **Removal comes in per-epoch and per-user forms, and the names must stay distinct.** `removeKey(userId, keyIndex)` retires one epoch; `removeAllKeys(userId)` revokes the participant entirely. Do not render these as overloads of one name: dropping the index argument would then silently mean "revoke everything", which is the opposite of the caller's intent and impossible to catch in review.
 - **Every key operation's outcome is tabulated in Appendix B.** Implement the edge cases (removing the latest or active epoch, a failed import, an absent index) from that table rather than from prose.
 - **Join request carries `e2ee: true`** so the backend knows the call is encrypted.
-- The internal attach points (`encrypt(sender, codec, trackType)` / `decrypt(receiver, userId, trackType)`) are called by the RTC layer, not by apps. Keeping them behind a small interface lets an integrator plug in a different scheme (e.g. SFrame).
+- The internal attach points (`encrypt(sender, codec, trackType)` / `decrypt(receiver, userId, trackType)`) are called by the RTC layer, not by apps. The publisher creates an E2EE sender without a track and attaches media only after `encrypt` returns and sender parameters succeed. `encrypt` must synchronously attach the transform or throw, and must support a sender whose `track` is null. A failed initialization retires that transceiver so retries cannot bypass attachment. Keeping these points behind a small interface lets an integrator plug in a different scheme (e.g. SFrame).
 
 ---
 

package/src/stats/__tests__/utils.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import { getStreamClientId } from '../utils';
+import { SdkType } from '../../gen/video/sfu/models/models';
+
+describe('getStreamClientId', () => {
+  const sdk = (type: SdkType) => ({
+    type,
+    major: '1',
+    minor: '43',
+    patch: '1',
+  });
+
+  it('names the React SDK', () => {
+    expect(getStreamClientId(sdk(SdkType.REACT))).toBe(
+      'stream-video-react-v1.43.1',
+    );
+  });
+
+  it('names the React Native SDK', () => {
+    expect(getStreamClientId(sdk(SdkType.REACT_NATIVE))).toBe(
+      'stream-video-react-native-v1.43.1',
+    );
+  });
+
+  it('falls back to the plain JS client for every other SDK type', () => {
+    expect(getStreamClientId(sdk(SdkType.PLAIN_JAVASCRIPT))).toBe(
+      'stream-video-js-v1.43.1',
+    );
+    expect(getStreamClientId(undefined)).toBe(
+      'stream-video-js-v0.0.0-development',
+    );
+  });
+});

package/src/stats/utils.ts

@@ -51,3 +51,18 @@ export const getSdkName = (sdk: Sdk | undefined) => {
 export const getSdkVersion = (sdk: Sdk | undefined) => {
   return sdk ? `${sdk.major}.${sdk.minor}.${sdk.patch}` : '0.0.0-development';
 };
+
+/**
+ * Returns the identifier the SFU receives in the `X-Stream-Client` header,
+ * e.g. `stream-video-react-v1.43.1`. Matches the format the coordinator
+ * already gets through the client's user agent.
+ */
+export const getStreamClientId = (sdk: Sdk | undefined) => {
+  const sdkPlatforms: Partial<Record<SdkType, string>> = {
+    [SdkType.REACT]: 'react',
+    [SdkType.REACT_NATIVE]: 'react-native',
+  };
+
+  const platform = (sdk && sdkPlatforms[sdk.type]) || 'js';
+  return `stream-video-${platform}-v${getSdkVersion(sdk)}`;
+};