livekit-client 1.2.0 → 1.2.3

package/dist/livekit-client.esm.mjs

@@ -2997,7 +2997,7 @@ LongBits$2.prototype.length = function length() {
   };
 })(minimal$1);
 
-var writer = Writer$1;
+var writer$2 = Writer$1;
 var util$4 = minimal$1;
 var BufferWriter$1; // cyclic
 
@@ -3476,7 +3476,7 @@ Writer$1._configure = function (BufferWriter_) {
 
 var writer_buffer = BufferWriter; // extends Writer
 
-var Writer = writer;
+var Writer = writer$2;
 (BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;
 var util$3 = minimal$1;
 /**
@@ -4193,7 +4193,7 @@ var roots = {};
 
   protobuf.build = "minimal"; // Serialization
 
-  protobuf.Writer = writer;
+  protobuf.Writer = writer$2;
   protobuf.BufferWriter = writer_buffer;
   protobuf.Reader = reader;
   protobuf.BufferReader = reader_buffer; // Utility
@@ -9997,8 +9997,8 @@ var RoomEvent;
    * When we have encountered an error while attempting to create a track.
    * The errors take place in getUserMedia().
    * Use MediaDeviceFailure.getFailure(error) to get the reason of failure.
-   * [[getAudioCreateError]] and [[getVideoCreateError]] will indicate if it had
-   * an error while creating the audio or video track respectively.
+   * [[LocalParticipant.lastCameraError]] and [[LocalParticipant.lastMicrophoneError]]
+   * will indicate if it had an error while creating the audio or video track respectively.
    *
    * args: (error: Error)
    */
@@ -10265,7 +10265,7 @@ function computeBitrate(currentStats, prevStats) {
   return (bytesNow - bytesPrev) * 8 * 1000 / (currentStats.timestamp - prevStats.timestamp);
 }
 
-var version$1 = "1.2.0";
+var version$1 = "1.2.3";
 
 const version = version$1;
 const protocolVersion = 8;
@@ -12016,8 +12016,6 @@ class LocalVideoTrack extends LocalTrack {
   }
 
   stop() {
-    this.sender = undefined;
-
     this._mediaStreamTrack.getConstraints();
 
     this.simulcastCodecs.forEach(trackInfo => {
@@ -13455,7 +13453,7 @@ function computeVideoEncodings(isScreenShare, width, height, options) {
           encodings.push({
             rid: videoRids[2 - i],
             scaleResolutionDownBy: 2 ** i,
-            maxBitrate: videoEncoding ? videoEncoding.maxBitrate / 2 ** i : 0,
+            maxBitrate: videoEncoding ? videoEncoding.maxBitrate / 3 ** i : 0,
 
             /* @ts-ignore */
             maxFramerate: original.encoding.maxFramerate,
@@ -14053,6 +14051,15 @@ class RemoteParticipant extends Participant {
 
     newTracks.forEach(publication => {
       this.emit(ParticipantEvent.TrackPublished, publication);
+      const existingTrackOfSource = Array.from(this.tracks.values()).find(publishedTrack => publishedTrack.source === publication.source);
+
+      if (existingTrackOfSource) {
+        livekitLogger.warn("received a second track publication for ".concat(this.identity, " with the same source: ").concat(publication.source), {
+          oldTrack: existingTrackOfSource,
+          newTrack: publication,
+          participant: this
+        });
+      }
     }); // detect removed tracks
 
     this.tracks.forEach(publication => {
@@ -14314,8 +14321,8 @@ class LocalParticipant extends Participant {
    */
 
 
-  setCameraEnabled(enabled, options) {
-    return this.setTrackEnabled(Track.Source.Camera, enabled, options);
+  setCameraEnabled(enabled, options, publishOptions) {
+    return this.setTrackEnabled(Track.Source.Camera, enabled, options, publishOptions);
   }
   /**
    * Enable or disable a participant's microphone track.
@@ -14325,8 +14332,8 @@ class LocalParticipant extends Participant {
    */
 
 
-  setMicrophoneEnabled(enabled, options) {
-    return this.setTrackEnabled(Track.Source.Microphone, enabled, options);
+  setMicrophoneEnabled(enabled, options, publishOptions) {
+    return this.setTrackEnabled(Track.Source.Microphone, enabled, options, publishOptions);
   }
   /**
    * Start or stop sharing a participant's screen
@@ -14334,8 +14341,8 @@ class LocalParticipant extends Participant {
    */
 
 
-  setScreenShareEnabled(enabled, options) {
-    return this.setTrackEnabled(Track.Source.ScreenShare, enabled, options);
+  setScreenShareEnabled(enabled, options, publishOptions) {
+    return this.setTrackEnabled(Track.Source.ScreenShare, enabled, options, publishOptions);
   }
   /** @internal */
 
@@ -14351,7 +14358,7 @@ class LocalParticipant extends Participant {
     return changed;
   }
 
-  async setTrackEnabled(source, enabled, options) {
+  async setTrackEnabled(source, enabled, options, publishOptions) {
     var _a, _b;
 
     livekitLogger.debug('setTrackEnabled', {
@@ -14401,7 +14408,7 @@ class LocalParticipant extends Participant {
           const publishPromises = [];
 
           for (const localTrack of localTracks) {
-            publishPromises.push(this.publishTrack(localTrack));
+            publishPromises.push(this.publishTrack(localTrack, publishOptions));
           }
 
           const publishedTracks = await Promise.all(publishPromises); // for screen share publications including audio, this will only return the screen share publication, not the screen share audio one
@@ -14581,7 +14588,7 @@ class LocalParticipant extends Participant {
 
 
   async publishTrack(track, options) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
 
     const opts = _objectSpread2(_objectSpread2({}, (_a = this.roomOptions) === null || _a === void 0 ? void 0 : _a.publishDefaults), options); // convert raw media track into audio or video track
 
@@ -14618,6 +14625,23 @@ class LocalParticipant extends Participant {
       track.source = opts.source;
     }
 
+    const existingTrackOfSource = Array.from(this.tracks.values()).find(publishedTrack => track instanceof LocalTrack && publishedTrack.source === track.source);
+
+    if (existingTrackOfSource) {
+      try {
+        // throw an Error in order to capture the stack trace
+        throw Error("publishing a second track with the same source: ".concat(track.source));
+      } catch (e) {
+        if (e instanceof Error) {
+          livekitLogger.warn(e.message, {
+            oldTrack: existingTrackOfSource,
+            newTrack: track,
+            trace: e.stack
+          });
+        }
+      }
+    }
+
     if (opts.stopMicTrackOnMute && track instanceof LocalAudioTrack) {
       track.stopOnMute = true;
     }
@@ -14725,6 +14749,10 @@ class LocalParticipant extends Participant {
       track.codec = opts.videoCodec;
     }
 
+    if (track.codec === 'av1' && encodings && ((_h = encodings[0]) === null || _h === void 0 ? void 0 : _h.maxBitrate)) {
+      this.engine.publisher.setTrackCodecBitrate(req.cid, track.codec, encodings[0].maxBitrate / 1000);
+    }
+
     this.engine.negotiate(); // store RTPSender
 
     track.sender = transceiver.sender;
@@ -14746,7 +14774,7 @@ class LocalParticipant extends Participant {
 
 
   async publishAdditionalCodecForTrack(track, videoCodec, options) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f;
 
     const opts = _objectSpread2(_objectSpread2({}, (_a = this.roomOptions) === null || _a === void 0 ? void 0 : _a.publishDefaults), options); // clear scalabilityMode setting for backup codec
 
@@ -14814,6 +14842,11 @@ class LocalParticipant extends Participant {
     const transceiver = await this.engine.publisher.pc.addTransceiver(simulcastTrack.mediaStreamTrack, transceiverInit);
     this.setPreferredCodec(transceiver, track.kind, opts.videoCodec);
     track.setSimulcastTrackSender(opts.videoCodec, transceiver.sender);
+
+    if (videoCodec === 'av1' && ((_f = encodings[0]) === null || _f === void 0 ? void 0 : _f.maxBitrate)) {
+      this.engine.publisher.setTrackCodecBitrate(req.cid, videoCodec, encodings[0].maxBitrate / 1000);
+    }
+
     this.engine.negotiate();
     livekitLogger.debug("published ".concat(opts.videoCodec, " for track ").concat(track.sid), {
       encodings,
@@ -14840,7 +14873,6 @@ class LocalParticipant extends Participant {
     }
 
     track = publication.track;
-    track.sender = undefined;
     track.off(TrackEvent.Muted, this.onTrackMuted);
     track.off(TrackEvent.Unmuted, this.onTrackUnmuted);
     track.off(TrackEvent.Ended, this.handleTrackEnded);
@@ -14855,29 +14887,19 @@ class LocalParticipant extends Participant {
       track.stop();
     }
 
-    const {
-      mediaStreamTrack
-    } = track;
-
-    if (this.engine.publisher && this.engine.publisher.pc.connectionState !== 'closed') {
-      const senders = this.engine.publisher.pc.getSenders();
-      senders.forEach(sender => {
-        var _a;
-
-        if (sender.track === mediaStreamTrack) {
-          try {
-            (_a = this.engine.publisher) === null || _a === void 0 ? void 0 : _a.pc.removeTrack(sender);
-            this.engine.negotiate();
-          } catch (e) {
-            livekitLogger.warn('failed to remove track', {
-              error: e,
-              method: 'unpublishTrack'
-            });
-          }
-        }
-      });
-    } // remove from our maps
+    if (this.engine.publisher && this.engine.publisher.pc.connectionState !== 'closed' && track.sender) {
+      try {
+        this.engine.publisher.pc.removeTrack(track.sender);
+        this.engine.negotiate();
+      } catch (e) {
+        livekitLogger.warn('failed to remove track', {
+          error: e,
+          method: 'unpublishTrack'
+        });
+      }
+    }
 
+    track.sender = undefined; // remove from our maps
 
     this.tracks.delete(publication.trackSid);
 
@@ -19041,13 +19063,718 @@ function createConnectionParams(token, info, opts) {
   return "?".concat(params.toString());
 }
 
+const maxRetryDelay = 7000;
+const DEFAULT_RETRY_DELAYS_IN_MS = [0, 300, 2 * 2 * 300, 3 * 3 * 300, 4 * 4 * 300, maxRetryDelay, maxRetryDelay, maxRetryDelay, maxRetryDelay, maxRetryDelay];
+
+class DefaultReconnectPolicy {
+  constructor(retryDelays) {
+    this._retryDelays = retryDelays !== undefined ? [...retryDelays] : DEFAULT_RETRY_DELAYS_IN_MS;
+  }
+
+  nextRetryDelayInMs(context) {
+    if (context.retryCount >= this._retryDelays.length) return null;
+    const retryDelay = this._retryDelays[context.retryCount];
+    if (context.retryCount <= 1) return retryDelay;
+    return retryDelay + Math.random() * 1000;
+  }
+
+}
+
+var parser$1 = {};
+
+var grammar$2 = {exports: {}};
+
+var grammar$1 = grammar$2.exports = {
+  v: [{
+    name: 'version',
+    reg: /^(\d*)$/
+  }],
+  o: [{
+    // o=- 20518 0 IN IP4 203.0.113.1
+    // NB: sessionId will be a String in most cases because it is huge
+    name: 'origin',
+    reg: /^(\S*) (\d*) (\d*) (\S*) IP(\d) (\S*)/,
+    names: ['username', 'sessionId', 'sessionVersion', 'netType', 'ipVer', 'address'],
+    format: '%s %s %d %s IP%d %s'
+  }],
+  // default parsing of these only (though some of these feel outdated)
+  s: [{
+    name: 'name'
+  }],
+  i: [{
+    name: 'description'
+  }],
+  u: [{
+    name: 'uri'
+  }],
+  e: [{
+    name: 'email'
+  }],
+  p: [{
+    name: 'phone'
+  }],
+  z: [{
+    name: 'timezones'
+  }],
+  // TODO: this one can actually be parsed properly...
+  r: [{
+    name: 'repeats'
+  }],
+  // TODO: this one can also be parsed properly
+  // k: [{}], // outdated thing ignored
+  t: [{
+    // t=0 0
+    name: 'timing',
+    reg: /^(\d*) (\d*)/,
+    names: ['start', 'stop'],
+    format: '%d %d'
+  }],
+  c: [{
+    // c=IN IP4 10.47.197.26
+    name: 'connection',
+    reg: /^IN IP(\d) (\S*)/,
+    names: ['version', 'ip'],
+    format: 'IN IP%d %s'
+  }],
+  b: [{
+    // b=AS:4000
+    push: 'bandwidth',
+    reg: /^(TIAS|AS|CT|RR|RS):(\d*)/,
+    names: ['type', 'limit'],
+    format: '%s:%s'
+  }],
+  m: [{
+    // m=video 51744 RTP/AVP 126 97 98 34 31
+    // NB: special - pushes to session
+    // TODO: rtp/fmtp should be filtered by the payloads found here?
+    reg: /^(\w*) (\d*) ([\w/]*)(?: (.*))?/,
+    names: ['type', 'port', 'protocol', 'payloads'],
+    format: '%s %d %s %s'
+  }],
+  a: [{
+    // a=rtpmap:110 opus/48000/2
+    push: 'rtp',
+    reg: /^rtpmap:(\d*) ([\w\-.]*)(?:\s*\/(\d*)(?:\s*\/(\S*))?)?/,
+    names: ['payload', 'codec', 'rate', 'encoding'],
+    format: function (o) {
+      return o.encoding ? 'rtpmap:%d %s/%s/%s' : o.rate ? 'rtpmap:%d %s/%s' : 'rtpmap:%d %s';
+    }
+  }, {
+    // a=fmtp:108 profile-level-id=24;object=23;bitrate=64000
+    // a=fmtp:111 minptime=10; useinbandfec=1
+    push: 'fmtp',
+    reg: /^fmtp:(\d*) ([\S| ]*)/,
+    names: ['payload', 'config'],
+    format: 'fmtp:%d %s'
+  }, {
+    // a=control:streamid=0
+    name: 'control',
+    reg: /^control:(.*)/,
+    format: 'control:%s'
+  }, {
+    // a=rtcp:65179 IN IP4 193.84.77.194
+    name: 'rtcp',
+    reg: /^rtcp:(\d*)(?: (\S*) IP(\d) (\S*))?/,
+    names: ['port', 'netType', 'ipVer', 'address'],
+    format: function (o) {
+      return o.address != null ? 'rtcp:%d %s IP%d %s' : 'rtcp:%d';
+    }
+  }, {
+    // a=rtcp-fb:98 trr-int 100
+    push: 'rtcpFbTrrInt',
+    reg: /^rtcp-fb:(\*|\d*) trr-int (\d*)/,
+    names: ['payload', 'value'],
+    format: 'rtcp-fb:%s trr-int %d'
+  }, {
+    // a=rtcp-fb:98 nack rpsi
+    push: 'rtcpFb',
+    reg: /^rtcp-fb:(\*|\d*) ([\w-_]*)(?: ([\w-_]*))?/,
+    names: ['payload', 'type', 'subtype'],
+    format: function (o) {
+      return o.subtype != null ? 'rtcp-fb:%s %s %s' : 'rtcp-fb:%s %s';
+    }
+  }, {
+    // a=extmap:2 urn:ietf:params:rtp-hdrext:toffset
+    // a=extmap:1/recvonly URI-gps-string
+    // a=extmap:3 urn:ietf:params:rtp-hdrext:encrypt urn:ietf:params:rtp-hdrext:smpte-tc 25@600/24
+    push: 'ext',
+    reg: /^extmap:(\d+)(?:\/(\w+))?(?: (urn:ietf:params:rtp-hdrext:encrypt))? (\S*)(?: (\S*))?/,
+    names: ['value', 'direction', 'encrypt-uri', 'uri', 'config'],
+    format: function (o) {
+      return 'extmap:%d' + (o.direction ? '/%s' : '%v') + (o['encrypt-uri'] ? ' %s' : '%v') + ' %s' + (o.config ? ' %s' : '');
+    }
+  }, {
+    // a=extmap-allow-mixed
+    name: 'extmapAllowMixed',
+    reg: /^(extmap-allow-mixed)/
+  }, {
+    // a=crypto:1 AES_CM_128_HMAC_SHA1_80 inline:PS1uQCVeeCFCanVmcjkpPywjNWhcYD0mXXtxaVBR|2^20|1:32
+    push: 'crypto',
+    reg: /^crypto:(\d*) ([\w_]*) (\S*)(?: (\S*))?/,
+    names: ['id', 'suite', 'config', 'sessionConfig'],
+    format: function (o) {
+      return o.sessionConfig != null ? 'crypto:%d %s %s %s' : 'crypto:%d %s %s';
+    }
+  }, {
+    // a=setup:actpass
+    name: 'setup',
+    reg: /^setup:(\w*)/,
+    format: 'setup:%s'
+  }, {
+    // a=connection:new
+    name: 'connectionType',
+    reg: /^connection:(new|existing)/,
+    format: 'connection:%s'
+  }, {
+    // a=mid:1
+    name: 'mid',
+    reg: /^mid:([^\s]*)/,
+    format: 'mid:%s'
+  }, {
+    // a=msid:0c8b064d-d807-43b4-b434-f92a889d8587 98178685-d409-46e0-8e16-7ef0db0db64a
+    name: 'msid',
+    reg: /^msid:(.*)/,
+    format: 'msid:%s'
+  }, {
+    // a=ptime:20
+    name: 'ptime',
+    reg: /^ptime:(\d*(?:\.\d*)*)/,
+    format: 'ptime:%d'
+  }, {
+    // a=maxptime:60
+    name: 'maxptime',
+    reg: /^maxptime:(\d*(?:\.\d*)*)/,
+    format: 'maxptime:%d'
+  }, {
+    // a=sendrecv
+    name: 'direction',
+    reg: /^(sendrecv|recvonly|sendonly|inactive)/
+  }, {
+    // a=ice-lite
+    name: 'icelite',
+    reg: /^(ice-lite)/
+  }, {
+    // a=ice-ufrag:F7gI
+    name: 'iceUfrag',
+    reg: /^ice-ufrag:(\S*)/,
+    format: 'ice-ufrag:%s'
+  }, {
+    // a=ice-pwd:x9cml/YzichV2+XlhiMu8g
+    name: 'icePwd',
+    reg: /^ice-pwd:(\S*)/,
+    format: 'ice-pwd:%s'
+  }, {
+    // a=fingerprint:SHA-1 00:11:22:33:44:55:66:77:88:99:AA:BB:CC:DD:EE:FF:00:11:22:33
+    name: 'fingerprint',
+    reg: /^fingerprint:(\S*) (\S*)/,
+    names: ['type', 'hash'],
+    format: 'fingerprint:%s %s'
+  }, {
+    // a=candidate:0 1 UDP 2113667327 203.0.113.1 54400 typ host
+    // a=candidate:1162875081 1 udp 2113937151 192.168.34.75 60017 typ host generation 0 network-id 3 network-cost 10
+    // a=candidate:3289912957 2 udp 1845501695 193.84.77.194 60017 typ srflx raddr 192.168.34.75 rport 60017 generation 0 network-id 3 network-cost 10
+    // a=candidate:229815620 1 tcp 1518280447 192.168.150.19 60017 typ host tcptype active generation 0 network-id 3 network-cost 10
+    // a=candidate:3289912957 2 tcp 1845501695 193.84.77.194 60017 typ srflx raddr 192.168.34.75 rport 60017 tcptype passive generation 0 network-id 3 network-cost 10
+    push: 'candidates',
+    reg: /^candidate:(\S*) (\d*) (\S*) (\d*) (\S*) (\d*) typ (\S*)(?: raddr (\S*) rport (\d*))?(?: tcptype (\S*))?(?: generation (\d*))?(?: network-id (\d*))?(?: network-cost (\d*))?/,
+    names: ['foundation', 'component', 'transport', 'priority', 'ip', 'port', 'type', 'raddr', 'rport', 'tcptype', 'generation', 'network-id', 'network-cost'],
+    format: function (o) {
+      var str = 'candidate:%s %d %s %d %s %d typ %s';
+      str += o.raddr != null ? ' raddr %s rport %d' : '%v%v'; // NB: candidate has three optional chunks, so %void middles one if it's missing
+
+      str += o.tcptype != null ? ' tcptype %s' : '%v';
+
+      if (o.generation != null) {
+        str += ' generation %d';
+      }
+
+      str += o['network-id'] != null ? ' network-id %d' : '%v';
+      str += o['network-cost'] != null ? ' network-cost %d' : '%v';
+      return str;
+    }
+  }, {
+    // a=end-of-candidates (keep after the candidates line for readability)
+    name: 'endOfCandidates',
+    reg: /^(end-of-candidates)/
+  }, {
+    // a=remote-candidates:1 203.0.113.1 54400 2 203.0.113.1 54401 ...
+    name: 'remoteCandidates',
+    reg: /^remote-candidates:(.*)/,
+    format: 'remote-candidates:%s'
+  }, {
+    // a=ice-options:google-ice
+    name: 'iceOptions',
+    reg: /^ice-options:(\S*)/,
+    format: 'ice-options:%s'
+  }, {
+    // a=ssrc:2566107569 cname:t9YU8M1UxTF8Y1A1
+    push: 'ssrcs',
+    reg: /^ssrc:(\d*) ([\w_-]*)(?::(.*))?/,
+    names: ['id', 'attribute', 'value'],
+    format: function (o) {
+      var str = 'ssrc:%d';
+
+      if (o.attribute != null) {
+        str += ' %s';
+
+        if (o.value != null) {
+          str += ':%s';
+        }
+      }
+
+      return str;
+    }
+  }, {
+    // a=ssrc-group:FEC 1 2
+    // a=ssrc-group:FEC-FR 3004364195 1080772241
+    push: 'ssrcGroups',
+    // token-char = %x21 / %x23-27 / %x2A-2B / %x2D-2E / %x30-39 / %x41-5A / %x5E-7E
+    reg: /^ssrc-group:([\x21\x23\x24\x25\x26\x27\x2A\x2B\x2D\x2E\w]*) (.*)/,
+    names: ['semantics', 'ssrcs'],
+    format: 'ssrc-group:%s %s'
+  }, {
+    // a=msid-semantic: WMS Jvlam5X3SX1OP6pn20zWogvaKJz5Hjf9OnlV
+    name: 'msidSemantic',
+    reg: /^msid-semantic:\s?(\w*) (\S*)/,
+    names: ['semantic', 'token'],
+    format: 'msid-semantic: %s %s' // space after ':' is not accidental
+
+  }, {
+    // a=group:BUNDLE audio video
+    push: 'groups',
+    reg: /^group:(\w*) (.*)/,
+    names: ['type', 'mids'],
+    format: 'group:%s %s'
+  }, {
+    // a=rtcp-mux
+    name: 'rtcpMux',
+    reg: /^(rtcp-mux)/
+  }, {
+    // a=rtcp-rsize
+    name: 'rtcpRsize',
+    reg: /^(rtcp-rsize)/
+  }, {
+    // a=sctpmap:5000 webrtc-datachannel 1024
+    name: 'sctpmap',
+    reg: /^sctpmap:([\w_/]*) (\S*)(?: (\S*))?/,
+    names: ['sctpmapNumber', 'app', 'maxMessageSize'],
+    format: function (o) {
+      return o.maxMessageSize != null ? 'sctpmap:%s %s %s' : 'sctpmap:%s %s';
+    }
+  }, {
+    // a=x-google-flag:conference
+    name: 'xGoogleFlag',
+    reg: /^x-google-flag:([^\s]*)/,
+    format: 'x-google-flag:%s'
+  }, {
+    // a=rid:1 send max-width=1280;max-height=720;max-fps=30;depend=0
+    push: 'rids',
+    reg: /^rid:([\d\w]+) (\w+)(?: ([\S| ]*))?/,
+    names: ['id', 'direction', 'params'],
+    format: function (o) {
+      return o.params ? 'rid:%s %s %s' : 'rid:%s %s';
+    }
+  }, {
+    // a=imageattr:97 send [x=800,y=640,sar=1.1,q=0.6] [x=480,y=320] recv [x=330,y=250]
+    // a=imageattr:* send [x=800,y=640] recv *
+    // a=imageattr:100 recv [x=320,y=240]
+    push: 'imageattrs',
+    reg: new RegExp( // a=imageattr:97
+    '^imageattr:(\\d+|\\*)' + // send [x=800,y=640,sar=1.1,q=0.6] [x=480,y=320]
+    '[\\s\\t]+(send|recv)[\\s\\t]+(\\*|\\[\\S+\\](?:[\\s\\t]+\\[\\S+\\])*)' + // recv [x=330,y=250]
+    '(?:[\\s\\t]+(recv|send)[\\s\\t]+(\\*|\\[\\S+\\](?:[\\s\\t]+\\[\\S+\\])*))?'),
+    names: ['pt', 'dir1', 'attrs1', 'dir2', 'attrs2'],
+    format: function (o) {
+      return 'imageattr:%s %s %s' + (o.dir2 ? ' %s %s' : '');
+    }
+  }, {
+    // a=simulcast:send 1,2,3;~4,~5 recv 6;~7,~8
+    // a=simulcast:recv 1;4,5 send 6;7
+    name: 'simulcast',
+    reg: new RegExp( // a=simulcast:
+    '^simulcast:' + // send 1,2,3;~4,~5
+    '(send|recv) ([a-zA-Z0-9\\-_~;,]+)' + // space + recv 6;~7,~8
+    '(?:\\s?(send|recv) ([a-zA-Z0-9\\-_~;,]+))?' + // end
+    '$'),
+    names: ['dir1', 'list1', 'dir2', 'list2'],
+    format: function (o) {
+      return 'simulcast:%s %s' + (o.dir2 ? ' %s %s' : '');
+    }
+  }, {
+    // old simulcast draft 03 (implemented by Firefox)
+    //   https://tools.ietf.org/html/draft-ietf-mmusic-sdp-simulcast-03
+    // a=simulcast: recv pt=97;98 send pt=97
+    // a=simulcast: send rid=5;6;7 paused=6,7
+    name: 'simulcast_03',
+    reg: /^simulcast:[\s\t]+([\S+\s\t]+)$/,
+    names: ['value'],
+    format: 'simulcast: %s'
+  }, {
+    // a=framerate:25
+    // a=framerate:29.97
+    name: 'framerate',
+    reg: /^framerate:(\d+(?:$|\.\d+))/,
+    format: 'framerate:%s'
+  }, {
+    // RFC4570
+    // a=source-filter: incl IN IP4 239.5.2.31 10.1.15.5
+    name: 'sourceFilter',
+    reg: /^source-filter: *(excl|incl) (\S*) (IP4|IP6|\*) (\S*) (.*)/,
+    names: ['filterMode', 'netType', 'addressTypes', 'destAddress', 'srcList'],
+    format: 'source-filter: %s %s %s %s %s'
+  }, {
+    // a=bundle-only
+    name: 'bundleOnly',
+    reg: /^(bundle-only)/
+  }, {
+    // a=label:1
+    name: 'label',
+    reg: /^label:(.+)/,
+    format: 'label:%s'
+  }, {
+    // RFC version 26 for SCTP over DTLS
+    // https://tools.ietf.org/html/draft-ietf-mmusic-sctp-sdp-26#section-5
+    name: 'sctpPort',
+    reg: /^sctp-port:(\d+)$/,
+    format: 'sctp-port:%s'
+  }, {
+    // RFC version 26 for SCTP over DTLS
+    // https://tools.ietf.org/html/draft-ietf-mmusic-sctp-sdp-26#section-6
+    name: 'maxMessageSize',
+    reg: /^max-message-size:(\d+)$/,
+    format: 'max-message-size:%s'
+  }, {
+    // RFC7273
+    // a=ts-refclk:ptp=IEEE1588-2008:39-A7-94-FF-FE-07-CB-D0:37
+    push: 'tsRefClocks',
+    reg: /^ts-refclk:([^\s=]*)(?:=(\S*))?/,
+    names: ['clksrc', 'clksrcExt'],
+    format: function (o) {
+      return 'ts-refclk:%s' + (o.clksrcExt != null ? '=%s' : '');
+    }
+  }, {
+    // RFC7273
+    // a=mediaclk:direct=963214424
+    name: 'mediaClk',
+    reg: /^mediaclk:(?:id=(\S*))? *([^\s=]*)(?:=(\S*))?(?: *rate=(\d+)\/(\d+))?/,
+    names: ['id', 'mediaClockName', 'mediaClockValue', 'rateNumerator', 'rateDenominator'],
+    format: function (o) {
+      var str = 'mediaclk:';
+      str += o.id != null ? 'id=%s %s' : '%v%s';
+      str += o.mediaClockValue != null ? '=%s' : '';
+      str += o.rateNumerator != null ? ' rate=%s' : '';
+      str += o.rateDenominator != null ? '/%s' : '';
+      return str;
+    }
+  }, {
+    // a=keywds:keywords
+    name: 'keywords',
+    reg: /^keywds:(.+)$/,
+    format: 'keywds:%s'
+  }, {
+    // a=content:main
+    name: 'content',
+    reg: /^content:(.+)/,
+    format: 'content:%s'
+  }, // BFCP https://tools.ietf.org/html/rfc4583
+  {
+    // a=floorctrl:c-s
+    name: 'bfcpFloorCtrl',
+    reg: /^floorctrl:(c-only|s-only|c-s)/,
+    format: 'floorctrl:%s'
+  }, {
+    // a=confid:1
+    name: 'bfcpConfId',
+    reg: /^confid:(\d+)/,
+    format: 'confid:%s'
+  }, {
+    // a=userid:1
+    name: 'bfcpUserId',
+    reg: /^userid:(\d+)/,
+    format: 'userid:%s'
+  }, {
+    // a=floorid:1
+    name: 'bfcpFloorId',
+    reg: /^floorid:(.+) (?:m-stream|mstrm):(.+)/,
+    names: ['id', 'mStream'],
+    format: 'floorid:%s mstrm:%s'
+  }, {
+    // any a= that we don't understand is kept verbatim on media.invalid
+    push: 'invalid',
+    names: ['value']
+  }]
+}; // set sensible defaults to avoid polluting the grammar with boring details
+
+Object.keys(grammar$1).forEach(function (key) {
+  var objs = grammar$1[key];
+  objs.forEach(function (obj) {
+    if (!obj.reg) {
+      obj.reg = /(.*)/;
+    }
+
+    if (!obj.format) {
+      obj.format = '%s';
+    }
+  });
+});
+
+(function (exports) {
+  var toIntIfInt = function (v) {
+    return String(Number(v)) === v ? Number(v) : v;
+  };
+
+  var attachProperties = function (match, location, names, rawName) {
+    if (rawName && !names) {
+      location[rawName] = toIntIfInt(match[1]);
+    } else {
+      for (var i = 0; i < names.length; i += 1) {
+        if (match[i + 1] != null) {
+          location[names[i]] = toIntIfInt(match[i + 1]);
+        }
+      }
+    }
+  };
+
+  var parseReg = function (obj, location, content) {
+    var needsBlank = obj.name && obj.names;
+
+    if (obj.push && !location[obj.push]) {
+      location[obj.push] = [];
+    } else if (needsBlank && !location[obj.name]) {
+      location[obj.name] = {};
+    }
+
+    var keyLocation = obj.push ? {} : // blank object that will be pushed
+    needsBlank ? location[obj.name] : location; // otherwise, named location or root
+
+    attachProperties(content.match(obj.reg), keyLocation, obj.names, obj.name);
+
+    if (obj.push) {
+      location[obj.push].push(keyLocation);
+    }
+  };
+
+  var grammar = grammar$2.exports;
+  var validLine = RegExp.prototype.test.bind(/^([a-z])=(.*)/);
+
+  exports.parse = function (sdp) {
+    var session = {},
+        media = [],
+        location = session; // points at where properties go under (one of the above)
+    // parse lines we understand
+
+    sdp.split(/(\r\n|\r|\n)/).filter(validLine).forEach(function (l) {
+      var type = l[0];
+      var content = l.slice(2);
+
+      if (type === 'm') {
+        media.push({
+          rtp: [],
+          fmtp: []
+        });
+        location = media[media.length - 1]; // point at latest media line
+      }
+
+      for (var j = 0; j < (grammar[type] || []).length; j += 1) {
+        var obj = grammar[type][j];
+
+        if (obj.reg.test(content)) {
+          return parseReg(obj, location, content);
+        }
+      }
+    });
+    session.media = media; // link it up
+
+    return session;
+  };
+
+  var paramReducer = function (acc, expr) {
+    var s = expr.split(/=(.+)/, 2);
+
+    if (s.length === 2) {
+      acc[s[0]] = toIntIfInt(s[1]);
+    } else if (s.length === 1 && expr.length > 1) {
+      acc[s[0]] = undefined;
+    }
+
+    return acc;
+  };
+
+  exports.parseParams = function (str) {
+    return str.split(/;\s?/).reduce(paramReducer, {});
+  }; // For backward compatibility - alias will be removed in 3.0.0
+
+
+  exports.parseFmtpConfig = exports.parseParams;
+
+  exports.parsePayloads = function (str) {
+    return str.toString().split(' ').map(Number);
+  };
+
+  exports.parseRemoteCandidates = function (str) {
+    var candidates = [];
+    var parts = str.split(' ').map(toIntIfInt);
+
+    for (var i = 0; i < parts.length; i += 3) {
+      candidates.push({
+        component: parts[i],
+        ip: parts[i + 1],
+        port: parts[i + 2]
+      });
+    }
+
+    return candidates;
+  };
+
+  exports.parseImageAttributes = function (str) {
+    return str.split(' ').map(function (item) {
+      return item.substring(1, item.length - 1).split(',').reduce(paramReducer, {});
+    });
+  };
+
+  exports.parseSimulcastStreamList = function (str) {
+    return str.split(';').map(function (stream) {
+      return stream.split(',').map(function (format) {
+        var scid,
+            paused = false;
+
+        if (format[0] !== '~') {
+          scid = toIntIfInt(format);
+        } else {
+          scid = toIntIfInt(format.substring(1, format.length));
+          paused = true;
+        }
+
+        return {
+          scid: scid,
+          paused: paused
+        };
+      });
+    });
+  };
+})(parser$1);
+
+var grammar = grammar$2.exports; // customized util.format - discards excess arguments and can void middle ones
+
+var formatRegExp = /%[sdv%]/g;
+
+var format = function (formatStr) {
+  var i = 1;
+  var args = arguments;
+  var len = args.length;
+  return formatStr.replace(formatRegExp, function (x) {
+    if (i >= len) {
+      return x; // missing argument
+    }
+
+    var arg = args[i];
+    i += 1;
+
+    switch (x) {
+      case '%%':
+        return '%';
+
+      case '%s':
+        return String(arg);
+
+      case '%d':
+        return Number(arg);
+
+      case '%v':
+        return '';
+    }
+  }); // NB: we discard excess arguments - they are typically undefined from makeLine
+};
+
+var makeLine = function (type, obj, location) {
+  var str = obj.format instanceof Function ? obj.format(obj.push ? location : location[obj.name]) : obj.format;
+  var args = [type + '=' + str];
+
+  if (obj.names) {
+    for (var i = 0; i < obj.names.length; i += 1) {
+      var n = obj.names[i];
+
+      if (obj.name) {
+        args.push(location[obj.name][n]);
+      } else {
+        // for mLine and push attributes
+        args.push(location[obj.names[i]]);
+      }
+    }
+  } else {
+    args.push(location[obj.name]);
+  }
+
+  return format.apply(null, args);
+}; // RFC specified order
+// TODO: extend this with all the rest
+
+
+var defaultOuterOrder = ['v', 'o', 's', 'i', 'u', 'e', 'p', 'c', 'b', 't', 'r', 'z', 'a'];
+var defaultInnerOrder = ['i', 'c', 'b', 'a'];
+
+var writer$1 = function (session, opts) {
+  opts = opts || {}; // ensure certain properties exist
+
+  if (session.version == null) {
+    session.version = 0; // 'v=0' must be there (only defined version atm)
+  }
+
+  if (session.name == null) {
+    session.name = ' '; // 's= ' must be there if no meaningful name set
+  }
+
+  session.media.forEach(function (mLine) {
+    if (mLine.payloads == null) {
+      mLine.payloads = '';
+    }
+  });
+  var outerOrder = opts.outerOrder || defaultOuterOrder;
+  var innerOrder = opts.innerOrder || defaultInnerOrder;
+  var sdp = []; // loop through outerOrder for matching properties on session
+
+  outerOrder.forEach(function (type) {
+    grammar[type].forEach(function (obj) {
+      if (obj.name in session && session[obj.name] != null) {
+        sdp.push(makeLine(type, obj, session));
+      } else if (obj.push in session && session[obj.push] != null) {
+        session[obj.push].forEach(function (el) {
+          sdp.push(makeLine(type, obj, el));
+        });
+      }
+    });
+  }); // then for each media line, follow the innerOrder
+
+  session.media.forEach(function (mLine) {
+    sdp.push(makeLine('m', grammar.m[0], mLine));
+    innerOrder.forEach(function (type) {
+      grammar[type].forEach(function (obj) {
+        if (obj.name in mLine && mLine[obj.name] != null) {
+          sdp.push(makeLine(type, obj, mLine));
+        } else if (obj.push in mLine && mLine[obj.push] != null) {
+          mLine[obj.push].forEach(function (el) {
+            sdp.push(makeLine(type, obj, el));
+          });
+        }
+      });
+    });
+  });
+  return sdp.join('\r\n') + '\r\n';
+};
+
+var parser = parser$1;
+var writer = writer$1;
+var write = writer;
+var parse = parser.parse;
+
 /** @internal */
 
 class PCTransport {
   constructor(config) {
     this.pendingCandidates = [];
     this.restartingIce = false;
-    this.renegotiate = false; // debounced negotiate interface
+    this.renegotiate = false;
+    this.trackBitrates = []; // debounced negotiate interface
 
     this.negotiate = r(() => {
       this.createAndSendOffer();
@@ -19082,6 +19809,8 @@ class PCTransport {
   }
 
   async createAndSendOffer(options) {
+    var _a;
+
     if (this.onOffer === undefined) {
       return;
     }
@@ -19112,21 +19841,114 @@ class PCTransport {
 
     livekitLogger.debug('starting to negotiate');
     const offer = await this.pc.createOffer(options);
+    const sdpParsed = parse((_a = offer.sdp) !== null && _a !== void 0 ? _a : '');
+    sdpParsed.media.forEach(media => {
+      if (media.type === 'audio') {
+        ensureAudioNack(media);
+      } else if (media.type === 'video') {
+        // mung sdp for codec bitrate setting that can't apply by sendEncoding
+        this.trackBitrates.some(trackbr => {
+          if (!media.msid || !media.msid.includes(trackbr.sid)) {
+            return false;
+          }
+
+          let codecPayload = 0;
+          media.rtp.some(rtp => {
+            if (rtp.codec.toUpperCase() === trackbr.codec.toUpperCase()) {
+              codecPayload = rtp.payload;
+              return true;
+            }
+
+            return false;
+          }); // add x-google-max-bitrate to fmtp line if not exist
+
+          if (codecPayload > 0) {
+            if (!media.fmtp.some(fmtp => {
+              if (fmtp.payload === codecPayload) {
+                if (!fmtp.config.includes('x-google-max-bitrate')) {
+                  fmtp.config += ";x-google-max-bitrate=".concat(trackbr.maxbr);
+                }
+
+                return true;
+              }
+
+              return false;
+            })) {
+              media.fmtp.push({
+                payload: codecPayload,
+                config: "x-google-max-bitrate=".concat(trackbr.maxbr)
+              });
+            }
+          }
+
+          return true;
+        });
+      }
+    });
+    offer.sdp = write(sdpParsed);
+    this.trackBitrates = [];
     await this.pc.setLocalDescription(offer);
     this.onOffer(offer);
   }
 
+  async createAndSetAnswer() {
+    var _a;
+
+    const answer = await this.pc.createAnswer();
+    const sdpParsed = parse((_a = answer.sdp) !== null && _a !== void 0 ? _a : '');
+    sdpParsed.media.forEach(media => {
+      if (media.type === 'audio') {
+        ensureAudioNack(media);
+      }
+    });
+    answer.sdp = write(sdpParsed);
+    await this.pc.setLocalDescription(answer);
+    return answer;
+  }
+
+  setTrackCodecBitrate(sid, codec, maxbr) {
+    this.trackBitrates.push({
+      sid,
+      codec,
+      maxbr
+    });
+  }
+
   close() {
     this.pc.close();
   }
 
 }
 
+function ensureAudioNack(media) {
+  // found opus codec to add nack fb
+  let opusPayload = 0;
+  media.rtp.some(rtp => {
+    if (rtp.codec === 'opus') {
+      opusPayload = rtp.payload;
+      return true;
+    }
+
+    return false;
+  }); // add nack rtcpfb if not exist
+
+  if (opusPayload > 0) {
+    if (!media.rtcpFb) {
+      media.rtcpFb = [];
+    }
+
+    if (!media.rtcpFb.some(fb => fb.payload === opusPayload && fb.type === 'nack')) {
+      media.rtcpFb.push({
+        payload: opusPayload,
+        type: 'nack'
+      });
+    }
+  }
+}
+
 const lossyDataChannel = '_lossy';
 const reliableDataChannel = '_reliable';
-const maxReconnectRetries = 10;
 const minReconnectWait = 2 * 1000;
-const maxReconnectDuration = 60 * 1000;
 const maxICEConnectTimeout = 15 * 1000;
 var PCState;
 
@@ -19141,8 +19963,14 @@ var PCState;
 
 
 class RTCEngine extends events.exports.EventEmitter {
-  constructor() {
+  constructor(options) {
+    var _this;
+
+    var _a;
+
     super();
+    _this = this;
+    this.options = options;
     this.rtcConfig = {};
     this.subscriberPrimary = false;
     this.pcState = PCState.New;
@@ -19217,53 +20045,85 @@ class RTCEngine extends events.exports.EventEmitter {
     // after a number of retries, we'll close and give up permanently
 
 
-    this.handleDisconnect = connection => {
-      if (this._isClosed) {
+    this.handleDisconnect = function (connection) {
+      let signalEvents = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+
+      if (_this._isClosed) {
         return;
       }
 
       livekitLogger.debug("".concat(connection, " disconnected"));
 
-      if (this.reconnectAttempts === 0) {
+      if (_this.reconnectAttempts === 0) {
         // only reset start time on the first try
-        this.reconnectStart = Date.now();
+        _this.reconnectStart = Date.now();
       }
 
-      const delay = this.reconnectAttempts * this.reconnectAttempts * 300;
-      setTimeout(async () => {
+      const disconnect = duration => {
+        livekitLogger.info("could not recover connection after ".concat(_this.reconnectAttempts, " attempts, ").concat(duration, "ms. giving up"));
+
+        _this.emit(EngineEvent.Disconnected);
+
+        _this.close();
+      };
+
+      const duration = Date.now() - _this.reconnectStart;
+
+      const delay = _this.getNextRetryDelay({
+        elapsedMs: duration,
+        retryCount: _this.reconnectAttempts
+      });
+
+      if (delay === null) {
+        disconnect(duration);
+        return;
+      }
+
+      livekitLogger.debug("reconnecting in ".concat(delay, "ms"));
+
+      if (_this.reconnectTimeout) {
+        clearTimeout(_this.reconnectTimeout);
+      }
+
+      _this.reconnectTimeout = setTimeout(async () => {
         var _a, _b, _c;
 
-        if (this._isClosed) {
+        if (_this._isClosed) {
           return;
         } // guard for attempting reconnection multiple times while one attempt is still not finished
 
 
-        if (this.attemptingReconnect) {
+        if (_this.attemptingReconnect) {
           return;
         }
 
         if (isFireFox() || // TODO remove once clientConfiguration handles firefox case server side
-        ((_a = this.clientConfiguration) === null || _a === void 0 ? void 0 : _a.resumeConnection) === ClientConfigSetting.DISABLED || // signaling state could change to closed due to hardware sleep
+        ((_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.primaryPC) === null || _b === void 0 ? void 0 : _b.signalingState) !== null && _c !== void 0 ? _c : 'closed') === 'closed') {
-          this.fullReconnectOnNext = true;
+        ((_c = (_b = _this.primaryPC) === null || _b === void 0 ? void 0 : _b.signalingState) !== null && _c !== void 0 ? _c : 'closed') === 'closed') {
+          _this.fullReconnectOnNext = true;
         }
 
         try {
-          this.attemptingReconnect = true;
+          _this.attemptingReconnect = true;
 
-          if (this.fullReconnectOnNext) {
-            await this.restartConnection();
+          if (_this.fullReconnectOnNext) {
+            await _this.restartConnection(signalEvents);
           } else {
-            await this.resumeConnection();
+            await _this.resumeConnection(signalEvents);
           }
 
-          this.reconnectAttempts = 0;
-          this.fullReconnectOnNext = false;
+          _this.reconnectAttempts = 0;
+          _this.fullReconnectOnNext = false;
+
+          if (_this.reconnectTimeout) {
+            clearTimeout(_this.reconnectTimeout);
+          }
         } catch (e) {
-          this.reconnectAttempts += 1;
+          _this.reconnectAttempts += 1;
           let reconnectRequired = false;
           let recoverable = true;
+          let requireSignalEvents = false;
 
           if (e instanceof UnexpectedConnectionState) {
             livekitLogger.debug('received unrecoverable error', {
@@ -19274,35 +20134,29 @@ class RTCEngine extends events.exports.EventEmitter {
           } else if (!(e instanceof SignalReconnectError)) {
             // cannot resume
             reconnectRequired = true;
-          } // when we flip from resume to reconnect, we need to reset reconnectAttempts
-          // this is needed to fire the right reconnecting events
+          } // when we flip from resume to reconnect
+          // we need to fire the right reconnecting events
 
 
-          if (reconnectRequired && !this.fullReconnectOnNext) {
-            this.fullReconnectOnNext = true;
-            this.reconnectAttempts = 0;
-          }
-
-          const duration = Date.now() - this.reconnectStart;
-
-          if (this.reconnectAttempts >= maxReconnectRetries || duration > maxReconnectDuration) {
-            recoverable = false;
+          if (reconnectRequired && !_this.fullReconnectOnNext) {
+            _this.fullReconnectOnNext = true;
+            requireSignalEvents = true;
           }
 
           if (recoverable) {
-            this.handleDisconnect('reconnect');
+            _this.handleDisconnect('reconnect', requireSignalEvents);
           } else {
-            livekitLogger.info("could not recover connection after ".concat(maxReconnectRetries, " attempts, ").concat(duration, "ms. giving up"));
-            this.emit(EngineEvent.Disconnected);
-            this.close();
+            disconnect(Date.now() - _this.reconnectStart);
           }
         } finally {
-          this.attemptingReconnect = false;
+          _this.attemptingReconnect = false;
         }
       }, delay);
     };
 
     this.client = new SignalClient();
+    this.client.signalLatency = this.options.expSignalLatency;
+    this.reconnectPolicy = (_a = this.options.reconnectPolicy) !== null && _a !== void 0 ? _a : new DefaultReconnectPolicy();
   }
 
   get isClosed() {
@@ -19366,8 +20220,16 @@ class RTCEngine extends events.exports.EventEmitter {
       throw new TrackInvalidError('a track with the same ID has already been published');
     }
 
-    return new Promise(resolve => {
-      this.pendingTrackResolvers[req.cid] = resolve;
+    return new Promise((resolve, reject) => {
+      const publicationTimeout = setTimeout(() => {
+        reject(new ConnectionError('publication of local track timed out, no response from server'));
+      }, 15000);
+
+      this.pendingTrackResolvers[req.cid] = info => {
+        clearTimeout(publicationTimeout);
+        resolve(info);
+      };
+
       this.client.sendAddTrack(req);
     });
   }
@@ -19541,8 +20403,7 @@ class RTCEngine extends events.exports.EventEmitter {
       });
       await this.subscriber.setRemoteDescription(sd); // answer the offer
 
-      const answer = await this.subscriber.pc.createAnswer();
-      await this.subscriber.pc.setLocalDescription(answer);
+      const answer = await this.subscriber.createAndSetAnswer();
       this.client.sendAnswer(answer);
     };
 
@@ -19615,7 +20476,22 @@ class RTCEngine extends events.exports.EventEmitter {
     this.reliableDC.onerror = this.handleDataError;
   }
 
+  getNextRetryDelay(context) {
+    try {
+      return this.reconnectPolicy.nextRetryDelayInMs(context);
+    } catch (e) {
+      livekitLogger.warn('encountered error in reconnect policy', {
+        error: e
+      });
+    } // error in user code with provided reconnect policy, stop reconnecting
+
+
+    return null;
+  }
+
   async restartConnection() {
+    let emitRestarting = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+
     var _a, _b;
 
     if (!this.url || !this.token) {
@@ -19625,7 +20501,7 @@ class RTCEngine extends events.exports.EventEmitter {
 
     livekitLogger.info("reconnecting, attempt: ".concat(this.reconnectAttempts));
 
-    if (this.reconnectAttempts === 0) {
+    if (emitRestarting || this.reconnectAttempts === 0) {
       this.emit(EngineEvent.Restarting);
     }
 
@@ -19654,6 +20530,8 @@ class RTCEngine extends events.exports.EventEmitter {
   }
 
   async resumeConnection() {
+    let emitResuming = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+
     var _a;
 
     if (!this.url || !this.token) {
@@ -19668,14 +20546,20 @@ class RTCEngine extends events.exports.EventEmitter {
 
     livekitLogger.info("resuming signal connection, attempt ".concat(this.reconnectAttempts));
 
-    if (this.reconnectAttempts === 0) {
+    if (emitResuming || this.reconnectAttempts === 0) {
       this.emit(EngineEvent.Resuming);
     }
 
     try {
       await this.client.reconnect(this.url, this.token);
     } catch (e) {
-      throw new SignalReconnectError();
+      let message = '';
+
+      if (e instanceof Error) {
+        message = e.message;
+      }
+
+      throw new SignalReconnectError(message);
     }
 
     this.emit(EngineEvent.SignalResumed);
@@ -19983,23 +20867,7 @@ class Room extends events.exports.EventEmitter {
         this.localParticipant.identity = pi.identity;
         this.localParticipant.updateInfo(pi); // forward metadata changed for the local participant
 
-        this.localParticipant.on(ParticipantEvent.ParticipantMetadataChanged, metadata => {
-          this.emit(RoomEvent.ParticipantMetadataChanged, metadata, this.localParticipant);
-        }).on(ParticipantEvent.TrackMuted, pub => {
-          this.emit(RoomEvent.TrackMuted, pub, this.localParticipant);
-        }).on(ParticipantEvent.TrackUnmuted, pub => {
-          this.emit(RoomEvent.TrackUnmuted, pub, this.localParticipant);
-        }).on(ParticipantEvent.LocalTrackPublished, pub => {
-          this.emit(RoomEvent.LocalTrackPublished, pub, this.localParticipant);
-        }).on(ParticipantEvent.LocalTrackUnpublished, pub => {
-          this.emit(RoomEvent.LocalTrackUnpublished, pub, this.localParticipant);
-        }).on(ParticipantEvent.ConnectionQualityChanged, quality => {
-          this.emit(RoomEvent.ConnectionQualityChanged, quality, this.localParticipant);
-        }).on(ParticipantEvent.MediaDevicesError, e => {
-          this.emit(RoomEvent.MediaDevicesError, e);
-        }).on(ParticipantEvent.ParticipantPermissionsChanged, prevPermissions => {
-          this.emit(RoomEvent.ParticipantPermissionsChanged, prevPermissions, this.localParticipant);
-        }); // populate remote participants, these should not trigger new events
+        this.localParticipant.on(ParticipantEvent.ParticipantMetadataChanged, this.onLocalParticipantMetadataChanged).on(ParticipantEvent.TrackMuted, this.onLocalTrackMuted).on(ParticipantEvent.TrackUnmuted, this.onLocalTrackUnmuted).on(ParticipantEvent.LocalTrackPublished, this.onLocalTrackPublished).on(ParticipantEvent.LocalTrackUnpublished, this.onLocalTrackUnpublished).on(ParticipantEvent.ConnectionQualityChanged, this.onLocalConnectionQualityChanged).on(ParticipantEvent.MediaDevicesError, this.onMediaDevicesError).on(ParticipantEvent.ParticipantPermissionsChanged, this.onLocalParticipantPermissionsChanged); // populate remote participants, these should not trigger new events
 
         joinResponse.otherParticipants.forEach(info => {
           if (info.sid !== this.localParticipant.sid && info.identity !== this.localParticipant.identity) {
@@ -20342,6 +21210,38 @@ class Room extends events.exports.EventEmitter {
       });
     };
 
+    this.onLocalParticipantMetadataChanged = metadata => {
+      this.emit(RoomEvent.ParticipantMetadataChanged, metadata, this.localParticipant);
+    };
+
+    this.onLocalTrackMuted = pub => {
+      this.emit(RoomEvent.TrackMuted, pub, this.localParticipant);
+    };
+
+    this.onLocalTrackUnmuted = pub => {
+      this.emit(RoomEvent.TrackUnmuted, pub, this.localParticipant);
+    };
+
+    this.onLocalTrackPublished = pub => {
+      this.emit(RoomEvent.LocalTrackPublished, pub, this.localParticipant);
+    };
+
+    this.onLocalTrackUnpublished = pub => {
+      this.emit(RoomEvent.LocalTrackUnpublished, pub, this.localParticipant);
+    };
+
+    this.onLocalConnectionQualityChanged = quality => {
+      this.emit(RoomEvent.ConnectionQualityChanged, quality, this.localParticipant);
+    };
+
+    this.onMediaDevicesError = e => {
+      this.emit(RoomEvent.MediaDevicesError, e);
+    };
+
+    this.onLocalParticipantPermissionsChanged = prevPermissions => {
+      this.emit(RoomEvent.ParticipantPermissionsChanged, prevPermissions, this.localParticipant);
+    };
+
     this.participants = new Map();
     this.identityToSid = new Map();
     this.options = options || {};
@@ -20357,8 +21257,7 @@ class Room extends events.exports.EventEmitter {
       return;
     }
 
-    this.engine = new RTCEngine();
-    this.engine.client.signalLatency = this.options.expSignalLatency;
+    this.engine = new RTCEngine(this.options);
     this.engine.client.onParticipantUpdate = this.handleParticipantUpdates;
     this.engine.client.onRoomUpdate = this.handleRoomUpdate;
     this.engine.client.onSpeakersChanged = this.handleSpeakersChanged;
@@ -20639,6 +21538,7 @@ class Room extends events.exports.EventEmitter {
         p.unpublishTrack(pub.trackSid);
       });
     });
+    this.localParticipant.off(ParticipantEvent.ParticipantMetadataChanged, this.onLocalParticipantMetadataChanged).off(ParticipantEvent.TrackMuted, this.onLocalTrackMuted).off(ParticipantEvent.TrackUnmuted, this.onLocalTrackUnmuted).off(ParticipantEvent.LocalTrackPublished, this.onLocalTrackPublished).off(ParticipantEvent.LocalTrackUnpublished, this.onLocalTrackUnpublished).off(ParticipantEvent.ConnectionQualityChanged, this.onLocalConnectionQualityChanged).off(ParticipantEvent.MediaDevicesError, this.onMediaDevicesError).off(ParticipantEvent.ParticipantPermissionsChanged, this.onLocalParticipantPermissionsChanged);
     this.localParticipant.tracks.forEach(pub => {
       var _a, _b;
 
@@ -20996,5 +21896,5 @@ async function createLocalScreenTracks(options) {
   return localTracks;
 }
 
-export { AudioPresets, ConnectionError, ConnectionQuality, ConnectionState, DataPacket_Kind, DisconnectReason, EngineEvent, LivekitError, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalVideoTrack, LogLevel, MediaDeviceFailure, Participant, ParticipantEvent, PublishDataError, RemoteAudioTrack, RemoteParticipant, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, RoomEvent, RoomState, ScreenSharePresets, Track, TrackEvent, TrackInvalidError, TrackPublication, UnexpectedConnectionState, UnsupportedServer, VideoPreset, VideoPresets, VideoPresets43, VideoQuality, attachToElement, createLocalAudioTrack, createLocalScreenTracks, createLocalTracks, createLocalVideoTrack, detachTrack, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, protocolVersion, setLogExtension, setLogLevel, version };
+export { AudioPresets, ConnectionError, ConnectionQuality, ConnectionState, DataPacket_Kind, DefaultReconnectPolicy, DisconnectReason, EngineEvent, LivekitError, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalVideoTrack, LogLevel, MediaDeviceFailure, Participant, ParticipantEvent, PublishDataError, RemoteAudioTrack, RemoteParticipant, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, RoomEvent, RoomState, ScreenSharePresets, Track, TrackEvent, TrackInvalidError, TrackPublication, UnexpectedConnectionState, UnsupportedServer, VideoPreset, VideoPresets, VideoPresets43, VideoQuality, attachToElement, createLocalAudioTrack, createLocalScreenTracks, createLocalTracks, createLocalVideoTrack, detachTrack, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, protocolVersion, setLogExtension, setLogLevel, version };
 //# sourceMappingURL=livekit-client.esm.mjs.map