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

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

@@ -1,6 +1,7 @@
 import type { AxiosResponse } from 'axios';
 import type { APIErrorResponse } from './types';
 import type { ConnectionErrorEvent } from '../../gen/coordinator';
+import type { ScopedLogger } from '../../logger';
 export declare const sleep: (m: number) => Promise<unknown>;
 export declare const timeboxed: <T extends Promise<unknown>[]>(promises: [...T], ms: number) => Promise<{ [K in keyof T]: Awaited<T[K]>; }>;
 export declare function isFunction<T>(value: Function | T): value is Function;
@@ -25,3 +26,12 @@ export declare function addConnectionEventListeners(cb: (e: Event) => void): voi
 export declare function removeConnectionEventListeners(cb: (e: Event) => void): void;
 export declare function isErrorResponse(res: AxiosResponse<unknown>): res is AxiosResponse<APIErrorResponse>;
 export declare function isCloseEvent(res: CloseEvent | ConnectionErrorEvent): res is CloseEvent;
+/**
+ * Invokes a single event listener in isolation, so that a faulty listener
+ * cannot abort the dispatch loop nor the bookkeeping that follows it.
+ *
+ * @param listener the listener to invoke.
+ * @param event the event to pass to the listener.
+ * @param logger the logger to report listener failures with.
+ */
+export declare const invokeEventListener: <T>(listener: (event: T) => unknown, event: T, logger: ScopedLogger) => void;

package/dist/src/sorting/participants.d.ts

@@ -36,6 +36,19 @@ export declare const publishingVideo: Comparator<StreamVideoParticipant>;
  * @param b the second participant.
  */
 export declare const publishingAudio: Comparator<StreamVideoParticipant>;
