livekit-client 1.1.1 → 1.1.4

package/dist/livekit-client.esm.mjs

@@ -7049,7 +7049,8 @@ function createBaseAddTrackRequest() {
     disableDtx: false,
     source: 0,
     layers: [],
-    simulcastCodecs: []
+    simulcastCodecs: [],
+    sid: ''
   };
 }
 
@@ -7097,6 +7098,10 @@ const AddTrackRequest = {
       SimulcastCodec.encode(v, writer.uint32(82).fork()).ldelim();
     }
 
+    if (message.sid !== '') {
+      writer.uint32(90).string(message.sid);
+    }
+
     return writer;
   },
 
@@ -7149,6 +7154,10 @@ const AddTrackRequest = {
           message.simulcastCodecs.push(SimulcastCodec.decode(reader, reader.uint32()));
           break;
 
+        case 11:
+          message.sid = reader.string();
+          break;
+
         default:
           reader.skipType(tag & 7);
           break;
@@ -7169,7 +7178,8 @@ const AddTrackRequest = {
       disableDtx: isSet(object.disableDtx) ? Boolean(object.disableDtx) : false,
       source: isSet(object.source) ? trackSourceFromJSON(object.source) : 0,
       layers: Array.isArray(object === null || object === void 0 ? void 0 : object.layers) ? object.layers.map(e => VideoLayer.fromJSON(e)) : [],
-      simulcastCodecs: Array.isArray(object === null || object === void 0 ? void 0 : object.simulcastCodecs) ? object.simulcastCodecs.map(e => SimulcastCodec.fromJSON(e)) : []
+      simulcastCodecs: Array.isArray(object === null || object === void 0 ? void 0 : object.simulcastCodecs) ? object.simulcastCodecs.map(e => SimulcastCodec.fromJSON(e)) : [],
+      sid: isSet(object.sid) ? String(object.sid) : ''
     };
   },
 
@@ -7196,11 +7206,12 @@ const AddTrackRequest = {
       obj.simulcastCodecs = [];
     }
 
+    message.sid !== undefined && (obj.sid = message.sid);
     return obj;
   },
 
   fromPartial(object) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
 
     const message = createBaseAddTrackRequest();
     message.cid = (_a = object.cid) !== null && _a !== void 0 ? _a : '';
@@ -7213,6 +7224,7 @@ const AddTrackRequest = {
     message.source = (_h = object.source) !== null && _h !== void 0 ? _h : 0;
     message.layers = ((_j = object.layers) === null || _j === void 0 ? void 0 : _j.map(e => VideoLayer.fromPartial(e))) || [];
     message.simulcastCodecs = ((_k = object.simulcastCodecs) === null || _k === void 0 ? void 0 : _k.map(e => SimulcastCodec.fromPartial(e))) || [];
+    message.sid = (_l = object.sid) !== null && _l !== void 0 ? _l : '';
     return message;
   }
 
@@ -10058,7 +10070,7 @@ function computeBitrate(currentStats, prevStats) {
   return (bytesNow - bytesPrev) * 8 * 1000 / (currentStats.timestamp - prevStats.timestamp);
 }
 
-var version$1 = "1.1.1";
+var version$1 = "1.1.4";
 
 const version = version$1;
 const protocolVersion = 8;
