livekit-client 2.1.0 → 2.1.1

package/dist/livekit-client.esm.mjs

@@ -175,6 +175,7 @@ function normalizeEnumValue(value) {
 class Message {
   /**
    * Compare with a message of the same type.
+   * Note that this function disregards extensions and unknown fields.
    */
   equals(other) {
     return this.getType().runtime.util.equals(this.getType(), this, other);
@@ -2185,7 +2186,7 @@ function readScalar$1(type, json, longType, nullAsZeroValue) {
         if (json.trim().length === json.length) int32 = Number(json);
       }
       if (int32 === undefined) break;
-      if (type == ScalarType.UINT32) assertUInt32(int32);else assertInt32(int32);
+      if (type == ScalarType.UINT32 || type == ScalarType.FIXED32) assertUInt32(int32);else assertInt32(int32);
       return int32;
     // int64, fixed64, uint64: JSON value will be a decimal string. Either numbers or strings are accepted.
     case ScalarType.INT64:
@@ -2997,6 +2998,9 @@ function makeUtilCommon() {
         }
         any[member.localName] = copy;
       }
+      for (const uf of type.runtime.bin.listUnknownFields(message)) {
+        type.runtime.bin.onUnknownField(any, uf.no, uf.wireType, uf.data);
+      }
       return target;
     }
   };
