livekit-client 1.6.0 → 1.6.1

package/dist/livekit-client.esm.mjs

@@ -19,7 +19,11 @@ function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
-var loglevel = {exports: {}};
+var loglevelExports = {};
+var loglevel = {
+  get exports(){ return loglevelExports; },
+  set exports(v){ loglevelExports = v; },
+};
 
 /*
 * loglevel - https://github.com/pimterry/loglevel
@@ -294,7 +298,7 @@ var LogLevel;
   LogLevel[LogLevel["error"] = 4] = "error";
   LogLevel[LogLevel["silent"] = 5] = "silent";
 })(LogLevel || (LogLevel = {}));
-const livekitLogger = loglevel.exports.getLogger('livekit');
+const livekitLogger = loglevelExports.getLogger('livekit');
 livekitLogger.setLevel(LogLevel.info);
 function setLogLevel(level) {
   livekitLogger.setLevel(level);
@@ -1501,7 +1505,11 @@ Long.fromBytesBE = function fromBytesBE(bytes, unsigned) {
   return new Long(bytes[4] << 24 | bytes[5] << 16 | bytes[6] << 8 | bytes[7], bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3], unsigned);
 };
 
-var minimal$1 = {exports: {}};
+var minimalExports = {};
+var minimal$1 = {
+  get exports(){ return minimalExports; },
+  set exports(v){ minimalExports = v; },
+};
 
 var indexMinimal = {};
 
@@ -3986,7 +3994,7 @@ var roots = {};
 
   module.exports = indexMinimal;
 })(minimal$1);
-var _m0 = /*@__PURE__*/getDefaultExportFromCjs(minimal$1.exports);
+var _m0 = /*@__PURE__*/getDefaultExportFromCjs(minimalExports);
 
 /* eslint-disable */
 var globalThis$3 = (() => {
@@ -7228,17 +7236,17 @@ function fixNegotiationNeeded(window, browserDetails) {
 
 var chromeShim = /*#__PURE__*/Object.freeze({
 	__proto__: null,
-	shimMediaStream: shimMediaStream,
-	shimOnTrack: shimOnTrack$1,
+	fixNegotiationNeeded: fixNegotiationNeeded,
+	shimAddTrackRemoveTrack: shimAddTrackRemoveTrack,
+	shimAddTrackRemoveTrackWithNative: shimAddTrackRemoveTrackWithNative,
+	shimGetDisplayMedia: shimGetDisplayMedia$1,
 	shimGetSendersWithDtmf: shimGetSendersWithDtmf,
 	shimGetStats: shimGetStats,
-	shimSenderReceiverGetStats: shimSenderReceiverGetStats,
-	shimAddTrackRemoveTrackWithNative: shimAddTrackRemoveTrackWithNative,
-	shimAddTrackRemoveTrack: shimAddTrackRemoveTrack,
-	shimPeerConnection: shimPeerConnection$1,
-	fixNegotiationNeeded: fixNegotiationNeeded,
 	shimGetUserMedia: shimGetUserMedia$2,
-	shimGetDisplayMedia: shimGetDisplayMedia$1
+	shimMediaStream: shimMediaStream,
+	shimOnTrack: shimOnTrack$1,
+	shimPeerConnection: shimPeerConnection$1,
+	shimSenderReceiverGetStats: shimSenderReceiverGetStats
 });
 
 /*
@@ -7592,18 +7600,18 @@ function shimCreateAnswer(window) {
 
 var firefoxShim = /*#__PURE__*/Object.freeze({
 	__proto__: null,
+	shimAddTransceiver: shimAddTransceiver,
+	shimCreateAnswer: shimCreateAnswer,
+	shimCreateOffer: shimCreateOffer,
+	shimGetDisplayMedia: shimGetDisplayMedia,
+	shimGetParameters: shimGetParameters,
+	shimGetUserMedia: shimGetUserMedia$1,
 	shimOnTrack: shimOnTrack,
 	shimPeerConnection: shimPeerConnection,
-	shimSenderGetStats: shimSenderGetStats,
+	shimRTCDataChannel: shimRTCDataChannel,
 	shimReceiverGetStats: shimReceiverGetStats,
 	shimRemoveStream: shimRemoveStream,
-	shimRTCDataChannel: shimRTCDataChannel,
-	shimAddTransceiver: shimAddTransceiver,
-	shimGetParameters: shimGetParameters,
-	shimCreateOffer: shimCreateOffer,
-	shimCreateAnswer: shimCreateAnswer,
-	shimGetUserMedia: shimGetUserMedia$1,
-	shimGetDisplayMedia: shimGetDisplayMedia
+	shimSenderGetStats: shimSenderGetStats
 });
 
 /*
@@ -7925,18 +7933,22 @@ function shimAudioContext(window) {
 
 var safariShim = /*#__PURE__*/Object.freeze({
 	__proto__: null,
-	shimLocalStreamsAPI: shimLocalStreamsAPI,
-	shimRemoteStreamsAPI: shimRemoteStreamsAPI,
+	shimAudioContext: shimAudioContext,
 	shimCallbacksAPI: shimCallbacksAPI,
-	shimGetUserMedia: shimGetUserMedia,
 	shimConstraints: shimConstraints,
-	shimRTCIceServerUrls: shimRTCIceServerUrls,
-	shimTrackEventTransceiver: shimTrackEventTransceiver,
 	shimCreateOfferLegacy: shimCreateOfferLegacy,
-	shimAudioContext: shimAudioContext
+	shimGetUserMedia: shimGetUserMedia,
+	shimLocalStreamsAPI: shimLocalStreamsAPI,
+	shimRTCIceServerUrls: shimRTCIceServerUrls,
+	shimRemoteStreamsAPI: shimRemoteStreamsAPI,
+	shimTrackEventTransceiver: shimTrackEventTransceiver
 });
 
-var sdp$1 = {exports: {}};
+var sdpExports = {};
+var sdp$1 = {
+  get exports(){ return sdpExports; },
+  set exports(v){ sdpExports = v; },
+};
 
 /* eslint-env node */
 (function (module) {
@@ -8668,12 +8680,12 @@ var sdp$1 = {exports: {}};
     module.exports = SDPUtils;
   }
 })(sdp$1);
-var SDPUtils = sdp$1.exports;
+var SDPUtils = sdpExports;
 
 var sdp = /*#__PURE__*/_mergeNamespaces({
 	__proto__: null,
 	default: SDPUtils
-}, [sdp$1.exports]);
+}, [sdpExports]);
 
 /*
  *  Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
@@ -9063,13 +9075,13 @@ function shimParameterlessSetLocalDescription(window, browserDetails) {
 
 var commonShim = /*#__PURE__*/Object.freeze({
 	__proto__: null,
-	shimRTCIceCandidate: shimRTCIceCandidate,
-	shimMaxMessageSize: shimMaxMessageSize,
-	shimSendThrowTypeError: shimSendThrowTypeError,
-	shimConnectionState: shimConnectionState,
 	removeExtmapAllowMixed: removeExtmapAllowMixed,
 	shimAddIceCandidateNullOrEmpty: shimAddIceCandidateNullOrEmpty,
-	shimParameterlessSetLocalDescription: shimParameterlessSetLocalDescription
+	shimConnectionState: shimConnectionState,
+	shimMaxMessageSize: shimMaxMessageSize,
+	shimParameterlessSetLocalDescription: shimParameterlessSetLocalDescription,
+	shimRTCIceCandidate: shimRTCIceCandidate,
+	shimSendThrowTypeError: shimSendThrowTypeError
 });
 
 /*
@@ -12558,6 +12570,7 @@ var EngineEvent;
   EngineEvent["Restarting"] = "restarting";
   EngineEvent["Restarted"] = "restarted";
   EngineEvent["SignalResumed"] = "signalResumed";
+  EngineEvent["Closing"] = "closing";
   EngineEvent["MediaTrackAdded"] = "mediaTrackAdded";
   EngineEvent["ActiveSpeakersUpdate"] = "activeSpeakersUpdate";
   EngineEvent["DataPacketReceived"] = "dataPacketReceived";
@@ -12636,7 +12649,11 @@ function computeBitrate(currentStats, prevStats) {
   return (bytesNow - bytesPrev) * 8 * 1000 / (currentStats.timestamp - prevStats.timestamp);
 }
 
-var uaParser = {exports: {}};
+var uaParserExports = {};
+var uaParser = {
+  get exports(){ return uaParserExports; },
+  set exports(v){ uaParserExports = v; },
+};
 
 (function (module, exports) {
   /////////////////////////////////////////////////////////////////////////////////
@@ -13316,10 +13333,10 @@ var uaParser = {exports: {}};
       };
     }
   })(typeof window === 'object' ? window : commonjsGlobal);
-})(uaParser, uaParser.exports);
-var UAParser = uaParser.exports;
+})(uaParser, uaParserExports);
+var UAParser = uaParserExports;
 
-var version$1 = "1.6.0";
+var version$1 = "1.6.1";
 
 const version = version$1;
 const protocolVersion = 8;
@@ -13906,7 +13923,11 @@ class DeviceManager {
 DeviceManager.mediaDeviceKinds = ['audioinput', 'audiooutput', 'videoinput'];
 DeviceManager.userMediaPromiseMap = new Map();
 
-var events = {exports: {}};
+var eventsExports = {};
+var events = {
+  get exports(){ return eventsExports; },
+  set exports(v){ eventsExports = v; },
+};
 
 var R = typeof Reflect === 'object' ? Reflect : null;
 var ReflectApply = R && typeof R.apply === 'function' ? R.apply : function ReflectApply(target, receiver, args) {
@@ -13934,7 +13955,7 @@ function EventEmitter() {
   EventEmitter.init.call(this);
 }
 events.exports = EventEmitter;
-events.exports.once = once;
+eventsExports.once = once;
 
 // Backwards-compat with node 0.10.x
 EventEmitter.EventEmitter = EventEmitter;
@@ -14290,7 +14311,7 @@ const BACKGROUND_REACTION_DELAY = 5000;
 // keep old audio elements when detached, we would re-use them since on iOS
 // Safari tracks which audio elements have been "blessed" by the user.
 const recycledElements = [];
-class Track extends events.exports.EventEmitter {
+class Track extends eventsExports.EventEmitter {
   constructor(mediaTrack, kind) {
     super();
     this.attachedElements = [];
@@ -14367,12 +14388,21 @@ class Track extends events.exports.EventEmitter {
     // the element's srcObject was set to something else out of band.
     // we'll want to re-attach it in that case
     attachToElement(this._mediaStreamTrack, element);
-    if (element instanceof HTMLAudioElement) {
+    // handle auto playback failures
+    const allMediaStreamTracks = element.srcObject.getTracks();
+    if (allMediaStreamTracks.some(tr => tr.kind === 'audio')) {
       // manually play audio to detect audio playback status
       element.play().then(() => {
         this.emit(TrackEvent.AudioPlaybackStarted);
       }).catch(e => {
         this.emit(TrackEvent.AudioPlaybackFailed, e);
+        // If audio playback isn't allowed make sure we still play back the video
+        if (element && allMediaStreamTracks.some(tr => tr.kind === 'video') && e.name === 'NotAllowedError') {
+          element.muted = true;
+          element.play().catch(() => {
+            // catch for Safari, exceeded options at this point to automatically play the media element
+          });
+        }
       });
     }
     this.emit(TrackEvent.ElementAttached, element);
@@ -14460,6 +14490,12 @@ function attachToElement(track, element) {
     });
     mediaStream.addTrack(track);
   }
+  element.autoplay = true;
+  // In case there are no audio tracks present on the mediastream, we set the element as muted to ensure autoplay works
+  element.muted = mediaStream.getAudioTracks().length === 0;
+  if (element instanceof HTMLVideoElement) {
+    element.playsInline = true;
+  }
   // avoid flicker
   if (element.srcObject !== mediaStream) {
     element.srcObject = mediaStream;
@@ -14481,10 +14517,6 @@ function attachToElement(track, element) {
       }, 0);
     }
   }
-  element.autoplay = true;
-  if (element instanceof HTMLVideoElement) {
-    element.playsInline = true;
-  }
 }
 /** @internal */
 function detachTrack(track, element) {
@@ -14589,6 +14621,7 @@ function detachTrack(track, element) {
   Track.streamStateFromProto = streamStateFromProto;
 })(Track || (Track = {}));
 
