livekit-client 1.11.3 → 1.12.0

package/dist/livekit-client.esm.mjs

@@ -285,6 +285,7 @@ var loglevel = {exports: {}};
   });
 })(loglevel);
 var loglevelExports = loglevel.exports;
+var log$1 = /*@__PURE__*/getDefaultExportFromCjs(loglevelExports);
 
 var LogLevel;
 (function (LogLevel) {
@@ -297,8 +298,13 @@ var LogLevel;
 })(LogLevel || (LogLevel = {}));
 const livekitLogger = loglevelExports.getLogger('livekit');
 livekitLogger.setDefaultLevel(LogLevel.info);
-function setLogLevel(level) {
-  livekitLogger.setLevel(level);
+function setLogLevel(level, loggerName) {
+  if (loggerName) {
+    loglevelExports.getLogger(loggerName).setLevel(level);
+  }
+  for (const logger of Object.values(loglevelExports.getLoggers())) {
+    logger.setLevel(level);
+  }
 }
 /**
  * use this to hook into the logging function to allow sending internal livekit logs to third party services
@@ -320,6 +326,8 @@ function setLogExtension(extension) {
   livekitLogger.setLevel(livekitLogger.getLevel()); // Be sure to call setLevel method in order to apply plugin
 }
 
+loglevelExports.getLogger('lk-e2ee');
+
 var long = Long;
 
 /**
@@ -4295,7 +4303,7 @@ function disconnectReasonToJSON(object) {
 }
 var ReconnectReason;
 (function (ReconnectReason) {
-  ReconnectReason[ReconnectReason["RR_UNKOWN"] = 0] = "RR_UNKOWN";
+  ReconnectReason[ReconnectReason["RR_UNKNOWN"] = 0] = "RR_UNKNOWN";
   ReconnectReason[ReconnectReason["RR_SIGNAL_DISCONNECTED"] = 1] = "RR_SIGNAL_DISCONNECTED";
   ReconnectReason[ReconnectReason["RR_PUBLISHER_FAILED"] = 2] = "RR_PUBLISHER_FAILED";
   ReconnectReason[ReconnectReason["RR_SUBSCRIBER_FAILED"] = 3] = "RR_SUBSCRIBER_FAILED";
@@ -4304,7 +4312,7 @@ var ReconnectReason;
 })(ReconnectReason || (ReconnectReason = {}));
 var SubscriptionError;
 (function (SubscriptionError) {
-  SubscriptionError[SubscriptionError["SE_UNKOWN"] = 0] = "SE_UNKOWN";
+  SubscriptionError[SubscriptionError["SE_UNKNOWN"] = 0] = "SE_UNKNOWN";
   SubscriptionError[SubscriptionError["SE_CODEC_UNSUPPORTED"] = 1] = "SE_CODEC_UNSUPPORTED";
   SubscriptionError[SubscriptionError["SE_TRACK_NOTFOUND"] = 2] = "SE_TRACK_NOTFOUND";
   SubscriptionError[SubscriptionError["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
@@ -4312,8 +4320,8 @@ var SubscriptionError;
 function subscriptionErrorFromJSON(object) {
   switch (object) {
     case 0:
-    case "SE_UNKOWN":
-      return SubscriptionError.SE_UNKOWN;
+    case "SE_UNKNOWN":
+      return SubscriptionError.SE_UNKNOWN;
     case 1:
     case "SE_CODEC_UNSUPPORTED":
       return SubscriptionError.SE_CODEC_UNSUPPORTED;
@@ -4328,8 +4336,8 @@ function subscriptionErrorFromJSON(object) {
 }
 function subscriptionErrorToJSON(object) {
   switch (object) {
-    case SubscriptionError.SE_UNKOWN:
-      return "SE_UNKOWN";
+    case SubscriptionError.SE_UNKNOWN:
+      return "SE_UNKNOWN";
     case SubscriptionError.SE_CODEC_UNSUPPORTED:
       return "SE_CODEC_UNSUPPORTED";
     case SubscriptionError.SE_TRACK_NOTFOUND:
@@ -14187,77 +14195,94 @@ function getMatch(exp, ua) {
   return match && match.length >= id && match[id] || '';
 }
 
-var version$1 = "1.11.3";
+var version$1 = "1.12.0";
 
 const version = version$1;
 const protocolVersion = 9;
 
-const defaultId = 'default';
-class DeviceManager {
-  static getInstance() {
-    if (this.instance === undefined) {
-      this.instance = new DeviceManager();
-    }
-    return this.instance;
-  }
-  getDevices(kind) {
-    let requestPermissions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-    var _a;
-    return __awaiter(this, void 0, void 0, function* () {
-      if (((_a = DeviceManager.userMediaPromiseMap) === null || _a === void 0 ? void 0 : _a.size) > 0) {
-        livekitLogger.debug('awaiting getUserMedia promise');
-        try {
-          if (kind) {
-            yield DeviceManager.userMediaPromiseMap.get(kind);
-          } else {
-            yield Promise.all(DeviceManager.userMediaPromiseMap.values());
-          }
-        } catch (e) {
-          livekitLogger.warn('error waiting for media permissons');
-        }
-      }
-      let devices = yield navigator.mediaDevices.enumerateDevices();
-      if (requestPermissions && kind && (
-      // for safari we need to skip this check, as otherwise it will re-acquire user media and fail on iOS https://bugs.webkit.org/show_bug.cgi?id=179363
-      !DeviceManager.userMediaPromiseMap.get(kind) || !isSafari())) {
-        const isDummyDeviceOrEmpty = devices.length === 0 || devices.some(device => {
-          const noLabel = device.label === '';
-          const isRelevant = kind ? device.kind === kind : true;
-          return noLabel && isRelevant;
-        });
-        if (isDummyDeviceOrEmpty) {
-          const permissionsToAcquire = {
-            video: kind !== 'audioinput' && kind !== 'audiooutput',
-            audio: kind !== 'videoinput'
-          };
-          const stream = yield navigator.mediaDevices.getUserMedia(permissionsToAcquire);
-          devices = yield navigator.mediaDevices.enumerateDevices();
-          stream.getTracks().forEach(track => {
-            track.stop();
-          });
-        }
-      }
-      if (kind) {
-        devices = devices.filter(device => device.kind === kind);
-      }
-      return devices;
-    });
+class VideoPreset {
+  constructor(width, height, maxBitrate, maxFramerate, priority) {
+    this.width = width;
+    this.height = height;
+    this.encoding = {
+      maxBitrate,
+      maxFramerate,
+      priority
+    };
   }
-  normalizeDeviceId(kind, deviceId, groupId) {
-    return __awaiter(this, void 0, void 0, function* () {
-      if (deviceId !== defaultId) {
-        return deviceId;
-      }
-      // resolve actual device id if it's 'default': Chrome returns it when no
-      // device has been chosen
-      const devices = yield this.getDevices(kind);
-      const device = devices.find(d => d.groupId === groupId && d.deviceId !== defaultId);
-      return device === null || device === void 0 ? void 0 : device.deviceId;
-    });
+  get resolution() {
+    return {
+      width: this.width,
+      height: this.height,
+      frameRate: this.encoding.maxFramerate,
+      aspectRatio: this.width / this.height
+    };
   }
 }
-DeviceManager.mediaDeviceKinds = ['audioinput', 'audiooutput', 'videoinput'];
-DeviceManager.userMediaPromiseMap = new Map();
+const backupCodecs = ['vp8', 'h264'];
+const videoCodecs = ['vp8', 'h264', 'vp9', 'av1'];
+function isBackupCodec(codec) {
+  return !!backupCodecs.find(backup => backup === codec);
+}
+function isCodecEqual(c1, c2) {
+  return (c1 === null || c1 === void 0 ? void 0 : c1.toLowerCase().replace(/audio\/|video\//y, '')) === (c2 === null || c2 === void 0 ? void 0 : c2.toLowerCase().replace(/audio\/|video\//y, ''));
+}
+var AudioPresets;
+(function (AudioPresets) {
+  AudioPresets.telephone = {
+    maxBitrate: 12000
+  };
+  AudioPresets.speech = {
+    maxBitrate: 20000
+  };
+  AudioPresets.music = {
+    maxBitrate: 32000
+  };
+  AudioPresets.musicStereo = {
+    maxBitrate: 48000
+  };
+  AudioPresets.musicHighQuality = {
+    maxBitrate: 64000
+  };
+  AudioPresets.musicHighQualityStereo = {
+    maxBitrate: 96000
+  };
+})(AudioPresets || (AudioPresets = {}));
+/**
+ * Sane presets for video resolution/encoding
+ */
+const VideoPresets = {
+  h90: new VideoPreset(160, 90, 60000, 15),
+  h180: new VideoPreset(320, 180, 120000, 15),
+  h216: new VideoPreset(384, 216, 180000, 15),
+  h360: new VideoPreset(640, 360, 300000, 20),
+  h540: new VideoPreset(960, 540, 600000, 25),
+  h720: new VideoPreset(1280, 720, 1700000, 30),
+  h1080: new VideoPreset(1920, 1080, 3000000, 30),
+  h1440: new VideoPreset(2560, 1440, 5000000, 30),
+  h2160: new VideoPreset(3840, 2160, 8000000, 30)
+};
+/**
+ * Four by three presets
+ */
+const VideoPresets43 = {
+  h120: new VideoPreset(160, 120, 80000, 15),
+  h180: new VideoPreset(240, 180, 100000, 15),
+  h240: new VideoPreset(320, 240, 150000, 15),
+  h360: new VideoPreset(480, 360, 225000, 20),
+  h480: new VideoPreset(640, 480, 300000, 20),
+  h540: new VideoPreset(720, 540, 450000, 25),
+  h720: new VideoPreset(960, 720, 1500000, 30),
+  h1080: new VideoPreset(1440, 1080, 2500000, 30),
+  h1440: new VideoPreset(1920, 1440, 3500000, 30)
+};
+const ScreenSharePresets = {
+  h360fps3: new VideoPreset(640, 360, 200000, 3, 'medium'),
+  h720fps5: new VideoPreset(1280, 720, 400000, 5, 'medium'),
+  h720fps15: new VideoPreset(1280, 720, 1000000, 15, 'medium'),
+  h1080fps15: new VideoPreset(1920, 1080, 1500000, 15, 'medium'),
+  h1080fps30: new VideoPreset(1920, 1080, 3000000, 30, 'medium')
+};
 
 /**
  * Events are the primary way LiveKit notifies your application of changes.
@@ -14501,6 +14526,8 @@ var RoomEvent;
    * args: (isRecording: boolean)
    */
   RoomEvent["RecordingStatusChanged"] = "recordingStatusChanged";
+  RoomEvent["ParticipantEncryptionStatusChanged"] = "participantEncryptionStatusChanged";
+  RoomEvent["EncryptionError"] = "encryptionError";
   /**
    * Emits whenever the current buffer status of a data channel changes
    * args: (isLow: boolean, kind: [[DataPacket_Kind]])
@@ -14652,6 +14679,8 @@ var ParticipantEvent;
    * args: (prevPermissions: [[ParticipantPermission]])
    */
   ParticipantEvent["ParticipantPermissionsChanged"] = "participantPermissionsChanged";
+  /** @internal */
+  ParticipantEvent["PCTrackAdded"] = "pcTrackAdded";
 })(ParticipantEvent || (ParticipantEvent = {}));
 /** @internal */
 var EngineEvent;
@@ -14669,7 +14698,15 @@ var EngineEvent;
   EngineEvent["MediaTrackAdded"] = "mediaTrackAdded";
   EngineEvent["ActiveSpeakersUpdate"] = "activeSpeakersUpdate";
   EngineEvent["DataPacketReceived"] = "dataPacketReceived";
+  EngineEvent["RTPVideoMapUpdate"] = "rtpVideoMapUpdate";
   EngineEvent["DCBufferStatusChanged"] = "dcBufferStatusChanged";
