livekit-client 1.1.6 → 1.1.9

package/dist/livekit-client.esm.mjs

@@ -4484,6 +4484,82 @@ function clientConfigSettingToJSON(object) {
       return 'UNKNOWN';
   }
 }
+var DisconnectReason;
+
+(function (DisconnectReason) {
+  DisconnectReason[DisconnectReason["UNKNOWN_REASON"] = 0] = "UNKNOWN_REASON";
+  DisconnectReason[DisconnectReason["CLIENT_INITIATED"] = 1] = "CLIENT_INITIATED";
+  DisconnectReason[DisconnectReason["DUPLICATE_IDENTITY"] = 2] = "DUPLICATE_IDENTITY";
+  DisconnectReason[DisconnectReason["SERVER_SHUTDOWN"] = 3] = "SERVER_SHUTDOWN";
+  DisconnectReason[DisconnectReason["PARTICIPANT_REMOVED"] = 4] = "PARTICIPANT_REMOVED";
+  DisconnectReason[DisconnectReason["ROOM_DELETED"] = 5] = "ROOM_DELETED";
+  DisconnectReason[DisconnectReason["STATE_MISMATCH"] = 6] = "STATE_MISMATCH";
+  DisconnectReason[DisconnectReason["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(DisconnectReason || (DisconnectReason = {}));
+
+function disconnectReasonFromJSON(object) {
+  switch (object) {
+    case 0:
+    case 'UNKNOWN_REASON':
+      return DisconnectReason.UNKNOWN_REASON;
+
+    case 1:
+    case 'CLIENT_INITIATED':
+      return DisconnectReason.CLIENT_INITIATED;
+
+    case 2:
+    case 'DUPLICATE_IDENTITY':
+      return DisconnectReason.DUPLICATE_IDENTITY;
+
+    case 3:
+    case 'SERVER_SHUTDOWN':
+      return DisconnectReason.SERVER_SHUTDOWN;
+
+    case 4:
+    case 'PARTICIPANT_REMOVED':
+      return DisconnectReason.PARTICIPANT_REMOVED;
+
+    case 5:
+    case 'ROOM_DELETED':
+      return DisconnectReason.ROOM_DELETED;
+
+    case 6:
+    case 'STATE_MISMATCH':
+      return DisconnectReason.STATE_MISMATCH;
+
+    case -1:
+    case 'UNRECOGNIZED':
+    default:
+      return DisconnectReason.UNRECOGNIZED;
+  }
+}
+function disconnectReasonToJSON(object) {
+  switch (object) {
+    case DisconnectReason.UNKNOWN_REASON:
+      return 'UNKNOWN_REASON';
+
+    case DisconnectReason.CLIENT_INITIATED:
+      return 'CLIENT_INITIATED';
+
+    case DisconnectReason.DUPLICATE_IDENTITY:
+      return 'DUPLICATE_IDENTITY';
+
+    case DisconnectReason.SERVER_SHUTDOWN:
+      return 'SERVER_SHUTDOWN';
+
+    case DisconnectReason.PARTICIPANT_REMOVED:
+      return 'PARTICIPANT_REMOVED';
+
+    case DisconnectReason.ROOM_DELETED:
+      return 'ROOM_DELETED';
+
+    case DisconnectReason.STATE_MISMATCH:
+      return 'STATE_MISMATCH';
+
+    default:
+      return 'UNKNOWN';
+  }
+}
 var ParticipantInfo_State;
 
 (function (ParticipantInfo_State) {
@@ -5204,7 +5280,8 @@ function createBaseSimulcastCodecInfo() {
   return {
     mimeType: '',
     mid: '',
-    cid: ''
+    cid: '',
+    layers: []
   };
 }
 
@@ -5224,6 +5301,10 @@ const SimulcastCodecInfo = {
       writer.uint32(26).string(message.cid);
     }
 
+    for (const v of message.layers) {
+      VideoLayer.encode(v, writer.uint32(34).fork()).ldelim();
+    }
+
     return writer;
   },
 
@@ -5248,6 +5329,10 @@ const SimulcastCodecInfo = {
           message.cid = reader.string();
           break;
 
+        case 4:
+          message.layers.push(VideoLayer.decode(reader, reader.uint32()));
+          break;
+
         default:
           reader.skipType(tag & 7);
           break;
@@ -5261,7 +5346,8 @@ const SimulcastCodecInfo = {
     return {
       mimeType: isSet$1(object.mimeType) ? String(object.mimeType) : '',
       mid: isSet$1(object.mid) ? String(object.mid) : '',
-      cid: isSet$1(object.cid) ? String(object.cid) : ''
+      cid: isSet$1(object.cid) ? String(object.cid) : '',
+      layers: Array.isArray(object === null || object === void 0 ? void 0 : object.layers) ? object.layers.map(e => VideoLayer.fromJSON(e)) : []
     };
   },
 
@@ -5270,16 +5356,24 @@ const SimulcastCodecInfo = {
     message.mimeType !== undefined && (obj.mimeType = message.mimeType);
     message.mid !== undefined && (obj.mid = message.mid);
     message.cid !== undefined && (obj.cid = message.cid);
+
+    if (message.layers) {
+      obj.layers = message.layers.map(e => e ? VideoLayer.toJSON(e) : undefined);
+    } else {
+      obj.layers = [];
+    }
+
     return obj;
   },
 
   fromPartial(object) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
 
     const message = createBaseSimulcastCodecInfo();
     message.mimeType = (_a = object.mimeType) !== null && _a !== void 0 ? _a : '';
     message.mid = (_b = object.mid) !== null && _b !== void 0 ? _b : '';
     message.cid = (_c = object.cid) !== null && _c !== void 0 ? _c : '';
+    message.layers = ((_d = object.layers) === null || _d === void 0 ? void 0 : _d.map(e => VideoLayer.fromPartial(e))) || [];
     return message;
   }
 
@@ -6179,7 +6273,8 @@ function createBaseClientConfiguration() {
   return {
     video: undefined,
     screen: undefined,
-    resumeConnection: 0
+    resumeConnection: 0,
+    disabledCodecs: undefined
   };
 }
 
@@ -6199,6 +6294,10 @@ const ClientConfiguration = {
       writer.uint32(24).int32(message.resumeConnection);
     }
 
+    if (message.disabledCodecs !== undefined) {
+      DisabledCodecs.encode(message.disabledCodecs, writer.uint32(34).fork()).ldelim();
+    }
+
     return writer;
   },
 
@@ -6223,6 +6322,10 @@ const ClientConfiguration = {
           message.resumeConnection = reader.int32();
           break;
 
+        case 4:
+          message.disabledCodecs = DisabledCodecs.decode(reader, reader.uint32());
+          break;
+
         default:
           reader.skipType(tag & 7);
           break;
@@ -6236,7 +6339,8 @@ const ClientConfiguration = {
     return {
       video: isSet$1(object.video) ? VideoConfiguration.fromJSON(object.video) : undefined,
       screen: isSet$1(object.screen) ? VideoConfiguration.fromJSON(object.screen) : undefined,
-      resumeConnection: isSet$1(object.resumeConnection) ? clientConfigSettingFromJSON(object.resumeConnection) : 0
+      resumeConnection: isSet$1(object.resumeConnection) ? clientConfigSettingFromJSON(object.resumeConnection) : 0,
+      disabledCodecs: isSet$1(object.disabledCodecs) ? DisabledCodecs.fromJSON(object.disabledCodecs) : undefined
     };
   },
 
@@ -6245,6 +6349,7 @@ const ClientConfiguration = {
     message.video !== undefined && (obj.video = message.video ? VideoConfiguration.toJSON(message.video) : undefined);
     message.screen !== undefined && (obj.screen = message.screen ? VideoConfiguration.toJSON(message.screen) : undefined);
     message.resumeConnection !== undefined && (obj.resumeConnection = clientConfigSettingToJSON(message.resumeConnection));
+    message.disabledCodecs !== undefined && (obj.disabledCodecs = message.disabledCodecs ? DisabledCodecs.toJSON(message.disabledCodecs) : undefined);
     return obj;
   },
 
@@ -6255,6 +6360,7 @@ const ClientConfiguration = {
     message.video = object.video !== undefined && object.video !== null ? VideoConfiguration.fromPartial(object.video) : undefined;
     message.screen = object.screen !== undefined && object.screen !== null ? VideoConfiguration.fromPartial(object.screen) : undefined;
     message.resumeConnection = (_a = object.resumeConnection) !== null && _a !== void 0 ? _a : 0;
+    message.disabledCodecs = object.disabledCodecs !== undefined && object.disabledCodecs !== null ? DisabledCodecs.fromPartial(object.disabledCodecs) : undefined;
     return message;
   }
 
@@ -6321,6 +6427,73 @@ const VideoConfiguration = {
 
 };
 
+function createBaseDisabledCodecs() {
+  return {
+    codecs: []
+  };
+}
+
+const DisabledCodecs = {
+  encode(message) {
+    let writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : minimal.Writer.create();
+
+    for (const v of message.codecs) {
+      Codec.encode(v, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input, length) {
+    const reader = input instanceof minimal.Reader ? input : new minimal.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDisabledCodecs();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.codecs.push(Codec.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object) {
+    return {
+      codecs: Array.isArray(object === null || object === void 0 ? void 0 : object.codecs) ? object.codecs.map(e => Codec.fromJSON(e)) : []
+    };
+  },
+
+  toJSON(message) {
+    const obj = {};
+
+    if (message.codecs) {
+      obj.codecs = message.codecs.map(e => e ? Codec.toJSON(e) : undefined);
+    } else {
+      obj.codecs = [];
+    }
+
+    return obj;
+  },
+
+  fromPartial(object) {
+    var _a;
+
+    const message = createBaseDisabledCodecs();
+    message.codecs = ((_a = object.codecs) === null || _a === void 0 ? void 0 : _a.map(e => Codec.fromPartial(e))) || [];
+    return message;
+  }
+
+};
+
 var globalThis$1 = (() => {
   if (typeof globalThis$1 !== 'undefined') return globalThis$1;
   if (typeof self !== 'undefined') return self;
@@ -6346,9 +6519,11 @@ const btoa = globalThis$1.btoa || (bin => globalThis$1.Buffer.from(bin, 'binary'
 
 function base64FromBytes(arr) {
   const bin = [];
-  arr.forEach(byte => {
+
+  for (const byte of arr) {
     bin.push(String.fromCharCode(byte));
-  });
+  }
+
   return btoa(bin.join(''));
 }
 
@@ -8033,7 +8208,8 @@ const UpdateTrackSettings = {
 
 function createBaseLeaveRequest() {
   return {
-    canReconnect: false
+    canReconnect: false,
+    reason: 0
   };
 }
 
@@ -8045,6 +8221,10 @@ const LeaveRequest = {
       writer.uint32(8).bool(message.canReconnect);
     }
 
+    if (message.reason !== 0) {
+      writer.uint32(16).int32(message.reason);
+    }
+
     return writer;
   },
 
@@ -8061,6 +8241,10 @@ const LeaveRequest = {
           message.canReconnect = reader.bool();
           break;
 
+        case 2:
+          message.reason = reader.int32();
+          break;
+
         default:
           reader.skipType(tag & 7);
           break;
@@ -8072,21 +8256,24 @@ const LeaveRequest = {
 
   fromJSON(object) {
     return {
-      canReconnect: isSet(object.canReconnect) ? Boolean(object.canReconnect) : false
+      canReconnect: isSet(object.canReconnect) ? Boolean(object.canReconnect) : false,
+      reason: isSet(object.reason) ? disconnectReasonFromJSON(object.reason) : 0
     };
   },
 
   toJSON(message) {
     const obj = {};
     message.canReconnect !== undefined && (obj.canReconnect = message.canReconnect);
+    message.reason !== undefined && (obj.reason = disconnectReasonToJSON(message.reason));
     return obj;
   },
 
   fromPartial(object) {
-    var _a;
+    var _a, _b;
 
     const message = createBaseLeaveRequest();
     message.canReconnect = (_a = object.canReconnect) !== null && _a !== void 0 ? _a : false;
+    message.reason = (_b = object.reason) !== null && _b !== void 0 ? _b : 0;
     return message;
   }
 
@@ -10070,7 +10257,7 @@ function computeBitrate(currentStats, prevStats) {
   return (bytesNow - bytesPrev) * 8 * 1000 / (currentStats.timestamp - prevStats.timestamp);
 }
 
-var version$1 = "1.1.6";
+var version$1 = "1.1.9";
 
 const version = version$1;
 const protocolVersion = 8;
@@ -10190,6 +10377,178 @@ class Future {
 
 }
 
+class Queue {
+  /**
+   * @class Queue
+   * 
+   * Priority queue with rate limiting<br>
+   * See the medium article:<br>
+   * https://mmomtchev.medium.com/parallelizing-download-loops-in-js-with-async-await-queue-670420880cd6
+   * 
+   * @param {number} [_maxConcurrent=1] Number of tasks allowed to run simultaneously
+   * @param {number} [_minCycle=0] Minimum number of milliseconds between two consecutive tasks
+   */
+  constructor(_maxConcurrent, _minCycle) {
+    this.maxConcurrent = _maxConcurrent || 1;
+    this.minCycle = _minCycle || 0;
+    this.queueRunning = [];
+    this.queueWaiting = {};
+    this.lastRun = 0;
+  }
+  /** @private */
+
+
+  dequeue(hash) {
+    const q = this.queueRunning;
+    const idx = q.findIndex(x => x.hash === hash);
+    if (idx == -1) throw 'queue desync';
+    const o = q[idx];
+    q.splice(idx, 1);
+    return o;
+  }
+  /** @private */
+
+
+  getFirstWaiting() {
+    for (let p of Object.keys(this.queueWaiting).sort((a, b) => a - b)) if (this.queueWaiting[p] !== undefined && this.queueWaiting[p].length > 0) return this.queueWaiting[p];
+
+    return undefined;
+  }
+  /**
+   * Signal that the task `hash` has finished.<br>
+   * Frees its slot in the queue
+   * 
+   * @method end
+   * @param {any} hash Unique hash identifying the task, Symbol() works very well
+   */
+
+
+  end(hash) {
+    const me = this.dequeue(hash);
+    me.resolve();
+    /* Choose the next task to run and unblock its promise */
+
+    const q = this.getFirstWaiting();
+
+    if (q !== undefined) {
+      const next = q.shift();
+      next.resolve();
+    }
+  }
+  /**
+   * Wait for a slot in the queue
+   * 
+   * @method wait
+   * @param {any} hash Unique hash identifying the task
+   * @param {number} [priority=0] Optional priority, -1 is higher priority than 1
+   * @return {Promise<void>} Resolved when the task is ready to run
+   */
+
+
+  async wait(hash, _priority) {
+    const priority = _priority === undefined ? 0 : _priority;
+    /* Us on the queue */
+
+    let me = {
+      hash,
+      priority
+    };
+    /* Create priorities on the fly */
+
+    if (this.queueWaiting[priority] == undefined) this.queueWaiting[priority] = [];
+    /* Are we allowed to run? */
+
+    if (this.queueRunning.length >= this.maxConcurrent) {
+      /* This promise will be unlocked from the outside */
+
+      /* and it cannot reject */
+      me.promise = new Promise(resolve => {
+        me.resolve = resolve;
+      });
+      /* Get in the line */
+
+      this.queueWaiting[priority].push(me);
+      await me.promise;
+    }
+
+    this.queueRunning.push(me);
+    me.promise = new Promise(resolve => {
+      me.resolve = resolve;
+    });
+    /* Wait if it is too soon */
+
+    while (Date.now() - this.lastRun < this.minCycle) {
+      await new Promise(resolve => setTimeout(resolve, this.minCycle - Date.now() + this.lastRun));
+    }
+
+    this.lastRun = Date.now();
+  }
+  /**
+   * Run a job (equivalent to calling Queue.wait(), fn() and then Queue.end())<br>
+   * fn can be both synchronous or asynchronous function
+   * 
+   * @method run
+   * @param {Function} fn The job
+   * @param {number} [priority=0] Optional priority, -1 is higher priority than 1
+   * @return {Promise<any>} Resolved when the task has finished with the return value of fn
+   */
+
+
+  run(job, _priority) {
+    const priority = _priority === undefined ? 0 : _priority;
+    const id = Symbol();
+    return this.wait(id, priority).then(() => job()).finally(() => {
+      this.end(id);
+    });
+  }
+  /**
+   * @interface QueueStats {running: number, waiting: number, last: number}
+   */
+
+  /**
+   * Return the number of running and waiting jobs
+   * 
+   * @method stat
+   * @return {QueueStats} running, waiting, last
+   */
+
+
+  stat() {
+    return {
+      running: this.queueRunning.length,
+      waiting: Object.keys(this.queueWaiting).reduce((t, x) => t += this.queueWaiting[x].length, 0),
+      last: this.lastRun
+    };
+  }
+  /**
+   * Returns a promise that resolves when the queue is empty
+   * 
+   * @method flush
+   * @return {Promise<void>}
+   */
+
+
+  async flush() {
+    /* Aways wait on the lowest priority in the queue */
+    while (this.stat().waiting > 0) {
+      for (let p of Object.keys(this.queueWaiting).sort((a, b) => b - a)) {
+        const qp = this.queueWaiting[p];
+
+        if (qp !== undefined && qp.length > 0) {
+          await qp[qp.length - 1].promise;
+        }
+      }
+    }
+    /* And then finish on the running queue */
+
+
+    while (this.queueRunning.length > 0) {
+      await Promise.allSettled(this.queueRunning.map(x => x.promise));
+    }
+  }
+
+}
+
 const defaultId = 'default';
 class DeviceManager {
   static getInstance() {
@@ -10742,6 +11101,7 @@ class Track extends events.exports.EventEmitter {
 
     this.kind = kind;
     this._mediaStreamTrack = mediaTrack;
+    this._mediaStreamID = mediaTrack.id;
     this.source = Track.Source.Unknown;
 
     if (isWeb()) {
@@ -10761,6 +11121,16 @@ class Track extends events.exports.EventEmitter {
   get mediaStreamTrack() {
     return this._mediaStreamTrack;
   }
+  /**
+   * @internal
+   * used for keep mediaStream's first id, since it's id might change
+   * if we disable/enable a track
+   */
+
+
+  get mediaStreamID() {
+    return this._mediaStreamID;
+  }
 
   attach(element) {
     let elementType = 'audio';
@@ -11087,6 +11457,7 @@ class LocalTrack extends Track {
     this.reacquireTrack = false;
     this.wasMuted = false;
     this.providedByUser = userProvidedTrack;
+    this.muteQueue = new Queue();
   }
 
   get id() {
@@ -11167,7 +11538,9 @@ class LocalTrack extends Track {
     // 'A MediaStreamTrack ended due to a capture failure`
 
 
-    this._mediaStreamTrack.stop();
+    if (!this.providedByUser) {
+      this._mediaStreamTrack.stop();
+    }
 
     track.addEventListener('ended', this.handleEnded);
     livekitLogger.debug('replace MediaStreamTrack');
@@ -11235,6 +11608,8 @@ class LocalTrack extends Track {
   }
 
   setTrackMuted(muted) {
+    livekitLogger.debug("setting ".concat(this.kind, " track ").concat(muted ? 'muted' : 'unmuted'));
+
     if (this.isMuted === muted) {
       return;
     }
@@ -11268,34 +11643,38 @@ class LocalTrack extends Track {
   }
 
   async pauseUpstream() {
-    if (this._isUpstreamPaused === true) {
-      return;
-    }
+    this.muteQueue.run(async () => {
+      if (this._isUpstreamPaused === true) {
+        return;
+      }
 
-    if (!this.sender) {
-      livekitLogger.warn('unable to pause upstream for an unpublished track');
-      return;
-    }
+      if (!this.sender) {
+        livekitLogger.warn('unable to pause upstream for an unpublished track');
+        return;
+      }
 
-    this._isUpstreamPaused = true;
-    this.emit(TrackEvent.UpstreamPaused, this);
-    const emptyTrack = this.kind === Track.Kind.Audio ? getEmptyAudioStreamTrack() : getEmptyVideoStreamTrack();
-    await this.sender.replaceTrack(emptyTrack);
+      this._isUpstreamPaused = true;
+      this.emit(TrackEvent.UpstreamPaused, this);
+      const emptyTrack = this.kind === Track.Kind.Audio ? getEmptyAudioStreamTrack() : getEmptyVideoStreamTrack();
+      await this.sender.replaceTrack(emptyTrack);
+    });
   }
 
   async resumeUpstream() {
-    if (this._isUpstreamPaused === false) {
-      return;
-    }
+    this.muteQueue.run(async () => {
+      if (this._isUpstreamPaused === false) {
+        return;
+      }
 
-    if (!this.sender) {
-      livekitLogger.warn('unable to resume upstream for an unpublished track');
-      return;
-    }
+      if (!this.sender) {
+        livekitLogger.warn('unable to resume upstream for an unpublished track');
+        return;
+      }
 
-    this._isUpstreamPaused = false;
-    this.emit(TrackEvent.UpstreamResumed, this);
-    await this.sender.replaceTrack(this._mediaStreamTrack);
+      this._isUpstreamPaused = false;
+      this.emit(TrackEvent.UpstreamResumed, this);
+      await this.sender.replaceTrack(this._mediaStreamTrack);
+    });
   }
 
 }
@@ -11453,24 +11832,28 @@ class LocalAudioTrack extends LocalTrack {
   }
 
   async mute() {
-    // disabled special handling as it will cause BT headsets to switch communication modes
-    if (this.source === Track.Source.Microphone && this.stopOnMute) {
-      livekitLogger.debug('stopping mic track'); // also stop the track, so that microphone indicator is turned off
+    await this.muteQueue.run(async () => {
+      // disabled special handling as it will cause BT headsets to switch communication modes
+      if (this.source === Track.Source.Microphone && this.stopOnMute && !this.isUserProvided) {
+        livekitLogger.debug('stopping mic track'); // also stop the track, so that microphone indicator is turned off
 
-      this._mediaStreamTrack.stop();
-    }
+        this._mediaStreamTrack.stop();
+      }
 
-    await super.mute();
+      await super.mute();
+    });
     return this;
   }
 
   async unmute() {
-    if (this.source === Track.Source.Microphone && this.stopOnMute && !this.isUserProvided) {
-      livekitLogger.debug('reacquiring mic track');
-      await this.restartTrack();
-    }
+    await this.muteQueue.run(async () => {
+      if (this.source === Track.Source.Microphone && this.stopOnMute && !this.isUserProvided) {
+        livekitLogger.debug('reacquiring mic track');
+        await this.restartTrack();
+      }
 
-    await super.unmute();
+      await super.unmute();
+    });
     return this;
   }
 
@@ -11636,23 +12019,27 @@ class LocalVideoTrack extends LocalTrack {
   }
 
   async mute() {
-    if (this.source === Track.Source.Camera) {
-      livekitLogger.debug('stopping camera track'); // also stop the track, so that camera indicator is turned off
+    await this.muteQueue.run(async () => {
+      if (this.source === Track.Source.Camera && !this.isUserProvided) {
+        livekitLogger.debug('stopping camera track'); // also stop the track, so that camera indicator is turned off
 
-      this._mediaStreamTrack.stop();
-    }
+        this._mediaStreamTrack.stop();
+      }
 
-    await super.mute();
+      await super.mute();
+    });
     return this;
   }
 
   async unmute() {
-    if (this.source === Track.Source.Camera && !this.isUserProvided) {
-      livekitLogger.debug('reacquiring camera track');
-      await this.restartTrack();
-    }
+    await this.muteQueue.run(async () => {
+      if (this.source === Track.Source.Camera && !this.isUserProvided) {
+        livekitLogger.debug('reacquiring camera track');
+        await this.restartTrack();
+      }
 
-    await super.unmute();
+      await super.unmute();
+    });
     return this;
   }
 
@@ -11969,6 +12356,7 @@ class RemoteTrack extends Track {
   setMuted(muted) {
     if (this.isMuted !== muted) {
       this.isMuted = muted;
+      this._mediaStreamTrack.enabled = !muted;
       this.emit(muted ? TrackEvent.Muted : TrackEvent.Unmuted, this);
     }
   }
@@ -12553,6 +12941,9 @@ class TrackPublication extends events.exports.EventEmitter {
     }
 
     this.trackInfo = info;
+    livekitLogger.trace('update publication info', {
+      info
+    });
   }
 
 }
@@ -12875,6 +13266,9 @@ class Participant extends events.exports.EventEmitter {
 
 
     this.participantInfo = info;
+    livekitLogger.trace('update participant info', {
+      info
+    });
   }
   /** @internal */
 
@@ -13619,6 +14013,10 @@ class RemoteParticipant extends Participant {
 
     this.tracks.forEach(publication => {
       if (!validTracks.has(publication.trackSid)) {
+        livekitLogger.trace('detected removed track on remote participant, unpublishing', {
+          publication,
+          participantSid: this.sid
+        });
         this.unpublishTrack(publication.trackSid, true);
       }
     });
@@ -14500,6 +14898,32 @@ class LocalParticipant extends Participant {
       this.updateTrackSubscriptionPermissions();
     }
   }
+  /** @internal */
+
+
+  updateInfo(info) {
+    super.updateInfo(info); // reconcile track mute status.
+    // if server's track mute status doesn't match actual, we'll have to update
+    // the server's copy
+
+    info.tracks.forEach(ti => {
+      var _a, _b;
+
+      const pub = this.tracks.get(ti.sid);
+
+      if (pub) {
+        const mutedOnServer = pub.isMuted || ((_b = (_a = pub.track) === null || _a === void 0 ? void 0 : _a.isUpstreamPaused) !== null && _b !== void 0 ? _b : false);
+
+        if (mutedOnServer !== ti.muted) {
+          livekitLogger.debug('updating server mute state after reconcile', {
+            sid: ti.sid,
+            muted: mutedOnServer
+          });
+          this.engine.client.sendMuteTrack(ti.sid, mutedOnServer);
+        }
+      }
+    });
+  }
 
   getPublicationForTrack(track) {
     let publication;
@@ -14577,7 +15001,7 @@ class LocalParticipant extends Participant {
     this.tracks.forEach(track => {
       if (track.track !== undefined) {
         infos.push({
-          cid: track.track.mediaStreamTrack.id,
+          cid: track.track.mediaStreamID,
           track: track.trackInfo
         });
       }
@@ -18094,57 +18518,6 @@ adapterFactory({
   window: typeof window === 'undefined' ? undefined : window
 });
 
-class Queue {
-  constructor() {
-    this.queue = [];
-    this.running = false;
-  }
-
-  enqueue(cb) {
-    livekitLogger.trace('enqueuing request to fire later');
-    this.queue.push(cb);
-  }
-
-  dequeue() {
-    const evt = this.queue.shift();
-    if (evt) evt();
-    livekitLogger.trace('firing request from queue');
-  }
-
-  async run() {
-    if (this.running) return;
-    livekitLogger.trace('start queue');
-    this.running = true;
-
-    while (this.running && this.queue.length > 0) {
-      this.dequeue();
-    }
-
-    this.running = false;
-    livekitLogger.trace('queue finished');
-  }
-
-  pause() {
-    livekitLogger.trace('pausing queue');
-    this.running = false;
-  }
-
-  reset() {
-    livekitLogger.trace('resetting queue');
-    this.running = false;
-    this.queue = [];
-  }
-
-  isRunning() {
-    return this.running;
-  }
-
-  isEmpty() {
-    return this.queue.length === 0;
-  }
-
-}
-
 const passThroughQueueSignals = ['syncState', 'trickle', 'offer', 'answer', 'simulate', 'leave'];
 
 function canPassThroughQueue(req) {
@@ -18165,6 +18538,7 @@ class SignalClient {
     this.isReconnecting = false;
     this.useJSON = useJSON;
     this.requestQueue = new Queue();
+    this.queuedRequests = [];
   }
 
   async join(url, token, opts, abortSignal) {
@@ -18392,14 +18766,20 @@ class SignalClient {
 
   async sendRequest(req) {
     let fromQueue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    // capture all requests while reconnecting and put them in a queue.
-    // keep order by queueing up new events as long as the queue is not empty
+    // capture all requests while reconnecting and put them in a queue
     // unless the request originates from the queue, then don't enqueue again
     const canQueue = !fromQueue && !canPassThroughQueue(req);
 
-    if (canQueue && (this.isReconnecting || !this.requestQueue.isEmpty())) {
-      this.requestQueue.enqueue(() => this.sendRequest(req, true));
+    if (canQueue && this.isReconnecting) {
+      this.queuedRequests.push(async () => {
+        await this.sendRequest(req, true);
+      });
       return;
+    } // make sure previously queued requests are being sent first
+
+
+    if (!fromQueue) {
+      await this.requestQueue.flush();
     }
 
     if (this.signalLatency) {
@@ -18497,8 +18877,15 @@ class SignalClient {
   }
 
   setReconnected() {
+    while (this.queuedRequests.length > 0) {
+      const req = this.queuedRequests.shift();
+
+      if (req) {
+        this.requestQueue.run(req);
+      }
+    }
+
     this.isReconnecting = false;
-    this.requestQueue.run();
   }
 
   handleWSError(ev) {
@@ -19126,9 +19513,13 @@ class RTCEngine extends events.exports.EventEmitter {
         this.fullReconnectOnNext = true;
         this.primaryPC = undefined;
       } else {
-        this.emit(EngineEvent.Disconnected);
+        this.emit(EngineEvent.Disconnected, leave === null || leave === void 0 ? void 0 : leave.reason);
         this.close();
       }
+
+      livekitLogger.trace('leave request', {
+        leave
+      });
     };
   }
 
@@ -19511,7 +19902,14 @@ class Room extends events.exports.EventEmitter {
         }); // populate remote participants, these should not trigger new events
 
         joinResponse.otherParticipants.forEach(info => {
-          this.getOrCreateParticipant(info.sid, info);
+          if (info.sid !== this.localParticipant.sid && info.identity !== this.localParticipant.identity) {
+            this.getOrCreateParticipant(info.sid, info);
+          } else {
+            livekitLogger.warn('received info to create local participant as remote participant', {
+              info,
+              localParticipant: this.localParticipant
+            });
+          }
         });
         this.name = joinResponse.room.name;
         this.sid = joinResponse.room.sid;
@@ -19867,8 +20265,8 @@ class Room extends events.exports.EventEmitter {
     this.engine.client.onConnectionQuality = this.handleConnectionQualityUpdate;
     this.engine.on(EngineEvent.MediaTrackAdded, (mediaTrack, stream, receiver) => {
       this.onTrackAdded(mediaTrack, stream, receiver);
-    }).on(EngineEvent.Disconnected, () => {
-      this.handleDisconnect();
+    }).on(EngineEvent.Disconnected, reason => {
+      this.handleDisconnect(this.options.stopLocalTrackOnUnpublish, reason);
     }).on(EngineEvent.ActiveSpeakersUpdate, this.handleActiveSpeakersUpdate).on(EngineEvent.DataPacketReceived, this.handleDataPacket).on(EngineEvent.Resuming, () => {
       if (this.setAndEmitConnectionState(ConnectionState.Reconnecting)) {
         this.emit(RoomEvent.Reconnecting);
@@ -19930,6 +20328,15 @@ class Room extends events.exports.EventEmitter {
     let req;
 
     switch (scenario) {
+      case 'signal-reconnect':
+        this.engine.client.close();
+
+        if (this.engine.client.onClose) {
+          this.engine.client.onClose('simulate disconnect');
+        }
+
+        break;
+
       case 'speaker':
         req = SimulateScenario.fromPartial({
           speakerUpdate: 3
@@ -20079,21 +20486,28 @@ class Room extends events.exports.EventEmitter {
     // at that time, ICE connectivity has not been established so the track is not
     // technically subscribed.
     // We'll defer these events until when the room is connected or eventually disconnected.
-    if (this.state === ConnectionState.Connecting || this.state === ConnectionState.Reconnecting) {
-      setTimeout(() => {
+    if (this.connectFuture) {
+      this.connectFuture.promise.then(() => {
         this.onTrackAdded(mediaTrack, stream, receiver);
-      }, 50);
+      });
       return;
     }
 
     if (this.state === ConnectionState.Disconnected) {
       livekitLogger.warn('skipping incoming track after Room disconnected');
+      return;
     }
 
     const parts = unpackStreamId(stream.id);
     const participantId = parts[0];
     let trackId = parts[1];
     if (!trackId || trackId === '') trackId = mediaTrack.id;
+
+    if (participantId === this.localParticipant.sid) {
+      livekitLogger.warn('tried to create RemoteParticipant for local participant');
+      return;
+    }
+
     const participant = this.getOrCreateParticipant(participantId);
     let adaptiveStreamSettings;
 
@@ -20110,6 +20524,7 @@ class Room extends events.exports.EventEmitter {
 
   handleDisconnect() {
     let shouldStopTracks = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+    let reason = arguments.length > 1 ? arguments[1] : undefined;
 
     var _a;
 
@@ -20144,7 +20559,7 @@ class Room extends events.exports.EventEmitter {
     }
 
     this.setAndEmitConnectionState(ConnectionState.Disconnected);
-    this.emit(RoomEvent.Disconnected);
+    this.emit(RoomEvent.Disconnected, reason);
   }
 
   handleParticipantDisconnected(sid, participant) {
@@ -20470,5 +20885,5 @@ async function createLocalScreenTracks(options) {
   return localTracks;
 }
 
-export { AudioPresets, ConnectionError, ConnectionQuality, ConnectionState, DataPacket_Kind, 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, protocolVersion, setLogExtension, setLogLevel, version };
+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 };
 //# sourceMappingURL=livekit-client.esm.mjs.map