livekit-client 2.20.0 → 2.20.1

package/dist/livekit-client.esm.mjs

@@ -8937,10 +8937,15 @@ function detectBrowser(window) {
       return brand.brand === 'Chromium';
     });
     if (chromium) {
-      return {
-        browser: 'chrome',
-        version: parseInt(chromium.version, 10)
-      };
+      const version = parseInt(chromium.version, 10);
+      // navigator.userAgentData was introduced in Chromium 90
+      // so any Chromium brand reporting a version below 90 is invalid
+      if (version >= 90) {
+        return {
+          browser: 'chrome',
+          version
+        };
+      }
     }
   }
   if (navigator.mozGetUserMedia) {
@@ -9049,6 +9054,9 @@ function filterStats(result, track, outbound) {
 /* eslint-env node */
 const logging = log$4;
 function shimGetUserMedia$2(window, browserDetails) {
+  if (browserDetails.version >= 64) {
+    return;
+  }
   const navigator = window && window.navigator;
   if (!navigator.mediaDevices) {
     return;
@@ -9202,6 +9210,8 @@ function shimGetUserMedia$2(window, browserDetails) {
   // Even though Chrome 45 has navigator.mediaDevices and a getUserMedia
   // function which returns a Promise, it does not accept spec-style
   // constraints.
+  // Fixed in M64 too, see
+  //   https://groups.google.com/g/discuss-webrtc/c/DMPTKcXVUQ4/m/85FaASoFBwAJ?
   if (navigator.mediaDevices.getUserMedia) {
     const origGetUserMedia = navigator.mediaDevices.getUserMedia.bind(navigator.mediaDevices);
     navigator.mediaDevices.getUserMedia = function (cs) {
@@ -9787,6 +9797,9 @@ function fixNegotiationNeeded(window, browserDetails) {
 /* eslint-env node */
 function shimGetUserMedia$1(window, browserDetails) {
   const navigator = window && window.navigator;
+  if (!navigator.mediaDevices) {
+    return;
+  }
   const MediaStreamTrack = window && window.MediaStreamTrack;
   navigator.getUserMedia = function (constraints, onSuccess, onError) {
     // Replace Firefox 44+'s deprecation warning with unprefixed version.
@@ -9840,10 +9853,10 @@ function shimGetUserMedia$1(window, browserDetails) {
 /* eslint-env node */
 
 function shimGetDisplayMedia(window, preferredMediaSource) {
-  if (window.navigator.mediaDevices && 'getDisplayMedia' in window.navigator.mediaDevices) {
+  if (!window.navigator.mediaDevices) {
     return;
   }
-  if (!window.navigator.mediaDevices) {
+  if (window.navigator.mediaDevices && 'getDisplayMedia' in window.navigator.mediaDevices) {
     return;
   }
   window.navigator.mediaDevices.getDisplayMedia = function getDisplayMedia(constraints) {
@@ -10023,13 +10036,17 @@ function shimRTCDataChannel(window) {
     window.RTCDataChannel = window.DataChannel;
   }
 }
-function shimAddTransceiver(window) {
+function shimAddTransceiver(window, browserDetails) {
   // https://github.com/webrtcHacks/adapter/issues/998#issuecomment-516921647
   // Firefox ignores the init sendEncodings options passed to addTransceiver
   // https://bugzilla.mozilla.org/show_bug.cgi?id=1396918
   if (!(typeof window === 'object' && window.RTCPeerConnection)) {
     return;
   }
+  // Fixed by https://bugzilla.mozilla.org/show_bug.cgi?id=1401592 in FF110.
+  if (browserDetails.version >= 110) {
+    return;
+  }
   const origAddTransceiver = window.RTCPeerConnection.prototype.addTransceiver;
   if (origAddTransceiver) {
     window.RTCPeerConnection.prototype.addTransceiver = function addTransceiver() {
@@ -10089,10 +10106,14 @@ function shimAddTransceiver(window) {
     };
   }
 }
-function shimGetParameters(window) {
+function shimGetParameters(window, browserDetails) {
   if (!(typeof window === 'object' && window.RTCRtpSender)) {
     return;
   }
+  // Fixed by https://bugzilla.mozilla.org/show_bug.cgi?id=1401592 in FF110.
+  if (browserDetails.version >= 110) {
+    return;
+  }
   const origGetParameters = window.RTCRtpSender.prototype.getParameters;
   if (origGetParameters) {
     window.RTCRtpSender.prototype.getParameters = function getParameters() {
@@ -10104,13 +10125,17 @@ function shimGetParameters(window) {
     };
   }
 }
-function shimCreateOffer(window) {
+function shimCreateOffer(window, browserDetails) {
   // https://github.com/webrtcHacks/adapter/issues/998#issuecomment-516921647
   // Firefox ignores the init sendEncodings options passed to addTransceiver
   // https://bugzilla.mozilla.org/show_bug.cgi?id=1396918
   if (!(typeof window === 'object' && window.RTCPeerConnection)) {
     return;
   }
+  // Fixed by https://bugzilla.mozilla.org/show_bug.cgi?id=1401592 in FF110.
+  if (browserDetails.version >= 110) {
+    return;
+  }
   const origCreateOffer = window.RTCPeerConnection.prototype.createOffer;
   window.RTCPeerConnection.prototype.createOffer = function createOffer() {
     if (this.setParametersPromises && this.setParametersPromises.length) {
@@ -10123,13 +10148,17 @@ function shimCreateOffer(window) {
     return origCreateOffer.apply(this, arguments);
   };
 }
-function shimCreateAnswer(window) {
+function shimCreateAnswer(window, browserDetails) {
   // https://github.com/webrtcHacks/adapter/issues/998#issuecomment-516921647
   // Firefox ignores the init sendEncodings options passed to addTransceiver
   // https://bugzilla.mozilla.org/show_bug.cgi?id=1396918
   if (!(typeof window === 'object' && window.RTCPeerConnection)) {
     return;
   }
+  // Fixed by https://bugzilla.mozilla.org/show_bug.cgi?id=1401592 in FF110.
+  if (browserDetails.version >= 110) {
+    return;
+  }
   const origCreateAnswer = window.RTCPeerConnection.prototype.createAnswer;
   window.RTCPeerConnection.prototype.createAnswer = function createAnswer() {
     if (this.setParametersPromises && this.setParametersPromises.length) {
@@ -11291,6 +11320,15 @@ function shimMaxMessageSize(window, browserDetails) {
   if (!window.RTCPeerConnection) {
     return;
   }
+  if (browserDetails.browser === 'chrome' && browserDetails.version > 102) {
+    // Unified plan is supported so no need to do anything.
+    return;
+  }
+  if (browserDetails.browser === 'firefox' && browserDetails.version >= 113) {
+    // Native RTCSctpTransport, see
+    // https://bugzilla.mozilla.org/show_bug.cgi?id=1278299
+    return;
+  }
   if (!('sctp' in window.RTCPeerConnection.prototype)) {
     Object.defineProperty(window.RTCPeerConnection.prototype, 'sctp', {
       get() {
@@ -11427,7 +11465,7 @@ function shimSendThrowTypeError(window, browserDetails) {
   if (!(window.RTCPeerConnection && 'createDataChannel' in window.RTCPeerConnection.prototype)) {
     return;
   }
-  if (browserDetails.browser === 'chrome' && browserDetails.version > 149) {
+  if (browserDetails.browser === 'chrome' && browserDetails.version >= 149) {
     // Fixed by https://issues.chromium.org/issues/490588131
     return;
   }
@@ -11706,10 +11744,10 @@ function adapterFactory() {
       shimSenderGetStats(window);
       shimReceiverGetStats(window);
       shimRTCDataChannel(window);
-      shimAddTransceiver(window);
-      shimGetParameters(window);
-      shimCreateOffer(window);
-      shimCreateAnswer(window);
+      shimAddTransceiver(window, browserDetails);
+      shimGetParameters(window, browserDetails);
+      shimCreateOffer(window, browserDetails);
+      shimCreateAnswer(window, browserDetails);
       shimRTCIceCandidate(window);
       shimConnectionState(window);
       shimMaxMessageSize(window, browserDetails);
@@ -11843,7 +11881,7 @@ function getMatch(exp, ua) {
 }
 function getOSVersion(ua) {
   return ua.includes('mac os') ? getMatch(/\(.+?(\d+_\d+(:?_\d+)?)/, ua, 1).replace(/_/g, '.') : undefined;
-}var version$1 = "2.20.0";const version = version$1;
+}var version$1 = "2.20.1";const version = version$1;
 const protocolVersion = 17;
 /** Initial client protocol. */
 const CLIENT_PROTOCOL_DEFAULT = 0;
@@ -18215,6 +18253,15 @@ class PCTransport extends eventsExports.EventEmitter {
             });
           }
         });
+        // The server's answer sets per-track codec params (e.g. opus `usedtx`) on
+        // the sections mapped to a published track, but leaves the pre-populated
+        // recvonly placeholder sections with defaults. Conform the placeholders so
+        // each shared payload type is consistent across the bundle, otherwise
+        // libwebrtc flags a "bundled payload type collision".
+        const placeholderMids = this.getPlaceholderMids();
+        if (placeholderMids.size > 0) {
+          conformBundledCodecFmtp(sdpParsed.media, media => placeholderMids.has(getMidString(media.mid)));
+        }
         mungedSDP = libExports.write(sdpParsed);
       }
       yield this.setMungedSDP(sd, mungedSDP, true);
@@ -18359,6 +18406,15 @@ class PCTransport extends eventsExports.EventEmitter {
             });
           }
         });
+        // Conform the placeholder sections (pre-populated, or reverted after an
+        // unpublish) so every shared payload type carries identical fmtp across the
+        // bundle, otherwise libwebrtc flags a "bundled payload type collision".
+        // Detection is by transceiver (mids are stable across renegotiations) since
+        // an unpublished section keeps its `a=msid`.
+        const placeholderMids = this.getPlaceholderMids();
+        if (placeholderMids.size > 0) {
+          conformBundledCodecFmtp(sdpParsed.media, media => placeholderMids.has(getMidString(media.mid)));
+        }
         if (this.latestOfferId > offerId) {
           this.log.warn('latestOfferId mismatch', Object.assign(Object.assign({}, this.logContext), {
             latestOfferId: this.latestOfferId,
@@ -18388,6 +18444,17 @@ class PCTransport extends eventsExports.EventEmitter {
       return answer;
     });
   }
+  /**
+   * Returns the mids of transceivers that carry no outgoing track on this
+   * (publisher) connection: the pre-populated placeholders added by
+   * `RTCEngine.applyInitialPublisherLayout`, plus any transceiver that was used
+   * for a track and reverted on unpublish. Their codec fmtp is conformed to the
+   * published tracks so a shared payload type stays consistent across the bundle.
+   */
+  getPlaceholderMids() {
+    var _a, _b;
+    return placeholderMidsFromTransceivers((_b = (_a = this._pc) === null || _a === void 0 ? void 0 : _a.getTransceivers()) !== null && _b !== void 0 ? _b : []);
+  }
   createDataChannel(label, dataChannelDict) {
     return this.pc.createDataChannel(label, dataChannelDict);
   }
@@ -18610,6 +18677,79 @@ function ensureAudioNackAndStereo(media, stereoMids, nackMids) {
     }
   }
 }
+/**
+ * Returns the mids of transceivers that carry no outgoing track: the
+ * pre-populated placeholders added by `RTCEngine.applyInitialPublisherLayout`,
+ * plus any transceiver that was used for a track and reverted on unpublish. The
+ * `sender.track` check is the reliable signal — an unpublished section keeps its
+ * `a=msid` (and its stale send-derived fmtp), so it can't be told apart from a
+ * real send by SDP alone. Transceiver mids are stable across renegotiations, so
+ * this works for every offer/answer after the first.
+ * @internal
+ */
+function placeholderMidsFromTransceivers(transceivers) {
+  const mids = new Set();
+  for (const transceiver of transceivers) {
+    if (transceiver.mid && !transceiver.sender.track) {
+      mids.add(transceiver.mid);
+    }
+  }
+  return mids;
+}
+/**
+ * Within a BUNDLE group a payload type must map to identical codec parameters
+ * across every m-line. When the same payload type carries different fmtp between
+ * sections — e.g. opus `usedtx=1` on the published microphone but not on the
+ * pre-populated recvonly placeholders, or H.265 with different `level-id` between
+ * a published video track and a placeholder — libwebrtc flags a "bundled payload
+ * type collision".
+ *
+ * Rewrite the placeholder sections so every shared payload type carries the
+ * same fmtp. Real (non-placeholder) sections always win the canonical value, so
+ * a published track's encoder parameters are never altered. When no real
+ * section declares a payload type — e.g. a placeholder that was reused for a
+ * track and then reverted to recvonly keeps its send-derived `level-id` while
+ * fresh placeholders use the default — the placeholders still converge on the
+ * first value seen, so two placeholders can't disagree either. Only placeholder
+ * sections are ever rewritten, and it is codec-agnostic (opus, H.265, ...).
+ * `isPlaceholder` identifies the sections to conform.
+ * @internal
+ */
+function conformBundledCodecFmtp(media, isPlaceholder) {
+  var _a, _b;
+  // Canonical fmtp per payload type. Payload types are unique within a BUNDLE
+  // group, so keying by payload alone (across audio and video) is safe. A real
+  // section's value always takes precedence; otherwise the first placeholder
+  // value seen is used so divergent placeholders still converge.
+  const canonicalByPayload = new Map();
+  const fromRealSection = new Set();
+  for (const m of media) {
+    const placeholder = isPlaceholder(m);
+    for (const fmtp of (_a = m.fmtp) !== null && _a !== void 0 ? _a : []) {
+      if (!placeholder) {
+        canonicalByPayload.set(fmtp.payload, fmtp.config);
+        fromRealSection.add(fmtp.payload);
+      } else if (!canonicalByPayload.has(fmtp.payload)) {
+        canonicalByPayload.set(fmtp.payload, fmtp.config);
+      }
+    }
+  }
+  if (canonicalByPayload.size === 0) {
+    return;
+  }
+  // Conform placeholder sections to the canonical fmtp for each shared payload.
+  for (const m of media) {
+    if (!isPlaceholder(m)) {
+      continue;
+    }
+    for (const fmtp of (_b = m.fmtp) !== null && _b !== void 0 ? _b : []) {
+      const config = canonicalByPayload.get(fmtp.payload);
+      if (config !== undefined && fmtp.config !== config) {
+        fmtp.config = config;
+      }
+    }
+  }
+}
 function extractStereoAndNackAudioFromOffer(offer) {
   var _a;
   const stereoMids = [];