+  EngineEvent["ParticipantUpdate"] = "participantUpdate";
+  EngineEvent["RoomUpdate"] = "roomUpdate";
+  EngineEvent["SpeakersChanged"] = "speakersChanged";
+  EngineEvent["StreamStateChanged"] = "streamStateChanged";
+  EngineEvent["ConnectionQualityUpdate"] = "connectionQualityUpdate";
+  EngineEvent["SubscriptionError"] = "subscriptionError";
+  EngineEvent["SubscriptionPermissionUpdate"] = "subscriptionPermissionUpdate";
 })(EngineEvent || (EngineEvent = {}));
 var TrackEvent;
 (function (TrackEvent) {
@@ -15063,387 +15100,16 @@ function detachTrack(track, element) {
   Track.streamStateFromProto = streamStateFromProto;
 })(Track || (Track = {}));
 
-const defaultDimensionsTimeout = 1000;
-class LocalTrack extends Track {
-  /**
-   *
-   * @param mediaTrack
-   * @param kind
-   * @param constraints MediaTrackConstraints that are being used when restarting or reacquiring tracks
-   * @param userProvidedTrack Signals to the SDK whether or not the mediaTrack should be managed (i.e. released and reacquired) internally by the SDK
-   */
-  constructor(mediaTrack, kind, constraints) {
-    let userProvidedTrack = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-    super(mediaTrack, kind);
-    this.isSettingUpProcessor = false;
-    this._isUpstreamPaused = false;
-    this.handleEnded = () => {
-      if (this.isInBackground) {
-        this.reacquireTrack = true;
-      }
-      this._mediaStreamTrack.removeEventListener('mute', this.pauseUpstream);
-      this._mediaStreamTrack.removeEventListener('unmute', this.resumeUpstream);
-      this.emit(TrackEvent.Ended, this);
-    };
-    /**
-     * pauses publishing to the server without disabling the local MediaStreamTrack
-     * this is used to display a user's own video locally while pausing publishing to
-     * the server.
-     * this API is unsupported on Safari < 12 due to a bug
-     **/
-    this.pauseUpstream = () => __awaiter(this, void 0, void 0, function* () {
-      const unlock = yield this.pauseUpstreamLock.lock();
-      try {
-        if (this._isUpstreamPaused === true) {
-          return;
-        }
-        if (!this.sender) {
-          livekitLogger.warn('unable to pause upstream for an unpublished track');
-          return;
-        }
-        this._isUpstreamPaused = true;
-        this.emit(TrackEvent.UpstreamPaused, this);
-        const browser = getBrowser();
-        if ((browser === null || browser === void 0 ? void 0 : browser.name) === 'Safari' && compareVersions(browser.version, '12.0') < 0) {
-          // https://bugs.webkit.org/show_bug.cgi?id=184911
-          throw new DeviceUnsupportedError('pauseUpstream is not supported on Safari < 12.');
-        }
-        yield this.sender.replaceTrack(null);
-      } finally {
-        unlock();
-      }
-    });
-    this.resumeUpstream = () => __awaiter(this, void 0, void 0, function* () {
-      const unlock = yield this.pauseUpstreamLock.lock();
-      try {
-        if (this._isUpstreamPaused === false) {
-          return;
-        }
-        if (!this.sender) {
-          livekitLogger.warn('unable to resume upstream for an unpublished track');
-          return;
-        }
-        this._isUpstreamPaused = false;
-        this.emit(TrackEvent.UpstreamResumed, this);
-        // this operation is noop if mediastreamtrack is already being sent
-        yield this.sender.replaceTrack(this._mediaStreamTrack);
-      } finally {
-        unlock();
-      }
-    });
-    this.reacquireTrack = false;
-    this.providedByUser = userProvidedTrack;
-    this.muteLock = new Mutex();
-    this.pauseUpstreamLock = new Mutex();
-    // added to satisfy TS compiler, constraints are synced with MediaStreamTrack
-    this.constraints = mediaTrack.getConstraints();
-    this.setMediaStreamTrack(mediaTrack);
-    if (constraints) {
-      this.constraints = constraints;
-    }
-  }
-  get id() {
-    return this._mediaStreamTrack.id;
-  }
-  get dimensions() {
-    if (this.kind !== Track.Kind.Video) {
-      return undefined;
-    }
-    const {
-      width,
-      height
-    } = this._mediaStreamTrack.getSettings();
-    if (width && height) {
-      return {
-        width,
-        height
-      };
-    }
-    return undefined;
-  }
-  get isUpstreamPaused() {
-    return this._isUpstreamPaused;
+function mergeDefaultOptions(options, audioDefaults, videoDefaults) {
+  const opts = Object.assign({}, options);
+  if (opts.audio === true) opts.audio = {};
+  if (opts.video === true) opts.video = {};
+  // use defaults
+  if (opts.audio) {
+    mergeObjectWithoutOverwriting(opts.audio, audioDefaults);
   }
-  get isUserProvided() {
-    return this.providedByUser;
-  }
-  get mediaStreamTrack() {
-    var _a, _b;
-    return (_b = (_a = this.processor) === null || _a === void 0 ? void 0 : _a.processedTrack) !== null && _b !== void 0 ? _b : this._mediaStreamTrack;
-  }
-  setMediaStreamTrack(newTrack) {
-    return __awaiter(this, void 0, void 0, function* () {
-      if (newTrack === this._mediaStreamTrack) {
-        return;
-      }
-      if (this._mediaStreamTrack) {
-        // detach
-        this.attachedElements.forEach(el => {
-          detachTrack(this._mediaStreamTrack, el);
-        });
-        this._mediaStreamTrack.removeEventListener('ended', this.handleEnded);
-        this._mediaStreamTrack.removeEventListener('mute', this.pauseUpstream);
-        this._mediaStreamTrack.removeEventListener('unmute', this.resumeUpstream);
-        if (!this.providedByUser) {
-          this._mediaStreamTrack.stop();
-        }
-      }
-      this.mediaStream = new MediaStream([newTrack]);
-      if (newTrack) {
-        newTrack.addEventListener('ended', this.handleEnded);
-        // when underlying track emits mute, it indicates that the device is unable
-        // to produce media. In this case we'll need to signal with remote that
-        // the track is "muted"
-        // note this is different from LocalTrack.mute because we do not want to
-        // touch MediaStreamTrack.enabled
-        newTrack.addEventListener('mute', this.pauseUpstream);
-        newTrack.addEventListener('unmute', this.resumeUpstream);
-        this.constraints = newTrack.getConstraints();
-      }
-      if (this.sender) {
-        yield this.sender.replaceTrack(newTrack);
-      }
-      this._mediaStreamTrack = newTrack;
-      if (newTrack) {
-        // sync muted state with the enabled state of the newly provided track
-        this._mediaStreamTrack.enabled = !this.isMuted;
-        // when a valid track is replace, we'd want to start producing
-        yield this.resumeUpstream();
-        this.attachedElements.forEach(el => {
-          attachToElement(newTrack, el);
-        });
-      }
-    });
-  }
-  waitForDimensions() {
-    let timeout = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultDimensionsTimeout;
-    return __awaiter(this, void 0, void 0, function* () {
-      if (this.kind === Track.Kind.Audio) {
-        throw new Error('cannot get dimensions for audio tracks');
-      }
-      const started = Date.now();
-      while (Date.now() - started < timeout) {
-        const dims = this.dimensions;
-        if (dims) {
-          return dims;
-        }
-        yield sleep(50);
-      }
-      throw new TrackInvalidError('unable to get track dimensions after timeout');
-    });
-  }
-  /**
-   * @returns DeviceID of the device that is currently being used for this track
-   */
-  getDeviceId() {
-    return __awaiter(this, void 0, void 0, function* () {
-      // screen share doesn't have a usable device id
-      if (this.source === Track.Source.ScreenShare) {
-        return;
-      }
-      const {
-        deviceId,
-        groupId
-      } = this._mediaStreamTrack.getSettings();
-      const kind = this.kind === Track.Kind.Audio ? 'audioinput' : 'videoinput';
-      return DeviceManager.getInstance().normalizeDeviceId(kind, deviceId, groupId);
-    });
-  }
-  mute() {
-    return __awaiter(this, void 0, void 0, function* () {
-      this.setTrackMuted(true);
-      return this;
-    });
-  }
-  unmute() {
-    return __awaiter(this, void 0, void 0, function* () {
-      this.setTrackMuted(false);
-      return this;
-    });
-  }
-  replaceTrack(track) {
-    let userProvidedTrack = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-    return __awaiter(this, void 0, void 0, function* () {
-      if (!this.sender) {
-        throw new TrackInvalidError('unable to replace an unpublished track');
-      }
-      livekitLogger.debug('replace MediaStreamTrack');
-      yield this.setMediaStreamTrack(track);
-      // this must be synced *after* setting mediaStreamTrack above, since it relies
-      // on the previous state in order to cleanup
-      this.providedByUser = userProvidedTrack;
-      if (this.processor) {
-        yield this.stopProcessor();
-      }
-      return this;
-    });
-  }
-  restart(constraints) {
-    return __awaiter(this, void 0, void 0, function* () {
-      if (!constraints) {
-        constraints = this.constraints;
-      }
-      livekitLogger.debug('restarting track with constraints', constraints);
-      const streamConstraints = {
-        audio: false,
-        video: false
-      };
-      if (this.kind === Track.Kind.Video) {
-        streamConstraints.video = constraints;
-      } else {
-        streamConstraints.audio = constraints;
-      }
-      // these steps are duplicated from setMediaStreamTrack because we must stop
-      // the previous tracks before new tracks can be acquired
-      this.attachedElements.forEach(el => {
-        detachTrack(this.mediaStreamTrack, el);
-      });
-      this._mediaStreamTrack.removeEventListener('ended', this.handleEnded);
-      // on Safari, the old audio track must be stopped before attempting to acquire
-      // the new track, otherwise the new track will stop with
-      // 'A MediaStreamTrack ended due to a capture failure`
-      this._mediaStreamTrack.stop();
-      // create new track and attach
-      const mediaStream = yield navigator.mediaDevices.getUserMedia(streamConstraints);
-      const newTrack = mediaStream.getTracks()[0];
-      newTrack.addEventListener('ended', this.handleEnded);
-      livekitLogger.debug('re-acquired MediaStreamTrack');
-      yield this.setMediaStreamTrack(newTrack);
-      this.constraints = constraints;
-      if (this.processor) {
-        const processor = this.processor;
-        yield this.setProcessor(processor);
-      } else {
-        this.attachedElements.forEach(el => {
-          attachToElement(this._mediaStreamTrack, el);
-        });
-      }
-      this.emit(TrackEvent.Restarted, this);
-      return this;
-    });
-  }
-  setTrackMuted(muted) {
-    livekitLogger.debug("setting ".concat(this.kind, " track ").concat(muted ? 'muted' : 'unmuted'));
-    if (this.isMuted === muted && this._mediaStreamTrack.enabled !== muted) {
-      return;
-    }
-    this.isMuted = muted;
-    this._mediaStreamTrack.enabled = !muted;
-    this.emit(muted ? TrackEvent.Muted : TrackEvent.Unmuted, this);
-  }
-  get needsReAcquisition() {
-    return this._mediaStreamTrack.readyState !== 'live' || this._mediaStreamTrack.muted || !this._mediaStreamTrack.enabled || this.reacquireTrack;
-  }
-  handleAppVisibilityChanged() {
-    const _super = Object.create(null, {
-      handleAppVisibilityChanged: {
-        get: () => super.handleAppVisibilityChanged
-      }
-    });
-    return __awaiter(this, void 0, void 0, function* () {
-      yield _super.handleAppVisibilityChanged.call(this);
-      if (!isMobile()) return;
-      livekitLogger.debug("visibility changed, is in Background: ".concat(this.isInBackground));
-      if (!this.isInBackground && this.needsReAcquisition && !this.isUserProvided && !this.isMuted) {
-        livekitLogger.debug("track needs to be reaquired, restarting ".concat(this.source));
-        yield this.restart();
-        this.reacquireTrack = false;
-      }
-    });
-  }
-  stop() {
-    var _a;
-    super.stop();
-    this._mediaStreamTrack.removeEventListener('ended', this.handleEnded);
-    this._mediaStreamTrack.removeEventListener('mute', this.pauseUpstream);
-    this._mediaStreamTrack.removeEventListener('unmute', this.resumeUpstream);
-    (_a = this.processor) === null || _a === void 0 ? void 0 : _a.destroy();
-    this.processor = undefined;
-  }
-  /**
-   * Sets a processor on this track.
-   * See https://github.com/livekit/track-processors-js for example usage
-   *
-   * @experimental
-   *
-   * @param processor
-   * @param showProcessedStreamLocally
-   * @returns
-   */
-  setProcessor(processor) {
-    let showProcessedStreamLocally = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-    var _a, _b;
-    return __awaiter(this, void 0, void 0, function* () {
-      if (this.isSettingUpProcessor) {
-        livekitLogger.warn('already trying to set up a processor');
-        return;
-      }
-      livekitLogger.debug('setting up processor');
-      this.isSettingUpProcessor = true;
-      if (this.processor) {
-        yield this.stopProcessor();
-      }
-      if (this.kind === 'unknown') {
-        throw TypeError('cannot set processor on track of unknown kind');
-      }
-      this.processorElement = (_a = this.processorElement) !== null && _a !== void 0 ? _a : document.createElement(this.kind);
-      this.processorElement.muted = true;
-      attachToElement(this._mediaStreamTrack, this.processorElement);
-      this.processorElement.play().catch(e => livekitLogger.error(e));
-      const processorOptions = {
-        kind: this.kind,
-        track: this._mediaStreamTrack,
-        element: this.processorElement
-      };
-      yield processor.init(processorOptions);
-      this.processor = processor;
-      if (this.processor.processedTrack) {
-        for (const el of this.attachedElements) {
-          if (el !== this.processorElement && showProcessedStreamLocally) {
-            detachTrack(this._mediaStreamTrack, el);
-            attachToElement(this.processor.processedTrack, el);
-          }
-        }
-        yield (_b = this.sender) === null || _b === void 0 ? void 0 : _b.replaceTrack(this.processor.processedTrack);
-      }
-      this.isSettingUpProcessor = false;
-    });
-  }
-  getProcessor() {
-    return this.processor;
-  }
-  /**
-   * Stops the track processor
-   * See https://github.com/livekit/track-processors-js for example usage
-   *
-   * @experimental
-   * @returns
-   */
-  stopProcessor() {
-    var _a, _b;
-    return __awaiter(this, void 0, void 0, function* () {
-      if (!this.processor) return;
-      livekitLogger.debug('stopping processor');
-      (_a = this.processor.processedTrack) === null || _a === void 0 ? void 0 : _a.stop();
-      yield this.processor.destroy();
-      this.processor = undefined;
-      (_b = this.processorElement) === null || _b === void 0 ? void 0 : _b.remove();
-      this.processorElement = undefined;
-      yield this.restart();
-    });
-  }
-}
-
-function mergeDefaultOptions(options, audioDefaults, videoDefaults) {
-  const opts = Object.assign({}, options);
-  if (opts.audio === true) opts.audio = {};
-  if (opts.video === true) opts.video = {};
-  // use defaults
-  if (opts.audio) {
-    mergeObjectWithoutOverwriting(opts.audio, audioDefaults);
-  }
-  if (opts.video) {
-    mergeObjectWithoutOverwriting(opts.video, videoDefaults);
+  if (opts.video) {
+    mergeObjectWithoutOverwriting(opts.video, videoDefaults);
   }
   return opts;
 }
@@ -15526,6 +15192,18 @@ function getNewAudioContext() {
     });
   }
 }
+/**
+ * @internal
+ */
+function sourceToKind(source) {
+  if (source === Track.Source.Microphone) {
+    return 'audioinput';
+  } else if (source === Track.Source.Camera) {
+    return 'videoinput';
+  } else {
+    return undefined;
+  }
+}
 
 const separator = '|';
 const ddExtensionURI = 'https://aomediacodec.github.io/av1-rtp-spec/#dependency-descriptor-rtp-header-extension';
@@ -15878,6 +15556,9 @@ class Mutex {
     return willUnlock;
   }
 }
