@stream-io/video-client 1.55.2 → 1.57.0

package/src/rtc/Publisher.ts

@@ -40,6 +40,7 @@ export class Publisher extends BasePeerConnection {
   private readonly clonedTracks = new Set<MediaStreamTrack>();
   private publishOptions: PublishOption[];
   private readonly selfSubEnabled: boolean;
+  private readonly transceiverLockKey = `pub.tx.${this.lock}`;
 
   /**
    * Constructs a new `Publisher` instance.
@@ -107,28 +108,31 @@ export class Publisher extends BasePeerConnection {
     trackType: TrackType,
     options: TrackPublishOptions = {},
   ) => {
-    if (!this.publishOptions.some((o) => o.trackType === trackType)) {
-      throw new Error(`No publish options found for ${TrackType[trackType]}`);
-    }
-
-    for (const publishOption of this.publishOptions) {
-      if (publishOption.trackType !== trackType) continue;
-
-      // create a clone of the track as otherwise the same trackId will
-      // appear in the SDP in multiple transceivers
-      const trackToPublish = this.cloneTrack(track);
+    return withoutConcurrency(this.transceiverLockKey, async () => {
+      const publishOptions = this.publishOptions.filter(
+        (o) => o.trackType === trackType,
+      );
+      if (!publishOptions.length) {
+        throw new Error(`No publish options found for ${TrackType[trackType]}`);
+      }
 
-      const bundle = this.transceiverCache.get(publishOption);
-      if (!bundle) {
-        await this.addTransceiver(trackToPublish, publishOption, options);
-      } else {
-        const previousTrack = bundle.transceiver.sender.track;
-        await this.updateTransceiver(bundle, trackToPublish, options);
-        if (!isReactNative()) {
-          this.stopTrack(previousTrack);
+      for (const publishOption of publishOptions) {
+        // create a clone of the track as otherwise the same trackId will
+        // appear in the SDP in multiple transceivers
+        const trackToPublish = this.cloneTrack(track);
+
+        const bundle = this.transceiverCache.get(publishOption);
+        if (!bundle) {
+          await this.addTransceiver(trackToPublish, publishOption, options);
+        } else {
+          const previousTrack = bundle.transceiver.sender.track;
+          await this.updateTransceiver(bundle, trackToPublish, options);
+          if (!isReactNative()) {
+            this.stopTrack(previousTrack);
+          }
         }
       }
-    }
+    });
   };
 
   /**
@@ -139,6 +143,7 @@ export class Publisher extends BasePeerConnection {
     publishOption: PublishOption,
     options: TrackPublishOptions,
   ) => {
+    const trackType = publishOption.trackType;
     const encodings = isAudioTrackType(publishOption.trackType)
       ? computeAudioLayers(publishOption, options)
       : computeVideoLayers(track, publishOption);
@@ -149,6 +154,12 @@ export class Publisher extends BasePeerConnection {
       direction: 'sendonly',
       sendEncodings,
     });
+    // claim the cache entry in the same task that created the transceiver:
+    // an await in between would let a concurrent caller add a second one
+    // for the same publish option
+    this.transceiverCache.add({ publishOption, transceiver, options });
+    this.trackIdToTrackType.set(track.id, trackType);
+    this.logger.debug(`Added ${TrackType[trackType]} transceiver`);
 
     const params = transceiver.sender.getParameters();
     params.degradationPreference =
@@ -156,11 +167,6 @@ export class Publisher extends BasePeerConnection {
       'maintain-framerate';
     await transceiver.sender.setParameters(params);
 
-    const trackType = publishOption.trackType;
-    this.logger.debug(`Added ${TrackType[trackType]} transceiver`);
-    this.transceiverCache.add({ publishOption, transceiver, options });
-    this.trackIdToTrackType.set(track.id, trackType);
-
     await this.negotiate();
   };
 
@@ -225,38 +231,40 @@ export class Publisher extends BasePeerConnection {
    * Synchronizes the current Publisher state with the provided publish options.
    */
   private syncPublishOptions = async () => {
-    // enable publishing with new options -> [av1, vp9]
-    for (const publishOption of this.publishOptions) {
-      const { trackType } = publishOption;
-      if (!this.isPublishing(trackType)) continue;
-      if (this.transceiverCache.has(publishOption)) continue;
-
-      const item = this.transceiverCache.find(
-        (i) =>
-          !!i.transceiver.sender.track &&
-          i.publishOption.trackType === trackType,
-      );
-      if (!item) continue;
-
-      // take the track from the existing transceiver for the same track type,
-      // clone it and publish it with the new publish options
-      const track = this.cloneTrack(item.transceiver.sender.track!);
-      await this.addTransceiver(track, publishOption, item.options);
-    }
+    return withoutConcurrency(this.transceiverLockKey, async () => {
+      // enable publishing with new options -> [av1, vp9]
+      for (const publishOption of this.publishOptions) {
+        const { trackType } = publishOption;
+        if (!this.isPublishing(trackType)) continue;
+        if (this.transceiverCache.has(publishOption)) continue;
+
+        const item = this.transceiverCache.find(
+          (i) =>
+            !!i.transceiver.sender.track &&
+            i.publishOption.trackType === trackType,
+        );
+        if (!item) continue;
+
+        // take the track from the existing transceiver for the same track type,
+        // clone it and publish it with the new publish options
+        const track = this.cloneTrack(item.transceiver.sender.track!);
+        await this.addTransceiver(track, publishOption, item.options);
+      }
 
-    // stop publishing with options not required anymore -> [vp9]
-    for (const item of this.transceiverCache.items()) {
-      const { publishOption, transceiver } = item;
-      const hasPublishOption = this.publishOptions.some(
-        (option) =>
-          option.id === publishOption.id &&
-          option.trackType === publishOption.trackType,
-      );
-      if (hasPublishOption) continue;
-      // it is safe to stop the track here, it is a clone
-      this.stopTrack(transceiver.sender.track);
-      await this.updateTransceiver(item, null);
-    }
+      // stop publishing with options not required anymore -> [vp9]
+      for (const item of this.transceiverCache.items()) {
+        const { publishOption, transceiver } = item;
+        const hasPublishOption = this.publishOptions.some(
+          (option) =>
+            option.id === publishOption.id &&
+            option.trackType === publishOption.trackType,
+        );
+        if (hasPublishOption) continue;
+        // it is safe to stop the track here, it is a clone
+        this.stopTrack(transceiver.sender.track);
+        await this.updateTransceiver(item, null);
+      }
+    });
   };
 
   /**
@@ -456,13 +464,25 @@ export class Publisher extends BasePeerConnection {
   private negotiate = async (options?: RTCOfferOptions): Promise<void> => {
     return withoutConcurrency(`publisher.negotiate.${this.lock}`, async () => {
       const offer = await this.pc.createOffer(options);
-      const tracks = this.getAnnouncedTracks(offer.sdp);
-      if (!tracks.length) throw new Error(`Can't negotiate without any tracks`);
-
       try {
         this.isIceRestarting = options?.iceRestart ?? false;
         await this.pc.setLocalDescription(offer);
 
+        // the announced tracks have to be read after `setLocalDescription`.
+        // `transceiver.mid` is null until the offer is applied, and reading the
+        // tracks earlier makes `extractMid` guess the mid from the offer SDP.
+        // That guess goes stale after a rolled-back negotiation, and a mid that
+        // doesn't match the m-section carrying the track stops the SFU from
+        // correlating the two: it then answers with every offered codec instead
+        // of the announced one, and we publish the first codec of that list.
+        // Per https://www.w3.org/TR/webrtc/#set-description, applying a local
+        // offer associates the transceiver with its m-section and sets
+        // `[[Mid]]` to `[[JsepMid]]`; a rollback disassociates a transceiver
+        // that wasn't associated before and resets both slots to null.
+        const tracks = this.getAnnouncedTracks(offer.sdp);
+        if (!tracks.length)
+          throw new Error(`Can't negotiate without any tracks`);
+
         const { sdp: baseSdp = '' } = offer;
         const {
           dangerouslyForceCodec,

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

@@ -24,6 +24,7 @@ import { IceTrickleBuffer } from '../IceTrickleBuffer';
 import { StreamClient } from '../../coordinator/connection/client';
 import { TransceiverCache } from '../TransceiverCache';
 import { promiseWithResolvers } from '../../helpers/promise';
+import { settled } from '../../helpers/concurrency';
 import { isFirefox } from '../../helpers/browsers';
 
 vi.mock('../../StreamSfuClient', () => {
@@ -1318,6 +1319,97 @@ describe('Publisher', () => {
     });
   });
 
+  describe('mid assignment during negotiation', () => {
+    const sdpWith = (
+      sections: Array<{ mid: string; trackId?: string; port: number }>,
+    ) =>
+      [
+        'v=0',
+        'o=- 0 0 IN IP4 127.0.0.1',
+        's=-',
+        't=0 0',
+        ...sections.flatMap((s) => [
+          `m=video ${s.port} UDP/TLS/RTP/SAVPF 96`,
+          'c=IN IP4 0.0.0.0',
+          `a=mid:${s.mid}`,
+          ...(s.trackId
+            ? [`a=msid:stream-id ${s.trackId}`, 'a=sendonly']
+            : ['a=inactive']),
+        ]),
+        '',
+      ].join('\r\n');
+
+    it('announces the mid the browser assigned, not the one guessed from the pending offer', async () => {
+      const track = new MediaStreamTrack();
+      const transceiver = new RTCRtpTransceiver();
+      // @ts-expect-error test setup
+      transceiver.sender.track = track;
+      // @ts-expect-error readonly field
+      transceiver.mid = null;
+
+      publisher['transceiverCache'].add({
+        publishOption: publisher['publishOptions'][0],
+        transceiver,
+        options: {},
+        negotiated: false,
+      });
+
+      const firstOffer = {
+        type: 'offer',
+        sdp: sdpWith([{ mid: '0', trackId: track.id, port: 9 }]),
+      };
+      const secondOffer = {
+        type: 'offer',
+        sdp: sdpWith([
+          { mid: '0', port: 0 },
+          { mid: '1', trackId: track.id, port: 9 },
+        ]),
+      };
+
+      const pc = publisher['pc'];
+      vi.spyOn(pc, 'createOffer')
+        // @ts-expect-error TS picks up the wrong overload
+        .mockResolvedValueOnce(firstOffer)
+        // @ts-expect-error TS picks up the wrong overload
+        .mockResolvedValueOnce(secondOffer);
+
+      vi.spyOn(pc, 'setLocalDescription').mockImplementation(async (desc) => {
+        // @ts-expect-error readonly field
+        transceiver.mid =
+          desc?.sdp === firstOffer.sdp
+            ? '0'
+            : desc?.sdp === secondOffer.sdp
+              ? '1'
+              : null; // rollback reverts the mid of a never-negotiated transceiver
+        // @ts-expect-error readonly field
+        pc.signalingState =
+          desc?.type === 'rollback' ? 'stable' : 'have-local-offer';
+      });
+      vi.spyOn(pc, 'setRemoteDescription').mockResolvedValue();
+
+      sfuClient.setPublisher = vi
+        .fn()
+        .mockRejectedValueOnce(new Error('SetPublisherTimeout'));
+      await expect(publisher['negotiate']()).rejects.toThrow(
+        'SetPublisherTimeout',
+      );
+      expect(pc.setLocalDescription).toHaveBeenLastCalledWith({
+        type: 'rollback',
+      });
+      expect(transceiver.mid).toBeNull();
+
+      sfuClient.setPublisher = vi
+        .fn()
+        .mockResolvedValue({ response: { sdp: 'answer-sdp' } });
+      await publisher['negotiate']();
+
+      expect(sfuClient.setPublisher).toHaveBeenCalledWith({
+        sdp: secondOffer.sdp,
+        tracks: [expect.objectContaining({ trackId: track.id, mid: '1' })],
+      });
+    });
+  });
+
   describe('Firefox unpublish workaround', () => {
     const mockSenderParams = (
       transceiver: RTCRtpTransceiver,
@@ -1845,4 +1937,209 @@ describe('Publisher', () => {
       expect(trackStopSpy).toHaveBeenCalled();
     });
   });
+
+  describe('concurrent transceiver management', () => {
+    const videoOption = (id: number, codecName: string): PublishOption =>
+      fromPartial({
+        id,
+        trackType: TrackType.VIDEO,
+        bitrate: 1000,
+        codec: { name: codecName },
+        fps: 30,
+        maxTemporalLayers: 3,
+        maxSpatialLayers: 3,
+        degradationPreference: DegradationPreference.UNSPECIFIED,
+      });
+
+    const makeTrack = (): MediaStreamTrack => {
+      const track = new MediaStreamTrack();
+      // @ts-expect-error readonly field
+      track.id = crypto.randomUUID();
+      vi.spyOn(track, 'clone').mockImplementation(() => makeTrack());
+      return track;
+    };
+
+    const makeTransceiver = (track: MediaStreamTrack) => {
+      const transceiver = new RTCRtpTransceiver();
+      // @ts-expect-error test setup
+      transceiver.sender.track = track;
+      transceiver.sender.replaceTrack = vi.fn(async (next) => {
+        // @ts-expect-error test setup
+        transceiver.sender.track = next;
+      });
+      return transceiver;
+    };
+
+    /**
+     * The shared mock returns the same transceiver for every call, which would
+     * hide duplicates. Give every `addTransceiver` call its own transceiver,
+     * with the track bound to the sender like the browser does.
+     */
+    const withDistinctTransceivers = (
+      decorate: (transceiver: RTCRtpTransceiver) => void = () => {},
+    ) => {
+      vi.spyOn(publisher['pc'], 'addTransceiver').mockImplementation(
+        // @ts-expect-error the mock only implements what the Publisher uses
+        (track: MediaStreamTrack) => {
+          const transceiver = makeTransceiver(track);
+          decorate(transceiver);
+          return transceiver;
+        },
+      );
+    };
+
+    const announcedKeys = () =>
+      publisher
+        .getAnnouncedTracks(undefined)
+        .map((track) => `${track.trackType}:${track.publishOptionId}`);
+
+    beforeEach(() => {
+      withDistinctTransceivers();
+      // @ts-expect-error private method
+      vi.spyOn(publisher, 'negotiate').mockResolvedValue();
+    });
+
+    it('announces one track per publish option when publish() runs concurrently', async () => {
+      await Promise.all([
+        publisher.publish(makeTrack(), TrackType.VIDEO),
+        publisher.publish(makeTrack(), TrackType.VIDEO),
+      ]);
+
+      expect(publisher['transceiverCache'].items()).toHaveLength(1);
+      expect(announcedKeys()).toEqual([`${TrackType.VIDEO}:1`]);
+    });
+
+    it('announces one track per publish option when publish() runs during a codec switch', async () => {
+      const track = makeTrack();
+      await publisher.publish(track, TrackType.VIDEO);
+
+      // stall the first await inside addTransceiver, so the codec switch is
+      // still in-flight when the next publish() looks up the cache
+      let releaseCodecSwitch!: () => void;
+      const codecSwitch = new Promise<void>((resolve) => {
+        releaseCodecSwitch = resolve;
+      });
+      withDistinctTransceivers((transceiver) => {
+        transceiver.sender.setParameters = vi.fn(() => codecSwitch);
+      });
+
+      dispatcher.dispatch(
+        SfuEvent.create({
+          eventPayload: {
+            oneofKind: 'changePublishOptions',
+            changePublishOptions: {
+              publishOptions: [videoOption(1, 'vp9'), videoOption(2, 'av1')],
+              reason: 'test',
+            },
+          },
+        }) as DispatchableMessage<'changePublishOptions'>,
+        'test',
+      );
+      await vi.waitFor(() =>
+        expect(publisher['pc'].addTransceiver).toHaveBeenCalled(),
+      );
+
+      const publishTask = publisher.publish(track, TrackType.VIDEO);
+      // a macrotask boundary drains the pending microtasks, which is as far
+      // as an unserialized publish() can get: up to the cache lookup for the
+      // new publish option. It cannot resolve earlier under load, so this
+      // does not depend on wall-clock timing.
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      releaseCodecSwitch();
+      await publishTask;
+      await settled(publisher['eventLockKey']('changePublishOptions'));
+
+      expect(announcedKeys()).toEqual([
+        `${TrackType.VIDEO}:1`,
+        `${TrackType.VIDEO}:2`,
+      ]);
+    });
+
+    it('rejects a queued publish whose publish options were retired', async () => {
+      // stall the first negotiation, so the next publish() has to queue
+      const firstNegotiation = promiseWithResolvers<void>();
+      let negotiations = 0;
+      // @ts-expect-error private method
+      vi.spyOn(publisher, 'negotiate').mockImplementation(() =>
+        ++negotiations === 1 ? firstNegotiation.promise : Promise.resolve(),
+      );
+
+      const firstPublish = publisher.publish(makeTrack(), TrackType.VIDEO);
+      await vi.waitFor(() => expect(negotiations).toBe(1));
+
+      const queuedPublish = publisher.publish(makeTrack(), TrackType.VIDEO);
+      // video is retired while the second publish waits for the lock
+      publisher['publishOptions'] = [];
+
+      firstNegotiation.resolve();
+      await firstPublish;
+
+      // it must not report success without having published anything
+      await expect(queuedPublish).rejects.toThrow(
+        'No publish options found for VIDEO',
+      );
+      expect(publisher['pc'].addTransceiver).toHaveBeenCalledTimes(1);
+    });
+
+    it('does not keep publishing with an option retired mid-publish', async () => {
+      publisher['publishOptions'] = [
+        videoOption(1, 'vp9'),
+        videoOption(2, 'av1'),
+      ];
+
+      // stall the first negotiation, so publish() is suspended in its loop
+      // after option 1 was added but before option 2 is reached
+      const firstNegotiation = promiseWithResolvers<void>();
+      let negotiations = 0;
+      // @ts-expect-error private method
+      vi.spyOn(publisher, 'negotiate').mockImplementation(() =>
+        ++negotiations === 1 ? firstNegotiation.promise : Promise.resolve(),
+      );
+
+      const publishTask = publisher.publish(makeTrack(), TrackType.VIDEO);
+      await vi.waitFor(() => expect(negotiations).toBe(1));
+
+      dispatcher.dispatch(
+        SfuEvent.create({
+          eventPayload: {
+            oneofKind: 'changePublishOptions',
+            changePublishOptions: {
+              publishOptions: [videoOption(1, 'vp9')],
+              reason: 'test',
+            },
+          },
+        }) as DispatchableMessage<'changePublishOptions'>,
+        'test',
+      );
+      // the handler runs synchronously, so the retired options are in place
+      // and syncPublishOptions is already queued behind this publish
+      expect(publisher['publishOptions']).toHaveLength(1);
+
+      firstNegotiation.resolve();
+      await publishTask;
+      await settled(publisher['eventLockKey']('changePublishOptions'));
+
+      expect(announcedKeys()).toEqual([`${TrackType.VIDEO}:1`]);
+    });
+
+    it('reuses the transceiver on republish after setParameters failed', async () => {
+      withDistinctTransceivers((transceiver) => {
+        transceiver.sender.setParameters = vi
+          .fn()
+          .mockRejectedValueOnce(new Error('InvalidModificationError'));
+      });
+
+      await expect(
+        publisher.publish(makeTrack(), TrackType.VIDEO),
+      ).rejects.toThrow('InvalidModificationError');
+
+      // the transceiver the browser created is tracked, so the republish
+      // reuses it instead of adding a second one for the same publish option
+      await publisher.publish(makeTrack(), TrackType.VIDEO);
+
+      expect(publisher['pc'].addTransceiver).toHaveBeenCalledTimes(1);
+      expect(publisher['transceiverCache'].items()).toHaveLength(1);
+      expect(announcedKeys()).toEqual([`${TrackType.VIDEO}:1`]);
+    });
+  });
 });

