livekit-client 2.9.0 → 2.9.2

package/dist/livekit-client.esm.mjs

@@ -6666,6 +6666,18 @@ PERFORMANCE OF THIS SOFTWARE.
 /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
 
 
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
 function __awaiter(thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -11150,7 +11162,7 @@ function getOSVersion(ua) {
   return ua.includes('mac os') ? getMatch(/\(.+?(\d+_\d+(:?_\d+)?)/, ua, 1).replace(/_/g, '.') : undefined;
 }
 
-var version$1 = "2.9.0";
+var version$1 = "2.9.2";
 
 const version = version$1;
 const protocolVersion = 15;
@@ -12130,6 +12142,21 @@ function isLocalParticipant(p) {
 function isRemoteParticipant(p) {
   return !p.isLocal;
 }
+function splitUtf8(s, n) {
+  // adapted from https://stackoverflow.com/a/6043797
+  const result = [];
+  while (s.length > n) {
+    let k = n;
+    // Move back to find the start of a UTF-8 character
+    while ((s.charCodeAt(k) & 0xc0) === 0x80) {
+      k--;
+    }
+    result.push(s.slice(0, k));
+    s = s.slice(k);
+  }
+  result.push(s);
+  return result;
+}
 
 function mergeDefaultOptions(options, audioDefaults, videoDefaults) {
   var _a, _b, _c;
@@ -15557,6 +15584,11 @@ class LocalTrack extends Track {
         if (!constraints) {
           constraints = this._constraints;
         }
+        const _a = this._constraints,
+          {
+            deviceId
+          } = _a,
+          otherConstraints = __rest(_a, ["deviceId"]);
         this.log.debug('restarting track with constraints', Object.assign(Object.assign({}, this.logContext), {
           constraints
         }));
@@ -15565,9 +15597,13 @@ class LocalTrack extends Track {
           video: false
         };
         if (this.kind === Track.Kind.Video) {
-          streamConstraints.video = constraints;
+          streamConstraints.video = deviceId ? {
+            deviceId
+          } : true;
         } else {
-          streamConstraints.audio = constraints;
+          streamConstraints.audio = deviceId ? {
+            deviceId
+          } : true;
         }
         // these steps are duplicated from setMediaStreamTrack because we must stop
         // the previous tracks before new tracks can be acquired
@@ -15582,6 +15618,7 @@ class LocalTrack extends Track {
         // create new track and attach
         const mediaStream = yield navigator.mediaDevices.getUserMedia(streamConstraints);
         const newTrack = mediaStream.getTracks()[0];
+        yield newTrack.applyConstraints(otherConstraints);
         newTrack.addEventListener('ended', this.handleEnded);
         this.log.debug('re-acquired MediaStreamTrack', this.logContext);
         yield this.setMediaStreamTrack(newTrack);
@@ -16191,6 +16228,10 @@ function computeTrackBackupEncodings(track, videoCodec, opts) {
   const settings = track.mediaStreamTrack.getSettings();
   const width = (_a = settings.width) !== null && _a !== void 0 ? _a : (_b = track.dimensions) === null || _b === void 0 ? void 0 : _b.width;
   const height = (_c = settings.height) !== null && _c !== void 0 ? _c : (_d = track.dimensions) === null || _d === void 0 ? void 0 : _d.height;
+  // disable simulcast for screenshare backup codec since L1Tx is used by primary codec
+  if (track.source === Track.Source.ScreenShare && opts.simulcast) {
+    opts.simulcast = false;
+  }
   const encodings = computeVideoEncodings(track.source === Track.Source.ScreenShare, width, height, opts);
   return encodings;
 }
@@ -18239,11 +18280,13 @@ class ByteStreamReader extends BaseStreamReader {
         }
       }),
       return() {
-        reader.releaseLock();
-        return {
-          done: true,
-          value: undefined
-        };
+        return __awaiter(this, void 0, void 0, function* () {
+          reader.releaseLock();
+          return {
+            done: true,
+            value: undefined
+          };
+        });
       }
     };
   }
@@ -18322,11 +18365,7 @@ class TextStreamReader extends BaseStreamReader {
             this.handleChunkReceived(value);
             return {
               done: false,
-              value: {
-                index: bigIntToNumber(value.chunkIndex),
-                current: decoder.decode(value.content),
-                collected: Array.from(this.receivedChunks.values()).sort((a, b) => bigIntToNumber(a.chunkIndex) - bigIntToNumber(b.chunkIndex)).map(chunk => decoder.decode(chunk.content)).join('')
-              }
+              value: decoder.decode(value.content)
             };
           }
         } catch (error) {
@@ -18338,26 +18377,26 @@ class TextStreamReader extends BaseStreamReader {
         }
       }),
       return() {
-        reader.releaseLock();
-        return {
-          done: true,
-          value: undefined
-        };
+        return __awaiter(this, void 0, void 0, function* () {
+          reader.releaseLock();
+          return {
+            done: true,
+            value: undefined
+          };
+        });
       }
     };
   }
   readAll() {
     return __awaiter(this, void 0, void 0, function* () {
       var _a, e_2, _b, _c;
-      let latestString = '';
+      let finalString = '';
       try {
         for (var _d = true, _e = __asyncValues(this), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
           _c = _f.value;
           _d = false;
-          const {
-            collected
-          } = _c;
-          latestString = collected;
+          const chunk = _c;
+          finalString += chunk;
         }
       } catch (e_2_1) {
         e_2 = {
@@ -18370,7 +18409,7 @@ class TextStreamReader extends BaseStreamReader {
           if (e_2) throw e_2.error;
         }
       }
-      return latestString;
+      return finalString;
     });
   }
 }