+const defaultDimensionsTimeout = 2 * 1000;
 class LocalTrack extends Track {
   /**
    *
@@ -14638,6 +14671,21 @@ class LocalTrack extends Track {
   get isUserProvided() {
     return this.providedByUser;
   }
+  async waitForDimensions() {
+    let timeout = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultDimensionsTimeout;
+    if (this.kind === Track.Kind.Audio) {
+      throw new Error('cannot get dimensions for audio tracks');
+    }
+    const started = Date.now();
+    while (Date.now() - started < timeout) {
+      const dims = this.dimensions;
+      if (dims) {
+        return dims;
+      }
+      await sleep(50);
+    }
+    throw new TrackInvalidError('unable to get track dimensions after timeout');
+  }
   /**
    * @returns DeviceID of the device that is currently being used for this track
    */
@@ -15818,7 +15866,7 @@ function isElementInViewport(el) {
   return top < window.pageYOffset + window.innerHeight && left < window.pageXOffset + window.innerWidth && top + height > window.pageYOffset && left + width > window.pageXOffset && !hidden && (opacity !== '' ? parseFloat(opacity) > 0 : true) && display !== 'none';
 }
 
-class TrackPublication extends events.exports.EventEmitter {
+class TrackPublication extends eventsExports.EventEmitter {
   constructor(kind, id, name) {
     super();
     this.metadataMuted = false;
@@ -16069,7 +16117,7 @@ function qualityFromProto(q) {
       return ConnectionQuality.Unknown;
   }
 }
-class Participant extends events.exports.EventEmitter {
+class Participant extends eventsExports.EventEmitter {
   /** @internal */
   constructor(sid, identity, name, metadata) {
     super();
@@ -16887,10 +16935,6 @@ class RemoteParticipant extends Participant {
       }
       validTracks.set(ti.sid, publication);
     });
-    // always emit events for new publications, Room will not forward them unless it's ready
-    newTracks.forEach(publication => {
-      this.emit(ParticipantEvent.TrackPublished, publication);
-    });
     // detect removed tracks
     this.tracks.forEach(publication => {
       if (!validTracks.has(publication.trackSid)) {
@@ -16901,6 +16945,10 @@ class RemoteParticipant extends Participant {
         this.unpublishTrack(publication.trackSid, true);
       }
     });
+    // always emit events for new publications, Room will not forward them unless it's ready
+    newTracks.forEach(publication => {
+      this.emit(ParticipantEvent.TrackPublished, publication);
+    });
   }
   /** @internal */
   unpublishTrack(sid, sendUnpublish) {
@@ -17243,7 +17291,7 @@ class LocalParticipant extends Participant {
     } else if (track && track.track) {
       // screenshare cannot be muted, unpublish instead
       if (source === Track.Source.ScreenShare) {
-        track = this.unpublishTrack(track.track);
+        track = await this.unpublishTrack(track.track);
         const screenAudioTrack = this.getTrack(Track.Source.ScreenShareAudio);
         if (screenAudioTrack && screenAudioTrack.track) {
           this.unpublishTrack(screenAudioTrack.track);
@@ -17384,7 +17432,7 @@ class LocalParticipant extends Participant {
    * @param options
    */
   async publishTrack(track, options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    var _a, _b, _c, _d, _e;
     // convert raw media track into audio or video track
     if (track instanceof MediaStreamTrack) {
       switch (track.kind) {
@@ -17475,18 +17523,24 @@ class LocalParticipant extends Participant {
     let encodings;
     let simEncodings;
     if (track.kind === Track.Kind.Video) {
-      // TODO: support react native, which doesn't expose getSettings
-      const settings = track.mediaStreamTrack.getSettings();
-      const width = (_d = settings.width) !== null && _d !== void 0 ? _d : (_e = track.dimensions) === null || _e === void 0 ? void 0 : _e.width;
-      const height = (_f = settings.height) !== null && _f !== void 0 ? _f : (_g = track.dimensions) === null || _g === void 0 ? void 0 : _g.height;
+      let dims = {
+        width: 0,
+        height: 0
+      };
+      try {
+        dims = await track.waitForDimensions();
+      } catch (e) {
+        // log failure
+        livekitLogger.error('could not determine track dimensions');
+      }
       // width and height should be defined for video
-      req.width = width !== null && width !== void 0 ? width : 0;
-      req.height = height !== null && height !== void 0 ? height : 0;
+      req.width = dims.width;
+      req.height = dims.height;
       // for svc codecs, disable simulcast and use vp8 for backup codec
       if (track instanceof LocalVideoTrack) {
         if ((opts === null || opts === void 0 ? void 0 : opts.videoCodec) === 'av1') {
           // set scalabilityMode to 'L3T3' by default
-          opts.scalabilityMode = (_h = opts.scalabilityMode) !== null && _h !== void 0 ? _h : 'L3T3';
+          opts.scalabilityMode = (_d = opts.scalabilityMode) !== null && _d !== void 0 ? _d : 'L3T3';
         }
         // set up backup
         if (opts.videoCodec && opts.backupCodec && opts.videoCodec !== opts.backupCodec.codec) {
@@ -17504,7 +17558,7 @@ class LocalParticipant extends Participant {
           }];
         }
       }
-      encodings = computeVideoEncodings(track.source === Track.Source.ScreenShare, width, height, opts);
+      encodings = computeVideoEncodings(track.source === Track.Source.ScreenShare, dims.width, dims.height, opts);
       req.layers = videoLayersFromEncodings(req.width, req.height, simEncodings !== null && simEncodings !== void 0 ? simEncodings : encodings);
     } else if (track.kind === Track.Kind.Audio && opts.audioBitrate) {
       encodings = [{
@@ -17528,7 +17582,7 @@ class LocalParticipant extends Participant {
     });
     // store RTPSender
     track.sender = await this.engine.createSender(track, opts, encodings);
-    if (track.codec === 'av1' && encodings && ((_j = encodings[0]) === null || _j === void 0 ? void 0 : _j.maxBitrate)) {
+    if (track.codec === 'av1' && encodings && ((_e = encodings[0]) === null || _e === void 0 ? void 0 : _e.maxBitrate)) {
       this.engine.publisher.setTrackCodecBitrate(req.cid, track.codec, encodings[0].maxBitrate / 1000);
     }
     this.engine.negotiate();
@@ -17597,7 +17651,7 @@ class LocalParticipant extends Participant {
       trackInfo: ti
     });
   }
-  unpublishTrack(track, stopOnUnpublish) {
+  async unpublishTrack(track, stopOnUnpublish) {
     var _a, _b;
     // look through all published tracks to find the right ones
     const publication = this.getPublicationForTrack(track);
@@ -17642,7 +17696,7 @@ class LocalParticipant extends Participant {
           method: 'unpublishTrack'
         });
       } finally {
-        this.engine.negotiate();
+        await this.engine.negotiate();
       }
     }
     track.sender = undefined;
@@ -17660,15 +17714,25 @@ class LocalParticipant extends Participant {
     publication.setTrack(undefined);
     return publication;
   }
-  unpublishTracks(tracks) {
-    const publications = [];
-    tracks.forEach(track => {
-      const pub = this.unpublishTrack(track);
-      if (pub) {
-        publications.push(pub);
+  async unpublishTracks(tracks) {
+    const results = await Promise.all(tracks.map(track => this.unpublishTrack(track)));
+    return results.filter(track => track instanceof LocalTrackPublication);
+  }
+  async republishAllTracks(options) {
+    const localPubs = [];
+    this.tracks.forEach(pub => {
+      if (pub.track) {
+        if (options) {
+          pub.options = _objectSpread2(_objectSpread2({}, pub.options), options);
+        }
+        localPubs.push(pub);
       }
     });
-    return publications;
+    await Promise.all(localPubs.map(async pub => {
+      const track = pub.track;
+      await this.unpublishTrack(track, false);
+      await this.publishTrack(track, pub.options);
+    }));
   }
   /**
    * Publish a new data payload to the room. Data will be forwarded to each
@@ -18334,7 +18398,11 @@ const roomConnectOptionDefaults = {
 
 var parser$1 = {};
 
-var grammar$2 = {exports: {}};
+var grammarExports = {};
+var grammar$2 = {
+  get exports(){ return grammarExports; },
+  set exports(v){ grammarExports = v; },
+};
 
 var grammar$1 = grammar$2.exports = {
   v: [{
@@ -18804,7 +18872,7 @@ Object.keys(grammar$1).forEach(function (key) {
       location[obj.push].push(keyLocation);
     }
   };
-  var grammar = grammar$2.exports;
+  var grammar = grammarExports;
   var validLine = RegExp.prototype.test.bind(/^([a-z])=(.*)/);
   exports.parse = function (sdp) {
     var session = {},
@@ -18888,7 +18956,7 @@ Object.keys(grammar$1).forEach(function (key) {
   };
 })(parser$1);
 
-var grammar = grammar$2.exports;
+var grammar = grammarExports;
 
 // customized util.format - discards excess arguments and can void middle ones
 var formatRegExp = /%[sdv%]/g;
@@ -19002,9 +19070,14 @@ parser.parseRemoteCandidates;
 parser.parseImageAttributes;
 parser.parseSimulcastStreamList;
 
+const PCEvents = {
+  NegotiationStarted: 'negotiationStarted',
+  NegotiationComplete: 'negotiationComplete'
+};
 /** @internal */
-class PCTransport {
+class PCTransport extends eventsExports {
   constructor(config) {
+    super();
     this.pendingCandidates = [];
     this.restartingIce = false;
     this.renegotiate = false;
@@ -19012,6 +19085,7 @@ class PCTransport {
     this.remoteStereoMids = [];
     // debounced negotiate interface
     this.negotiate = r(onError => {
+      this.emit(PCEvents.NegotiationStarted);
       try {
         this.createAndSendOffer();
       } catch (e) {
@@ -19046,6 +19120,8 @@ class PCTransport {
     if (this.renegotiate) {
       this.renegotiate = false;
       this.createAndSendOffer();
+    } else if (sd.type === 'answer') {
+      this.emit(PCEvents.NegotiationComplete);
     }
   }
   async createAndSendOffer(options) {
@@ -19244,7 +19320,7 @@ var PCState;
   PCState[PCState["Closed"] = 4] = "Closed";
 })(PCState || (PCState = {}));
 /** @internal */
-class RTCEngine extends events.exports.EventEmitter {
+class RTCEngine extends eventsExports.EventEmitter {
   get isClosed() {
     return this._isClosed;
   }
@@ -19402,8 +19478,13 @@ class RTCEngine extends events.exports.EventEmitter {
   }
   async close() {
     const unlock = await this.closingLock.lock();
+    if (this.isClosed) {
+      unlock();
+      return;
+    }
     try {
       this._isClosed = true;
+      this.emit(EngineEvent.Closing);
       this.removeAllListeners();
       this.deregisterOnLineListener();
       this.clearPendingReconnect();
@@ -19969,43 +20050,77 @@ class RTCEngine extends events.exports.EventEmitter {
       this.reliableDC.send(msg);
     }
   }
-  async ensurePublisherConnected(kind) {
-    var _a, _b;
-    if (!this.subscriberPrimary) {
-      return;
-    }
-    if (!this.publisher) {
-      throw new ConnectionError('publisher connection not set');
+  /**
+   * @internal
+   */
+  async ensureDataTransportConnected(kind) {
+    let subscriber = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.subscriberPrimary;
+    var _a, _b, _c;
+    const transport = subscriber ? this.subscriber : this.publisher;
+    const transportName = subscriber ? 'Subscriber' : 'Publisher';
+    if (!transport) {
+      throw new ConnectionError("".concat(transportName, " connection not set"));
     }
-    if (!this.publisher.isICEConnected && this.publisher.pc.iceConnectionState !== 'checking') {
+    if (!subscriber && !((_a = this.publisher) === null || _a === void 0 ? void 0 : _a.isICEConnected) && ((_b = this.publisher) === null || _b === void 0 ? void 0 : _b.pc.iceConnectionState) !== 'checking') {
       // start negotiation
       this.negotiate();
     }
-    const targetChannel = this.dataChannelForKind(kind);
+    const targetChannel = this.dataChannelForKind(kind, subscriber);
     if ((targetChannel === null || targetChannel === void 0 ? void 0 : targetChannel.readyState) === 'open') {
       return;
     }
-    // wait until publisher ICE connected
+    // wait until ICE connected
     const endTime = new Date().getTime() + this.peerConnectionTimeout;
     while (new Date().getTime() < endTime) {
-      if (this.publisher.isICEConnected && ((_a = this.dataChannelForKind(kind)) === null || _a === void 0 ? void 0 : _a.readyState) === 'open') {
+      if (transport.isICEConnected && ((_c = this.dataChannelForKind(kind, subscriber)) === null || _c === void 0 ? void 0 : _c.readyState) === 'open') {
         return;
       }
       await sleep(50);
     }
-    throw new ConnectionError("could not establish publisher connection, state ".concat((_b = this.publisher) === null || _b === void 0 ? void 0 : _b.pc.iceConnectionState));
+    throw new ConnectionError("could not establish ".concat(transportName, " connection, state: ").concat(transport.pc.iceConnectionState));
+  }
+  async ensurePublisherConnected(kind) {
+    await this.ensureDataTransportConnected(kind, false);
   }
   /** @internal */
   negotiate() {
-    if (!this.publisher) {
-      return;
-    }
-    this.hasPublished = true;
-    this.publisher.negotiate(e => {
-      if (e instanceof NegotiationError) {
-        this.fullReconnectOnNext = true;
+    // observe signal state
+    return new Promise((resolve, reject) => {
+      if (!this.publisher) {
+        reject(new NegotiationError('publisher is not defined'));
+        return;
       }
-      this.handleDisconnect('negotiation');
+      this.hasPublished = true;
+      const handleClosed = () => {
+        livekitLogger.debug('engine disconnected while negotiation was ongoing');
+        cleanup();
+        resolve();
+        return;
+      };
+      this.on(EngineEvent.Closing, handleClosed);
+      const negotiationTimeout = setTimeout(() => {
+        reject('negotiation timed out');
+        this.handleDisconnect('negotiation');
+      }, this.peerConnectionTimeout);
+      const cleanup = () => {
+        clearTimeout(negotiationTimeout);
+        this.off(EngineEvent.Closing, handleClosed);
+      };
+      this.publisher.once(PCEvents.NegotiationStarted, () => {
+        var _a;
+        (_a = this.publisher) === null || _a === void 0 ? void 0 : _a.once(PCEvents.NegotiationComplete, () => {
+          cleanup();
+          resolve();
+        });
+      });
+      this.publisher.negotiate(e => {
+        cleanup();
+        reject(e);
+        if (e instanceof NegotiationError) {
+          this.fullReconnectOnNext = true;
+        }
+        this.handleDisconnect('negotiation');
+      });
     });
   }
   dataChannelForKind(kind, sub) {
@@ -20093,7 +20208,7 @@ const RoomState = ConnectionState;
  *
  * @noInheritDoc
  */
-class Room extends events.exports.EventEmitter {
+class Room extends eventsExports.EventEmitter {
   /**
    * Creates a new Room, the primary construct for a LiveKit session.
    * @param options
@@ -20117,13 +20232,17 @@ class Room extends events.exports.EventEmitter {
     this.metadata = undefined;
     this._isRecording = false;
     this.audioEnabled = true;
-    this.connect = (url, token, opts) => {
+    this.connect = async (url, token, opts) => {
+      // In case a disconnect called happened right before the connect call, make sure the disconnect is completed first by awaiting its lock
+      const unlockDisconnect = await this.disconnectLock.lock();
       if (this.state === ConnectionState.Connected) {
         // when the state is reconnecting or connected, this function returns immediately
         livekitLogger.info("already connected to room ".concat(this.name));
+        unlockDisconnect();
         return Promise.resolve();
       }
       if (this.connectFuture) {
+        unlockDisconnect();
         return this.connectFuture.promise;
       }
       this.setAndEmitConnectionState(ConnectionState.Connecting);
@@ -20132,6 +20251,8 @@ class Room extends events.exports.EventEmitter {
         if (!this.abortController || this.abortController.signal.aborted) {
           this.abortController = new AbortController();
         }
+        // at this point the intention to connect has been signalled so we can allow cancelling of the connection via disconnect() again
+        unlockDisconnect();
         if (this.state === ConnectionState.Reconnecting) {
           livekitLogger.info('Reconnection attempt replaced by new connection attempt');
           // make sure we close and recreate the existing engine in order to get rid of any potentially ongoing reconnection attempts
@@ -20697,7 +20818,10 @@ class Room extends events.exports.EventEmitter {
       });
     });
     try {
-      await Promise.all(elements.map(e => e.play()));
+      await Promise.all(elements.map(e => {
+        e.muted = false;
+        return e.play();
+      }));
       this.handleAudioPlaybackStarted();
     } catch (err) {
       this.handleAudioPlaybackFailed(err);
@@ -20887,7 +21011,7 @@ class Room extends events.exports.EventEmitter {
     this.emitWhenConnected(RoomEvent.ParticipantDisconnected, participant);
   }
   async acquireAudioContext() {
-    var _a;
+    var _a, _b;
     if (typeof this.options.expWebAudioMix !== 'boolean' && this.options.expWebAudioMix.audioContext) {
       // override audio context with custom audio context if supplied by user
       this.audioContext = this.options.expWebAudioMix.audioContext;
@@ -20900,6 +21024,11 @@ class Room extends events.exports.EventEmitter {
     if (this.options.expWebAudioMix) {
       this.participants.forEach(participant => participant.setAudioContext(this.audioContext));
     }
+    const newContextIsRunning = ((_b = this.audioContext) === null || _b === void 0 ? void 0 : _b.state) === 'running';
+    if (newContextIsRunning !== this.canPlaybackAudio) {
+      this.audioEnabled = newContextIsRunning;
+      this.emit(RoomEvent.AudioPlaybackStatusChanged, newContextIsRunning);
+    }
   }
   createParticipant(id, info) {
     let participant;
@@ -21055,8 +21184,10 @@ class Room extends events.exports.EventEmitter {
     }, options.participants);
     this.handleDisconnect();
     this.name = 'simulated-room';
-    this.localParticipant.identity = 'simulated-local';
-    this.localParticipant.name = 'simulated-local';
+    this.localParticipant.updateInfo(ParticipantInfo.fromPartial({
+      identity: 'simulated-local',
+      name: 'local-name'
+    }));
     this.setupLocalParticipantEvents();
     this.emit(RoomEvent.SignalConnected);
     this.emit(RoomEvent.Connected);
@@ -21241,7 +21372,7 @@ var CheckStatus;
   CheckStatus[CheckStatus["SUCCESS"] = 3] = "SUCCESS";
   CheckStatus[CheckStatus["FAILED"] = 4] = "FAILED";
 })(CheckStatus || (CheckStatus = {}));
-class Checker extends events.exports.EventEmitter {
+class Checker extends eventsExports.EventEmitter {
   constructor(url, token) {
     let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
     super();
@@ -21521,7 +21652,7 @@ class WebSocketCheck extends Checker {
   }
 }
 
-class ConnectionCheck extends events.exports {
+class ConnectionCheck extends eventsExports {
   constructor(url, token) {
     super();
     this.checkResults = new Map();