temp fix

Author: MiloszFilimowski

packages/webrtc-client/src/tracks/Remote.ts

@@ -44,6 +44,9 @@ export class Remote {
     return remoteTrack;
   };
 
+  public getTrackByMidOrNull = (mid: string): RemoteTrack | null =>
+    Object.values(this.remoteTracks).find((remote) => remote.mLineId === mid) ?? null;
+
   public addTracks = (endpointId: EndpointId, tracks: Record<TrackId, MediaEvent_Track>) => {
     const endpoint: EndpointWithTrackContext | undefined = this.remoteEndpoints[endpointId];
 
@@ -72,10 +75,18 @@ export class Remote {
 
   private removeRemoteTrack = (trackId: TrackId) => {
     const remoteTrack = this.remoteTracks[trackId];
-    if (!remoteTrack) throw new Error(`Track ${trackId} not found`);
+    if (!remoteTrack) {
+      console.warn(`Track ${trackId} not found, skipping remove`);
+      return;
+    }
 
     const remoteEndpoint = this.remoteEndpoints[remoteTrack.trackContext.endpoint.id];
-    if (!remoteEndpoint) throw new Error(`Endpoint ${remoteTrack.trackContext.endpoint.id} not found`);
+    if (!remoteEndpoint) {
+      console.warn(`Endpoint ${remoteTrack.trackContext.endpoint.id} not found, skipping remove`);
+      delete this.remoteTracks[trackId];
+      this.emit('trackRemoved', remoteTrack.trackContext);
+      return;
+    }
 
     remoteEndpoint.tracks.delete(trackId);
     delete this.remoteTracks[trackId];
@@ -110,7 +121,10 @@ export class Remote {
 
   public updateRemoteEndpoint = (endpointId: string, metadataJson?: MetadataJson) => {
     const endpoint: EndpointWithTrackContext | undefined = this.remoteEndpoints[endpointId];
-    if (!endpoint) throw new Error(`Endpoint ${endpointId} not found`);
+    if (!endpoint) {
+      console.warn(`Endpoint ${endpointId} not found, skipping update`);
+      return;
+    }
 
     endpoint.metadata = metadataJson ? JSON.parse(metadataJson) : undefined;
 
@@ -119,7 +133,10 @@ export class Remote {
 
   public removeRemoteEndpoint = (endpointId: EndpointId) => {
     const endpoint: EndpointWithTrackContext | undefined = this.remoteEndpoints[endpointId];
-    if (!endpoint) throw new Error(`Endpoint ${endpointId} not found`);
+    if (!endpoint) {
+      console.warn(`Endpoint ${endpointId} not found, skipping remove`);
+      return;
+    }
 
     const trackIds = [...endpoint.tracks.values()].map(({ trackId }) => trackId);
 
@@ -131,10 +148,16 @@ export class Remote {
   };
 
   public updateRemoteTrack = (endpointId: string, trackId: string, metadataJson?: MetadataJson) => {
-    if (!this.remoteEndpoints[endpointId]) throw new Error(`Endpoint ${endpointId} not found`);
+    if (!this.remoteEndpoints[endpointId]) {
+      console.warn(`Endpoint ${endpointId} not found, skipping track update`);
+      return;
+    }
 
     const remoteTrack = this.remoteTracks[trackId];
-    if (!remoteTrack) throw new Error(`Track ${trackId} not found`);
+    if (!remoteTrack) {
+      console.warn(`Track ${trackId} not found, skipping update`);
+      return;
+    }
 
     remoteTrack.trackContext.metadata = metadataJson ? JSON.parse(metadataJson) : undefined;
 
@@ -143,7 +166,10 @@ export class Remote {
 
   public disableRemoteTrackEncoding = (trackId: TrackId, encoding: Variant) => {
     const remoteTrack = this.remoteTracks[trackId];
-    if (!remoteTrack) throw new Error(`Track ${trackId} not found`);
+    if (!remoteTrack) {
+      console.warn(`Track ${trackId} not found, skipping disableEncoding`);
+      return;
+    }
 
     remoteTrack.disableTrackEncoding(encoding);
 
@@ -152,7 +178,10 @@ export class Remote {
 
   public enableRemoteTrackEncoding = (trackId: TrackId, encoding: Variant) => {
     const remoteTrack = this.remoteTracks[trackId];
-    if (!remoteTrack) throw new Error(`Track ${trackId} not found`);
+    if (!remoteTrack) {
+      console.warn(`Track ${trackId} not found, skipping enableEncoding`);
+      return;
+    }
 
     remoteTrack.enableTrackEncoding(encoding);
 
@@ -161,7 +190,10 @@ export class Remote {
 
   public setRemoteTrackEncoding = (trackId: TrackId, encoding: Variant, reason?: EncodingReason) => {
     const remoteTrack = this.remoteTracks[trackId];
-    if (!remoteTrack) throw new Error(`Track ${trackId} not found`);
+    if (!remoteTrack) {
+      console.warn(`Track ${trackId} not found, skipping setEncoding`);
+      return;
+    }
 
     remoteTrack.trackContext.encoding = encoding;
     remoteTrack.trackContext.encodingReason = reason;
@@ -171,7 +203,10 @@ export class Remote {
 
   public setRemoteTrackVadStatus = (trackId: TrackId, vadStatus: MediaEvent_VadNotification_Status) => {
     const remoteTrack = this.remoteTracks[trackId];
-    if (!remoteTrack) throw new Error(`Track ${trackId} not found`);
+    if (!remoteTrack) {
+      console.warn(`Track ${trackId} not found, skipping vad status update`);
+      return;
+    }
 
     let nextStatus: VadStatus | null = null;
 
@@ -208,7 +243,10 @@ export class Remote {
 
   public setTargetRemoteTrackEncoding = (trackId: TrackId, variant: Variant) => {
     const remoteTrack = this.remoteTracks[trackId];
-    if (!remoteTrack) throw new Error(`Track ${trackId} not found`);
+    if (!remoteTrack) {
+      console.warn(`Track ${trackId} not found, skipping setTargetEncoding`);
+      return;
+    }
 
     try {
       remoteTrack.setTargetTrackEncoding(variant);

packages/webrtc-client/src/webRTCEndpoint.ts

@@ -55,6 +55,8 @@ export class WebRTCEndpoint extends (EventEmitter as new () => TypedEmitter<Requ
 
   private clearConnectionCallbacks: (() => void) | null = null;
 
+  private pendingRemovals: Array<() => void> = [];
+
   constructor(props: WebRTCEndpointProps = {}) {
     super();
 
@@ -201,11 +203,26 @@ export class WebRTCEndpoint extends (EventEmitter as new () => TypedEmitter<Requ
 
   private onTrackReady = (event: RTCTrackEvent) => {
     const stream = event.streams[0];
-    if (!stream) throw new Error('Cannot find media stream');
+    const mid = event.transceiver.mid ?? null;
 
-    const mid = event.transceiver.mid!;
+    if (!stream) {
+      this.logger.warn('ontrack without a media stream, ignoring', { mid, pcId: this.connectionManager?.pcId });
+      return;
+    }
 
-    const remoteTrack = this.remote.getTrackByMid(mid);
+    if (mid === null) {
+      this.logger.warn('ontrack without a mid, ignoring', { pcId: this.connectionManager?.pcId });
+      return;
+    }
+
+    const remoteTrack = this.remote.getTrackByMidOrNull(mid);
+    if (!remoteTrack) {
+      this.logger.warn('ontrack for unknown mid, likely a removal race', {
+        mid,
+        pcId: this.connectionManager?.pcId,
+      });
+      return;
+    }
 
     remoteTrack.setReady(stream, event.track);
 
@@ -293,10 +310,11 @@ export class WebRTCEndpoint extends (EventEmitter as new () => TypedEmitter<Requ
 
       if (this.getEndpointId() === endpointId) return;
 
-      this.remote.removeTracks(trackIds);
+      this.scheduleRemoval(() => this.remote.removeTracks(trackIds));
     } else if (event.sdpAnswer) {
-      this.localTrackManager.ongoingRenegotiation = false;
       await this.onSdpAnswer(event.sdpAnswer);
+      this.localTrackManager.ongoingRenegotiation = false;
+      this.flushPendingRemovals();
       this.commandsQueue.processNextCommand();
     } else if (event.candidate) {
       await this.onRemoteCandidate(event.candidate);
@@ -316,7 +334,7 @@ export class WebRTCEndpoint extends (EventEmitter as new () => TypedEmitter<Requ
 
       if (this.getEndpointId() === endpointId) return;
 
-      this.remote.removeRemoteEndpoint(endpointId);
+      this.scheduleRemoval(() => this.remote.removeRemoteEndpoint(endpointId));
     } else if (event.endpointUpdated) {
       const { endpointId, metadataJson } = event.endpointUpdated;
       if (this.getEndpointId() === endpointId) return;
@@ -352,6 +370,34 @@ export class WebRTCEndpoint extends (EventEmitter as new () => TypedEmitter<Requ
     }
   };
 
+  private scheduleRemoval = (action: () => void) => {
+    if (this.localTrackManager.ongoingRenegotiation) {
+      this.pendingRemovals.push(action);
+      return;
+    }
+
+    try {
+      action();
+    } catch (err) {
+      this.logger.warn('removal action failed', err);
+    }
+  };
+
+  private flushPendingRemovals = () => {
+    if (this.pendingRemovals.length === 0) return;
+
+    const removals = this.pendingRemovals;
+    this.pendingRemovals = [];
+
+    for (const action of removals) {
+      try {
+        action();
+      } catch (err) {
+        this.logger.warn('deferred removal action failed', err);
+      }
+    }
+  };
+
   private onSdpAnswer = async (data: MediaEvent_SdpAnswer) => {
     // eslint-disable-next-line no-console
     console.log('[DEBUG transceivers] onSdpAnswer', {
@@ -780,6 +826,8 @@ export class WebRTCEndpoint extends (EventEmitter as new () => TypedEmitter<Requ
       this.dataChannelManager?.cleanup();
     }
 
+    this.pendingRemovals = [];
+
     this.connectionManager = undefined;
   };
 

packages/webrtc-client/tests/events/encodingSwitchedEvent.test.ts

@@ -1,4 +1,4 @@
-import { expect, it } from 'vitest';
+import { expect, it, vi } from 'vitest';
 
 import { Variant, WebRTCEndpoint } from '../../src';
 import { serializeServerMediaEvent } from '../../src/mediaEvent';
@@ -32,27 +32,26 @@ it('Change existing track encoding', () => {
   expect(finalTrackEncoding).toBe(Variant.VARIANT_MEDIUM);
 });
 
-it('Changing track encoding when endpoint exist but track does not exist', () => {
+it('Changing track encoding when endpoint exist but track does not exist warns instead of throwing', async () => {
   // Given
   const webRTCEndpoint = new WebRTCEndpoint();
+  const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
 
   setupRoom(webRTCEndpoint, exampleEndpointId, exampleTrackId);
 
   const initialTrackEncoding = webRTCEndpoint.getRemoteTracks()[exampleTrackId]!.encoding;
   expect(initialTrackEncoding).toBe(undefined);
 
   // When
-  expect(() =>
-    webRTCEndpoint.receiveMediaEvent(
-      serializeServerMediaEvent({
-        trackVariantSwitched: createEncodingSwitchedEvent(
-          exampleEndpointId,
-          notExistingTrackId,
-          Variant.VARIANT_MEDIUM,
-        ),
-      }),
-    ),
-  ).rejects.toThrow(`Track ${notExistingTrackId} not found`);
+  await webRTCEndpoint.receiveMediaEvent(
+    serializeServerMediaEvent({
+      trackVariantSwitched: createEncodingSwitchedEvent(exampleEndpointId, notExistingTrackId, Variant.VARIANT_MEDIUM),
+    }),
+  );
+
+  // Then
+  expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining(`Track ${notExistingTrackId} not found`));
+  warnSpy.mockRestore();
 });
 
 it('Changing track encoding when endpoint does not exist but track exist in other endpoint', () => {

packages/webrtc-client/tests/events/endpointRemovedEvent.test.ts

@@ -1,4 +1,4 @@
-import { expect, it } from 'vitest';
+import { expect, it, vi } from 'vitest';
 
 import { WebRTCEndpoint } from '../../src';
 import { serializeServerMediaEvent } from '../../src/mediaEvent';
@@ -12,23 +12,24 @@ import {
 import { mockRTCPeerConnection } from '../mocks';
 import { setupRoom } from '../utils';
 
-it('Remove the endpoint that does not exist', () => {
+it('Remove the endpoint that does not exist warns instead of throwing', async () => {
   // Given
   mockRTCPeerConnection();
   const webRTCEndpoint = new WebRTCEndpoint();
+  const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
 
   webRTCEndpoint.receiveMediaEvent(
     serializeServerMediaEvent({ connected: createConnectedEventWithOneEndpoint(exampleEndpointId) }),
   );
 
   // When
-  expect(() =>
-    webRTCEndpoint.receiveMediaEvent(
-      serializeServerMediaEvent({ endpointRemoved: createEndpointRemoved(notExistingEndpointId) }),
-    ),
-  )
-    // Then
-    .rejects.toThrow(`Endpoint ${notExistingEndpointId} not found`);
+  await webRTCEndpoint.receiveMediaEvent(
+    serializeServerMediaEvent({ endpointRemoved: createEndpointRemoved(notExistingEndpointId) }),
+  );
+
+  // Then
+  expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining(`Endpoint ${notExistingEndpointId} not found`));
+  warnSpy.mockRestore();
 });
 
 it('Remove current peer', () =>
@@ -71,15 +72,16 @@ it('Remove existing endpoint should remove it from remote endpoints', () => {
   expect(Object.values(endpoints).length).toBe(0);
 });
 
-it('Remove existing endpoint should remove all tracks', () => {
+it('Remove existing endpoint should remove all tracks', async () => {
   // Given
   mockRTCPeerConnection();
   const webRTCEndpoint = new WebRTCEndpoint();
 
-  setupRoom(webRTCEndpoint, exampleEndpointId, exampleTrackId);
+  await setupRoom(webRTCEndpoint, exampleEndpointId, exampleTrackId);
+  (webRTCEndpoint as any).localTrackManager.ongoingRenegotiation = false;
 
   // When
-  webRTCEndpoint.receiveMediaEvent(
+  await webRTCEndpoint.receiveMediaEvent(
     serializeServerMediaEvent({ endpointRemoved: createEndpointRemoved(exampleEndpointId) }),
   );
 
@@ -88,22 +90,24 @@ it('Remove existing endpoint should remove all tracks', () => {
   expect(Object.values(tracks).length).toBe(0);
 });
 
-it('Remove existing endpoint should emit trackRemoved event', () =>
-  new Promise((done) => {
-    // Given
-    mockRTCPeerConnection();
-    const webRTCEndpoint = new WebRTCEndpoint();
+it('Remove existing endpoint should emit trackRemoved event', async () => {
+  // Given
+  mockRTCPeerConnection();
+  const webRTCEndpoint = new WebRTCEndpoint();
 
-    setupRoom(webRTCEndpoint, exampleEndpointId, exampleTrackId);
+  await setupRoom(webRTCEndpoint, exampleEndpointId, exampleTrackId);
+  (webRTCEndpoint as any).localTrackManager.ongoingRenegotiation = false;
 
-    webRTCEndpoint.on('trackRemoved', (trackContext) => {
-      // Then
-      expect(trackContext.trackId).toBe(exampleTrackId);
-      done('');
-    });
+  const removed: string[] = [];
+  webRTCEndpoint.on('trackRemoved', (trackContext) => {
+    removed.push(trackContext.trackId);
+  });
 
-    // When
-    webRTCEndpoint.receiveMediaEvent(
-      serializeServerMediaEvent({ endpointRemoved: createEndpointRemoved(exampleEndpointId) }),
-    );
-  }));
+  // When
+  await webRTCEndpoint.receiveMediaEvent(
+    serializeServerMediaEvent({ endpointRemoved: createEndpointRemoved(exampleEndpointId) }),
+  );
+
+  // Then
+  expect(removed).toEqual([exampleTrackId]);
+});