livekit-client 2.15.8 → 2.15.10

package/dist/livekit-client.esm.mjs

@@ -7373,6 +7373,110 @@ const TrackSubscribed = /* @__PURE__ */proto3.makeMessageType("livekit.TrackSubs
   T: 9
   /* ScalarType.STRING */
 }]);
+const ConnectionSettings = /* @__PURE__ */proto3.makeMessageType("livekit.ConnectionSettings", () => [{
+  no: 1,
+  name: "auto_subscribe",
+  kind: "scalar",
+  T: 8
+  /* ScalarType.BOOL */
+}, {
+  no: 2,
+  name: "adaptive_stream",
+  kind: "scalar",
+  T: 8
+  /* ScalarType.BOOL */
+}, {
+  no: 3,
+  name: "subscriber_allow_pause",
+  kind: "scalar",
+  T: 8,
+  opt: true
+}, {
+  no: 4,
+  name: "disable_ice_lite",
+  kind: "scalar",
+  T: 8
+  /* ScalarType.BOOL */
+}]);
+const JoinRequest = /* @__PURE__ */proto3.makeMessageType("livekit.JoinRequest", () => [{
+  no: 1,
+  name: "client_info",
+  kind: "message",
+  T: ClientInfo
+}, {
+  no: 2,
+  name: "connection_settings",
+  kind: "message",
+  T: ConnectionSettings
+}, {
+  no: 3,
+  name: "metadata",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 4,
+  name: "participant_attributes",
+  kind: "map",
+  K: 9,
+  V: {
+    kind: "scalar",
+    T: 9
+    /* ScalarType.STRING */
+  }
+}, {
+  no: 5,
+  name: "add_track_requests",
+  kind: "message",
+  T: AddTrackRequest,
+  repeated: true
+}, {
+  no: 6,
+  name: "publisher_offer",
+  kind: "message",
+  T: SessionDescription
+}, {
+  no: 7,
+  name: "reconnect",
+  kind: "scalar",
+  T: 8
+  /* ScalarType.BOOL */
+}, {
+  no: 8,
+  name: "reconnect_reason",
+  kind: "enum",
+  T: proto3.getEnumType(ReconnectReason)
+}, {
+  no: 9,
+  name: "participant_sid",
+  kind: "scalar",
+  T: 9
+  /* ScalarType.STRING */
+}, {
+  no: 10,
+  name: "sync_state",
+  kind: "message",
+  T: SyncState
+}]);
+const WrappedJoinRequest = /* @__PURE__ */proto3.makeMessageType("livekit.WrappedJoinRequest", () => [{
+  no: 1,
+  name: "compression",
+  kind: "enum",
+  T: proto3.getEnumType(WrappedJoinRequest_Compression)
+}, {
+  no: 2,
+  name: "join_request",
+  kind: "scalar",
+  T: 12
+  /* ScalarType.BYTES */
+}]);
+const WrappedJoinRequest_Compression = /* @__PURE__ */proto3.makeEnum("livekit.WrappedJoinRequest.Compression", [{
+  no: 0,
+  name: "NONE"
+}, {
+  no: 1,
+  name: "GZIP"
+}]);
 const MediaSectionsRequirement = /* @__PURE__ */proto3.makeMessageType("livekit.MediaSectionsRequirement", () => [{
   no: 1,
   name: "num_audios",
@@ -12466,7 +12570,7 @@ function getOSVersion(ua) {
   return ua.includes('mac os') ? getMatch(/\(.+?(\d+_\d+(:?_\d+)?)/, ua, 1).replace(/_/g, '.') : undefined;
 }
 
-var version$1 = "2.15.8";
+var version$1 = "2.15.10";
 
 const version = version$1;
 const protocolVersion = 16;
@@ -13078,6 +13182,14 @@ function supportsSetSinkId(elm) {
   }
   return 'setSinkId' in elm;
 }
+/**
+ * Checks whether or not setting an audio output via {@link Room#setActiveDevice}
+ * is supported for the current browser.
+ */
+function supportsAudioOutputSelection() {
+  // Note: this is method publicly exported under a user friendly name and currently only proxying `supportsSetSinkId`
+  return supportsSetSinkId();
+}
 function isBrowserSupported() {
   if (typeof RTCPeerConnection === 'undefined') {
     return false;
@@ -14405,6 +14517,102 @@ class AsyncQueue {
   }
 }
 
+/**
+ * [WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) with [Streams API](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API)
+ *
+ * @see https://web.dev/websocketstream/
+ */
+class WebSocketStream {
+  get readyState() {
+    return this.ws.readyState;
+  }
+  constructor(url) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var _a, _b;
+    if ((_a = options.signal) === null || _a === void 0 ? void 0 : _a.aborted) {
+      throw new DOMException('This operation was aborted', 'AbortError');
+    }
+    this.url = url;
+    const ws = new WebSocket(url, (_b = options.protocols) !== null && _b !== void 0 ? _b : []);
+    ws.binaryType = 'arraybuffer';
+    this.ws = ws;
+    const closeWithInfo = function () {
+      let {
+        closeCode: code,
+        reason
+      } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return ws.close(code, reason);
+    };
+    this.opened = new Promise((resolve, reject) => {
+      ws.onopen = () => {
+        resolve({
+          readable: new ReadableStream({
+            start(controller) {
+              ws.onmessage = _ref => {
+                let {
+                  data
+                } = _ref;
+                return controller.enqueue(data);
+              };
+              ws.onerror = e => controller.error(e);
+            },
+            cancel: closeWithInfo
+          }),
+          writable: new WritableStream({
+            write(chunk) {
+              ws.send(chunk);
+            },
+            abort() {
+              ws.close();
+            },
+            close: closeWithInfo
+          }),
+          protocol: ws.protocol,
+          extensions: ws.extensions
+        });
+        ws.removeEventListener('error', reject);
+      };
+      ws.addEventListener('error', reject);
+    });
+    this.closed = new Promise((resolve, reject) => {
+      const rejectHandler = () => __awaiter(this, void 0, void 0, function* () {
+        const closePromise = new Promise(res => {
+          if (ws.readyState === WebSocket.CLOSED) return;else {
+            ws.addEventListener('close', closeEv => {
+              res(closeEv);
+            }, {
+              once: true
+            });
+          }
+        });
+        const reason = yield Promise.race([sleep(250), closePromise]);
+        if (!reason) {
+          reject(new Error('Encountered unspecified websocket error without a timely close event'));
+        } else {
+          // if we can infer the close reason from the close event then resolve the promise, we don't need to throw
+          resolve(reason);
+        }
+      });
+      ws.onclose = _ref2 => {
+        let {
+          code,
+          reason
+        } = _ref2;
+        resolve({
+          closeCode: code,
+          reason
+        });
+        ws.removeEventListener('error', rejectHandler);
+      };
+      ws.addEventListener('error', rejectHandler);
+    });
+    if (options.signal) {
+      options.signal.onabort = () => ws.close();
+    }
+    this.close = closeWithInfo;
+  }
+}
+
 function createRtcUrl(url, searchParams) {
   const urlObj = new URL(toWebsocketUrl(url));
   searchParams.forEach((value, key) => {
@@ -14423,6 +14631,16 @@ function appendUrlPath(urlObj, path) {
   urlObj.pathname = "".concat(ensureTrailingSlash(urlObj.pathname)).concat(path);
   return urlObj.toString();
 }
+function parseSignalResponse(value) {
+  if (typeof value === 'string') {
+    return SignalResponse.fromJson(JSON.parse(value), {
+      ignoreUnknownFields: true
+    });
+  } else if (value instanceof ArrayBuffer) {
+    return SignalResponse.fromBinary(new Uint8Array(value));
+  }
+  throw new Error("could not decode websocket message: ".concat(typeof value));
+}
 
 const passThroughQueueSignals = ['syncState', 'trickle', 'offer', 'answer', 'simulate', 'leave'];
 function canPassThroughQueue(req) {
@@ -14441,6 +14659,8 @@ var SignalConnectionState;
   SignalConnectionState[SignalConnectionState["DISCONNECTING"] = 3] = "DISCONNECTING";
   SignalConnectionState[SignalConnectionState["DISCONNECTED"] = 4] = "DISCONNECTED";
 })(SignalConnectionState || (SignalConnectionState = {}));
+/** specifies how much time (in ms) we allow for the ws to close its connection gracefully before continuing */
+const MAX_WS_CLOSE_TIME = 250;
 /** @internal */
 class SignalClient {
   get currentState() {
@@ -14478,6 +14698,7 @@ class SignalClient {
       this.onTokenRefresh = undefined;
       this.onTrickle = undefined;
       this.onClose = undefined;
+      this.onMediaSectionsRequirement = undefined;
     };
     this.log = getLogger((_a = loggerOptions.loggerName) !== null && _a !== void 0 ? _a : LoggerNames.Signal);
     this.loggerContextCb = loggerOptions.loggerContextCb;
@@ -14520,137 +14741,149 @@ class SignalClient {
     });
   }
   connect(url, token, opts, abortSignal) {
-    this.connectOptions = opts;
-    const clientInfo = getClientInfo();
-    const params = createConnectionParams(token, clientInfo, opts);
-    const rtcUrl = createRtcUrl(url, params);
-    const validateUrl = createValidateUrl(rtcUrl);
-    return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
       const unlock = yield this.connectionLock.lock();
-      try {
-        const abortHandler = () => __awaiter(this, void 0, void 0, function* () {
-          this.close();
-          clearTimeout(wsTimeout);
-          reject(new ConnectionError('room connection has been cancelled (signal)', ConnectionErrorReason.Cancelled));
-        });
-        const wsTimeout = setTimeout(() => {
-          this.close();
-          reject(new ConnectionError('room connection has timed out (signal)', ConnectionErrorReason.ServerUnreachable));
-        }, opts.websocketTimeout);
-        if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
-          abortHandler();
-        }
-        abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.addEventListener('abort', abortHandler);
-        const redactedUrl = new URL(rtcUrl);
-        if (redactedUrl.searchParams.has('access_token')) {
-          redactedUrl.searchParams.set('access_token', '<redacted>');
-        }
-        this.log.debug("connecting to ".concat(redactedUrl), Object.assign({
-          reconnect: opts.reconnect,
-          reconnectReason: opts.reconnectReason
-        }, this.logContext));
-        if (this.ws) {
-          yield this.close(false);
-        }
-        this.ws = new WebSocket(rtcUrl);
-        this.ws.binaryType = 'arraybuffer';
-        this.ws.onopen = () => {
-          clearTimeout(wsTimeout);
-        };
-        this.ws.onerror = ev => __awaiter(this, void 0, void 0, function* () {
-          if (this.state !== SignalConnectionState.CONNECTED) {
-            this.state = SignalConnectionState.DISCONNECTED;
-            clearTimeout(wsTimeout);
-            try {
-              const resp = yield fetch(validateUrl);
-              if (resp.status.toFixed(0).startsWith('4')) {
-                const msg = yield resp.text();
-                reject(new ConnectionError(msg, ConnectionErrorReason.NotAllowed, resp.status));
-              } else {
-                reject(new ConnectionError("Encountered unknown websocket error during connection: ".concat(ev.toString()), ConnectionErrorReason.InternalError, resp.status));
-              }
-            } catch (e) {
-              reject(new ConnectionError(e instanceof Error ? e.message : 'server was not reachable', ConnectionErrorReason.ServerUnreachable));
+      this.connectOptions = opts;
+      const clientInfo = getClientInfo();
+      const params = opts.singlePeerConnection ? createJoinRequestConnectionParams(token, clientInfo, opts) : createConnectionParams(token, clientInfo, opts);
+      const rtcUrl = createRtcUrl(url, params);
+      const validateUrl = createValidateUrl(rtcUrl);
+      return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        try {
+          const timeoutAbortController = new AbortController();
+          const signals = abortSignal ? [timeoutAbortController.signal, abortSignal] : [timeoutAbortController.signal];
+          const combinedAbort = AbortSignal.any(signals);
+          const abortHandler = event => __awaiter(this, void 0, void 0, function* () {
+            // send leave if we have an active stream writer (connection is open)
+            if (this.streamWriter) {
+              this.sendLeave().then(() => this.close()).catch(e => {
+                this.log.error(e);
+                this.close();
+              });
+            } else {
+              this.close();
             }
-            return;
+            clearTimeout(wsTimeout);
+            const target = event.currentTarget;
+            reject(target instanceof AbortSignal ? target.reason : target);
+          });
+          combinedAbort.addEventListener('abort', abortHandler);
+          const wsTimeout = setTimeout(() => {
+            timeoutAbortController.abort(new ConnectionError('room connection has timed out (signal)', ConnectionErrorReason.ServerUnreachable));
+          }, opts.websocketTimeout);
+          const handleSignalConnected = (connection, firstMessage) => {
+            this.handleSignalConnected(connection, wsTimeout, firstMessage);
+          };
+          const redactedUrl = new URL(rtcUrl);
+          if (redactedUrl.searchParams.has('access_token')) {
+            redactedUrl.searchParams.set('access_token', '<redacted>');
           }
-          // other errors, handle
-          this.handleWSError(ev);
-        });
-        this.ws.onmessage = ev => __awaiter(this, void 0, void 0, function* () {
-          var _a, _b, _c;
-          // not considered connected until JoinResponse is received
-          let resp;
-          if (typeof ev.data === 'string') {
-            const json = JSON.parse(ev.data);
-            resp = SignalResponse.fromJson(json, {
-              ignoreUnknownFields: true
-            });
-          } else if (ev.data instanceof ArrayBuffer) {
-            resp = SignalResponse.fromBinary(new Uint8Array(ev.data));
-          } else {
-            this.log.error("could not decode websocket message: ".concat(typeof ev.data), this.logContext);
-            return;
+          this.log.debug("connecting to ".concat(redactedUrl), Object.assign({
+            reconnect: opts.reconnect,
+            reconnectReason: opts.reconnectReason
+          }, this.logContext));
+          if (this.ws) {
+            yield this.close(false);
           }
-          if (this.state !== SignalConnectionState.CONNECTED) {
-            let shouldProcessMessage = false;
-            // handle join message only
-            if (((_a = resp.message) === null || _a === void 0 ? void 0 : _a.case) === 'join') {
-              this.state = SignalConnectionState.CONNECTED;
-              abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.removeEventListener('abort', abortHandler);
-              this.pingTimeoutDuration = resp.message.value.pingTimeout;
-              this.pingIntervalDuration = resp.message.value.pingInterval;
+          this.ws = new WebSocketStream(rtcUrl, {
+            signal: combinedAbort
+          });
+          try {
+            this.ws.closed.then(closeInfo => {
+              if (this.isEstablishingConnection) {
+                reject(new ConnectionError("Websocket got closed during a (re)connection attempt: ".concat(closeInfo.reason), ConnectionErrorReason.InternalError));
+              }
+              if (closeInfo.closeCode !== 1000) {
+                this.log.warn("websocket closed", Object.assign(Object.assign({}, this.logContext), {
+                  reason: closeInfo.reason,
+                  code: closeInfo.closeCode,
+                  wasClean: closeInfo.closeCode === 1000,
+                  state: this.state
+                }));
+              }
+              return;
+            }).catch(reason => {
+              if (this.isEstablishingConnection) {
+                reject(new ConnectionError("Websocket error during a (re)connection attempt: ".concat(reason), ConnectionErrorReason.InternalError));
+              }
+            });
+            const connection = yield this.ws.opened.catch(reason => __awaiter(this, void 0, void 0, function* () {
+              if (this.state !== SignalConnectionState.CONNECTED) {
+                this.state = SignalConnectionState.DISCONNECTED;
+                clearTimeout(wsTimeout);
+                const error = yield this.handleConnectionError(reason, validateUrl);
+                reject(error);
+                return;
+              }
+              // other errors, handle
+              this.handleWSError(reason);
+              reject(reason);
+              return;
+            }));
+            clearTimeout(wsTimeout);
+            if (!connection) {
+              return;
+            }
+            const signalReader = connection.readable.getReader();
+            this.streamWriter = connection.writable.getWriter();
+            const firstMessage = yield signalReader.read();
+            signalReader.releaseLock();
+            if (!firstMessage.value) {
+              throw new ConnectionError('no message received as first message', ConnectionErrorReason.InternalError);
+            }
+            const firstSignalResponse = parseSignalResponse(firstMessage.value);
+            // Validate the first message
+            const validation = this.validateFirstMessage(firstSignalResponse, (_a = opts.reconnect) !== null && _a !== void 0 ? _a : false);
+            if (!validation.isValid) {
+              reject(validation.error);
+              return;
+            }
+            // Handle join response - set up ping configuration
+            if (((_b = firstSignalResponse.message) === null || _b === void 0 ? void 0 : _b.case) === 'join') {
+              this.pingTimeoutDuration = firstSignalResponse.message.value.pingTimeout;
+              this.pingIntervalDuration = firstSignalResponse.message.value.pingInterval;
               if (this.pingTimeoutDuration && this.pingTimeoutDuration > 0) {
                 this.log.debug('ping config', Object.assign(Object.assign({}, this.logContext), {
                   timeout: this.pingTimeoutDuration,
                   interval: this.pingIntervalDuration
                 }));
-                this.startPingInterval();
               }
-              resolve(resp.message.value);
-            } else if (this.state === SignalConnectionState.RECONNECTING && resp.message.case !== 'leave') {
-              // in reconnecting, any message received means signal reconnected
-              this.state = SignalConnectionState.CONNECTED;
-              abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.removeEventListener('abort', abortHandler);
-              this.startPingInterval();
-              if (((_b = resp.message) === null || _b === void 0 ? void 0 : _b.case) === 'reconnect') {
-                resolve(resp.message.value);
-              } else {
-                this.log.debug('declaring signal reconnected without reconnect response received', this.logContext);
-                resolve(undefined);
-                shouldProcessMessage = true;
-              }
-            } else if (this.isEstablishingConnection && resp.message.case === 'leave') {
-              reject(new ConnectionError('Received leave request while trying to (re)connect', ConnectionErrorReason.LeaveRequest, undefined, resp.message.value.reason));
-            } else if (!opts.reconnect) {
-              // non-reconnect case, should receive join response first
-              reject(new ConnectionError("did not receive join response, got ".concat((_c = resp.message) === null || _c === void 0 ? void 0 : _c.case, " instead"), ConnectionErrorReason.InternalError));
-            }
-            if (!shouldProcessMessage) {
-              return;
             }
+            // Handle successful connection
+            const firstMessageToProcess = validation.shouldProcessFirstMessage ? firstSignalResponse : undefined;
+            handleSignalConnected(connection, firstMessageToProcess);
+            resolve(validation.response);
+          } catch (e) {
+            clearTimeout(wsTimeout);
+            reject(e);
           }
-          if (this.signalLatency) {
-            yield sleep(this.signalLatency);
-          }
-          this.handleSignalResponse(resp);
-        });
-        this.ws.onclose = ev => {
-          if (this.isEstablishingConnection) {
-            reject(new ConnectionError('Websocket got closed during a (re)connection attempt', ConnectionErrorReason.InternalError));
-          }
-          this.log.warn("websocket closed", Object.assign(Object.assign({}, this.logContext), {
-            reason: ev.reason,
-            code: ev.code,
-            wasClean: ev.wasClean,
-            state: this.state
-          }));
-          this.handleOnClose(ev.reason);
-        };
-      } finally {
-        unlock();
+        } finally {
+          unlock();
+        }
+      }));
+    });
+  }
+  startReadingLoop(signalReader, firstMessage) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (firstMessage) {
+        this.handleSignalResponse(firstMessage);
       }
-    }));
+      while (true) {
+        if (this.signalLatency) {
+          yield sleep(this.signalLatency);
+        }
+        const {
+          done,
+          value
+        } = yield signalReader.read();
+        if (done) {
+          break;
+        }
+        const resp = parseSignalResponse(value);
+        this.handleSignalResponse(resp);
+      }
+    });
   }
   close() {
     return __awaiter(this, arguments, void 0, function () {
@@ -14664,26 +14897,20 @@ class SignalClient {
             _this.state = SignalConnectionState.DISCONNECTING;
           }
           if (_this.ws) {
-            _this.ws.onmessage = null;
-            _this.ws.onopen = null;
-            _this.ws.onclose = null;
-            // calling `ws.close()` only starts the closing handshake (CLOSING state), prefer to wait until state is actually CLOSED
-            const closePromise = new Promise(resolve => {
-              if (_this.ws) {
-                _this.ws.onclose = () => {
-                  resolve();
-                };
-              } else {
-                resolve();
-              }
+            _this.ws.close({
+              closeCode: 1000,
+              reason: 'Close method called on signal client'
             });
-            if (_this.ws.readyState < _this.ws.CLOSING) {
-              _this.ws.close();
-              // 250ms grace period for ws to close gracefully
-              yield Promise.race([closePromise, sleep(250)]);
-            }
+            // calling `ws.close()` only starts the closing handshake (CLOSING state), prefer to wait until state is actually CLOSED
+            const closePromise = _this.ws.closed;
             _this.ws = undefined;
+            _this.streamWriter = undefined;
+            yield Promise.race([closePromise, sleep(MAX_WS_CLOSE_TIME)]);
           }
+        } catch (e) {
+          _this.log.debug('websocket error while closing', Object.assign(Object.assign({}, _this.logContext), {
+            error: e
+          }));
         } finally {
           if (updateState) {
             _this.state = SignalConnectionState.DISCONNECTED;
@@ -14860,7 +15087,7 @@ class SignalClient {
           _this3.log.debug("skipping signal request (type: ".concat(message.case, ") - SignalClient disconnected"));
           return;
         }
-        if (!_this3.ws || _this3.ws.readyState !== _this3.ws.OPEN) {
+        if (!_this3.streamWriter) {
           _this3.log.error("cannot send signal request before connected, type: ".concat(message === null || message === void 0 ? void 0 : message.case), _this3.logContext);
           return;
         }
@@ -14869,9 +15096,9 @@ class SignalClient {
         });
         try {
           if (_this3.useJSON) {
-            _this3.ws.send(req.toJsonString());
+            yield _this3.streamWriter.write(req.toJsonString());
           } else {
-            _this3.ws.send(req.toBinary());
+            yield _this3.streamWriter.write(req.toBinary());
           }
         } catch (e) {
           _this3.log.error('error sending signal message', Object.assign(Object.assign({}, _this3.logContext), {
@@ -14975,6 +15202,10 @@ class SignalClient {
       if (this.onRoomMoved) {
         this.onRoomMoved(msg.value);
       }
+    } else if (msg.case === 'mediaSectionsRequirement') {
+      if (this.onMediaSectionsRequirement) {
+        this.onMediaSectionsRequirement(msg.value);
+      }
     } else {
       this.log.debug('unsupported message', Object.assign(Object.assign({}, this.logContext), {
         msgCase: msg.case
@@ -15005,9 +15236,9 @@ class SignalClient {
       }
     });
   }
-  handleWSError(ev) {
+  handleWSError(error) {
     this.log.error('websocket error', Object.assign(Object.assign({}, this.logContext), {
-      error: ev
+      error
     }));
   }
   /**
@@ -15052,6 +15283,89 @@ class SignalClient {
       CriticalTimers.clearInterval(this.pingInterval);
     }
   }
+  /**
+   * Handles the successful connection to the signal server
+   * @param connection The WebSocket connection
+   * @param timeoutHandle The timeout handle to clear
+   * @param firstMessage Optional first message to process
+   * @internal
+   */
+  handleSignalConnected(connection, timeoutHandle, firstMessage) {
+    this.state = SignalConnectionState.CONNECTED;
+    clearTimeout(timeoutHandle);
+    this.startPingInterval();
+    this.startReadingLoop(connection.readable.getReader(), firstMessage);
+  }
+  /**
+   * Validates the first message received from the signal server
+   * @param firstSignalResponse The first signal response received
+   * @param isReconnect Whether this is a reconnection attempt
+   * @returns Validation result with response or error
+   * @internal
+   */
+  validateFirstMessage(firstSignalResponse, isReconnect) {
+    var _a, _b, _c, _d, _e;
+    if (((_a = firstSignalResponse.message) === null || _a === void 0 ? void 0 : _a.case) === 'join') {
+      return {
+        isValid: true,
+        response: firstSignalResponse.message.value
+      };
+    } else if (this.state === SignalConnectionState.RECONNECTING && ((_b = firstSignalResponse.message) === null || _b === void 0 ? void 0 : _b.case) !== 'leave') {
+      if (((_c = firstSignalResponse.message) === null || _c === void 0 ? void 0 : _c.case) === 'reconnect') {
+        return {
+          isValid: true,
+          response: firstSignalResponse.message.value
+        };
+      } else {
+        // in reconnecting, any message received means signal reconnected and we still need to process it
+        this.log.debug('declaring signal reconnected without reconnect response received', this.logContext);
+        return {
+          isValid: true,
+          response: undefined,
+          shouldProcessFirstMessage: true
+        };
+      }
+    } else if (this.isEstablishingConnection && ((_d = firstSignalResponse.message) === null || _d === void 0 ? void 0 : _d.case) === 'leave') {
+      return {
+        isValid: false,
+        error: new ConnectionError('Received leave request while trying to (re)connect', ConnectionErrorReason.LeaveRequest, undefined, firstSignalResponse.message.value.reason)
+      };
+    } else if (!isReconnect) {
+      // non-reconnect case, should receive join response first
+      return {
+        isValid: false,
+        error: new ConnectionError("did not receive join response, got ".concat((_e = firstSignalResponse.message) === null || _e === void 0 ? void 0 : _e.case, " instead"), ConnectionErrorReason.InternalError)
+      };
+    }
+    return {
+      isValid: false,
+      error: new ConnectionError('Unexpected first message', ConnectionErrorReason.InternalError)
+    };
+  }
+  /**
+   * Handles WebSocket connection errors by validating with the server
+   * @param reason The error that occurred
+   * @param validateUrl The URL to validate the connection with
+   * @returns A ConnectionError with appropriate reason and status
+   * @internal
+   */
+  handleConnectionError(reason, validateUrl) {
+    return __awaiter(this, void 0, void 0, function* () {
+      try {
+        const resp = yield fetch(validateUrl);
+        if (resp.status.toFixed(0).startsWith('4')) {
+          const msg = yield resp.text();
+          return new ConnectionError(msg, ConnectionErrorReason.NotAllowed, resp.status);
+        } else if (reason instanceof ConnectionError) {
+          return reason;
+        } else {
+          return new ConnectionError("Encountered unknown websocket error during connection: ".concat(reason), ConnectionErrorReason.InternalError, resp.status);
+        }
+      } catch (e) {
+        return e instanceof ConnectionError ? e : new ConnectionError(e instanceof Error ? e.message : 'server was not reachable', ConnectionErrorReason.ServerUnreachable);
+      }
+    });
+  }
 }
 function fromProtoSessionDescription(sd) {
   const rsd = {
@@ -15120,6 +15434,27 @@ function createConnectionParams(token, info, opts) {
   }
   return params;
 }
+function createJoinRequestConnectionParams(token, info, opts) {
+  const params = new URLSearchParams();
+  params.set('access_token', token);
+  const joinRequest = new JoinRequest({
+    clientInfo: info,
+    connectionSettings: new ConnectionSettings({
+      autoSubscribe: !!opts.autoSubscribe,
+      adaptiveStream: !!opts.adaptiveStream
+    }),
+    reconnect: !!opts.reconnect,
+    participantSid: opts.sid ? opts.sid : undefined
+  });
+  if (opts.reconnectReason) {
+    joinRequest.reconnectReason = opts.reconnectReason;
+  }
+  const wrappedJoinRequest = new WrappedJoinRequest({
+    joinRequest: joinRequest.toBinary()
+  });
+  params.set('join_request', btoa(new TextDecoder('utf-8').decode(wrappedJoinRequest.toBinary())));
+  return params;
+}
 
 class DataPacketBuffer {
   constructor() {
@@ -16132,7 +16467,7 @@ class PCTransport extends eventsExports.EventEmitter {
         sdpParsed.media.forEach(media => {
           const mid = getMidString(media.mid);
           if (media.type === 'audio') {
-            // mung sdp for opus bitrate settings
+            // munge sdp for opus bitrate settings
             this.trackBitrates.some(trackbr => {
               if (!trackbr.transceiver || mid != trackbr.transceiver.mid) {
                 return false;
@@ -16237,7 +16572,7 @@ class PCTransport extends eventsExports.EventEmitter {
         sdpParsed.media.forEach(media => {
           ensureIPAddrMatchVersion(media);
           if (media.type === 'audio') {
-            ensureAudioNackAndStereo(media, [], []);
+            ensureAudioNackAndStereo(media, ['all'], []);
           } else if (media.type === 'video') {
             this.trackBitrates.some(trackbr => {
               if (!media.msid || !trackbr.cid || !media.msid.includes(trackbr.cid)) {
@@ -16313,6 +16648,9 @@ class PCTransport extends eventsExports.EventEmitter {
   addTransceiver(mediaStreamTrack, transceiverInit) {
     return this.pc.addTransceiver(mediaStreamTrack, transceiverInit);
   }
+  addTransceiverOfKind(kind, transceiverInit) {
+    return this.pc.addTransceiver(kind, transceiverInit);
+  }
   addTrack(track) {
     if (!this._pc) {
       throw new UnexpectedConnectionState('PC closed, cannot add track');
@@ -16507,7 +16845,7 @@ function ensureAudioNackAndStereo(media, stereoMids, nackMids) {
         type: 'nack'
       });
     }
-    if (stereoMids.includes(mid)) {
+    if (stereoMids.includes(mid) || stereoMids.length === 1 && stereoMids[0] === 'all') {
       media.fmtp.some(fmtp => {
         if (fmtp.payload === opusPayload) {
           if (!fmtp.config.includes('stereo=1')) {
@@ -16607,7 +16945,8 @@ const roomOptionDefaults = {
   stopLocalTrackOnUnpublish: true,
   reconnectPolicy: new DefaultReconnectPolicy(),
   disconnectOnPageLeave: true,
-  webAudioMix: false
+  webAudioMix: false,
+  singlePeerConnection: false
 };
 const roomConnectOptionDefaults = {
   autoSubscribe: true,
@@ -16635,12 +16974,12 @@ class PCTransportManager {
   get currentState() {
     return this.state;
   }
-  constructor(rtcConfig, subscriberPrimary, loggerOptions) {
+  constructor(rtcConfig, mode, loggerOptions) {
     var _a;
     this.peerConnectionTimeout = roomConnectOptionDefaults.peerConnectionTimeout;
     this.log = livekitLogger;
     this.updateState = () => {
-      var _a;
+      var _a, _b;
       const previousState = this.state;
       const connectionStates = this.requiredTransports.map(tr => tr.getConnectionState());
       if (connectionStates.every(st => st === 'connected')) {
@@ -16658,35 +16997,41 @@ class PCTransportManager {
       }
       if (previousState !== this.state) {
         this.log.debug("pc state change: from ".concat(PCTransportState[previousState], " to ").concat(PCTransportState[this.state]), this.logContext);
-        (_a = this.onStateChange) === null || _a === void 0 ? void 0 : _a.call(this, this.state, this.publisher.getConnectionState(), this.subscriber.getConnectionState());
+        (_a = this.onStateChange) === null || _a === void 0 ? void 0 : _a.call(this, this.state, this.publisher.getConnectionState(), (_b = this.subscriber) === null || _b === void 0 ? void 0 : _b.getConnectionState());
       }
     };
     this.log = getLogger((_a = loggerOptions.loggerName) !== null && _a !== void 0 ? _a : LoggerNames.PCManager);
     this.loggerOptions = loggerOptions;
-    this.isPublisherConnectionRequired = !subscriberPrimary;
-    this.isSubscriberConnectionRequired = subscriberPrimary;
+    this.isPublisherConnectionRequired = mode !== 'subscriber-primary';
+    this.isSubscriberConnectionRequired = mode === 'subscriber-primary';
     this.publisher = new PCTransport(rtcConfig, loggerOptions);
-    this.subscriber = new PCTransport(rtcConfig, loggerOptions);
+    if (mode !== 'publisher-only') {
+      this.subscriber = new PCTransport(rtcConfig, loggerOptions);
+      this.subscriber.onConnectionStateChange = this.updateState;
+      this.subscriber.onIceConnectionStateChange = this.updateState;
+      this.subscriber.onSignalingStatechange = this.updateState;
+      this.subscriber.onIceCandidate = candidate => {
+        var _a;
+        (_a = this.onIceCandidate) === null || _a === void 0 ? void 0 : _a.call(this, candidate, SignalTarget.SUBSCRIBER);
+      };
+      // in subscriber primary mode, server side opens sub data channels.
+      this.subscriber.onDataChannel = ev => {
+        var _a;
+        (_a = this.onDataChannel) === null || _a === void 0 ? void 0 : _a.call(this, ev);
+      };
+      this.subscriber.onTrack = ev => {
+        var _a;
+        (_a = this.onTrack) === null || _a === void 0 ? void 0 : _a.call(this, ev);
+      };
+    }
     this.publisher.onConnectionStateChange = this.updateState;
-    this.subscriber.onConnectionStateChange = this.updateState;
     this.publisher.onIceConnectionStateChange = this.updateState;
-    this.subscriber.onIceConnectionStateChange = this.updateState;
     this.publisher.onSignalingStatechange = this.updateState;
-    this.subscriber.onSignalingStatechange = this.updateState;
     this.publisher.onIceCandidate = candidate => {
       var _a;
       (_a = this.onIceCandidate) === null || _a === void 0 ? void 0 : _a.call(this, candidate, SignalTarget.PUBLISHER);
     };
-    this.subscriber.onIceCandidate = candidate => {
-      var _a;
-      (_a = this.onIceCandidate) === null || _a === void 0 ? void 0 : _a.call(this, candidate, SignalTarget.SUBSCRIBER);
-    };
-    // in subscriber primary mode, server side opens sub data channels.
-    this.subscriber.onDataChannel = ev => {
-      var _a;
-      (_a = this.onDataChannel) === null || _a === void 0 ? void 0 : _a.call(this, ev);
-    };
-    this.subscriber.onTrack = ev => {
+    this.publisher.onTrack = ev => {
       var _a;
       (_a = this.onTrack) === null || _a === void 0 ? void 0 : _a.call(this, ev);
     };
@@ -16707,11 +17052,6 @@ class PCTransportManager {
     this.isPublisherConnectionRequired = require;
     this.updateState();
   }
-  requireSubscriber() {
-    let require = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-    this.isSubscriberConnectionRequired = require;
-    this.updateState();
-  }
   createAndSendPublisherOffer(options) {
     return this.publisher.createAndSendOffer(options);
   }
@@ -16723,6 +17063,7 @@ class PCTransportManager {
   }
   close() {
     return __awaiter(this, void 0, void 0, function* () {
+      var _a;
       if (this.publisher && this.publisher.getSignallingState() !== 'closed') {
         const publisher = this.publisher;
         for (const sender of publisher.getSenders()) {
@@ -16738,13 +17079,15 @@ class PCTransportManager {
           }
         }
       }
-      yield Promise.all([this.publisher.close(), this.subscriber.close()]);
+      yield Promise.all([this.publisher.close(), (_a = this.subscriber) === null || _a === void 0 ? void 0 : _a.close()]);
       this.updateState();
     });
   }
   triggerIceRestart() {
     return __awaiter(this, void 0, void 0, function* () {
-      this.subscriber.restartingIce = true;
+      if (this.subscriber) {
+        this.subscriber.restartingIce = true;
+      }
       // only restart publisher if it's needed
       if (this.needsPublisher) {
         yield this.createAndSendPublisherOffer({
@@ -16755,28 +17098,30 @@ class PCTransportManager {
   }
   addIceCandidate(candidate, target) {
     return __awaiter(this, void 0, void 0, function* () {
+      var _a;
       if (target === SignalTarget.PUBLISHER) {
         yield this.publisher.addIceCandidate(candidate);
       } else {
-        yield this.subscriber.addIceCandidate(candidate);
+        yield (_a = this.subscriber) === null || _a === void 0 ? void 0 : _a.addIceCandidate(candidate);
       }
     });
   }
   createSubscriberAnswerFromOffer(sd, offerId) {
     return __awaiter(this, void 0, void 0, function* () {
+      var _a, _b, _c;
       this.log.debug('received server offer', Object.assign(Object.assign({}, this.logContext), {
         RTCSdpType: sd.type,
         sdp: sd.sdp,
-        signalingState: this.subscriber.getSignallingState().toString()
+        signalingState: (_a = this.subscriber) === null || _a === void 0 ? void 0 : _a.getSignallingState().toString()
       }));
       const unlock = yield this.remoteOfferLock.lock();
       try {
-        const success = yield this.subscriber.setRemoteDescription(sd, offerId);
+        const success = yield (_b = this.subscriber) === null || _b === void 0 ? void 0 : _b.setRemoteDescription(sd, offerId);
         if (!success) {
           return undefined;
         }
         // answer the offer
-        const answer = yield this.subscriber.createAndSetAnswer();
+        const answer = yield (_c = this.subscriber) === null || _c === void 0 ? void 0 : _c.createAndSetAnswer();
         return answer;
       } finally {
         unlock();
@@ -16784,8 +17129,9 @@ class PCTransportManager {
     });
   }
   updateConfiguration(config, iceRestart) {
+    var _a;
     this.publisher.setConfiguration(config);
-    this.subscriber.setConfiguration(config);
+    (_a = this.subscriber) === null || _a === void 0 ? void 0 : _a.setConfiguration(config);
     if (iceRestart) {
       this.triggerIceRestart();
     }
@@ -16835,6 +17181,9 @@ class PCTransportManager {
   addPublisherTransceiver(track, transceiverInit) {
     return this.publisher.addTransceiver(track, transceiverInit);
   }
+  addPublisherTransceiverOfKind(kind, transceiverInit) {
+    return this.publisher.addTransceiverOfKind(kind, transceiverInit);
+  }
   addPublisherTrack(track) {
     return this.publisher.addTrack(track);
   }
@@ -16857,7 +17206,7 @@ class PCTransportManager {
     if (this.isPublisherConnectionRequired) {
       transports.push(this.publisher);
     }
-    if (this.isSubscriberConnectionRequired) {
+    if (this.isSubscriberConnectionRequired && this.subscriber) {
       transports.push(this.subscriber);
     }
     return transports;
@@ -19052,7 +19401,9 @@ class RTCEngine extends eventsExports.EventEmitter {
           const decryptedData = yield (_c = this.e2eeManager) === null || _c === void 0 ? void 0 : _c.handleEncryptedData(dp.value.value.encryptedValue, dp.value.value.iv, dp.participantIdentity, dp.value.value.keyIndex);
           const decryptedPacket = EncryptedPacketPayload.fromBinary(decryptedData.payload);
           const newDp = new DataPacket({
-            value: decryptedPacket.value
+            value: decryptedPacket.value,
+            participantIdentity: dp.participantIdentity,
+            participantSid: dp.participantSid
           });
           if (((_d = newDp.value) === null || _d === void 0 ? void 0 : _d.case) === 'user') {
             // compatibility
@@ -19367,7 +19718,7 @@ class RTCEngine extends eventsExports.EventEmitter {
       }
       this.participantSid = (_a = joinResponse.participant) === null || _a === void 0 ? void 0 : _a.sid;
       const rtcConfig = this.makeRTCConfiguration(joinResponse);
-      this.pcManager = new PCTransportManager(rtcConfig, joinResponse.subscriberPrimary, this.loggerOptions);
+      this.pcManager = new PCTransportManager(rtcConfig, this.options.singlePeerConnection ? 'publisher-only' : joinResponse.subscriberPrimary ? 'subscriber-primary' : 'publisher-primary', this.loggerOptions);
       this.emit(EngineEvent.TransportsCreated, this.pcManager.publisher, this.pcManager.subscriber);
       this.pcManager.onIceCandidate = (candidate, target) => {
         this.client.sendIceCandidate(candidate, target);
@@ -19403,6 +19754,9 @@ class RTCEngine extends eventsExports.EventEmitter {
         }
       });
       this.pcManager.onTrack = ev => {
+        // this fires after the underlying transceiver is stopped and potentially
+        // peer connection closed, so do not bubble up if there are no streams
+        if (ev.streams.length === 0) return;
         this.emit(EngineEvent.MediaTrackAdded, ev.track, ev.streams[0], ev.receiver);
       };
       if (!supportOptionalDatachannel((_b = joinResponse.serverInfo) === null || _b === void 0 ? void 0 : _b.protocol)) {
@@ -19417,7 +19771,8 @@ class RTCEngine extends eventsExports.EventEmitter {
         return;
       }
       this.log.debug('received server answer', Object.assign(Object.assign({}, this.logContext), {
-        RTCSdpType: sd.type
+        RTCSdpType: sd.type,
+        sdp: sd.sdp
       }));
       yield this.pcManager.setPublisherAnswer(sd, offerId);
     });
@@ -19484,6 +19839,19 @@ class RTCEngine extends eventsExports.EventEmitter {
       }
       this.emit(EngineEvent.RoomMoved, res);
     };
+    this.client.onMediaSectionsRequirement = requirement => {
+      var _a, _b;
+      const transceiverInit = {
+        direction: 'recvonly'
+      };
+      for (let i = 0; i < requirement.numAudios; i++) {
+        (_a = this.pcManager) === null || _a === void 0 ? void 0 : _a.addPublisherTransceiverOfKind('audio', transceiverInit);
+      }
+      for (let i = 0; i < requirement.numVideos; i++) {
+        (_b = this.pcManager) === null || _b === void 0 ? void 0 : _b.addPublisherTransceiverOfKind('video', transceiverInit);
+      }
+      this.negotiate();
+    };
     this.client.onClose = () => {
       this.handleDisconnect('signal', ReconnectReason.RR_SIGNAL_DISCONNECTED);
     };
@@ -20113,19 +20481,21 @@ class RTCEngine extends eventsExports.EventEmitter {
   }
   /** @internal */
   sendSyncState(remoteTracks, localTracks) {
-    var _a, _b;
+    var _a, _b, _c, _d;
     if (!this.pcManager) {
       this.log.warn('sync state cannot be sent without peer connection setup', this.logContext);
       return;
     }
-    const previousAnswer = this.pcManager.subscriber.getLocalDescription();
-    const previousOffer = this.pcManager.subscriber.getRemoteDescription();
+    const previousPublisherOffer = this.pcManager.publisher.getLocalDescription();
+    const previousPublisherAnswer = this.pcManager.publisher.getRemoteDescription();
+    const previousSubscriberOffer = (_a = this.pcManager.subscriber) === null || _a === void 0 ? void 0 : _a.getRemoteDescription();
+    const previousSubscriberAnswer = (_b = this.pcManager.subscriber) === null || _b === void 0 ? void 0 : _b.getLocalDescription();
     /* 1. autosubscribe on, so subscribed tracks = all tracks - unsub tracks,
           in this case, we send unsub tracks, so server add all tracks to this
           subscribe pc and unsub special tracks from it.
        2. autosubscribe off, we send subscribed tracks.
     */
-    const autoSubscribe = (_b = (_a = this.signalOpts) === null || _a === void 0 ? void 0 : _a.autoSubscribe) !== null && _b !== void 0 ? _b : true;
+    const autoSubscribe = (_d = (_c = this.signalOpts) === null || _c === void 0 ? void 0 : _c.autoSubscribe) !== null && _d !== void 0 ? _d : true;
     const trackSids = new Array();
     const trackSidsDisabled = new Array();
     remoteTracks.forEach(track => {
@@ -20137,13 +20507,19 @@ class RTCEngine extends eventsExports.EventEmitter {
       }
     });
     this.client.sendSyncState(new SyncState({
-      answer: previousAnswer ? toProtoSessionDescription({
-        sdp: previousAnswer.sdp,
-        type: previousAnswer.type
+      answer: this.options.singlePeerConnection ? previousPublisherAnswer ? toProtoSessionDescription({
+        sdp: previousPublisherAnswer.sdp,
+        type: previousPublisherAnswer.type
+      }) : undefined : previousSubscriberAnswer ? toProtoSessionDescription({
+        sdp: previousSubscriberAnswer.sdp,
+        type: previousSubscriberAnswer.type
       }) : undefined,
-      offer: previousOffer ? toProtoSessionDescription({
-        sdp: previousOffer.sdp,
-        type: previousOffer.type
+      offer: this.options.singlePeerConnection ? previousPublisherOffer ? toProtoSessionDescription({
+        sdp: previousPublisherOffer.sdp,
+        type: previousPublisherOffer.type
+      }) : undefined : previousSubscriberOffer ? toProtoSessionDescription({
+        sdp: previousSubscriberOffer.sdp,
+        type: previousSubscriberOffer.type
       }) : undefined,
       subscription: new UpdateSubscription({
         trackSids,
@@ -23879,10 +24255,10 @@ class LocalParticipant extends Participant {
         destinationIdentity,
         method,
         payload,
-        responseTimeout = 10000
+        responseTimeout = 15000
       } = _ref3;
       return function* () {
-        const maxRoundTripLatency = 2000;
+        const maxRoundTripLatency = 7000;
         return new Promise((resolve, reject) => __awaiter(_this5, void 0, void 0, function* () {
           var _a, _b, _c, _d;
           if (byteLength(payload) > MAX_PAYLOAD_BYTES) {
@@ -24803,7 +25179,8 @@ class Room extends eventsExports.EventEmitter {
         adaptiveStream: typeof roomOptions.adaptiveStream === 'object' ? true : roomOptions.adaptiveStream,
         maxRetries: connectOptions.maxRetries,
         e2eeEnabled: !!this.e2eeManager,
-        websocketTimeout: connectOptions.websocketTimeout
+        websocketTimeout: connectOptions.websocketTimeout,
+        singlePeerConnection: roomOptions.singlePeerConnection
       }, abortController.signal);
       let serverInfo = joinResponse.serverInfo;
       if (!serverInfo) {
@@ -24940,8 +25317,9 @@ class Room extends eventsExports.EventEmitter {
             _this2.log.info('disconnect from room', Object.assign({}, _this2.logContext));
             if (_this2.state === ConnectionState.Connecting || _this2.state === ConnectionState.Reconnecting || _this2.isResuming) {
               // try aborting pending connection attempt
-              _this2.log.warn('abort connection attempt', _this2.logContext);
-              (_a = _this2.abortController) === null || _a === void 0 ? void 0 : _a.abort();
+              const msg = 'Abort connection attempt due to user initiated disconnect';
+              _this2.log.warn(msg, _this2.logContext);
+              (_a = _this2.abortController) === null || _a === void 0 ? void 0 : _a.abort(msg);
               // in case the abort controller didn't manage to cancel the connection attempt, reject the connect promise explicitly
               (_c = (_b = _this2.connectFuture) === null || _b === void 0 ? void 0 : _b.reject) === null || _c === void 0 ? void 0 : _c.call(_b, new ConnectionError('Client initiated disconnect', ConnectionErrorReason.Cancelled));
               _this2.connectFuture = undefined;
@@ -25513,6 +25891,7 @@ class Room extends eventsExports.EventEmitter {
     if (e2eeOptions) {
       if ('e2eeManager' in e2eeOptions) {
         this.e2eeManager = e2eeOptions.e2eeManager;
+        this.e2eeManager.isDataChannelEncryptionEnabled = dcEncryptionEnabled;
       } else {
         this.e2eeManager = new E2EEManager(e2eeOptions, dcEncryptionEnabled);
       }
@@ -27087,7 +27466,8 @@ class TURNCheck extends Checker {
         autoSubscribe: true,
         maxRetries: 0,
         e2eeEnabled: false,
-        websocketTimeout: 15000
+        websocketTimeout: 15000,
+        singlePeerConnection: false
       });
       let hasTLS = false;
       let hasTURN = false;
@@ -27137,6 +27517,7 @@ class WebRTCCheck extends Checker {
       let hasTcp = false;
       let hasIpv4Udp = false;
       this.room.on(RoomEvent.SignalConnected, () => {
+        var _a;
         const prevTrickle = this.room.engine.client.onTrickle;
         this.room.engine.client.onTrickle = (sd, target) => {
           if (sd.candidate) {
@@ -27160,7 +27541,7 @@ class WebRTCCheck extends Checker {
             prevTrickle(sd, target);
           }
         };
-        if (this.room.engine.pcManager) {
+        if ((_a = this.room.engine.pcManager) === null || _a === void 0 ? void 0 : _a.subscriber) {
           this.room.engine.pcManager.subscriber.onIceCandidateError = ev => {
             if (ev instanceof RTCPeerConnectionIceErrorEvent) {
               this.appendWarning("error with ICE candidate: ".concat(ev.errorCode, " ").concat(ev.errorText, " ").concat(ev.url));
@@ -27216,7 +27597,8 @@ class WebSocketCheck extends Checker {
         autoSubscribe: true,
         maxRetries: 0,
         e2eeEnabled: false,
-        websocketTimeout: 15000
+        websocketTimeout: 15000,
+        singlePeerConnection: false
       });
       this.appendMessage("Connected to server, version ".concat(joinRes.serverVersion, "."));
       if (((_a = joinRes.serverInfo) === null || _a === void 0 ? void 0 : _a.edition) === ServerInfo_Edition.Cloud && ((_b = joinRes.serverInfo) === null || _b === void 0 ? void 0 : _b.region)) {
@@ -27584,15 +27966,17 @@ function decodeJwt(jwt) {
 
 const ONE_SECOND_IN_MILLISECONDS = 1000;
 const ONE_MINUTE_IN_MILLISECONDS = 60 * ONE_SECOND_IN_MILLISECONDS;
-function isResponseExpired(response) {
+function isResponseTokenValid(response) {
   const jwtPayload = decodeTokenPayload(response.participantToken);
-  if (!(jwtPayload === null || jwtPayload === void 0 ? void 0 : jwtPayload.exp)) {
+  if (!(jwtPayload === null || jwtPayload === void 0 ? void 0 : jwtPayload.nbf) || !(jwtPayload === null || jwtPayload === void 0 ? void 0 : jwtPayload.exp)) {
     return true;
   }
-  const expInMilliseconds = jwtPayload.exp * ONE_SECOND_IN_MILLISECONDS;
-  const expiresAt = new Date(expInMilliseconds - ONE_MINUTE_IN_MILLISECONDS);
   const now = new Date();
-  return expiresAt >= now;
+  const nbfInMilliseconds = jwtPayload.nbf * ONE_SECOND_IN_MILLISECONDS;
+  const nbfDate = new Date(nbfInMilliseconds);
+  const expInMilliseconds = jwtPayload.exp * ONE_SECOND_IN_MILLISECONDS;
+  const expDate = new Date(expInMilliseconds - ONE_MINUTE_IN_MILLISECONDS);
+  return nbfDate <= now && expDate > now;
 }
 function decodeTokenPayload(token) {
   const payload = decodeJwt(token);
@@ -27644,7 +28028,7 @@ class TokenSourceCached extends TokenSourceConfigurable {
     if (!this.cachedResponse) {
       return false;
     }
-    if (isResponseExpired(this.cachedResponse)) {
+    if (!isResponseTokenValid(this.cachedResponse)) {
       return false;
     }
     if (this.isSameAsCachedFetchOptions(fetchOptions)) {
@@ -27913,5 +28297,5 @@ function isFacingModeValue(item) {
   return item === undefined || allowedValues.includes(item);
 }
 
-export { AudioPresets, BackupCodecPolicy, BaseKeyProvider, CheckStatus, Checker, ConnectionCheck, ConnectionError, ConnectionErrorReason, ConnectionQuality, ConnectionState, CriticalTimers, CryptorError, CryptorErrorReason, CryptorEvent, DataPacket_Kind, DataStreamError, DataStreamErrorReason, DefaultReconnectPolicy, DeviceUnsupportedError, DisconnectReason, EncryptionEvent, Encryption_Type, EngineEvent, ExternalE2EEKeyProvider, KeyHandlerEvent, KeyProviderEvent, LivekitError, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalTrackRecorder, LocalVideoTrack, LogLevel, LoggerNames, MediaDeviceFailure, _ as Mutex, NegotiationError, Participant, ParticipantEvent, ParticipantInfo_Kind as ParticipantKind, PublishDataError, PublishTrackError, RemoteAudioTrack, RemoteParticipant, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, RoomEvent, RpcError, ScreenSharePresets, SignalRequestError, SubscriptionError, TokenSource, TokenSourceConfigurable, TokenSourceCustom, TokenSourceEndpoint, TokenSourceFixed, TokenSourceLiteral, TokenSourceSandboxTokenServer, Track, TrackEvent, TrackInvalidError, TrackPublication, TrackType, UnexpectedConnectionState, UnsupportedServer, VideoPreset, VideoPresets, VideoPresets43, VideoQuality, asEncryptablePacket, attachToElement, attributeTypings as attributes, audioCodecs, compareVersions, createAudioAnalyser, createE2EEKey, createKeyMaterialFromBuffer, createKeyMaterialFromString, createLocalAudioTrack, createLocalScreenTracks, createLocalTracks, createLocalVideoTrack, deriveKeys, detachTrack, facingModeFromDeviceLabel, facingModeFromLocalTrack, getBrowser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, getLogger, importKey, isAudioCodec, isAudioTrack, isBackupCodec, isBackupVideoCodec, isBrowserSupported, isE2EESupported, isInsertableStreamSupported, isLocalParticipant, isLocalTrack, isRemoteParticipant, isRemoteTrack, isScriptTransformSupported, isVideoCodec, isVideoFrame, isVideoTrack, needsRbspUnescaping, parseRbsp, protocolVersion, ratchet, setLogExtension, setLogLevel, supportsAV1, supportsAdaptiveStream, supportsDynacast, supportsVP9, version, videoCodecs, writeRbsp };
+export { AudioPresets, BackupCodecPolicy, BaseKeyProvider, CheckStatus, Checker, ConnectionCheck, ConnectionError, ConnectionErrorReason, ConnectionQuality, ConnectionState, CriticalTimers, CryptorError, CryptorErrorReason, CryptorEvent, DataPacket_Kind, DataStreamError, DataStreamErrorReason, DefaultReconnectPolicy, DeviceUnsupportedError, DisconnectReason, EncryptionEvent, Encryption_Type, EngineEvent, ExternalE2EEKeyProvider, KeyHandlerEvent, KeyProviderEvent, LivekitError, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalTrackRecorder, LocalVideoTrack, LogLevel, LoggerNames, MediaDeviceFailure, _ as Mutex, NegotiationError, Participant, ParticipantEvent, ParticipantInfo_Kind as ParticipantKind, PublishDataError, PublishTrackError, RemoteAudioTrack, RemoteParticipant, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, RoomEvent, RpcError, ScreenSharePresets, SignalRequestError, SubscriptionError, TokenSource, TokenSourceConfigurable, TokenSourceCustom, TokenSourceEndpoint, TokenSourceFixed, TokenSourceLiteral, TokenSourceSandboxTokenServer, Track, TrackEvent, TrackInvalidError, TrackPublication, TrackType, UnexpectedConnectionState, UnsupportedServer, VideoPreset, VideoPresets, VideoPresets43, VideoQuality, asEncryptablePacket, attachToElement, attributeTypings as attributes, audioCodecs, compareVersions, createAudioAnalyser, createE2EEKey, createKeyMaterialFromBuffer, createKeyMaterialFromString, createLocalAudioTrack, createLocalScreenTracks, createLocalTracks, createLocalVideoTrack, deriveKeys, detachTrack, facingModeFromDeviceLabel, facingModeFromLocalTrack, getBrowser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, getLogger, importKey, isAudioCodec, isAudioTrack, isBackupCodec, isBackupVideoCodec, isBrowserSupported, isE2EESupported, isInsertableStreamSupported, isLocalParticipant, isLocalTrack, isRemoteParticipant, isRemoteTrack, isScriptTransformSupported, isVideoCodec, isVideoFrame, isVideoTrack, needsRbspUnescaping, parseRbsp, protocolVersion, ratchet, setLogExtension, setLogLevel, supportsAV1, supportsAdaptiveStream, supportsAudioOutputSelection, supportsDynacast, supportsVP9, version, videoCodecs, writeRbsp };
 //# sourceMappingURL=livekit-client.esm.mjs.map