package/src/rtc/types.ts

@@ -39,8 +39,7 @@ export const ReconnectReason = {
 } as const;
 
 export type ReconnectReason =
-  | (typeof ReconnectReason)[keyof typeof ReconnectReason]
-  | (string & {});
+  (typeof ReconnectReason)[keyof typeof ReconnectReason] | (string & {});
 
 export type OnReconnectionNeeded = (
   kind: WebsocketReconnectStrategy,
@@ -60,18 +59,20 @@ export type OnIceConnected = (peerType: PeerType) => void;
  * Snapshot of the peer connection's ICE and DTLS state surfaced to telemetry
  * consumers (e.g. `ClientEventReporter`). Fired on every transition of
  * either `iceConnectionState` or `peerConnectionState`.
+ *
+ * `iceConnectionState` is the live `RTCPeerConnection.iceConnectionState` read
+ * at the moment the event fires, regardless of which transition triggered it.
+ * Consumers must use it (rather than assuming a value from `stateType`) because
+ * the browser does not guarantee the relative ordering of the `ice` and
+ * `peerConnection` `failed` transitions.
  */
-export type PeerConnectionStateChangeEvent =
-  | {
-      peerType: PeerType;
-      stateType: 'ice';
-      state: RTCIceConnectionState;
-    }
-  | {
-      peerType: PeerType;
-      stateType: 'peerConnection';
-      state: RTCPeerConnectionState;
-    };
+export type PeerConnectionStateChangeEvent = {
+  peerType: PeerType;
+  iceConnectionState: RTCIceConnectionState;
+} & (
+  | { stateType: 'ice'; state: RTCIceConnectionState }
+  | { stateType: 'peerConnection'; state: RTCPeerConnectionState }
+);
 
 export type OnPeerConnectionStateChange = (
   event: PeerConnectionStateChangeEvent,

package/src/stats/rtc/types.ts

@@ -12,9 +12,15 @@ export type RTCStatsDataType =
   | boolean
   | RTCOfferOptions
   | [string | RTCDataChannelInit | undefined] // createDataChannel
-  | (RTCOfferOptions | undefined) // createOffer | createAnswer
+  | (
+      | RTCOfferOptions
+      | undefined // createOffer | createAnswer
+    )
   | RTCSessionDescriptionInit
-  | (RTCIceCandidateInit | RTCIceCandidate) // addIceCandidate
+  | (
+      | RTCIceCandidateInit
+      | RTCIceCandidate // addIceCandidate
+    )
   | object
   | number
   | null

package/src/store/CallState.ts

@@ -341,8 +341,7 @@ export class CallState {
 
   private readonly eventHandlers: {
     [EventType in VideoEvent['type']]:
-      | ((event: Extract<VideoEvent, { type: EventType }>) => void)
-      | undefined;
+      ((event: Extract<VideoEvent, { type: EventType }>) => void) | undefined;
   };
 
   /**
@@ -408,21 +407,6 @@ export class CallState {
     this.thumbnails$ = this.thumbnailsSubject.asObservable();
     this.closedCaptions$ = this.closedCaptionsSubject.asObservable();
 
-    /**
-     * Performs shallow comparison of two arrays.
-     * Expects primitive values: [1, 2, 3] is equal to [2, 1, 3].
-     */
-    const isShallowEqual = <T>(a: Array<T>, b: Array<T>): boolean => {
-      if (a.length !== b.length) return false;
-      for (const item of a) {
-        if (!b.includes(item)) return false;
-      }
-      for (const item of b) {
-        if (!a.includes(item)) return false;
-      }
-      return true;
-    };
-
     /**
      * Creates an Observable from the given subject by piping to the
      * `distinctUntilChanged()` operator.
@@ -436,7 +420,10 @@ export class CallState {
     this.anonymousParticipantCount$ = duc(
       this.anonymousParticipantCountSubject,
     );
-    this.blockedUserIds$ = duc(this.blockedUserIdsSubject, isShallowEqual);
+    this.blockedUserIds$ = duc(
+      this.blockedUserIdsSubject,
+      RxUtils.isShallowArrayEqual,
+    );
     this.backstage$ = duc(this.backstageSubject);
     this.callingState$ = duc(this.callingStateSubject);
     this.ownCapabilities$ = combineLatest([
@@ -471,7 +458,7 @@ export class CallState {
 
         return nextCapabilities;
       }),
-      distinctUntilChanged(isShallowEqual),
+      distinctUntilChanged(RxUtils.isShallowArrayEqual),
       shareReplay({ bufferSize: 1, refCount: true }),
     );
     this.participantCount$ = duc(this.participantCountSubject);

package/src/store/rxUtils.ts

@@ -10,6 +10,21 @@ type AsyncFunctionPatch<T> = (currentValue: T) => Promise<T>;
  */
 export type Patch<T> = T | FunctionPatch<T>;
 
+/**
+ * Performs shallow comparison of two arrays.
+ * Expects primitive values: [1, 2, 3] is equal to [2, 1, 3].
+ */
+export const isShallowArrayEqual = <T>(a: Array<T>, b: Array<T>): boolean => {
+  if (a.length !== b.length) return false;
+  for (const item of a) {
+    if (!b.includes(item)) return false;
+  }
+  for (const item of b) {
+    if (!a.includes(item)) return false;
+  }
+  return true;
+};
+
 /**
  * Checks if the provided update is a function patch.
  *

package/src/types.ts

@@ -143,10 +143,7 @@ export interface StreamVideoParticipant extends Participant {
 export type VideoTrackType = 'videoTrack' | 'screenShareTrack';
 export type AudioTrackType = 'audioTrack' | 'screenShareAudioTrack';
 export type TrackMuteType =
-  | 'audio'
-  | 'video'
-  | 'screenshare'
-  | 'screenshare_audio';
+  'audio' | 'video' | 'screenshare' | 'screenshare_audio';
 
 /**
  * Represents a participant's pin state.