@@ -10353,7 +10357,8 @@ const browsersList = [{
     const browser = {
       name: 'Firefox',
       version: getMatch(/(?:firefox|iceweasel|fxios)[\s/](\d+(\.?_?\d+)+)/i, ua),
-      os: ua.toLowerCase().includes('fxios') ? 'iOS' : undefined
+      os: ua.toLowerCase().includes('fxios') ? 'iOS' : undefined,
+      osVersion: getOSVersion(ua)
     };
     return browser;
   }
@@ -10363,7 +10368,8 @@ const browsersList = [{
     const browser = {
       name: 'Chrome',
       version: getMatch(/(?:chrome|chromium|crios|crmo)\/(\d+(\.?_?\d+)+)/i, ua),
-      os: ua.toLowerCase().includes('crios') ? 'iOS' : undefined
+      os: ua.toLowerCase().includes('crios') ? 'iOS' : undefined,
+      osVersion: getOSVersion(ua)
     };
     return browser;
   }
@@ -10374,7 +10380,8 @@ const browsersList = [{
     const browser = {
       name: 'Safari',
       version: getMatch(commonVersionIdentifier, ua),
-      os: ua.includes('mobile/') ? 'iOS' : 'macOS'
+      os: ua.includes('mobile/') ? 'iOS' : 'macOS',
+      osVersion: getOSVersion(ua)
     };
     return browser;
   }
@@ -10384,8 +10391,11 @@ function getMatch(exp, ua) {
   const match = ua.match(exp);
   return match && match.length >= id && match[id] || '';
 }
+function getOSVersion(ua) {
+  return ua.includes('mac os') ? getMatch(/\(.+?(\d+_\d+(:?_\d+)?)/, ua, 1).replace(/_/g, '.') : undefined;
+}
 
-var version$1 = "2.1.0";
+var version$1 = "2.1.1";
 
 const version = version$1;
 const protocolVersion = 12;
@@ -11175,29 +11185,6 @@ function supportsSetSinkId(elm) {
   }
   return 'setSinkId' in elm;
 }
-const setCodecPreferencesVersions = {
-  Chrome: '100',
-  Safari: '15',
-  Firefox: '100'
-};
-function supportsSetCodecPreferences(transceiver) {
-  if (!isWeb()) {
-    return false;
-  }
-  if (!('setCodecPreferences' in transceiver)) {
-    return false;
-  }
-  const browser = getBrowser();
-  if (!(browser === null || browser === void 0 ? void 0 : browser.name) || !browser.version) {
-    // version is required
-    return false;
-  }
-  const v = setCodecPreferencesVersions[browser.name];
-  if (v) {
-    return compareVersions(browser.version, v) >= 0;
-  }
-  return false;
-}
 function isBrowserSupported() {
   if (typeof RTCPeerConnection === 'undefined') {
     return false;
@@ -11217,8 +11204,27 @@ function isSafari17() {
   return (b === null || b === void 0 ? void 0 : b.name) === 'Safari' && b.version.startsWith('17.');
 }
 function isMobile() {
+  var _a, _b;
   if (!isWeb()) return false;
-  return /Tablet|iPad|Mobile|Android|BlackBerry/.test(navigator.userAgent);
+  return (
+    // @ts-expect-error `userAgentData` is not yet part of typescript
+    (_b = (_a = navigator.userAgentData) === null || _a === void 0 ? void 0 : _a.mobile) !== null && _b !== void 0 ? _b : /Tablet|iPad|Mobile|Android|BlackBerry/.test(navigator.userAgent)
+  );
+}
+function isE2EESimulcastSupported() {
+  const browser = getBrowser();
+  const supportedSafariVersion = '17.2'; // see https://bugs.webkit.org/show_bug.cgi?id=257803
+  if (browser) {
+    if (browser.name !== 'Safari' && browser.os !== 'iOS') {
+      return true;
+    } else if (browser.os === 'iOS' && browser.osVersion && compareVersions(supportedSafariVersion, browser.osVersion) >= 0) {
+      return true;
+    } else if (browser.name === 'Safari' && compareVersions(supportedSafariVersion, browser.version) >= 0) {
+      return true;
+    } else {
+      return false;
+    }
+  }
 }
 function isWeb() {
   return typeof document !== 'undefined';
@@ -14141,8 +14147,6 @@ class PCTransport extends eventsExports.EventEmitter {
           yield this.pc.setLocalDescription(sd);
         }
       } catch (e) {
-        // this error cannot always be caught.
-        // If the local description has a setCodecPreferences error, this error will be uncaught
         let msg = 'unknown error';
         if (e instanceof Error) {
           msg = e.message;
@@ -14568,2330 +14572,2288 @@ class PCTransportManager {
   }
 }
 
-const lossyDataChannel = '_lossy';
-const reliableDataChannel = '_reliable';
-const minReconnectWait = 2 * 1000;
-const leaveReconnect = 'leave-reconnect';
-var PCState;
-(function (PCState) {
-  PCState[PCState["New"] = 0] = "New";
-  PCState[PCState["Connected"] = 1] = "Connected";
-  PCState[PCState["Disconnected"] = 2] = "Disconnected";
-  PCState[PCState["Reconnecting"] = 3] = "Reconnecting";
-  PCState[PCState["Closed"] = 4] = "Closed";
-})(PCState || (PCState = {}));
-/** @internal */
-class RTCEngine extends eventsExports.EventEmitter {
-  get isClosed() {
-    return this._isClosed;
+const monitorFrequency = 2000;
+function computeBitrate(currentStats, prevStats) {
+  if (!prevStats) {
+    return 0;
   }
-  get pendingReconnect() {
-    return !!this.reconnectTimeout;
+  let bytesNow;
+  let bytesPrev;
+  if ('bytesReceived' in currentStats) {
+    bytesNow = currentStats.bytesReceived;
+    bytesPrev = prevStats.bytesReceived;
+  } else if ('bytesSent' in currentStats) {
+    bytesNow = currentStats.bytesSent;
+    bytesPrev = prevStats.bytesSent;
   }
-  constructor(options) {
-    var _a;
-    super();
-    this.options = options;
-    this.rtcConfig = {};
-    this.peerConnectionTimeout = roomConnectOptionDefaults.peerConnectionTimeout;
-    this.fullReconnectOnNext = false;
-    this.subscriberPrimary = false;
-    this.pcState = PCState.New;
-    this._isClosed = true;
-    this.pendingTrackResolvers = {};
-    this.reconnectAttempts = 0;
-    this.reconnectStart = 0;
-    this.attemptingReconnect = false;
-    /** keeps track of how often an initial join connection has been tried */
-    this.joinAttempts = 0;
-    /** specifies how often an initial join connection is allowed to retry */
-    this.maxJoinAttempts = 1;
-    this.shouldFailNext = false;
-    this.log = livekitLogger;
-    this.handleDataChannel = _b => __awaiter(this, [_b], void 0, function (_ref) {
-      var _this = this;
-      let {
-        channel
-      } = _ref;
-      return function* () {
-        if (!channel) {
-          return;
+  if (bytesNow === undefined || bytesPrev === undefined || currentStats.timestamp === undefined || prevStats.timestamp === undefined) {
+    return 0;
+  }
+  return (bytesNow - bytesPrev) * 8 * 1000 / (currentStats.timestamp - prevStats.timestamp);
+}
+
+class LocalAudioTrack extends LocalTrack {
+  /**
+   * boolean indicating whether enhanced noise cancellation is currently being used on this track
+   */
+  get enhancedNoiseCancellation() {
+    return this.isKrispNoiseFilterEnabled;
+  }
+  /**
+   *
+   * @param mediaTrack
+   * @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, constraints) {
+    let userProvidedTrack = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    let audioContext = arguments.length > 3 ? arguments[3] : undefined;
+    let loggerOptions = arguments.length > 4 ? arguments[4] : undefined;
+    super(mediaTrack, Track.Kind.Audio, constraints, userProvidedTrack, loggerOptions);
+    /** @internal */
+    this.stopOnMute = false;
+    this.isKrispNoiseFilterEnabled = false;
+    this.monitorSender = () => __awaiter(this, void 0, void 0, function* () {
+      if (!this.sender) {
+        this._currentBitrate = 0;
+        return;
+      }
+      let stats;
+      try {
+        stats = yield this.getSenderStats();
+      } catch (e) {
+        this.log.error('could not get audio sender stats', Object.assign(Object.assign({}, this.logContext), {
+          error: e
+        }));
+        return;
+      }
+      if (stats && this.prevStats) {
+        this._currentBitrate = computeBitrate(stats, this.prevStats);
+      }
+      this.prevStats = stats;
+    });
+    this.handleKrispNoiseFilterEnable = () => {
+      this.isKrispNoiseFilterEnabled = true;
+      this.log.debug("Krisp noise filter enabled", this.logContext);
+      this.emit(TrackEvent.AudioTrackFeatureUpdate, this, AudioTrackFeature.TF_ENHANCED_NOISE_CANCELLATION, true);
+    };
+    this.handleKrispNoiseFilterDisable = () => {
+      this.isKrispNoiseFilterEnabled = false;
+      this.log.debug("Krisp noise filter disabled", this.logContext);
+      this.emit(TrackEvent.AudioTrackFeatureUpdate, this, AudioTrackFeature.TF_ENHANCED_NOISE_CANCELLATION, false);
+    };
+    this.audioContext = audioContext;
+    this.checkForSilence();
+  }
+  setDeviceId(deviceId) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (this._constraints.deviceId === deviceId && this._mediaStreamTrack.getSettings().deviceId === unwrapConstraint(deviceId)) {
+        return true;
+      }
+      this._constraints.deviceId = deviceId;
+      if (!this.isMuted) {
+        yield this.restartTrack();
+      }
+      return this.isMuted || unwrapConstraint(deviceId) === this._mediaStreamTrack.getSettings().deviceId;
+    });
+  }
+  mute() {
+    const _super = Object.create(null, {
+      mute: {
+        get: () => super.mute
+      }
+    });
+    return __awaiter(this, void 0, void 0, function* () {
+      const unlock = yield this.muteLock.lock();
+      try {
+        if (this.isMuted) {
+          this.log.debug('Track already muted', this.logContext);
+          return this;
         }
-        if (channel.label === reliableDataChannel) {
-          _this.reliableDCSub = channel;
-        } else if (channel.label === lossyDataChannel) {
-          _this.lossyDCSub = channel;
-        } else {
-          return;
+        // disabled special handling as it will cause BT headsets to switch communication modes
+        if (this.source === Track.Source.Microphone && this.stopOnMute && !this.isUserProvided) {
+          this.log.debug('stopping mic track', this.logContext);
+          // also stop the track, so that microphone indicator is turned off
+          this._mediaStreamTrack.stop();
         }
-        _this.log.debug("on data channel ".concat(channel.id, ", ").concat(channel.label), _this.logContext);
-        channel.onmessage = _this.handleDataMessage;
-      }();
+        yield _super.mute.call(this);
+        return this;
+      } finally {
+        unlock();
+      }
     });
-    this.handleDataMessage = message => __awaiter(this, void 0, void 0, function* () {
-      var _c, _d;
-      // make sure to respect incoming data message order by processing message events one after the other
-      const unlock = yield this.dataProcessLock.lock();
+  }
+  unmute() {
+    const _super = Object.create(null, {
+      unmute: {
+        get: () => super.unmute
+      }
+    });
+    return __awaiter(this, void 0, void 0, function* () {
+      const unlock = yield this.muteLock.lock();
       try {
-        // decode
-        let buffer;
-        if (message.data instanceof ArrayBuffer) {
-          buffer = message.data;
-        } else if (message.data instanceof Blob) {
-          buffer = yield message.data.arrayBuffer();
-        } else {
-          this.log.error('unsupported data type', Object.assign(Object.assign({}, this.logContext), {
-            data: message.data
-          }));
-          return;
+        if (!this.isMuted) {
+          this.log.debug('Track already unmuted', this.logContext);
+          return this;
         }
-        const dp = DataPacket.fromBinary(new Uint8Array(buffer));
-        if (((_c = dp.value) === null || _c === void 0 ? void 0 : _c.case) === 'speaker') {
-          // dispatch speaker updates
-          this.emit(EngineEvent.ActiveSpeakersUpdate, dp.value.value.speakers);
-        } else if (((_d = dp.value) === null || _d === void 0 ? void 0 : _d.case) === 'user') {
-          this.emit(EngineEvent.DataPacketReceived, dp.value.value, dp.kind);
+        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) {
+          this.log.debug('reacquiring mic track', this.logContext);
+          yield this.restartTrack();
         }
+        yield _super.unmute.call(this);
+        return this;
       } finally {
         unlock();
       }
     });
-    this.handleDataError = event => {
-      const channel = event.currentTarget;
-      const channelKind = channel.maxRetransmits === 0 ? 'lossy' : 'reliable';
-      if (event instanceof ErrorEvent && event.error) {
-        const {
-          error
-        } = event.error;
-        this.log.error("DataChannel error on ".concat(channelKind, ": ").concat(event.message), Object.assign(Object.assign({}, this.logContext), {
-          error
-        }));
-      } else {
-        this.log.error("Unknown DataChannel error on ".concat(channelKind), Object.assign(Object.assign({}, this.logContext), {
-          event
-        }));
+  }
+  restartTrack(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+      let constraints;
+      if (options) {
+        const streamConstraints = constraintsForOptions({
+          audio: options
+        });
+        if (typeof streamConstraints.audio !== 'boolean') {
+          constraints = streamConstraints.audio;
+        }
       }
-    };
-    this.handleBufferedAmountLow = event => {
-      const channel = event.currentTarget;
-      const channelKind = channel.maxRetransmits === 0 ? DataPacket_Kind.LOSSY : DataPacket_Kind.RELIABLE;
-      this.updateAndEmitDCBufferStatus(channelKind);
-    };
-    // websocket reconnect behavior. if websocket is interrupted, and the PeerConnection
-    // continues to work, we can reconnect to websocket to continue the session
-    // after a number of retries, we'll close and give up permanently
-    this.handleDisconnect = (connection, disconnectReason) => {
-      if (this._isClosed) {
-        return;
-      }
-      this.log.warn("".concat(connection, " disconnected"), this.logContext);
-      if (this.reconnectAttempts === 0) {
-        // only reset start time on the first try
-        this.reconnectStart = Date.now();
-      }
-      const disconnect = duration => {
-        this.log.warn("could not recover connection after ".concat(this.reconnectAttempts, " attempts, ").concat(duration, "ms. giving up"), this.logContext);
-        this.emit(EngineEvent.Disconnected);
-        this.close();
-      };
-      const duration = Date.now() - this.reconnectStart;
-      let delay = this.getNextRetryDelay({
-        elapsedMs: duration,
-        retryCount: this.reconnectAttempts
-      });
-      if (delay === null) {
-        disconnect(duration);
-        return;
-      }
-      if (connection === leaveReconnect) {
-        delay = 0;
-      }
-      this.log.debug("reconnecting in ".concat(delay, "ms"), this.logContext);
-      this.clearReconnectTimeout();
-      if (this.token && this.regionUrlProvider) {
-        // token may have been refreshed, we do not want to recreate the regionUrlProvider
-        // since the current engine may have inherited a regional url
-        this.regionUrlProvider.updateToken(this.token);
-      }
-      this.reconnectTimeout = CriticalTimers.setTimeout(() => this.attemptReconnect(disconnectReason).finally(() => this.reconnectTimeout = undefined), delay);
-    };
-    this.waitForRestarted = () => {
-      return new Promise((resolve, reject) => {
-        if (this.pcState === PCState.Connected) {
-          resolve();
-        }
-        const onRestarted = () => {
-          this.off(EngineEvent.Disconnected, onDisconnected);
-          resolve();
-        };
-        const onDisconnected = () => {
-          this.off(EngineEvent.Restarted, onRestarted);
-          reject();
-        };
-        this.once(EngineEvent.Restarted, onRestarted);
-        this.once(EngineEvent.Disconnected, onDisconnected);
-      });
-    };
-    this.updateAndEmitDCBufferStatus = kind => {
-      const status = this.isBufferStatusLow(kind);
-      if (typeof status !== 'undefined' && status !== this.dcBufferStatus.get(kind)) {
-        this.dcBufferStatus.set(kind, status);
-        this.emit(EngineEvent.DCBufferStatusChanged, status, kind);
-      }
-    };
-    this.isBufferStatusLow = kind => {
-      const dc = this.dataChannelForKind(kind);
-      if (dc) {
-        return dc.bufferedAmount <= dc.bufferedAmountLowThreshold;
-      }
-    };
-    this.handleBrowserOnLine = () => {
-      // in case the engine is currently reconnecting, attempt a reconnect immediately after the browser state has changed to 'onLine'
-      if (this.client.currentState === SignalConnectionState.RECONNECTING) {
-        this.clearReconnectTimeout();
-        this.attemptReconnect(ReconnectReason.RR_SIGNAL_DISCONNECTED);
+      yield this.restart(constraints);
+    });
+  }
+  restart(constraints) {
+    const _super = Object.create(null, {
+      restart: {
+        get: () => super.restart
       }
-    };
-    this.log = getLogger((_a = options.loggerName) !== null && _a !== void 0 ? _a : LoggerNames.Engine);
-    this.loggerOptions = {
-      loggerName: options.loggerName,
-      loggerContextCb: () => this.logContext
-    };
-    this.client = new SignalClient(undefined, this.loggerOptions);
-    this.client.signalLatency = this.options.expSignalLatency;
-    this.reconnectPolicy = this.options.reconnectPolicy;
-    this.registerOnLineListener();
-    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);
+    });
+    return __awaiter(this, void 0, void 0, function* () {
+      const track = yield _super.restart.call(this, constraints);
+      this.checkForSilence();
+      return track;
+    });
   }
-  /** @internal */
-  get logContext() {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
-    return {
-      room: (_b = (_a = this.latestJoinResponse) === null || _a === void 0 ? void 0 : _a.room) === null || _b === void 0 ? void 0 : _b.name,
-      roomID: (_d = (_c = this.latestJoinResponse) === null || _c === void 0 ? void 0 : _c.room) === null || _d === void 0 ? void 0 : _d.sid,
-      participant: (_f = (_e = this.latestJoinResponse) === null || _e === void 0 ? void 0 : _e.participant) === null || _f === void 0 ? void 0 : _f.identity,
-      pID: (_h = (_g = this.latestJoinResponse) === null || _g === void 0 ? void 0 : _g.participant) === null || _h === void 0 ? void 0 : _h.sid
-    };
+  /* @internal */
+  startMonitor() {
+    if (!isWeb()) {
+      return;
+    }
+    if (this.monitorInterval) {
+      return;
+    }
+    this.monitorInterval = setInterval(() => {
+      this.monitorSender();
+    }, monitorFrequency);
   }
-  join(url, token, opts, abortSignal) {
+  setProcessor(processor) {
     return __awaiter(this, void 0, void 0, function* () {
-      this.url = url;
-      this.token = token;
-      this.signalOpts = opts;
-      this.maxJoinAttempts = opts.maxRetries;
+      var _a;
+      const unlock = yield this.processorLock.lock();
       try {
-        this.joinAttempts += 1;
-        this.setupSignalClientCallbacks();
-        const joinResponse = yield this.client.join(url, token, opts, abortSignal);
-        this._isClosed = false;
-        this.latestJoinResponse = joinResponse;
-        this.subscriberPrimary = joinResponse.subscriberPrimary;
-        if (!this.pcManager) {
-          yield this.configure(joinResponse);
+        if (!this.audioContext) {
+          throw Error('Audio context needs to be set on LocalAudioTrack in order to enable processors');
         }
-        // create offer
-        if (!this.subscriberPrimary) {
-          this.negotiate();
+        if (this.processor) {
+          yield this.stopProcessor();
         }
-        this.clientConfiguration = joinResponse.clientConfiguration;
-        return joinResponse;
-      } catch (e) {
-        if (e instanceof ConnectionError) {
-          if (e.reason === 1 /* ConnectionErrorReason.ServerUnreachable */) {
-            this.log.warn("Couldn't connect to server, attempt ".concat(this.joinAttempts, " of ").concat(this.maxJoinAttempts), this.logContext);
-            if (this.joinAttempts < this.maxJoinAttempts) {
-              return this.join(url, token, opts, abortSignal);
-            }
-          }
+        const processorOptions = {
+          kind: this.kind,
+          track: this._mediaStreamTrack,
+          audioContext: this.audioContext
+        };
+        this.log.debug("setting up audio processor ".concat(processor.name), this.logContext);
+        yield processor.init(processorOptions);
+        this.processor = processor;
+        if (this.processor.processedTrack) {
+          yield (_a = this.sender) === null || _a === void 0 ? void 0 : _a.replaceTrack(this.processor.processedTrack);
+          this.processor.processedTrack.addEventListener('enable-lk-krisp-noise-filter', this.handleKrispNoiseFilterEnable);
+          this.processor.processedTrack.addEventListener('disable-lk-krisp-noise-filter', this.handleKrispNoiseFilterDisable);
         }
-        throw e;
-      }
-    });
-  }
-  close() {
-    return __awaiter(this, void 0, void 0, function* () {
-      const unlock = yield this.closingLock.lock();
-      if (this.isClosed) {
-        unlock();
-        return;
-      }
-      try {
-        this._isClosed = true;
-        this.emit(EngineEvent.Closing);
-        this.removeAllListeners();
-        this.deregisterOnLineListener();
-        this.clearPendingReconnect();
-        yield this.cleanupPeerConnections();
-        yield this.cleanupClient();
+        this.emit(TrackEvent.TrackProcessorUpdate, this.processor);
       } finally {
         unlock();
       }
     });
   }
-  cleanupPeerConnections() {
+  /**
+   * @internal
+   * @experimental
+   */
+  setAudioContext(audioContext) {
+    this.audioContext = audioContext;
+  }
+  getSenderStats() {
     return __awaiter(this, void 0, void 0, function* () {
       var _a;
-      yield (_a = this.pcManager) === null || _a === void 0 ? void 0 : _a.close();
-      this.pcManager = 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;
+      if (!((_a = this.sender) === null || _a === void 0 ? void 0 : _a.getStats)) {
+        return undefined;
+      }
+      const stats = yield this.sender.getStats();
+      let audioStats;
+      stats.forEach(v => {
+        if (v.type === 'outbound-rtp') {
+          audioStats = {
+            type: 'audio',
+            streamId: v.id,
+            packetsSent: v.packetsSent,
+            packetsLost: v.packetsLost,
+            bytesSent: v.bytesSent,
+            timestamp: v.timestamp,
+            roundTripTime: v.roundTripTime,
+            jitter: v.jitter
+          };
+        }
+      });
+      return audioStats;
     });
   }
-  cleanupClient() {
+  checkForSilence() {
     return __awaiter(this, void 0, void 0, function* () {
-      yield this.client.close();
-      this.client.resetCallbacks();
+      const trackIsSilent = yield detectSilence(this);
+      if (trackIsSilent) {
+        if (!this.isMuted) {
+          this.log.warn('silence detected on local audio track', this.logContext);
+        }
+        this.emit(TrackEvent.AudioSilenceDetected);
+      }
+      return trackIsSilent;
     });
   }
-  addTrack(req) {
-    if (this.pendingTrackResolvers[req.cid]) {
-      throw new TrackInvalidError('a track with the same ID has already been published');
-    }
-    return new Promise((resolve, reject) => {
-      const publicationTimeout = setTimeout(() => {
-        delete this.pendingTrackResolvers[req.cid];
-        reject(new ConnectionError('publication of local track timed out, no response from server'));
-      }, 10000);
-      this.pendingTrackResolvers[req.cid] = {
-        resolve: info => {
-          clearTimeout(publicationTimeout);
-          resolve(info);
-        },
-        reject: () => {
-          clearTimeout(publicationTimeout);
-          reject(new Error('Cancelled publication by calling unpublish'));
-        }
-      };
-      this.client.sendAddTrack(req);
-    });
+}
+
+/** @internal */
+function mediaTrackToLocalTrack(mediaStreamTrack, constraints, loggerOptions) {
+  switch (mediaStreamTrack.kind) {
+    case 'audio':
+      return new LocalAudioTrack(mediaStreamTrack, constraints, false, undefined, loggerOptions);
+    case 'video':
+      return new LocalVideoTrack(mediaStreamTrack, constraints, false, loggerOptions);
+    default:
+      throw new TrackInvalidError("unsupported track type: ".concat(mediaStreamTrack.kind));
   }
-  /**
-   * Removes sender from PeerConnection, returning true if it was removed successfully
-   * and a negotiation is necessary
-   * @param sender
-   * @returns
-   */
-  removeTrack(sender) {
-    if (sender.track && this.pendingTrackResolvers[sender.track.id]) {
-      const {
-        reject
-      } = this.pendingTrackResolvers[sender.track.id];
-      if (reject) {
-        reject();
-      }
-      delete this.pendingTrackResolvers[sender.track.id];
+}
+/* @internal */
+const presets169 = Object.values(VideoPresets);
+/* @internal */
+const presets43 = Object.values(VideoPresets43);
+/* @internal */
+const presetsScreenShare = Object.values(ScreenSharePresets);
+/* @internal */
+const defaultSimulcastPresets169 = [VideoPresets.h180, VideoPresets.h360];
+/* @internal */
+const defaultSimulcastPresets43 = [VideoPresets43.h180, VideoPresets43.h360];
+/* @internal */
+const computeDefaultScreenShareSimulcastPresets = fromPreset => {
+  const layers = [{
+    scaleResolutionDownBy: 2,
+    fps: fromPreset.encoding.maxFramerate
+  }];
+  return layers.map(t => {
+    var _a, _b;
+    return new VideoPreset(Math.floor(fromPreset.width / t.scaleResolutionDownBy), Math.floor(fromPreset.height / t.scaleResolutionDownBy), Math.max(150000, Math.floor(fromPreset.encoding.maxBitrate / (Math.pow(t.scaleResolutionDownBy, 2) * (((_a = fromPreset.encoding.maxFramerate) !== null && _a !== void 0 ? _a : 30) / ((_b = t.fps) !== null && _b !== void 0 ? _b : 30))))), t.fps, fromPreset.encoding.priority);
+  });
+};
+// /**
+//  *
+//  * @internal
+//  * @experimental
+//  */
+// const computeDefaultMultiCodecSimulcastEncodings = (width: number, height: number) => {
+//   // use vp8 as a default
+//   const vp8 = determineAppropriateEncoding(false, width, height);
+//   const vp9 = { ...vp8, maxBitrate: vp8.maxBitrate * 0.9 };
+//   const h264 = { ...vp8, maxBitrate: vp8.maxBitrate * 1.1 };
+//   const av1 = { ...vp8, maxBitrate: vp8.maxBitrate * 0.7 };
+//   return {
+//     vp8,
+//     vp9,
+//     h264,
+//     av1,
+//   };
+// };
+const videoRids = ['q', 'h', 'f'];
+/* @internal */
+function computeVideoEncodings(isScreenShare, width, height, options) {
+  var _a, _b;
+  let videoEncoding = options === null || options === void 0 ? void 0 : options.videoEncoding;
+  if (isScreenShare) {
+    videoEncoding = options === null || options === void 0 ? void 0 : options.screenShareEncoding;
+  }
+  const useSimulcast = options === null || options === void 0 ? void 0 : options.simulcast;
+  const scalabilityMode = options === null || options === void 0 ? void 0 : options.scalabilityMode;
+  const videoCodec = options === null || options === void 0 ? void 0 : options.videoCodec;
+  if (!videoEncoding && !useSimulcast && !scalabilityMode || !width || !height) {
+    // when we aren't simulcasting or svc, will need to return a single encoding without
+    // capping bandwidth. we always require a encoding for dynacast
+    return [{}];
+  }
+  if (!videoEncoding) {
+    // find the right encoding based on width/height
+    videoEncoding = determineAppropriateEncoding(isScreenShare, width, height, videoCodec);
+    livekitLogger.debug('using video encoding', videoEncoding);
+  }
+  const original = new VideoPreset(width, height, videoEncoding.maxBitrate, videoEncoding.maxFramerate, videoEncoding.priority);
+  if (scalabilityMode && isSVCCodec(videoCodec)) {
+    const sm = new ScalabilityMode(scalabilityMode);
+    const encodings = [];
+    if (sm.spatial > 3) {
+      throw new Error("unsupported scalabilityMode: ".concat(scalabilityMode));
     }
-    try {
-      this.pcManager.removeTrack(sender);
-      return true;
-    } catch (e) {
-      this.log.warn('failed to remove track', Object.assign(Object.assign({}, this.logContext), {
-        error: e
-      }));
+    // Before M113 in Chrome, defining multiple encodings with an SVC codec indicated
+    // that SVC mode should be used. Safari still works this way.
+    // This is a bit confusing but is due to how libwebrtc interpreted the encodings field
+    // before M113.
+    // Announced here: https://groups.google.com/g/discuss-webrtc/c/-QQ3pxrl-fw?pli=1
+    const browser = getBrowser();
+    if (isSafari() || (browser === null || browser === void 0 ? void 0 : browser.name) === 'Chrome' && compareVersions(browser === null || browser === void 0 ? void 0 : browser.version, '113') < 0) {
+      const bitratesRatio = sm.suffix == 'h' ? 2 : 3;
+      for (let i = 0; i < sm.spatial; i += 1) {
+        // in legacy SVC, scaleResolutionDownBy cannot be set
+        encodings.push({
+          rid: videoRids[2 - i],
+          maxBitrate: videoEncoding.maxBitrate / Math.pow(bitratesRatio, i),
+          maxFramerate: original.encoding.maxFramerate
+        });
+      }
+      // legacy SVC, scalabilityMode is set only on the first encoding
+      /* @ts-ignore */
+      encodings[0].scalabilityMode = scalabilityMode;
+    } else {
+      encodings.push({
+        maxBitrate: videoEncoding.maxBitrate,
+        maxFramerate: original.encoding.maxFramerate,
+        /* @ts-ignore */
+        scalabilityMode: scalabilityMode
+      });
     }
-    return false;
+    livekitLogger.debug("using svc encoding", {
+      encodings
+    });
+    return encodings;
   }
-  updateMuteStatus(trackSid, muted) {
-    this.client.sendMuteTrack(trackSid, muted);
+  if (!useSimulcast) {
+    return [videoEncoding];
   }
-  get dataSubscriberReadyState() {
-    var _a;
-    return (_a = this.reliableDCSub) === null || _a === void 0 ? void 0 : _a.readyState;
+  let presets = [];
+  if (isScreenShare) {
+    presets = (_a = sortPresets(options === null || options === void 0 ? void 0 : options.screenShareSimulcastLayers)) !== null && _a !== void 0 ? _a : defaultSimulcastLayers(isScreenShare, original);
+  } else {
+    presets = (_b = sortPresets(options === null || options === void 0 ? void 0 : options.videoSimulcastLayers)) !== null && _b !== void 0 ? _b : defaultSimulcastLayers(isScreenShare, original);
   }
-  getConnectedServerAddress() {
-    return __awaiter(this, void 0, void 0, function* () {
-      var _a;
-      return (_a = this.pcManager) === null || _a === void 0 ? void 0 : _a.getConnectedAddress();
+  let midPreset;
+  if (presets.length > 0) {
+    const lowPreset = presets[0];
+    if (presets.length > 1) {
+      [, midPreset] = presets;
+    }
+    // NOTE:
+    //   1. Ordering of these encodings is important. Chrome seems
+    //      to use the index into encodings to decide which layer
+    //      to disable when CPU constrained.
+    //      So encodings should be ordered in increasing spatial
+    //      resolution order.
+    //   2. livekit-server translates rids into layers. So, all encodings
+    //      should have the base layer `q` and then more added
+    //      based on other conditions.
+    const size = Math.max(width, height);
+    if (size >= 960 && midPreset) {
+      return encodingsFromPresets(width, height, [lowPreset, midPreset, original]);
+    }
+    if (size >= 480) {
+      return encodingsFromPresets(width, height, [lowPreset, original]);
+    }
+  }
+  return encodingsFromPresets(width, height, [original]);
+}
+function computeTrackBackupEncodings(track, videoCodec, opts) {
+  var _a, _b, _c, _d;
+  // backupCodec should not be true anymore, default codec is set in LocalParticipant.publish
+  if (!opts.backupCodec || opts.backupCodec === true || opts.backupCodec.codec === opts.videoCodec) {
+    // backup codec publishing is disabled
+    return;
+  }
+  if (videoCodec !== opts.backupCodec.codec) {
+    livekitLogger.warn('requested a different codec than specified as backup', {
+      serverRequested: videoCodec,
+      backup: opts.backupCodec.codec
     });
   }
-  /* @internal */
-  setRegionUrlProvider(provider) {
-    this.regionUrlProvider = provider;
+  opts.videoCodec = videoCodec;
+  // use backup encoding setting as videoEncoding for backup codec publishing
+  opts.videoEncoding = opts.backupCodec.encoding;
+  const settings = track.mediaStreamTrack.getSettings();
+  const width = (_a = settings.width) !== null && _a !== void 0 ? _a : (_b = track.dimensions) === null || _b === void 0 ? void 0 : _b.width;
+  const height = (_c = settings.height) !== null && _c !== void 0 ? _c : (_d = track.dimensions) === null || _d === void 0 ? void 0 : _d.height;
+  const encodings = computeVideoEncodings(track.source === Track.Source.ScreenShare, width, height, opts);
+  return encodings;
+}
+/* @internal */
+function determineAppropriateEncoding(isScreenShare, width, height, codec) {
+  const presets = presetsForResolution(isScreenShare, width, height);
+  let {
+    encoding
+  } = presets[0];
+  // handle portrait by swapping dimensions
+  const size = Math.max(width, height);
+  for (let i = 0; i < presets.length; i += 1) {
+    const preset = presets[i];
+    encoding = preset.encoding;
+    if (preset.width >= size) {
+      break;
+    }
   }
-  configure(joinResponse) {
-    return __awaiter(this, void 0, void 0, function* () {
-      var _a;
-      // already configured
-      if (this.pcManager && this.pcManager.currentState !== PCTransportState.NEW) {
-        return;
+  // presets are based on the assumption of vp8 as a codec
+  // for other codecs we adjust the maxBitrate if no specific videoEncoding has been provided
+  // users should override these with ones that are optimized for their use case
+  // NOTE: SVC codec bitrates are inclusive of all scalability layers. while
+  // bitrate for non-SVC codecs does not include other simulcast layers.
+  if (codec) {
+    switch (codec) {
+      case 'av1':
+        encoding = Object.assign({}, encoding);
+        encoding.maxBitrate = encoding.maxBitrate * 0.7;
+        break;
+      case 'vp9':
+        encoding = Object.assign({}, encoding);
+        encoding.maxBitrate = encoding.maxBitrate * 0.85;
+        break;
+    }
+  }
+  return encoding;
+}
+/* @internal */
+function presetsForResolution(isScreenShare, width, height) {
+  if (isScreenShare) {
+    return presetsScreenShare;
+  }
+  const aspect = width > height ? width / height : height / width;
+  if (Math.abs(aspect - 16.0 / 9) < Math.abs(aspect - 4.0 / 3)) {
+    return presets169;
+  }
+  return presets43;
+}
+/* @internal */
+function defaultSimulcastLayers(isScreenShare, original) {
+  if (isScreenShare) {
+    return computeDefaultScreenShareSimulcastPresets(original);
+  }
+  const {
+    width,
+    height
+  } = original;
+  const aspect = width > height ? width / height : height / width;
+  if (Math.abs(aspect - 16.0 / 9) < Math.abs(aspect - 4.0 / 3)) {
+    return defaultSimulcastPresets169;
+  }
+  return defaultSimulcastPresets43;
+}
+// presets should be ordered by low, medium, high
+function encodingsFromPresets(width, height, presets) {
+  const encodings = [];
+  presets.forEach((preset, idx) => {
+    if (idx >= videoRids.length) {
+      return;
+    }
+    const size = Math.min(width, height);
+    const rid = videoRids[idx];
+    const encoding = {
+      rid,
+      scaleResolutionDownBy: Math.max(1, size / Math.min(preset.width, preset.height)),
+      maxBitrate: preset.encoding.maxBitrate
+    };
+    if (preset.encoding.maxFramerate) {
+      encoding.maxFramerate = preset.encoding.maxFramerate;
+    }
+    const canSetPriority = isFireFox() || idx === 0;
+    if (preset.encoding.priority && canSetPriority) {
+      encoding.priority = preset.encoding.priority;
+      encoding.networkPriority = preset.encoding.priority;
+    }
+    encodings.push(encoding);
+  });
+  // RN ios simulcast requires all same framerates.
+  if (isReactNative() && getReactNativeOs() === 'ios') {
+    let topFramerate = undefined;
+    encodings.forEach(encoding => {
+      if (!topFramerate) {
+        topFramerate = encoding.maxFramerate;
+      } else if (encoding.maxFramerate && encoding.maxFramerate > topFramerate) {
+        topFramerate = encoding.maxFramerate;
       }
-      this.participantSid = (_a = joinResponse.participant) === null || _a === void 0 ? void 0 : _a.sid;
-      const rtcConfig = this.makeRTCConfiguration(joinResponse);
-      this.pcManager = new PCTransportManager(rtcConfig, joinResponse.subscriberPrimary, this.loggerOptions);
-      this.emit(EngineEvent.TransportsCreated, this.pcManager.publisher, this.pcManager.subscriber);
-      this.pcManager.onIceCandidate = (candidate, target) => {
-        this.client.sendIceCandidate(candidate, target);
-      };
-      this.pcManager.onPublisherOffer = offer => {
-        this.client.sendOffer(offer);
-      };
-      this.pcManager.onDataChannel = this.handleDataChannel;
-      this.pcManager.onStateChange = (connectionState, publisherState, subscriberState) => __awaiter(this, void 0, void 0, function* () {
-        this.log.debug("primary PC state changed ".concat(connectionState), this.logContext);
-        if (['closed', 'disconnected', 'failed'].includes(publisherState)) {
-          // reset publisher connection promise
-          this.publisherConnectionPromise = undefined;
-        }
-        if (connectionState === PCTransportState.CONNECTED) {
-          const shouldEmit = this.pcState === PCState.New;
-          this.pcState = PCState.Connected;
-          if (shouldEmit) {
-            this.emit(EngineEvent.Connected, joinResponse);
-          }
-        } else if (connectionState === PCTransportState.FAILED) {
-          // on Safari, PeerConnection will switch to 'disconnected' during renegotiation
-          if (this.pcState === PCState.Connected) {
-            this.pcState = PCState.Disconnected;
-            this.handleDisconnect('peerconnection failed', subscriberState === 'failed' ? ReconnectReason.RR_SUBSCRIBER_FAILED : ReconnectReason.RR_PUBLISHER_FAILED);
-          }
-        }
-        // detect cases where both signal client and peer connection are severed and assume that user has lost network connection
-        const isSignalSevered = this.client.isDisconnected || this.client.currentState === SignalConnectionState.RECONNECTING;
-        const isPCSevered = [PCTransportState.FAILED, PCTransportState.CLOSING, PCTransportState.CLOSED].includes(connectionState);
-        if (isSignalSevered && isPCSevered && !this._isClosed) {
-          this.emit(EngineEvent.Offline);
-        }
-      });
-      this.pcManager.onTrack = ev => {
-        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.pcManager) {
-        return;
+    let notifyOnce = true;
+    encodings.forEach(encoding => {
+      var _a;
+      if (encoding.maxFramerate != topFramerate) {
+        if (notifyOnce) {
+          notifyOnce = false;
+          livekitLogger.info("Simulcast on iOS React-Native requires all encodings to share the same framerate.");
+        }
+        livekitLogger.info("Setting framerate of encoding \"".concat((_a = encoding.rid) !== null && _a !== void 0 ? _a : '', "\" to ").concat(topFramerate));
+        encoding.maxFramerate = topFramerate;
       }
-      this.log.debug('received server answer', Object.assign(Object.assign({}, this.logContext), {
-        RTCSdpType: sd.type
-      }));
-      yield this.pcManager.setPublisherAnswer(sd);
     });
-    // add candidate on trickle
-    this.client.onTrickle = (candidate, target) => {
-      if (!this.pcManager) {
-        return;
+  }
+  return encodings;
+}
+/** @internal */
+function sortPresets(presets) {
+  if (!presets) return;
+  return presets.sort((a, b) => {
+    const {
+      encoding: aEnc
+    } = a;
+    const {
+      encoding: bEnc
+    } = b;
+    if (aEnc.maxBitrate > bEnc.maxBitrate) {
+      return 1;
+    }
+    if (aEnc.maxBitrate < bEnc.maxBitrate) return -1;
+    if (aEnc.maxBitrate === bEnc.maxBitrate && aEnc.maxFramerate && bEnc.maxFramerate) {
+      return aEnc.maxFramerate > bEnc.maxFramerate ? 1 : -1;
+    }
+    return 0;
+  });
+}
+/** @internal */
+class ScalabilityMode {
+  constructor(scalabilityMode) {
+    const results = scalabilityMode.match(/^L(\d)T(\d)(h|_KEY|_KEY_SHIFT){0,1}$/);
+    if (!results) {
+      throw new Error('invalid scalability mode');
+    }
+    this.spatial = parseInt(results[1]);
+    this.temporal = parseInt(results[2]);
+    if (results.length > 3) {
+      switch (results[3]) {
+        case 'h':
+        case '_KEY':
+        case '_KEY_SHIFT':
+          this.suffix = results[3];
       }
-      this.log.trace('got ICE candidate from peer', Object.assign(Object.assign({}, this.logContext), {
-        candidate,
-        target
-      }));
-      this.pcManager.addIceCandidate(candidate, target);
-    };
-    // when server creates an offer for the client
-    this.client.onOffer = sd => __awaiter(this, void 0, void 0, function* () {
-      if (!this.pcManager) {
+    }
+  }
+  toString() {
+    var _a;
+    return "L".concat(this.spatial, "T").concat(this.temporal).concat((_a = this.suffix) !== null && _a !== void 0 ? _a : '');
+  }
+}
+
+const refreshSubscribedCodecAfterNewCodec = 5000;
+class LocalVideoTrack extends LocalTrack {
+  /**
+   *
+   * @param mediaTrack
+   * @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, constraints) {
+    let userProvidedTrack = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    let loggerOptions = arguments.length > 3 ? arguments[3] : undefined;
+    super(mediaTrack, Track.Kind.Video, constraints, userProvidedTrack, loggerOptions);
+    /* @internal */
+    this.simulcastCodecs = new Map();
+    this.monitorSender = () => __awaiter(this, void 0, void 0, function* () {
+      if (!this.sender) {
+        this._currentBitrate = 0;
         return;
       }
-      const answer = yield this.pcManager.createSubscriberAnswerFromOffer(sd);
-      this.client.sendAnswer(answer);
-    });
-    this.client.onLocalTrackPublished = res => {
-      var _a;
-      this.log.debug('received trackPublishedResponse', Object.assign(Object.assign({}, this.logContext), {
-        cid: res.cid,
-        track: (_a = res.track) === null || _a === void 0 ? void 0 : _a.sid
-      }));
-      if (!this.pendingTrackResolvers[res.cid]) {
-        this.log.error("missing track resolver for ".concat(res.cid), Object.assign(Object.assign({}, this.logContext), {
-          cid: res.cid
+      let stats;
+      try {
+        stats = yield this.getSenderStats();
+      } catch (e) {
+        this.log.error('could not get audio sender stats', Object.assign(Object.assign({}, this.logContext), {
+          error: e
         }));
         return;
       }
-      const {
-        resolve
-      } = this.pendingTrackResolvers[res.cid];
-      delete this.pendingTrackResolvers[res.cid];
-      resolve(res.track);
-    };
-    this.client.onLocalTrackUnpublished = response => {
-      this.emit(EngineEvent.LocalTrackUnpublished, response);
-    };
-    this.client.onTokenRefresh = token => {
-      this.token = token;
-    };
-    this.client.onRemoteMuteChanged = (trackSid, muted) => {
-      this.emit(EngineEvent.RemoteMute, trackSid, muted);
-    };
-    this.client.onSubscribedQualityUpdate = update => {
-      this.emit(EngineEvent.SubscribedQualityUpdate, update);
-    };
-    this.client.onClose = () => {
-      this.handleDisconnect('signal', ReconnectReason.RR_SIGNAL_DISCONNECTED);
-    };
-    this.client.onLeave = leave => {
-      if (leave === null || leave === void 0 ? void 0 : leave.canReconnect) {
-        this.fullReconnectOnNext = true;
-        // reconnect immediately instead of waiting for next attempt
-        this.handleDisconnect(leaveReconnect);
-      } else {
-        this.emit(EngineEvent.Disconnected, leave === null || leave === void 0 ? void 0 : leave.reason);
-        this.close();
-      }
-      this.log.debug('client leave request', Object.assign(Object.assign({}, this.logContext), {
-        reason: leave === null || leave === void 0 ? void 0 : leave.reason
-      }));
-    };
+      const statsMap = new Map(stats.map(s => [s.rid, s]));
+      if (this.prevStats) {
+        let totalBitrate = 0;
+        statsMap.forEach((s, key) => {
+          var _a;
+          const prev = (_a = this.prevStats) === null || _a === void 0 ? void 0 : _a.get(key);
+          totalBitrate += computeBitrate(s, prev);
+        });
+        this._currentBitrate = totalBitrate;
+      }
+      this.prevStats = statsMap;
+    });
+    this.senderLock = new Mutex();
   }
-  makeRTCConfiguration(serverResponse) {
-    var _a;
-    const rtcConfig = Object.assign({}, this.rtcConfig);
-    if ((_a = this.signalOpts) === null || _a === void 0 ? void 0 : _a.e2eeEnabled) {
-      this.log.debug('E2EE - setting up transports with insertable streams', this.logContext);
-      //  this makes sure that no data is sent before the transforms are ready
-      // @ts-ignore
-      rtcConfig.encodedInsertableStreams = true;
-    }
-    // update ICE servers before creating PeerConnection
-    if (serverResponse.iceServers && !rtcConfig.iceServers) {
-      const rtcIceServers = [];
-      serverResponse.iceServers.forEach(iceServer => {
-        const rtcIceServer = {
-          urls: iceServer.urls
-        };
-        if (iceServer.username) rtcIceServer.username = iceServer.username;
-        if (iceServer.credential) {
-          rtcIceServer.credential = iceServer.credential;
-        }
-        rtcIceServers.push(rtcIceServer);
-      });
-      rtcConfig.iceServers = rtcIceServers;
-    }
-    if (serverResponse.clientConfiguration && serverResponse.clientConfiguration.forceRelay === ClientConfigSetting.ENABLED) {
-      rtcConfig.iceTransportPolicy = 'relay';
+  get isSimulcast() {
+    if (this.sender && this.sender.getParameters().encodings.length > 1) {
+      return true;
     }
-    // @ts-ignore
-    rtcConfig.sdpSemantics = 'unified-plan';
-    // @ts-ignore
-    rtcConfig.continualGatheringPolicy = 'gather_continually';
-    return rtcConfig;
+    return false;
   }
-  createDataChannels() {
-    if (!this.pcManager) {
+  /* @internal */
+  startMonitor(signalClient) {
+    var _a;
+    this.signalClient = signalClient;
+    if (!isWeb()) {
       return;
     }
-    // clear old data channel callbacks if recreate
-    if (this.lossyDC) {
-      this.lossyDC.onmessage = null;
-      this.lossyDC.onerror = null;
+    // save original encodings
+    // TODO : merge simulcast tracks stats
+    const params = (_a = this.sender) === null || _a === void 0 ? void 0 : _a.getParameters();
+    if (params) {
+      this.encodings = params.encodings;
     }
-    if (this.reliableDC) {
-      this.reliableDC.onmessage = null;
-      this.reliableDC.onerror = null;
+    if (this.monitorInterval) {
+      return;
     }
-    // create data channels
-    this.lossyDC = this.pcManager.createPublisherDataChannel(lossyDataChannel, {
-      // will drop older packets that arrive
-      ordered: true,
-      maxRetransmits: 0
+    this.monitorInterval = setInterval(() => {
+      this.monitorSender();
+    }, monitorFrequency);
+  }
+  stop() {
+    this._mediaStreamTrack.getConstraints();
+    this.simulcastCodecs.forEach(trackInfo => {
+      trackInfo.mediaStreamTrack.stop();
     });
-    this.reliableDC = this.pcManager.createPublisherDataChannel(reliableDataChannel, {
-      ordered: true
+    super.stop();
+  }
+  pauseUpstream() {
+    const _super = Object.create(null, {
+      pauseUpstream: {
+        get: () => super.pauseUpstream
+      }
+    });
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a, e_1, _b, _c;
+      var _d;
+      yield _super.pauseUpstream.call(this);
+      try {
+        for (var _e = true, _f = __asyncValues(this.simulcastCodecs.values()), _g; _g = yield _f.next(), _a = _g.done, !_a; _e = true) {
+          _c = _g.value;
+          _e = false;
+          const sc = _c;
+          yield (_d = sc.sender) === null || _d === void 0 ? void 0 : _d.replaceTrack(null);
+        }
+      } catch (e_1_1) {
+        e_1 = {
+          error: e_1_1
+        };
+      } finally {
+        try {
+          if (!_e && !_a && (_b = _f.return)) yield _b.call(_f);
+        } finally {
+          if (e_1) throw e_1.error;
+        }
+      }
     });
-    // also handle messages over the pub channel, for backwards compatibility
-    this.lossyDC.onmessage = this.handleDataMessage;
-    this.reliableDC.onmessage = this.handleDataMessage;
-    // handle datachannel errors
-    this.lossyDC.onerror = this.handleDataError;
-    this.reliableDC.onerror = this.handleDataError;
-    // set up dc buffer threshold, set to 64kB (otherwise 0 by default)
-    this.lossyDC.bufferedAmountLowThreshold = 65535;
-    this.reliableDC.bufferedAmountLowThreshold = 65535;
-    // handle buffer amount low events
-    this.lossyDC.onbufferedamountlow = this.handleBufferedAmountLow;
-    this.reliableDC.onbufferedamountlow = this.handleBufferedAmountLow;
   }
-  setPreferredCodec(transceiver, kind, videoCodec) {
-    if (!('getCapabilities' in RTCRtpReceiver)) {
-      return;
-    }
-    // when setting codec preferences, the capabilites need to be read from the RTCRtpReceiver
-    const cap = RTCRtpReceiver.getCapabilities(kind);
-    if (!cap) return;
-    this.log.debug('get receiver capabilities', Object.assign(Object.assign({}, this.logContext), {
-      cap
-    }));
-    const matched = [];
-    const partialMatched = [];
-    const unmatched = [];
-    cap.codecs.forEach(c => {
-      const codec = c.mimeType.toLowerCase();
-      if (codec === 'audio/opus') {
-        matched.push(c);
-        return;
+  resumeUpstream() {
+    const _super = Object.create(null, {
+      resumeUpstream: {
+        get: () => super.resumeUpstream
       }
-      const matchesVideoCodec = codec === "video/".concat(videoCodec);
-      if (!matchesVideoCodec) {
-        unmatched.push(c);
-        return;
+    });
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a, e_2, _b, _c;
+      var _d;
+      yield _super.resumeUpstream.call(this);
+      try {
+        for (var _e = true, _f = __asyncValues(this.simulcastCodecs.values()), _g; _g = yield _f.next(), _a = _g.done, !_a; _e = true) {
+          _c = _g.value;
+          _e = false;
+          const sc = _c;
+          yield (_d = sc.sender) === null || _d === void 0 ? void 0 : _d.replaceTrack(sc.mediaStreamTrack);
+        }
+      } catch (e_2_1) {
+        e_2 = {
+          error: e_2_1
+        };
+      } finally {
+        try {
+          if (!_e && !_a && (_b = _f.return)) yield _b.call(_f);
+        } finally {
+          if (e_2) throw e_2.error;
+        }
       }
-      // for h264 codecs that have sdpFmtpLine available, use only if the
-      // profile-level-id is 42e01f for cross-browser compatibility
-      if (videoCodec === 'h264') {
-        if (c.sdpFmtpLine && c.sdpFmtpLine.includes('profile-level-id=42e01f')) {
-          matched.push(c);
-        } else {
-          partialMatched.push(c);
+    });
+  }
+  mute() {
+    const _super = Object.create(null, {
+      mute: {
+        get: () => super.mute
+      }
+    });
+    return __awaiter(this, void 0, void 0, function* () {
+      const unlock = yield this.muteLock.lock();
+      try {
+        if (this.isMuted) {
+          this.log.debug('Track already muted', this.logContext);
+          return this;
         }
-        return;
+        if (this.source === Track.Source.Camera && !this.isUserProvided) {
+          this.log.debug('stopping camera track', this.logContext);
+          // also stop the track, so that camera indicator is turned off
+          this._mediaStreamTrack.stop();
+        }
+        yield _super.mute.call(this);
+        return this;
+      } finally {
+        unlock();
       }
-      matched.push(c);
     });
-    if (supportsSetCodecPreferences(transceiver)) {
-      transceiver.setCodecPreferences(matched.concat(partialMatched, unmatched));
-    }
   }
-  createSender(track, opts, encodings) {
+  unmute() {
+    const _super = Object.create(null, {
+      unmute: {
+        get: () => super.unmute
+      }
+    });
     return __awaiter(this, void 0, void 0, function* () {
-      if (supportsTransceiver()) {
-        const sender = yield this.createTransceiverRTCRtpSender(track, opts, encodings);
-        return sender;
+      const unlock = yield this.muteLock.lock();
+      try {
+        if (!this.isMuted) {
+          this.log.debug('Track already unmuted', this.logContext);
+          return this;
+        }
+        if (this.source === Track.Source.Camera && !this.isUserProvided) {
+          this.log.debug('reacquiring camera track', this.logContext);
+          yield this.restartTrack();
+        }
+        yield _super.unmute.call(this);
+        return this;
+      } finally {
+        unlock();
       }
-      if (supportsAddTrack()) {
-        this.log.warn('using add-track fallback', this.logContext);
-        const sender = yield this.createRTCRtpSender(track.mediaStreamTrack);
-        return sender;
+    });
+  }
+  setTrackMuted(muted) {
+    super.setTrackMuted(muted);
+    for (const sc of this.simulcastCodecs.values()) {
+      sc.mediaStreamTrack.enabled = !muted;
+    }
+  }
+  getSenderStats() {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a;
+      if (!((_a = this.sender) === null || _a === void 0 ? void 0 : _a.getStats)) {
+        return [];
       }
-      throw new UnexpectedConnectionState('Required webRTC APIs not supported on this device');
+      const items = [];
+      const stats = yield this.sender.getStats();
+      stats.forEach(v => {
+        var _a;
+        if (v.type === 'outbound-rtp') {
+          const vs = {
+            type: 'video',
+            streamId: v.id,
+            frameHeight: v.frameHeight,
+            frameWidth: v.frameWidth,
+            framesPerSecond: v.framesPerSecond,
+            framesSent: v.framesSent,
+            firCount: v.firCount,
+            pliCount: v.pliCount,
+            nackCount: v.nackCount,
+            packetsSent: v.packetsSent,
+            bytesSent: v.bytesSent,
+            qualityLimitationReason: v.qualityLimitationReason,
+            qualityLimitationDurations: v.qualityLimitationDurations,
+            qualityLimitationResolutionChanges: v.qualityLimitationResolutionChanges,
+            rid: (_a = v.rid) !== null && _a !== void 0 ? _a : v.id,
+            retransmittedPacketsSent: v.retransmittedPacketsSent,
+            targetBitrate: v.targetBitrate,
+            timestamp: v.timestamp
+          };
+          // locate the appropriate remote-inbound-rtp item
+          const r = stats.get(v.remoteId);
+          if (r) {
+            vs.jitter = r.jitter;
+            vs.packetsLost = r.packetsLost;
+            vs.roundTripTime = r.roundTripTime;
+          }
+          items.push(vs);
+        }
+      });
+      // make sure highest res layer is always first
+      items.sort((a, b) => {
+        var _a, _b;
+        return ((_a = b.frameWidth) !== null && _a !== void 0 ? _a : 0) - ((_b = a.frameWidth) !== null && _b !== void 0 ? _b : 0);
+      });
+      return items;
     });
   }
-  createSimulcastSender(track, simulcastTrack, opts, encodings) {
-    return __awaiter(this, void 0, void 0, function* () {
-      // store RTCRtpSender
-      if (supportsTransceiver()) {
-        return this.createSimulcastTransceiverSender(track, simulcastTrack, opts, encodings);
-      }
-      if (supportsAddTrack()) {
-        this.log.debug('using add-track fallback', this.logContext);
-        return this.createRTCRtpSender(track.mediaStreamTrack);
-      }
-      throw new UnexpectedConnectionState('Cannot stream on this device');
-    });
+  setPublishingQuality(maxQuality) {
+    const qualities = [];
+    for (let q = VideoQuality.LOW; q <= VideoQuality.HIGH; q += 1) {
+      qualities.push(new SubscribedQuality({
+        quality: q,
+        enabled: q <= maxQuality
+      }));
+    }
+    this.log.debug("setting publishing quality. max quality ".concat(maxQuality), this.logContext);
+    this.setPublishingLayers(qualities);
   }
-  createTransceiverRTCRtpSender(track, opts, encodings) {
+  setDeviceId(deviceId) {
     return __awaiter(this, void 0, void 0, function* () {
-      if (!this.pcManager) {
-        throw new UnexpectedConnectionState('publisher is closed');
-      }
-      const streams = [];
-      if (track.mediaStream) {
-        streams.push(track.mediaStream);
-      }
-      const transceiverInit = {
-        direction: 'sendonly',
-        streams
-      };
-      if (encodings) {
-        transceiverInit.sendEncodings = encodings;
+      if (this._constraints.deviceId === deviceId && this._mediaStreamTrack.getSettings().deviceId === unwrapConstraint(deviceId)) {
+        return true;
       }
-      // addTransceiver for react-native is async. web is synchronous, but await won't effect it.
-      const transceiver = yield this.pcManager.addPublisherTransceiver(track.mediaStreamTrack, transceiverInit);
-      if (track.kind === Track.Kind.Video && opts.videoCodec) {
-        this.setPreferredCodec(transceiver, track.kind, opts.videoCodec);
-        track.codec = opts.videoCodec;
+      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 transceiver.sender;
+      return this.isMuted || unwrapConstraint(deviceId) === this._mediaStreamTrack.getSettings().deviceId;
     });
   }
-  createSimulcastTransceiverSender(track, simulcastTrack, opts, encodings) {
+  restartTrack(options) {
     return __awaiter(this, void 0, void 0, function* () {
-      if (!this.pcManager) {
-        throw new UnexpectedConnectionState('publisher is closed');
-      }
-      const transceiverInit = {
-        direction: 'sendonly'
-      };
-      if (encodings) {
-        transceiverInit.sendEncodings = encodings;
+      var _a, e_3, _b, _c;
+      let constraints;
+      if (options) {
+        const streamConstraints = constraintsForOptions({
+          video: options
+        });
+        if (typeof streamConstraints.video !== 'boolean') {
+          constraints = streamConstraints.video;
+        }
       }
-      // addTransceiver for react-native is async. web is synchronous, but await won't effect it.
-      const transceiver = yield this.pcManager.addPublisherTransceiver(simulcastTrack.mediaStreamTrack, transceiverInit);
-      if (!opts.videoCodec) {
-        return;
+      yield this.restart(constraints);
+      try {
+        for (var _d = true, _e = __asyncValues(this.simulcastCodecs.values()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+          _c = _f.value;
+          _d = false;
+          const sc = _c;
+          if (sc.sender) {
+            sc.mediaStreamTrack = this.mediaStreamTrack.clone();
+            yield sc.sender.replaceTrack(sc.mediaStreamTrack);
+          }
+        }
+      } catch (e_3_1) {
+        e_3 = {
+          error: e_3_1
+        };
+      } finally {
+        try {
+          if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+        } finally {
+          if (e_3) throw e_3.error;
+        }
       }
-      this.setPreferredCodec(transceiver, track.kind, opts.videoCodec);
-      track.setSimulcastTrackSender(opts.videoCodec, transceiver.sender);
-      return transceiver.sender;
     });
   }
-  createRTCRtpSender(track) {
-    return __awaiter(this, void 0, void 0, function* () {
-      if (!this.pcManager) {
-        throw new UnexpectedConnectionState('publisher is closed');
+  setProcessor(processor_1) {
+    const _super = Object.create(null, {
+      setProcessor: {
+        get: () => super.setProcessor
       }
-      return this.pcManager.addPublisherTrack(track);
     });
-  }
-  attemptReconnect(reason) {
-    return __awaiter(this, void 0, void 0, function* () {
-      var _a, _b, _c;
-      if (this._isClosed) {
-        return;
-      }
-      // guard for attempting reconnection multiple times while one attempt is still not finished
-      if (this.attemptingReconnect) {
-        livekitLogger.warn('already attempting reconnect, returning early', this.logContext);
-        return;
-      }
-      if (((_a = this.clientConfiguration) === null || _a === void 0 ? void 0 : _a.resumeConnection) === ClientConfigSetting.DISABLED ||
-      // signaling state could change to closed due to hardware sleep
-      // those connections cannot be resumed
-      ((_c = (_b = this.pcManager) === null || _b === void 0 ? void 0 : _b.currentState) !== null && _c !== void 0 ? _c : PCTransportState.NEW) === PCTransportState.NEW) {
-        this.fullReconnectOnNext = true;
-      }
-      try {
-        this.attemptingReconnect = true;
-        if (this.fullReconnectOnNext) {
-          yield this.restartConnection();
-        } else {
-          yield this.resumeConnection(reason);
-        }
-        this.clearPendingReconnect();
-        this.fullReconnectOnNext = false;
-      } catch (e) {
-        this.reconnectAttempts += 1;
-        let recoverable = true;
-        if (e instanceof UnexpectedConnectionState) {
-          this.log.debug('received unrecoverable error', Object.assign(Object.assign({}, this.logContext), {
-            error: e
-          }));
-          // unrecoverable
-          recoverable = false;
-        } else if (!(e instanceof SignalReconnectError)) {
-          // cannot resume
-          this.fullReconnectOnNext = true;
-        }
-        if (recoverable) {
-          this.handleDisconnect('reconnect', ReconnectReason.RR_UNKNOWN);
-        } else {
-          this.log.info("could not recover connection after ".concat(this.reconnectAttempts, " attempts, ").concat(Date.now() - this.reconnectStart, "ms. giving up"), this.logContext);
-          this.emit(EngineEvent.Disconnected);
-          yield this.close();
+    return __awaiter(this, arguments, void 0, function (processor) {
+      var _this = this;
+      let showProcessedStreamLocally = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      return function* () {
+        var _a, e_4, _b, _c;
+        var _d, _e;
+        yield _super.setProcessor.call(_this, processor, showProcessedStreamLocally);
+        if ((_d = _this.processor) === null || _d === void 0 ? void 0 : _d.processedTrack) {
+          try {
+            for (var _f = true, _g = __asyncValues(_this.simulcastCodecs.values()), _h; _h = yield _g.next(), _a = _h.done, !_a; _f = true) {
+              _c = _h.value;
+              _f = false;
+              const sc = _c;
+              yield (_e = sc.sender) === null || _e === void 0 ? void 0 : _e.replaceTrack(_this.processor.processedTrack);
+            }
+          } catch (e_4_1) {
+            e_4 = {
+              error: e_4_1
+            };
+          } finally {
+            try {
+              if (!_f && !_a && (_b = _g.return)) yield _b.call(_g);
+            } finally {
+              if (e_4) throw e_4.error;
+            }
+          }
         }
-      } finally {
-        this.attemptingReconnect = false;
-      }
+      }();
     });
   }
-  getNextRetryDelay(context) {
-    try {
-      return this.reconnectPolicy.nextRetryDelayInMs(context);
-    } catch (e) {
-      this.log.warn('encountered error in reconnect policy', Object.assign(Object.assign({}, this.logContext), {
-        error: e
-      }));
+  addSimulcastTrack(codec, encodings) {
+    if (this.simulcastCodecs.has(codec)) {
+      this.log.error("".concat(codec, " already added, skipping adding simulcast codec"), this.logContext);
+      return;
     }
-    // error in user code with provided reconnect policy, stop reconnecting
-    return null;
+    const simulcastCodecInfo = {
+      codec,
+      mediaStreamTrack: this.mediaStreamTrack.clone(),
+      sender: undefined,
+      encodings
+    };
+    this.simulcastCodecs.set(codec, simulcastCodecInfo);
+    return simulcastCodecInfo;
   }
-  restartConnection(regionUrl) {
+  setSimulcastTrackSender(codec, sender) {
+    const simulcastCodecInfo = this.simulcastCodecs.get(codec);
+    if (!simulcastCodecInfo) {
+      return;
+    }
+    simulcastCodecInfo.sender = sender;
+    // browser will reenable disabled codec/layers after new codec has been published,
+    // so refresh subscribedCodecs after publish a new codec
+    setTimeout(() => {
+      if (this.subscribedCodecs) {
+        this.setPublishingCodecs(this.subscribedCodecs);
+      }
+    }, refreshSubscribedCodecAfterNewCodec);
+  }
+  /**
+   * @internal
+   * Sets codecs that should be publishing, returns new codecs that have not yet
+   * been published
+   */
+  setPublishingCodecs(codecs) {
     return __awaiter(this, void 0, void 0, function* () {
-      var _a, _b, _c;
-      try {
-        if (!this.url || !this.token) {
-          // permanent failure, don't attempt reconnection
-          throw new UnexpectedConnectionState('could not reconnect, url or token not saved');
-        }
-        this.log.info("reconnecting, attempt: ".concat(this.reconnectAttempts), this.logContext);
-        this.emit(EngineEvent.Restarting);
-        if (!this.client.isDisconnected) {
-          yield this.client.sendLeave();
-        }
-        yield this.cleanupPeerConnections();
-        yield this.cleanupClient();
-        let joinResponse;
-        try {
-          if (!this.signalOpts) {
-            this.log.warn('attempted connection restart, without signal options present', this.logContext);
-            throw new SignalReconnectError();
-          }
-          // in case a regionUrl is passed, the region URL takes precedence
-          joinResponse = yield this.join(regionUrl !== null && regionUrl !== void 0 ? regionUrl : this.url, this.token, this.signalOpts);
-        } catch (e) {
-          if (e instanceof ConnectionError && e.reason === 0 /* ConnectionErrorReason.NotAllowed */) {
-            throw new UnexpectedConnectionState('could not reconnect, token might be expired');
+      var _a, codecs_1, codecs_1_1;
+      var _b, e_5, _c, _d;
+      this.log.debug('setting publishing codecs', Object.assign(Object.assign({}, this.logContext), {
+        codecs,
+        currentCodec: this.codec
+      }));
+      // only enable simulcast codec for preference codec setted
+      if (!this.codec && codecs.length > 0) {
+        yield this.setPublishingLayers(codecs[0].qualities);
+        return [];
+      }
+      this.subscribedCodecs = codecs;
+      const newCodecs = [];
+      try {
+        for (_a = true, codecs_1 = __asyncValues(codecs); codecs_1_1 = yield codecs_1.next(), _b = codecs_1_1.done, !_b; _a = true) {
+          _d = codecs_1_1.value;
+          _a = false;
+          const codec = _d;
+          if (!this.codec || this.codec === codec.codec) {
+            yield this.setPublishingLayers(codec.qualities);
+          } else {
+            const simulcastCodecInfo = this.simulcastCodecs.get(codec.codec);
+            this.log.debug("try setPublishingCodec for ".concat(codec.codec), Object.assign(Object.assign({}, this.logContext), {
+              simulcastCodecInfo
+            }));
+            if (!simulcastCodecInfo || !simulcastCodecInfo.sender) {
+              for (const q of codec.qualities) {
+                if (q.enabled) {
+                  newCodecs.push(codec.codec);
+                  break;
+                }
+              }
+            } else if (simulcastCodecInfo.encodings) {
+              this.log.debug("try setPublishingLayersForSender ".concat(codec.codec), this.logContext);
+              yield setPublishingLayersForSender(simulcastCodecInfo.sender, simulcastCodecInfo.encodings, codec.qualities, this.senderLock, this.log, this.logContext);
+            }
           }
-          throw new SignalReconnectError();
-        }
-        if (this.shouldFailNext) {
-          this.shouldFailNext = false;
-          throw new Error('simulated failure');
-        }
-        this.client.setReconnected();
-        this.emit(EngineEvent.SignalRestarted, joinResponse);
-        yield this.waitForPCReconnected();
-        // re-check signal connection state before setting engine as resumed
-        if (this.client.currentState !== SignalConnectionState.CONNECTED) {
-          throw new SignalReconnectError('Signal connection got severed during reconnect');
         }
-        (_a = this.regionUrlProvider) === null || _a === void 0 ? void 0 : _a.resetAttempts();
-        // reconnect success
-        this.emit(EngineEvent.Restarted);
-      } catch (error) {
-        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)
-          (_c = this.regionUrlProvider) === null || _c === void 0 ? void 0 : _c.resetAttempts();
-          throw error;
+      } catch (e_5_1) {
+        e_5 = {
+          error: e_5_1
+        };
+      } finally {
+        try {
+          if (!_a && !_b && (_c = codecs_1.return)) yield _c.call(codecs_1);
+        } finally {
+          if (e_5) throw e_5.error;
         }
       }
+      return newCodecs;
     });
   }
-  resumeConnection(reason) {
+  /**
+   * @internal
+   * Sets layers that should be publishing
+   */
+  setPublishingLayers(qualities) {
     return __awaiter(this, void 0, void 0, function* () {
-      var _a;
-      if (!this.url || !this.token) {
-        // permanent failure, don't attempt reconnection
-        throw new UnexpectedConnectionState('could not reconnect, url or token not saved');
+      this.log.debug('setting publishing layers', Object.assign(Object.assign({}, this.logContext), {
+        qualities
+      }));
+      if (!this.sender || !this.encodings) {
+        return;
       }
-      // trigger publisher reconnect
-      if (!this.pcManager) {
-        throw new UnexpectedConnectionState('publisher and subscriber connections unset');
+      yield setPublishingLayersForSender(this.sender, this.encodings, qualities, this.senderLock, this.log, this.logContext);
+    });
+  }
+  handleAppVisibilityChanged() {
+    const _super = Object.create(null, {
+      handleAppVisibilityChanged: {
+        get: () => super.handleAppVisibilityChanged
       }
-      this.log.info("resuming signal connection, attempt ".concat(this.reconnectAttempts), this.logContext);
-      this.emit(EngineEvent.Resuming);
-      let res;
-      try {
-        this.setupSignalClientCallbacks();
-        res = yield this.client.reconnect(this.url, this.token, this.participantSid, reason);
-      } catch (error) {
-        let message = '';
-        if (error instanceof Error) {
-          message = error.message;
-          this.log.error(error.message, Object.assign(Object.assign({}, this.logContext), {
-            error
-          }));
-        }
-        if (error instanceof ConnectionError && error.reason === 0 /* ConnectionErrorReason.NotAllowed */) {
-          throw new UnexpectedConnectionState('could not reconnect, token might be expired');
-        }
-        if (error instanceof ConnectionError && error.reason === 4 /* ConnectionErrorReason.LeaveRequest */) {
-          throw error;
-        }
-        throw new SignalReconnectError(message);
+    });
+    return __awaiter(this, void 0, void 0, function* () {
+      yield _super.handleAppVisibilityChanged.call(this);
+      if (!isMobile()) return;
+      if (this.isInBackground && this.source === Track.Source.Camera) {
+        this._mediaStreamTrack.enabled = false;
       }
-      this.emit(EngineEvent.SignalResumed);
-      if (res) {
-        const rtcConfig = this.makeRTCConfiguration(res);
-        this.pcManager.updateConfiguration(rtcConfig);
-      } else {
-        this.log.warn('Did not receive reconnect response', this.logContext);
+    });
+  }
+}
+function setPublishingLayersForSender(sender, senderEncodings, qualities, senderLock, log, logContext) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const unlock = yield senderLock.lock();
+    log.debug('setPublishingLayersForSender', Object.assign(Object.assign({}, logContext), {
+      sender,
+      qualities,
+      senderEncodings
+    }));
+    try {
+      const params = sender.getParameters();
+      const {
+        encodings
+      } = params;
+      if (!encodings) {
+        return;
       }
-      if (this.shouldFailNext) {
-        this.shouldFailNext = false;
-        throw new Error('simulated failure');
+      if (encodings.length !== senderEncodings.length) {
+        log.warn('cannot set publishing layers, encodings mismatch', Object.assign(Object.assign({}, logContext), {
+          encodings,
+          senderEncodings
+        }));
+        return;
       }
-      yield this.pcManager.triggerIceRestart();
-      yield this.waitForPCReconnected();
-      // re-check signal connection state before setting engine as resumed
-      if (this.client.currentState !== SignalConnectionState.CONNECTED) {
-        throw new SignalReconnectError('Signal connection got severed during reconnect');
+      let hasChanged = false;
+      /* disable closable spatial layer as it has video blur / frozen issue with current server / client
+      1. chrome 113: when switching to up layer with scalability Mode change, it will generate a
+            low resolution frame and recover very quickly, but noticable
+      2. livekit sfu: additional pli request cause video frozen for a few frames, also noticable */
+      const closableSpatial = false;
+      /* @ts-ignore */
+      if (closableSpatial && encodings[0].scalabilityMode) ; else {
+        // simulcast dynacast encodings
+        encodings.forEach((encoding, idx) => {
+          var _a;
+          let rid = (_a = encoding.rid) !== null && _a !== void 0 ? _a : '';
+          if (rid === '') {
+            rid = 'q';
+          }
+          const quality = videoQualityForRid(rid);
+          const subscribedQuality = qualities.find(q => q.quality === quality);
+          if (!subscribedQuality) {
+            return;
+          }
+          if (encoding.active !== subscribedQuality.enabled) {
+            hasChanged = true;
+            encoding.active = subscribedQuality.enabled;
+            log.debug("setting layer ".concat(subscribedQuality.quality, " to ").concat(encoding.active ? 'enabled' : 'disabled'), logContext);
+            // FireFox does not support setting encoding.active to false, so we
+            // have a workaround of lowering its bitrate and resolution to the min.
+            if (isFireFox()) {
+              if (subscribedQuality.enabled) {
+                encoding.scaleResolutionDownBy = senderEncodings[idx].scaleResolutionDownBy;
+                encoding.maxBitrate = senderEncodings[idx].maxBitrate;
+                /* @ts-ignore */
+                encoding.maxFrameRate = senderEncodings[idx].maxFrameRate;
+              } else {
+                encoding.scaleResolutionDownBy = 4;
+                encoding.maxBitrate = 10;
+                /* @ts-ignore */
+                encoding.maxFrameRate = 2;
+              }
+            }
+          }
+        });
       }
-      this.client.setReconnected();
-      // recreate publish datachannel if it's id is null
-      // (for safari https://bugs.webkit.org/show_bug.cgi?id=184688)
-      if (((_a = this.reliableDC) === null || _a === void 0 ? void 0 : _a.readyState) === 'open' && this.reliableDC.id === null) {
-        this.createDataChannels();
+      if (hasChanged) {
+        params.encodings = encodings;
+        log.debug("setting encodings", Object.assign(Object.assign({}, logContext), {
+          encodings: params.encodings
+        }));
+        yield sender.setParameters(params);
       }
-      // resume success
-      this.emit(EngineEvent.Resumed);
-    });
+    } finally {
+      unlock();
+    }
+  });
+}
+function videoQualityForRid(rid) {
+  switch (rid) {
+    case 'f':
+      return VideoQuality.HIGH;
+    case 'h':
+      return VideoQuality.MEDIUM;
+    case 'q':
+      return VideoQuality.LOW;
+    default:
+      return VideoQuality.HIGH;
   }
-  waitForPCInitialConnection(timeout, abortController) {
-    return __awaiter(this, void 0, void 0, function* () {
-      if (!this.pcManager) {
-        throw new UnexpectedConnectionState('PC manager is closed');
-      }
-      yield this.pcManager.ensurePCTransportConnection(abortController, timeout);
-    });
+}
+function videoLayersFromEncodings(width, height, encodings, svc) {
+  // default to a single layer, HQ
+  if (!encodings) {
+    return [new VideoLayer({
+      quality: VideoQuality.HIGH,
+      width,
+      height,
+      bitrate: 0,
+      ssrc: 0
+    })];
+  }
+  if (svc) {
+    // svc layers
+    /* @ts-ignore */
+    const encodingSM = encodings[0].scalabilityMode;
+    const sm = new ScalabilityMode(encodingSM);
+    const layers = [];
+    const resRatio = sm.suffix == 'h' ? 1.5 : 2;
+    const bitratesRatio = sm.suffix == 'h' ? 2 : 3;
+    for (let i = 0; i < sm.spatial; i += 1) {
+      layers.push(new VideoLayer({
+        quality: VideoQuality.HIGH - i,
+        width: Math.ceil(width / Math.pow(resRatio, i)),
+        height: Math.ceil(height / Math.pow(resRatio, i)),
+        bitrate: encodings[0].maxBitrate ? Math.ceil(encodings[0].maxBitrate / Math.pow(bitratesRatio, i)) : 0,
+        ssrc: 0
+      }));
+    }
+    return layers;
   }
-  waitForPCReconnected() {
-    return __awaiter(this, void 0, void 0, function* () {
-      this.pcState = PCState.Reconnecting;
-      this.log.debug('waiting for peer connection to reconnect', this.logContext);
-      try {
-        yield sleep(minReconnectWait); // FIXME setTimeout again not ideal for a connection critical path
-        if (!this.pcManager) {
-          throw new UnexpectedConnectionState('PC manager is closed');
-        }
-        yield this.pcManager.ensurePCTransportConnection(undefined, this.peerConnectionTimeout);
-        this.pcState = PCState.Connected;
-      } catch (e) {
-        // TODO do we need a `failed` state here for the PC?
-        this.pcState = PCState.Disconnected;
-        throw new ConnectionError("could not establish PC connection, ".concat(e.message));
-      }
+  return encodings.map(encoding => {
+    var _a, _b, _c;
+    const scale = (_a = encoding.scaleResolutionDownBy) !== null && _a !== void 0 ? _a : 1;
+    let quality = videoQualityForRid((_b = encoding.rid) !== null && _b !== void 0 ? _b : '');
+    return new VideoLayer({
+      quality,
+      width: Math.ceil(width / scale),
+      height: Math.ceil(height / scale),
+      bitrate: (_c = encoding.maxBitrate) !== null && _c !== void 0 ? _c : 0,
+      ssrc: 0
     });
+  });
+}
+
+const lossyDataChannel = '_lossy';
+const reliableDataChannel = '_reliable';
+const minReconnectWait = 2 * 1000;
+const leaveReconnect = 'leave-reconnect';
+var PCState;
+(function (PCState) {
+  PCState[PCState["New"] = 0] = "New";
+  PCState[PCState["Connected"] = 1] = "Connected";
+  PCState[PCState["Disconnected"] = 2] = "Disconnected";
+  PCState[PCState["Reconnecting"] = 3] = "Reconnecting";
+  PCState[PCState["Closed"] = 4] = "Closed";
+})(PCState || (PCState = {}));
+/** @internal */
+class RTCEngine extends eventsExports.EventEmitter {
+  get isClosed() {
+    return this._isClosed;
   }
-  /* @internal */
-  sendDataPacket(packet, kind) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const msg = packet.toBinary();
-      // make sure we do have a data connection
-      yield this.ensurePublisherConnected(kind);
-      const dc = this.dataChannelForKind(kind);
-      if (dc) {
-        dc.send(msg);
-      }
-      this.updateAndEmitDCBufferStatus(kind);
-    });
+  get pendingReconnect() {
+    return !!this.reconnectTimeout;
   }
-  /**
-   * @internal
-   */
-  ensureDataTransportConnected(kind_1) {
-    return __awaiter(this, arguments, void 0, function (kind) {
-      var _this2 = this;
-      let subscriber = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.subscriberPrimary;
+  constructor(options) {
+    var _a;
+    super();
+    this.options = options;
+    this.rtcConfig = {};
+    this.peerConnectionTimeout = roomConnectOptionDefaults.peerConnectionTimeout;
+    this.fullReconnectOnNext = false;
+    this.subscriberPrimary = false;
+    this.pcState = PCState.New;
+    this._isClosed = true;
+    this.pendingTrackResolvers = {};
+    this.reconnectAttempts = 0;
+    this.reconnectStart = 0;
+    this.attemptingReconnect = false;
+    /** keeps track of how often an initial join connection has been tried */
+    this.joinAttempts = 0;
+    /** specifies how often an initial join connection is allowed to retry */
+    this.maxJoinAttempts = 1;
+    this.shouldFailNext = false;
+    this.log = livekitLogger;
+    this.handleDataChannel = _b => __awaiter(this, [_b], void 0, function (_ref) {
+      var _this = this;
+      let {
+        channel
+      } = _ref;
       return function* () {
-        var _a;
-        if (!_this2.pcManager) {
-          throw new UnexpectedConnectionState('PC manager is closed');
-        }
-        const transport = subscriber ? _this2.pcManager.subscriber : _this2.pcManager.publisher;
-        const transportName = subscriber ? 'Subscriber' : 'Publisher';
-        if (!transport) {
-          throw new ConnectionError("".concat(transportName, " connection not set"));
-        }
-        if (!subscriber && !_this2.pcManager.publisher.isICEConnected && _this2.pcManager.publisher.getICEConnectionState() !== 'checking') {
-          // start negotiation
-          _this2.negotiate();
-        }
-        const targetChannel = _this2.dataChannelForKind(kind, subscriber);
-        if ((targetChannel === null || targetChannel === void 0 ? void 0 : targetChannel.readyState) === 'open') {
+        if (!channel) {
           return;
         }
-        // wait until ICE connected
-        const endTime = new Date().getTime() + _this2.peerConnectionTimeout;
-        while (new Date().getTime() < endTime) {
-          if (transport.isICEConnected && ((_a = _this2.dataChannelForKind(kind, subscriber)) === null || _a === void 0 ? void 0 : _a.readyState) === 'open') {
-            return;
-          }
-          yield sleep(50);
+        if (channel.label === reliableDataChannel) {
+          _this.reliableDCSub = channel;
+        } else if (channel.label === lossyDataChannel) {
+          _this.lossyDCSub = channel;
+        } else {
+          return;
         }
-        throw new ConnectionError("could not establish ".concat(transportName, " connection, state: ").concat(transport.getICEConnectionState()));
+        _this.log.debug("on data channel ".concat(channel.id, ", ").concat(channel.label), _this.logContext);
+        channel.onmessage = _this.handleDataMessage;
       }();
     });
-  }
-  ensurePublisherConnected(kind) {
-    return __awaiter(this, void 0, void 0, function* () {
-      if (!this.publisherConnectionPromise) {
-        this.publisherConnectionPromise = this.ensureDataTransportConnected(kind, false);
-      }
-      yield this.publisherConnectionPromise;
-    });
-  }
-  /* @internal */
-  verifyTransport() {
-    if (!this.pcManager) {
-      return false;
-    }
-    // primary connection
-    if (this.pcManager.currentState !== PCTransportState.CONNECTED) {
-      return false;
-    }
-    // ensure signal is connected
-    if (!this.client.ws || this.client.ws.readyState === WebSocket.CLOSED) {
-      return false;
-    }
-    return true;
-  }
-  /** @internal */
-  negotiate() {
-    return __awaiter(this, void 0, void 0, function* () {
-      // observe signal state
-      return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-        if (!this.pcManager) {
-          reject(new NegotiationError('PC manager is closed'));
-          return;
-        }
-        this.pcManager.requirePublisher();
-        const abortController = new AbortController();
-        const handleClosed = () => {
-          abortController.abort();
-          this.log.debug('engine disconnected while negotiation was ongoing', this.logContext);
-          resolve();
+    this.handleDataMessage = message => __awaiter(this, void 0, void 0, function* () {
+      var _c, _d;
+      // make sure to respect incoming data message order by processing message events one after the other
+      const unlock = yield this.dataProcessLock.lock();
+      try {
+        // decode
+        let buffer;
+        if (message.data instanceof ArrayBuffer) {
+          buffer = message.data;
+        } else if (message.data instanceof Blob) {
+          buffer = yield message.data.arrayBuffer();
+        } else {
+          this.log.error('unsupported data type', Object.assign(Object.assign({}, this.logContext), {
+            data: message.data
+          }));
           return;
-        };
-        if (this.isClosed) {
-          reject('cannot negotiate on closed engine');
         }
-        this.on(EngineEvent.Closing, handleClosed);
-        this.pcManager.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);
-        });
-        try {
-          yield this.pcManager.negotiate(abortController);
-          resolve();
-        } catch (e) {
-          if (e instanceof NegotiationError) {
-            this.fullReconnectOnNext = true;
-          }
-          this.handleDisconnect('negotiation', ReconnectReason.RR_UNKNOWN);
-          reject(e);
-        } finally {
-          this.off(EngineEvent.Closing, handleClosed);
+        const dp = DataPacket.fromBinary(new Uint8Array(buffer));
+        if (((_c = dp.value) === null || _c === void 0 ? void 0 : _c.case) === 'speaker') {
+          // dispatch speaker updates
+          this.emit(EngineEvent.ActiveSpeakersUpdate, dp.value.value.speakers);
+        } else if (((_d = dp.value) === null || _d === void 0 ? void 0 : _d.case) === 'user') {
+          this.emit(EngineEvent.DataPacketReceived, dp.value.value, dp.kind);
         }
-      }));
-    });
-  }
-  dataChannelForKind(kind, sub) {
-    if (!sub) {
-      if (kind === DataPacket_Kind.LOSSY) {
-        return this.lossyDC;
-      }
-      if (kind === DataPacket_Kind.RELIABLE) {
-        return this.reliableDC;
-      }
-    } else {
-      if (kind === DataPacket_Kind.LOSSY) {
-        return this.lossyDCSub;
-      }
-      if (kind === DataPacket_Kind.RELIABLE) {
-        return this.reliableDCSub;
-      }
-    }
-  }
-  /** @internal */
-  sendSyncState(remoteTracks, localTracks) {
-    var _a, _b;
-    if (!this.pcManager) {
-      this.log.warn('sync state cannot be sent without peer connection setup', this.logContext);
-      return;
-    }
-    const previousAnswer = this.pcManager.subscriber.getLocalDescription();
-    const previousOffer = this.pcManager.subscriber.getRemoteDescription();
-    /* 1. autosubscribe on, so subscribed tracks = all tracks - unsub tracks,
-          in this case, we send unsub tracks, so server add all tracks to this
-          subscribe pc and unsub special tracks from it.
-       2. autosubscribe off, we send subscribed tracks.
-    */
-    const autoSubscribe = (_b = (_a = this.signalOpts) === null || _a === void 0 ? void 0 : _a.autoSubscribe) !== null && _b !== void 0 ? _b : true;
-    const trackSids = new Array();
-    const trackSidsDisabled = new Array();
-    remoteTracks.forEach(track => {
-      if (track.isDesired !== autoSubscribe) {
-        trackSids.push(track.trackSid);
-      }
-      if (!track.isEnabled) {
-        trackSidsDisabled.push(track.trackSid);
+      } finally {
+        unlock();
       }
     });
-    this.client.sendSyncState(new SyncState({
-      answer: previousAnswer ? toProtoSessionDescription({
-        sdp: previousAnswer.sdp,
-        type: previousAnswer.type
-      }) : undefined,
-      offer: previousOffer ? toProtoSessionDescription({
-        sdp: previousOffer.sdp,
-        type: previousOffer.type
-      }) : undefined,
-      subscription: new UpdateSubscription({
-        trackSids,
-        subscribe: !autoSubscribe,
-        participantTracks: []
-      }),
-      publishTracks: getTrackPublicationInfo(localTracks),
-      dataChannels: this.dataChannelsInfo(),
-      trackSidsDisabled
-    }));
-  }
-  /* @internal */
-  failNext() {
-    // debugging method to fail the next reconnect/resume attempt
-    this.shouldFailNext = true;
-  }
-  dataChannelsInfo() {
-    const infos = [];
-    const getInfo = (dc, target) => {
-      if ((dc === null || dc === void 0 ? void 0 : dc.id) !== undefined && dc.id !== null) {
-        infos.push(new DataChannelInfo({
-          label: dc.label,
-          id: dc.id,
-          target
+    this.handleDataError = event => {
+      const channel = event.currentTarget;
+      const channelKind = channel.maxRetransmits === 0 ? 'lossy' : 'reliable';
+      if (event instanceof ErrorEvent && event.error) {
+        const {
+          error
+        } = event.error;
+        this.log.error("DataChannel error on ".concat(channelKind, ": ").concat(event.message), Object.assign(Object.assign({}, this.logContext), {
+          error
+        }));
+      } else {
+        this.log.error("Unknown DataChannel error on ".concat(channelKind), Object.assign(Object.assign({}, this.logContext), {
+          event
         }));
       }
     };
-    getInfo(this.dataChannelForKind(DataPacket_Kind.LOSSY), SignalTarget.PUBLISHER);
-    getInfo(this.dataChannelForKind(DataPacket_Kind.RELIABLE), SignalTarget.PUBLISHER);
-    getInfo(this.dataChannelForKind(DataPacket_Kind.LOSSY, true), SignalTarget.SUBSCRIBER);
-    getInfo(this.dataChannelForKind(DataPacket_Kind.RELIABLE, true), SignalTarget.SUBSCRIBER);
-    return infos;
-  }
-  clearReconnectTimeout() {
-    if (this.reconnectTimeout) {
-      CriticalTimers.clearTimeout(this.reconnectTimeout);
-    }
-  }
-  clearPendingReconnect() {
-    this.clearReconnectTimeout();
-    this.reconnectAttempts = 0;
-  }
-  registerOnLineListener() {
-    if (isWeb()) {
-      window.addEventListener('online', this.handleBrowserOnLine);
-    }
-  }
-  deregisterOnLineListener() {
-    if (isWeb()) {
-      window.removeEventListener('online', this.handleBrowserOnLine);
-    }
-  }
-}
-class SignalReconnectError extends Error {}
-
-class RegionUrlProvider {
-  constructor(url, token) {
-    this.lastUpdateAt = 0;
-    this.settingsCacheTime = 3000;
-    this.attemptedRegions = [];
-    this.serverUrl = new URL(url);
-    this.token = token;
-  }
-  updateToken(token) {
-    this.token = token;
-  }
-  isCloud() {
-    return isCloud(this.serverUrl);
-  }
-  getServerUrl() {
-    return this.serverUrl;
-  }
-  getNextBestRegionUrl(abortSignal) {
-    return __awaiter(this, void 0, void 0, function* () {
-      if (!this.isCloud()) {
-        throw Error('region availability is only supported for LiveKit Cloud domains');
-      }
-      if (!this.regionSettings || Date.now() - this.lastUpdateAt > this.settingsCacheTime) {
-        this.regionSettings = yield this.fetchRegionSettings(abortSignal);
+    this.handleBufferedAmountLow = event => {
+      const channel = event.currentTarget;
+      const channelKind = channel.maxRetransmits === 0 ? DataPacket_Kind.LOSSY : DataPacket_Kind.RELIABLE;
+      this.updateAndEmitDCBufferStatus(channelKind);
+    };
+    // websocket reconnect behavior. if websocket is interrupted, and the PeerConnection
+    // continues to work, we can reconnect to websocket to continue the session
+    // after a number of retries, we'll close and give up permanently
+    this.handleDisconnect = (connection, disconnectReason) => {
+      if (this._isClosed) {
+        return;
       }
-      const regionsLeft = this.regionSettings.regions.filter(region => !this.attemptedRegions.find(attempted => attempted.url === region.url));
-      if (regionsLeft.length > 0) {
-        const nextRegion = regionsLeft[0];
-        this.attemptedRegions.push(nextRegion);
-        livekitLogger.debug("next region: ".concat(nextRegion.region));
-        return nextRegion.url;
-      } else {
-        return null;
+      this.log.warn("".concat(connection, " disconnected"), this.logContext);
+      if (this.reconnectAttempts === 0) {
+        // only reset start time on the first try
+        this.reconnectStart = Date.now();
       }
-    });
-  }
-  resetAttempts() {
-    this.attemptedRegions = [];
-  }
-  /* @internal */
-  fetchRegionSettings(signal) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const regionSettingsResponse = yield fetch("".concat(getCloudConfigUrl(this.serverUrl), "/regions"), {
-        headers: {
-          authorization: "Bearer ".concat(this.token)
-        },
-        signal
+      const disconnect = duration => {
+        this.log.warn("could not recover connection after ".concat(this.reconnectAttempts, " attempts, ").concat(duration, "ms. giving up"), this.logContext);
+        this.emit(EngineEvent.Disconnected);
+        this.close();
+      };
+      const duration = Date.now() - this.reconnectStart;
+      let delay = this.getNextRetryDelay({
+        elapsedMs: duration,
+        retryCount: this.reconnectAttempts
       });
-      if (regionSettingsResponse.ok) {
-        const regionSettings = yield regionSettingsResponse.json();
-        this.lastUpdateAt = Date.now();
-        return regionSettings;
-      } else {
-        throw new ConnectionError("Could not fetch region settings: ".concat(regionSettingsResponse.statusText), regionSettingsResponse.status === 401 ? 0 /* ConnectionErrorReason.NotAllowed */ : undefined, regionSettingsResponse.status);
-      }
-    });
-  }
-}
-function getCloudConfigUrl(serverUrl) {
-  return "".concat(serverUrl.protocol.replace('ws', 'http'), "//").concat(serverUrl.host, "/settings");
-}
-
-const monitorFrequency = 2000;
-function computeBitrate(currentStats, prevStats) {
-  if (!prevStats) {
-    return 0;
-  }
-  let bytesNow;
-  let bytesPrev;
-  if ('bytesReceived' in currentStats) {
-    bytesNow = currentStats.bytesReceived;
-    bytesPrev = prevStats.bytesReceived;
-  } else if ('bytesSent' in currentStats) {
-    bytesNow = currentStats.bytesSent;
-    bytesPrev = prevStats.bytesSent;
-  }
-  if (bytesNow === undefined || bytesPrev === undefined || currentStats.timestamp === undefined || prevStats.timestamp === undefined) {
-    return 0;
-  }
-  return (bytesNow - bytesPrev) * 8 * 1000 / (currentStats.timestamp - prevStats.timestamp);
-}
-
-class LocalAudioTrack extends LocalTrack {
-  /**
-   * boolean indicating whether enhanced noise cancellation is currently being used on this track
-   */
-  get enhancedNoiseCancellation() {
-    return this.isKrispNoiseFilterEnabled;
-  }
-  /**
-   *
-   * @param mediaTrack
-   * @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, constraints) {
-    let userProvidedTrack = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-    let audioContext = arguments.length > 3 ? arguments[3] : undefined;
-    let loggerOptions = arguments.length > 4 ? arguments[4] : undefined;
-    super(mediaTrack, Track.Kind.Audio, constraints, userProvidedTrack, loggerOptions);
-    /** @internal */
-    this.stopOnMute = false;
-    this.isKrispNoiseFilterEnabled = false;
-    this.monitorSender = () => __awaiter(this, void 0, void 0, function* () {
-      if (!this.sender) {
-        this._currentBitrate = 0;
+      if (delay === null) {
+        disconnect(duration);
         return;
       }
-      let stats;
-      try {
-        stats = yield this.getSenderStats();
-      } catch (e) {
-        this.log.error('could not get audio sender stats', Object.assign(Object.assign({}, this.logContext), {
-          error: e
-        }));
-        return;
+      if (connection === leaveReconnect) {
+        delay = 0;
       }
-      if (stats && this.prevStats) {
-        this._currentBitrate = computeBitrate(stats, this.prevStats);
+      this.log.debug("reconnecting in ".concat(delay, "ms"), this.logContext);
+      this.clearReconnectTimeout();
+      if (this.token && this.regionUrlProvider) {
+        // token may have been refreshed, we do not want to recreate the regionUrlProvider
+        // since the current engine may have inherited a regional url
+        this.regionUrlProvider.updateToken(this.token);
+      }
+      this.reconnectTimeout = CriticalTimers.setTimeout(() => this.attemptReconnect(disconnectReason).finally(() => this.reconnectTimeout = undefined), delay);
+    };
+    this.waitForRestarted = () => {
+      return new Promise((resolve, reject) => {
+        if (this.pcState === PCState.Connected) {
+          resolve();
+        }
+        const onRestarted = () => {
+          this.off(EngineEvent.Disconnected, onDisconnected);
+          resolve();
+        };
+        const onDisconnected = () => {
+          this.off(EngineEvent.Restarted, onRestarted);
+          reject();
+        };
+        this.once(EngineEvent.Restarted, onRestarted);
+        this.once(EngineEvent.Disconnected, onDisconnected);
+      });
+    };
+    this.updateAndEmitDCBufferStatus = kind => {
+      const status = this.isBufferStatusLow(kind);
+      if (typeof status !== 'undefined' && status !== this.dcBufferStatus.get(kind)) {
+        this.dcBufferStatus.set(kind, status);
+        this.emit(EngineEvent.DCBufferStatusChanged, status, kind);
+      }
+    };
+    this.isBufferStatusLow = kind => {
+      const dc = this.dataChannelForKind(kind);
+      if (dc) {
+        return dc.bufferedAmount <= dc.bufferedAmountLowThreshold;
+      }
+    };
+    this.handleBrowserOnLine = () => {
+      // in case the engine is currently reconnecting, attempt a reconnect immediately after the browser state has changed to 'onLine'
+      if (this.client.currentState === SignalConnectionState.RECONNECTING) {
+        this.clearReconnectTimeout();
+        this.attemptReconnect(ReconnectReason.RR_SIGNAL_DISCONNECTED);
       }
-      this.prevStats = stats;
-    });
-    this.handleKrispNoiseFilterEnable = () => {
-      this.isKrispNoiseFilterEnabled = true;
-      this.log.debug("Krisp noise filter enabled", this.logContext);
-      this.emit(TrackEvent.AudioTrackFeatureUpdate, this, AudioTrackFeature.TF_ENHANCED_NOISE_CANCELLATION, true);
     };
-    this.handleKrispNoiseFilterDisable = () => {
-      this.isKrispNoiseFilterEnabled = false;
-      this.log.debug("Krisp noise filter disabled", this.logContext);
-      this.emit(TrackEvent.AudioTrackFeatureUpdate, this, AudioTrackFeature.TF_ENHANCED_NOISE_CANCELLATION, false);
+    this.log = getLogger((_a = options.loggerName) !== null && _a !== void 0 ? _a : LoggerNames.Engine);
+    this.loggerOptions = {
+      loggerName: options.loggerName,
+      loggerContextCb: () => this.logContext
     };
-    this.audioContext = audioContext;
-    this.checkForSilence();
+    this.client = new SignalClient(undefined, this.loggerOptions);
+    this.client.signalLatency = this.options.expSignalLatency;
+    this.reconnectPolicy = this.options.reconnectPolicy;
+    this.registerOnLineListener();
+    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);
   }
-  setDeviceId(deviceId) {
-    return __awaiter(this, void 0, void 0, function* () {
-      if (this._constraints.deviceId === deviceId && this._mediaStreamTrack.getSettings().deviceId === unwrapConstraint(deviceId)) {
-        return true;
-      }
-      this._constraints.deviceId = deviceId;
-      if (!this.isMuted) {
-        yield this.restartTrack();
-      }
-      return this.isMuted || unwrapConstraint(deviceId) === this._mediaStreamTrack.getSettings().deviceId;
-    });
+  /** @internal */
+  get logContext() {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    return {
+      room: (_b = (_a = this.latestJoinResponse) === null || _a === void 0 ? void 0 : _a.room) === null || _b === void 0 ? void 0 : _b.name,
+      roomID: (_d = (_c = this.latestJoinResponse) === null || _c === void 0 ? void 0 : _c.room) === null || _d === void 0 ? void 0 : _d.sid,
+      participant: (_f = (_e = this.latestJoinResponse) === null || _e === void 0 ? void 0 : _e.participant) === null || _f === void 0 ? void 0 : _f.identity,
+      pID: (_h = (_g = this.latestJoinResponse) === null || _g === void 0 ? void 0 : _g.participant) === null || _h === void 0 ? void 0 : _h.sid
+    };
   }
-  mute() {
-    const _super = Object.create(null, {
-      mute: {
-        get: () => super.mute
-      }
-    });
+  join(url, token, opts, abortSignal) {
     return __awaiter(this, void 0, void 0, function* () {
-      const unlock = yield this.muteLock.lock();
+      this.url = url;
+      this.token = token;
+      this.signalOpts = opts;
+      this.maxJoinAttempts = opts.maxRetries;
       try {
-        if (this.isMuted) {
-          this.log.debug('Track already muted', this.logContext);
-          return this;
+        this.joinAttempts += 1;
+        this.setupSignalClientCallbacks();
+        const joinResponse = yield this.client.join(url, token, opts, abortSignal);
+        this._isClosed = false;
+        this.latestJoinResponse = joinResponse;
+        this.subscriberPrimary = joinResponse.subscriberPrimary;
+        if (!this.pcManager) {
+          yield this.configure(joinResponse);
         }
-        // disabled special handling as it will cause BT headsets to switch communication modes
-        if (this.source === Track.Source.Microphone && this.stopOnMute && !this.isUserProvided) {
-          this.log.debug('stopping mic track', this.logContext);
-          // also stop the track, so that microphone indicator is turned off
-          this._mediaStreamTrack.stop();
+        // create offer
+        if (!this.subscriberPrimary) {
+          this.negotiate();
         }
-        yield _super.mute.call(this);
-        return this;
-      } finally {
-        unlock();
+        this.clientConfiguration = joinResponse.clientConfiguration;
+        return joinResponse;
+      } catch (e) {
+        if (e instanceof ConnectionError) {
+          if (e.reason === 1 /* ConnectionErrorReason.ServerUnreachable */) {
+            this.log.warn("Couldn't connect to server, attempt ".concat(this.joinAttempts, " of ").concat(this.maxJoinAttempts), this.logContext);
+            if (this.joinAttempts < this.maxJoinAttempts) {
+              return this.join(url, token, opts, abortSignal);
+            }
+          }
+        }
+        throw e;
       }
     });
   }
-  unmute() {
-    const _super = Object.create(null, {
-      unmute: {
-        get: () => super.unmute
-      }
-    });
+  close() {
     return __awaiter(this, void 0, void 0, function* () {
-      const unlock = yield this.muteLock.lock();
+      const unlock = yield this.closingLock.lock();
+      if (this.isClosed) {
+        unlock();
+        return;
+      }
       try {
-        if (!this.isMuted) {
-          this.log.debug('Track already unmuted', this.logContext);
-          return this;
-        }
-        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) {
-          this.log.debug('reacquiring mic track', this.logContext);
-          yield this.restartTrack();
-        }
-        yield _super.unmute.call(this);
-        return this;
+        this._isClosed = true;
+        this.emit(EngineEvent.Closing);
+        this.removeAllListeners();
+        this.deregisterOnLineListener();
+        this.clearPendingReconnect();
+        yield this.cleanupPeerConnections();
+        yield this.cleanupClient();
       } finally {
         unlock();
       }
     });
   }
-  restartTrack(options) {
+  cleanupPeerConnections() {
     return __awaiter(this, void 0, void 0, function* () {
-      let constraints;
-      if (options) {
-        const streamConstraints = constraintsForOptions({
-          audio: options
-        });
-        if (typeof streamConstraints.audio !== 'boolean') {
-          constraints = streamConstraints.audio;
-        }
-      }
-      yield this.restart(constraints);
+      var _a;
+      yield (_a = this.pcManager) === null || _a === void 0 ? void 0 : _a.close();
+      this.pcManager = 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;
     });
   }
-  restart(constraints) {
-    const _super = Object.create(null, {
-      restart: {
-        get: () => super.restart
-      }
-    });
+  cleanupClient() {
     return __awaiter(this, void 0, void 0, function* () {
-      const track = yield _super.restart.call(this, constraints);
-      this.checkForSilence();
-      return track;
+      yield this.client.close();
+      this.client.resetCallbacks();
     });
   }
-  /* @internal */
-  startMonitor() {
-    if (!isWeb()) {
-      return;
-    }
-    if (this.monitorInterval) {
-      return;
+  addTrack(req) {
+    if (this.pendingTrackResolvers[req.cid]) {
+      throw new TrackInvalidError('a track with the same ID has already been published');
     }
-    this.monitorInterval = setInterval(() => {
-      this.monitorSender();
-    }, monitorFrequency);
-  }
-  setProcessor(processor) {
-    return __awaiter(this, void 0, void 0, function* () {
-      var _a;
-      const unlock = yield this.processorLock.lock();
-      try {
-        if (!this.audioContext) {
-          throw Error('Audio context needs to be set on LocalAudioTrack in order to enable processors');
-        }
-        if (this.processor) {
-          yield this.stopProcessor();
-        }
-        const processorOptions = {
-          kind: this.kind,
-          track: this._mediaStreamTrack,
-          audioContext: this.audioContext
-        };
-        this.log.debug("setting up audio processor ".concat(processor.name), this.logContext);
-        yield processor.init(processorOptions);
-        this.processor = processor;
-        if (this.processor.processedTrack) {
-          yield (_a = this.sender) === null || _a === void 0 ? void 0 : _a.replaceTrack(this.processor.processedTrack);
-          this.processor.processedTrack.addEventListener('enable-lk-krisp-noise-filter', this.handleKrispNoiseFilterEnable);
-          this.processor.processedTrack.addEventListener('disable-lk-krisp-noise-filter', this.handleKrispNoiseFilterDisable);
+    return new Promise((resolve, reject) => {
+      const publicationTimeout = setTimeout(() => {
+        delete this.pendingTrackResolvers[req.cid];
+        reject(new ConnectionError('publication of local track timed out, no response from server'));
+      }, 10000);
+      this.pendingTrackResolvers[req.cid] = {
+        resolve: info => {
+          clearTimeout(publicationTimeout);
+          resolve(info);
+        },
+        reject: () => {
+          clearTimeout(publicationTimeout);
+          reject(new Error('Cancelled publication by calling unpublish'));
         }
-        this.emit(TrackEvent.TrackProcessorUpdate, this.processor);
-      } finally {
-        unlock();
+      };
+      this.client.sendAddTrack(req);
+    });
+  }
+  /**
+   * Removes sender from PeerConnection, returning true if it was removed successfully
+   * and a negotiation is necessary
+   * @param sender
+   * @returns
+   */
+  removeTrack(sender) {
+    if (sender.track && this.pendingTrackResolvers[sender.track.id]) {
+      const {
+        reject
+      } = this.pendingTrackResolvers[sender.track.id];
+      if (reject) {
+        reject();
       }
+      delete this.pendingTrackResolvers[sender.track.id];
+    }
+    try {
+      this.pcManager.removeTrack(sender);
+      return true;
+    } catch (e) {
+      this.log.warn('failed to remove track', Object.assign(Object.assign({}, this.logContext), {
+        error: e
+      }));
+    }
+    return false;
+  }
+  updateMuteStatus(trackSid, muted) {
+    this.client.sendMuteTrack(trackSid, muted);
+  }
+  get dataSubscriberReadyState() {
+    var _a;
+    return (_a = this.reliableDCSub) === null || _a === void 0 ? void 0 : _a.readyState;
+  }
+  getConnectedServerAddress() {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a;
+      return (_a = this.pcManager) === null || _a === void 0 ? void 0 : _a.getConnectedAddress();
     });
   }
-  /**
-   * @internal
-   * @experimental
-   */
-  setAudioContext(audioContext) {
-    this.audioContext = audioContext;
+  /* @internal */
+  setRegionUrlProvider(provider) {
+    this.regionUrlProvider = provider;
   }
-  getSenderStats() {
+  configure(joinResponse) {
     return __awaiter(this, void 0, void 0, function* () {
       var _a;
-      if (!((_a = this.sender) === null || _a === void 0 ? void 0 : _a.getStats)) {
-        return undefined;
+      // already configured
+      if (this.pcManager && this.pcManager.currentState !== PCTransportState.NEW) {
+        return;
       }
-      const stats = yield this.sender.getStats();
-      let audioStats;
-      stats.forEach(v => {
-        if (v.type === 'outbound-rtp') {
-          audioStats = {
-            type: 'audio',
-            streamId: v.id,
-            packetsSent: v.packetsSent,
-            packetsLost: v.packetsLost,
-            bytesSent: v.bytesSent,
-            timestamp: v.timestamp,
-            roundTripTime: v.roundTripTime,
-            jitter: v.jitter
-          };
+      this.participantSid = (_a = joinResponse.participant) === null || _a === void 0 ? void 0 : _a.sid;
+      const rtcConfig = this.makeRTCConfiguration(joinResponse);
+      this.pcManager = new PCTransportManager(rtcConfig, joinResponse.subscriberPrimary, this.loggerOptions);
+      this.emit(EngineEvent.TransportsCreated, this.pcManager.publisher, this.pcManager.subscriber);
+      this.pcManager.onIceCandidate = (candidate, target) => {
+        this.client.sendIceCandidate(candidate, target);
+      };
+      this.pcManager.onPublisherOffer = offer => {
+        this.client.sendOffer(offer);
+      };
+      this.pcManager.onDataChannel = this.handleDataChannel;
+      this.pcManager.onStateChange = (connectionState, publisherState, subscriberState) => __awaiter(this, void 0, void 0, function* () {
+        this.log.debug("primary PC state changed ".concat(connectionState), this.logContext);
+        if (['closed', 'disconnected', 'failed'].includes(publisherState)) {
+          // reset publisher connection promise
+          this.publisherConnectionPromise = undefined;
+        }
+        if (connectionState === PCTransportState.CONNECTED) {
+          const shouldEmit = this.pcState === PCState.New;
+          this.pcState = PCState.Connected;
+          if (shouldEmit) {
+            this.emit(EngineEvent.Connected, joinResponse);
+          }
+        } else if (connectionState === PCTransportState.FAILED) {
+          // on Safari, PeerConnection will switch to 'disconnected' during renegotiation
+          if (this.pcState === PCState.Connected) {
+            this.pcState = PCState.Disconnected;
+            this.handleDisconnect('peerconnection failed', subscriberState === 'failed' ? ReconnectReason.RR_SUBSCRIBER_FAILED : ReconnectReason.RR_PUBLISHER_FAILED);
+          }
+        }
+        // detect cases where both signal client and peer connection are severed and assume that user has lost network connection
+        const isSignalSevered = this.client.isDisconnected || this.client.currentState === SignalConnectionState.RECONNECTING;
+        const isPCSevered = [PCTransportState.FAILED, PCTransportState.CLOSING, PCTransportState.CLOSED].includes(connectionState);
+        if (isSignalSevered && isPCSevered && !this._isClosed) {
+          this.emit(EngineEvent.Offline);
         }
       });
-      return audioStats;
+      this.pcManager.onTrack = ev => {
+        this.emit(EngineEvent.MediaTrackAdded, ev.track, ev.streams[0], ev.receiver);
+      };
+      this.createDataChannels();
     });
   }
-  checkForSilence() {
-    return __awaiter(this, void 0, void 0, function* () {
-      const trackIsSilent = yield detectSilence(this);
-      if (trackIsSilent) {
-        if (!this.isMuted) {
-          this.log.warn('silence detected on local audio track', this.logContext);
-        }
-        this.emit(TrackEvent.AudioSilenceDetected);
+  setupSignalClientCallbacks() {
+    // configure signaling client
+    this.client.onAnswer = sd => __awaiter(this, void 0, void 0, function* () {
+      if (!this.pcManager) {
+        return;
       }
-      return trackIsSilent;
+      this.log.debug('received server answer', Object.assign(Object.assign({}, this.logContext), {
+        RTCSdpType: sd.type
+      }));
+      yield this.pcManager.setPublisherAnswer(sd);
     });
-  }
-}
-
-/** @internal */
-function mediaTrackToLocalTrack(mediaStreamTrack, constraints, loggerOptions) {
-  switch (mediaStreamTrack.kind) {
-    case 'audio':
-      return new LocalAudioTrack(mediaStreamTrack, constraints, false, undefined, loggerOptions);
-    case 'video':
-      return new LocalVideoTrack(mediaStreamTrack, constraints, false, loggerOptions);
-    default:
-      throw new TrackInvalidError("unsupported track type: ".concat(mediaStreamTrack.kind));
-  }
-}
-/* @internal */
-const presets169 = Object.values(VideoPresets);
-/* @internal */
-const presets43 = Object.values(VideoPresets43);
-/* @internal */
-const presetsScreenShare = Object.values(ScreenSharePresets);
-/* @internal */
-const defaultSimulcastPresets169 = [VideoPresets.h180, VideoPresets.h360];
-/* @internal */
-const defaultSimulcastPresets43 = [VideoPresets43.h180, VideoPresets43.h360];
-/* @internal */
-const computeDefaultScreenShareSimulcastPresets = fromPreset => {
-  const layers = [{
-    scaleResolutionDownBy: 2,
-    fps: fromPreset.encoding.maxFramerate
-  }];
-  return layers.map(t => {
-    var _a, _b;
-    return new VideoPreset(Math.floor(fromPreset.width / t.scaleResolutionDownBy), Math.floor(fromPreset.height / t.scaleResolutionDownBy), Math.max(150000, Math.floor(fromPreset.encoding.maxBitrate / (Math.pow(t.scaleResolutionDownBy, 2) * (((_a = fromPreset.encoding.maxFramerate) !== null && _a !== void 0 ? _a : 30) / ((_b = t.fps) !== null && _b !== void 0 ? _b : 30))))), t.fps, fromPreset.encoding.priority);
-  });
-};
-// /**
-//  *
-//  * @internal
-//  * @experimental
-//  */
-// const computeDefaultMultiCodecSimulcastEncodings = (width: number, height: number) => {
-//   // use vp8 as a default
-//   const vp8 = determineAppropriateEncoding(false, width, height);
-//   const vp9 = { ...vp8, maxBitrate: vp8.maxBitrate * 0.9 };
-//   const h264 = { ...vp8, maxBitrate: vp8.maxBitrate * 1.1 };
-//   const av1 = { ...vp8, maxBitrate: vp8.maxBitrate * 0.7 };
-//   return {
-//     vp8,
-//     vp9,
-//     h264,
-//     av1,
-//   };
-// };
-const videoRids = ['q', 'h', 'f'];
-/* @internal */
-function computeVideoEncodings(isScreenShare, width, height, options) {
-  var _a, _b;
-  let videoEncoding = options === null || options === void 0 ? void 0 : options.videoEncoding;
-  if (isScreenShare) {
-    videoEncoding = options === null || options === void 0 ? void 0 : options.screenShareEncoding;
-  }
-  const useSimulcast = options === null || options === void 0 ? void 0 : options.simulcast;
-  const scalabilityMode = options === null || options === void 0 ? void 0 : options.scalabilityMode;
-  const videoCodec = options === null || options === void 0 ? void 0 : options.videoCodec;
-  if (!videoEncoding && !useSimulcast && !scalabilityMode || !width || !height) {
-    // when we aren't simulcasting or svc, will need to return a single encoding without
-    // capping bandwidth. we always require a encoding for dynacast
-    return [{}];
-  }
-  if (!videoEncoding) {
-    // find the right encoding based on width/height
-    videoEncoding = determineAppropriateEncoding(isScreenShare, width, height, videoCodec);
-    livekitLogger.debug('using video encoding', videoEncoding);
-  }
-  const original = new VideoPreset(width, height, videoEncoding.maxBitrate, videoEncoding.maxFramerate, videoEncoding.priority);
-  if (scalabilityMode && isSVCCodec(videoCodec)) {
-    const sm = new ScalabilityMode(scalabilityMode);
-    const encodings = [];
-    if (sm.spatial > 3) {
-      throw new Error("unsupported scalabilityMode: ".concat(scalabilityMode));
-    }
-    // Before M113 in Chrome, defining multiple encodings with an SVC codec indicated
-    // that SVC mode should be used. Safari still works this way.
-    // This is a bit confusing but is due to how libwebrtc interpreted the encodings field
-    // before M113.
-    // Announced here: https://groups.google.com/g/discuss-webrtc/c/-QQ3pxrl-fw?pli=1
-    const browser = getBrowser();
-    if (isSafari() || (browser === null || browser === void 0 ? void 0 : browser.name) === 'Chrome' && compareVersions(browser === null || browser === void 0 ? void 0 : browser.version, '113') < 0) {
-      const bitratesRatio = sm.suffix == 'h' ? 2 : 3;
-      for (let i = 0; i < sm.spatial; i += 1) {
-        // in legacy SVC, scaleResolutionDownBy cannot be set
-        encodings.push({
-          rid: videoRids[2 - i],
-          maxBitrate: videoEncoding.maxBitrate / Math.pow(bitratesRatio, i),
-          maxFramerate: original.encoding.maxFramerate
-        });
+    // add candidate on trickle
+    this.client.onTrickle = (candidate, target) => {
+      if (!this.pcManager) {
+        return;
+      }
+      this.log.trace('got ICE candidate from peer', Object.assign(Object.assign({}, this.logContext), {
+        candidate,
+        target
+      }));
+      this.pcManager.addIceCandidate(candidate, target);
+    };
+    // when server creates an offer for the client
+    this.client.onOffer = sd => __awaiter(this, void 0, void 0, function* () {
+      if (!this.pcManager) {
+        return;
+      }
+      const answer = yield this.pcManager.createSubscriberAnswerFromOffer(sd);
+      this.client.sendAnswer(answer);
+    });
+    this.client.onLocalTrackPublished = res => {
+      var _a;
+      this.log.debug('received trackPublishedResponse', Object.assign(Object.assign({}, this.logContext), {
+        cid: res.cid,
+        track: (_a = res.track) === null || _a === void 0 ? void 0 : _a.sid
+      }));
+      if (!this.pendingTrackResolvers[res.cid]) {
+        this.log.error("missing track resolver for ".concat(res.cid), Object.assign(Object.assign({}, this.logContext), {
+          cid: res.cid
+        }));
+        return;
+      }
+      const {
+        resolve
+      } = this.pendingTrackResolvers[res.cid];
+      delete this.pendingTrackResolvers[res.cid];
+      resolve(res.track);
+    };
+    this.client.onLocalTrackUnpublished = response => {
+      this.emit(EngineEvent.LocalTrackUnpublished, response);
+    };
+    this.client.onTokenRefresh = token => {
+      this.token = token;
+    };
+    this.client.onRemoteMuteChanged = (trackSid, muted) => {
+      this.emit(EngineEvent.RemoteMute, trackSid, muted);
+    };
+    this.client.onSubscribedQualityUpdate = update => {
+      this.emit(EngineEvent.SubscribedQualityUpdate, update);
+    };
+    this.client.onClose = () => {
+      this.handleDisconnect('signal', ReconnectReason.RR_SIGNAL_DISCONNECTED);
+    };
+    this.client.onLeave = leave => {
+      if (leave === null || leave === void 0 ? void 0 : leave.canReconnect) {
+        this.fullReconnectOnNext = true;
+        // reconnect immediately instead of waiting for next attempt
+        this.handleDisconnect(leaveReconnect);
+      } else {
+        this.emit(EngineEvent.Disconnected, leave === null || leave === void 0 ? void 0 : leave.reason);
+        this.close();
       }
-      // legacy SVC, scalabilityMode is set only on the first encoding
-      /* @ts-ignore */
-      encodings[0].scalabilityMode = scalabilityMode;
-    } else {
-      encodings.push({
-        maxBitrate: videoEncoding.maxBitrate,
-        maxFramerate: original.encoding.maxFramerate,
-        /* @ts-ignore */
-        scalabilityMode: scalabilityMode
-      });
-    }
-    livekitLogger.debug("using svc encoding", {
-      encodings
-    });
-    return encodings;
-  }
-  if (!useSimulcast) {
-    return [videoEncoding];
-  }
-  let presets = [];
-  if (isScreenShare) {
-    presets = (_a = sortPresets(options === null || options === void 0 ? void 0 : options.screenShareSimulcastLayers)) !== null && _a !== void 0 ? _a : defaultSimulcastLayers(isScreenShare, original);
-  } else {
-    presets = (_b = sortPresets(options === null || options === void 0 ? void 0 : options.videoSimulcastLayers)) !== null && _b !== void 0 ? _b : defaultSimulcastLayers(isScreenShare, original);
+      this.log.debug('client leave request', Object.assign(Object.assign({}, this.logContext), {
+        reason: leave === null || leave === void 0 ? void 0 : leave.reason
+      }));
+    };
   }
-  let midPreset;
-  if (presets.length > 0) {
-    const lowPreset = presets[0];
-    if (presets.length > 1) {
-      [, midPreset] = presets;
+  makeRTCConfiguration(serverResponse) {
+    var _a;
+    const rtcConfig = Object.assign({}, this.rtcConfig);
+    if ((_a = this.signalOpts) === null || _a === void 0 ? void 0 : _a.e2eeEnabled) {
+      this.log.debug('E2EE - setting up transports with insertable streams', this.logContext);
+      //  this makes sure that no data is sent before the transforms are ready
+      // @ts-ignore
+      rtcConfig.encodedInsertableStreams = true;
     }
-    // NOTE:
-    //   1. Ordering of these encodings is important. Chrome seems
-    //      to use the index into encodings to decide which layer
-    //      to disable when CPU constrained.
-    //      So encodings should be ordered in increasing spatial
-    //      resolution order.
-    //   2. livekit-server translates rids into layers. So, all encodings
-    //      should have the base layer `q` and then more added
-    //      based on other conditions.
-    const size = Math.max(width, height);
-    if (size >= 960 && midPreset) {
-      return encodingsFromPresets(width, height, [lowPreset, midPreset, original]);
+    // update ICE servers before creating PeerConnection
+    if (serverResponse.iceServers && !rtcConfig.iceServers) {
+      const rtcIceServers = [];
+      serverResponse.iceServers.forEach(iceServer => {
+        const rtcIceServer = {
+          urls: iceServer.urls
+        };
+        if (iceServer.username) rtcIceServer.username = iceServer.username;
+        if (iceServer.credential) {
+          rtcIceServer.credential = iceServer.credential;
+        }
+        rtcIceServers.push(rtcIceServer);
+      });
+      rtcConfig.iceServers = rtcIceServers;
     }
-    if (size >= 480) {
-      return encodingsFromPresets(width, height, [lowPreset, original]);
+    if (serverResponse.clientConfiguration && serverResponse.clientConfiguration.forceRelay === ClientConfigSetting.ENABLED) {
+      rtcConfig.iceTransportPolicy = 'relay';
     }
+    // @ts-ignore
+    rtcConfig.sdpSemantics = 'unified-plan';
+    // @ts-ignore
+    rtcConfig.continualGatheringPolicy = 'gather_continually';
+    return rtcConfig;
   }
-  return encodingsFromPresets(width, height, [original]);
-}
-function computeTrackBackupEncodings(track, videoCodec, opts) {
-  var _a, _b, _c, _d;
-  // backupCodec should not be true anymore, default codec is set in LocalParticipant.publish
-  if (!opts.backupCodec || opts.backupCodec === true || opts.backupCodec.codec === opts.videoCodec) {
-    // backup codec publishing is disabled
-    return;
-  }
-  if (videoCodec !== opts.backupCodec.codec) {
-    livekitLogger.warn('requested a different codec than specified as backup', {
-      serverRequested: videoCodec,
-      backup: opts.backupCodec.codec
-    });
-  }
-  opts.videoCodec = videoCodec;
-  // use backup encoding setting as videoEncoding for backup codec publishing
-  opts.videoEncoding = opts.backupCodec.encoding;
-  const settings = track.mediaStreamTrack.getSettings();
-  const width = (_a = settings.width) !== null && _a !== void 0 ? _a : (_b = track.dimensions) === null || _b === void 0 ? void 0 : _b.width;
-  const height = (_c = settings.height) !== null && _c !== void 0 ? _c : (_d = track.dimensions) === null || _d === void 0 ? void 0 : _d.height;
-  const encodings = computeVideoEncodings(track.source === Track.Source.ScreenShare, width, height, opts);
-  return encodings;
-}
-/* @internal */
-function determineAppropriateEncoding(isScreenShare, width, height, codec) {
-  const presets = presetsForResolution(isScreenShare, width, height);
-  let {
-    encoding
-  } = presets[0];
-  // handle portrait by swapping dimensions
-  const size = Math.max(width, height);
-  for (let i = 0; i < presets.length; i += 1) {
-    const preset = presets[i];
-    encoding = preset.encoding;
-    if (preset.width >= size) {
-      break;
+  createDataChannels() {
+    if (!this.pcManager) {
+      return;
     }
-  }
-  // presets are based on the assumption of vp8 as a codec
-  // for other codecs we adjust the maxBitrate if no specific videoEncoding has been provided
-  // users should override these with ones that are optimized for their use case
-  // NOTE: SVC codec bitrates are inclusive of all scalability layers. while
-  // bitrate for non-SVC codecs does not include other simulcast layers.
-  if (codec) {
-    switch (codec) {
-      case 'av1':
-        encoding = Object.assign({}, encoding);
-        encoding.maxBitrate = encoding.maxBitrate * 0.7;
-        break;
-      case 'vp9':
-        encoding = Object.assign({}, encoding);
-        encoding.maxBitrate = encoding.maxBitrate * 0.85;
-        break;
+    // clear old data channel callbacks if recreate
+    if (this.lossyDC) {
+      this.lossyDC.onmessage = null;
+      this.lossyDC.onerror = null;
     }
+    if (this.reliableDC) {
+      this.reliableDC.onmessage = null;
+      this.reliableDC.onerror = null;
+    }
+    // create data channels
+    this.lossyDC = this.pcManager.createPublisherDataChannel(lossyDataChannel, {
+      // will drop older packets that arrive
+      ordered: true,
+      maxRetransmits: 0
+    });
+    this.reliableDC = this.pcManager.createPublisherDataChannel(reliableDataChannel, {
+      ordered: true
+    });
+    // also handle messages over the pub channel, for backwards compatibility
+    this.lossyDC.onmessage = this.handleDataMessage;
+    this.reliableDC.onmessage = this.handleDataMessage;
+    // handle datachannel errors
+    this.lossyDC.onerror = this.handleDataError;
+    this.reliableDC.onerror = this.handleDataError;
+    // set up dc buffer threshold, set to 64kB (otherwise 0 by default)
+    this.lossyDC.bufferedAmountLowThreshold = 65535;
+    this.reliableDC.bufferedAmountLowThreshold = 65535;
+    // handle buffer amount low events
+    this.lossyDC.onbufferedamountlow = this.handleBufferedAmountLow;
+    this.reliableDC.onbufferedamountlow = this.handleBufferedAmountLow;
   }
-  return encoding;
-}
-/* @internal */
-function presetsForResolution(isScreenShare, width, height) {
-  if (isScreenShare) {
-    return presetsScreenShare;
-  }
-  const aspect = width > height ? width / height : height / width;
-  if (Math.abs(aspect - 16.0 / 9) < Math.abs(aspect - 4.0 / 3)) {
-    return presets169;
-  }
-  return presets43;
-}
-/* @internal */
-function defaultSimulcastLayers(isScreenShare, original) {
-  if (isScreenShare) {
-    return computeDefaultScreenShareSimulcastPresets(original);
+  createSender(track, opts, encodings) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (supportsTransceiver()) {
+        const sender = yield this.createTransceiverRTCRtpSender(track, opts, encodings);
+        return sender;
+      }
+      if (supportsAddTrack()) {
+        this.log.warn('using add-track fallback', this.logContext);
+        const sender = yield this.createRTCRtpSender(track.mediaStreamTrack);
+        return sender;
+      }
+      throw new UnexpectedConnectionState('Required webRTC APIs not supported on this device');
+    });
   }
-  const {
-    width,
-    height
-  } = original;
-  const aspect = width > height ? width / height : height / width;
-  if (Math.abs(aspect - 16.0 / 9) < Math.abs(aspect - 4.0 / 3)) {
-    return defaultSimulcastPresets169;
+  createSimulcastSender(track, simulcastTrack, opts, encodings) {
+    return __awaiter(this, void 0, void 0, function* () {
+      // store RTCRtpSender
+      if (supportsTransceiver()) {
+        return this.createSimulcastTransceiverSender(track, simulcastTrack, opts, encodings);
+      }
+      if (supportsAddTrack()) {
+        this.log.debug('using add-track fallback', this.logContext);
+        return this.createRTCRtpSender(track.mediaStreamTrack);
+      }
+      throw new UnexpectedConnectionState('Cannot stream on this device');
+    });
   }
-  return defaultSimulcastPresets43;
-}
-// presets should be ordered by low, medium, high
-function encodingsFromPresets(width, height, presets) {
-  const encodings = [];
-  presets.forEach((preset, idx) => {
-    if (idx >= videoRids.length) {
-      return;
-    }
-    const size = Math.min(width, height);
-    const rid = videoRids[idx];
-    const encoding = {
-      rid,
-      scaleResolutionDownBy: Math.max(1, size / Math.min(preset.width, preset.height)),
-      maxBitrate: preset.encoding.maxBitrate
-    };
-    if (preset.encoding.maxFramerate) {
-      encoding.maxFramerate = preset.encoding.maxFramerate;
-    }
-    const canSetPriority = isFireFox() || idx === 0;
-    if (preset.encoding.priority && canSetPriority) {
-      encoding.priority = preset.encoding.priority;
-      encoding.networkPriority = preset.encoding.priority;
-    }
-    encodings.push(encoding);
-  });
-  // RN ios simulcast requires all same framerates.
-  if (isReactNative() && getReactNativeOs() === 'ios') {
-    let topFramerate = undefined;
-    encodings.forEach(encoding => {
-      if (!topFramerate) {
-        topFramerate = encoding.maxFramerate;
-      } else if (encoding.maxFramerate && encoding.maxFramerate > topFramerate) {
-        topFramerate = encoding.maxFramerate;
+  createTransceiverRTCRtpSender(track, opts, encodings) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!this.pcManager) {
+        throw new UnexpectedConnectionState('publisher is closed');
+      }
+      const streams = [];
+      if (track.mediaStream) {
+        streams.push(track.mediaStream);
+      }
+      if (track instanceof LocalVideoTrack) {
+        track.codec = opts.videoCodec;
       }
-    });
-    let notifyOnce = true;
-    encodings.forEach(encoding => {
-      var _a;
-      if (encoding.maxFramerate != topFramerate) {
-        if (notifyOnce) {
-          notifyOnce = false;
-          livekitLogger.info("Simulcast on iOS React-Native requires all encodings to share the same framerate.");
-        }
-        livekitLogger.info("Setting framerate of encoding \"".concat((_a = encoding.rid) !== null && _a !== void 0 ? _a : '', "\" to ").concat(topFramerate));
-        encoding.maxFramerate = topFramerate;
+      const transceiverInit = {
+        direction: 'sendonly',
+        streams
+      };
+      if (encodings) {
+        transceiverInit.sendEncodings = encodings;
       }
+      // addTransceiver for react-native is async. web is synchronous, but await won't effect it.
+      const transceiver = yield this.pcManager.addPublisherTransceiver(track.mediaStreamTrack, transceiverInit);
+      return transceiver.sender;
     });
   }
-  return encodings;
-}
-/** @internal */
-function sortPresets(presets) {
-  if (!presets) return;
-  return presets.sort((a, b) => {
-    const {
-      encoding: aEnc
-    } = a;
-    const {
-      encoding: bEnc
-    } = b;
-    if (aEnc.maxBitrate > bEnc.maxBitrate) {
-      return 1;
-    }
-    if (aEnc.maxBitrate < bEnc.maxBitrate) return -1;
-    if (aEnc.maxBitrate === bEnc.maxBitrate && aEnc.maxFramerate && bEnc.maxFramerate) {
-      return aEnc.maxFramerate > bEnc.maxFramerate ? 1 : -1;
-    }
-    return 0;
-  });
-}
-/** @internal */
-class ScalabilityMode {
-  constructor(scalabilityMode) {
-    const results = scalabilityMode.match(/^L(\d)T(\d)(h|_KEY|_KEY_SHIFT){0,1}$/);
-    if (!results) {
-      throw new Error('invalid scalability mode');
-    }
-    this.spatial = parseInt(results[1]);
-    this.temporal = parseInt(results[2]);
-    if (results.length > 3) {
-      switch (results[3]) {
-        case 'h':
-        case '_KEY':
-        case '_KEY_SHIFT':
-          this.suffix = results[3];
+  createSimulcastTransceiverSender(track, simulcastTrack, opts, encodings) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!this.pcManager) {
+        throw new UnexpectedConnectionState('publisher is closed');
       }
-    }
+      const transceiverInit = {
+        direction: 'sendonly'
+      };
+      if (encodings) {
+        transceiverInit.sendEncodings = encodings;
+      }
+      // addTransceiver for react-native is async. web is synchronous, but await won't effect it.
+      const transceiver = yield this.pcManager.addPublisherTransceiver(simulcastTrack.mediaStreamTrack, transceiverInit);
+      if (!opts.videoCodec) {
+        return;
+      }
+      track.setSimulcastTrackSender(opts.videoCodec, transceiver.sender);
+      return transceiver.sender;
+    });
   }
-  toString() {
-    var _a;
-    return "L".concat(this.spatial, "T").concat(this.temporal).concat((_a = this.suffix) !== null && _a !== void 0 ? _a : '');
+  createRTCRtpSender(track) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!this.pcManager) {
+        throw new UnexpectedConnectionState('publisher is closed');
+      }
+      return this.pcManager.addPublisherTrack(track);
+    });
   }
-}
-
-const refreshSubscribedCodecAfterNewCodec = 5000;
-class LocalVideoTrack extends LocalTrack {
-  /**
-   *
-   * @param mediaTrack
-   * @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, constraints) {
-    let userProvidedTrack = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-    let loggerOptions = arguments.length > 3 ? arguments[3] : undefined;
-    super(mediaTrack, Track.Kind.Video, constraints, userProvidedTrack, loggerOptions);
-    /* @internal */
-    this.simulcastCodecs = new Map();
-    this.monitorSender = () => __awaiter(this, void 0, void 0, function* () {
-      if (!this.sender) {
-        this._currentBitrate = 0;
+  attemptReconnect(reason) {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a, _b, _c;
+      if (this._isClosed) {
         return;
       }
-      let stats;
-      try {
-        stats = yield this.getSenderStats();
-      } catch (e) {
-        this.log.error('could not get audio sender stats', Object.assign(Object.assign({}, this.logContext), {
-          error: e
-        }));
+      // guard for attempting reconnection multiple times while one attempt is still not finished
+      if (this.attemptingReconnect) {
+        livekitLogger.warn('already attempting reconnect, returning early', this.logContext);
         return;
       }
-      const statsMap = new Map(stats.map(s => [s.rid, s]));
-      if (this.prevStats) {
-        let totalBitrate = 0;
-        statsMap.forEach((s, key) => {
-          var _a;
-          const prev = (_a = this.prevStats) === null || _a === void 0 ? void 0 : _a.get(key);
-          totalBitrate += computeBitrate(s, prev);
-        });
-        this._currentBitrate = totalBitrate;
+      if (((_a = this.clientConfiguration) === null || _a === void 0 ? void 0 : _a.resumeConnection) === ClientConfigSetting.DISABLED ||
+      // signaling state could change to closed due to hardware sleep
+      // those connections cannot be resumed
+      ((_c = (_b = this.pcManager) === null || _b === void 0 ? void 0 : _b.currentState) !== null && _c !== void 0 ? _c : PCTransportState.NEW) === PCTransportState.NEW) {
+        this.fullReconnectOnNext = true;
+      }
+      try {
+        this.attemptingReconnect = true;
+        if (this.fullReconnectOnNext) {
+          yield this.restartConnection();
+        } else {
+          yield this.resumeConnection(reason);
+        }
+        this.clearPendingReconnect();
+        this.fullReconnectOnNext = false;
+      } catch (e) {
+        this.reconnectAttempts += 1;
+        let recoverable = true;
+        if (e instanceof UnexpectedConnectionState) {
+          this.log.debug('received unrecoverable error', Object.assign(Object.assign({}, this.logContext), {
+            error: e
+          }));
+          // unrecoverable
+          recoverable = false;
+        } else if (!(e instanceof SignalReconnectError)) {
+          // cannot resume
+          this.fullReconnectOnNext = true;
+        }
+        if (recoverable) {
+          this.handleDisconnect('reconnect', ReconnectReason.RR_UNKNOWN);
+        } else {
+          this.log.info("could not recover connection after ".concat(this.reconnectAttempts, " attempts, ").concat(Date.now() - this.reconnectStart, "ms. giving up"), this.logContext);
+          this.emit(EngineEvent.Disconnected);
+          yield this.close();
+        }
+      } finally {
+        this.attemptingReconnect = false;
       }
-      this.prevStats = statsMap;
     });
-    this.senderLock = new Mutex();
-  }
-  get isSimulcast() {
-    if (this.sender && this.sender.getParameters().encodings.length > 1) {
-      return true;
-    }
-    return false;
   }
-  /* @internal */
-  startMonitor(signalClient) {
-    var _a;
-    this.signalClient = signalClient;
-    if (!isWeb()) {
-      return;
-    }
-    // save original encodings
-    // TODO : merge simulcast tracks stats
-    const params = (_a = this.sender) === null || _a === void 0 ? void 0 : _a.getParameters();
-    if (params) {
-      this.encodings = params.encodings;
-    }
-    if (this.monitorInterval) {
-      return;
+  getNextRetryDelay(context) {
+    try {
+      return this.reconnectPolicy.nextRetryDelayInMs(context);
+    } catch (e) {
+      this.log.warn('encountered error in reconnect policy', Object.assign(Object.assign({}, this.logContext), {
+        error: e
+      }));
     }
-    this.monitorInterval = setInterval(() => {
-      this.monitorSender();
-    }, monitorFrequency);
-  }
-  stop() {
-    this._mediaStreamTrack.getConstraints();
-    this.simulcastCodecs.forEach(trackInfo => {
-      trackInfo.mediaStreamTrack.stop();
-    });
-    super.stop();
+    // error in user code with provided reconnect policy, stop reconnecting
+    return null;
   }
-  pauseUpstream() {
-    const _super = Object.create(null, {
-      pauseUpstream: {
-        get: () => super.pauseUpstream
-      }
-    });
+  restartConnection(regionUrl) {
     return __awaiter(this, void 0, void 0, function* () {
-      var _a, e_1, _b, _c;
-      var _d;
-      yield _super.pauseUpstream.call(this);
+      var _a, _b, _c;
       try {
-        for (var _e = true, _f = __asyncValues(this.simulcastCodecs.values()), _g; _g = yield _f.next(), _a = _g.done, !_a; _e = true) {
-          _c = _g.value;
-          _e = false;
-          const sc = _c;
-          yield (_d = sc.sender) === null || _d === void 0 ? void 0 : _d.replaceTrack(null);
+        if (!this.url || !this.token) {
+          // permanent failure, don't attempt reconnection
+          throw new UnexpectedConnectionState('could not reconnect, url or token not saved');
+        }
+        this.log.info("reconnecting, attempt: ".concat(this.reconnectAttempts), this.logContext);
+        this.emit(EngineEvent.Restarting);
+        if (!this.client.isDisconnected) {
+          yield this.client.sendLeave();
+        }
+        yield this.cleanupPeerConnections();
+        yield this.cleanupClient();
+        let joinResponse;
+        try {
+          if (!this.signalOpts) {
+            this.log.warn('attempted connection restart, without signal options present', this.logContext);
+            throw new SignalReconnectError();
+          }
+          // in case a regionUrl is passed, the region URL takes precedence
+          joinResponse = yield this.join(regionUrl !== null && regionUrl !== void 0 ? regionUrl : this.url, this.token, this.signalOpts);
+        } catch (e) {
+          if (e instanceof ConnectionError && e.reason === 0 /* ConnectionErrorReason.NotAllowed */) {
+            throw new UnexpectedConnectionState('could not reconnect, token might be expired');
+          }
+          throw new SignalReconnectError();
+        }
+        if (this.shouldFailNext) {
+          this.shouldFailNext = false;
+          throw new Error('simulated failure');
+        }
+        this.client.setReconnected();
+        this.emit(EngineEvent.SignalRestarted, joinResponse);
+        yield this.waitForPCReconnected();
+        // re-check signal connection state before setting engine as resumed
+        if (this.client.currentState !== SignalConnectionState.CONNECTED) {
+          throw new SignalReconnectError('Signal connection got severed during reconnect');
         }
-      } catch (e_1_1) {
-        e_1 = {
-          error: e_1_1
-        };
-      } finally {
-        try {
-          if (!_e && !_a && (_b = _f.return)) yield _b.call(_f);
-        } finally {
-          if (e_1) throw e_1.error;
+        (_a = this.regionUrlProvider) === null || _a === void 0 ? void 0 : _a.resetAttempts();
+        // reconnect success
+        this.emit(EngineEvent.Restarted);
+      } catch (error) {
+        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)
+          (_c = this.regionUrlProvider) === null || _c === void 0 ? void 0 : _c.resetAttempts();
+          throw error;
         }
       }
     });
   }
-  resumeUpstream() {
-    const _super = Object.create(null, {
-      resumeUpstream: {
-        get: () => super.resumeUpstream
-      }
-    });
+  resumeConnection(reason) {
     return __awaiter(this, void 0, void 0, function* () {
-      var _a, e_2, _b, _c;
-      var _d;
-      yield _super.resumeUpstream.call(this);
-      try {
-        for (var _e = true, _f = __asyncValues(this.simulcastCodecs.values()), _g; _g = yield _f.next(), _a = _g.done, !_a; _e = true) {
-          _c = _g.value;
-          _e = false;
-          const sc = _c;
-          yield (_d = sc.sender) === null || _d === void 0 ? void 0 : _d.replaceTrack(sc.mediaStreamTrack);
-        }
-      } catch (e_2_1) {
-        e_2 = {
-          error: e_2_1
-        };
-      } finally {
-        try {
-          if (!_e && !_a && (_b = _f.return)) yield _b.call(_f);
-        } finally {
-          if (e_2) throw e_2.error;
-        }
+      var _a;
+      if (!this.url || !this.token) {
+        // permanent failure, don't attempt reconnection
+        throw new UnexpectedConnectionState('could not reconnect, url or token not saved');
       }
-    });
-  }
-  mute() {
-    const _super = Object.create(null, {
-      mute: {
-        get: () => super.mute
+      // trigger publisher reconnect
+      if (!this.pcManager) {
+        throw new UnexpectedConnectionState('publisher and subscriber connections unset');
       }
-    });
-    return __awaiter(this, void 0, void 0, function* () {
-      const unlock = yield this.muteLock.lock();
+      this.log.info("resuming signal connection, attempt ".concat(this.reconnectAttempts), this.logContext);
+      this.emit(EngineEvent.Resuming);
+      let res;
       try {
-        if (this.isMuted) {
-          this.log.debug('Track already muted', this.logContext);
-          return this;
+        this.setupSignalClientCallbacks();
+        res = yield this.client.reconnect(this.url, this.token, this.participantSid, reason);
+      } catch (error) {
+        let message = '';
+        if (error instanceof Error) {
+          message = error.message;
+          this.log.error(error.message, Object.assign(Object.assign({}, this.logContext), {
+            error
+          }));
         }
-        if (this.source === Track.Source.Camera && !this.isUserProvided) {
-          this.log.debug('stopping camera track', this.logContext);
-          // also stop the track, so that camera indicator is turned off
-          this._mediaStreamTrack.stop();
+        if (error instanceof ConnectionError && error.reason === 0 /* ConnectionErrorReason.NotAllowed */) {
+          throw new UnexpectedConnectionState('could not reconnect, token might be expired');
         }
-        yield _super.mute.call(this);
-        return this;
-      } finally {
-        unlock();
+        if (error instanceof ConnectionError && error.reason === 4 /* ConnectionErrorReason.LeaveRequest */) {
+          throw error;
+        }
+        throw new SignalReconnectError(message);
+      }
+      this.emit(EngineEvent.SignalResumed);
+      if (res) {
+        const rtcConfig = this.makeRTCConfiguration(res);
+        this.pcManager.updateConfiguration(rtcConfig);
+      } else {
+        this.log.warn('Did not receive reconnect response', this.logContext);
+      }
+      if (this.shouldFailNext) {
+        this.shouldFailNext = false;
+        throw new Error('simulated failure');
+      }
+      yield this.pcManager.triggerIceRestart();
+      yield this.waitForPCReconnected();
+      // re-check signal connection state before setting engine as resumed
+      if (this.client.currentState !== SignalConnectionState.CONNECTED) {
+        throw new SignalReconnectError('Signal connection got severed during reconnect');
       }
+      this.client.setReconnected();
+      // recreate publish datachannel if it's id is null
+      // (for safari https://bugs.webkit.org/show_bug.cgi?id=184688)
+      if (((_a = this.reliableDC) === null || _a === void 0 ? void 0 : _a.readyState) === 'open' && this.reliableDC.id === null) {
+        this.createDataChannels();
+      }
+      // resume success
+      this.emit(EngineEvent.Resumed);
     });
   }
-  unmute() {
-    const _super = Object.create(null, {
-      unmute: {
-        get: () => super.unmute
+  waitForPCInitialConnection(timeout, abortController) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!this.pcManager) {
+        throw new UnexpectedConnectionState('PC manager is closed');
       }
+      yield this.pcManager.ensurePCTransportConnection(abortController, timeout);
     });
+  }
+  waitForPCReconnected() {
     return __awaiter(this, void 0, void 0, function* () {
-      const unlock = yield this.muteLock.lock();
+      this.pcState = PCState.Reconnecting;
+      this.log.debug('waiting for peer connection to reconnect', this.logContext);
       try {
-        if (!this.isMuted) {
-          this.log.debug('Track already unmuted', this.logContext);
-          return this;
-        }
-        if (this.source === Track.Source.Camera && !this.isUserProvided) {
-          this.log.debug('reacquiring camera track', this.logContext);
-          yield this.restartTrack();
+        yield sleep(minReconnectWait); // FIXME setTimeout again not ideal for a connection critical path
+        if (!this.pcManager) {
+          throw new UnexpectedConnectionState('PC manager is closed');
         }
-        yield _super.unmute.call(this);
-        return this;
-      } finally {
-        unlock();
+        yield this.pcManager.ensurePCTransportConnection(undefined, this.peerConnectionTimeout);
+        this.pcState = PCState.Connected;
+      } catch (e) {
+        // TODO do we need a `failed` state here for the PC?
+        this.pcState = PCState.Disconnected;
+        throw new ConnectionError("could not establish PC connection, ".concat(e.message));
       }
     });
   }
-  setTrackMuted(muted) {
-    super.setTrackMuted(muted);
-    for (const sc of this.simulcastCodecs.values()) {
-      sc.mediaStreamTrack.enabled = !muted;
-    }
-  }
-  getSenderStats() {
+  /* @internal */
+  sendDataPacket(packet, kind) {
     return __awaiter(this, void 0, void 0, function* () {
-      var _a;
-      if (!((_a = this.sender) === null || _a === void 0 ? void 0 : _a.getStats)) {
-        return [];
+      const msg = packet.toBinary();
+      // make sure we do have a data connection
+      yield this.ensurePublisherConnected(kind);
+      const dc = this.dataChannelForKind(kind);
+      if (dc) {
+        dc.send(msg);
       }
-      const items = [];
-      const stats = yield this.sender.getStats();
-      stats.forEach(v => {
-        var _a;
-        if (v.type === 'outbound-rtp') {
-          const vs = {
-            type: 'video',
-            streamId: v.id,
-            frameHeight: v.frameHeight,
-            frameWidth: v.frameWidth,
-            framesPerSecond: v.framesPerSecond,
-            framesSent: v.framesSent,
-            firCount: v.firCount,
-            pliCount: v.pliCount,
-            nackCount: v.nackCount,
-            packetsSent: v.packetsSent,
-            bytesSent: v.bytesSent,
-            qualityLimitationReason: v.qualityLimitationReason,
-            qualityLimitationDurations: v.qualityLimitationDurations,
-            qualityLimitationResolutionChanges: v.qualityLimitationResolutionChanges,
-            rid: (_a = v.rid) !== null && _a !== void 0 ? _a : v.id,
-            retransmittedPacketsSent: v.retransmittedPacketsSent,
-            targetBitrate: v.targetBitrate,
-            timestamp: v.timestamp
-          };
-          // locate the appropriate remote-inbound-rtp item
-          const r = stats.get(v.remoteId);
-          if (r) {
-            vs.jitter = r.jitter;
-            vs.packetsLost = r.packetsLost;
-            vs.roundTripTime = r.roundTripTime;
-          }
-          items.push(vs);
-        }
-      });
-      // make sure highest res layer is always first
-      items.sort((a, b) => {
-        var _a, _b;
-        return ((_a = b.frameWidth) !== null && _a !== void 0 ? _a : 0) - ((_b = a.frameWidth) !== null && _b !== void 0 ? _b : 0);
-      });
-      return items;
+      this.updateAndEmitDCBufferStatus(kind);
     });
   }
-  setPublishingQuality(maxQuality) {
-    const qualities = [];
-    for (let q = VideoQuality.LOW; q <= VideoQuality.HIGH; q += 1) {
-      qualities.push(new SubscribedQuality({
-        quality: q,
-        enabled: q <= maxQuality
-      }));
-    }
-    this.log.debug("setting publishing quality. max quality ".concat(maxQuality), this.logContext);
-    this.setPublishingLayers(qualities);
+  /**
+   * @internal
+   */
+  ensureDataTransportConnected(kind_1) {
+    return __awaiter(this, arguments, void 0, function (kind) {
+      var _this2 = this;
+      let subscriber = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.subscriberPrimary;
+      return function* () {
+        var _a;
+        if (!_this2.pcManager) {
+          throw new UnexpectedConnectionState('PC manager is closed');
+        }
+        const transport = subscriber ? _this2.pcManager.subscriber : _this2.pcManager.publisher;
+        const transportName = subscriber ? 'Subscriber' : 'Publisher';
+        if (!transport) {
+          throw new ConnectionError("".concat(transportName, " connection not set"));
+        }
+        if (!subscriber && !_this2.pcManager.publisher.isICEConnected && _this2.pcManager.publisher.getICEConnectionState() !== 'checking') {
+          // start negotiation
+          _this2.negotiate();
+        }
+        const targetChannel = _this2.dataChannelForKind(kind, subscriber);
+        if ((targetChannel === null || targetChannel === void 0 ? void 0 : targetChannel.readyState) === 'open') {
+          return;
+        }
+        // wait until ICE connected
+        const endTime = new Date().getTime() + _this2.peerConnectionTimeout;
+        while (new Date().getTime() < endTime) {
+          if (transport.isICEConnected && ((_a = _this2.dataChannelForKind(kind, subscriber)) === null || _a === void 0 ? void 0 : _a.readyState) === 'open') {
+            return;
+          }
+          yield sleep(50);
+        }
+        throw new ConnectionError("could not establish ".concat(transportName, " connection, state: ").concat(transport.getICEConnectionState()));
+      }();
+    });
   }
-  setDeviceId(deviceId) {
+  ensurePublisherConnected(kind) {
     return __awaiter(this, void 0, void 0, function* () {
-      if (this._constraints.deviceId === deviceId && this._mediaStreamTrack.getSettings().deviceId === unwrapConstraint(deviceId)) {
-        return true;
-      }
-      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();
+      if (!this.publisherConnectionPromise) {
+        this.publisherConnectionPromise = this.ensureDataTransportConnected(kind, false);
       }
-      return this.isMuted || unwrapConstraint(deviceId) === this._mediaStreamTrack.getSettings().deviceId;
+      yield this.publisherConnectionPromise;
     });
   }
-  restartTrack(options) {
+  /* @internal */
+  verifyTransport() {
+    if (!this.pcManager) {
+      return false;
+    }
+    // primary connection
+    if (this.pcManager.currentState !== PCTransportState.CONNECTED) {
+      return false;
+    }
+    // ensure signal is connected
+    if (!this.client.ws || this.client.ws.readyState === WebSocket.CLOSED) {
+      return false;
+    }
+    return true;
+  }
+  /** @internal */
+  negotiate() {
     return __awaiter(this, void 0, void 0, function* () {
-      var _a, e_3, _b, _c;
-      let constraints;
-      if (options) {
-        const streamConstraints = constraintsForOptions({
-          video: options
-        });
-        if (typeof streamConstraints.video !== 'boolean') {
-          constraints = streamConstraints.video;
-        }
-      }
-      yield this.restart(constraints);
-      try {
-        for (var _d = true, _e = __asyncValues(this.simulcastCodecs.values()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-          _c = _f.value;
-          _d = false;
-          const sc = _c;
-          if (sc.sender) {
-            sc.mediaStreamTrack = this.mediaStreamTrack.clone();
-            yield sc.sender.replaceTrack(sc.mediaStreamTrack);
-          }
+      // observe signal state
+      return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+        if (!this.pcManager) {
+          reject(new NegotiationError('PC manager is closed'));
+          return;
         }
-      } catch (e_3_1) {
-        e_3 = {
-          error: e_3_1
+        this.pcManager.requirePublisher();
+        const abortController = new AbortController();
+        const handleClosed = () => {
+          abortController.abort();
+          this.log.debug('engine disconnected while negotiation was ongoing', this.logContext);
+          resolve();
+          return;
         };
-      } finally {
+        if (this.isClosed) {
+          reject('cannot negotiate on closed engine');
+        }
+        this.on(EngineEvent.Closing, handleClosed);
+        this.pcManager.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);
+        });
         try {
-          if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+          yield this.pcManager.negotiate(abortController);
+          resolve();
+        } catch (e) {
+          if (e instanceof NegotiationError) {
+            this.fullReconnectOnNext = true;
+          }
+          this.handleDisconnect('negotiation', ReconnectReason.RR_UNKNOWN);
+          reject(e);
         } finally {
-          if (e_3) throw e_3.error;
+          this.off(EngineEvent.Closing, handleClosed);
         }
-      }
+      }));
     });
   }
-  setProcessor(processor_1) {
-    const _super = Object.create(null, {
-      setProcessor: {
-        get: () => super.setProcessor
+  dataChannelForKind(kind, sub) {
+    if (!sub) {
+      if (kind === DataPacket_Kind.LOSSY) {
+        return this.lossyDC;
       }
-    });
-    return __awaiter(this, arguments, void 0, function (processor) {
-      var _this = this;
-      let showProcessedStreamLocally = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-      return function* () {
-        var _a, e_4, _b, _c;
-        var _d, _e;
-        yield _super.setProcessor.call(_this, processor, showProcessedStreamLocally);
-        if ((_d = _this.processor) === null || _d === void 0 ? void 0 : _d.processedTrack) {
-          try {
-            for (var _f = true, _g = __asyncValues(_this.simulcastCodecs.values()), _h; _h = yield _g.next(), _a = _h.done, !_a; _f = true) {
-              _c = _h.value;
-              _f = false;
-              const sc = _c;
-              yield (_e = sc.sender) === null || _e === void 0 ? void 0 : _e.replaceTrack(_this.processor.processedTrack);
-            }
-          } catch (e_4_1) {
-            e_4 = {
-              error: e_4_1
-            };
-          } finally {
-            try {
-              if (!_f && !_a && (_b = _g.return)) yield _b.call(_g);
-            } finally {
-              if (e_4) throw e_4.error;
-            }
-          }
-        }
-      }();
-    });
+      if (kind === DataPacket_Kind.RELIABLE) {
+        return this.reliableDC;
+      }
+    } else {
+      if (kind === DataPacket_Kind.LOSSY) {
+        return this.lossyDCSub;
+      }
+      if (kind === DataPacket_Kind.RELIABLE) {
+        return this.reliableDCSub;
+      }
+    }
   }
-  addSimulcastTrack(codec, encodings) {
-    if (this.simulcastCodecs.has(codec)) {
-      this.log.error("".concat(codec, " already added, skipping adding simulcast codec"), this.logContext);
+  /** @internal */
+  sendSyncState(remoteTracks, localTracks) {
+    var _a, _b;
+    if (!this.pcManager) {
+      this.log.warn('sync state cannot be sent without peer connection setup', this.logContext);
       return;
     }
-    const simulcastCodecInfo = {
-      codec,
-      mediaStreamTrack: this.mediaStreamTrack.clone(),
-      sender: undefined,
-      encodings
+    const previousAnswer = this.pcManager.subscriber.getLocalDescription();
+    const previousOffer = this.pcManager.subscriber.getRemoteDescription();
+    /* 1. autosubscribe on, so subscribed tracks = all tracks - unsub tracks,
+          in this case, we send unsub tracks, so server add all tracks to this
+          subscribe pc and unsub special tracks from it.
+       2. autosubscribe off, we send subscribed tracks.
+    */
+    const autoSubscribe = (_b = (_a = this.signalOpts) === null || _a === void 0 ? void 0 : _a.autoSubscribe) !== null && _b !== void 0 ? _b : true;
+    const trackSids = new Array();
+    const trackSidsDisabled = new Array();
+    remoteTracks.forEach(track => {
+      if (track.isDesired !== autoSubscribe) {
+        trackSids.push(track.trackSid);
+      }
+      if (!track.isEnabled) {
+        trackSidsDisabled.push(track.trackSid);
+      }
+    });
+    this.client.sendSyncState(new SyncState({
+      answer: previousAnswer ? toProtoSessionDescription({
+        sdp: previousAnswer.sdp,
+        type: previousAnswer.type
+      }) : undefined,
+      offer: previousOffer ? toProtoSessionDescription({
+        sdp: previousOffer.sdp,
+        type: previousOffer.type
+      }) : undefined,
+      subscription: new UpdateSubscription({
+        trackSids,
+        subscribe: !autoSubscribe,
+        participantTracks: []
+      }),
+      publishTracks: getTrackPublicationInfo(localTracks),
+      dataChannels: this.dataChannelsInfo(),
+      trackSidsDisabled
+    }));
+  }
+  /* @internal */
+  failNext() {
+    // debugging method to fail the next reconnect/resume attempt
+    this.shouldFailNext = true;
+  }
+  dataChannelsInfo() {
+    const infos = [];
+    const getInfo = (dc, target) => {
+      if ((dc === null || dc === void 0 ? void 0 : dc.id) !== undefined && dc.id !== null) {
+        infos.push(new DataChannelInfo({
+          label: dc.label,
+          id: dc.id,
+          target
+        }));
+      }
     };
-    this.simulcastCodecs.set(codec, simulcastCodecInfo);
-    return simulcastCodecInfo;
+    getInfo(this.dataChannelForKind(DataPacket_Kind.LOSSY), SignalTarget.PUBLISHER);
+    getInfo(this.dataChannelForKind(DataPacket_Kind.RELIABLE), SignalTarget.PUBLISHER);
+    getInfo(this.dataChannelForKind(DataPacket_Kind.LOSSY, true), SignalTarget.SUBSCRIBER);
+    getInfo(this.dataChannelForKind(DataPacket_Kind.RELIABLE, true), SignalTarget.SUBSCRIBER);
+    return infos;
+  }
+  clearReconnectTimeout() {
+    if (this.reconnectTimeout) {
+      CriticalTimers.clearTimeout(this.reconnectTimeout);
+    }
+  }
+  clearPendingReconnect() {
+    this.clearReconnectTimeout();
+    this.reconnectAttempts = 0;
+  }
+  registerOnLineListener() {
+    if (isWeb()) {
+      window.addEventListener('online', this.handleBrowserOnLine);
+    }
+  }
+  deregisterOnLineListener() {
+    if (isWeb()) {
+      window.removeEventListener('online', this.handleBrowserOnLine);
+    }
+  }
+}
+class SignalReconnectError extends Error {}
+
+class RegionUrlProvider {
+  constructor(url, token) {
+    this.lastUpdateAt = 0;
+    this.settingsCacheTime = 3000;
+    this.attemptedRegions = [];
+    this.serverUrl = new URL(url);
+    this.token = token;
+  }
+  updateToken(token) {
+    this.token = token;
+  }
+  isCloud() {
+    return isCloud(this.serverUrl);
   }
-  setSimulcastTrackSender(codec, sender) {
-    const simulcastCodecInfo = this.simulcastCodecs.get(codec);
-    if (!simulcastCodecInfo) {
-      return;
-    }
-    simulcastCodecInfo.sender = sender;
-    // browser will reenable disabled codec/layers after new codec has been published,
-    // so refresh subscribedCodecs after publish a new codec
-    setTimeout(() => {
-      if (this.subscribedCodecs) {
-        this.setPublishingCodecs(this.subscribedCodecs);
-      }
-    }, refreshSubscribedCodecAfterNewCodec);
+  getServerUrl() {
+    return this.serverUrl;
   }
-  /**
-   * @internal
-   * Sets codecs that should be publishing, returns new codecs that have not yet
-   * been published
-   */
-  setPublishingCodecs(codecs) {
+  getNextBestRegionUrl(abortSignal) {
     return __awaiter(this, void 0, void 0, function* () {
-      var _a, codecs_1, codecs_1_1;
-      var _b, e_5, _c, _d;
-      this.log.debug('setting publishing codecs', Object.assign(Object.assign({}, this.logContext), {
-        codecs,
-        currentCodec: this.codec
-      }));
-      // only enable simulcast codec for preference codec setted
-      if (!this.codec && codecs.length > 0) {
-        yield this.setPublishingLayers(codecs[0].qualities);
-        return [];
+      if (!this.isCloud()) {
+        throw Error('region availability is only supported for LiveKit Cloud domains');
       }
-      this.subscribedCodecs = codecs;
-      const newCodecs = [];
-      try {
-        for (_a = true, codecs_1 = __asyncValues(codecs); codecs_1_1 = yield codecs_1.next(), _b = codecs_1_1.done, !_b; _a = true) {
-          _d = codecs_1_1.value;
-          _a = false;
-          const codec = _d;
-          if (!this.codec || this.codec === codec.codec) {
-            yield this.setPublishingLayers(codec.qualities);
-          } else {
-            const simulcastCodecInfo = this.simulcastCodecs.get(codec.codec);
-            this.log.debug("try setPublishingCodec for ".concat(codec.codec), Object.assign(Object.assign({}, this.logContext), {
-              simulcastCodecInfo
-            }));
-            if (!simulcastCodecInfo || !simulcastCodecInfo.sender) {
-              for (const q of codec.qualities) {
-                if (q.enabled) {
-                  newCodecs.push(codec.codec);
-                  break;
-                }
-              }
-            } else if (simulcastCodecInfo.encodings) {
-              this.log.debug("try setPublishingLayersForSender ".concat(codec.codec), this.logContext);
-              yield setPublishingLayersForSender(simulcastCodecInfo.sender, simulcastCodecInfo.encodings, codec.qualities, this.senderLock, this.log, this.logContext);
-            }
-          }
-        }
-      } catch (e_5_1) {
-        e_5 = {
-          error: e_5_1
-        };
-      } finally {
-        try {
-          if (!_a && !_b && (_c = codecs_1.return)) yield _c.call(codecs_1);
-        } finally {
-          if (e_5) throw e_5.error;
-        }
+      if (!this.regionSettings || Date.now() - this.lastUpdateAt > this.settingsCacheTime) {
+        this.regionSettings = yield this.fetchRegionSettings(abortSignal);
       }
-      return newCodecs;
-    });
-  }
-  /**
-   * @internal
-   * Sets layers that should be publishing
-   */
-  setPublishingLayers(qualities) {
-    return __awaiter(this, void 0, void 0, function* () {
-      this.log.debug('setting publishing layers', Object.assign(Object.assign({}, this.logContext), {
-        qualities
-      }));
-      if (!this.sender || !this.encodings) {
-        return;
+      const regionsLeft = this.regionSettings.regions.filter(region => !this.attemptedRegions.find(attempted => attempted.url === region.url));
+      if (regionsLeft.length > 0) {
+        const nextRegion = regionsLeft[0];
+        this.attemptedRegions.push(nextRegion);
+        livekitLogger.debug("next region: ".concat(nextRegion.region));
+        return nextRegion.url;
+      } else {
+        return null;
       }
-      yield setPublishingLayersForSender(this.sender, this.encodings, qualities, this.senderLock, this.log, this.logContext);
     });
   }
-  handleAppVisibilityChanged() {
-    const _super = Object.create(null, {
-      handleAppVisibilityChanged: {
-        get: () => super.handleAppVisibilityChanged
-      }
-    });
+  resetAttempts() {
+    this.attemptedRegions = [];
+  }
+  /* @internal */
+  fetchRegionSettings(signal) {
     return __awaiter(this, void 0, void 0, function* () {
-      yield _super.handleAppVisibilityChanged.call(this);
-      if (!isMobile()) return;
-      if (this.isInBackground && this.source === Track.Source.Camera) {
-        this._mediaStreamTrack.enabled = false;
+      const regionSettingsResponse = yield fetch("".concat(getCloudConfigUrl(this.serverUrl), "/regions"), {
+        headers: {
+          authorization: "Bearer ".concat(this.token)
+        },
+        signal
+      });
+      if (regionSettingsResponse.ok) {
+        const regionSettings = yield regionSettingsResponse.json();
+        this.lastUpdateAt = Date.now();
+        return regionSettings;
+      } else {
+        throw new ConnectionError("Could not fetch region settings: ".concat(regionSettingsResponse.statusText), regionSettingsResponse.status === 401 ? 0 /* ConnectionErrorReason.NotAllowed */ : undefined, regionSettingsResponse.status);
       }
     });
   }
 }
-function setPublishingLayersForSender(sender, senderEncodings, qualities, senderLock, log, logContext) {
-  return __awaiter(this, void 0, void 0, function* () {
-    const unlock = yield senderLock.lock();
-    log.debug('setPublishingLayersForSender', Object.assign(Object.assign({}, logContext), {
-      sender,
-      qualities,
-      senderEncodings
-    }));
-    try {
-      const params = sender.getParameters();
-      const {
-        encodings
-      } = params;
-      if (!encodings) {
-        return;
-      }
-      if (encodings.length !== senderEncodings.length) {
-        log.warn('cannot set publishing layers, encodings mismatch', Object.assign(Object.assign({}, logContext), {
-          encodings,
-          senderEncodings
-        }));
-        return;
-      }
-      let hasChanged = false;
-      /* disable closable spatial layer as it has video blur / frozen issue with current server / client
-      1. chrome 113: when switching to up layer with scalability Mode change, it will generate a
-            low resolution frame and recover very quickly, but noticable
-      2. livekit sfu: additional pli request cause video frozen for a few frames, also noticable */
-      const closableSpatial = false;
-      /* @ts-ignore */
-      if (closableSpatial && encodings[0].scalabilityMode) ; else {
-        // simulcast dynacast encodings
-        encodings.forEach((encoding, idx) => {
-          var _a;
-          let rid = (_a = encoding.rid) !== null && _a !== void 0 ? _a : '';
-          if (rid === '') {
-            rid = 'q';
-          }
-          const quality = videoQualityForRid(rid);
-          const subscribedQuality = qualities.find(q => q.quality === quality);
-          if (!subscribedQuality) {
-            return;
-          }
-          if (encoding.active !== subscribedQuality.enabled) {
-            hasChanged = true;
-            encoding.active = subscribedQuality.enabled;
-            log.debug("setting layer ".concat(subscribedQuality.quality, " to ").concat(encoding.active ? 'enabled' : 'disabled'), logContext);
-            // FireFox does not support setting encoding.active to false, so we
-            // have a workaround of lowering its bitrate and resolution to the min.
-            if (isFireFox()) {
-              if (subscribedQuality.enabled) {
-                encoding.scaleResolutionDownBy = senderEncodings[idx].scaleResolutionDownBy;
-                encoding.maxBitrate = senderEncodings[idx].maxBitrate;
-                /* @ts-ignore */
-                encoding.maxFrameRate = senderEncodings[idx].maxFrameRate;
-              } else {
-                encoding.scaleResolutionDownBy = 4;
-                encoding.maxBitrate = 10;
-                /* @ts-ignore */
-                encoding.maxFrameRate = 2;
-              }
-            }
-          }
-        });
-      }
-      if (hasChanged) {
-        params.encodings = encodings;
-        log.debug("setting encodings", Object.assign(Object.assign({}, logContext), {
-          encodings: params.encodings
-        }));
-        yield sender.setParameters(params);
-      }
-    } finally {
-      unlock();
-    }
-  });
-}
-function videoQualityForRid(rid) {
-  switch (rid) {
-    case 'f':
-      return VideoQuality.HIGH;
-    case 'h':
-      return VideoQuality.MEDIUM;
-    case 'q':
-      return VideoQuality.LOW;
-    default:
-      return VideoQuality.HIGH;
-  }
-}
-function videoLayersFromEncodings(width, height, encodings, svc) {
-  // default to a single layer, HQ
-  if (!encodings) {
-    return [new VideoLayer({
-      quality: VideoQuality.HIGH,
-      width,
-      height,
-      bitrate: 0,
-      ssrc: 0
-    })];
-  }
-  if (svc) {
-    // svc layers
-    /* @ts-ignore */
-    const encodingSM = encodings[0].scalabilityMode;
-    const sm = new ScalabilityMode(encodingSM);
-    const layers = [];
-    const resRatio = sm.suffix == 'h' ? 1.5 : 2;
-    const bitratesRatio = sm.suffix == 'h' ? 2 : 3;
-    for (let i = 0; i < sm.spatial; i += 1) {
-      layers.push(new VideoLayer({
-        quality: VideoQuality.HIGH - i,
-        width: Math.ceil(width / Math.pow(resRatio, i)),
-        height: Math.ceil(height / Math.pow(resRatio, i)),
-        bitrate: encodings[0].maxBitrate ? Math.ceil(encodings[0].maxBitrate / Math.pow(bitratesRatio, i)) : 0,
-        ssrc: 0
-      }));
-    }
-    return layers;
-  }
-  return encodings.map(encoding => {
-    var _a, _b, _c;
-    const scale = (_a = encoding.scaleResolutionDownBy) !== null && _a !== void 0 ? _a : 1;
-    let quality = videoQualityForRid((_b = encoding.rid) !== null && _b !== void 0 ? _b : '');
-    return new VideoLayer({
-      quality,
-      width: Math.ceil(width / scale),
-      height: Math.ceil(height / scale),
-      bitrate: (_c = encoding.maxBitrate) !== null && _c !== void 0 ? _c : 0,
-      ssrc: 0
-    });
-  });
+function getCloudConfigUrl(serverUrl) {
+  return "".concat(serverUrl.protocol.replace('ws', 'http'), "//").concat(serverUrl.host, "/settings");
 }
 
 class RemoteTrack extends Track {
@@ -18468,9 +18430,8 @@ 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) {
-        this.log.info("End-to-end encryption is set up, simulcast publishing will be disabled on Safari", Object.assign({}, this.logContext));
+      if (!isE2EESimulcastSupported() && this.roomOptions.e2ee) {
+        this.log.info("End-to-end encryption is set up, simulcast publishing will be disabled on Safari versions and iOS browsers running iOS < v17.2", Object.assign({}, this.logContext));
         opts.simulcast = false;
       }
       if (opts.source) {
@@ -18630,7 +18591,6 @@ class LocalParticipant extends Participant {
           this.log.debug('falling back to server selected codec', Object.assign(Object.assign(Object.assign({}, this.logContext), getLogContextFromTrack(track)), {
             codec: updatedCodec
           }));
-          /* @ts-ignore */
           opts.videoCodec = updatedCodec;
           // recompute encodings since bitrates/etc could have changed
           encodings = computeVideoEncodings(track.source === Track.Source.ScreenShare, req.width, req.height, opts);