@stream-io/video-client 1.57.0 → 1.59.0

package/src/permissions/PermissionsContext.ts

@@ -1,4 +1,8 @@
-import { CallSettingsResponse, OwnCapability } from '../gen/coordinator';
+import {
+  CallSettingsResponse,
+  OwnCapability,
+  RequestPermissionRequestPermissionsEnum,
+} from '../gen/coordinator';
 import { TrackType } from '../gen/video/sfu/models/models';
 import { ensureExhausted } from '../helpers/ensureExhausted';
 
@@ -70,20 +74,21 @@ export class PermissionsContext {
    * @param settings the call settings to check against (optional).
    */
   canRequest = (
-    permission: OwnCapability,
+    permission: RequestPermissionRequestPermissionsEnum,
     settings: CallSettingsResponse | undefined = this.settings,
   ) => {
     if (!settings) return false;
 
     const { audio, video, screensharing } = settings;
     switch (permission) {
-      case OwnCapability.SEND_AUDIO:
+      case RequestPermissionRequestPermissionsEnum.SEND_AUDIO:
         return audio.access_request_enabled;
-      case OwnCapability.SEND_VIDEO:
+      case RequestPermissionRequestPermissionsEnum.SEND_VIDEO:
         return video.access_request_enabled;
-      case OwnCapability.SCREENSHARE:
+      case RequestPermissionRequestPermissionsEnum.SCREENSHARE:
         return screensharing.access_request_enabled;
       default:
+        ensureExhausted(permission);
         return false;
     }
   };

package/src/reporting/ClientEventReporter.ts

@@ -19,6 +19,11 @@ import type {
   BrowserPermissionState,
 } from '../devices/BrowserPermission';
 import { getCurrentValue } from '../store/rxUtils';
+import type {
+  ClientEvent,
+  ReportClientEventRequest,
+  ReportClientEventResponse,
+} from '../gen/coordinator';
 
 export type ClientEventPeerConnection = 'publish' | 'subscribe';
 
@@ -55,7 +60,6 @@ export type CallReportContext = {
   callId: string;
   getSfuId: () => string;
   getCallSessionId: () => string;
-  getUserSessionId: () => string;
 };
 
 export type ClientEventReporterOptions = {
@@ -80,7 +84,6 @@ type StagePairState = {
 
 type PeerConnectionPairState = StagePairState & {
   sfuId: string;
-  userSessionId: string;
   wasPreviouslyConnected: boolean;
   lastIceState?: RTCIceConnectionState;
 };
@@ -192,9 +195,7 @@ export class ClientEventReporter {
     this.coordinatorWsPair = undefined;
   };
 
-  private buildCoordinatorWsCommon = (
-    pair: StagePairState,
-  ): Record<string, unknown> => ({
+  private buildCoordinatorWsCommon = (pair: StagePairState): ClientEvent => ({
     user_id: pair.userIdSnapshot ?? this.streamClient.userID,
     stage: 'CoordinatorWS',
     stage_id: pair.sid,
@@ -383,7 +384,6 @@ export class ClientEventReporter {
       user_id: this.streamClient.userID || this.coordinatorConnectUserId,
       type: ctx?.callType,
       id: ctx?.callId,
-      call_cid: cid,
       stage: 'JoinInitiated',
       join_attempt_id: joinAttemptId,
       ...(coordinatorConnectId && {
@@ -608,7 +608,6 @@ export class ClientEventReporter {
       startedAt: Date.now(),
       joinAttemptIdSnapshot: this.joinAttemptIds.get(cid),
       sfuId: this.getSfuId(cid),
-      userSessionId: this.getUserSessionId(cid),
       wasPreviouslyConnected: this.pcEverConnected.get(key) === true,
       lastIceState: iceConnectionState,
     };
@@ -620,9 +619,6 @@ export class ClientEventReporter {
       peer_connection: role,
       was_previously_connected: pair.wasPreviouslyConnected,
       ...(pair.sfuId && { sfu_id: pair.sfuId }),
-      ...(pair.userSessionId && {
-        user_session_id: pair.userSessionId,
-      }),
       event_type: 'initiated',
     });
   };
@@ -641,9 +637,6 @@ export class ClientEventReporter {
       peer_connection: role,
       was_previously_connected: pair.wasPreviouslyConnected,
       ...(pair.sfuId && { sfu_id: pair.sfuId }),
-      ...(pair.userSessionId && {
-        user_session_id: pair.userSessionId,
-      }),
       event_type: 'completed',
       outcome: 'success',
       retry_count_attempt: 0,
@@ -667,9 +660,6 @@ export class ClientEventReporter {
       ...this.sessionIdField(cid),
       peer_connection: role,
       was_previously_connected: pair.wasPreviouslyConnected,
-      ...(pair.userSessionId && {
-        user_session_id: pair.userSessionId,
-      }),
       ...(pair.sfuId && { sfu_id: pair.sfuId }),
       event_type: 'completed',
       outcome: 'failure',
@@ -685,10 +675,7 @@ export class ClientEventReporter {
   private getSfuId = (cid: string): string =>
     this.callContexts.get(cid)?.getSfuId() ?? '';
 
-  private getUserSessionId = (cid: string): string =>
-    this.callContexts.get(cid)?.getUserSessionId() ?? '';
-
-  private sessionIdField = (cid: string): Record<string, unknown> => {
+  private sessionIdField = (cid: string): { call_session_id?: string } => {
     const callSessionId = this.callContexts.get(cid)?.getCallSessionId() ?? '';
     return callSessionId ? { call_session_id: callSessionId } : {};
   };
@@ -697,14 +684,13 @@ export class ClientEventReporter {
     cid: string,
     stage: ClientEventStage,
     pair: StagePairState,
-  ): Record<string, unknown> => {
+  ): ClientEvent => {
     const ctx = this.callContexts.get(cid);
     const coordinatorConnectId = this.coordinatorConnectId;
     return {
       user_id: this.streamClient.userID || this.coordinatorConnectUserId,
       type: ctx?.callType ?? '',
       id: ctx?.callId ?? '',
-      call_cid: cid,
       stage,
       stage_id: pair.sid,
       ...(pair.joinAttemptIdSnapshot && {
@@ -719,22 +705,23 @@ export class ClientEventReporter {
     };
   };
 
-  private send = (body: Record<string, unknown>) => {
+  private send = (body: ClientEvent) => {
     if (!this.enabled) return;
     void this.sendWithRetry(body);
   };
 
-  private sendForCall = (cid: string, body: Record<string, unknown>) => {
+  private sendForCall = (cid: string, body: ClientEvent) => {
     if (!this.callContexts.has(cid)) return;
     this.send(body);
   };
 
-  private sendWithRetry = async (
-    body: Record<string, unknown>,
-  ): Promise<boolean> => {
+  private sendWithRetry = async (body: ClientEvent): Promise<boolean> => {
     for (let attempt = 0; attempt < 5; attempt++) {
       try {
-        await this.streamClient.doAxiosRequest(
+        await this.streamClient.doAxiosRequest<
+          ReportClientEventResponse,
+          ReportClientEventRequest
+        >(
           'post',
           '/call_client_event',
           { events: [body] },

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

@@ -77,7 +77,6 @@ describe('ClientEventReporter', () => {
       callId: 'call-1',
       getCallSessionId: () => 'session-1',
       getSfuId: () => 'sfu-1',
-      getUserSessionId: () => 'user-session-1',
     };
     reporter.registerCall(cid, ctx);
   });
@@ -91,7 +90,7 @@ describe('ClientEventReporter', () => {
     expect(events).toHaveLength(2);
     expect(events[0]).toMatchObject({
       event_type: 'initiated',
-      call_cid: cid,
+      id: 'call-1',
       user_id: 'user-1',
       coordinator_connect_id: connectId,
       join_reason: 'first-attempt',
@@ -523,7 +522,6 @@ describe('ClientEventReporter', () => {
       peer_connection: 'publish',
       was_previously_connected: false,
       sfu_id: 'sfu-1',
-      user_session_id: 'user-session-1',
     });
     expect(events[1]).toMatchObject({
       event_type: 'completed',
@@ -712,7 +710,6 @@ describe('ClientEventReporter', () => {
       callId: 'call-2',
       getCallSessionId: () => 'session-2',
       getSfuId: () => 'sfu-2',
-      getUserSessionId: () => 'user-session-2',
     });
 
     reporter.startCorrelation(cid, 'first-attempt');
@@ -722,10 +719,10 @@ describe('ClientEventReporter', () => {
     await flush();
 
     const ws1 = postedEvents().filter(
-      (e) => e.stage === 'WSJoin' && e.call_cid === cid,
+      (e) => e.stage === 'WSJoin' && e.id === 'call-1',
     );
     const ws2 = postedEvents().filter(
-      (e) => e.stage === 'WSJoin' && e.call_cid === cid2,
+      (e) => e.stage === 'WSJoin' && e.id === 'call-2',
     );
     expect(ws1).toHaveLength(2);
     expect(ws2).toHaveLength(2);
@@ -806,7 +803,6 @@ describe('ClientEventReporter (disabled)', () => {
       callId: 'call-1',
       getCallSessionId: () => 'session-1',
       getSfuId: () => 'sfu-1',
-      getUserSessionId: () => 'user-session-1',
     });
   });
 

package/src/rtc/BasePeerConnection.ts

@@ -8,6 +8,8 @@ import {
   TrackType,
   WebsocketReconnectStrategy,
 } from '../gen/video/sfu/models/models';
+import type { E2EEManager } from './e2ee/E2EEManager';
+import { hasInsertableStreams } from './e2ee/transformSupport';
 import { NegotiationError } from './NegotiationError';
 import { StreamSfuClient } from '../StreamSfuClient';
 import { AllSfuEvents, Dispatcher } from './Dispatcher';
@@ -35,6 +37,7 @@ export abstract class BasePeerConnection {
   protected readonly state: CallState;
   protected readonly dispatcher: Dispatcher;
   protected readonly clientPublishOptions?: ClientPublishOptions;
+  protected readonly e2ee?: E2EEManager;
   protected tag: string;
   protected sfuClient: StreamSfuClient;
 
@@ -75,6 +78,7 @@ export abstract class BasePeerConnection {
       tag,
       enableTracing,
       clientPublishOptions,
+      e2ee,
       iceRestartDelay = 2500,
       statsTimestampDriftThresholdMs = 0,
     }: BasePeerConnectionOpts,
@@ -85,6 +89,7 @@ export abstract class BasePeerConnection {
     this.dispatcher = dispatcher;
     this.iceRestartDelay = iceRestartDelay;
     this.clientPublishOptions = clientPublishOptions;
+    this.e2ee = e2ee;
     this.tag = tag;
     this.onReconnectionNeeded = onReconnectionNeeded;
     this.onIceConnected = onIceConnected;
@@ -114,7 +119,13 @@ export abstract class BasePeerConnection {
   }
 
   private createPeerConnection = (connectionConfig?: RTCConfiguration) => {
-    const pc = new RTCPeerConnection(connectionConfig);
+    const config: RTCConfiguration = { ...connectionConfig };
+    // The legacy Insertable Streams path requires this non-standard flag.
+    if (this.e2ee && hasInsertableStreams()) {
+      // @ts-expect-error not part of the standard lib yet
+      config.encodedInsertableStreams = true;
+    }
+    const pc = new RTCPeerConnection(config);
     pc.addEventListener('icecandidate', this.onIceCandidate);
     pc.addEventListener('icecandidateerror', this.onIceCandidateError);
     pc.addEventListener(

package/src/rtc/Publisher.ts

@@ -166,6 +166,14 @@ export class Publisher extends BasePeerConnection {
       toRTCDegradationPreference(publishOption.degradationPreference) ??
       'maintain-framerate';
     await transceiver.sender.setParameters(params);
+    if (this.e2ee) {
+      this.e2ee.encrypt(
+        transceiver.sender,
+        publishOption.codec?.name.toLowerCase(),
+        TrackType[publishOption.trackType],
+      );
+      this.logger.debug('E2EE encryptor attached to sender');
+    }
 
     await this.negotiate();
   };

package/src/rtc/Subscriber.ts

@@ -94,6 +94,13 @@ export class Subscriber extends BasePeerConnection {
     }
   };
 
+  /**
+   * Whether the given stream is one the SFU echoed back to us
+   * (`allowOwnTracksLoopback`) rather than a local capture stream.
+   */
+  isSelfSubscribedStream = (stream: MediaStream | undefined): boolean =>
+    !!stream && !!this.trackedStreams?.has(stream);
+
   private handleOnTrack = (e: RTCTrackEvent) => {
     const { streams, track } = e;
     const [primaryStream] = streams;
@@ -151,8 +158,13 @@ export class Subscriber extends BasePeerConnection {
         trackLookupPrefix: trackId,
         track: primaryStream,
         trackType,
+        receiver: this.e2ee ? e.receiver : undefined,
       });
       return;
+    } else if (this.e2ee) {
+      const { userId } = participantToUpdate;
+      this.e2ee.decrypt(e.receiver, userId, TrackType[trackType]);
+      this.logger.debug('E2EE decryptor attached to receiver', userId);
     }
 
     const streamKindProp = trackTypeToParticipantStreamKey(trackType);
@@ -207,6 +219,7 @@ export class Subscriber extends BasePeerConnection {
       (p) => p.trackLookupPrefix === trackId,
     );
     if (!target) return;
+    if (target.isLocalParticipant) return;
     this.state.updateParticipant(target.sessionId, (p) => {
       const current = p.interruptedTracks ?? [];
       const has = current.includes(trackType);

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

@@ -146,6 +146,50 @@ describe('Publisher', () => {
       expect(negotiateSpy).toHaveBeenCalled();
     });
 
+    it('should attach an encryptor when E2EE manager is provided', async () => {
+      const e2eeMock = {
+        encrypt: vi.fn(),
+        decrypt: vi.fn(),
+      };
+      publisher.dispose();
+      publisher = new Publisher(
+        {
+          sfuClient,
+          dispatcher,
+          state,
+          tag: 'test',
+          enableTracing: false,
+          e2ee: e2eeMock,
+        },
+        [
+          {
+            id: 1,
+            trackType: TrackType.VIDEO,
+            bitrate: 1000,
+            // @ts-expect-error - incomplete data
+            codec: { name: 'vp9' },
+            fps: 30,
+            maxTemporalLayers: 3,
+            maxSpatialLayers: 3,
+          },
+        ],
+      );
+
+      const track = new MediaStreamTrack();
+      const clone = new MediaStreamTrack();
+      vi.spyOn(track, 'clone').mockReturnValue(clone);
+      // @ts-expect-error - private method
+      vi.spyOn(publisher, 'negotiate').mockResolvedValue();
+
+      await publisher.publish(track, TrackType.VIDEO);
+
+      expect(e2eeMock.encrypt).toHaveBeenCalledWith(
+        expect.anything(), // sender
+        'vp9',
+        'VIDEO',
+      );
+    });
+
     it('should update an existing transceiver for a new track', async () => {
       const track = new MediaStreamTrack();
       const clone = new MediaStreamTrack();
@@ -239,6 +283,63 @@ describe('Publisher', () => {
     });
   });
 
+  describe('E2EE peer connection config', () => {
+    const e2ee = { encrypt: vi.fn(), decrypt: vi.fn() };
+
+    /**
+     * Build a publisher and return the RTCConfiguration it constructed its peer
+     * connection with. The publisher from the outer `beforeEach` already
+     * consumed a call, hence the last one rather than the first.
+     */
+    const configOf = async (opts: { e2ee?: typeof e2ee }) => {
+      await publisher.dispose();
+      publisher = new Publisher(
+        {
+          sfuClient,
+          dispatcher,
+          state,
+          tag: 'test',
+          enableTracing: false,
+          ...opts,
+        },
+        [],
+      );
+      const calls = vi.mocked(globalThis.RTCPeerConnection).mock.calls;
+      return calls[calls.length - 1][0] as Record<string, unknown> | undefined;
+    };
+
+    const withInsertableStreams = (available: boolean) => {
+      if (available) {
+        Object.assign(RTCRtpSender.prototype, {
+          createEncodedStreams: vi.fn(),
+        });
+      } else {
+        // @ts-expect-error - non-standard property from the mock prototype
+        delete RTCRtpSender.prototype.createEncodedStreams;
+      }
+    };
+
+    afterEach(() => withInsertableStreams(false));
+
+    it('enables encodedInsertableStreams when a manager is attached', async () => {
+      withInsertableStreams(true);
+      const config = await configOf({ e2ee });
+      expect(config?.encodedInsertableStreams).toBe(true);
+    });
+
+    it('leaves the flag off when no manager is attached', async () => {
+      withInsertableStreams(true);
+      const config = await configOf({});
+      expect(config?.encodedInsertableStreams).toBeUndefined();
+    });
+
+    it('leaves the flag off on browsers without Insertable Streams', async () => {
+      withInsertableStreams(false);
+      const config = await configOf({ e2ee });
+      expect(config?.encodedInsertableStreams).toBeUndefined();
+    });
+  });
+
   describe('Event Handling', () => {
     it('handles changePublishQuality events', () => {
       publisher['changePublishQuality'] = vi.fn();

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

@@ -17,6 +17,7 @@ import { NegotiationError } from '../NegotiationError';
 import { ReconnectReason } from '../types';
 import { IceTrickleBuffer } from '../IceTrickleBuffer';
 import { StreamClient } from '../../coordinator/connection/client';
+import { fromPartial } from '@total-typescript/shoehorn';
 
 vi.mock('../../StreamSfuClient', () => {
   console.log('MOCKING StreamSfuClient');
@@ -446,6 +447,65 @@ describe('Subscriber', () => {
   });
 
   describe('OnTrack', () => {
+    const audioStreamNamed = (trackLookupPrefix: string) => {
+      const stream = new MediaStream();
+      // @ts-expect-error - mock
+      stream.id = `${trackLookupPrefix}:TRACK_TYPE_AUDIO`;
+      return stream;
+    };
+
+    const audioTrack = () => {
+      const track = new MediaStreamTrack();
+      // @ts-expect-error - mock
+      track.kind = 'audio';
+      return track;
+    };
+
+    it('replaces the local capture stream with the echoed one, leaving the capture tracks live', () => {
+      const captureTrack = audioTrack();
+      const captureStream = new MediaStream();
+      captureStream.getTracks = () => [captureTrack];
+      const echoedStream = audioStreamNamed('self-lookup');
+      // @ts-expect-error - incomplete mock
+      state.updateOrAddParticipant('self-session', {
+        sessionId: 'self-session',
+        trackLookupPrefix: 'self-lookup',
+        isLocalParticipant: true,
+        audioStream: captureStream,
+      });
+
+      const onTrack = subscriber['handleOnTrack'];
+      // @ts-expect-error - incomplete mock
+      onTrack({ streams: [echoedStream], track: audioTrack() });
+
+      const participant = state.participants.find(
+        (p) => p.sessionId === 'self-session',
+      );
+      expect(participant?.audioStream).toBe(echoedStream);
+      // the device manager owns the capture stream and is still publishing it
+      expect(captureTrack.stop).not.toHaveBeenCalled();
+      expect(captureStream.removeTrack).not.toHaveBeenCalled();
+    });
+
+    it('reports streams it received as self-subscribed, and capture streams as not', () => {
+      const echoedStream = audioStreamNamed('self-lookup');
+      const captureStream = new MediaStream();
+      // @ts-expect-error - incomplete mock
+      state.updateOrAddParticipant('self-session', {
+        sessionId: 'self-session',
+        trackLookupPrefix: 'self-lookup',
+        isLocalParticipant: true,
+      });
+
+      const onTrack = subscriber['handleOnTrack'];
+      // @ts-expect-error - incomplete mock
+      onTrack({ streams: [echoedStream], track: audioTrack() });
+
+      expect(subscriber.isSelfSubscribedStream(echoedStream)).toBe(true);
+      expect(subscriber.isSelfSubscribedStream(captureStream)).toBe(false);
+      expect(subscriber.isSelfSubscribedStream(undefined)).toBe(false);
+    });
+
     it('should add unknown tracks to the to the call state', () => {
       const mediaStream = new MediaStream();
       const mediaStreamTrack = new MediaStreamTrack();
@@ -522,6 +582,94 @@ describe('Subscriber', () => {
       expect(baseTrack.stop).toHaveBeenCalled();
       expect(baseStream.removeTrack).toHaveBeenCalledWith(baseTrack);
     });
+
+    it('should store receiver in orphaned track when E2EE is enabled', () => {
+      const e2eeMock = {
+        encrypt: vi.fn(),
+        decrypt: vi.fn(),
+      };
+      subscriber.dispose();
+      const e2eeState = new CallState();
+      subscriber = new Subscriber({
+        sfuClient,
+        dispatcher,
+        state: e2eeState,
+        connectionConfig: { iceServers: [] },
+        tag: 'test',
+        enableTracing: true,
+        e2ee: e2eeMock,
+      });
+
+      const mediaStream = new MediaStream();
+      const mediaStreamTrack = new MediaStreamTrack();
+      const receiver = {};
+      // @ts-expect-error - mock
+      mediaStream.id = 'orphan-prefix:TRACK_TYPE_VIDEO';
+
+      const registerOrphanedTrackSpy = vi.spyOn(
+        e2eeState,
+        'registerOrphanedTrack',
+      );
+      const onTrack = subscriber['handleOnTrack'];
+      // @ts-expect-error - incomplete mock
+      onTrack({ streams: [mediaStream], track: mediaStreamTrack, receiver });
+
+      // Decrypt is NOT called immediately for orphaned tracks
+      expect(e2eeMock.decrypt).not.toHaveBeenCalled();
+      // Receiver is stored with the orphaned track for later reconciliation
+      expect(registerOrphanedTrackSpy).toHaveBeenCalledWith({
+        id: mediaStream.id,
+        trackLookupPrefix: 'orphan-prefix',
+        track: mediaStream,
+        trackType: TrackType.VIDEO,
+        receiver,
+      });
+    });
+
+    it('should decrypt with userId when participant is found', () => {
+      const e2eeMock = {
+        encrypt: vi.fn(),
+        decrypt: vi.fn(),
+      };
+      subscriber.dispose();
+      const e2eeState = new CallState();
+      subscriber = new Subscriber({
+        sfuClient,
+        dispatcher,
+        state: e2eeState,
+        connectionConfig: { iceServers: [] },
+        tag: 'test',
+        enableTracing: true,
+        e2ee: e2eeMock,
+      });
+
+      // Register a participant whose trackLookupPrefix matches the stream
+      e2eeState.updateOrAddParticipant(
+        'session-id',
+        fromPartial({
+          sessionId: 'session-id',
+          userId: 'real-user-id',
+          trackLookupPrefix: '123',
+        }),
+      );
+
+      const mediaStream = new MediaStream();
+      const mediaStreamTrack = new MediaStreamTrack();
+      const receiver = {};
+      // @ts-expect-error - mock
+      mediaStream.id = '123:TRACK_TYPE_VIDEO';
+
+      const onTrack = subscriber['handleOnTrack'];
+      // @ts-expect-error - incomplete mock
+      onTrack({ streams: [mediaStream], track: mediaStreamTrack, receiver });
+
+      // Uses the participant's userId (not trackLookupPrefix) for key lookup
+      expect(e2eeMock.decrypt).toHaveBeenCalledWith(
+        receiver,
+        'real-user-id',
+        'VIDEO',
+      );
+    });
   });
 
   describe('interruptedTracks', () => {
@@ -594,6 +742,48 @@ describe('Subscriber', () => {
       expect(interruptedFor('session-id')).toEqual([]);
     });
 
+    it('leaves the local participant alone on a self-sub track', () => {
+      const mediaStream = new MediaStream();
+      const track = new MediaStreamTrack();
+      // @ts-expect-error - mock
+      mediaStream.id = 'self-lookup:TRACK_TYPE_AUDIO';
+      // @ts-expect-error - mock
+      track.kind = 'audio';
+      Object.defineProperty(track, 'muted', {
+        configurable: true,
+        get: () => true,
+      });
+      // @ts-expect-error - incomplete mock
+      state.updateOrAddParticipant('self-session', {
+        sessionId: 'self-session',
+        trackLookupPrefix: 'self-lookup',
+        isLocalParticipant: true,
+        interruptedTracks: [],
+      });
+
+      const onTrack = subscriber['handleOnTrack'];
+      // @ts-expect-error - incomplete mock
+      onTrack({ streams: [mediaStream], track });
+
+      expect(interruptedFor('self-session')).toEqual([]);
+
+      const handlers: Record<string, () => void> = {};
+      for (const [event, handler] of (
+        track.addEventListener as ReturnType<typeof vi.fn>
+      ).mock.calls) {
+        handlers[event] = handler as () => void;
+      }
+
+      handlers['mute']();
+      expect(interruptedFor('self-session')).toEqual([]);
+
+      state.updateParticipant('self-session', {
+        interruptedTracks: [TrackType.AUDIO],
+      });
+      handlers['unmute']();
+      expect(interruptedFor('self-session')).toEqual([TrackType.AUDIO]);
+    });
+
     it('ignores non-audio remote tracks to avoid Dynascale false positives', () => {
       // Remote video track.muted is dominated by viewport-driven
       // SFU unsubscriptions, so we deliberately only track audio