livekit-client 1.1.7 → 1.2.0

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;
   }
 
@@ -10002,6 +10189,8 @@ var TrackEvent;
   TrackEvent["Muted"] = "muted";
   TrackEvent["Unmuted"] = "unmuted";
   TrackEvent["Ended"] = "ended";
+  TrackEvent["Subscribed"] = "subscribed";
+  TrackEvent["Unsubscribed"] = "unsubscribed";
   /** @internal */
 
   TrackEvent["UpdateSettings"] = "updateSettings";
@@ -10044,6 +10233,12 @@ var TrackEvent;
    */
 
   TrackEvent["UpstreamResumed"] = "upstreamResumed";
+  /**
+   * @internal
+   * Fires on RemoteTrackPublication
+   */
+
+  TrackEvent["SubscriptionPermissionChanged"] = "subscriptionPermissionChanged";
 })(TrackEvent || (TrackEvent = {}));
 
 const monitorFrequency = 2000;
@@ -10070,7 +10265,7 @@ function computeBitrate(currentStats, prevStats) {
   return (bytesNow - bytesPrev) * 8 * 1000 / (currentStats.timestamp - prevStats.timestamp);
 }
 
-var version$1 = "1.1.7";
+var version$1 = "1.2.0";
 
 const version = version$1;
 const protocolVersion = 8;
@@ -10190,6 +10385,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 +11109,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 +11129,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 +11465,7 @@ class LocalTrack extends Track {
     this.reacquireTrack = false;
     this.wasMuted = false;
     this.providedByUser = userProvidedTrack;
+    this.muteQueue = new Queue();
   }
 
   get id() {
@@ -11167,7 +11546,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');
@@ -11177,6 +11558,7 @@ class LocalTrack extends Track {
     }
 
     this._mediaStreamTrack = track;
+    await this.resumeUpstream();
     this.attachedElements.forEach(el => {
       attachToElement(track, el);
     });
@@ -11226,6 +11608,7 @@ class LocalTrack extends Track {
     }
 
     this._mediaStreamTrack = newTrack;
+    await this.resumeUpstream();
     this.attachedElements.forEach(el => {
       attachToElement(newTrack, el);
     });
@@ -11235,6 +11618,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 +11653,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 +11842,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 +12029,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 +12366,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 +12951,9 @@ class TrackPublication extends events.exports.EventEmitter {
     }
 
     this.trackInfo = info;
+    livekitLogger.trace('update publication info', {
+      info
+    });
   }
 
 }
@@ -12875,6 +13276,9 @@ class Participant extends events.exports.EventEmitter {
 
 
     this.participantInfo = info;
+    livekitLogger.trace('update participant info', {
+      info
+    });
   }
   /** @internal */
 
