livekit-client 1.2.2 → 1.2.5

package/src/room/Room.ts

@@ -99,8 +99,12 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   /** used for aborting pending connections to a LiveKit server */
   private abortController?: AbortController;
 
+  /** future holding client initiated connection attempt */
   private connectFuture?: Future<void>;
 
+  /** future holding sdk initiated reconnection attempt */
+  private reconnectFuture?: Future<void>;
+
   /**
    * Creates a new Room, the primary construct for a LiveKit session.
    * @param options
@@ -134,9 +138,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       return;
     }
 
-    this.engine = new RTCEngine();
+    this.engine = new RTCEngine(this.options);
 
-    this.engine.client.signalLatency = this.options.expSignalLatency;
     this.engine.client.onParticipantUpdate = this.handleParticipantUpdates;
     this.engine.client.onRoomUpdate = this.handleRoomUpdate;
     this.engine.client.onSpeakersChanged = this.handleSpeakersChanged;
@@ -157,12 +160,17 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       .on(EngineEvent.ActiveSpeakersUpdate, this.handleActiveSpeakersUpdate)
       .on(EngineEvent.DataPacketReceived, this.handleDataPacket)
       .on(EngineEvent.Resuming, () => {
+        if (!this.reconnectFuture) {
+          this.reconnectFuture = new Future();
+        }
         if (this.setAndEmitConnectionState(ConnectionState.Reconnecting)) {
           this.emit(RoomEvent.Reconnecting);
         }
       })
       .on(EngineEvent.Resumed, () => {
         this.setAndEmitConnectionState(ConnectionState.Connected);
+        this.reconnectFuture?.resolve();
+        this.reconnectFuture = undefined;
         this.emit(RoomEvent.Reconnected);
         this.updateSubscriptions();
       })
@@ -194,165 +202,145 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     return DeviceManager.getInstance().getDevices(kind, requestPermissions);
   }
 
-  connect = async (url: string, token: string, opts?: RoomConnectOptions): Promise<void> => {
+  connect = (url: string, token: string, opts?: RoomConnectOptions): Promise<void> => {
     if (this.state === ConnectionState.Connected) {
       // when the state is reconnecting or connected, this function returns immediately
       log.warn(`already connected to room ${this.name}`);
-      return;
+      return Promise.resolve();
     }
 
     if (this.connectFuture) {
       return this.connectFuture.promise;
+    } else if (this.reconnectFuture) {
+      this.connectFuture = this.reconnectFuture;
+      return this.connectFuture.promise;
     }
-    this.setAndEmitConnectionState(ConnectionState.Connecting);
-
-    if (!this.abortController || this.abortController.signal.aborted) {
-      this.abortController = new AbortController();
-    }
-
-    // recreate engine if previously disconnected
-    this.createEngine();
-
-    this.acquireAudioContext();
-
-    if (opts?.rtcConfig) {
-      this.engine.rtcConfig = opts.rtcConfig;
-    }
-
-    this.connOptions = opts;
+    const connectPromise = new Promise<void>(async (resolve, reject) => {
+      this.setAndEmitConnectionState(ConnectionState.Connecting);
+      if (!this.abortController || this.abortController.signal.aborted) {
+        this.abortController = new AbortController();
+      }
 
-    try {
-      const joinResponse = await this.engine.join(
-        url,
-        token,
-        {
-          autoSubscribe: opts?.autoSubscribe,
-          publishOnly: opts?.publishOnly,
-          adaptiveStream:
-            typeof this.options?.adaptiveStream === 'object' ? true : this.options?.adaptiveStream,
-        },
-        this.abortController.signal,
-      );
-      log.debug(
-        `connected to Livekit Server version: ${joinResponse.serverVersion}, region: ${joinResponse.serverRegion}`,
-      );
+      // recreate engine if previously disconnected
+      this.createEngine();
 
-      if (!joinResponse.serverVersion) {
-        throw new UnsupportedServer('unknown server version');
-      }
+      this.acquireAudioContext();
 
-      if (joinResponse.serverVersion === '0.15.1' && this.options.dynacast) {
-        log.debug('disabling dynacast due to server version');
-        // dynacast has a bug in 0.15.1, so we cannot use it then
-        this.options.dynacast = false;
+      if (opts?.rtcConfig) {
+        this.engine.rtcConfig = opts.rtcConfig;
       }
 
-      const pi = joinResponse.participant!;
-
-      this.localParticipant.sid = pi.sid;
-      this.localParticipant.identity = pi.identity;
-
-      this.localParticipant.updateInfo(pi);
-      // forward metadata changed for the local participant
-      this.localParticipant
-        .on(ParticipantEvent.ParticipantMetadataChanged, (metadata: string | undefined) => {
-          this.emit(RoomEvent.ParticipantMetadataChanged, metadata, this.localParticipant);
-        })
-        .on(ParticipantEvent.TrackMuted, (pub: TrackPublication) => {
-          this.emit(RoomEvent.TrackMuted, pub, this.localParticipant);
-        })
-        .on(ParticipantEvent.TrackUnmuted, (pub: TrackPublication) => {
-          this.emit(RoomEvent.TrackUnmuted, pub, this.localParticipant);
-        })
-        .on(ParticipantEvent.LocalTrackPublished, (pub: LocalTrackPublication) => {
-          this.emit(RoomEvent.LocalTrackPublished, pub, this.localParticipant);
-        })
-        .on(ParticipantEvent.LocalTrackUnpublished, (pub: LocalTrackPublication) => {
-          this.emit(RoomEvent.LocalTrackUnpublished, pub, this.localParticipant);
-        })
-        .on(ParticipantEvent.ConnectionQualityChanged, (quality: ConnectionQuality) => {
-          this.emit(RoomEvent.ConnectionQualityChanged, quality, this.localParticipant);
-        })
-        .on(ParticipantEvent.MediaDevicesError, (e: Error) => {
-          this.emit(RoomEvent.MediaDevicesError, e);
-        })
-        .on(
-          ParticipantEvent.ParticipantPermissionsChanged,
-          (prevPermissions: ParticipantPermission) => {
-            this.emit(
-              RoomEvent.ParticipantPermissionsChanged,
-              prevPermissions,
-              this.localParticipant,
-            );
+      this.connOptions = opts;
+
+      try {
+        const joinResponse = await this.engine.join(
+          url,
+          token,
+          {
+            autoSubscribe: opts?.autoSubscribe,
+            publishOnly: opts?.publishOnly,
+            adaptiveStream:
+              typeof this.options?.adaptiveStream === 'object'
+                ? true
+                : this.options?.adaptiveStream,
           },
+          this.abortController.signal,
+        );
+        log.debug(
+          `connected to Livekit Server version: ${joinResponse.serverVersion}, region: ${joinResponse.serverRegion}`,
         );
 
-      // populate remote participants, these should not trigger new events
-      joinResponse.otherParticipants.forEach((info) => {
-        if (
-          info.sid !== this.localParticipant.sid &&
-          info.identity !== this.localParticipant.identity
-        ) {
-          this.getOrCreateParticipant(info.sid, info);
-        } else {
-          log.warn('received info to create local participant as remote participant', {
-            info,
-            localParticipant: this.localParticipant,
-          });
+        if (!joinResponse.serverVersion) {
+          throw new UnsupportedServer('unknown server version');
         }
-      });
 
-      this.name = joinResponse.room!.name;
-      this.sid = joinResponse.room!.sid;
-      this.metadata = joinResponse.room!.metadata;
-      this.emit(RoomEvent.SignalConnected);
-    } catch (err) {
-      this.recreateEngine();
-      this.setAndEmitConnectionState(
-        ConnectionState.Disconnected,
-        new ConnectionError('could not establish signal connection'),
-      );
-      throw err;
-    }
+        if (joinResponse.serverVersion === '0.15.1' && this.options.dynacast) {
+          log.debug('disabling dynacast due to server version');
+          // dynacast has a bug in 0.15.1, so we cannot use it then
+          this.options.dynacast = false;
+        }
 
-    // don't return until ICE connected
-    const connectTimeout = setTimeout(() => {
-      // timeout
-      this.recreateEngine();
-      this.setAndEmitConnectionState(
-        ConnectionState.Disconnected,
-        new ConnectionError('could not connect PeerConnection after timeout'),
-      );
-    }, maxICEConnectTimeout);
-    const abortHandler = () => {
-      log.warn('closing engine');
-      clearTimeout(connectTimeout);
-      this.recreateEngine();
-      this.setAndEmitConnectionState(
-        ConnectionState.Disconnected,
-        new ConnectionError('room connection has been cancelled'),
-      );
-    };
-    if (this.abortController?.signal.aborted) {
-      abortHandler();
-    }
-    this.abortController?.signal.addEventListener('abort', abortHandler);
-
-    this.engine.once(EngineEvent.Connected, () => {
-      clearTimeout(connectTimeout);
-      this.abortController?.signal.removeEventListener('abort', abortHandler);
-      // also hook unload event
-      if (isWeb()) {
-        window.addEventListener('beforeunload', this.onBeforeUnload);
-        navigator.mediaDevices?.addEventListener('devicechange', this.handleDeviceChange);
+        const pi = joinResponse.participant!;
+
+        this.localParticipant.sid = pi.sid;
+        this.localParticipant.identity = pi.identity;
+
+        this.localParticipant.updateInfo(pi);
+        // forward metadata changed for the local participant
+        this.localParticipant
+          .on(ParticipantEvent.ParticipantMetadataChanged, this.onLocalParticipantMetadataChanged)
+          .on(ParticipantEvent.TrackMuted, this.onLocalTrackMuted)
+          .on(ParticipantEvent.TrackUnmuted, this.onLocalTrackUnmuted)
+          .on(ParticipantEvent.LocalTrackPublished, this.onLocalTrackPublished)
+          .on(ParticipantEvent.LocalTrackUnpublished, this.onLocalTrackUnpublished)
+          .on(ParticipantEvent.ConnectionQualityChanged, this.onLocalConnectionQualityChanged)
+          .on(ParticipantEvent.MediaDevicesError, this.onMediaDevicesError)
+          .on(
+            ParticipantEvent.ParticipantPermissionsChanged,
+            this.onLocalParticipantPermissionsChanged,
+          );
+
+        // populate remote participants, these should not trigger new events
+        joinResponse.otherParticipants.forEach((info) => {
+          if (
+            info.sid !== this.localParticipant.sid &&
+            info.identity !== this.localParticipant.identity
+          ) {
+            this.getOrCreateParticipant(info.sid, info);
+          } else {
+            log.warn('received info to create local participant as remote participant', {
+              info,
+              localParticipant: this.localParticipant,
+            });
+          }
+        });
+
+        this.name = joinResponse.room!.name;
+        this.sid = joinResponse.room!.sid;
+        this.metadata = joinResponse.room!.metadata;
+        this.emit(RoomEvent.SignalConnected);
+      } catch (err) {
+        this.recreateEngine();
+        this.handleDisconnect(this.options.stopLocalTrackOnUnpublish);
+        reject(new ConnectionError('could not establish signal connection'));
+      }
+
+      // don't return until ICE connected
+      const connectTimeout = setTimeout(() => {
+        // timeout
+        this.recreateEngine();
+        this.handleDisconnect(this.options.stopLocalTrackOnUnpublish);
+        reject(new ConnectionError('could not connect PeerConnection after timeout'));
+      }, maxICEConnectTimeout);
+      const abortHandler = () => {
+        log.warn('closing engine');
+        clearTimeout(connectTimeout);
+        this.recreateEngine();
+        this.handleDisconnect(this.options.stopLocalTrackOnUnpublish);
+        reject(new ConnectionError('room connection has been cancelled'));
+      };
+      if (this.abortController?.signal.aborted) {
+        abortHandler();
       }
-      this.setAndEmitConnectionState(ConnectionState.Connected);
+      this.abortController?.signal.addEventListener('abort', abortHandler);
+
+      this.engine.once(EngineEvent.Connected, () => {
+        clearTimeout(connectTimeout);
+        this.abortController?.signal.removeEventListener('abort', abortHandler);
+        // also hook unload event
+        if (isWeb()) {
+          window.addEventListener('beforeunload', this.onBeforeUnload);
+          navigator.mediaDevices?.addEventListener('devicechange', this.handleDeviceChange);
+        }
+        this.setAndEmitConnectionState(ConnectionState.Connected);
+        resolve();
+      });
     });
+    this.connectFuture = new Future(connectPromise);
 
-    if (this.connectFuture) {
-      /** @ts-ignore */
-      return this.connectFuture.promise;
-    }
+    this.connectFuture.promise.finally(() => (this.connectFuture = undefined));
+
+    return this.connectFuture.promise;
   };
 
   /**
@@ -360,11 +348,13 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
    */
   disconnect = async (stopTracks = true) => {
     log.info('disconnect from room', { identity: this.localParticipant.identity });
-    if (this.state === ConnectionState.Connecting) {
+    if (this.state === ConnectionState.Connecting || this.state === ConnectionState.Reconnecting) {
       // try aborting pending connection attempt
       log.warn('abort connection attempt');
       this.abortController?.abort();
-      return;
+      // in case the abort controller didn't manage to cancel the connection attempt, reject the connect promise explicitly
+      this.connectFuture?.reject(new ConnectionError('Client initiated disconnect'));
+      this.connectFuture = undefined;
     }
     // send leave
     if (this.engine?.client.isConnected) {
@@ -374,7 +364,6 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     if (this.engine) {
       this.engine.close();
     }
-
     this.handleDisconnect(stopTracks, DisconnectReason.CLIENT_INITIATED);
     /* @ts-ignore */
     this.engine = undefined;
@@ -592,6 +581,9 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   }
 
   private handleRestarting = () => {
+    if (!this.reconnectFuture) {
+      this.reconnectFuture = new Future();
+    }
     // also unwind existing participants & existing subscriptions
     for (const p of this.participants.values()) {
       this.handleParticipantDisconnected(p.sid, p);
@@ -608,6 +600,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     });
     this.setAndEmitConnectionState(ConnectionState.Connected);
     this.emit(RoomEvent.Reconnected);
+    this.reconnectFuture?.resolve();
+    this.reconnectFuture = undefined;
 
     // rehydrate participants
     if (joinResponse.participant) {
@@ -651,12 +645,32 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     if (this.state === ConnectionState.Disconnected) {
       return;
     }
+    // reject potentially ongoing reconnection attempt
+    if (this.connectFuture === this.reconnectFuture) {
+      this.connectFuture?.reject(undefined);
+      this.connectFuture = undefined;
+      this.reconnectFuture = undefined;
+    }
+
     this.participants.forEach((p) => {
       p.tracks.forEach((pub) => {
         p.unpublishTrack(pub.trackSid);
       });
     });
 
+    this.localParticipant
+      .off(ParticipantEvent.ParticipantMetadataChanged, this.onLocalParticipantMetadataChanged)
+      .off(ParticipantEvent.TrackMuted, this.onLocalTrackMuted)
+      .off(ParticipantEvent.TrackUnmuted, this.onLocalTrackUnmuted)
+      .off(ParticipantEvent.LocalTrackPublished, this.onLocalTrackPublished)
+      .off(ParticipantEvent.LocalTrackUnpublished, this.onLocalTrackUnpublished)
+      .off(ParticipantEvent.ConnectionQualityChanged, this.onLocalConnectionQualityChanged)
+      .off(ParticipantEvent.MediaDevicesError, this.onMediaDevicesError)
+      .off(
+        ParticipantEvent.ParticipantPermissionsChanged,
+        this.onLocalParticipantPermissionsChanged,
+      );
+
     this.localParticipant.tracks.forEach((pub) => {
       if (pub.track) {
         this.localParticipant.unpublishTrack(pub.track, shouldStopTracks);
@@ -666,6 +680,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         pub.track?.stop();
       }
     });
+
     this.localParticipant.tracks.clear();
     this.localParticipant.videoTracks.clear();
     this.localParticipant.audioTracks.clear();
@@ -1037,35 +1052,11 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
   }
 
-  private setAndEmitConnectionState(state: ConnectionState, error?: Error): boolean {
+  private setAndEmitConnectionState(state: ConnectionState): boolean {
     if (state === this.state) {
       // unchanged
       return false;
     }
-    switch (state) {
-      case ConnectionState.Connecting:
-      case ConnectionState.Reconnecting:
-        if (!this.connectFuture) {
-          // reuse existing connect future if possible
-          this.connectFuture = new Future<void>();
-        }
-        break;
-      case ConnectionState.Connected:
-        if (this.connectFuture) {
-          this.connectFuture.resolve();
-          this.connectFuture = undefined;
-        }
-        break;
-      case ConnectionState.Disconnected:
-        if (this.connectFuture) {
-          error ??= new Error('disconnected from Room');
-          this.connectFuture.reject(error);
-          this.connectFuture = undefined;
-        }
-        break;
-      default:
-      // nothing
-    }
     this.state = state;
     this.emit(RoomEvent.ConnectionStateChanged, this.state);
     return true;
@@ -1081,6 +1072,38 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     return false;
   }
 
+  private onLocalParticipantMetadataChanged = (metadata: string | undefined) => {
+    this.emit(RoomEvent.ParticipantMetadataChanged, metadata, this.localParticipant);
+  };
+
+  private onLocalTrackMuted = (pub: TrackPublication) => {
+    this.emit(RoomEvent.TrackMuted, pub, this.localParticipant);
+  };
+
+  private onLocalTrackUnmuted = (pub: TrackPublication) => {
+    this.emit(RoomEvent.TrackUnmuted, pub, this.localParticipant);
+  };
+
+  private onLocalTrackPublished = (pub: LocalTrackPublication) => {
+    this.emit(RoomEvent.LocalTrackPublished, pub, this.localParticipant);
+  };
+
+  private onLocalTrackUnpublished = (pub: LocalTrackPublication) => {
+    this.emit(RoomEvent.LocalTrackUnpublished, pub, this.localParticipant);
+  };
+
+  private onLocalConnectionQualityChanged = (quality: ConnectionQuality) => {
+    this.emit(RoomEvent.ConnectionQualityChanged, quality, this.localParticipant);
+  };
+
+  private onMediaDevicesError = (e: Error) => {
+    this.emit(RoomEvent.MediaDevicesError, e);
+  };
+
+  private onLocalParticipantPermissionsChanged = (prevPermissions: ParticipantPermission) => {
+    this.emit(RoomEvent.ParticipantPermissionsChanged, prevPermissions, this.localParticipant);
+  };
+
   // /** @internal */
   emit<E extends keyof RoomEventCallbacks>(
     event: E,

package/src/room/events.ts

@@ -218,8 +218,8 @@ export enum RoomEvent {
    * When we have encountered an error while attempting to create a track.
    * The errors take place in getUserMedia().
    * Use MediaDeviceFailure.getFailure(error) to get the reason of failure.
-   * [[getAudioCreateError]] and [[getVideoCreateError]] will indicate if it had
-   * an error while creating the audio or video track respectively.
+   * [[LocalParticipant.lastCameraError]] and [[LocalParticipant.lastMicrophoneError]]
+   * will indicate if it had an error while creating the audio or video track respectively.
    *
    * args: (error: Error)
    */

package/src/room/participant/LocalParticipant.ts

@@ -434,6 +434,23 @@ export default class LocalParticipant extends Participant {
     if (opts.source) {
       track.source = opts.source;
     }
+    const existingTrackOfSource = Array.from(this.tracks.values()).find(
+      (publishedTrack) => track instanceof LocalTrack && publishedTrack.source === track.source,
+    );
+    if (existingTrackOfSource) {
+      try {
+        // throw an Error in order to capture the stack trace
+        throw Error(`publishing a second track with the same source: ${track.source}`);
+      } catch (e: unknown) {
+        if (e instanceof Error) {
+          log.warn(e.message, {
+            oldTrack: existingTrackOfSource,
+            newTrack: track,
+            trace: e.stack,
+          });
+        }
+      }
+    }
     if (opts.stopMicTrackOnMute && track instanceof LocalAudioTrack) {
       track.stopOnMute = true;
     }
@@ -686,8 +703,6 @@ export default class LocalParticipant extends Participant {
     }
 
     track = publication.track;
-
-    track.sender = undefined;
     track.off(TrackEvent.Muted, this.onTrackMuted);
     track.off(TrackEvent.Unmuted, this.onTrackUnmuted);
     track.off(TrackEvent.Ended, this.handleTrackEnded);
@@ -701,22 +716,31 @@ export default class LocalParticipant extends Participant {
       track.stop();
     }
 
-    const { mediaStreamTrack } = track;
-
-    if (this.engine.publisher && this.engine.publisher.pc.connectionState !== 'closed') {
-      const senders = this.engine.publisher.pc.getSenders();
-      senders.forEach((sender) => {
-        if (sender.track === mediaStreamTrack) {
-          try {
-            this.engine.publisher?.pc.removeTrack(sender);
-            this.engine.negotiate();
-          } catch (e) {
-            log.warn('failed to remove track', { error: e, method: 'unpublishTrack' });
+    if (
+      this.engine.publisher &&
+      this.engine.publisher.pc.connectionState !== 'closed' &&
+      track.sender
+    ) {
+      try {
+        this.engine.removeTrack(track.sender);
+        if (track instanceof LocalVideoTrack) {
+          for (const [, trackInfo] of track.simulcastCodecs) {
+            if (trackInfo.sender) {
+              this.engine.removeTrack(trackInfo.sender);
+              trackInfo.sender = undefined;
+            }
           }
+          track.simulcastCodecs.clear();
         }
-      });
+      } catch (e) {
+        log.warn('failed to unpublish track', { error: e, method: 'unpublishTrack' });
+      } finally {
+        this.engine.negotiate();
+      }
     }
 
+    track.sender = undefined;
+
     // remove from our maps
     this.tracks.delete(publication.trackSid);
     switch (publication.kind) {

package/src/room/participant/RemoteParticipant.ts

@@ -210,6 +210,20 @@ export default class RemoteParticipant extends Participant {
         publication = new RemoteTrackPublication(kind, ti.sid, ti.name);
         publication.updateInfo(ti);
         newTracks.set(ti.sid, publication);
+        const existingTrackOfSource = Array.from(this.tracks.values()).find(
+          (publishedTrack) => publishedTrack.source === publication?.source,
+        );
+        if (existingTrackOfSource) {
+          log.warn(
+            `received a second track publication for ${this.identity} with the same source: ${publication.source}`,
+            {
+              oldTrack: existingTrackOfSource,
+              newTrack: publication,
+              participant: this,
+              participantInfo: info,
+            },
+          );
+        }
         this.addTrackPublication(publication);
       } else {
         publication.updateInfo(ti);

package/src/room/track/LocalAudioTrack.ts

@@ -8,8 +8,6 @@ import { Track } from './Track';
 import { constraintsForOptions, detectSilence } from './utils';
 
 export default class LocalAudioTrack extends LocalTrack {
-  sender?: RTCRtpSender;
-
   /** @internal */
   stopOnMute: boolean = false;
 

package/src/room/track/LocalVideoTrack.ts

@@ -27,17 +27,15 @@ export class SimulcastTrackInfo {
 const refreshSubscribedCodecAfterNewCodec = 5000;
 
 export default class LocalVideoTrack extends LocalTrack {
-  /* internal */
+  /* @internal */
   signalClient?: SignalClient;
 
   private prevStats?: Map<string, VideoSenderStats>;
 
   private encodings?: RTCRtpEncodingParameters[];
 
-  private simulcastCodecs: Map<VideoCodec, SimulcastTrackInfo> = new Map<
-    VideoCodec,
-    SimulcastTrackInfo
-  >();
+  /* @internal */
+  simulcastCodecs: Map<VideoCodec, SimulcastTrackInfo> = new Map<VideoCodec, SimulcastTrackInfo>();
 
   private subscribedCodecs?: SubscribedCodec[];
 
@@ -75,13 +73,10 @@ export default class LocalVideoTrack extends LocalTrack {
   }
 
   stop() {
-    this.sender = undefined;
     this._mediaStreamTrack.getConstraints();
     this.simulcastCodecs.forEach((trackInfo) => {
       trackInfo.mediaStreamTrack.stop();
-      trackInfo.sender = undefined;
     });
-    this.simulcastCodecs.clear();
     super.stop();
   }
 

package/src/room/track/RemoteTrackPublication.ts

@@ -8,7 +8,7 @@ import { TrackPublication } from './TrackPublication';
 import { RemoteTrack } from './types';
 
 export default class RemoteTrackPublication extends TrackPublication {
-  track?: RemoteTrack;
+  track?: RemoteTrack = undefined;
 
   /** @internal */
   protected allowed = true;

package/src/room/track/RemoteVideoTrack.ts

@@ -10,9 +10,6 @@ import { AdaptiveStreamSettings } from './types';
 const REACTION_DELAY = 100;
 
 export default class RemoteVideoTrack extends RemoteTrack {
-  /** @internal */
-  receiver?: RTCRtpReceiver;
-
   private prevStats?: VideoReceiverStats;
 
   private elementInfos: ElementInfo[] = [];