+function isVideoCodec(maybeCodec) {
+  return videoCodecs.includes(maybeCodec);
+}
 function unwrapConstraint(constraint) {
   if (typeof constraint === 'string') {
     return constraint;
@@ -15957,6 +15638,20 @@ class SignalClient {
     let useJSON = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
     /** signal rtt in milliseconds */
     this.rtt = 0;
+    /** @internal */
+    this.resetCallbacks = () => {
+      this.onAnswer = undefined;
+      this.onLeave = undefined;
+      this.onLocalTrackPublished = undefined;
+      this.onLocalTrackUnpublished = undefined;
+      this.onNegotiateRequested = undefined;
+      this.onOffer = undefined;
+      this.onRemoteMuteChanged = undefined;
+      this.onSubscribedQualityUpdate = undefined;
+      this.onTokenRefresh = undefined;
+      this.onTrickle = undefined;
+      this.onClose = undefined;
+    };
     this.isConnected = false;
     this.isReconnecting = false;
     this.useJSON = useJSON;
@@ -16102,15 +15797,17 @@ class SignalClient {
       try {
         this.isConnected = false;
         if (this.ws) {
-          this.ws.onclose = null;
           this.ws.onmessage = null;
           this.ws.onopen = null;
+          this.ws.onclose = null;
           // calling `ws.close()` only starts the closing handshake (CLOSING state), prefer to wait until state is actually CLOSED
           const closePromise = new Promise(resolve => {
             if (this.ws) {
-              this.ws.onclose = resolve;
+              this.ws.onclose = () => {
+                resolve();
+              };
             } else {
-              resolve(true);
+              resolve();
             }
           });
           if (this.ws.readyState < this.ws.CLOSING) {
@@ -16119,9 +15816,9 @@ class SignalClient {
             yield Promise.race([closePromise, sleep(250)]);
           }
           this.ws = undefined;
-          this.clearPingInterval();
         }
       } finally {
+        this.clearPingInterval();
         unlock();
       }
     });
@@ -16164,7 +15861,7 @@ class SignalClient {
   sendAddTrack(req) {
     return this.sendRequest({
       $case: 'addTrack',
-      addTrack: AddTrackRequest.fromPartial(req)
+      addTrack: req
     });
   }
   sendUpdateLocalMetadata(metadata, name) {
@@ -16374,10 +16071,11 @@ class SignalClient {
   handleOnClose(reason) {
     return __awaiter(this, void 0, void 0, function* () {
       if (!this.isConnected) return;
+      const onCloseCallback = this.onClose;
       yield this.close();
       livekitLogger.debug("websocket connection closed: ".concat(reason));
-      if (this.onClose) {
-        this.onClose(reason);
+      if (onCloseCallback) {
+        onCloseCallback(reason);
       }
     });
   }
@@ -16483,18 +16181,944 @@ function createConnectionParams(token, info, opts) {
   if (opts.publishOnly !== undefined) {
     params.set('publish', opts.publishOnly);
   }
-  if (opts.adaptiveStream) {
-    params.set('adaptive_stream', '1');
+  if (opts.adaptiveStream) {
+    params.set('adaptive_stream', '1');
+  }
+  if (opts.reconnectReason) {
+    params.set('reconnect_reason', opts.reconnectReason.toString());
+  }
+  // @ts-ignore
+  if ((_a = navigator.connection) === null || _a === void 0 ? void 0 : _a.type) {
+    // @ts-ignore
+    params.set('network', navigator.connection.type);
+  }
+  return "?".concat(params.toString());
+}
+
+const ENCRYPTION_ALGORITHM = 'AES-GCM';
+// flag set to indicate that e2ee has been setup for sender/receiver;
+const E2EE_FLAG = 'lk_e2ee';
+const SALT = 'LKFrameEncryptionKey';
+const KEY_PROVIDER_DEFAULTS = {
+  sharedKey: false,
+  ratchetSalt: SALT,
+  ratchetWindowSize: 8
+};
+
+function isE2EESupported() {
+  return isInsertableStreamSupported() || isScriptTransformSupported();
+}
+function isScriptTransformSupported() {
+  // @ts-ignore
+  return typeof window.RTCRtpScriptTransform !== 'undefined';
+}
+function isInsertableStreamSupported() {
+  return typeof window.RTCRtpSender !== 'undefined' &&
+  // @ts-ignore
+  typeof window.RTCRtpSender.prototype.createEncodedStreams !== 'undefined';
+}
+function isVideoFrame(frame) {
+  return 'type' in frame;
+}
+function importKey(keyBytes) {
+  let algorithm = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+    name: ENCRYPTION_ALGORITHM
+  };
+  let usage = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'encrypt';
+  return __awaiter(this, void 0, void 0, function* () {
+    // https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/importKey
+    return crypto.subtle.importKey('raw', keyBytes, algorithm, false, usage === 'derive' ? ['deriveBits', 'deriveKey'] : ['encrypt', 'decrypt']);
+  });
+}
+function createKeyMaterialFromString(password) {
+  return __awaiter(this, void 0, void 0, function* () {
+    let enc = new TextEncoder();
+    const keyMaterial = yield crypto.subtle.importKey('raw', enc.encode(password), {
+      name: 'PBKDF2'
+    }, false, ['deriveBits', 'deriveKey']);
+    return keyMaterial;
+  });
+}
+function getAlgoOptions(algorithmName, salt) {
+  const textEncoder = new TextEncoder();
+  const encodedSalt = textEncoder.encode(salt);
+  switch (algorithmName) {
+    case 'HKDF':
+      return {
+        name: 'HKDF',
+        salt: encodedSalt,
+        hash: 'SHA-256',
+        info: new ArrayBuffer(128)
+      };
+    case 'PBKDF2':
+      {
+        return {
+          name: 'PBKDF2',
+          salt: encodedSalt,
+          hash: 'SHA-256',
+          iterations: 100000
+        };
+      }
+    default:
+      throw new Error("algorithm ".concat(algorithmName, " is currently unsupported"));
+  }
+}
+/**
+ * Derives a set of keys from the master key.
+ * See https://tools.ietf.org/html/draft-omara-sframe-00#section-4.3.1
+ */
+function deriveKeys(material, salt) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const algorithmOptions = getAlgoOptions(material.algorithm.name, salt);
+    // https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/deriveKey#HKDF
+    // https://developer.mozilla.org/en-US/docs/Web/API/HkdfParams
+    const encryptionKey = yield crypto.subtle.deriveKey(algorithmOptions, material, {
+      name: ENCRYPTION_ALGORITHM,
+      length: 128
+    }, false, ['encrypt', 'decrypt']);
+    return {
+      material,
+      encryptionKey
+    };
+  });
+}
+function createE2EEKey() {
+  return window.crypto.getRandomValues(new Uint8Array(32));
+}
+function mimeTypeToVideoCodecString(mimeType) {
+  const codec = mimeType.split('/')[1].toLowerCase();
+  if (!videoCodecs.includes(codec)) {
+    throw Error("Video codec not supported: ".concat(codec));
+  }
+  return codec;
+}
+/**
+ * Ratchets a key. See
+ * https://tools.ietf.org/html/draft-omara-sframe-00#section-4.3.5.1
+ */
+function ratchet(material, salt) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const algorithmOptions = getAlgoOptions(material.algorithm.name, salt);
+    // https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/deriveBits
+    return crypto.subtle.deriveBits(algorithmOptions, material, 256);
+  });
+}
+
+/**
+ * @experimental
+ */
+class BaseKeyProvider extends EventEmitter {
+  constructor() {
+    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    super();
+    /**
+     * callback being invoked after a ratchet request has been performed on the local participant
+     * that surfaces the new key material.
+     * @param material
+     * @param keyIndex
+     */
+    this.onKeyRatcheted = (material, keyIndex) => {
+      console.debug('key ratcheted event received', material, keyIndex);
+    };
+    this.keyInfoMap = new Map();
+    this.options = Object.assign(Object.assign({}, KEY_PROVIDER_DEFAULTS), options);
+    this.on('keyRatcheted', this.onKeyRatcheted);
+  }
+  /**
+   * callback to invoke once a key has been set for a participant
+   * @param key
+   * @param participantId
+   * @param keyIndex
+   */
+  onSetEncryptionKey(key, participantId, keyIndex) {
+    const keyInfo = {
+      key,
+      participantId,
+      keyIndex
+    };
+    this.keyInfoMap.set("".concat(participantId !== null && participantId !== void 0 ? participantId : 'shared', "-").concat(keyIndex !== null && keyIndex !== void 0 ? keyIndex : 0), keyInfo);
+    this.emit('setKey', keyInfo);
+  }
+  getKeys() {
+    return Array.from(this.keyInfoMap.values());
+  }
+  getOptions() {
+    return this.options;
+  }
+  ratchetKey(participantId, keyIndex) {
+    this.emit('ratchetRequest', participantId, keyIndex);
+  }
+}
+/**
+ * A basic KeyProvider implementation intended for a single shared
+ * passphrase between all participants
+ * @experimental
+ */
+class ExternalE2EEKeyProvider extends BaseKeyProvider {
+  constructor() {
+    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const opts = Object.assign(Object.assign({}, options), {
+      sharedKey: true
+    });
+    super(opts);
+  }
+  /**
+   * Accepts a passphrase that's used to create the crypto keys
+   * @param key
+   */
+  setKey(key) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const derivedKey = yield createKeyMaterialFromString(key);
+      this.onSetEncryptionKey(derivedKey);
+    });
+  }
+}
+
+const EncryptionEvent = {
+  ParticipantEncryptionStatusChanged: 'participantEncryptionStatusChanged',
+  Error: 'encryptionError'
+};
+const CryptorEvent = {
+  Error: 'cryptorError'
+};
+
+const defaultId = 'default';
+class DeviceManager {
+  static getInstance() {
+    if (this.instance === undefined) {
+      this.instance = new DeviceManager();
+    }
+    return this.instance;
+  }
+  getDevices(kind) {
+    let requestPermissions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+      if (((_a = DeviceManager.userMediaPromiseMap) === null || _a === void 0 ? void 0 : _a.size) > 0) {
+        livekitLogger.debug('awaiting getUserMedia promise');
+        try {
+          if (kind) {
+            yield DeviceManager.userMediaPromiseMap.get(kind);
+          } else {
+            yield Promise.all(DeviceManager.userMediaPromiseMap.values());
+          }
+        } catch (e) {
+          livekitLogger.warn('error waiting for media permissons');
+        }
+      }
+      let devices = yield navigator.mediaDevices.enumerateDevices();
+      if (requestPermissions && kind && (
+      // for safari we need to skip this check, as otherwise it will re-acquire user media and fail on iOS https://bugs.webkit.org/show_bug.cgi?id=179363
+      !DeviceManager.userMediaPromiseMap.get(kind) || !isSafari())) {
+        const isDummyDeviceOrEmpty = devices.length === 0 || devices.some(device => {
+          const noLabel = device.label === '';
+          const isRelevant = kind ? device.kind === kind : true;
+          return noLabel && isRelevant;
+        });
+        if (isDummyDeviceOrEmpty) {
+          const permissionsToAcquire = {
+            video: kind !== 'audioinput' && kind !== 'audiooutput',
+            audio: kind !== 'videoinput'
+          };
+          const stream = yield navigator.mediaDevices.getUserMedia(permissionsToAcquire);
+          devices = yield navigator.mediaDevices.enumerateDevices();
+          stream.getTracks().forEach(track => {
+            track.stop();
+          });
+        }
+      }
+      if (kind) {
+        devices = devices.filter(device => device.kind === kind);
+      }
+      return devices;
+    });
+  }
+  normalizeDeviceId(kind, deviceId, groupId) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (deviceId !== defaultId) {
+        return deviceId;
+      }
+      // resolve actual device id if it's 'default': Chrome returns it when no
+      // device has been chosen
+      const devices = yield this.getDevices(kind);
+      const device = devices.find(d => d.groupId === groupId && d.deviceId !== defaultId);
+      return device === null || device === void 0 ? void 0 : device.deviceId;
+    });
+  }
+}
+DeviceManager.mediaDeviceKinds = ['audioinput', 'audiooutput', 'videoinput'];
+DeviceManager.userMediaPromiseMap = new Map();
+
+const defaultDimensionsTimeout = 1000;
+class LocalTrack extends Track {
+  get constraints() {
+    return this._constraints;
+  }
+  /**
+   *
+   * @param mediaTrack
+   * @param kind
+   * @param constraints MediaTrackConstraints that are being used when restarting or reacquiring tracks
+   * @param userProvidedTrack Signals to the SDK whether or not the mediaTrack should be managed (i.e. released and reacquired) internally by the SDK
+   */
+  constructor(mediaTrack, kind, constraints) {
+    let userProvidedTrack = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    super(mediaTrack, kind);
+    this._isUpstreamPaused = false;
+    this.handleEnded = () => {
+      if (this.isInBackground) {
+        this.reacquireTrack = true;
+      }
+      this._mediaStreamTrack.removeEventListener('mute', this.pauseUpstream);
+      this._mediaStreamTrack.removeEventListener('unmute', this.resumeUpstream);
+      this.emit(TrackEvent.Ended, this);
+    };
+    /**
+     * pauses publishing to the server without disabling the local MediaStreamTrack
+     * this is used to display a user's own video locally while pausing publishing to
+     * the server.
+     * this API is unsupported on Safari < 12 due to a bug
+     **/
+    this.pauseUpstream = () => __awaiter(this, void 0, void 0, function* () {
+      const unlock = yield this.pauseUpstreamLock.lock();
+      try {
+        if (this._isUpstreamPaused === true) {
+          return;
+        }
+        if (!this.sender) {
+          livekitLogger.warn('unable to pause upstream for an unpublished track');
+          return;
+        }
+        this._isUpstreamPaused = true;
+        this.emit(TrackEvent.UpstreamPaused, this);
+        const browser = getBrowser();
+        if ((browser === null || browser === void 0 ? void 0 : browser.name) === 'Safari' && compareVersions(browser.version, '12.0') < 0) {
+          // https://bugs.webkit.org/show_bug.cgi?id=184911
+          throw new DeviceUnsupportedError('pauseUpstream is not supported on Safari < 12.');
+        }
+        yield this.sender.replaceTrack(null);
+      } finally {
+        unlock();
+      }
+    });
+    this.resumeUpstream = () => __awaiter(this, void 0, void 0, function* () {
+      const unlock = yield this.pauseUpstreamLock.lock();
+      try {
+        if (this._isUpstreamPaused === false) {
+          return;
+        }
+        if (!this.sender) {
+          livekitLogger.warn('unable to resume upstream for an unpublished track');
+          return;
+        }
+        this._isUpstreamPaused = false;
+        this.emit(TrackEvent.UpstreamResumed, this);
+        // this operation is noop if mediastreamtrack is already being sent
+        yield this.sender.replaceTrack(this._mediaStreamTrack);
+      } finally {
+        unlock();
+      }
+    });
+    this.reacquireTrack = false;
+    this.providedByUser = userProvidedTrack;
+    this.muteLock = new Mutex();
+    this.pauseUpstreamLock = new Mutex();
+    this.processorLock = new Mutex();
+    this.setMediaStreamTrack(mediaTrack, true);
+    // added to satisfy TS compiler, constraints are synced with MediaStreamTrack
+    this._constraints = mediaTrack.getConstraints();
+    if (constraints) {
+      this._constraints = constraints;
+    }
+  }
+  get id() {
+    return this._mediaStreamTrack.id;
+  }
+  get dimensions() {
+    if (this.kind !== Track.Kind.Video) {
+      return undefined;
+    }
+    const {
+      width,
+      height
+    } = this._mediaStreamTrack.getSettings();
+    if (width && height) {
+      return {
+        width,
+        height
+      };
+    }
+    return undefined;
+  }
+  get isUpstreamPaused() {
+    return this._isUpstreamPaused;
+  }
+  get isUserProvided() {
+    return this.providedByUser;
+  }
+  get mediaStreamTrack() {
+    var _a, _b;
+    return (_b = (_a = this.processor) === null || _a === void 0 ? void 0 : _a.processedTrack) !== null && _b !== void 0 ? _b : this._mediaStreamTrack;
+  }
+  setMediaStreamTrack(newTrack, force) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (newTrack === this._mediaStreamTrack && !force) {
+        return;
+      }
+      if (this._mediaStreamTrack) {
+        // detach
+        this.attachedElements.forEach(el => {
+          detachTrack(this._mediaStreamTrack, el);
+        });
+        this._mediaStreamTrack.removeEventListener('ended', this.handleEnded);
+        this._mediaStreamTrack.removeEventListener('mute', this.pauseUpstream);
+        this._mediaStreamTrack.removeEventListener('unmute', this.resumeUpstream);
+        if (!this.providedByUser && this._mediaStreamTrack !== newTrack) {
+          this._mediaStreamTrack.stop();
+        }
+      }
+      this.mediaStream = new MediaStream([newTrack]);
+      if (newTrack) {
+        newTrack.addEventListener('ended', this.handleEnded);
+        // when underlying track emits mute, it indicates that the device is unable
+        // to produce media. In this case we'll need to signal with remote that
+        // the track is "muted"
+        // note this is different from LocalTrack.mute because we do not want to
+        // touch MediaStreamTrack.enabled
+        newTrack.addEventListener('mute', this.pauseUpstream);
+        newTrack.addEventListener('unmute', this.resumeUpstream);
+        this._constraints = newTrack.getConstraints();
+      }
+      if (this.sender) {
+        yield this.sender.replaceTrack(newTrack);
+      }
+      this._mediaStreamTrack = newTrack;
+      if (newTrack) {
+        // sync muted state with the enabled state of the newly provided track
+        this._mediaStreamTrack.enabled = !this.isMuted;
+        // when a valid track is replace, we'd want to start producing
+        yield this.resumeUpstream();
+        this.attachedElements.forEach(el => {
+          attachToElement(newTrack, el);
+        });
+      }
+    });
+  }
+  waitForDimensions() {
+    let timeout = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultDimensionsTimeout;
+    return __awaiter(this, void 0, void 0, function* () {
+      if (this.kind === Track.Kind.Audio) {
+        throw new Error('cannot get dimensions for audio tracks');
+      }
+      const started = Date.now();
+      while (Date.now() - started < timeout) {
+        const dims = this.dimensions;
+        if (dims) {
+          return dims;
+        }
+        yield sleep(50);
+      }
+      throw new TrackInvalidError('unable to get track dimensions after timeout');
+    });
+  }
+  /**
+   * @returns DeviceID of the device that is currently being used for this track
+   */
+  getDeviceId() {
+    return __awaiter(this, void 0, void 0, function* () {
+      // screen share doesn't have a usable device id
+      if (this.source === Track.Source.ScreenShare) {
+        return;
+      }
+      const {
+        deviceId,
+        groupId
+      } = this._mediaStreamTrack.getSettings();
+      const kind = this.kind === Track.Kind.Audio ? 'audioinput' : 'videoinput';
+      return DeviceManager.getInstance().normalizeDeviceId(kind, deviceId, groupId);
+    });
+  }
+  mute() {
+    return __awaiter(this, void 0, void 0, function* () {
+      this.setTrackMuted(true);
+      return this;
+    });
+  }
+  unmute() {
+    return __awaiter(this, void 0, void 0, function* () {
+      this.setTrackMuted(false);
+      return this;
+    });
+  }
+  replaceTrack(track) {
+    let userProvidedTrack = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!this.sender) {
+        throw new TrackInvalidError('unable to replace an unpublished track');
+      }
+      livekitLogger.debug('replace MediaStreamTrack');
+      yield this.setMediaStreamTrack(track);
+      // this must be synced *after* setting mediaStreamTrack above, since it relies
+      // on the previous state in order to cleanup
+      this.providedByUser = userProvidedTrack;
+      if (this.processor) {
+        yield this.stopProcessor();
+      }
+      return this;
+    });
+  }
+  restart(constraints) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!constraints) {
+        constraints = this._constraints;
+      }
+      livekitLogger.debug('restarting track with constraints', constraints);
+      const streamConstraints = {
+        audio: false,
+        video: false
+      };
+      if (this.kind === Track.Kind.Video) {
+        streamConstraints.video = constraints;
+      } else {
+        streamConstraints.audio = constraints;
+      }
+      // these steps are duplicated from setMediaStreamTrack because we must stop
+      // the previous tracks before new tracks can be acquired
+      this.attachedElements.forEach(el => {
+        detachTrack(this.mediaStreamTrack, el);
+      });
+      this._mediaStreamTrack.removeEventListener('ended', this.handleEnded);
+      // on Safari, the old audio track must be stopped before attempting to acquire
+      // the new track, otherwise the new track will stop with
+      // 'A MediaStreamTrack ended due to a capture failure`
+      this._mediaStreamTrack.stop();
+      // create new track and attach
+      const mediaStream = yield navigator.mediaDevices.getUserMedia(streamConstraints);
+      const newTrack = mediaStream.getTracks()[0];
+      newTrack.addEventListener('ended', this.handleEnded);
+      livekitLogger.debug('re-acquired MediaStreamTrack');
+      yield this.setMediaStreamTrack(newTrack);
+      this._constraints = constraints;
+      if (this.processor) {
+        const processor = this.processor;
+        yield this.setProcessor(processor);
+      } else {
+        this.attachedElements.forEach(el => {
+          attachToElement(this._mediaStreamTrack, el);
+        });
+      }
+      this.emit(TrackEvent.Restarted, this);
+      return this;
+    });
+  }
+  setTrackMuted(muted) {
+    livekitLogger.debug("setting ".concat(this.kind, " track ").concat(muted ? 'muted' : 'unmuted'));
+    if (this.isMuted === muted && this._mediaStreamTrack.enabled !== muted) {
+      return;
+    }
+    this.isMuted = muted;
+    this._mediaStreamTrack.enabled = !muted;
+    this.emit(muted ? TrackEvent.Muted : TrackEvent.Unmuted, this);
+  }
+  get needsReAcquisition() {
+    return this._mediaStreamTrack.readyState !== 'live' || this._mediaStreamTrack.muted || !this._mediaStreamTrack.enabled || this.reacquireTrack;
+  }
+  handleAppVisibilityChanged() {
+    const _super = Object.create(null, {
+      handleAppVisibilityChanged: {
+        get: () => super.handleAppVisibilityChanged
+      }
+    });
+    return __awaiter(this, void 0, void 0, function* () {
+      yield _super.handleAppVisibilityChanged.call(this);
+      if (!isMobile()) return;
+      livekitLogger.debug("visibility changed, is in Background: ".concat(this.isInBackground));
+      if (!this.isInBackground && this.needsReAcquisition && !this.isUserProvided && !this.isMuted) {
+        livekitLogger.debug("track needs to be reaquired, restarting ".concat(this.source));
+        yield this.restart();
+        this.reacquireTrack = false;
+      }
+    });
+  }
+  stop() {
+    var _a;
+    super.stop();
+    this._mediaStreamTrack.removeEventListener('ended', this.handleEnded);
+    this._mediaStreamTrack.removeEventListener('mute', this.pauseUpstream);
+    this._mediaStreamTrack.removeEventListener('unmute', this.resumeUpstream);
+    (_a = this.processor) === null || _a === void 0 ? void 0 : _a.destroy();
+    this.processor = undefined;
+  }
+  /**
+   * Sets a processor on this track.
+   * See https://github.com/livekit/track-processors-js for example usage
+   *
+   * @experimental
+   *
+   * @param processor
+   * @param showProcessedStreamLocally
+   * @returns
+   */
+  setProcessor(processor) {
+    let showProcessedStreamLocally = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+      const unlock = yield this.processorLock.lock();
+      try {
+        livekitLogger.debug('setting up processor');
+        if (this.processor) {
+          yield this.stopProcessor();
+        }
+        if (this.kind === 'unknown') {
+          throw TypeError('cannot set processor on track of unknown kind');
+        }
+        this.processorElement = (_a = this.processorElement) !== null && _a !== void 0 ? _a : document.createElement(this.kind);
+        this.processorElement.muted = true;
+        attachToElement(this._mediaStreamTrack, this.processorElement);
+        this.processorElement.play().catch(error => livekitLogger.error('failed to play processor element', {
+          error
+        }));
+        const processorOptions = {
+          kind: this.kind,
+          track: this._mediaStreamTrack,
+          element: this.processorElement
+        };
+        yield processor.init(processorOptions);
+        this.processor = processor;
+        if (this.processor.processedTrack) {
+          for (const el of this.attachedElements) {
+            if (el !== this.processorElement && showProcessedStreamLocally) {
+              detachTrack(this._mediaStreamTrack, el);
+              attachToElement(this.processor.processedTrack, el);
+            }
+          }
+          yield (_b = this.sender) === null || _b === void 0 ? void 0 : _b.replaceTrack(this.processor.processedTrack);
+        }
+      } finally {
+        unlock();
+      }
+    });
+  }
+  getProcessor() {
+    return this.processor;
+  }
+  /**
+   * Stops the track processor
+   * See https://github.com/livekit/track-processors-js for example usage
+   *
+   * @experimental
+   * @returns
+   */
+  stopProcessor() {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!this.processor) return;
+      livekitLogger.debug('stopping processor');
+      (_a = this.processor.processedTrack) === null || _a === void 0 ? void 0 : _a.stop();
+      yield this.processor.destroy();
+      this.processor = undefined;
+      (_b = this.processorElement) === null || _b === void 0 ? void 0 : _b.remove();
+      this.processorElement = undefined;
+      yield this.restart();
+    });
+  }
+}
+
+/**
+ * @experimental
+ */
+class E2EEManager extends EventEmitter {
+  get isEnabled() {
+    return this.encryptionEnabled;
+  }
+  constructor(options) {
+    super();
+    this.onWorkerMessage = ev => {
+      var _a, _b;
+      const {
+        kind,
+        data
+      } = ev.data;
+      switch (kind) {
+        case 'error':
+          console.error('error in worker', {
+            data
+          });
+          this.emit(EncryptionEvent.Error, data.error);
+          break;
+        case 'enable':
+          if (this.encryptionEnabled !== data.enabled && !data.participantId) {
+            this.emit(EncryptionEvent.ParticipantEncryptionStatusChanged, data.enabled, (_a = this.room) === null || _a === void 0 ? void 0 : _a.localParticipant);
+            this.encryptionEnabled = data.enabled;
+          } else if (data.participantId) {
+            const participant = (_b = this.room) === null || _b === void 0 ? void 0 : _b.getParticipantByIdentity(data.participantId);
+            this.emit(EncryptionEvent.ParticipantEncryptionStatusChanged, data.enabled, participant);
+          }
+          if (this.encryptionEnabled) {
+            this.keyProvider.getKeys().forEach(keyInfo => {
+              this.postKey(keyInfo);
+            });
+          }
+          break;
+        case 'ratchetKey':
+          this.keyProvider.emit('keyRatcheted', data.material, data.keyIndex);
+          break;
+      }
+    };
+    this.onWorkerError = ev => {
+      livekitLogger.error('e2ee worker encountered an error:', {
+        error: ev.error
+      });
+      this.emit(EncryptionEvent.Error, ev.error);
+    };
+    this.keyProvider = options.keyProvider;
+    this.worker = options.worker;
+    this.encryptionEnabled = false;
+  }
+  /**
+   * @internal
+   */
+  setup(room) {
+    if (!isE2EESupported()) {
+      throw new DeviceUnsupportedError('tried to setup end-to-end encryption on an unsupported browser');
+    }
+    livekitLogger.info('setting up e2ee');
+    if (room !== this.room) {
+      this.room = room;
+      this.setupEventListeners(room, this.keyProvider);
+      // this.worker = new Worker('');
+      const msg = {
+        kind: 'init',
+        data: {
+          keyProviderOptions: this.keyProvider.getOptions()
+        }
+      };
+      if (this.worker) {
+        livekitLogger.info("initializing worker", {
+          worker: this.worker
+        });
+        this.worker.onmessage = this.onWorkerMessage;
+        this.worker.onerror = this.onWorkerError;
+        this.worker.postMessage(msg);
+      }
+    }
+  }
+  /**
+   * @internal
+   */
+  setParticipantCryptorEnabled(enabled, participantId) {
+    return __awaiter(this, void 0, void 0, function* () {
+      livekitLogger.info("set e2ee to ".concat(enabled));
+      if (this.worker) {
+        const enableMsg = {
+          kind: 'enable',
+          data: {
+            enabled,
+            participantId
+          }
+        };
+        this.worker.postMessage(enableMsg);
+      } else {
+        throw new ReferenceError('failed to enable e2ee, worker is not ready');
+      }
+    });
+  }
+  setupEngine(engine) {
+    engine.on(EngineEvent.RTPVideoMapUpdate, rtpMap => {
+      this.postRTPMap(rtpMap);
+    });
+  }
+  setupEventListeners(room, keyProvider) {
+    room.on(RoomEvent.TrackPublished, (pub, participant) => this.setParticipantCryptorEnabled(pub.trackInfo.encryption !== Encryption_Type.NONE, participant.identity));
+    room.on(RoomEvent.ConnectionStateChanged, state => {
+      if (state === ConnectionState.Connected) {
+        room.participants.forEach(participant => {
+          participant.tracks.forEach(pub => {
+            this.setParticipantCryptorEnabled(pub.trackInfo.encryption !== Encryption_Type.NONE, participant.identity);
+          });
+        });
+      }
+    });
+    room.on(RoomEvent.TrackUnsubscribed, (track, _, participant) => {
+      var _a;
+      const msg = {
+        kind: 'removeTransform',
+        data: {
+          participantId: participant.identity,
+          trackId: track.mediaStreamID
+        }
+      };
+      (_a = this.worker) === null || _a === void 0 ? void 0 : _a.postMessage(msg);
+    });
+    room.on(RoomEvent.TrackSubscribed, (track, pub, participant) => {
+      this.setupE2EEReceiver(track, participant.identity, pub.trackInfo);
+    });
+    room.localParticipant.on(ParticipantEvent.LocalTrackPublished, publication => __awaiter(this, void 0, void 0, function* () {
+      this.setupE2EESender(publication.track, publication.track.sender, room.localParticipant.identity);
+    }));
+    keyProvider.on('setKey', keyInfo => this.postKey(keyInfo)).on('ratchetRequest', (participantId, keyIndex) => this.postRatchetRequest(participantId, keyIndex));
+  }
+  postRatchetRequest(participantId, keyIndex) {
+    if (!this.worker) {
+      throw Error('could not ratchet key, worker is missing');
+    }
+    const msg = {
+      kind: 'ratchetRequest',
+      data: {
+        participantId,
+        keyIndex
+      }
+    };
+    this.worker.postMessage(msg);
+  }
+  postKey(_ref) {
+    let {
+      key,
+      participantId,
+      keyIndex
+    } = _ref;
+    if (!this.worker) {
+      throw Error('could not set key, worker is missing');
+    }
+    const msg = {
+      kind: 'setKey',
+      data: {
+        participantId,
+        key,
+        keyIndex
+      }
+    };
+    this.worker.postMessage(msg);
+  }
+  postRTPMap(map) {
+    if (!this.worker) {
+      throw Error('could not post rtp map, worker is missing');
+    }
+    const msg = {
+      kind: 'setRTPMap',
+      data: {
+        map
+      }
+    };
+    this.worker.postMessage(msg);
+  }
+  setupE2EEReceiver(track, remoteId, trackInfo) {
+    if (!track.receiver) {
+      return;
+    }
+    if (!(trackInfo === null || trackInfo === void 0 ? void 0 : trackInfo.mimeType) || trackInfo.mimeType === '') {
+      throw new TypeError('MimeType missing from trackInfo, cannot set up E2EE cryptor');
+    }
+    this.handleReceiver(track.receiver, track.mediaStreamID, remoteId, track.kind === 'video' ? mimeTypeToVideoCodecString(trackInfo.mimeType) : undefined);
+  }
+  setupE2EESender(track, sender, localId) {
+    if (!(track instanceof LocalTrack) || !sender) {
+      if (!sender) livekitLogger.warn('early return because sender is not ready');
+      return;
+    }
+    this.handleSender(sender, track.mediaStreamID, localId, undefined);
   }
-  if (opts.reconnectReason) {
-    params.set('reconnect_reason', opts.reconnectReason.toString());
+  /**
+   * Handles the given {@code RTCRtpReceiver} by creating a {@code TransformStream} which will inject
+   * a frame decoder.
+   *
+   */
+  handleReceiver(receiver, trackId, participantId, codec) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!this.worker) {
+        return;
+      }
+      if (isScriptTransformSupported()) {
+        const options = {
+          kind: 'decode',
+          participantId,
+          trackId,
+          codec
+        };
+        // @ts-ignore
+        receiver.transform = new RTCRtpScriptTransform(this.worker, options);
+      } else {
+        if (E2EE_FLAG in receiver && codec) {
+          // only update codec
+          const msg = {
+            kind: 'updateCodec',
+            data: {
+              trackId,
+              codec,
+              participantId
+            }
+          };
+          this.worker.postMessage(msg);
+          return;
+        }
+        // @ts-ignore
+        let writable = receiver.writableStream;
+        // @ts-ignore
+        let readable = receiver.readableStream;
+        if (!writable || !readable) {
+          // @ts-ignore
+          const receiverStreams = receiver.createEncodedStreams();
+          // @ts-ignore
+          receiver.writableStream = receiverStreams.writable;
+          writable = receiverStreams.writable;
+          // @ts-ignore
+          receiver.readableStream = receiverStreams.readable;
+          readable = receiverStreams.readable;
+        }
+        const msg = {
+          kind: 'decode',
+          data: {
+            readableStream: readable,
+            writableStream: writable,
+            trackId: trackId,
+            codec,
+            participantId
+          }
+        };
+        this.worker.postMessage(msg, [readable, writable]);
+      }
+      // @ts-ignore
+      receiver[E2EE_FLAG] = true;
+    });
   }
