@stream-io/video-client 1.5.0 → 1.6.0-0

package/src/StreamVideoClient.ts

@@ -86,29 +86,30 @@ export class StreamVideoClient {
 
     setLogger(logger, logLevel);
     this.logger = getLogger(['client']);
+    const coordinatorLogger = getLogger(['coordinator']);
 
     if (typeof apiKeyOrArgs === 'string') {
       this.streamClient = new StreamClient(apiKeyOrArgs, {
         persistUserOnConnectionFailure: true,
         ...opts,
         logLevel,
-        logger: this.logger,
+        logger: coordinatorLogger,
       });
     } else {
       this.streamClient = new StreamClient(apiKeyOrArgs.apiKey, {
         persistUserOnConnectionFailure: true,
         ...apiKeyOrArgs.options,
         logLevel,
-        logger: this.logger,
+        logger: coordinatorLogger,
       });
 
       const sdkInfo = getSdkInfo();
       if (sdkInfo) {
+        const sdkName = SdkType[sdkInfo.type].toLowerCase();
+        const sdkVersion = `${sdkInfo.major}.${sdkInfo.minor}.${sdkInfo.patch}`;
+        const userAgent = this.streamClient.getUserAgent();
         this.streamClient.setUserAgent(
-          this.streamClient.getUserAgent() +
-            `-video-${SdkType[sdkInfo.type].toLowerCase()}-sdk-${
-              sdkInfo.major
-            }.${sdkInfo.minor}.${sdkInfo.patch}`,
+          `${userAgent}-video-${sdkName}-sdk-${sdkVersion}`,
         );
       }
     }
@@ -187,10 +188,10 @@ export class StreamVideoClient {
    * @param user the user to connect.
    * @param token a token or a function that returns a token.
    */
-  async connectUser(
+  connectUser = async (
     user: User,
     token?: TokenOrProvider,
-  ): Promise<void | ConnectedEvent> {
+  ): Promise<void | ConnectedEvent> => {
     if (user.type === 'anonymous') {
       user.id = '!anon';
       return this.connectAnonymousUser(user as UserWithId, token);
@@ -299,7 +300,7 @@ export class StreamVideoClient {
     );
 
     return connectUserResponse;
-  }
+  };
 
   /**
    * Disconnects the currently connected user from the client.
@@ -408,7 +409,7 @@ export class StreamVideoClient {
         clientStore: this.writeableStateStore,
       });
       call.state.updateFromCallResponse(c.call);
-      await call.applyDeviceConfig();
+      await call.applyDeviceConfig(false);
       if (data.watch) {
         this.writeableStateStore.registerCall(call);
       }
@@ -473,12 +474,12 @@ export class StreamVideoClient {
    * @param {string} push_provider_name user provided push provider name
    * @param {string} [userID] the user id (defaults to current user)
    */
-  async addVoipDevice(
+  addVoipDevice = async (
     id: string,
     push_provider: string,
     push_provider_name: string,
     userID?: string,
-  ) {
+  ) => {
     return await this.addDevice(
       id,
       push_provider,
@@ -486,7 +487,7 @@ export class StreamVideoClient {
       userID,
       true,
     );
-  }
+  };
 
   /**
    * getDevices - Returns the devices associated with a current user
@@ -520,9 +521,7 @@ export class StreamVideoClient {
   onRingingCall = async (call_cid: string) => {
     // if we find the call and is already ringing, we don't need to create a new call
     // as client would have received the call.ring state because the app had WS alive when receiving push notifications
-    let call = this.readOnlyStateStore.calls.find(
-      (c) => c.cid === call_cid && c.ringing,
-    );
+    let call = this.state.calls.find((c) => c.cid === call_cid && c.ringing);
     if (!call) {
       // if not it means that WS is not alive when receiving the push notifications and we need to fetch the call
       const [callType, callId] = call_cid.split(':');

package/src/coordinator/connection/client.ts

@@ -12,10 +12,12 @@ import { TokenManager } from './token_manager';
 import { WSConnectionFallback } from './connection_fallback';
 import { isErrorResponse, isWSFailure } from './errors';
 import {
+  addConnectionEventListeners,
   isFunction,
   isOnline,
   KnownCodes,
   randomId,
+  removeConnectionEventListeners,
   retryInterval,
   sleep,
 } from './utils';
@@ -131,11 +133,19 @@ export class StreamClient {
       this.options.baseURL || 'https://video.stream-io-api.com/video',
     );
 
-    if (typeof process !== 'undefined' && process.env.STREAM_LOCAL_TEST_RUN) {
+    if (
+      typeof process !== 'undefined' &&
+      'env' in process &&
+      process.env.STREAM_LOCAL_TEST_RUN
+    ) {
       this.setBaseURL('http://localhost:3030/video');
     }
 
-    if (typeof process !== 'undefined' && process.env.STREAM_LOCAL_TEST_HOST) {
+    if (
+      typeof process !== 'undefined' &&
+      'env' in process &&
+      process.env.STREAM_LOCAL_TEST_HOST
+    ) {
       this.setBaseURL(`http://${process.env.STREAM_LOCAL_TEST_HOST}/video`);
     }
 
@@ -265,6 +275,7 @@ export class StreamClient {
     );
 
     try {
+      addConnectionEventListeners(this.updateNetworkConnectionStatus);
       return await this.setUserPromise;
     } catch (err) {
       if (this.persistUserOnConnectionFailure) {
@@ -398,6 +409,7 @@ export class StreamClient {
     this.anonymous = false;
 
     await this.closeConnection(timeout);
+    removeConnectionEventListeners(this.updateNetworkConnectionStatus);
 
     this.tokenManager.reset();
 
@@ -436,6 +448,7 @@ export class StreamClient {
     user: UserWithId,
     tokenOrProvider: TokenOrProvider,
   ) => {
+    addConnectionEventListeners(this.updateNetworkConnectionStatus);
     this.connectionIdPromise = new Promise<string | undefined>(
       (resolve, reject) => {
         this.resolveConnectionId = resolve;
@@ -661,7 +674,6 @@ export class StreamClient {
   };
 
   dispatchEvent = (event: StreamVideoEvent) => {
-    if (!event.received_at) event.received_at = new Date();
     this.logger('debug', `Dispatching event: ${event.type}`, event);
     if (!this.listeners) return;
 
@@ -855,10 +867,15 @@ export class StreamClient {
     });
   };
 
-  /**
-   * creates an abort controller that will be used by the next HTTP Request.
-   */
-  createAbortControllerForNextRequest = () => {
-    return (this.nextRequestAbortController = new AbortController());
+  updateNetworkConnectionStatus = (
+    event: { type: 'online' | 'offline' } | Event,
+  ) => {
+    if (event.type === 'offline') {
+      this.logger('debug', 'device went offline');
+      this.dispatchEvent({ type: 'network.changed', online: false });
+    } else if (event.type === 'online') {
+      this.logger('debug', 'device went online');
+      this.dispatchEvent({ type: 'network.changed', online: true });
+    }
   };
 }

package/src/coordinator/connection/connection.ts

@@ -578,6 +578,7 @@ export class StableWSConnection {
     }
 
     if (data) {
+      data.received_at = new Date();
       this.client.dispatchEvent(data);
     }
     this.scheduleConnectionCheck();

package/src/coordinator/connection/types.ts

@@ -52,6 +52,11 @@ export type ConnectionChangedEvent = {
   online: boolean;
 };
 
+export type NetworkChangedEvent = {
+  type: 'network.changed';
+  online: boolean;
+};
+
 export type TransportChangedEvent = {
   type: 'transport.changed';
   mode: 'longpoll';
@@ -63,6 +68,7 @@ export type ConnectionRecoveredEvent = {
 
 export type StreamVideoEvent = (
   | WSEvent
+  | NetworkChangedEvent
   | ConnectionChangedEvent
   | TransportChangedEvent
   | ConnectionRecoveredEvent

package/src/devices/CameraManager.ts

@@ -61,7 +61,7 @@ export class CameraManager extends InputMediaDeviceManager<CameraManagerState> {
         this.logger('warn', 'could not apply target resolution', error);
       }
     }
-    if (this.state.status === 'enabled') {
+    if (this.enabled) {
       const { width, height } = this.state
         .mediaStream!.getVideoTracks()[0]
         ?.getSettings();

package/src/devices/InputMediaDeviceManager.ts

@@ -63,6 +63,13 @@ export abstract class InputMediaDeviceManager<
     return this.getDevices();
   }
 
+  /**
+   * Returns `true` when this device is in enabled state.
+   */
+  get enabled() {
+    return this.state.status === 'enabled';
+  }
+
   /**
    * Starts stream.
    */
@@ -216,7 +223,7 @@ export abstract class InputMediaDeviceManager<
   };
 
   protected async applySettingsToStream() {
-    if (this.state.status === 'enabled') {
+    if (this.enabled) {
       await this.muteStream();
       await this.unmuteStream();
     }
@@ -374,7 +381,7 @@ export abstract class InputMediaDeviceManager<
             .then(chainWith(parent), (error) => {
               this.logger(
                 'warn',
-                'Fitler failed to start and will be ignored',
+                'Filter failed to start and will be ignored',
                 error,
               );
               return parent;
@@ -384,13 +391,15 @@ export abstract class InputMediaDeviceManager<
     }
     if (this.call.state.callingState === CallingState.JOINED) {
       await this.publishStream(stream);
+    } else {
+      this.logger('debug', 'Stream is not published as the call is not joined');
     }
     if (this.state.mediaStream !== stream) {
       this.state.setMediaStream(stream, await rootStream);
       this.getTracks().forEach((track) => {
         track.addEventListener('ended', async () => {
           await this.statusChangeSettled();
-          if (this.state.status === 'enabled') {
+          if (this.enabled) {
             this.isTrackStoppedDueToTrackEnd = true;
             setTimeout(() => {
               this.isTrackStoppedDueToTrackEnd = false;

package/src/devices/MicrophoneManager.ts

@@ -25,7 +25,7 @@ export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManager
   private noiseCancellation: INoiseCancellation | undefined;
   private noiseCancellationChangeUnsubscribe: (() => void) | undefined;
   private noiseCancellationRegistration?: Promise<void>;
-  private uregisterNoiseCancellation?: () => Promise<void>;
+  private unregisterNoiseCancellation?: () => Promise<void>;
 
   constructor(
     call: Call,
@@ -144,7 +144,7 @@ export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManager
         noiseCancellation.toFilter(),
       );
       this.noiseCancellationRegistration = registrationResult.registered;
-      this.uregisterNoiseCancellation = registrationResult.unregister;
+      this.unregisterNoiseCancellation = registrationResult.unregister;
       await this.noiseCancellationRegistration;
 
       // handles an edge case where a noise cancellation is enabled after
@@ -173,7 +173,7 @@ export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManager
     if (isReactNative()) {
       throw new Error('Noise cancellation is not supported in React Native');
     }
-    await (this.uregisterNoiseCancellation?.() ?? Promise.resolve())
+    await (this.unregisterNoiseCancellation?.() ?? Promise.resolve())
       .then(() => this.noiseCancellation?.disable())
       .then(() => this.noiseCancellationChangeUnsubscribe?.())
       .catch((err) => {

package/src/devices/devices.ts

@@ -16,7 +16,7 @@ import { lazy } from '../helpers/lazy';
  * Returns an Observable that emits the list of available devices
  * that meet the given constraints.
  *
- * @param constraints the constraints to use when requesting the devices.
+ * @param permission a BrowserPermission instance.
  * @param kind the kind of devices to enumerate.
  */
 const getDevices = (permission: BrowserPermission, kind: MediaDeviceKind) => {

package/src/events/__tests__/mutes.test.ts

@@ -28,9 +28,9 @@ describe('mutes', () => {
       // @ts-expect-error partial data
       call.publisher.isPublishing = vi.fn().mockReturnValue(true);
 
-      vi.spyOn(call, 'stopPublish').mockResolvedValue(undefined);
       vi.spyOn(call.camera, 'disable').mockResolvedValue(undefined);
       vi.spyOn(call.microphone, 'disable').mockResolvedValue(undefined);
+      vi.spyOn(call.screenShare, 'disable').mockResolvedValue(undefined);
 
       // @ts-ignore
       call.on = (event: string, h) => {
@@ -56,41 +56,38 @@ describe('mutes', () => {
       });
     });
 
-    it('should automatically mute only when cause is moderation', async () => {
-      await handler!({
+    it('should automatically mute only when cause is moderation', () => {
+      handler!({
         cause: TrackUnpublishReason.PERMISSION_REVOKED,
         type: TrackType.VIDEO,
         sessionId: 'session-id',
         userId: 'user-id',
       });
       expect(call.camera.disable).not.toHaveBeenCalled();
-      expect(call.stopPublish).not.toHaveBeenCalledWith(TrackType.VIDEO);
     });
 
-    it('should handle remote soft video mute', async () => {
-      await handler!({
+    it('should handle remote soft video mute', () => {
+      handler!({
         cause: TrackUnpublishReason.MODERATION,
         type: TrackType.VIDEO,
         sessionId: 'session-id',
         userId: 'user-id',
       });
       expect(call.camera.disable).toHaveBeenCalled();
-      expect(call.stopPublish).toHaveBeenCalledWith(TrackType.VIDEO);
     });
 
-    it('should handle remote soft audio mute', async () => {
-      await handler!({
+    it('should handle remote soft audio mute', () => {
+      handler!({
         cause: TrackUnpublishReason.MODERATION,
         type: TrackType.AUDIO,
         sessionId: 'session-id',
         userId: 'user-id',
       });
       expect(call.microphone.disable).toHaveBeenCalled();
-      expect(call.stopPublish).toHaveBeenCalledWith(TrackType.AUDIO);
     });
 
-    it('should handle remote soft screenshare mute', async () => {
-      await handler!({
+    it('should handle remote soft screenshare mute', () => {
+      handler!({
         cause: TrackUnpublishReason.MODERATION,
         type: TrackType.SCREEN_SHARE,
         sessionId: 'session-id',
@@ -98,7 +95,7 @@ describe('mutes', () => {
       });
       expect(call.camera.disable).not.toHaveBeenCalled();
       expect(call.microphone.disable).not.toHaveBeenCalled();
-      expect(call.stopPublish).toHaveBeenCalledWith(TrackType.SCREEN_SHARE);
+      expect(call.screenShare.disable).toHaveBeenCalled();
     });
   });
 });

package/src/events/__tests__/participant.test.ts

@@ -1,3 +1,4 @@
+import '../../rtc/__tests__/mocks/webrtc.mocks';
 import { describe, expect, it } from 'vitest';
 import { CallState } from '../../store';
 import { VisibilityState } from '../../types';
@@ -75,6 +76,80 @@ describe('Participant events', () => {
     });
   });
 
+  describe('orphaned tracks reconciliation', () => {
+    it('participantJoined should reconcile orphaned tracks if any', () => {
+      const state = new CallState();
+      const mediaStream = new MediaStream();
+      state.registerOrphanedTrack({
+        trackLookupPrefix: 'track-lookup-prefix',
+        trackType: TrackType.VIDEO,
+        track: mediaStream,
+      });
+      const onParticipantJoined = watchParticipantJoined(state);
+      onParticipantJoined({
+        // @ts-expect-error incomplete data
+        participant: {
+          userId: 'user-id',
+          sessionId: 'session-id',
+          trackLookupPrefix: 'track-lookup-prefix',
+        },
+      });
+
+      const p = state.findParticipantBySessionId('session-id');
+      expect(p).toBeDefined();
+      expect(p?.videoStream).toBe(mediaStream);
+      expect(state.takeOrphanedTracks('track-lookup-prefix')).toHaveLength(0);
+    });
+
+    it('trackPublished should reconcile orphaned tracks if any', () => {
+      const state = new CallState();
+      const mediaStream = new MediaStream();
+      state.registerOrphanedTrack({
+        trackLookupPrefix: 'track-lookup-prefix',
+        trackType: TrackType.AUDIO,
+        track: mediaStream,
+      });
+      const onTrackPublished = watchTrackPublished(state);
+      onTrackPublished({
+        // @ts-expect-error incomplete data
+        participant: {
+          userId: 'user-id',
+          sessionId: 'session-id',
+          trackLookupPrefix: 'track-lookup-prefix',
+        },
+      });
+
+      const p = state.findParticipantBySessionId('session-id');
+      expect(p).toBeDefined();
+      expect(p?.audioStream).toBe(mediaStream);
+      expect(state.takeOrphanedTracks('track-lookup-prefix')).toHaveLength(0);
+    });
+
+    it('trackUnpublished should reconcile orphaned tracks if any', () => {
+      const state = new CallState();
+      const mediaStream = new MediaStream();
+      state.registerOrphanedTrack({
+        trackLookupPrefix: 'track-lookup-prefix',
+        trackType: TrackType.SCREEN_SHARE,
+        track: mediaStream,
+      });
+      const onTrackUnPublished = watchTrackUnpublished(state);
+      onTrackUnPublished({
+        // @ts-expect-error incomplete data
+        participant: {
+          userId: 'user-id',
+          sessionId: 'session-id',
+          trackLookupPrefix: 'track-lookup-prefix',
+        },
+      });
+
+      const p = state.findParticipantBySessionId('session-id');
+      expect(p).toBeDefined();
+      expect(p?.screenShareStream).toBe(mediaStream);
+      expect(state.takeOrphanedTracks('track-lookup-prefix')).toHaveLength(0);
+    });
+  });
+
   describe('trackPublished', () => {
     it('updates the participant track list', () => {
       const state = new CallState();

package/src/events/callEventHandlers.ts

@@ -1,6 +1,5 @@
 import { Call } from '../Call';
 import { Dispatcher } from '../rtc';
-import { CallState } from '../store';
 import {
   handleRemoteSoftMute,
   watchAudioLevelChanged,
@@ -17,6 +16,7 @@ import {
   watchParticipantLeft,
   watchParticipantUpdated,
   watchPinsUpdated,
+  watchSfuCallEnded,
   watchSfuErrorReports,
   watchTrackPublished,
   watchTrackUnpublished,
@@ -36,16 +36,13 @@ type RingCallEvents = Extract<
  * Registers the default event handlers for a call during its lifecycle.
  *
  * @param call the call to register event handlers for.
- * @param state the call state.
  * @param dispatcher the dispatcher.
  */
-export const registerEventHandlers = (
-  call: Call,
-  state: CallState,
-  dispatcher: Dispatcher,
-) => {
+export const registerEventHandlers = (call: Call, dispatcher: Dispatcher) => {
+  const state = call.state;
   const eventHandlers = [
     call.on('call.ended', watchCallEnded(call)),
+    watchSfuCallEnded(call),
 
     watchLiveEnded(dispatcher, call),
     watchSfuErrorReports(dispatcher),

package/src/events/internal.ts

@@ -3,8 +3,12 @@ import { Call } from '../Call';
 import { CallState } from '../store';
 import { StreamVideoParticipantPatches } from '../types';
 import { getLogger } from '../logger';
-import type { PinsChanged } from '../gen/video/sfu/event/events';
-import { ErrorCode } from '../gen/video/sfu/models/models';
+import type { CallEnded, PinsChanged } from '../gen/video/sfu/event/events';
+import {
+  CallEndedReason,
+  ErrorCode,
+  WebsocketReconnectStrategy,
+} from '../gen/video/sfu/models/models';
 import { OwnCapability } from '../gen/coordinator';
 
 const logger = getLogger(['events']);
@@ -82,9 +86,10 @@ export const watchLiveEnded = (dispatcher: Dispatcher, call: Call) => {
 export const watchSfuErrorReports = (dispatcher: Dispatcher) => {
   return dispatcher.on('error', (e) => {
     if (!e.error) return;
-    const { error } = e;
+    const { error, reconnectStrategy } = e;
     logger('error', 'SFU reported error', {
       code: ErrorCode[error.code],
+      reconnectStrategy: WebsocketReconnectStrategy[reconnectStrategy],
       message: error.message,
       shouldRetry: error.shouldRetry,
     });
@@ -101,3 +106,15 @@ export const watchPinsUpdated = (state: CallState) => {
     state.setServerSidePins(pins);
   };
 };
+
+/**
+ * Watches for `callEnded` events.
+ */
+export const watchSfuCallEnded = (call: Call) => {
+  return call.on('callEnded', (e: CallEnded) => {
+    const reason = CallEndedReason[e.reason];
+    call.leave({ reason }).catch((err) => {
+      logger('error', 'Failed to leave call after call ended by the SFU', err);
+    });
+  });
+};

package/src/events/mutes.ts

@@ -27,6 +27,11 @@ export const handleRemoteSoftMute = (call: Call) => {
           await call.camera.disable();
         } else if (type === TrackType.AUDIO) {
           await call.microphone.disable();
+        } else if (
+          type === TrackType.SCREEN_SHARE ||
+          type === TrackType.SCREEN_SHARE_AUDIO
+        ) {
+          await call.screenShare.disable();
         } else {
           logger(
             'warn',
@@ -34,9 +39,6 @@ export const handleRemoteSoftMute = (call: Call) => {
             TrackType[type],
           );
         }
-        if (call.publisher?.isPublishing(type)) {
-          await call.stopPublish(type);
-        }
       } catch (error) {
         logger('error', 'Failed to stop publishing', error);
       }

package/src/events/participant.ts

@@ -5,8 +5,14 @@ import type {
   TrackPublished,
   TrackUnpublished,
 } from '../gen/video/sfu/event/events';
-import { StreamVideoParticipant, VisibilityState } from '../types';
+import type { Participant } from '../gen/video/sfu/models/models';
+import {
+  StreamVideoParticipant,
+  StreamVideoParticipantPatch,
+  VisibilityState,
+} from '../types';
 import { CallState } from '../store';
+import { trackTypeToParticipantStreamKey } from '../rtc/helpers/tracks';
 
 /**
  * An event responder which handles the `participantJoined` event.
@@ -19,21 +25,23 @@ export const watchParticipantJoined = (state: CallState) => {
     // potential duplicate events from the SFU.
     //
     // Although the SFU should not send duplicate events, we have seen
-    // some race conditions in the past during the `join-flow` where
-    // the SFU would send participant info as part of the `join`
+    // some race conditions in the past during the `join-flow`.
+    // The SFU would send participant info as part of the `join`
     // response and then follow up with a `participantJoined` event for
     // already announced participants.
+    const orphanedTracks = reconcileOrphanedTracks(state, participant);
     state.updateOrAddParticipant(
       participant.sessionId,
-      Object.assign<StreamVideoParticipant, Partial<StreamVideoParticipant>>(
-        participant,
-        {
-          viewportVisibilityState: {
-            videoTrack: VisibilityState.UNKNOWN,
-            screenShareTrack: VisibilityState.UNKNOWN,
-          },
+      Object.assign<
+        StreamVideoParticipant,
+        StreamVideoParticipantPatch | undefined,
+        Partial<StreamVideoParticipant>
+      >(participant, orphanedTracks, {
+        viewportVisibilityState: {
+          videoTrack: VisibilityState.UNKNOWN,
+          screenShareTrack: VisibilityState.UNKNOWN,
         },
-      ),
+      }),
     );
   };
 };
@@ -69,12 +77,14 @@ export const watchParticipantUpdated = (state: CallState) => {
  */
 export const watchTrackPublished = (state: CallState) => {
   return function onTrackPublished(e: TrackPublished) {
-    const { type, sessionId, participant } = e;
+    const { type, sessionId } = e;
     // An optimization for large calls.
     // After a certain threshold, the SFU would stop emitting `participantJoined`
     // events, and instead, it would only provide the participant's information
     // once they start publishing a track.
-    if (participant) {
+    if (e.participant) {
+      const orphanedTracks = reconcileOrphanedTracks(state, e.participant);
+      const participant = Object.assign(e.participant, orphanedTracks);
       state.updateOrAddParticipant(sessionId, participant);
     } else {
       state.updateParticipant(sessionId, (p) => ({
@@ -90,9 +100,11 @@ export const watchTrackPublished = (state: CallState) => {
  */
 export const watchTrackUnpublished = (state: CallState) => {
   return function onTrackUnpublished(e: TrackUnpublished) {
-    const { type, sessionId, participant } = e;
+    const { type, sessionId } = e;
     // An optimization for large calls. See `watchTrackPublished`.
-    if (participant) {
+    if (e.participant) {
+      const orphanedTracks = reconcileOrphanedTracks(state, e.participant);
+      const participant = Object.assign(e.participant, orphanedTracks);
       state.updateOrAddParticipant(sessionId, participant);
     } else {
       state.updateParticipant(sessionId, (p) => ({
@@ -103,3 +115,24 @@ export const watchTrackUnpublished = (state: CallState) => {
 };
 
 const unique = <T>(v: T, i: number, arr: T[]) => arr.indexOf(v) === i;
+
+/**
+ * Reconciles orphaned tracks (if any) for the given participant.
+ *
+ * @param state the call state.
+ * @param participant the participant.
+ */
+const reconcileOrphanedTracks = (
+  state: CallState,
+  participant: Participant,
+): StreamVideoParticipantPatch | undefined => {
+  const orphanTracks = state.takeOrphanedTracks(participant.trackLookupPrefix);
+  if (!orphanTracks.length) return;
+  const reconciledTracks: StreamVideoParticipantPatch = {};
+  for (const orphan of orphanTracks) {
+    const key = trackTypeToParticipantStreamKey(orphan.trackType);
+    if (!key) continue;
+    reconciledTracks[key] = orphan.track;
+  }
+  return reconciledTracks;
+};