+/**
+ * A comparator which prioritizes participants who are publishing any track
+ * over participants who are not publishing at all.
+ *
+ * Unlike `publishingVideo` and `publishingAudio`, this comparator does not
+ * distinguish between track types. Muting the microphone or turning off the
+ * camera does not change a participant's rank as long as they still publish
+ * something, which keeps the ordering stable across ordinary device toggles.
+ *
+ * @param a the first participant.
+ * @param b the second participant.
+ */
+export declare const publishing: Comparator<StreamVideoParticipant>;
 /**
  * A comparator which prioritizes participants who are pinned.
  *

package/package.json

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

package/src/__tests__/StreamVideoClient.ringing.test.ts

@@ -17,7 +17,14 @@ const secret = process.env.STREAM_SECRET!;
 
 describe('StreamVideoClient Ringing', () => {
   const serverClient = new StreamClient(apiKey, secret);
-  const testUserIds = ['oliver', 'sacha', 'marcelo'];
+
+  // user ids are generated per test: CI runs share a single Stream app, so
+  // fixed ids let a concurrently running job ring these users and satisfy the
+  // assertions in this file with an unrelated call.
+  let oliverId: string;
+  let sachaId: string;
+  let marceloId: string;
+  let testUserIds: string[];
 
   let oliverClient: StreamVideoClient;
   let sachaClient: StreamVideoClient;
@@ -54,6 +61,11 @@ describe('StreamVideoClient Ringing', () => {
   };
 
   beforeEach(async () => {
+    const suffix = crypto.randomUUID();
+    oliverId = `oliver-${suffix}`;
+    sachaId = `sacha-${suffix}`;
+    marceloId = `marcelo-${suffix}`;
+    testUserIds = [oliverId, sachaId, marceloId];
     [oliverClient, sachaClient, marceloClient] =
       await createClients(testUserIds);
   });
@@ -75,11 +87,11 @@ describe('StreamVideoClient Ringing', () => {
       await call.create({
         ring: true,
         data: {
-          created_by_id: 'oliver',
+          created_by_id: oliverId,
           members: [
-            { user_id: 'oliver' },
-            { user_id: 'sacha' },
-            { user_id: 'marcelo' },
+            { user_id: oliverId },
+            { user_id: sachaId },
+            { user_id: marceloId },
           ],
         },
       });
@@ -112,9 +124,9 @@ describe('StreamVideoClient Ringing', () => {
         ring: true,
         data: {
           members: [
-            { user_id: 'oliver' },
-            { user_id: 'sacha' },
-            { user_id: 'marcelo' },
+            { user_id: oliverId },
+            { user_id: sachaId },
+            { user_id: marceloId },
           ],
         },
       });
@@ -144,9 +156,9 @@ describe('StreamVideoClient Ringing', () => {
         ring: false, // don't ring all members by default
         data: {
           members: [
-            { user_id: 'oliver' },
-            { user_id: 'sacha' },
-            { user_id: 'marcelo' },
+            { user_id: oliverId },
+            { user_id: sachaId },
+            { user_id: marceloId },
           ],
         },
       });
@@ -162,7 +174,7 @@ describe('StreamVideoClient Ringing', () => {
       // oliver is calling sacha. only sacha should get a ring event
       const sachaIndividualRing = expectEvent(sachaClient, 'call.ring');
       const marceloIndividualRing = expectEvent(marceloClient, 'call.ring');
-      await oliverCall.ring({ members_ids: ['sacha'] });
+      await oliverCall.ring({ members_ids: [sachaId] });
       await expect(sachaIndividualRing).resolves.toHaveProperty(
         'call.cid',
         oliverCall.cid,
@@ -175,7 +187,7 @@ describe('StreamVideoClient Ringing', () => {
       // sacha is calling marcelo. only marcelo should get a ring event
       const oliverIndividualRing = expectEvent(oliverClient, 'call.ring');
       const marceloIndividualRing2 = expectEvent(marceloClient, 'call.ring');
-      await sachaCall.ring({ members_ids: ['marcelo'] });
+      await sachaCall.ring({ members_ids: [marceloId] });
       await expect(marceloIndividualRing2).resolves.toHaveProperty(
         'call.cid',
         sachaCall.cid,
@@ -241,8 +253,8 @@ describe('StreamVideoClient Ringing', () => {
       const serverCall = serverClient.video.call('default', callId);
       await serverCall.create({
         data: {
-          created_by_id: 'oliver',
-          members: [{ user_id: 'oliver' }, { user_id: 'sacha' }],
+          created_by_id: oliverId,
+          members: [{ user_id: oliverId }, { user_id: sachaId }],
         },
       });
 
@@ -266,7 +278,7 @@ describe('StreamVideoClient Ringing', () => {
       await oliverCall.create({
         ring: true,
         data: {
-          members: [{ user_id: 'oliver' }, { user_id: 'sacha' }],
+          members: [{ user_id: oliverId }, { user_id: sachaId }],
         },
       });
 
@@ -302,7 +314,7 @@ describe('StreamVideoClient Ringing', () => {
       await marceloCall.create({
         ring: true,
         data: {
-          members: [{ user_id: 'marcelo' }, { user_id: 'oliver' }],
+          members: [{ user_id: marceloId }, { user_id: oliverId }],
         },
       });
 
@@ -332,7 +344,7 @@ describe('StreamVideoClient Ringing', () => {
       await marceloCall.create({
         ring: true,
         data: {
-          members: [{ user_id: 'marcelo' }, { user_id: 'sacha' }],
+          members: [{ user_id: marceloId }, { user_id: sachaId }],
         },
       });
 
@@ -354,7 +366,7 @@ describe('StreamVideoClient Ringing', () => {
       await marceloCall.create({
         ring: true,
         data: {
-          members: [{ user_id: 'marcelo' }, { user_id: 'oliver' }],
+          members: [{ user_id: marceloId }, { user_id: oliverId }],
         },
       });
 
@@ -375,7 +387,7 @@ describe('StreamVideoClient Ringing', () => {
       await marceloCall.create({
         ring: true,
         data: {
-          members: [{ user_id: 'marcelo' }, { user_id: 'sacha' }],
+          members: [{ user_id: marceloId }, { user_id: sachaId }],
         },
       });
 

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

@@ -0,0 +1,115 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { StreamClient } from '../client';
+import { StableWSConnection } from '../connection';
+import { videoLoggerSystem } from '../../../logger';
+import type { StreamVideoEvent } from '../types';
+
+const event: StreamVideoEvent = { type: 'network.changed', online: true };
+
+describe('event listener isolation', () => {
+  let client: StreamClient;
+  let sink: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    sink = vi.fn();
+    videoLoggerSystem.configureLoggers({
+      coordinator: { sink, level: 'error' },
+    });
+    client = new StreamClient('key');
+  });
+
+  afterEach(() => {
+    videoLoggerSystem.restoreDefaults();
+    vi.restoreAllMocks();
+  });
+
+  const errorLogs = () =>
+    sink.mock.calls.filter(([level]) => level === 'error');
+
+  it('keeps dispatching after a listener throws', () => {
+    const failure = new Error('listener blew up');
+    const first = vi.fn(() => {
+      throw failure;
+    });
+    const second = vi.fn();
+
+    client.on('network.changed', first);
+    client.on('network.changed', second);
+
+    expect(() => client.dispatchEvent(event)).not.toThrow();
+    expect(first).toHaveBeenCalledTimes(1);
+    expect(second).toHaveBeenCalledTimes(1);
+  });
+
+  it('reports a synchronous throw through the logger', () => {
+    const failure = new Error('listener blew up');
+    client.on('network.changed', () => {
+      throw failure;
+    });
+
+    client.dispatchEvent(event);
+
+    expect(errorLogs()).toEqual([
+      [
+        'error',
+        '[coordinator]: Unhandled error in event listener',
+        failure,
+        event,
+      ],
+    ]);
+  });
+
+  it('reports a rejection from an async listener', async () => {
+    const failure = new Error('async listener blew up');
+    client.on('network.changed', async () => {
+      throw failure;
+    });
+    const next = vi.fn();
+    client.on('network.changed', next);
+
+    client.dispatchEvent(event);
+    expect(next).toHaveBeenCalledTimes(1);
+    expect(errorLogs()).toHaveLength(0);
+
+    await vi.waitFor(() => expect(errorLogs()).toHaveLength(1));
+    expect(errorLogs()[0]).toEqual([
+      'error',
+      '[coordinator]: Unhandled error in event listener',
+      failure,
+      event,
+    ]);
+  });
+
+  it('isolates a faulty `all` listener from type specific listeners', () => {
+    const all = vi.fn(() => {
+      throw new Error('all listener blew up');
+    });
+    const typed = vi.fn();
+
+    client.on('all', all);
+    client.on('network.changed', typed);
+
+    client.dispatchEvent(event);
+
+    expect(all).toHaveBeenCalledTimes(1);
+    expect(typed).toHaveBeenCalledTimes(1);
+    expect(errorLogs()).toHaveLength(1);
+  });
+
+  it('schedules the connection check even when a listener throws', () => {
+    const connection = new StableWSConnection(client);
+    const scheduleConnectionCheck = vi
+      .spyOn(connection, 'scheduleConnectionCheck')
+      .mockImplementation(() => {});
+
+    client.on('all', () => {
+      throw new Error('listener blew up');
+    });
+
+    connection.onmessage(connection.wsID, {
+      data: JSON.stringify({ type: 'custom' }),
+    } as MessageEvent);
+
+    expect(scheduleConnectionCheck).toHaveBeenCalledTimes(1);
+  });
+});

package/src/coordinator/connection/client.ts

@@ -10,6 +10,7 @@ import { TokenManager } from './token_manager';
 import {
   addConnectionEventListeners,
   generateUUIDv4,
+  invokeEventListener,
   isErrorResponse,
   KnownCodes,
   removeConnectionEventListeners,
@@ -589,12 +590,12 @@ export class StreamClient {
 
     // call generic listeners
     for (const listener of this.listeners.all || []) {
-      listener(event);
+      invokeEventListener(listener, event, this.logger);
     }
 
     // call type specific listeners
     for (const listener of this.listeners[event.type] || []) {
-      listener(event);
+      invokeEventListener(listener, event, this.logger);
     }
   };
 

package/src/coordinator/connection/utils.ts

@@ -1,6 +1,7 @@
 import type { AxiosResponse } from 'axios';
 import type { APIErrorResponse } from './types';
 import type { ConnectionErrorEvent } from '../../gen/coordinator';
+import type { ScopedLogger } from '../../logger';
 
 export const sleep = (m: number) => new Promise((r) => setTimeout(r, m));
 
@@ -118,3 +119,30 @@ export function isCloseEvent(
 ): res is CloseEvent {
   return (res as CloseEvent).code !== undefined;
 }
+
+/**
+ * Invokes a single event listener in isolation, so that a faulty listener
+ * cannot abort the dispatch loop nor the bookkeeping that follows it.
+ *
+ * @param listener the listener to invoke.
+ * @param event the event to pass to the listener.
+ * @param logger the logger to report listener failures with.
+ */
+export const invokeEventListener = <T>(
+  listener: (event: T) => unknown,
+  event: T,
+  logger: ScopedLogger,
+) => {
+  try {
+    const result = listener(event);
+    if (result && typeof (result as PromiseLike<unknown>).then === 'function') {
+      Promise.resolve(result).catch((error) => report(logger, error, event));
+    }
+  } catch (error) {
+    report(logger, error, event);
+  }
+};
+
+const report = (logger: ScopedLogger, error: unknown, event: unknown) => {
+  logger.error('Unhandled error in event listener', error, event);
+};