-  // @ts-ignore
-  if ((_a = navigator.connection) === null || _a === void 0 ? void 0 : _a.type) {
+  /**
+   * Handles the given {@code RTCRtpSender} by creating a {@code TransformStream} which will inject
+   * a frame encoder.
+   *
+   */
+  handleSender(sender, trackId, participantId, codec) {
+    if (E2EE_FLAG in sender || !this.worker) {
+      return;
+    }
+    if (isScriptTransformSupported()) {
+      livekitLogger.warn('initialize script transform');
+      const options = {
+        kind: 'encode',
+        participantId,
+        trackId,
+        codec
+      };
+      // @ts-ignore
+      sender.transform = new RTCRtpScriptTransform(this.worker, options);
+    } else {
+      livekitLogger.warn('initialize encoded streams');
+      // @ts-ignore
+      const senderStreams = sender.createEncodedStreams();
+      const msg = {
+        kind: 'encode',
+        data: {
+          readableStream: senderStreams.readable,
+          writableStream: senderStreams.writable,
+          codec,
+          trackId,
+          participantId
+        }
+      };
+      this.worker.postMessage(msg, [senderStreams.readable, senderStreams.writable]);
+    }
     // @ts-ignore
-    params.set('network', navigator.connection.type);
+    sender[E2EE_FLAG] = true;
   }
-  return "?".concat(params.toString());
 }
 
 var parser$1 = {};