@@ -10130,9 +10142,10 @@ function getEmptyVideoStreamTrack() {
   var _a;
 
   if (!emptyVideoStreamTrack) {
-    const canvas = document.createElement('canvas');
-    canvas.width = 2;
-    canvas.height = 2;
+    const canvas = document.createElement('canvas'); // the canvas size is set to 16, because electron apps seem to fail with smaller values
+
+    canvas.width = 16;
+    canvas.height = 16;
     (_a = canvas.getContext('2d')) === null || _a === void 0 ? void 0 : _a.fillRect(0, 0, canvas.width, canvas.height); // @ts-ignore
 
     const emptyStream = canvas.captureStream();
@@ -11047,6 +11060,7 @@ function detachTrack(track, element) {
 
 class LocalTrack extends Track {
   constructor(mediaTrack, kind, constraints) {
+    let userProvidedTrack = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
     super(mediaTrack, kind);
     this._isUpstreamPaused = false;
 
@@ -11063,6 +11077,7 @@ class LocalTrack extends Track {
     this.constraints = constraints !== null && constraints !== void 0 ? constraints : mediaTrack.getConstraints();
     this.reacquireTrack = false;
     this.wasMuted = false;
+    this.providedByUser = userProvidedTrack;
   }
 
   get id() {
@@ -11092,6 +11107,10 @@ class LocalTrack extends Track {
   get isUpstreamPaused() {
     return this._isUpstreamPaused;
   }
+
+  get isUserProvided() {
+    return this.providedByUser;
+  }
   /**
    * @returns DeviceID of the device that is currently being used for this track
    */
@@ -11123,6 +11142,8 @@ class LocalTrack extends Track {
   }
 
   async replaceTrack(track) {
+    let userProvidedTrack = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+
     if (!this.sender) {
       throw new TrackInvalidError('unable to replace an unpublished track');
     } // detach
@@ -11151,6 +11172,7 @@ class LocalTrack extends Track {
       attachToElement(track, el);
     });
     this.mediaStream = new MediaStream([track]);
+    this.providedByUser = userProvidedTrack;
     return this;
   }
 
@@ -11222,7 +11244,7 @@ class LocalTrack extends Track {
     if (!isMobile()) return;
     livekitLogger.debug("visibility changed, is in Background: ".concat(this.isInBackground));
 
-    if (!this.isInBackground && this.needsReAcquisition) {
+    if (!this.isInBackground && this.needsReAcquisition && !this.isUserProvided) {
       livekitLogger.debug("track needs to be reaquired, restarting ".concat(this.source));
       await this.restart();
       this.reacquireTrack = false; // Restore muted state if had to be restarted
@@ -11373,7 +11395,8 @@ function getNewAudioContext() {
 
 class LocalAudioTrack extends LocalTrack {
   constructor(mediaTrack, constraints) {
-    super(mediaTrack, Track.Kind.Audio, constraints);
+    let userProvidedTrack = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    super(mediaTrack, Track.Kind.Audio, constraints, userProvidedTrack);
     /** @internal */
 
     this.stopOnMute = false;
@@ -11433,7 +11456,7 @@ class LocalAudioTrack extends LocalTrack {
   }
 
   async unmute() {
-    if (this.source === Track.Source.Microphone && this.stopOnMute) {
+    if (this.source === Track.Source.Microphone && this.stopOnMute && !this.isUserProvided) {
       livekitLogger.debug('reacquiring mic track');
       await this.restartTrack();
     }
@@ -11514,9 +11537,11 @@ class LocalAudioTrack extends LocalTrack {
 
 }
 
+const refreshSubscribedCodecAfterNewCodec = 5000;
 class LocalVideoTrack extends LocalTrack {
   constructor(mediaTrack, constraints) {
-    super(mediaTrack, Track.Kind.Video, constraints);
+    let userProvidedTrack = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    super(mediaTrack, Track.Kind.Video, constraints, userProvidedTrack);
     this.simulcastCodecs = new Map();
 
     this.monitorSender = async () => {
@@ -11613,7 +11638,7 @@ class LocalVideoTrack extends LocalTrack {
   }
 
   async unmute() {
-    if (this.source === Track.Source.Camera) {
+    if (this.source === Track.Source.Camera && !this.isUserProvided) {
       livekitLogger.debug('reacquiring camera track');
       await this.restartTrack();
     }
@@ -11730,7 +11755,14 @@ class LocalVideoTrack extends LocalTrack {
       return;
     }
 
-    simulcastCodecInfo.sender = sender;
+    simulcastCodecInfo.sender = sender; // browser will reenable disabled codec/layers after new codec has been published,
+    // so refresh subscribedCodecs after publish a new codec
+
+    setTimeout(() => {
+      if (this.subscribedCodecs) {
+        this.setPublishingCodecs(this.subscribedCodecs);
+      }
+    }, refreshSubscribedCodecAfterNewCodec);
   }
   /**
    * @internal
@@ -11739,25 +11771,41 @@ class LocalVideoTrack extends LocalTrack {
 
 
   async setPublishingCodecs(codecs) {
-    livekitLogger.debug('setting publishing codecs', codecs);
+    livekitLogger.debug('setting publishing codecs', {
+      codecs,
+      currentCodec: this.codec
+    }); // only enable simulcast codec for preference codec setted
+
+    if (!this.codec && codecs.length > 0) {
+      await this.setPublishingLayers(codecs[0].qualities);
+      return [];
+    }
+
+    this.subscribedCodecs = codecs;
+    const newCodecs = [];
 
     for await (const codec of codecs) {
-      if (this.codec === codec.codec) {
+      if (!this.codec || this.codec === codec.codec) {
         await this.setPublishingLayers(codec.qualities);
       } else {
         const simulcastCodecInfo = this.simulcastCodecs.get(codec.codec);
         livekitLogger.debug("try setPublishingCodec for ".concat(codec.codec), simulcastCodecInfo);
 
         if (!simulcastCodecInfo || !simulcastCodecInfo.sender) {
-          return;
-        }
-
-        if (simulcastCodecInfo.encodings) {
+          for (const q of codec.qualities) {
+            if (q.enabled) {
+              newCodecs.push(codec.codec);
+              break;
+            }
+          }
+        } else if (simulcastCodecInfo.encodings) {
           livekitLogger.debug("try setPublishingLayersForSender ".concat(codec.codec));
           await setPublishingLayersForSender(simulcastCodecInfo.sender, simulcastCodecInfo.encodings, codec.qualities);
         }
       }
     }
+
+    return newCodecs;
   }
   /**
    * @internal
@@ -12188,6 +12236,8 @@ class RemoteVideoTrack extends RemoteTrack {
 
       this.debouncedHandleResize();
       this.updateVisibility();
+    } else {
+      livekitLogger.warn('visibility resize observer not triggered');
     }
   }
   /**
@@ -12336,9 +12386,7 @@ class RemoteVideoTrack extends RemoteTrack {
 }
 
 class HTMLElementInfo {
-  constructor(element) {
-    let visible = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-
+  constructor(element, visible) {
     this.onVisibilityChanged = entry => {
       var _a;
 
@@ -12355,7 +12403,7 @@ class HTMLElementInfo {
     };
 
     this.element = element;
-    this.visible = visible;
+    this.visible = visible !== null && visible !== void 0 ? visible : isElementInViewport(element);
     this.visibilityChangedAt = 0;
   }
 
@@ -12386,6 +12434,29 @@ class HTMLElementInfo {
     (_b = getResizeObserver()) === null || _b === void 0 ? void 0 : _b.unobserve(this.element);
   }
 
+} // does not account for occlusion by other elements
+
+
+function isElementInViewport(el) {
+  let top = el.offsetTop;
+  let left = el.offsetLeft;
+  const width = el.offsetWidth;
+  const height = el.offsetHeight;
+  const {
+    hidden
+  } = el;
+  const {
+    opacity,
+    display
+  } = getComputedStyle(el);
+
+  while (el.offsetParent) {
+    el = el.offsetParent;
+    top += el.offsetTop;
+    left += el.offsetLeft;
+  }
+
+  return top < window.pageYOffset + window.innerHeight && left < window.pageXOffset + window.innerWidth && top + height > window.pageYOffset && left + width > window.pageXOffset && !hidden && (opacity !== '' ? parseFloat(opacity) > 0 : true) && display !== 'none';
 }
 
 class TrackPublication extends events.exports.EventEmitter {
@@ -12895,10 +12966,10 @@ function trackPermissionToProto(perms) {
 function mediaTrackToLocalTrack(mediaStreamTrack, constraints) {
   switch (mediaStreamTrack.kind) {
     case 'audio':
-      return new LocalAudioTrack(mediaStreamTrack, constraints);
+      return new LocalAudioTrack(mediaStreamTrack, constraints, false);
 
     case 'video':
-      return new LocalVideoTrack(mediaStreamTrack, constraints);
+      return new LocalVideoTrack(mediaStreamTrack, constraints, false);
 
     default:
       throw new TrackInvalidError("unsupported track type: ".concat(mediaStreamTrack.kind));
@@ -13358,9 +13429,7 @@ class RemoteParticipant extends Participant {
 
 
   static fromParticipantInfo(signalClient, pi) {
-    const rp = new RemoteParticipant(signalClient, pi.sid, pi.identity);
-    rp.updateInfo(pi);
-    return rp;
+    return new RemoteParticipant(signalClient, pi.sid, pi.identity);
   }
 
   addTrackPublication(publication) {
@@ -13501,7 +13570,6 @@ class RemoteParticipant extends Participant {
 
 
   updateInfo(info) {
-    const alreadyHasMetadata = this.hasMetadata;
     super.updateInfo(info); // we are getting a list of all available tracks, reconcile in here
     // and send out events for changes
     // reconcile track publications, publish events only if metadata is already there
@@ -13529,14 +13597,11 @@ class RemoteParticipant extends Participant {
       }
 
       validTracks.set(ti.sid, publication);
-    }); // send new tracks
-
-    if (alreadyHasMetadata) {
-      newTracks.forEach(publication => {
-        this.emit(ParticipantEvent.TrackPublished, publication);
-      });
-    } // detect removed tracks
+    }); // always emit events for new publications, Room will not forward them unless it's ready
 
+    newTracks.forEach(publication => {
+      this.emit(ParticipantEvent.TrackPublished, publication);
+    }); // detect removed tracks
 
     this.tracks.forEach(publication => {
       if (!validTracks.has(publication.trackSid)) {
@@ -13605,7 +13670,7 @@ class RemoteParticipant extends Participant {
 
 }
 
-const compatibleCodecForSVC = 'vp8';
+const compatibleCodec = 'vp8';
 class LocalParticipant extends Participant {
   /** @internal */
   constructor(sid, identity, engine, options) {
@@ -13654,8 +13719,8 @@ class LocalParticipant extends Participant {
       this.onTrackMuted(track, track.isMuted);
     };
 
-    this.handleSubscribedQualityUpdate = update => {
-      var _a, _b, _c;
+    this.handleSubscribedQualityUpdate = async update => {
+      var _a, _b;
 
       if (!((_a = this.roomOptions) === null || _a === void 0 ? void 0 : _a.dynacast)) {
         return;
@@ -13672,9 +13737,18 @@ class LocalParticipant extends Participant {
       }
 
       if (update.subscribedCodecs.length > 0) {
-        (_b = pub.videoTrack) === null || _b === void 0 ? void 0 : _b.setPublishingCodecs(update.subscribedCodecs);
+        if (!pub.videoTrack) {
+          return;
+        }
+
+        const newCodecs = await pub.videoTrack.setPublishingCodecs(update.subscribedCodecs);
+
+        for await (const codec of newCodecs) {
+          livekitLogger.debug("publish ".concat(codec, " for ").concat(pub.videoTrack.sid));
+          await this.publishAdditionalCodecForTrack(pub.videoTrack, codec, pub.options);
+        }
       } else if (update.subscribedQualities.length > 0) {
-        (_c = pub.videoTrack) === null || _c === void 0 ? void 0 : _c.setPublishingLayers(update.subscribedQualities);
+        (_b = pub.videoTrack) === null || _b === void 0 ? void 0 : _b.setPublishingLayers(update.subscribedQualities);
       }
     };
 
@@ -14002,12 +14076,12 @@ class LocalParticipant extends Participant {
       throw new TrackInvalidError('no video track found');
     }
 
-    const screenVideo = new LocalVideoTrack(tracks[0]);
+    const screenVideo = new LocalVideoTrack(tracks[0], undefined, false);
     screenVideo.source = Track.Source.ScreenShare;
     const localTracks = [screenVideo];
 
     if (stream.getAudioTracks().length > 0) {
-      const screenAudio = new LocalAudioTrack(stream.getAudioTracks()[0]);
+      const screenAudio = new LocalAudioTrack(stream.getAudioTracks()[0], undefined, false);
       screenAudio.source = Track.Source.ScreenShareAudio;
       localTracks.push(screenAudio);
     }
@@ -14030,11 +14104,11 @@ class LocalParticipant extends Participant {
     if (track instanceof MediaStreamTrack) {
       switch (track.kind) {
         case 'audio':
-          track = new LocalAudioTrack(track);
+          track = new LocalAudioTrack(track, undefined, true);
           break;
 
         case 'video':
-          track = new LocalVideoTrack(track);
+          track = new LocalVideoTrack(track, undefined, true);
           break;
 
         default:
@@ -14088,7 +14162,6 @@ class LocalParticipant extends Participant {
 
     let encodings;
     let simEncodings;
-    let simulcastTracks;
 
     if (track.kind === Track.Kind.Video) {
       // TODO: support react native, which doesn't expose getSettings
@@ -14099,26 +14172,30 @@ class LocalParticipant extends Participant {
       req.width = width !== null && width !== void 0 ? width : 0;
       req.height = height !== null && height !== void 0 ? height : 0; // for svc codecs, disable simulcast and use vp8 for backup codec
 
-      if (track instanceof LocalVideoTrack && ((opts === null || opts === void 0 ? void 0 : opts.videoCodec) === 'vp9' || (opts === null || opts === void 0 ? void 0 : opts.videoCodec) === 'av1')) {
-        // set scalabilityMode to 'L3T3' by default
-        opts.scalabilityMode = (_g = opts.scalabilityMode) !== null && _g !== void 0 ? _g : 'L3T3'; // add backup codec track
-
-        const simOpts = _objectSpread2({}, opts);
-
-        simOpts.simulcast = true;
-        simOpts.scalabilityMode = undefined;
-        simEncodings = computeVideoEncodings(track.source === Track.Source.ScreenShare, width, height, simOpts);
-        const simulcastTrack = track.addSimulcastTrack(compatibleCodecForSVC, simEncodings);
-        simulcastTracks = [simulcastTrack];
-        req.simulcastCodecs = [{
-          codec: opts.videoCodec,
-          cid: track.mediaStreamTrack.id,
-          enableSimulcastLayers: true
-        }, {
-          codec: simulcastTrack.codec,
-          cid: simulcastTrack.mediaStreamTrack.id,
-          enableSimulcastLayers: true
-        }];
+      if (track instanceof LocalVideoTrack) {
+        if ((opts === null || opts === void 0 ? void 0 : opts.videoCodec) === 'vp9' || (opts === null || opts === void 0 ? void 0 : opts.videoCodec) === 'av1') {
+          // set scalabilityMode to 'L3T3' by default
+          opts.scalabilityMode = (_g = opts.scalabilityMode) !== null && _g !== void 0 ? _g : 'L3T3'; // add backup codec track
+
+          const simOpts = _objectSpread2({}, opts);
+
+          simOpts.simulcast = true;
+          simOpts.scalabilityMode = undefined;
+          simEncodings = computeVideoEncodings(track.source === Track.Source.ScreenShare, width, height, simOpts);
+        } // set vp8 codec as backup for any other codecs
+
+
+        if (opts.videoCodec && opts.videoCodec !== 'vp8') {
+          req.simulcastCodecs = [{
+            codec: opts.videoCodec,
+            cid: track.mediaStreamTrack.id,
+            enableSimulcastLayers: true
+          }, {
+            codec: compatibleCodec,
+            cid: '',
+            enableSimulcastLayers: true
+          }];
+        }
       }
 
       encodings = computeVideoEncodings(track.source === Track.Source.ScreenShare, width, height, opts);
@@ -14163,24 +14240,6 @@ class LocalParticipant extends Participant {
       track.codec = opts.videoCodec;
     }
 
-    const localTrack = track;
-
-    if (simulcastTracks) {
-      for await (const simulcastTrack of simulcastTracks) {
-        const simTransceiverInit = {
-          direction: 'sendonly'
-        };
-
-        if (simulcastTrack.encodings) {
-          simTransceiverInit.sendEncodings = simulcastTrack.encodings;
-        }
-
-        const simTransceiver = await this.engine.publisher.pc.addTransceiver(simulcastTrack.mediaStreamTrack, simTransceiverInit);
-        this.setPreferredCodec(simTransceiver, localTrack.kind, simulcastTrack.codec);
-        localTrack.setSimulcastTrackSender(simulcastTrack.codec, simTransceiver.sender);
-      }
-    }
-
     this.engine.negotiate(); // store RTPSender
 
     track.sender = transceiver.sender;
@@ -14196,6 +14255,86 @@ class LocalParticipant extends Participant {
     this.emit(ParticipantEvent.LocalTrackPublished, publication);
     return publication;
   }
+  /** @internal
+   * publish additional codec to existing track
+   */
+
+
+  async publishAdditionalCodecForTrack(track, videoCodec, options) {
+    var _a, _b, _c, _d, _e;
+
+    const opts = _objectSpread2(_objectSpread2({}, (_a = this.roomOptions) === null || _a === void 0 ? void 0 : _a.publishDefaults), options); // clear scalabilityMode setting for backup codec
+
+
+    opts.scalabilityMode = undefined;
+    opts.videoCodec = videoCodec; // is it not published? if so skip
+
+    let existingPublication;
+    this.tracks.forEach(publication => {
+      if (!publication.track) {
+        return;
+      }
+
+      if (publication.track === track) {
+        existingPublication = publication;
+      }
+    });
+
+    if (!existingPublication) {
+      throw new TrackInvalidError('track is not published');
+    }
+
+    if (!(track instanceof LocalVideoTrack)) {
+      throw new TrackInvalidError('track is not a video track');
+    }
+
+    const settings = track.mediaStreamTrack.getSettings();
+    const width = (_b = settings.width) !== null && _b !== void 0 ? _b : (_c = track.dimensions) === null || _c === void 0 ? void 0 : _c.width;
+    const height = (_d = settings.height) !== null && _d !== void 0 ? _d : (_e = track.dimensions) === null || _e === void 0 ? void 0 : _e.height;
+    const encodings = computeVideoEncodings(track.source === Track.Source.ScreenShare, width, height, opts);
+    const simulcastTrack = track.addSimulcastTrack(opts.videoCodec, encodings);
+    const req = AddTrackRequest.fromPartial({
+      cid: simulcastTrack.mediaStreamTrack.id,
+      type: Track.kindToProto(track.kind),
+      muted: track.isMuted,
+      source: Track.sourceToProto(track.source),
+      sid: track.sid,
+      simulcastCodecs: [{
+        codec: opts.videoCodec,
+        cid: simulcastTrack.mediaStreamTrack.id,
+        enableSimulcastLayers: opts.simulcast
+      }]
+    });
+    req.layers = videoLayersFromEncodings(req.width, req.height, encodings);
+
+    if (!this.engine || this.engine.isClosed) {
+      throw new UnexpectedConnectionState('cannot publish track when not connected');
+    }
+
+    const ti = await this.engine.addTrack(req);
+
+    if (!this.engine.publisher) {
+      throw new UnexpectedConnectionState('publisher is closed');
+    }
+
+    const transceiverInit = {
+      direction: 'sendonly'
+    };
+
+    if (encodings) {
+      transceiverInit.sendEncodings = encodings;
+    } // addTransceiver for react-native is async. web is synchronous, but await won't effect it.
+
+
+    const transceiver = await this.engine.publisher.pc.addTransceiver(simulcastTrack.mediaStreamTrack, transceiverInit);
+    this.setPreferredCodec(transceiver, track.kind, opts.videoCodec);
+    track.setSimulcastTrackSender(opts.videoCodec, transceiver.sender);
+    this.engine.negotiate();
+    livekitLogger.debug("published ".concat(opts.videoCodec, " for track ").concat(track.sid), {
+      encodings,
+      trackInfo: ti
+    });
+  }
 
   unpublishTrack(track, stopOnUnpublish) {
     var _a, _b; // look through all published tracks to find the right ones
@@ -19266,8 +19405,6 @@ class Room extends events.exports.EventEmitter {
   constructor(options) {
     var _this;
 
-    var _a, _b;
-
     super();
     _this = this;
     this.state = ConnectionState.Disconnected;
@@ -19363,7 +19500,7 @@ class Room extends events.exports.EventEmitter {
         this.metadata = joinResponse.room.metadata;
         this.emit(RoomEvent.SignalConnected);
       } catch (err) {
-        this.engine.close();
+        this.recreateEngine();
         this.setAndEmitConnectionState(ConnectionState.Disconnected);
         throw err;
       } // don't return until ICE connected
@@ -19374,7 +19511,7 @@ class Room extends events.exports.EventEmitter {
 
         const connectTimeout = setTimeout(() => {
           // timeout
-          this.engine.close();
+          this.recreateEngine();
           this.setAndEmitConnectionState(ConnectionState.Disconnected);
           reject(new ConnectionError('could not connect after timeout'));
         }, maxICEConnectTimeout);
@@ -19382,7 +19519,7 @@ class Room extends events.exports.EventEmitter {
         const abortHandler = () => {
           livekitLogger.warn('closing engine');
           clearTimeout(connectTimeout);
-          this.engine.close();
+          this.recreateEngine();
           this.setAndEmitConnectionState(ConnectionState.Disconnected);
           reject(new ConnectionError('room connection has been cancelled'));
         };
@@ -19447,14 +19584,14 @@ class Room extends events.exports.EventEmitter {
     };
 
     this.handleRestarting = () => {
-      if (this.setAndEmitConnectionState(ConnectionState.Reconnecting)) {
-        this.emit(RoomEvent.Reconnecting);
-      } // also unwind existing participants & existing subscriptions
-
-
+      // also unwind existing participants & existing subscriptions
       for (const p of this.participants.values()) {
         this.handleParticipantDisconnected(p.sid, p);
       }
+
+      if (this.setAndEmitConnectionState(ConnectionState.Reconnecting)) {
+        this.emit(RoomEvent.Reconnecting);
+      }
     };
 
     this.handleRestarted = async joinResponse => {
@@ -19483,7 +19620,7 @@ class Room extends events.exports.EventEmitter {
         this.localParticipant.unpublishTrack(track, false);
 
         if (!track.isMuted) {
-          if (track instanceof LocalAudioTrack || track instanceof LocalVideoTrack) {
+          if ((track instanceof LocalAudioTrack || track instanceof LocalVideoTrack) && !track.isUserProvided) {
             // we need to restart the track before publishing, often a full reconnect
             // is necessary because computer had gone to sleep.
             livekitLogger.debug('restarting existing track', {
@@ -19522,7 +19659,7 @@ class Room extends events.exports.EventEmitter {
           this.handleParticipantDisconnected(info.sid, remoteParticipant);
         } else if (isNewParticipant) {
           // fire connected event
-          this.emit(RoomEvent.ParticipantConnected, remoteParticipant);
+          this.emitWhenConnected(RoomEvent.ParticipantConnected, remoteParticipant);
         } else {
           // just update, no events
           remoteParticipant.updateInfo(info);
@@ -19564,7 +19701,7 @@ class Room extends events.exports.EventEmitter {
         }
       });
       this.activeSpeakers = activeSpeakers;
-      this.emit(RoomEvent.ActiveSpeakersChanged, activeSpeakers);
+      this.emitWhenConnected(RoomEvent.ActiveSpeakersChanged, activeSpeakers);
     }; // process list of changed speakers
 
 
@@ -19596,7 +19733,7 @@ class Room extends events.exports.EventEmitter {
       const activeSpeakers = Array.from(lastSpeakers.values());
       activeSpeakers.sort((a, b) => b.audioLevel - a.audioLevel);
       this.activeSpeakers = activeSpeakers;
-      this.emit(RoomEvent.ActiveSpeakersChanged, activeSpeakers);
+      this.emitWhenConnected(RoomEvent.ActiveSpeakersChanged, activeSpeakers);
     };
 
     this.handleStreamStateUpdate = streamStateUpdate => {
@@ -19615,7 +19752,7 @@ class Room extends events.exports.EventEmitter {
 
         pub.track.streamState = Track.streamStateFromProto(streamState.state);
         participant.emit(ParticipantEvent.TrackStreamStateChanged, pub, pub.track.streamState);
-        this.emit(ParticipantEvent.TrackStreamStateChanged, pub, pub.track.streamState, participant);
+        this.emitWhenConnected(ParticipantEvent.TrackStreamStateChanged, pub, pub.track.streamState, participant);
       });
     };
 
@@ -19634,7 +19771,7 @@ class Room extends events.exports.EventEmitter {
 
       pub._allowed = update.allowed;
       participant.emit(ParticipantEvent.TrackSubscriptionPermissionChanged, pub, pub.subscriptionStatus);
-      this.emit(ParticipantEvent.TrackSubscriptionPermissionChanged, pub, pub.subscriptionStatus, participant);
+      this.emitWhenConnected(ParticipantEvent.TrackSubscriptionPermissionChanged, pub, pub.subscriptionStatus, participant);
     };
 
     this.handleDataPacket = (userPacket, kind) => {
@@ -19671,7 +19808,7 @@ class Room extends events.exports.EventEmitter {
 
     this.handleRoomUpdate = r => {
       this.metadata = r.metadata;
-      this.emit(RoomEvent.RoomMetadataChanged, r.metadata);
+      this.emitWhenConnected(RoomEvent.RoomMetadataChanged, r.metadata);
     };
 
     this.handleConnectionQualityUpdate = update => {
@@ -19692,14 +19829,6 @@ class Room extends events.exports.EventEmitter {
     this.participants = new Map();
     this.identityToSid = new Map();
     this.options = options || {};
-
-    switch ((_b = (_a = this.options) === null || _a === void 0 ? void 0 : _a.publishDefaults) === null || _b === void 0 ? void 0 : _b.videoCodec) {
-      case 'av1':
-      case 'vp9':
-        this.options.publishDefaults.simulcast = undefined;
-        break;
-    }
-
     this.options.audioCaptureDefaults = _objectSpread2(_objectSpread2({}, audioDefaults), options === null || options === void 0 ? void 0 : options.audioCaptureDefaults);
     this.options.videoCaptureDefaults = _objectSpread2(_objectSpread2({}, videoDefaults), options === null || options === void 0 ? void 0 : options.videoCaptureDefaults);
     this.options.publishDefaults = _objectSpread2(_objectSpread2({}, publishDefaults), options === null || options === void 0 ? void 0 : options.publishDefaults);
@@ -19737,6 +19866,10 @@ class Room extends events.exports.EventEmitter {
         this.sendSyncState();
       }
     }).on(EngineEvent.Restarting, this.handleRestarting).on(EngineEvent.Restarted, this.handleRestarted);
+
+    if (this.localParticipant) {
+      this.localParticipant.engine = this.engine;
+    }
   }
   /**
    * getLocalDevices abstracts navigator.mediaDevices.enumerateDevices.
@@ -19913,7 +20046,34 @@ class Room extends events.exports.EventEmitter {
     }
   }
 
+  recreateEngine() {
+    this.engine.close();
+    /* @ts-ignore */
+
+    this.engine = undefined; // clear out existing remote participants, since they may have attached
+    // the old engine
+
+    this.participants.clear();
+    this.createEngine();
+  }
+
   onTrackAdded(mediaTrack, stream, receiver) {
+    // don't fire onSubscribed when connecting
+    // WebRTC fires onTrack as soon as setRemoteDescription is called on the offer
+    // at that time, ICE connectivity has not been established so the track is not
+    // technically subscribed.
+    // We'll defer these events until when the room is connected or eventually disconnected.
+    if (this.state === ConnectionState.Connecting || this.state === ConnectionState.Reconnecting) {
+      setTimeout(() => {
+        this.onTrackAdded(mediaTrack, stream, receiver);
+      }, 50);
+      return;
+    }
+
+    if (this.state === ConnectionState.Disconnected) {
+      livekitLogger.warn('skipping incoming track after Room disconnected');
+    }
+
     const parts = unpackStreamId(stream.id);
     const participantId = parts[0];
     let trackId = parts[1];
@@ -19983,7 +20143,7 @@ class Room extends events.exports.EventEmitter {
     participant.tracks.forEach(publication => {
       participant.unpublishTrack(publication.trackSid, true);
     });
-    this.emit(RoomEvent.ParticipantDisconnected, participant);
+    this.emitWhenConnected(RoomEvent.ParticipantDisconnected, participant);
   }
 
   acquireAudioContext() {
@@ -20030,7 +20190,7 @@ class Room extends events.exports.EventEmitter {
 
 
     participant.on(ParticipantEvent.TrackPublished, trackPublication => {
-      this.emit(RoomEvent.TrackPublished, trackPublication, participant);
+      this.emitWhenConnected(RoomEvent.TrackPublished, trackPublication, participant);
     }).on(ParticipantEvent.TrackSubscribed, (track, publication) => {
       // monitor playback status
       if (track.kind === Track.Kind.Audio) {
@@ -20040,22 +20200,27 @@ class Room extends events.exports.EventEmitter {
 
       this.emit(RoomEvent.TrackSubscribed, track, publication, participant);
     }).on(ParticipantEvent.TrackUnpublished, publication => {
-      this.emit(RoomEvent.TrackUnpublished, publication, participant);
+      this.emitWhenConnected(RoomEvent.TrackUnpublished, publication, participant);
     }).on(ParticipantEvent.TrackUnsubscribed, (track, publication) => {
       this.emit(RoomEvent.TrackUnsubscribed, track, publication, participant);
     }).on(ParticipantEvent.TrackSubscriptionFailed, sid => {
       this.emit(RoomEvent.TrackSubscriptionFailed, sid, participant);
     }).on(ParticipantEvent.TrackMuted, pub => {
-      this.emit(RoomEvent.TrackMuted, pub, participant);
+      this.emitWhenConnected(RoomEvent.TrackMuted, pub, participant);
     }).on(ParticipantEvent.TrackUnmuted, pub => {
-      this.emit(RoomEvent.TrackUnmuted, pub, participant);
+      this.emitWhenConnected(RoomEvent.TrackUnmuted, pub, participant);
     }).on(ParticipantEvent.ParticipantMetadataChanged, metadata => {
-      this.emit(RoomEvent.ParticipantMetadataChanged, metadata, participant);
+      this.emitWhenConnected(RoomEvent.ParticipantMetadataChanged, metadata, participant);
     }).on(ParticipantEvent.ConnectionQualityChanged, quality => {
-      this.emit(RoomEvent.ConnectionQualityChanged, quality, participant);
+      this.emitWhenConnected(RoomEvent.ConnectionQualityChanged, quality, participant);
     }).on(ParticipantEvent.ParticipantPermissionsChanged, prevPermissions => {
-      this.emit(RoomEvent.ParticipantPermissionsChanged, prevPermissions, participant);
-    });
+      this.emitWhenConnected(RoomEvent.ParticipantPermissionsChanged, prevPermissions, participant);
+    }); // update info at the end after callbacks have been set up
+
+    if (info) {
+      participant.updateInfo(info);
+    }
+
     return participant;
   }
 
@@ -20121,12 +20286,24 @@ class Room extends events.exports.EventEmitter {
     this.state = state;
     this.emit(RoomEvent.ConnectionStateChanged, this.state);
     return true;
+  }
+
+  emitWhenConnected(event) {
+    if (this.state === ConnectionState.Connected) {
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+
+      return this.emit(event, ...args);
+    }
+
+    return false;
   } // /** @internal */
 
 
   emit(event) {
-    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-      args[_key - 1] = arguments[_key];
+    for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+      args[_key2 - 1] = arguments[_key2];
     }
 
     livekitLogger.debug('room event', {
@@ -20235,12 +20412,12 @@ async function createLocalScreenTracks(options) {
     throw new TrackInvalidError('no video track found');
   }
 
-  const screenVideo = new LocalVideoTrack(tracks[0]);
+  const screenVideo = new LocalVideoTrack(tracks[0], undefined, false);
   screenVideo.source = Track.Source.ScreenShare;
   const localTracks = [screenVideo];
 
   if (stream.getAudioTracks().length > 0) {
-    const screenAudio = new LocalAudioTrack(stream.getAudioTracks()[0]);
+    const screenAudio = new LocalAudioTrack(stream.getAudioTracks()[0], undefined, false);
     screenAudio.source = Track.Source.ScreenShareAudio;
     localTracks.push(screenAudio);
   }