package/src/sorting/__tests__/presets.test.ts

@@ -1,8 +1,54 @@
 import { describe, expect, it } from 'vitest';
 import * as TestData from './participant-data';
-import { VisibilityState } from '../../types';
-import { paginatedLayoutSortPreset } from '../presets';
-import { TrackType } from '../../gen/video/sfu/models/models';
+import { StreamVideoParticipant, VisibilityState } from '../../types';
+import { Comparator } from '../comparator';
+import {
+  defaultSortPreset,
+  livestreamOrAudioRoomSortPreset,
+  paginatedLayoutSortPreset,
+  speakerLayoutSortPreset,
+} from '../presets';
+import {
+  ParticipantSource,
+  TrackType,
+} from '../../gen/video/sfu/models/models';
+
+const participant = (
+  name: string,
+  publishedTracks: TrackType[],
+  visibility: VisibilityState = VisibilityState.VISIBLE,
+  overrides: Partial<StreamVideoParticipant> = {},
+): StreamVideoParticipant =>
+  ({
+    name,
+    userId: name,
+    sessionId: name,
+    roles: ['user'],
+    publishedTracks,
+    trackLookupPrefix: name,
+    isSpeaking: false,
+    isDominantSpeaker: false,
+    audioLevel: 0,
+    image: '',
+    source: ParticipantSource.WEBRTC_UNSPECIFIED,
+    viewportVisibilityState: {
+      videoTrack: visibility,
+      screenShareTrack: visibility,
+    },
+    ...overrides,
+  }) as StreamVideoParticipant;
+
+const names = (ps: StreamVideoParticipant[]) => ps.map((p) => p.name);
+
+// every preset that prioritizes publishing participants over passive ones
+const presets: [string, Comparator<StreamVideoParticipant>][] = [
+  ['defaultSortPreset', defaultSortPreset],
+  ['speakerLayoutSortPreset', speakerLayoutSortPreset],
+  ['livestreamOrAudioRoomSortPreset', livestreamOrAudioRoomSortPreset],
+];
+
+const { UNKNOWN, VISIBLE, INVISIBLE } = VisibilityState;
+const { AUDIO, VIDEO, SCREEN_SHARE } = TrackType;
 
 describe('presets', () => {
   it('paginatedLayoutSortPreset', () => {
@@ -60,4 +106,143 @@ describe('presets', () => {
       ]
     `);
   });
+
+  // In SpeakerLayout the viewport is the participants bar, so the spotlight
+  // tile is never observed and stays UNKNOWN. Regression test for a passive
+  // participant holding the spotlight over a participant publishing video.
+  it.each(presets)(
+    '%s keeps passive participants out of the spotlight',
+    (_, preset) => {
+      const ps = [
+        participant('passive-viewer', [], UNKNOWN),
+        participant('host', [VIDEO]),
+        participant('local-viewer', [], VISIBLE, { isLocalParticipant: true }),
+      ];
+
+      expect(names(ps.sort(preset))).toEqual([
+        'host',
+        'passive-viewer',
+        'local-viewer',
+      ]);
+    },
+  );
+
+  it.each(presets)(
+    '%s promotes a rejoined publisher appended last',
+    (_, preset) => {
+      const ps = [
+        participant('v1', [], UNKNOWN),
+        participant('v2', []),
+        participant('v3', []),
+      ].sort(preset);
+      // a rejoining participant is appended to the end of the list
+      ps.push(participant('host', [AUDIO, VIDEO], UNKNOWN));
+
+      expect(names(ps.sort(preset))).toEqual(['host', 'v1', 'v2', 'v3']);
+    },
+  );
+
+  it.each(presets)(
+    '%s ranks passive participants below publishing ones regardless of visibility',
+    (_, preset) => {
+      const passive = [
+        participant('p1', [], UNKNOWN),
+        participant('p2', [], VISIBLE),
+        participant('p3', [], INVISIBLE),
+      ];
+      const publishing = [
+        participant('a1', [VIDEO], UNKNOWN),
+        participant('a2', [AUDIO], VISIBLE),
+        participant('a3', [AUDIO, VIDEO], INVISIBLE),
+      ];
+
+      for (const a of passive) {
+        for (const b of publishing) {
+          expect(preset(a, b)).toBe(1);
+          expect(preset(b, a)).toBe(-1);
+        }
+      }
+    },
+  );
+
+  // `publishing` ignores the track type, so a participant keeps its rank while
+  // it still publishes something. In speakerLayoutSortPreset the gated
+  // comparators cannot override this, because the gate only opens on INVISIBLE.
+  it.each<[string, TrackType[]]>([
+    ['camera and microphone on', [AUDIO, VIDEO]],
+    ['the microphone muted', [VIDEO]],
+    ['the camera turned off', [AUDIO]],
+  ])(
+    'speakerLayoutSortPreset keeps the spotlight with %s',
+    (_, spotlightTracks) => {
+      const ps = [
+        participant('spotlight', spotlightTracks, UNKNOWN),
+        participant('bar', [AUDIO, VIDEO]),
+      ];
+
+      expect(names(ps.sort(speakerLayoutSortPreset))).toEqual([
+        'spotlight',
+        'bar',
+      ]);
+    },
+  );
+
+  it('speakerLayoutSortPreset drops a spotlight that stops publishing', () => {
+    const ps = [
+      participant('spotlight', [], UNKNOWN),
+      participant('bar', [AUDIO, VIDEO]),
+    ];
+
+    expect(names(ps.sort(speakerLayoutSortPreset))).toEqual([
+      'bar',
+      'spotlight',
+    ]);
+  });
+
+  // livestreamOrAudioRoomSortPreset gates on INVISIBLE *or* UNKNOWN, so an
+  // unobserved spotlight tile stays comparable by audio and video state. This
+  // predates the `publishing` comparator, which only breaks ties between a
+  // publishing and a non-publishing participant.
+  it('livestreamOrAudioRoomSortPreset still re-ranks publishers by track state', () => {
+    const ps = [
+      participant('spotlight', [VIDEO], UNKNOWN),
+      participant('bar', [AUDIO, VIDEO]),
+    ];
+
+    expect(names(ps.sort(livestreamOrAudioRoomSortPreset))).toEqual([
+      'bar',
+      'spotlight',
+    ]);
+  });
+
+  it.each<[string, TrackType[], Partial<StreamVideoParticipant>]>([
+    ['a pinned participant', [], { pin: { isLocalPin: true, pinnedAt: 1 } }],
+    ['a presenter', [SCREEN_SHARE], {}],
+    ['the dominant speaker', [AUDIO], { isDominantSpeaker: true }],
+  ])(
+    'speakerLayoutSortPreset ranks %s above a publishing participant',
+    (_, tracks, overrides) => {
+      const ps = [
+        participant('publisher', [AUDIO, VIDEO], UNKNOWN),
+        participant('contender', tracks, VISIBLE, overrides),
+      ];
+
+      expect(names(ps.sort(speakerLayoutSortPreset))).toEqual([
+        'contender',
+        'publisher',
+      ]);
+    },
+  );
+
+  it('livestreamOrAudioRoomSortPreset still uses role as a tie breaker between publishers', () => {
+    const ps = [
+      participant('viewer', [AUDIO, VIDEO]),
+      participant('host', [AUDIO, VIDEO], UNKNOWN, { roles: ['host'] }),
+    ];
+
+    expect(names(ps.sort(livestreamOrAudioRoomSortPreset))).toEqual([
+      'host',
+      'viewer',
+    ]);
+  });
 });

package/src/sorting/__tests__/sorting.test.ts

@@ -1,11 +1,16 @@
 import { describe, expect, it } from 'vitest';
-import { ParticipantSource } from '../../gen/video/sfu/models/models';
+import {
+  ParticipantSource,
+  TrackType,
+} from '../../gen/video/sfu/models/models';
+import { StreamVideoParticipant } from '../../types';
 import {
   combineComparators,
   Comparator,
   conditional,
   dominantSpeaker,
   pinned,
+  publishing,
   publishingAudio,
   publishingVideo,
   screenSharing,
@@ -37,6 +42,22 @@ describe('Sorting', () => {
     expect(sorted.map((p) => p.name)).toEqual(['F', 'D', 'B', 'A', 'E', 'C']);
   });
 
+  it('publishing', () => {
+    const { AUDIO, VIDEO, SCREEN_SHARE } = TrackType;
+    const p = (publishedTracks: TrackType[]) =>
+      ({ publishedTracks }) as StreamVideoParticipant;
+
+    // publishing anything ranks above publishing nothing
+    expect(publishing(p([AUDIO]), p([]))).toEqual(-1);
+    expect(publishing(p([SCREEN_SHARE]), p([]))).toEqual(-1);
+    expect(publishing(p([]), p([VIDEO]))).toEqual(1);
+
+    // the track type is irrelevant, so device toggles do not change the rank
+    expect(publishing(p([AUDIO, VIDEO]), p([AUDIO]))).toEqual(0);
+    expect(publishing(p([VIDEO]), p([AUDIO]))).toEqual(0);
+    expect(publishing(p([]), p([]))).toEqual(0);
+  });
+
   it('conditional comparator', () => {
     const byValue: Comparator<number> = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
     const input = [2, 3, 1];

package/src/sorting/participants.ts

@@ -73,6 +73,26 @@ export const publishingAudio: Comparator<StreamVideoParticipant> = (a, b) => {
   return 0;
 };
 
+/**
+ * A comparator which prioritizes participants who are publishing any track
+ * over participants who are not publishing at all.
+ *
+ * Unlike `publishingVideo` and `publishingAudio`, this comparator does not
+ * distinguish between track types. Muting the microphone or turning off the
+ * camera does not change a participant's rank as long as they still publish
+ * something, which keeps the ordering stable across ordinary device toggles.
+ *
+ * @param a the first participant.
+ * @param b the second participant.
+ */
+export const publishing: Comparator<StreamVideoParticipant> = (a, b) => {
+  const hasA = a.publishedTracks.length > 0;
+  const hasB = b.publishedTracks.length > 0;
+  if (hasA && !hasB) return -1;
+  if (!hasA && hasB) return 1;
+  return 0;
+};
+
 /**
  * A comparator which prioritizes participants who are pinned.
  *

package/src/sorting/presets.ts

@@ -4,6 +4,7 @@ import { ParticipantSource } from '../gen/video/sfu/models/models';
 import {
   dominantSpeaker,
   pinned,
+  publishing,
   publishingAudio,
   publishingVideo,
   reactionType,
@@ -51,6 +52,7 @@ const withVideoIngressSource = withParticipantSource(
 export const defaultSortPreset = combineComparators(
   screenSharing,
   pinned,
+  publishing,
   ifInvisibleBy(
     combineComparators(
       dominantSpeaker,
@@ -69,6 +71,7 @@ export const speakerLayoutSortPreset = combineComparators(
   screenSharing,
   pinned,
   dominantSpeaker,
+  publishing,
   ifInvisibleBy(
     combineComparators(
       speaking,
@@ -102,6 +105,7 @@ export const paginatedLayoutSortPreset = combineComparators(
  * The sorting preset for livestreams and audio rooms.
  */
 export const livestreamOrAudioRoomSortPreset = combineComparators(
+  publishing,
   ifInvisibleOrUnknownBy(
     combineComparators(
       dominantSpeaker,

package/src/store/__tests__/CallState.test.ts

@@ -266,8 +266,8 @@ describe('CallState', () => {
           "E",
           "F",
           "A",
-          "C",
           "D",
+          "C",
         ]
       `);
 
@@ -288,8 +288,8 @@ describe('CallState', () => {
           "E",
           "F",
           "A",
-          "C",
           "D",
+          "C",
         ]
       `);
     });