@@ -13218,7 +13622,7 @@ class RemoteTrackPublication extends TrackPublication {
     super(...arguments);
     /** @internal */
 
-    this._allowed = true;
+    this.allowed = true;
     this.disabled = false;
     this.currentVideoQuality = VideoQuality.HIGH;
 
@@ -13250,7 +13654,10 @@ class RemoteTrackPublication extends TrackPublication {
 
 
   setSubscribed(subscribed) {
-    this.subscribed = subscribed;
+    this.subscribed = subscribed; // reset allowed status when desired subscription state changes
+    // server will notify client via signal message if it's not allowed
+
+    this.allowed = true;
     const sub = {
       trackSids: [this.trackSid],
       subscribe: this.subscribed,
@@ -13266,11 +13673,11 @@ class RemoteTrackPublication extends TrackPublication {
 
   get subscriptionStatus() {
     if (this.subscribed === false || !super.isSubscribed) {
-      return TrackPublication.SubscriptionStatus.Unsubscribed;
-    }
+      if (!this.allowed) {
+        return TrackPublication.SubscriptionStatus.NotAllowed;
+      }
 
-    if (!this._allowed) {
-      return TrackPublication.SubscriptionStatus.NotAllowed;
+      return TrackPublication.SubscriptionStatus.Unsubscribed;
     }
 
     return TrackPublication.SubscriptionStatus.Subscribed;
@@ -13285,10 +13692,6 @@ class RemoteTrackPublication extends TrackPublication {
       return false;
     }
 
-    if (!this._allowed) {
-      return false;
-    }
-
     return super.isSubscribed;
   }
 
@@ -13356,11 +13759,14 @@ class RemoteTrackPublication extends TrackPublication {
 
 
   setTrack(track) {
-    if (this.track) {
+    const prevStatus = this.subscriptionStatus;
+    const prevTrack = this.track;
+
+    if (prevTrack) {
       // unregister listener
-      this.track.off(TrackEvent.VideoDimensionsChanged, this.handleVideoDimensionsChange);
-      this.track.off(TrackEvent.VisibilityChanged, this.handleVisibilityChange);
-      this.track.off(TrackEvent.Ended, this.handleEnded);
+      prevTrack.off(TrackEvent.VideoDimensionsChanged, this.handleVideoDimensionsChange);
+      prevTrack.off(TrackEvent.VisibilityChanged, this.handleVisibilityChange);
+      prevTrack.off(TrackEvent.Ended, this.handleEnded);
     }
 
     super.setTrack(track);
@@ -13371,6 +13777,25 @@ class RemoteTrackPublication extends TrackPublication {
       track.on(TrackEvent.VisibilityChanged, this.handleVisibilityChange);
       track.on(TrackEvent.Ended, this.handleEnded);
     }
+
+    this.emitSubscriptionUpdateIfChanged(prevStatus);
+
+    if (!!track !== !!prevTrack) {
+      // when undefined status changes, there's a subscription changed event
+      if (track) {
+        this.emit(TrackEvent.Subscribed, track);
+      } else {
+        this.emit(TrackEvent.Unsubscribed, prevTrack);
+      }
+    }
+  }
+  /** @internal */
+
+
+  setAllowed(allowed) {
+    const prevStatus = this.subscriptionStatus;
+    this.allowed = allowed;
+    this.emitSubscriptionUpdateIfChanged(prevStatus);
   }
   /** @internal */
 
@@ -13383,6 +13808,16 @@ class RemoteTrackPublication extends TrackPublication {
     (_a = this.track) === null || _a === void 0 ? void 0 : _a.setMuted(info.muted);
   }
 
+  emitSubscriptionUpdateIfChanged(previousStatus) {
+    const currentStatus = this.subscriptionStatus;
+
+    if (previousStatus === currentStatus) {
+      return;
+    }
+
+    this.emit(TrackEvent.SubscriptionPermissionChanged, currentStatus, previousStatus);
+  }
+
   isManualOperationAllowed() {
     if (this.isAdaptiveStream) {
       livekitLogger.warn('adaptive stream is enabled, cannot change track settings', {
@@ -13457,8 +13892,14 @@ class RemoteParticipant extends Participant {
       });
       this.signalClient.sendUpdateSubscription(sub);
     });
-    publication.on(TrackEvent.Ended, track => {
-      this.emit(ParticipantEvent.TrackUnsubscribed, track, publication);
+    publication.on(TrackEvent.SubscriptionPermissionChanged, status => {
+      this.emit(ParticipantEvent.TrackSubscriptionPermissionChanged, publication, status);
+    });
+    publication.on(TrackEvent.Subscribed, track => {
+      this.emit(ParticipantEvent.TrackSubscribed, track, publication);
+    });
+    publication.on(TrackEvent.Unsubscribed, previousTrack => {
+      this.emit(ParticipantEvent.TrackUnsubscribed, previousTrack, publication);
     });
   }
 
@@ -13559,15 +14000,12 @@ class RemoteParticipant extends Participant {
     track.isMuted = publication.isMuted;
     track.setMediaStream(mediaStream);
     track.start();
-    publication.setTrack(track); // subscription means participant has permissions to subscribe
-
-    publication._allowed = true; // set participant volume on new microphone tracks
+    publication.setTrack(track); // set participant volume on new microphone tracks
 
     if (this.volume !== undefined && track instanceof RemoteAudioTrack && track.source === Track.Source.Microphone) {
       track.setVolume(this.volume);
     }
 
-    this.emit(ParticipantEvent.TrackSubscribed, track, publication);
     return publication;
   }
   /** @internal */
@@ -13619,6 +14057,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);
       }
     });
@@ -13651,15 +14093,8 @@ class RemoteParticipant extends Participant {
     } = publication;
 
     if (track) {
-      const {
-        isSubscribed
-      } = publication;
       track.stop();
-      publication.setTrack(undefined); // always send unsubscribed, since apps may rely on this
-
-      if (isSubscribed) {
-        this.emit(ParticipantEvent.TrackUnsubscribed, track, publication);
-      }
+      publication.setTrack(undefined);
     }
 
     if (sendUnpublish) {
@@ -13780,11 +14215,47 @@ class LocalParticipant extends Participant {
       this.unpublishTrack(track.track);
     };
 
-    this.handleTrackEnded = track => {
-      livekitLogger.debug('unpublishing local track due to TrackEnded', {
-        track: track.sid
-      });
-      this.unpublishTrack(track);
+    this.handleTrackEnded = async track => {
+      if (track.source === Track.Source.ScreenShare || track.source === Track.Source.ScreenShareAudio) {
+        livekitLogger.debug('unpublishing local track due to TrackEnded', {
+          track: track.sid
+        });
+        this.unpublishTrack(track);
+      } else if (track.isUserProvided) {
+        await track.pauseUpstream();
+      } else if (track instanceof LocalAudioTrack || track instanceof LocalVideoTrack) {
+        try {
+          if (isWeb()) {
+            try {
+              const currentPermissions = await (navigator === null || navigator === void 0 ? void 0 : navigator.permissions.query({
+                // the permission query for camera and microphone currently not supported in Safari and Firefox
+                // @ts-ignore
+                name: track.source === Track.Source.Camera ? 'camera' : 'microphone'
+              }));
+
+              if (currentPermissions && currentPermissions.state === 'denied') {
+                livekitLogger.warn("user has revoked access to ".concat(track.source)); // detect granted change after permissions were denied to try and resume then
+
+                currentPermissions.onchange = () => {
+                  if (currentPermissions.state !== 'denied') {
+                    track.restartTrack();
+                    currentPermissions.onchange = null;
+                  }
+                };
+
+                throw new Error('GetUserMedia Permission denied');
+              }
+            } catch (e) {// permissions query fails for firefox, we continue and try to restart the track
+            }
+          }
+
+          livekitLogger.debug('track ended, attempting to use a different device');
+          await track.restartTrack();
+        } catch (e) {
+          livekitLogger.warn("could not restart track, pausing upstream instead");
+          await track.pauseUpstream();
+        }
+      }
     };
 
     this.audioTracks = new Map();
@@ -14603,7 +15074,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
         });
       }
@@ -18120,57 +18591,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) {
@@ -18191,6 +18611,7 @@ class SignalClient {
     this.isReconnecting = false;
     this.useJSON = useJSON;
     this.requestQueue = new Queue();
+    this.queuedRequests = [];
   }
 
   async join(url, token, opts, abortSignal) {
@@ -18418,14 +18839,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) {
@@ -18523,8 +18950,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) {
@@ -19061,23 +19495,9 @@ class RTCEngine extends events.exports.EventEmitter {
         const track = ev.stream.getTracks()[0];
         this.emit(EngineEvent.MediaTrackAdded, track, ev.stream);
       };
-    } // data channels
-
-
-    this.lossyDC = this.publisher.pc.createDataChannel(lossyDataChannel, {
-      // will drop older packets that arrive
-      ordered: true,
-      maxRetransmits: 0
-    });
-    this.reliableDC = this.publisher.pc.createDataChannel(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; // configure signaling client
+    this.createDataChannels(); // configure signaling client
 
     this.client.onAnswer = async sd => {
       if (!this.publisher) {
@@ -19152,12 +19572,49 @@ 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
+      });
     };
   }
 
+  createDataChannels() {
+    if (!this.publisher) {
+      return;
+    } // 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.publisher.pc.createDataChannel(lossyDataChannel, {
+      // will drop older packets that arrive
+      ordered: true,
+      maxRetransmits: 0
+    });
+    this.reliableDC = this.publisher.pc.createDataChannel(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;
+  }
+
   async restartConnection() {
     var _a, _b;
 
@@ -19197,6 +19654,8 @@ class RTCEngine extends events.exports.EventEmitter {
   }
 
   async resumeConnection() {
+    var _a;
+
     if (!this.url || !this.token) {
       // permanent failure, don't attempt reconnection
       throw new UnexpectedConnectionState('could not reconnect, url or token not saved');
@@ -19229,7 +19688,13 @@ class RTCEngine extends events.exports.EventEmitter {
     }
 
     await this.waitForPCConnected();
-    this.client.setReconnected(); // resume success
+    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);
   }
@@ -19537,7 +20002,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;
@@ -19592,11 +20064,15 @@ class Room extends events.exports.EventEmitter {
      */
 
 
-    this.disconnect = function () {
+    this.disconnect = async function () {
       let stopTracks = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
 
       var _a, _b;
 
+      livekitLogger.info('disconnect from room', {
+        identity: _this.localParticipant.identity
+      });
+
       if (_this.state === ConnectionState.Connecting) {
         // try aborting pending connection attempt
         livekitLogger.warn('abort connection attempt');
@@ -19606,7 +20082,7 @@ class Room extends events.exports.EventEmitter {
 
 
       if ((_b = _this.engine) === null || _b === void 0 ? void 0 : _b.client.isConnected) {
-        _this.engine.client.sendLeave();
+        await _this.engine.client.sendLeave();
       } // close engine (also closes client)
 
 
@@ -19614,7 +20090,7 @@ class Room extends events.exports.EventEmitter {
         _this.engine.close();
       }
 
-      _this.handleDisconnect(stopTracks);
+      _this.handleDisconnect(stopTracks, DisconnectReason.CLIENT_INITIATED);
       /* @ts-ignore */
 
 
@@ -19811,9 +20287,7 @@ class Room extends events.exports.EventEmitter {
         return;
       }
 
-      pub._allowed = update.allowed;
-      participant.emit(ParticipantEvent.TrackSubscriptionPermissionChanged, pub, pub.subscriptionStatus);
-      this.emitWhenConnected(RoomEvent.TrackSubscriptionPermissionChanged, pub, pub.subscriptionStatus, participant);
+      pub.setAllowed(update.allowed);
     };
 
     this.handleDataPacket = (userPacket, kind) => {
@@ -19893,8 +20367,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);
@@ -20114,21 +20588,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;
 
@@ -20145,9 +20626,14 @@ 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;
 
+    if (this.state === ConnectionState.Disconnected) {
+      return;
+    }
+
     this.participants.forEach(p => {
       p.tracks.forEach(pub => {
         p.unpublishTrack(pub.trackSid);
@@ -20165,6 +20651,9 @@ class Room extends events.exports.EventEmitter {
         (_b = pub.track) === null || _b === void 0 ? void 0 : _b.stop();
       }
     });
+    this.localParticipant.tracks.clear();
+    this.localParticipant.videoTracks.clear();
+    this.localParticipant.audioTracks.clear();
     this.participants.clear();
     this.activeSpeakers = [];
 
@@ -20179,7 +20668,7 @@ class Room extends events.exports.EventEmitter {
     }
 
     this.setAndEmitConnectionState(ConnectionState.Disconnected);
-    this.emit(RoomEvent.Disconnected);
+    this.emit(RoomEvent.Disconnected, reason);
   }
 
   handleParticipantDisconnected(sid, participant) {
@@ -20266,6 +20755,8 @@ class Room extends events.exports.EventEmitter {
       this.emitWhenConnected(RoomEvent.ConnectionQualityChanged, quality, participant);
     }).on(ParticipantEvent.ParticipantPermissionsChanged, prevPermissions => {
       this.emitWhenConnected(RoomEvent.ParticipantPermissionsChanged, prevPermissions, participant);
+    }).on(ParticipantEvent.TrackSubscriptionPermissionChanged, (pub, status) => {
+      this.emitWhenConnected(RoomEvent.TrackSubscriptionPermissionChanged, pub, status, participant);
     }); // update info at the end after callbacks have been set up
 
     if (info) {
@@ -20505,5 +20996,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