@@ -17221,10 +17845,15 @@ eliminate this issue.
 const startBitrateForSVC = 0.7;
 const PCEvents = {
   NegotiationStarted: 'negotiationStarted',
-  NegotiationComplete: 'negotiationComplete'
+  NegotiationComplete: 'negotiationComplete',
+  RTPVideoPayloadTypes: 'rtpVideoPayloadTypes'
 };
 /** @internal */
 class PCTransport extends EventEmitter {
+  get pc() {
+    if (this._pc) return this._pc;
+    throw new UnexpectedConnectionState('Expected peer connection to be available');
+  }
   constructor(config) {
     let mediaConstraints = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     super();
@@ -17247,12 +17876,12 @@ class PCTransport extends EventEmitter {
         }
       }
     }, 100);
-    this.pc = isChromiumBased() ?
+    this._pc = isChromiumBased() ?
     // @ts-expect-error chrome allows additional media constraints to be passed into the RTCPeerConnection constructor
     new RTCPeerConnection(config, mediaConstraints) : new RTCPeerConnection(config);
   }
   get isICEConnected() {
-    return this.pc.iceConnectionState === 'connected' || this.pc.iceConnectionState === 'completed';
+    return this._pc !== null && (this.pc.iceConnectionState === 'connected' || this.pc.iceConnectionState === 'completed');
   }
   addIceCandidate(candidate) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -17329,6 +17958,14 @@ class PCTransport extends EventEmitter {
         this.createAndSendOffer();
       } else if (sd.type === 'answer') {
         this.emit(PCEvents.NegotiationComplete);
+        if (sd.sdp) {
+          const sdpParsed = parse(sd.sdp);
+          sdpParsed.media.forEach(media => {
+            if (media.type === 'video') {
+              this.emit(PCEvents.RTPVideoPayloadTypes, media.rtp);
+            }
+          });
+        }
       }
     });
   }
@@ -17342,7 +17979,7 @@ class PCTransport extends EventEmitter {
         livekitLogger.debug('restarting ICE');
         this.restartingIce = true;
       }