@@ -18383,7 +18422,7 @@ class BaseStreamWriter {
     this.info = info;
   }
   write(chunk) {
-    return this.defaultWriter.write([chunk]);
+    return this.defaultWriter.write(chunk);
   }
   close() {
     return __awaiter(this, void 0, void 0, function* () {
@@ -20790,14 +20829,9 @@ class LocalParticipant extends Participant {
         topic: options === null || options === void 0 ? void 0 : options.topic,
         attachedStreamIds: fileIds
       });
-      const textChunkSize = Math.floor(STREAM_CHUNK_SIZE / 4); // utf8 is at most 4 bytes long, so play it safe and take a quarter of the byte size to slice the string
-      const totalTextChunks = Math.ceil(totalTextLength / textChunkSize);
-      for (let i = 0; i < totalTextChunks; i++) {
-        const chunkData = text.slice(i * textChunkSize, Math.min((i + 1) * textChunkSize, totalTextLength));
-        yield this.engine.waitForBufferStatusLow(DataPacket_Kind.RELIABLE);
-        yield writer.write(chunkData);
-        handleProgress(Math.ceil((i + 1) / totalTextChunks), 0);
-      }
+      yield writer.write(text);
+      // set text part of progress to 1
+      handleProgress(1, 0);
       yield writer.close();
       if ((options === null || options === void 0 ? void 0 : options.attachments) && fileIds) {
         yield Promise.all(options.attachments.map((file, idx) => __awaiter(this, void 0, void 0, function* () {
@@ -20857,32 +20891,26 @@ class LocalParticipant extends Participant {
       const localP = this;
       const writableStream = new WritableStream({
         // Implement the sink
-        write(_ref3) {
-          let [textChunk] = _ref3;
-          var _a;
-          const textInBytes = new TextEncoder().encode(textChunk);
-          if (textInBytes.byteLength > STREAM_CHUNK_SIZE) {
-            (_a = this.abort) === null || _a === void 0 ? void 0 : _a.call(this);
-            throw new Error('chunk size too large');
-          }
-          return new Promise(resolve => __awaiter(this, void 0, void 0, function* () {
-            yield localP.engine.waitForBufferStatusLow(DataPacket_Kind.RELIABLE);
-            const chunk = new DataStream_Chunk({
-              content: textInBytes,
-              streamId,
-              chunkIndex: numberToBigInt(chunkId)
-            });
-            const chunkPacket = new DataPacket({
-              destinationIdentities,
-              value: {
-                case: 'streamChunk',
-                value: chunk
-              }
-            });
-            yield localP.engine.sendDataPacket(chunkPacket, DataPacket_Kind.RELIABLE);
-            chunkId += 1;
-            resolve();
-          }));
+        write(text) {
+          return __awaiter(this, void 0, void 0, function* () {
+            for (const textChunk in splitUtf8(text, STREAM_CHUNK_SIZE)) {
+              yield localP.engine.waitForBufferStatusLow(DataPacket_Kind.RELIABLE);
+              const chunk = new DataStream_Chunk({
+                content: new TextEncoder().encode(textChunk),
+                streamId,
+                chunkIndex: numberToBigInt(chunkId)
+              });
+              const chunkPacket = new DataPacket({
+                destinationIdentities,
+                value: {
+                  case: 'streamChunk',
+                  value: chunk
+                }
+              });
+              yield localP.engine.sendDataPacket(chunkPacket, DataPacket_Kind.RELIABLE);
+              chunkId += 1;
+            }
+          });
         },
         close() {
           return __awaiter(this, void 0, void 0, function* () {
@@ -20996,14 +21024,14 @@ class LocalParticipant extends Participant {
    * @throws Error on failure. Details in `message`.
    */
   performRpc(_a) {
-    return __awaiter(this, arguments, void 0, function (_ref4) {
+    return __awaiter(this, arguments, void 0, function (_ref3) {
       var _this5 = this;
       let {
         destinationIdentity,
         method,
         payload,
         responseTimeout = 10000
-      } = _ref4;
+      } = _ref3;
       return function* () {
         const maxRoundTripLatency = 2000;
         return new Promise((resolve, reject) => __awaiter(_this5, void 0, void 0, function* () {
@@ -21208,8 +21236,8 @@ class LocalParticipant extends Participant {
       const waitForPendingTimeout = 10000;
       const startTime = Date.now();
       while (Date.now() < startTime + waitForPendingTimeout) {
-        const publishPromiseEntry = Array.from(this.pendingPublishPromises.entries()).find(_ref5 => {
-          let [pendingTrack] = _ref5;
+        const publishPromiseEntry = Array.from(this.pendingPublishPromises.entries()).find(_ref4 => {
+          let [pendingTrack] = _ref4;
           return pendingTrack.source === source;
         });
         if (publishPromiseEntry) {
@@ -23666,15 +23694,13 @@ class Checker extends eventsExports.EventEmitter {
     super();
     this.status = CheckStatus.IDLE;
     this.logs = [];
-    this.errorsAsWarnings = false;
+    this.options = {};
     this.url = url;
     this.token = token;
     this.name = this.constructor.name;
     this.room = new Room(options.roomOptions);
     this.connectOptions = options.connectOptions;
-    if (options.errorsAsWarnings) {
-      this.errorsAsWarnings = options.errorsAsWarnings;
-    }
+    this.options = options;
   }
   run(onComplete) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -23686,7 +23712,7 @@ class Checker extends eventsExports.EventEmitter {
         yield this.perform();
       } catch (err) {
         if (err instanceof Error) {
-          if (this.errorsAsWarnings) {
+          if (this.options.errorsAsWarnings) {
             this.appendWarning(err.message);
           } else {
             this.appendError(err.message);
@@ -23709,12 +23735,15 @@ class Checker extends eventsExports.EventEmitter {
   isSuccess() {
     return !this.logs.some(l => l.level === 'error');
   }
-  connect() {
+  connect(url) {
     return __awaiter(this, void 0, void 0, function* () {
       if (this.room.state === ConnectionState.Connected) {
         return this.room;
       }
-      yield this.room.connect(this.url, this.token, this.connectOptions);
+      if (!url) {
+        url = this.url;
+      }
+      yield this.room.connect(url, this.token, this.connectOptions);
       return this.room;
     });
   }
@@ -23730,6 +23759,33 @@ class Checker extends eventsExports.EventEmitter {
   skip() {
     this.setStatus(CheckStatus.SKIPPED);
   }
+  switchProtocol(protocol) {
+    return __awaiter(this, void 0, void 0, function* () {
+      let hasReconnecting = false;
+      let hasReconnected = false;
+      this.room.on(RoomEvent.Reconnecting, () => {
+        hasReconnecting = true;
+      });
+      this.room.once(RoomEvent.Reconnected, () => {
+        hasReconnected = true;
+      });
+      this.room.simulateScenario("force-".concat(protocol));
+      yield new Promise(resolve => setTimeout(resolve, 1000));
+      if (!hasReconnecting) {
+        // no need to wait for reconnection
+        return;
+      }
+      // wait for 10 seconds for reconnection
+      const timeout = Date.now() + 10000;
+      while (Date.now() < timeout) {
+        if (hasReconnected) {
+          return;
+        }
+        yield sleep(100);
+      }
+      throw new Error("Could not reconnect using ".concat(protocol, " protocol after 10 seconds"));
+    });
+  }
   appendMessage(message) {
     this.logs.push({
       level: 'info',
@@ -23769,6 +23825,201 @@ class Checker extends eventsExports.EventEmitter {
   }
 }
 
+/**
+ * Checks for connections quality to closests Cloud regions and determining the best quality
+ */
+class CloudRegionCheck extends Checker {
+  get description() {
+    return 'Cloud regions';
+  }
+  perform() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const regionProvider = new RegionUrlProvider(this.url, this.token);
+      if (!regionProvider.isCloud()) {
+        this.skip();
+        return;
+      }
+      const regionStats = [];
+      const seenUrls = new Set();
+      for (let i = 0; i < 3; i++) {
+        const regionUrl = yield regionProvider.getNextBestRegionUrl();
+        if (!regionUrl) {
+          break;
+        }
+        if (seenUrls.has(regionUrl)) {
+          continue;
+        }
+        seenUrls.add(regionUrl);
+        const stats = yield this.checkCloudRegion(regionUrl);
+        this.appendMessage("".concat(stats.region, " RTT: ").concat(stats.rtt, "ms, duration: ").concat(stats.duration, "ms"));
+        regionStats.push(stats);
+      }
+      regionStats.sort((a, b) => {
+        return (a.duration - b.duration) * 0.5 + (a.rtt - b.rtt) * 0.5;
+      });
+      const bestRegion = regionStats[0];
+      this.bestStats = bestRegion;
+      this.appendMessage("best Cloud region: ".concat(bestRegion.region));
+    });
+  }
+  getInfo() {
+    const info = super.getInfo();
+    info.data = this.bestStats;
+    return info;
+  }
+  checkCloudRegion(url) {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a, _b;
+      yield this.connect(url);
+      if (this.options.protocol === 'tcp') {
+        yield this.switchProtocol('tcp');
+      }
+      const region = (_a = this.room.serverInfo) === null || _a === void 0 ? void 0 : _a.region;
+      if (!region) {
+        throw new Error('Region not found');
+      }
+      const writer = yield this.room.localParticipant.streamText({
+        topic: 'test'
+      });
+      const chunkSize = 1000; // each chunk is about 1000 bytes
+      const totalSize = 1000000; // approximately 1MB of data
+      const numChunks = totalSize / chunkSize; // will yield 1000 chunks
+      const chunkData = 'A'.repeat(chunkSize); // create a string of 1000 'A' characters
+      const startTime = Date.now();
+      for (let i = 0; i < numChunks; i++) {
+        yield writer.write(chunkData);
+      }
+      yield writer.close();
+      const endTime = Date.now();
+      const stats = yield (_b = this.room.engine.pcManager) === null || _b === void 0 ? void 0 : _b.publisher.getStats();
+      const regionStats = {
+        region: region,
+        rtt: 10000,
+        duration: endTime - startTime
+      };
+      stats === null || stats === void 0 ? void 0 : stats.forEach(stat => {
+        if (stat.type === 'candidate-pair' && stat.nominated) {
+          regionStats.rtt = stat.currentRoundTripTime * 1000;
+        }
+      });
+      yield this.disconnect();
+      return regionStats;
+    });
+  }
+}
+
+const TEST_DURATION = 10000;
+class ConnectionProtocolCheck extends Checker {
+  get description() {
+    return 'Connection via UDP vs TCP';
+  }
+  perform() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const udpStats = yield this.checkConnectionProtocol('udp');
+      const tcpStats = yield this.checkConnectionProtocol('tcp');
+      this.bestStats = udpStats;
+      // udp should is the better protocol typically. however, we'd prefer TCP when either of these conditions are true:
+      // 1. the bandwidth limitation is worse on UDP by 500ms
+      // 2. the packet loss is higher on UDP by 1%
+      if (udpStats.qualityLimitationDurations.bandwidth - tcpStats.qualityLimitationDurations.bandwidth > 0.5 || (udpStats.packetsLost - tcpStats.packetsLost) / udpStats.packetsSent > 0.01) {
+        this.appendMessage('best connection quality via tcp');
+        this.bestStats = tcpStats;
+      } else {
+        this.appendMessage('best connection quality via udp');
+      }
+      const stats = this.bestStats;
+      this.appendMessage("upstream bitrate: ".concat((stats.bitrateTotal / stats.count / 1000 / 1000).toFixed(2), " mbps"));
+      this.appendMessage("RTT: ".concat((stats.rttTotal / stats.count * 1000).toFixed(2), " ms"));
+      this.appendMessage("jitter: ".concat((stats.jitterTotal / stats.count * 1000).toFixed(2), " ms"));
+      if (stats.packetsLost > 0) {
+        this.appendWarning("packets lost: ".concat((stats.packetsLost / stats.packetsSent * 100).toFixed(2), "%"));
+      }
+      if (stats.qualityLimitationDurations.bandwidth > 1) {
+        this.appendWarning("bandwidth limited ".concat((stats.qualityLimitationDurations.bandwidth / (TEST_DURATION / 1000) * 100).toFixed(2), "%"));
+      }
+      if (stats.qualityLimitationDurations.cpu > 0) {
+        this.appendWarning("cpu limited ".concat((stats.qualityLimitationDurations.cpu / (TEST_DURATION / 1000) * 100).toFixed(2), "%"));
+      }
+    });
+  }
+  getInfo() {
+    const info = super.getInfo();
+    info.data = this.bestStats;
+    return info;
+  }
+  checkConnectionProtocol(protocol) {
+    return __awaiter(this, void 0, void 0, function* () {
+      yield this.connect();
+      if (protocol === 'tcp') {
+        yield this.switchProtocol('tcp');
+      } else {
+        yield this.switchProtocol('udp');
+      }
+      // create a canvas with animated content
+      const canvas = document.createElement('canvas');
+      canvas.width = 1280;
+      canvas.height = 720;
+      const ctx = canvas.getContext('2d');
+      if (!ctx) {
+        throw new Error('Could not get canvas context');
+      }
+      let hue = 0;
+      const animate = () => {
+        hue = (hue + 1) % 360;
+        ctx.fillStyle = "hsl(".concat(hue, ", 100%, 50%)");
+        ctx.fillRect(0, 0, canvas.width, canvas.height);
+        requestAnimationFrame(animate);
+      };
+      animate();
+      // create video track from canvas
+      const stream = canvas.captureStream(30); // 30fps
+      const videoTrack = stream.getVideoTracks()[0];
+      // publish to room
+      const pub = yield this.room.localParticipant.publishTrack(videoTrack, {
+        simulcast: false,
+        degradationPreference: 'maintain-resolution',
+        videoEncoding: {
+          maxBitrate: 2000000
+        }
+      });
+      const track = pub.track;
+      const protocolStats = {
+        protocol,
+        packetsLost: 0,
+        packetsSent: 0,
+        qualityLimitationDurations: {},
+        rttTotal: 0,
+        jitterTotal: 0,
+        bitrateTotal: 0,
+        count: 0
+      };
+      // gather stats once a second
+      const interval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+        const stats = yield track.getRTCStatsReport();
+        stats === null || stats === void 0 ? void 0 : stats.forEach(stat => {
+          if (stat.type === 'outbound-rtp') {
+            protocolStats.packetsSent = stat.packetsSent;
+            protocolStats.qualityLimitationDurations = stat.qualityLimitationDurations;
+            protocolStats.bitrateTotal += stat.targetBitrate;
+            protocolStats.count++;
+          } else if (stat.type === 'remote-inbound-rtp') {
+            protocolStats.packetsLost = stat.packetsLost;
+            protocolStats.rttTotal += stat.roundTripTime;
+            protocolStats.jitterTotal += stat.jitter;
+          }
+        });
+      }), 1000);
+      // wait a bit to gather stats
+      yield new Promise(resolve => setTimeout(resolve, TEST_DURATION));
+      clearInterval(interval);
+      videoTrack.stop();
+      canvas.remove();
+      yield this.disconnect();
+      return protocolStats;
+    });
+  }
+}
+
 /**
  * Creates a local video and audio track at the same time. When acquiring both
  * audio and video tracks together, it'll display a single permission prompt to
@@ -23814,11 +24065,12 @@ function createLocalTracks(options) {
       }
       // update the constraints with the device id the user gave permissions to in the permission prompt
       // otherwise each track restart (e.g. mute - unmute) will try to initialize the device again -> causing additional permission prompts
-      if (trackConstraints) {
-        trackConstraints.deviceId = mediaStreamTrack.getSettings().deviceId;
-      } else {
+      const newDeviceId = mediaStreamTrack.getSettings().deviceId;
+      if ((trackConstraints === null || trackConstraints === void 0 ? void 0 : trackConstraints.deviceId) && unwrapConstraint(trackConstraints.deviceId) !== newDeviceId) {
+        trackConstraints.deviceId = newDeviceId;
+      } else if (!trackConstraints) {
         trackConstraints = {
-          deviceId: mediaStreamTrack.getSettings().deviceId
+          deviceId: newDeviceId
         };
       }
       const track = mediaTrackToLocalTrack(mediaStreamTrack, trackConstraints);
@@ -23902,6 +24154,11 @@ class PublishAudioCheck extends Checker {
       var _a;
       const room = yield this.connect();
       const track = yield createLocalAudioTrack();
+      const trackIsSilent = yield detectSilence(track, 1000);
+      if (trackIsSilent) {
+        throw new Error('unable to detect audio from microphone');
+      }
+      this.appendMessage('detected audio from microphone');
       room.localParticipant.publishTrack(track);
       // wait for a few seconds to publish
       yield new Promise(resolve => setTimeout(resolve, 3000));
@@ -23933,6 +24190,8 @@ class PublishVideoCheck extends Checker {
       var _a;
       const room = yield this.connect();
       const track = yield createLocalVideoTrack();
+      // check if we have video from camera
+      yield this.checkForVideo(track.mediaStreamTrack);
       room.localParticipant.publishTrack(track);
       // wait for a few seconds to publish
       yield new Promise(resolve => setTimeout(resolve, 5000));
@@ -23953,6 +24212,50 @@ class PublishVideoCheck extends Checker {
       this.appendMessage("published ".concat(numPackets, " video packets"));
     });
   }
+  checkForVideo(track) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const stream = new MediaStream();
+      stream.addTrack(track.clone());
+      // Create video element to check frames
+      const video = document.createElement('video');
+      video.srcObject = stream;
+      video.muted = true;
+      yield new Promise(resolve => {
+        video.onplay = () => {
+          setTimeout(() => {
+            var _a, _b, _c, _d;
+            const canvas = document.createElement('canvas');
+            const settings = track.getSettings();
+            const width = (_b = (_a = settings.width) !== null && _a !== void 0 ? _a : video.videoWidth) !== null && _b !== void 0 ? _b : 1280;
+            const height = (_d = (_c = settings.height) !== null && _c !== void 0 ? _c : video.videoHeight) !== null && _d !== void 0 ? _d : 720;
+            canvas.width = width;
+            canvas.height = height;
+            const ctx = canvas.getContext('2d');
+            // Draw video frame to canvas
+            ctx.drawImage(video, 0, 0);
+            // Get image data and check if all pixels are black
+            const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+            const data = imageData.data;
+            let isAllBlack = true;
+            for (let i = 0; i < data.length; i += 4) {
+              if (data[i] !== 0 || data[i + 1] !== 0 || data[i + 2] !== 0) {
+                isAllBlack = false;
+                break;
+              }
+            }
+            if (isAllBlack) {
+              this.appendError('camera appears to be producing only black frames');
+            } else {
+              this.appendMessage('received video frames');
+            }
+            resolve();
+          }, 1000);
+        };
+        video.play();
+      });
+      video.remove();
+    });
+  }
 }
 
 class ReconnectCheck extends Checker {
@@ -24218,6 +24521,21 @@ class ConnectionCheck extends eventsExports.EventEmitter {
       return this.createAndRunCheck(PublishVideoCheck);
     });
   }
+  checkConnectionProtocol() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const info = yield this.createAndRunCheck(ConnectionProtocolCheck);
+      if (info.data && 'protocol' in info.data) {
+        const stats = info.data;
+        this.options.protocol = stats.protocol;
+      }
+      return info;
+    });
+  }
+  checkCloudRegion() {
+    return __awaiter(this, void 0, void 0, function* () {
+      return this.createAndRunCheck(CloudRegionCheck);
+    });
+  }
 }
 
 /**
@@ -24301,5 +24619,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, DefaultReconnectPolicy, DeviceUnsupportedError, DisconnectReason, EncryptionEvent, EngineEvent, ExternalE2EEKeyProvider, KeyHandlerEvent, KeyProviderEvent, LivekitError, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalVideoTrack, LogLevel, LoggerNames, MediaDeviceFailure, _ as Mutex, NegotiationError, Participant, ParticipantEvent, ParticipantInfo_Kind as ParticipantKind, PublishDataError, RemoteAudioTrack, RemoteParticipant, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, RoomEvent, RpcError, ScreenSharePresets, SignalRequestError, SubscriptionError, Track, TrackEvent, TrackInvalidError, TrackPublication, UnexpectedConnectionState, UnsupportedServer, VideoPreset, VideoPresets, VideoPresets43, VideoQuality, attachToElement, compareVersions, createAudioAnalyser, createE2EEKey, createKeyMaterialFromBuffer, createKeyMaterialFromString, createLocalAudioTrack, createLocalScreenTracks, createLocalTracks, createLocalVideoTrack, deriveKeys, detachTrack, facingModeFromDeviceLabel, facingModeFromLocalTrack, getBrowser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, getLogger, importKey, isAudioTrack, isBackupCodec, isBrowserSupported, isE2EESupported, isInsertableStreamSupported, isLocalParticipant, isLocalTrack, isRemoteParticipant, isRemoteTrack, isScriptTransformSupported, 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, DefaultReconnectPolicy, DeviceUnsupportedError, DisconnectReason, EncryptionEvent, EngineEvent, ExternalE2EEKeyProvider, KeyHandlerEvent, KeyProviderEvent, LivekitError, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalVideoTrack, LogLevel, LoggerNames, MediaDeviceFailure, _ as Mutex, NegotiationError, Participant, ParticipantEvent, ParticipantInfo_Kind as ParticipantKind, PublishDataError, RemoteAudioTrack, RemoteParticipant, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, RoomEvent, RpcError, ScreenSharePresets, SignalRequestError, SubscriptionError, Track, TrackEvent, TrackInvalidError, TrackPublication, TrackType, UnexpectedConnectionState, UnsupportedServer, VideoPreset, VideoPresets, VideoPresets43, VideoQuality, attachToElement, compareVersions, createAudioAnalyser, createE2EEKey, createKeyMaterialFromBuffer, createKeyMaterialFromString, createLocalAudioTrack, createLocalScreenTracks, createLocalTracks, createLocalVideoTrack, deriveKeys, detachTrack, facingModeFromDeviceLabel, facingModeFromLocalTrack, getBrowser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, getLogger, importKey, isAudioTrack, isBackupCodec, isBrowserSupported, isE2EESupported, isInsertableStreamSupported, isLocalParticipant, isLocalTrack, isRemoteParticipant, isRemoteTrack, isScriptTransformSupported, isVideoFrame, isVideoTrack, needsRbspUnescaping, parseRbsp, protocolVersion, ratchet, setLogExtension, setLogLevel, supportsAV1, supportsAdaptiveStream, supportsDynacast, supportsVP9, version, videoCodecs, writeRbsp };
 //# sourceMappingURL=livekit-client.esm.mjs.map