-      if (this.pc.signalingState === 'have-local-offer') {
+      if (this._pc && this._pc.signalingState === 'have-local-offer') {
         // we're waiting for the peer to accept our offer, so we'll just wait
         // the only exception to this is when ICE restart is needed
         const currentSD = this.pc.remoteDescription;
@@ -17354,7 +17991,7 @@ class PCTransport extends EventEmitter {
           this.renegotiate = true;
           return;
         }
-      } else if (this.pc.signalingState === 'closed') {
+      } else if (!this._pc || this._pc.signalingState === 'closed') {
         livekitLogger.warn('could not createOffer with closed peer connection');
         return;
       }
@@ -17428,9 +18065,22 @@ class PCTransport extends EventEmitter {
     this.trackBitrates.push(info);
   }
   close() {
-    this.pc.onconnectionstatechange = null;
-    this.pc.oniceconnectionstatechange = null;
-    this.pc.close();
+    if (!this._pc) {
+      return;
+    }
+    this._pc.close();
+    this._pc.onconnectionstatechange = null;
+    this._pc.oniceconnectionstatechange = null;
+    this._pc.onicegatheringstatechange = null;
+    this._pc.ondatachannel = null;
+    this._pc.onnegotiationneeded = null;
+    this._pc.onsignalingstatechange = null;
+    this._pc.onicecandidate = null;
+    this._pc.ondatachannel = null;
+    this._pc.ontrack = null;
+    this._pc.onconnectionstatechange = null;
+    this._pc.oniceconnectionstatechange = null;
+    this._pc = null;
   }
   setMungedSDP(sd, munged, remote) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -17620,89 +18270,6 @@ function getCloudConfigUrl(serverUrl) {
   return "".concat(serverUrl.protocol.replace('ws', 'http'), "//").concat(serverUrl.host, "/settings");
 }
 
-class VideoPreset {
-  constructor(width, height, maxBitrate, maxFramerate, priority) {
-    this.width = width;
-    this.height = height;
-    this.encoding = {
-      maxBitrate,
-      maxFramerate,
-      priority
-    };
-  }
-  get resolution() {
-    return {
-      width: this.width,
-      height: this.height,
-      frameRate: this.encoding.maxFramerate,
-      aspectRatio: this.width / this.height
-    };
-  }
-}
-const backupCodecs = ['vp8', 'h264'];
-function isBackupCodec(codec) {
-  return !!backupCodecs.find(backup => backup === codec);
-}
-function isCodecEqual(c1, c2) {
-  return (c1 === null || c1 === void 0 ? void 0 : c1.toLowerCase().replace(/audio\/|video\//y, '')) === (c2 === null || c2 === void 0 ? void 0 : c2.toLowerCase().replace(/audio\/|video\//y, ''));
-}
-var AudioPresets;
-(function (AudioPresets) {
-  AudioPresets.telephone = {
-    maxBitrate: 12000
-  };
-  AudioPresets.speech = {
-    maxBitrate: 20000
-  };
-  AudioPresets.music = {
-    maxBitrate: 32000
-  };
-  AudioPresets.musicStereo = {
-    maxBitrate: 48000
-  };
-  AudioPresets.musicHighQuality = {
-    maxBitrate: 64000
-  };
-  AudioPresets.musicHighQualityStereo = {
-    maxBitrate: 96000
-  };
-})(AudioPresets || (AudioPresets = {}));
-/**
- * Sane presets for video resolution/encoding
- */
-const VideoPresets = {
-  h90: new VideoPreset(160, 90, 60000, 15),
-  h180: new VideoPreset(320, 180, 120000, 15),
-  h216: new VideoPreset(384, 216, 180000, 15),
-  h360: new VideoPreset(640, 360, 300000, 20),
-  h540: new VideoPreset(960, 540, 600000, 25),
-  h720: new VideoPreset(1280, 720, 1700000, 30),
-  h1080: new VideoPreset(1920, 1080, 3000000, 30),
-  h1440: new VideoPreset(2560, 1440, 5000000, 30),
-  h2160: new VideoPreset(3840, 2160, 8000000, 30)
-};
-/**
- * Four by three presets
- */
-const VideoPresets43 = {
-  h120: new VideoPreset(160, 120, 80000, 15),
-  h180: new VideoPreset(240, 180, 100000, 15),
-  h240: new VideoPreset(320, 240, 150000, 15),
-  h360: new VideoPreset(480, 360, 225000, 20),
-  h480: new VideoPreset(640, 480, 300000, 20),
-  h540: new VideoPreset(720, 540, 450000, 25),
-  h720: new VideoPreset(960, 720, 1500000, 30),
-  h1080: new VideoPreset(1440, 1080, 2500000, 30),
-  h1440: new VideoPreset(1920, 1440, 3500000, 30)
-};
-const ScreenSharePresets = {
-  h360fps3: new VideoPreset(640, 360, 200000, 3, 'medium'),
-  h720fps5: new VideoPreset(1280, 720, 400000, 5, 'medium'),
-  h720fps15: new VideoPreset(1280, 720, 1000000, 15, 'medium'),
-  h1080fps15: new VideoPreset(1920, 1080, 1500000, 15, 'medium'),
-  h1080fps30: new VideoPreset(1920, 1080, 3000000, 30, 'medium')
-};
-
 const publishDefaults = {
   /**
    * @deprecated
@@ -17716,10 +18283,7 @@ const publishDefaults = {
   screenShareEncoding: ScreenSharePresets.h1080fps15.encoding,
   stopMicTrackOnMute: false,
   videoCodec: 'vp8',
-  backupCodec: {
-    codec: 'vp8',
-    encoding: VideoPresets.h540.encoding
-  }
+  backupCodec: false
 };
 const audioDefaults = {
   autoGainControl: true,
@@ -17924,6 +18488,13 @@ class RTCEngine extends EventEmitter {
     this.closingLock = new Mutex();
     this.dataProcessLock = new Mutex();
     this.dcBufferStatus = new Map([[DataPacket_Kind.LOSSY, true], [DataPacket_Kind.RELIABLE, true]]);
+    this.client.onParticipantUpdate = updates => this.emit(EngineEvent.ParticipantUpdate, updates);
+    this.client.onConnectionQuality = update => this.emit(EngineEvent.ConnectionQualityUpdate, update);
+    this.client.onRoomUpdate = update => this.emit(EngineEvent.RoomUpdate, update);
+    this.client.onSubscriptionError = resp => this.emit(EngineEvent.SubscriptionError, resp);
+    this.client.onSubscriptionPermissionUpdate = update => this.emit(EngineEvent.SubscriptionPermissionUpdate, update);
+    this.client.onSpeakersChanged = update => this.emit(EngineEvent.SpeakersChanged, update);
+    this.client.onStreamStateUpdate = update => this.emit(EngineEvent.StreamStateChanged, update);
   }
   join(url, token, opts, abortSignal) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -17943,6 +18514,7 @@ class RTCEngine extends EventEmitter {
         if (!this.subscriberPrimary) {
           this.negotiate();
         }
+        this.setupSignalClientCallbacks();
         this.clientConfiguration = joinResponse.clientConfiguration;
         return joinResponse;
       } catch (e) {
@@ -17971,33 +18543,65 @@ class RTCEngine extends EventEmitter {
         this.removeAllListeners();
         this.deregisterOnLineListener();
         this.clearPendingReconnect();
-        if (this.publisher && this.publisher.pc.signalingState !== 'closed') {
-          this.publisher.pc.getSenders().forEach(sender => {
-            var _a, _b;
-            try {
-              // TODO: react-native-webrtc doesn't have removeTrack yet.
-              if ((_a = this.publisher) === null || _a === void 0 ? void 0 : _a.pc.removeTrack) {
-                (_b = this.publisher) === null || _b === void 0 ? void 0 : _b.pc.removeTrack(sender);
-              }
-            } catch (e) {
-              livekitLogger.warn('could not removeTrack', {
-                error: e
-              });
-            }
-          });
-          this.publisher.close();
-          this.publisher = undefined;
-        }
-        if (this.subscriber) {
-          this.subscriber.close();
-          this.subscriber = undefined;
-        }
-        yield this.client.close();
+        yield this.cleanupPeerConnections();
+        yield this.cleanupClient();
       } finally {
         unlock();
       }
     });
   }
+  cleanupPeerConnections() {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (this.publisher && this.publisher.pc.signalingState !== 'closed') {
+        this.publisher.pc.getSenders().forEach(sender => {
+          var _a, _b;
+          try {
+            // TODO: react-native-webrtc doesn't have removeTrack yet.
+            if ((_a = this.publisher) === null || _a === void 0 ? void 0 : _a.pc.removeTrack) {
+              (_b = this.publisher) === null || _b === void 0 ? void 0 : _b.pc.removeTrack(sender);
+            }
+          } catch (e) {
+            livekitLogger.warn('could not removeTrack', {
+              error: e
+            });
+          }
+        });
+      }
+      if (this.publisher) {
+        this.publisher.close();
+        this.publisher = undefined;
+      }
+      if (this.subscriber) {
+        this.subscriber.close();
+        this.subscriber = undefined;
+      }
+      this.primaryPC = undefined;
+      const dcCleanup = dc => {
+        if (!dc) return;
+        dc.close();
+        dc.onbufferedamountlow = null;
+        dc.onclose = null;
+        dc.onclosing = null;
+        dc.onerror = null;
+        dc.onmessage = null;
+        dc.onopen = null;
+      };
+      dcCleanup(this.lossyDC);
+      dcCleanup(this.lossyDCSub);
+      dcCleanup(this.reliableDC);
+      dcCleanup(this.reliableDCSub);
+      this.lossyDC = undefined;
+      this.lossyDCSub = undefined;
+      this.reliableDC = undefined;
+      this.reliableDCSub = undefined;
+    });
+  }
+  cleanupClient() {
+    return __awaiter(this, void 0, void 0, function* () {
+      yield this.client.close();
+      this.client.resetCallbacks();
+    });
+  }
   addTrack(req) {
     if (this.pendingTrackResolvers[req.cid]) {
       throw new TrackInvalidError('a track with the same ID has already been published');
@@ -18064,13 +18668,19 @@ class RTCEngine extends EventEmitter {
     });
   }
   configure(joinResponse) {
-    var _a;
+    var _a, _b;
     // already configured
     if (this.publisher || this.subscriber) {
       return;
     }
     this.participantSid = (_a = joinResponse.participant) === null || _a === void 0 ? void 0 : _a.sid;
     const rtcConfig = this.makeRTCConfiguration(joinResponse);
+    if ((_b = this.signalOpts) === null || _b === void 0 ? void 0 : _b.e2eeEnabled) {
+      livekitLogger.debug('E2EE - setting up transports with insertable streams');
+      //  this makes sure that no data is sent before the transforms are ready
+      // @ts-ignore
+      rtcConfig.encodedInsertableStreams = true;
+    }
     const googConstraints = {
       optional: [{
         googDscp: true
@@ -18128,6 +18738,8 @@ class RTCEngine extends EventEmitter {
       this.emit(EngineEvent.MediaTrackAdded, ev.track, ev.streams[0], ev.receiver);
     };
     this.createDataChannels();
+  }
+  setupSignalClientCallbacks() {
     // configure signaling client
     this.client.onAnswer = sd => __awaiter(this, void 0, void 0, function* () {
       if (!this.publisher) {
@@ -18135,7 +18747,7 @@ class RTCEngine extends EventEmitter {
       }
       livekitLogger.debug('received server answer', {
         RTCSdpType: sd.type,
-        signalingState: this.publisher.pc.signalingState
+        signalingState: this.publisher.pc.signalingState.toString()
       });
       yield this.publisher.setRemoteDescription(sd);
     });
@@ -18161,7 +18773,7 @@ class RTCEngine extends EventEmitter {
       }
       livekitLogger.debug('received server offer', {
         RTCSdpType: sd.type,
-        signalingState: this.subscriber.pc.signalingState
+        signalingState: this.subscriber.pc.signalingState.toString()
       });
       yield this.subscriber.setRemoteDescription(sd);
       // answer the offer
@@ -18302,11 +18914,13 @@ class RTCEngine extends EventEmitter {
   createSender(track, opts, encodings) {
     return __awaiter(this, void 0, void 0, function* () {
       if (supportsTransceiver()) {
-        return this.createTransceiverRTCRtpSender(track, opts, encodings);
+        const sender = yield this.createTransceiverRTCRtpSender(track, opts, encodings);
+        return sender;
       }
       if (supportsAddTrack()) {
-        livekitLogger.debug('using add-track fallback');
-        return this.createRTCRtpSender(track.mediaStreamTrack);
+        livekitLogger.warn('using add-track fallback');
+        const sender = yield this.createRTCRtpSender(track.mediaStreamTrack);
+        return sender;
       }
       throw new UnexpectedConnectionState('Required webRTC APIs not supported on this device');
     });
@@ -18314,7 +18928,6 @@ class RTCEngine extends EventEmitter {
   createSimulcastSender(track, simulcastTrack, opts, encodings) {
     return __awaiter(this, void 0, void 0, function* () {
       // store RTCRtpSender
-      // @ts-ignore
       if (supportsTransceiver()) {
         return this.createSimulcastTransceiverSender(track, simulcastTrack, opts, encodings);
       }
@@ -18330,8 +18943,13 @@ class RTCEngine extends EventEmitter {
       if (!this.publisher) {
         throw new UnexpectedConnectionState('publisher is closed');
       }
+      const streams = [];
+      if (track.mediaStream) {
+        streams.push(track.mediaStream);
+      }
       const transceiverInit = {
-        direction: 'sendonly'
+        direction: 'sendonly',
+        streams
       };
       if (encodings) {
         transceiverInit.sendEncodings = encodings;
@@ -18413,7 +19031,7 @@ class RTCEngine extends EventEmitter {
           this.fullReconnectOnNext = true;
         }
         if (recoverable) {
-          this.handleDisconnect('reconnect', ReconnectReason.RR_UNKOWN);
+          this.handleDisconnect('reconnect', ReconnectReason.RR_UNKNOWN);
         } else {
           livekitLogger.info("could not recover connection after ".concat(this.reconnectAttempts, " attempts, ").concat(Date.now() - this.reconnectStart, "ms. giving up"));
           this.emit(EngineEvent.Disconnected);
@@ -18436,7 +19054,7 @@ class RTCEngine extends EventEmitter {
     return null;
   }
   restartConnection(regionUrl) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c;
     return __awaiter(this, void 0, void 0, function* () {
       try {
         if (!this.url || !this.token) {
@@ -18448,12 +19066,8 @@ class RTCEngine extends EventEmitter {
         if (this.client.isConnected) {
           yield this.client.sendLeave();
         }
-        yield this.client.close();
-        this.primaryPC = undefined;
-        (_a = this.publisher) === null || _a === void 0 ? void 0 : _a.close();
-        this.publisher = undefined;
-        (_b = this.subscriber) === null || _b === void 0 ? void 0 : _b.close();
-        this.subscriber = undefined;
+        yield this.cleanupPeerConnections();
+        yield this.cleanupClient();
         let joinResponse;
         try {
           if (!this.signalOpts) {
@@ -18475,17 +19089,17 @@ class RTCEngine extends EventEmitter {
         this.client.setReconnected();
         this.emit(EngineEvent.SignalRestarted, joinResponse);
         yield this.waitForPCReconnected();
-        (_c = this.regionUrlProvider) === null || _c === void 0 ? void 0 : _c.resetAttempts();
+        (_a = this.regionUrlProvider) === null || _a === void 0 ? void 0 : _a.resetAttempts();
         // reconnect success
         this.emit(EngineEvent.Restarted);
       } catch (error) {
-        const nextRegionUrl = yield (_d = this.regionUrlProvider) === null || _d === void 0 ? void 0 : _d.getNextBestRegionUrl();
+        const nextRegionUrl = yield (_b = this.regionUrlProvider) === null || _b === void 0 ? void 0 : _b.getNextBestRegionUrl();
         if (nextRegionUrl) {
           yield this.restartConnection(nextRegionUrl);
           return;
         } else {
           // no more regions to try (or we're not on cloud)
-          (_e = this.regionUrlProvider) === null || _e === void 0 ? void 0 : _e.resetAttempts();
+          (_c = this.regionUrlProvider) === null || _c === void 0 ? void 0 : _c.resetAttempts();
           throw error;
         }
       }
@@ -18505,6 +19119,7 @@ class RTCEngine extends EventEmitter {
       livekitLogger.info("resuming signal connection, attempt ".concat(this.reconnectAttempts));
       this.emit(EngineEvent.Resuming);
       try {
+        this.setupSignalClientCallbacks();
         const res = yield this.client.reconnect(this.url, this.token, this.participantSid, reason);
         if (res) {
           const rtcConfig = this.makeRTCConfiguration(res);
@@ -18692,6 +19307,9 @@ class RTCEngine extends EventEmitter {
         resolve();
         return;
       };
+      if (this.isClosed) {
+        reject('cannot negotiate on closed engine');
+      }
       this.on(EngineEvent.Closing, handleClosed);
       const negotiationTimeout = setTimeout(() => {
         reject('negotiation timed out');
@@ -18708,13 +19326,23 @@ class RTCEngine extends EventEmitter {
           resolve();
         });
       });
+      this.publisher.once(PCEvents.RTPVideoPayloadTypes, rtpTypes => {
+        const rtpMap = new Map();
+        rtpTypes.forEach(rtp => {
+          const codec = rtp.codec.toLowerCase();
+          if (isVideoCodec(codec)) {
+            rtpMap.set(rtp.payload, codec);
+          }
+        });
+        this.emit(EngineEvent.RTPVideoMapUpdate, rtpMap);
+      });
       this.publisher.negotiate(e => {
         cleanup();
         reject(e);
         if (e instanceof NegotiationError) {
           this.fullReconnectOnNext = true;
         }
-        this.handleDisconnect('negotiation', ReconnectReason.RR_UNKOWN);
+        this.handleDisconnect('negotiation', ReconnectReason.RR_UNKNOWN);
       });
     });
   }
@@ -18851,14 +19479,14 @@ class LocalAudioTrack extends LocalTrack {
   }
   setDeviceId(deviceId) {
     return __awaiter(this, void 0, void 0, function* () {
-      if (this.constraints.deviceId === deviceId) {
+      if (this._constraints.deviceId === deviceId) {
         return true;
       }
-      this.constraints.deviceId = deviceId;
+      this._constraints.deviceId = deviceId;
       if (!this.isMuted) {
         yield this.restartTrack();
       }
-      return unwrapConstraint(deviceId) === this.mediaStreamTrack.getSettings().deviceId;
+      return this.isMuted || unwrapConstraint(deviceId) === this.mediaStreamTrack.getSettings().deviceId;
     });
   }
   mute() {
@@ -18892,7 +19520,8 @@ class LocalAudioTrack extends LocalTrack {
     return __awaiter(this, void 0, void 0, function* () {
       const unlock = yield this.muteLock.lock();
       try {
-        if (this.source === Track.Source.Microphone && (this.stopOnMute || this._mediaStreamTrack.readyState === 'ended') && !this.isUserProvided) {
+        const deviceHasChanged = this._constraints.deviceId && this._mediaStreamTrack.getSettings().deviceId !== unwrapConstraint(this._constraints.deviceId);
+        if (this.source === Track.Source.Microphone && (this.stopOnMute || this._mediaStreamTrack.readyState === 'ended' || deviceHasChanged) && !this.isUserProvided) {
           livekitLogger.debug('reacquiring mic track');
           yield this.restartTrack();
         }
@@ -19447,16 +20076,16 @@ class LocalVideoTrack extends LocalTrack {
   }
   setDeviceId(deviceId) {
     return __awaiter(this, void 0, void 0, function* () {
-      if (this.constraints.deviceId === deviceId && this._mediaStreamTrack.getSettings().deviceId === unwrapConstraint(deviceId)) {
+      if (this._constraints.deviceId === deviceId && this._mediaStreamTrack.getSettings().deviceId === unwrapConstraint(deviceId)) {
         return true;
       }
-      this.constraints.deviceId = deviceId;
+      this._constraints.deviceId = deviceId;
       // when video is muted, underlying media stream track is stopped and
       // will be restarted later
       if (!this.isMuted) {
         yield this.restartTrack();
       }
-      return unwrapConstraint(deviceId) === this._mediaStreamTrack.getSettings().deviceId;
+      return this.isMuted || unwrapConstraint(deviceId) === this._mediaStreamTrack.getSettings().deviceId;
     });
   }
   restartTrack(options) {
@@ -20042,6 +20671,7 @@ class RemoteVideoTrack extends RemoteTrack {
     }
     this.elementInfos = this.elementInfos.filter(info => info !== elementInfo);
     this.updateVisibility();
+    this.debouncedHandleResize();
   }
   detach(element) {
     let detachedElements = [];
@@ -20094,9 +20724,8 @@ class RemoteVideoTrack extends RemoteTrack {
   stopObservingElement(element) {
     const stopElementInfos = this.elementInfos.filter(info => info.element === element);
     for (const info of stopElementInfos) {
-      info.stopObserving();
+      this.stopObservingElementInfo(info);
     }
-    this.elementInfos = this.elementInfos.filter(info => info.element !== element);
   }
   handleAppVisibilityChanged() {
     const _super = Object.create(null, {
@@ -20259,6 +20888,7 @@ class TrackPublication extends EventEmitter {
   constructor(kind, id, name) {
     super();
     this.metadataMuted = false;
+    this.encryption = Encryption_Type.NONE;
     this.handleMuted = () => {
       this.emit(TrackEvent.Muted);
     };
@@ -20292,6 +20922,9 @@ class TrackPublication extends EventEmitter {
   get isSubscribed() {
     return this.track !== undefined;
   }
+  get isEncrypted() {
+    return this.encryption !== Encryption_Type.NONE;
+  }
   /**
    * an [AudioTrack] if this publication holds an audio track
    */
@@ -20321,8 +20954,9 @@ class TrackPublication extends EventEmitter {
       };
       this.simulcasted = info.simulcast;
     }
+    this.encryption = info.encryption;
     this.trackInfo = info;
-    livekitLogger.trace('update publication info', {
+    livekitLogger.debug('update publication info', {
       info
     });
   }
@@ -20435,6 +21069,9 @@ function qualityFromProto(q) {
   }
 }
 class Participant extends EventEmitter {
+  get isEncrypted() {
+    return this.tracks.size > 0 && Array.from(this.tracks.values()).every(tr => tr.isEncrypted);
+  }
   /** @internal */
   constructor(sid, identity, name, metadata) {
     super();
@@ -21133,6 +21770,7 @@ class LocalParticipant extends Participant {
     this.pendingPublishPromises = new Map();
     this.participantTrackPermissions = [];
     this.allParticipantsAllowedToSubscribe = true;
+    this.encryptionType = Encryption_Type.NONE;
     this.handleReconnecting = () => {
       if (!this.reconnectFuture) {
         this.reconnectFuture = new Future();
@@ -21288,6 +21926,7 @@ class LocalParticipant extends Participant {
     this.engine = engine;
     this.roomOptions = options;
     this.setupEngine(engine);
+    this.activeDeviceMap = new Map();
   }
   get lastCameraError() {
     return this.cameraError;
@@ -21372,6 +22011,22 @@ class LocalParticipant extends Participant {
   setScreenShareEnabled(enabled, options, publishOptions) {
     return this.setTrackEnabled(Track.Source.ScreenShare, enabled, options, publishOptions);
   }
+  /** @internal */
+  setPermissions(permissions) {
+    const prevPermissions = this.permissions;
+    const changed = super.setPermissions(permissions);
+    if (changed && prevPermissions) {
+      this.emit(ParticipantEvent.ParticipantPermissionsChanged, prevPermissions);
+    }
+    return changed;
+  }
+  /** @internal */
+  setE2EEEnabled(enabled) {
+    return __awaiter(this, void 0, void 0, function* () {
+      this.encryptionType = enabled ? Encryption_Type.GCM : Encryption_Type.NONE;
+      yield this.republishAllTracks(undefined, false);
+    });
+  }
   setTrackEnabled(source, enabled, options, publishOptions) {
     var _a, _b;
     return __awaiter(this, void 0, void 0, function* () {
@@ -21596,14 +22251,35 @@ class LocalParticipant extends Participant {
       if (track instanceof LocalTrack && this.pendingPublishPromises.has(track)) {
         yield this.pendingPublishPromises.get(track);
       }
+      let defaultConstraints;
+      if (track instanceof MediaStreamTrack) {
+        defaultConstraints = track.getConstraints();
+      } else {
+        // we want to access constraints directly as `track.mediaStreamTrack`
+        // might be pointing to a non-device track (e.g. processed track) already
+        defaultConstraints = track.constraints;
+        let deviceKind = undefined;
+        switch (track.source) {
+          case Track.Source.Microphone:
+            deviceKind = 'audioinput';
+            break;
+          case Track.Source.Camera:
+            deviceKind = 'videoinput';
+        }
+        if (deviceKind && this.activeDeviceMap.has(deviceKind)) {
+          defaultConstraints = Object.assign(Object.assign({}, defaultConstraints), {
+            deviceId: this.activeDeviceMap.get(deviceKind)
+          });
+        }
+      }
       // convert raw media track into audio or video track
       if (track instanceof MediaStreamTrack) {
         switch (track.kind) {
           case 'audio':
-            track = new LocalAudioTrack(track, undefined, true);
+            track = new LocalAudioTrack(track, defaultConstraints, true);
             break;
           case 'video':
-            track = new LocalVideoTrack(track, undefined, true);
+            track = new LocalVideoTrack(track, defaultConstraints, true);
             break;
           default:
             throw new TrackInvalidError("unsupported MediaStreamTrack kind ".concat(track.kind));
@@ -21642,6 +22318,11 @@ class LocalParticipant extends Participant {
         (_d = options.red) !== null && _d !== void 0 ? _d : options.red = false;
       }
       const opts = Object.assign(Object.assign({}, this.roomOptions.publishDefaults), options);
+      // disable simulcast if e2ee is set on safari
+      if (isSafari() && this.roomOptions.e2ee) {
+        livekitLogger.info("End-to-end encryption is set up, simulcast publishing will be disabled on Safari");
+        opts.simulcast = false;
+      }
       if (opts.source) {
         track.source = opts.source;
       }
@@ -21658,7 +22339,7 @@ class LocalParticipant extends Participant {
     });
   }
   publish(track, opts, options, isStereo) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
     return __awaiter(this, void 0, void 0, function* () {
       const existingTrackOfSource = Array.from(this.tracks.values()).find(publishedTrack => track instanceof LocalTrack && publishedTrack.source === track.source);
       if (existingTrackOfSource && track.source !== Track.Source.Unknown) {
@@ -21705,8 +22386,9 @@ class LocalParticipant extends Participant {
         muted: track.isMuted,
         source: Track.sourceToProto(track.source),
         disableDtx: !((_a = opts.dtx) !== null && _a !== void 0 ? _a : true),
-        stereo: isStereo,
-        disableRed: !((_b = opts.red) !== null && _b !== void 0 ? _b : true)
+        encryption: this.encryptionType,
+        stereo: isStereo
+        // disableRed: !(opts.red ?? true),
       });
       // compute encodings and layers for video
       let encodings;
@@ -21721,7 +22403,7 @@ class LocalParticipant extends Participant {
         } catch (e) {
           // use defaults, it's quite painful for congestion control without simulcast
           // so using default dims according to publish settings
-          const defaultRes = (_d = (_c = this.roomOptions.videoCaptureDefaults) === null || _c === void 0 ? void 0 : _c.resolution) !== null && _d !== void 0 ? _d : VideoPresets.h720.resolution;
+          const defaultRes = (_c = (_b = this.roomOptions.videoCaptureDefaults) === null || _b === void 0 ? void 0 : _b.resolution) !== null && _c !== void 0 ? _c : VideoPresets.h720.resolution;
           dims = {
             width: defaultRes.width,
             height: defaultRes.height
@@ -21736,7 +22418,7 @@ class LocalParticipant extends Participant {
         if (track instanceof LocalVideoTrack) {
           if (isSVCCodec(opts.videoCodec)) {
             // set scalabilityMode to 'L3T3_KEY' by default
-            opts.scalabilityMode = (_e = opts.scalabilityMode) !== null && _e !== void 0 ? _e : 'L3T3_KEY';
+            opts.scalabilityMode = (_d = opts.scalabilityMode) !== null && _d !== void 0 ? _d : 'L3T3_KEY';
           }
           // set up backup
           if (opts.videoCodec && opts.backupCodec && opts.videoCodec !== opts.backupCodec.codec) {
@@ -21758,7 +22440,7 @@ class LocalParticipant extends Participant {
             req.simulcastCodecs = [{
               codec: opts.videoCodec,
               cid: track.mediaStreamTrack.id,
-              enableSimulcastLayers: (_f = opts.simulcast) !== null && _f !== void 0 ? _f : false
+              enableSimulcastLayers: (_e = opts.simulcast) !== null && _e !== void 0 ? _e : false
             }];
           }
         }
@@ -21766,9 +22448,9 @@ class LocalParticipant extends Participant {
         req.layers = videoLayersFromEncodings(req.width, req.height, encodings, isSVCCodec(opts.videoCodec));
       } else if (track.kind === Track.Kind.Audio) {
         encodings = [{
-          maxBitrate: (_h = (_g = opts.audioPreset) === null || _g === void 0 ? void 0 : _g.maxBitrate) !== null && _h !== void 0 ? _h : opts.audioBitrate,
-          priority: (_k = (_j = opts.audioPreset) === null || _j === void 0 ? void 0 : _j.priority) !== null && _k !== void 0 ? _k : 'high',
-          networkPriority: (_m = (_l = opts.audioPreset) === null || _l === void 0 ? void 0 : _l.priority) !== null && _m !== void 0 ? _m : 'high'
+          maxBitrate: (_g = (_f = opts.audioPreset) === null || _f === void 0 ? void 0 : _f.maxBitrate) !== null && _g !== void 0 ? _g : opts.audioBitrate,
+          priority: (_j = (_h = opts.audioPreset) === null || _h === void 0 ? void 0 : _h.priority) !== null && _j !== void 0 ? _j : 'high',
+          networkPriority: (_l = (_k = opts.audioPreset) === null || _k === void 0 ? void 0 : _k.priority) !== null && _l !== void 0 ? _l : 'high'
         }];
       }
       if (!this.engine || this.engine.isClosed) {
@@ -21830,10 +22512,10 @@ class LocalParticipant extends Participant {
             this.engine.publisher.setTrackCodecBitrate({
               transceiver: trackTransceiver,
               codec: 'opus',
-              maxbr: ((_o = encodings[0]) === null || _o === void 0 ? void 0 : _o.maxBitrate) ? encodings[0].maxBitrate / 1000 : 0
+              maxbr: ((_m = encodings[0]) === null || _m === void 0 ? void 0 : _m.maxBitrate) ? encodings[0].maxBitrate / 1000 : 0
             });
           }
-        } else if (track.codec && isSVCCodec(track.codec) && ((_p = encodings[0]) === null || _p === void 0 ? void 0 : _p.maxBitrate)) {
+        } else if (track.codec && isSVCCodec(track.codec) && ((_o = encodings[0]) === null || _o === void 0 ? void 0 : _o.maxBitrate)) {
           this.engine.publisher.setTrackCodecBitrate({
             cid: req.cid,
             codec: track.codec,
@@ -21841,7 +22523,7 @@ class LocalParticipant extends Participant {
           });
         }
       }
-      this.engine.negotiate();
+      yield this.engine.negotiate();
       if (track instanceof LocalVideoTrack) {
         track.startMonitor(this.engine.client);
       } else if (track instanceof LocalAudioTrack) {
@@ -21903,7 +22585,7 @@ class LocalParticipant extends Participant {
       }
       const ti = yield this.engine.addTrack(req);
       yield this.engine.createSimulcastSender(track, simulcastTrack, opts, encodings);
-      this.engine.negotiate();
+      yield this.engine.negotiate();
       livekitLogger.debug("published ".concat(videoCodec, " for track ").concat(track.sid), {
         encodings,
         trackInfo: ti
@@ -21999,6 +22681,7 @@ class LocalParticipant extends Participant {
     });
   }
   republishAllTracks(options) {
+    let restartTracks = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
     return __awaiter(this, void 0, void 0, function* () {
       const localPubs = [];
       this.tracks.forEach(pub => {
@@ -22012,6 +22695,14 @@ class LocalParticipant extends Participant {
       yield Promise.all(localPubs.map(pub => __awaiter(this, void 0, void 0, function* () {
         const track = pub.track;
         yield this.unpublishTrack(track, false);
+        if (restartTracks && !track.isMuted && (track instanceof LocalAudioTrack || track instanceof LocalVideoTrack) && !track.isUserProvided) {
+          // generally 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', {
+            track: pub.trackSid
+          });
+          yield track.restartTrack();
+        }
         yield this.publishTrack(track, pub.options);
       })));
     });
@@ -22187,6 +22878,8 @@ class Room extends EventEmitter {
      * a [[RoomEvent.ActiveSpeakersChanged]] event is fired
      */
     this.activeSpeakers = [];
+    /** reflects the sender encryption status of the local participant */
+    this.isE2EEEnabled = false;
     this.audioEnabled = true;
     this.connect = (url, token, opts) => __awaiter(this, void 0, void 0, function* () {
       // In case a disconnect called happened right before the connect call, make sure the disconnect is completed first by awaiting its lock
@@ -22247,7 +22940,8 @@ class Room extends EventEmitter {
         autoSubscribe: connectOptions.autoSubscribe,
         publishOnly: connectOptions.publishOnly,
         adaptiveStream: typeof roomOptions.adaptiveStream === 'object' ? true : roomOptions.adaptiveStream,
-        maxRetries: connectOptions.maxRetries
+        maxRetries: connectOptions.maxRetries,
+        e2eeEnabled: !!this.e2eeManager
       }, abortController.signal);
       let serverInfo = joinResponse.serverInfo;
       if (!serverInfo) {
@@ -22637,6 +23331,7 @@ class Room extends EventEmitter {
       this.emit(RoomEvent.TrackUnmuted, pub, this.localParticipant);
     };
     this.onLocalTrackPublished = pub => __awaiter(this, void 0, void 0, function* () {
+      var _j;
       this.emit(RoomEvent.LocalTrackPublished, pub, this.localParticipant);
       if (pub.track instanceof LocalAudioTrack) {
         const trackIsSilent = yield pub.track.checkForSilence();
@@ -22644,6 +23339,12 @@ class Room extends EventEmitter {
           this.emit(RoomEvent.LocalAudioSilenceDetected, pub);
         }
       }
+      const deviceId = yield (_j = pub.track) === null || _j === void 0 ? void 0 : _j.getDeviceId();
+      const deviceKind = sourceToKind(pub.source);
+      if (deviceKind && deviceId && deviceId !== this.localParticipant.activeDeviceMap.get(deviceKind)) {
+        this.localParticipant.activeDeviceMap.set(deviceKind, deviceId);
+        this.emit(RoomEvent.ActiveDeviceChanged, deviceKind, deviceId);
+      }
     });
     this.onLocalTrackUnpublished = pub => {
       this.emit(RoomEvent.LocalTrackUnpublished, pub, this.localParticipant);
@@ -22666,17 +23367,45 @@ class Room extends EventEmitter {
     this.options.publishDefaults = Object.assign(Object.assign({}, publishDefaults), options === null || options === void 0 ? void 0 : options.publishDefaults);
     this.maybeCreateEngine();
     this.disconnectLock = new Mutex();
-    this.activeDeviceMap = new Map();
+    this.localParticipant = new LocalParticipant('', '', this.engine, this.options);
     if (this.options.videoCaptureDefaults.deviceId) {
-      this.activeDeviceMap.set('videoinput', unwrapConstraint(this.options.videoCaptureDefaults.deviceId));
+      this.localParticipant.activeDeviceMap.set('videoinput', unwrapConstraint(this.options.videoCaptureDefaults.deviceId));
     }
     if (this.options.audioCaptureDefaults.deviceId) {
-      this.activeDeviceMap.set('audioinput', unwrapConstraint(this.options.audioCaptureDefaults.deviceId));
+      this.localParticipant.activeDeviceMap.set('audioinput', unwrapConstraint(this.options.audioCaptureDefaults.deviceId));
     }
     if ((_a = this.options.audioOutput) === null || _a === void 0 ? void 0 : _a.deviceId) {
       this.switchActiveDevice('audiooutput', unwrapConstraint(this.options.audioOutput.deviceId));
     }
-    this.localParticipant = new LocalParticipant('', '', this.engine, this.options);
+    if (this.options.e2ee) {
+      this.setupE2EE();
+    }
+  }
+  /**
+   * @experimental
+   */
+  setE2EEEnabled(enabled) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (this.e2eeManager) {
+        yield Promise.all([this.localParticipant.setE2EEEnabled(enabled), this.e2eeManager.setParticipantCryptorEnabled(enabled)]);
+      } else {
+        throw Error('e2ee not configured, please set e2ee settings within the room options');
+      }
+    });
+  }
+  setupE2EE() {
+    var _a;
+    if (this.options.e2ee) {
+      this.e2eeManager = new E2EEManager(this.options.e2ee);
+      this.e2eeManager.on(EncryptionEvent.ParticipantEncryptionStatusChanged, (enabled, participant) => {
+        if (participant instanceof LocalParticipant) {
+          this.isE2EEEnabled = enabled;
+        }
+        this.emit(RoomEvent.ParticipantEncryptionStatusChanged, enabled, participant);
+      });
+      this.e2eeManager.on(EncryptionEvent.Error, error => this.emit(RoomEvent.EncryptionError, error));
+      (_a = this.e2eeManager) === null || _a === void 0 ? void 0 : _a.setup(this);
+    }
   }
   /**
    * if the current room has a participant with `recorder: true` in its JWT grant
@@ -22713,14 +23442,7 @@ class Room extends EventEmitter {
       return;
     }
     this.engine = new RTCEngine(this.options);
-    this.engine.client.onParticipantUpdate = this.handleParticipantUpdates;
-    this.engine.client.onRoomUpdate = this.handleRoomUpdate;
-    this.engine.client.onSpeakersChanged = this.handleSpeakersChanged;
-    this.engine.client.onStreamStateUpdate = this.handleStreamStateUpdate;
-    this.engine.client.onSubscriptionPermissionUpdate = this.handleSubscriptionPermissionUpdate;
-    this.engine.client.onConnectionQuality = this.handleConnectionQualityUpdate;
-    this.engine.client.onSubscriptionError = this.handleSubscriptionError;
-    this.engine.on(EngineEvent.MediaTrackAdded, (mediaTrack, stream, receiver) => {
+    this.engine.on(EngineEvent.ParticipantUpdate, this.handleParticipantUpdates).on(EngineEvent.RoomUpdate, this.handleRoomUpdate).on(EngineEvent.SpeakersChanged, this.handleSpeakersChanged).on(EngineEvent.StreamStateChanged, this.handleStreamStateUpdate).on(EngineEvent.ConnectionQualityUpdate, this.handleConnectionQualityUpdate).on(EngineEvent.SubscriptionError, this.handleSubscriptionError).on(EngineEvent.SubscriptionPermissionUpdate, this.handleSubscriptionPermissionUpdate).on(EngineEvent.MediaTrackAdded, (mediaTrack, stream, receiver) => {
       this.onTrackAdded(mediaTrack, stream, receiver);
     }).on(EngineEvent.Disconnected, reason => {
       this.handleDisconnect(this.options.stopLocalTrackOnUnpublish, reason);
@@ -22749,6 +23471,9 @@ class Room extends EventEmitter {
     if (this.localParticipant) {
       this.localParticipant.setupEngine(this.engine);
     }
+    if (this.e2eeManager) {
+      this.e2eeManager.setupEngine(this.engine);
+    }
   }
   /**
    * getLocalDevices abstracts navigator.mediaDevices.enumerateDevices.
@@ -22803,10 +23528,8 @@ class Room extends EventEmitter {
       let req;
       switch (scenario) {
         case 'signal-reconnect':
-          yield this.engine.client.close();
-          if (this.engine.client.onClose) {
-            this.engine.client.onClose('simulate disconnect');
-          }
+          // @ts-expect-error function is private
+          yield this.engine.client.handleOnClose('simulate disconnect');
           break;
         case 'speaker':
           req = SimulateScenario.fromPartial({
@@ -22842,17 +23565,13 @@ class Room extends EventEmitter {
           break;
         case 'resume-reconnect':
           this.engine.failNext();
-          yield this.engine.client.close();
-          if (this.engine.client.onClose) {
-            this.engine.client.onClose('simulate resume-reconnect');
-          }
+          // @ts-expect-error function is private
+          yield this.engine.client.handleOnClose('simulate resume-disconnect');
           break;
         case 'full-reconnect':
           this.engine.fullReconnectOnNext = true;
-          yield this.engine.client.close();
-          if (this.engine.client.onClose) {
-            this.engine.client.onClose('simulate full-reconnect');
-          }
+          // @ts-expect-error function is private
+          yield this.engine.client.handleOnClose('simulate full-reconnect');
           break;
         case 'force-tcp':
         case 'force-tls':
@@ -22949,7 +23668,7 @@ class Room extends EventEmitter {
     return (_b = (_a = this.options.audioOutput) === null || _a === void 0 ? void 0 : _a.deviceId) !== null && _b !== void 0 ? _b : '';
   }
   getActiveDevice(kind) {
-    return this.activeDeviceMap.get(kind);
+    return this.localParticipant.activeDeviceMap.get(kind);
   }
   /**
    * Switches all active devices used in this room to the given device.
@@ -23022,7 +23741,7 @@ class Room extends EventEmitter {
         }
       }
       if (deviceHasChanged && success) {
-        this.activeDeviceMap.set(kind, deviceId);
+        this.localParticipant.activeDeviceMap.set(kind, deviceId);
         this.emit(RoomEvent.ActiveDeviceChanged, kind, deviceId);
       }
       return success;
@@ -23379,7 +24098,7 @@ class Room extends EventEmitter {
           sid: Math.floor(Math.random() * 10000).toString(),
           type: TrackType.AUDIO,
           name: 'video-dummy'
-        }), new LocalVideoTrack(publishOptions.useRealTracks ? (yield navigator.mediaDevices.getUserMedia({
+        }), new LocalVideoTrack(publishOptions.useRealTracks ? (yield window.navigator.mediaDevices.getUserMedia({
           video: true
         })).getVideoTracks()[0] : createDummyVideoStreamTrack((_a = 160 * participantOptions.aspectRatios[0]) !== null && _a !== void 0 ? _a : 1, 160, true, true)));
         // @ts-ignore
@@ -23792,7 +24511,8 @@ class TURNCheck extends Checker {
       const signalClient = new SignalClient();
       const joinRes = yield signalClient.join(this.url, this.token, {
         autoSubscribe: true,
-        maxRetries: 0
+        maxRetries: 0,
+        e2eeEnabled: false
       });
       let hasTLS = false;
       let hasTURN = false;
@@ -23863,7 +24583,8 @@ class WebSocketCheck extends Checker {
       let signalClient = new SignalClient();
       const joinRes = yield signalClient.join(this.url, this.token, {
         autoSubscribe: true,
-        maxRetries: 0
+        maxRetries: 0,
+        e2eeEnabled: false
       });
       this.appendMessage("Connected to server, version ".concat(joinRes.serverVersion, "."));
       yield signalClient.close();
@@ -23943,5 +24664,86 @@ class ConnectionCheck extends EventEmitter {
   }
 }
 
-export { AudioPresets, ConnectionCheck, ConnectionError, ConnectionQuality, ConnectionState, CriticalTimers, DataPacket_Kind, DefaultReconnectPolicy, DeviceUnsupportedError, DisconnectReason, EngineEvent, LivekitError, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalVideoTrack, LogLevel, MediaDeviceFailure, NegotiationError, Participant, ParticipantEvent, PublishDataError, RemoteAudioTrack, RemoteParticipant, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, RoomEvent, RoomState, ScreenSharePresets, Track, TrackEvent, TrackInvalidError, TrackPublication, UnexpectedConnectionState, UnsupportedServer, VideoPreset, VideoPresets, VideoPresets43, VideoQuality, attachToElement, createAudioAnalyser, createLocalAudioTrack, createLocalScreenTracks, createLocalTracks, createLocalVideoTrack, detachTrack, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, isBackupCodec, isBrowserSupported, isCodecEqual, protocolVersion, setLogExtension, setLogLevel, supportsAV1, supportsAdaptiveStream, supportsDynacast, supportsVP9, version };
+/**
+ * Try to analyze the local track to determine the facing mode of a track.
+ *
+ * @remarks
+ * There is no property supported by all browsers to detect whether a video track originated from a user- or environment-facing camera device.
+ * For this reason, we use the `facingMode` property when available, but will fall back on a string-based analysis of the device label to determine the facing mode.
+ * If both methods fail, the default facing mode will be used.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/facingMode | MDN docs on facingMode}
+ * @experimental
+ */
+function facingModeFromLocalTrack(localTrack) {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var _a;
+  const track = localTrack instanceof LocalTrack ? localTrack.mediaStreamTrack : localTrack;
+  const trackSettings = track.getSettings();
+  let result = {
+    facingMode: (_a = options.defaultFacingMode) !== null && _a !== void 0 ? _a : 'user',
+    confidence: 'low'
+  };
+  // 1. Try to get facingMode from track settings.
+  if ('facingMode' in trackSettings) {
+    const rawFacingMode = trackSettings.facingMode;
+    log$1.debug('rawFacingMode', {
+      rawFacingMode
+    });
+    if (rawFacingMode && typeof rawFacingMode === 'string' && isFacingModeValue(rawFacingMode)) {
+      result = {
+        facingMode: rawFacingMode,
+        confidence: 'high'
+      };
+    }
+  }
+  // 2. If we don't have a high confidence we try to get the facing mode from the device label.
+  if (['low', 'medium'].includes(result.confidence)) {
+    log$1.debug("Try to get facing mode from device label: (".concat(track.label, ")"));
+    const labelAnalysisResult = facingModeFromDeviceLabel(track.label);
+    if (labelAnalysisResult !== undefined) {
+      result = labelAnalysisResult;
+    }
+  }
+  return result;
+}
+const knownDeviceLabels = new Map([['obs virtual camera', {
+  facingMode: 'environment',
+  confidence: 'medium'
+}]]);
+const knownDeviceLabelSections = new Map([['iphone', {
+  facingMode: 'environment',
+  confidence: 'medium'
+}], ['ipad', {
+  facingMode: 'environment',
+  confidence: 'medium'
+}]]);
+/**
+ * Attempt to analyze the device label to determine the facing mode.
+ *
+ * @experimental
+ */
+function facingModeFromDeviceLabel(deviceLabel) {
+  var _a;
+  const label = deviceLabel.trim().toLowerCase();
+  // Empty string is a valid device label but we can't infer anything from it.
+  if (label === '') {
+    return undefined;
+  }
+  // Can we match against widely known device labels.
+  if (knownDeviceLabels.has(label)) {
+    return knownDeviceLabels.get(label);
+  }
+  // Can we match against sections of the device label.
+  return (_a = Array.from(knownDeviceLabelSections.entries()).find(_ref => {
+    let [section] = _ref;
+    return label.includes(section);
+  })) === null || _a === void 0 ? void 0 : _a[1];
+}
+function isFacingModeValue(item) {
+  const allowedValues = ['user', 'environment', 'left', 'right'];
+  return item === undefined || allowedValues.includes(item);
+}
+
+export { AudioPresets, BaseKeyProvider, ConnectionCheck, ConnectionError, ConnectionQuality, ConnectionState, CriticalTimers, CryptorEvent, DataPacket_Kind, DefaultReconnectPolicy, DeviceUnsupportedError, DisconnectReason, EncryptionEvent, EngineEvent, ExternalE2EEKeyProvider, LivekitError, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalVideoTrack, LogLevel, MediaDeviceFailure, NegotiationError, Participant, ParticipantEvent, PublishDataError, RemoteAudioTrack, RemoteParticipant, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, RoomEvent, RoomState, ScreenSharePresets, Track, TrackEvent, TrackInvalidError, TrackPublication, UnexpectedConnectionState, UnsupportedServer, VideoPreset, VideoPresets, VideoPresets43, VideoQuality, attachToElement, createAudioAnalyser, createE2EEKey, createKeyMaterialFromString, createLocalAudioTrack, createLocalScreenTracks, createLocalTracks, createLocalVideoTrack, deriveKeys, detachTrack, facingModeFromDeviceLabel, facingModeFromLocalTrack, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, importKey, isBackupCodec, isBrowserSupported, isCodecEqual, isE2EESupported, isInsertableStreamSupported, isScriptTransformSupported, isVideoFrame, mimeTypeToVideoCodecString, protocolVersion, ratchet, setLogExtension, setLogLevel, supportsAV1, supportsAdaptiveStream, supportsDynacast, supportsVP9, version, videoCodecs };
 //# sourceMappingURL=livekit-client.esm.mjs.map