livekit-client 2.9.9 → 2.11.0

package/dist/livekit-client.esm.mjs

@@ -15,9 +15,9 @@ function _mergeNamespaces(n, m) {
 
 var e = Object.defineProperty;
 var h = (i, s, t) => s in i ? e(i, s, {
-  enumerable: !0,
-  configurable: !0,
-  writable: !0,
+  enumerable: true,
+  configurable: true,
+  writable: true,
   value: t
 }) : i[s] = t;
 var o = (i, s, t) => h(i, typeof s != "symbol" ? s + "" : s, t);
@@ -64,10 +64,10 @@ function assert(condition, msg) {
   }
 }
 const FLOAT32_MAX = 3.4028234663852886e38,
-  FLOAT32_MIN = -3.4028234663852886e38,
+  FLOAT32_MIN = -34028234663852886e22,
   UINT32_MAX = 0xffffffff,
   INT32_MAX = 0x7fffffff,
-  INT32_MIN = -0x80000000;
+  INT32_MIN = -2147483648;
 /**
  * Assert a valid signed protobuf 32-bit integer.
  */
@@ -3772,10 +3772,13 @@ const EventMetric = /* @__PURE__ */proto3.makeMessageType("livekit.EventMetric",
 }]);
 const BackupCodecPolicy$1 = /* @__PURE__ */proto3.makeEnum("livekit.BackupCodecPolicy", [{
   no: 0,
-  name: "REGRESSION"
+  name: "PREFER_REGRESSION"
 }, {
   no: 1,
   name: "SIMULCAST"
+}, {
+  no: 2,
+  name: "REGRESSION"
 }]);
 const TrackType = /* @__PURE__ */proto3.makeEnum("livekit.TrackType", [{
   no: 0,
@@ -4169,6 +4172,12 @@ const ParticipantInfo = /* @__PURE__ */proto3.makeMessageType("livekit.Participa
   name: "disconnect_reason",
   kind: "enum",
   T: proto3.getEnumType(DisconnectReason)
+}, {
+  no: 18,
+  name: "kind_details",
+  kind: "enum",
+  T: proto3.getEnumType(ParticipantInfo_KindDetail),
+  repeated: true
 }]);
 const ParticipantInfo_State = /* @__PURE__ */proto3.makeEnum("livekit.ParticipantInfo.State", [{
   no: 0,
@@ -4199,6 +4208,13 @@ const ParticipantInfo_Kind = /* @__PURE__ */proto3.makeEnum("livekit.Participant
   no: 4,
   name: "AGENT"
 }]);
+const ParticipantInfo_KindDetail = /* @__PURE__ */proto3.makeEnum("livekit.ParticipantInfo.KindDetail", [{
+  no: 0,
+  name: "CLOUD_AGENT"
+}, {
+  no: 1,
+  name: "FORWARDED"
+}]);
 const Encryption_Type = /* @__PURE__ */proto3.makeEnum("livekit.Encryption.Type", [{
   no: 0,
   name: "NONE"
@@ -11011,6 +11027,7 @@ var EngineEvent;
   EngineEvent["LocalTrackSubscribed"] = "localTrackSubscribed";
   EngineEvent["Offline"] = "offline";
   EngineEvent["SignalRequestResponse"] = "signalRequestResponse";
+  EngineEvent["SignalConnected"] = "signalConnected";
 })(EngineEvent || (EngineEvent = {}));
 var TrackEvent;
 (function (TrackEvent) {
@@ -11169,7 +11186,7 @@ function getOSVersion(ua) {
   return ua.includes('mac os') ? getMatch(/\(.+?(\d+_\d+(:?_\d+)?)/, ua, 1).replace(/_/g, '.') : undefined;
 }
 
-var version$1 = "2.9.9";
+var version$1 = "2.11.0";
 
 const version = version$1;
 const protocolVersion = 15;
@@ -11567,7 +11584,7 @@ function detachTrack(track, element) {
     }
   }
   Track.streamStateFromProto = streamStateFromProto;
-})(Track);
+})(Track || (Track = {}));
 
 class VideoPreset {
   constructor(widthOrOptions, height, maxBitrate, maxFramerate, priority) {
@@ -11609,8 +11626,12 @@ function isBackupCodec(codec) {
 }
 var BackupCodecPolicy;
 (function (BackupCodecPolicy) {
-  BackupCodecPolicy[BackupCodecPolicy["REGRESSION"] = 0] = "REGRESSION";
+  // codec regression is preferred, the sfu will try to regress codec if possible but not guaranteed
+  BackupCodecPolicy[BackupCodecPolicy["PREFER_REGRESSION"] = 0] = "PREFER_REGRESSION";
+  // multi-codec simulcast, publish both primary and backup codec at the same time
   BackupCodecPolicy[BackupCodecPolicy["SIMULCAST"] = 1] = "SIMULCAST";
+  // always use backup codec only
+  BackupCodecPolicy[BackupCodecPolicy["REGRESSION"] = 2] = "REGRESSION";
 })(BackupCodecPolicy || (BackupCodecPolicy = {}));
 var AudioPresets;
 (function (AudioPresets) {
@@ -12041,12 +12062,6 @@ function unwrapConstraint(constraint) {
   }
   throw Error('could not unwrap constraint');
 }
-function toWebsocketUrl(url) {
-  if (url.startsWith('http')) {
-    return url.replace(/^(http)/, 'ws');
-  }
-  return url;
-}
 function toHttpUrl(url) {
   if (url.startsWith('ws')) {
     return url.replace(/^(ws)/, 'http');
@@ -12187,14 +12202,18 @@ function mergeDefaultOptions(options, audioDefaults, videoDefaults) {
   // use defaults
   if (clonedOptions.audio) {
     mergeObjectWithoutOverwriting(clonedOptions.audio, audioDefaults);
-    (_b = (_d = clonedOptions.audio).deviceId) !== null && _b !== void 0 ? _b : _d.deviceId = 'default';
+    (_b = (_d = clonedOptions.audio).deviceId) !== null && _b !== void 0 ? _b : _d.deviceId = {
+      ideal: 'default'
+    };
     if (audioProcessor || defaultAudioProcessor) {
       clonedOptions.audio.processor = audioProcessor !== null && audioProcessor !== void 0 ? audioProcessor : defaultAudioProcessor;
     }
   }
   if (clonedOptions.video) {
     mergeObjectWithoutOverwriting(clonedOptions.video, videoDefaults);
-    (_c = (_e = clonedOptions.video).deviceId) !== null && _c !== void 0 ? _c : _e.deviceId = 'default';
+    (_c = (_e = clonedOptions.video).deviceId) !== null && _c !== void 0 ? _c : _e.deviceId = {
+      ideal: 'default'
+    };
     if (videoProcessor || defaultVideoProcessor) {
       clonedOptions.video.processor = videoProcessor !== null && videoProcessor !== void 0 ? videoProcessor : defaultVideoProcessor;
     }
@@ -12228,10 +12247,14 @@ function constraintsForOptions(options) {
         }
       });
       constraints.video = videoOptions;
-      (_a = (_c = constraints.video).deviceId) !== null && _a !== void 0 ? _a : _c.deviceId = 'default';
+      (_a = (_c = constraints.video).deviceId) !== null && _a !== void 0 ? _a : _c.deviceId = {
+        ideal: 'default'
+      };
     } else {
       constraints.video = options.video ? {
-        deviceId: 'default'
+        deviceId: {
+          ideal: 'default'
+        }
       } : false;
     }
   } else {
@@ -12240,10 +12263,14 @@ function constraintsForOptions(options) {
   if (options.audio) {
     if (typeof options.audio === 'object') {
       constraints.audio = options.audio;
-      (_b = (_d = constraints.audio).deviceId) !== null && _b !== void 0 ? _b : _d.deviceId = 'default';
+      (_b = (_d = constraints.audio).deviceId) !== null && _b !== void 0 ? _b : _d.deviceId = {
+        ideal: 'default'
+      };
     } else {
       constraints.audio = {
-        deviceId: 'default'
+        deviceId: {
+          ideal: 'default'
+        }
       };
     }
   } else {
@@ -12848,7 +12875,9 @@ class DeviceManager {
             const permissionsToAcquire = {
               video: kind !== 'audioinput' && kind !== 'audiooutput',
               audio: kind !== 'videoinput' && {
-                deviceId: 'default'
+                deviceId: {
+                  ideal: 'default'
+                }
               }
             };
             const stream = yield navigator.mediaDevices.getUserMedia(permissionsToAcquire);
@@ -12936,6 +12965,25 @@ class AsyncQueue {
   }
 }
 
+function createRtcUrl(url, searchParams) {
+  const urlObj = new URL(url);
+  searchParams.forEach((value, key) => {
+    urlObj.searchParams.set(key, value);
+  });
+  return appendUrlPath(urlObj, 'rtc');
+}
+function createValidateUrl(rtcWsUrl) {
+  const urlObj = new URL(toHttpUrl(rtcWsUrl));
+  return appendUrlPath(urlObj, 'validate');
+}
+function ensureTrailingSlash(path) {
+  return path.endsWith('/') ? path : "".concat(path, "/");
+}
+function appendUrlPath(urlObj, path) {
+  urlObj.pathname = "".concat(ensureTrailingSlash(urlObj.pathname)).concat(path);
+  return urlObj.toString();
+}
+
 const passThroughQueueSignals = ['syncState', 'trickle', 'offer', 'answer', 'simulate', 'leave'];
 function canPassThroughQueue(req) {
   const canPass = passThroughQueueSignals.indexOf(req.case) >= 0;
@@ -13033,15 +13081,10 @@ class SignalClient {
   }
   connect(url, token, opts, abortSignal) {
     this.connectOptions = opts;
-    const urlObj = new URL(toWebsocketUrl(url));
-    // strip trailing slash
-    const hasTrailingSlash = urlObj.pathname.endsWith('/');
-    urlObj.pathname += hasTrailingSlash ? 'rtc' : '/rtc';
     const clientInfo = getClientInfo();
     const params = createConnectionParams(token, clientInfo, opts);
-    for (const [key, value] of params) {
-      urlObj.searchParams.set(key, value);
-    }
+    const rtcUrl = createRtcUrl(url, params);
+    const validateUrl = createValidateUrl(rtcUrl);
     return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
       const unlock = yield this.connectionLock.lock();
       try {
@@ -13058,7 +13101,7 @@ class SignalClient {
           abortHandler();
         }
         abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.addEventListener('abort', abortHandler);
-        const redactedUrl = new URL(urlObj.toString());
+        const redactedUrl = new URL(rtcUrl);
         if (redactedUrl.searchParams.has('access_token')) {
           redactedUrl.searchParams.set('access_token', '<redacted>');
         }
@@ -13069,7 +13112,7 @@ class SignalClient {
         if (this.ws) {
           yield this.close(false);
         }
-        this.ws = new WebSocket(urlObj.toString());
+        this.ws = new WebSocket(rtcUrl);
         this.ws.binaryType = 'arraybuffer';
         this.ws.onopen = () => {
           clearTimeout(wsTimeout);
@@ -13079,15 +13122,12 @@ class SignalClient {
             this.state = SignalConnectionState.DISCONNECTED;
             clearTimeout(wsTimeout);
             try {
-              const validateURL = new URL(urlObj.toString());
-              validateURL.protocol = "http".concat(validateURL.protocol.substring(2));
-              validateURL.pathname += '/validate';
-              const resp = yield fetch(validateURL);
+              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('Internal error', ConnectionErrorReason.InternalError, resp.status));
+                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));
@@ -14931,14 +14971,18 @@ const publishDefaults = {
   backupCodec: true
 };
 const audioDefaults = {
-  deviceId: 'default',
+  deviceId: {
+    ideal: 'default'
+  },
   autoGainControl: true,
   echoCancellation: true,
   noiseSuppression: true,
   voiceIsolation: true
 };
 const videoDefaults = {
-  deviceId: 'default',
+  deviceId: {
+    ideal: 'default'
+  },
   resolution: VideoPresets.h720.resolution
 };
 const roomOptionDefaults = {
@@ -15644,9 +15688,10 @@ class LocalTrack extends Track {
           constraints = this._constraints;
         }
         const {
-            deviceId
+            deviceId,
+            facingMode
           } = constraints,
-          otherConstraints = __rest(constraints, ["deviceId"]);
+          otherConstraints = __rest(constraints, ["deviceId", "facingMode"]);
         this.log.debug('restarting track with constraints', Object.assign(Object.assign({}, this.logContext), {
           constraints
         }));
@@ -15655,8 +15700,9 @@ class LocalTrack extends Track {
           video: false
         };
         if (this.kind === Track.Kind.Video) {
-          streamConstraints.video = deviceId ? {
-            deviceId
+          streamConstraints.video = deviceId || facingMode ? {
+            deviceId,
+            facingMode
           } : true;
         } else {
           streamConstraints.audio = deviceId ? {
@@ -16950,13 +16996,44 @@ function setPublishingLayersForSender(sender, senderEncodings, qualities, sender
         return;
       }
       let hasChanged = false;
-      /* disable closable spatial layer as it has video blur / frozen issue with current server / client
-      1. chrome 113: when switching to up layer with scalability Mode change, it will generate a
-            low resolution frame and recover very quickly, but noticable
-      2. livekit sfu: additional pli request cause video frozen for a few frames, also noticable */
-      const closableSpatial = false;
+      const browser = getBrowser();
+      const closableSpatial = (browser === null || browser === void 0 ? void 0 : browser.name) === 'Chrome' && compareVersions(browser === null || browser === void 0 ? void 0 : browser.version, '133') > 0;
       /* @ts-ignore */
-      if (closableSpatial && encodings[0].scalabilityMode) ; else {
+      if (closableSpatial && encodings[0].scalabilityMode) {
+        // svc dynacast encodings
+        const encoding = encodings[0];
+        /* @ts-ignore */
+        const mode = new ScalabilityMode(encoding.scalabilityMode);
+        let maxQuality = VideoQuality$1.OFF;
+        qualities.forEach(q => {
+          if (q.enabled && (maxQuality === VideoQuality$1.OFF || q.quality > maxQuality)) {
+            maxQuality = q.quality;
+          }
+        });
+        if (maxQuality === VideoQuality$1.OFF) {
+          if (encoding.active) {
+            encoding.active = false;
+            hasChanged = true;
+          }
+        } else if (!encoding.active || mode.spatial !== maxQuality + 1) {
+          hasChanged = true;
+          encoding.active = true;
+          /* @ts-ignore */
+          const originalMode = new ScalabilityMode(senderEncodings[0].scalabilityMode);
+          mode.spatial = maxQuality + 1;
+          mode.suffix = originalMode.suffix;
+          if (mode.spatial === 1) {
+            // no suffix for L1Tx
+            mode.suffix = undefined;
+          }
+          /* @ts-ignore */
+          encoding.scalabilityMode = mode.toString();
+          encoding.scaleResolutionDownBy = Math.pow(2, 2 - maxQuality);
+          if (senderEncodings[0].maxBitrate) {
+            encoding.maxBitrate = senderEncodings[0].maxBitrate / (encoding.scaleResolutionDownBy * encoding.scaleResolutionDownBy);
+          }
+        }
+      } else {
         // simulcast dynacast encodings
         encodings.forEach((encoding, idx) => {
           var _a;
@@ -17299,6 +17376,10 @@ class RTCEngine extends eventsExports.EventEmitter {
           this.negotiate();
         }
         this.clientConfiguration = joinResponse.clientConfiguration;
+        // emit signal connected event after a short delay to allow for join response to be processed on room
+        setTimeout(() => {
+          this.emit(EngineEvent.SignalConnected);
+        }, 10);
         return joinResponse;
       } catch (e) {
         if (e instanceof ConnectionError) {
@@ -18492,6 +18573,7 @@ class BaseStreamWriter {
   }
 }
 class TextStreamWriter extends BaseStreamWriter {}
+class ByteStreamWriter extends BaseStreamWriter {}
 
 class RemoteTrack extends Track {
   constructor(mediaTrack, sid, kind, receiver, loggerOptions) {
@@ -19245,7 +19327,7 @@ class TrackPublication extends eventsExports.EventEmitter {
     PermissionStatus["Allowed"] = "allowed";
     PermissionStatus["NotAllowed"] = "not_allowed";
   })(TrackPublication.PermissionStatus || (TrackPublication.PermissionStatus = {}));
-})(TrackPublication);
+})(TrackPublication || (TrackPublication = {}));
 
 class LocalTrackPublication extends TrackPublication {
   get isUpstreamPaused() {
@@ -20332,7 +20414,41 @@ class LocalParticipant extends Participant {
         if (opts.source) {
           track.source = opts.source;
         }
-        const publishPromise = _this2.publish(track, opts, isStereo);
+        const publishPromise = new Promise((resolve, reject) => __awaiter(_this2, void 0, void 0, function* () {
+          try {
+            if (this.engine.client.currentState !== SignalConnectionState.CONNECTED) {
+              this.log.debug('deferring track publication until signal is connected', Object.assign(Object.assign({}, this.logContext), {
+                track: getLogContextFromTrack(track)
+              }));
+              const onSignalConnected = () => __awaiter(this, void 0, void 0, function* () {
+                try {
+                  const publication = yield this.publish(track, opts, isStereo);
+                  resolve(publication);
+                } catch (e) {
+                  reject(e);
+                }
+              });
+              setTimeout(() => {
+                this.engine.off(EngineEvent.SignalConnected, onSignalConnected);
+                reject(new PublishTrackError('publishing rejected as engine not connected within timeout', 408));
+              }, 15000);
+              this.engine.once(EngineEvent.SignalConnected, onSignalConnected);
+              this.engine.on(EngineEvent.Closing, () => {
+                this.engine.off(EngineEvent.SignalConnected, onSignalConnected);
+                reject(new PublishTrackError('publishing rejected as engine closed', 499));
+              });
+            } else {
+              try {
+                const publication = yield this.publish(track, opts, isStereo);
+                resolve(publication);
+              } catch (e) {
+                reject(e);
+              }
+            }
+          } catch (e) {
+            reject(e);
+          }
+        }));
         _this2.pendingPublishPromises.set(track, publishPromise);
         try {
           const publication = yield publishPromise;
@@ -21029,23 +21145,57 @@ class LocalParticipant extends Participant {
   }
   _sendFile(streamId, file, options) {
     return __awaiter(this, void 0, void 0, function* () {
-      var _a, _b;
-      const totalLength = file.size;
-      const header = new DataStream_Header({
-        totalLength: numberToBigInt(totalLength),
-        mimeType: (_a = options === null || options === void 0 ? void 0 : options.mimeType) !== null && _a !== void 0 ? _a : file.type,
+      var _a;
+      const writer = yield this.streamBytes({
         streamId,
+        totalSize: file.size,
+        name: file.name,
+        mimeType: (_a = options === null || options === void 0 ? void 0 : options.mimeType) !== null && _a !== void 0 ? _a : file.type,
         topic: options === null || options === void 0 ? void 0 : options.topic,
-        encryptionType: options === null || options === void 0 ? void 0 : options.encryptionType,
+        destinationIdentities: options === null || options === void 0 ? void 0 : options.destinationIdentities
+      });
+      const reader = file.stream().getReader();
+      while (true) {
+        const {
+          done,
+          value
+        } = yield reader.read();
+        if (done) {
+          break;
+        }
+        yield writer.write(value);
+      }
+      yield writer.close();
+      return writer.info;
+    });
+  }
+  streamBytes(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+      var _a, _b, _c, _d, _e;
+      const streamId = (_a = options === null || options === void 0 ? void 0 : options.streamId) !== null && _a !== void 0 ? _a : crypto.randomUUID();
+      const destinationIdentities = options === null || options === void 0 ? void 0 : options.destinationIdentities;
+      const info = {
+        id: streamId,
+        mimeType: (_b = options === null || options === void 0 ? void 0 : options.mimeType) !== null && _b !== void 0 ? _b : 'application/octet-stream',
+        topic: (_c = options === null || options === void 0 ? void 0 : options.topic) !== null && _c !== void 0 ? _c : '',
+        timestamp: Date.now(),
+        attributes: options === null || options === void 0 ? void 0 : options.attributes,
+        size: options === null || options === void 0 ? void 0 : options.totalSize,
+        name: (_d = options === null || options === void 0 ? void 0 : options.name) !== null && _d !== void 0 ? _d : 'unknown'
+      };
+      const header = new DataStream_Header({
+        totalLength: numberToBigInt((_e = info.size) !== null && _e !== void 0 ? _e : 0),
+        mimeType: info.mimeType,
+        streamId,
+        topic: info.topic,
         timestamp: numberToBigInt(Date.now()),
         contentHeader: {
           case: 'byteHeader',
           value: new DataStream_ByteHeader({
-            name: file.name
+            name: info.name
           })
         }
       });
-      const destinationIdentities = options === null || options === void 0 ? void 0 : options.destinationIdentities;
       const packet = new DataPacket({
         destinationIdentities,
         value: {
@@ -21054,45 +21204,60 @@ class LocalParticipant extends Participant {
         }
       });
       yield this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
-      function read(b) {
-        return new Promise(resolve => {
-          const fr = new FileReader();
-          fr.onload = () => {
-            resolve(new Uint8Array(fr.result));
-          };
-          fr.readAsArrayBuffer(b);
-        });
-      }
-      const totalChunks = Math.ceil(totalLength / STREAM_CHUNK_SIZE);
-      for (let i = 0; i < totalChunks; i++) {
-        const chunkData = yield read(file.slice(i * STREAM_CHUNK_SIZE, Math.min((i + 1) * STREAM_CHUNK_SIZE, totalLength)));
-        yield this.engine.waitForBufferStatusLow(DataPacket_Kind.RELIABLE);
-        const chunk = new DataStream_Chunk({
-          content: chunkData,
-          streamId,
-          chunkIndex: numberToBigInt(i)
-        });
-        const chunkPacket = new DataPacket({
-          destinationIdentities,
-          value: {
-            case: 'streamChunk',
-            value: chunk
-          }
-        });
-        yield this.engine.sendDataPacket(chunkPacket, DataPacket_Kind.RELIABLE);
-        (_b = options === null || options === void 0 ? void 0 : options.onProgress) === null || _b === void 0 ? void 0 : _b.call(options, (i + 1) / totalChunks);
-      }
-      const trailer = new DataStream_Trailer({
-        streamId
-      });
-      const trailerPacket = new DataPacket({
-        destinationIdentities,
-        value: {
-          case: 'streamTrailer',
-          value: trailer
+      let chunkId = 0;
+      const writeMutex = new _();
+      const engine = this.engine;
+      const log = this.log;
+      const writableStream = new WritableStream({
+        write(chunk) {
+          return __awaiter(this, void 0, void 0, function* () {
+            const unlock = yield writeMutex.lock();
+            let byteOffset = 0;
+            try {
+              while (byteOffset < chunk.byteLength) {
+                const subChunk = chunk.slice(byteOffset, byteOffset + STREAM_CHUNK_SIZE);
+                yield engine.waitForBufferStatusLow(DataPacket_Kind.RELIABLE);
+                const chunkPacket = new DataPacket({
+                  destinationIdentities,
+                  value: {
+                    case: 'streamChunk',
+                    value: new DataStream_Chunk({
+                      content: subChunk,
+                      streamId,
+                      chunkIndex: numberToBigInt(chunkId)
+                    })
+                  }
+                });
+                yield engine.sendDataPacket(chunkPacket, DataPacket_Kind.RELIABLE);
+                chunkId += 1;
+                byteOffset += subChunk.byteLength;
+              }
+            } finally {
+              unlock();
+            }
+          });
+        },
+        close() {
+          return __awaiter(this, void 0, void 0, function* () {
+            const trailer = new DataStream_Trailer({
+              streamId
+            });
+            const trailerPacket = new DataPacket({
+              destinationIdentities,
+              value: {
+                case: 'streamTrailer',
+                value: trailer
+              }
+            });
+            yield engine.sendDataPacket(trailerPacket, DataPacket_Kind.RELIABLE);
+          });
+        },
+        abort(err) {
+          log.error('Sink error:', err);
         }
       });
-      yield this.engine.sendDataPacket(trailerPacket, DataPacket_Kind.RELIABLE);
+      const byteWriter = new ByteStreamWriter(writableStream, info);
+      return byteWriter;
     });
   }
   /**
@@ -23108,7 +23273,7 @@ class Room extends eventsExports.EventEmitter {
   switchActiveDevice(kind_1, deviceId_1) {
     return __awaiter(this, arguments, void 0, function (kind, deviceId) {
       var _this3 = this;
-      let exact = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      let exact = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
       return function* () {
         var _a, _b, _c, _d, _e, _f, _g;
         var _h;
@@ -24111,63 +24276,104 @@ function createLocalTracks(options) {
   return __awaiter(this, void 0, void 0, function* () {
     var _a, _b;
     // set default options to true
-    options !== null && options !== void 0 ? options : options = {};
-    (_a = options.audio) !== null && _a !== void 0 ? _a : options.audio = {
+    const internalOptions = Object.assign({}, options !== null && options !== void 0 ? options : {});
+    let attemptExactMatch = false;
+    let retryAudioOptions = options === null || options === void 0 ? void 0 : options.audio;
+    let retryVideoOptions = options === null || options === void 0 ? void 0 : options.video;
+    // if the user passes a device id as a string, we default to exact match
+    if (internalOptions.audio && typeof internalOptions.audio === 'object' && typeof internalOptions.audio.deviceId === 'string') {
+      const deviceId = internalOptions.audio.deviceId;
+      internalOptions.audio.deviceId = {
+        exact: deviceId
+      };
+      attemptExactMatch = true;
+      retryAudioOptions = Object.assign(Object.assign({}, internalOptions.audio), {
+        deviceId: {
+          ideal: deviceId
+        }
+      });
+    }
+    if (internalOptions.video && typeof internalOptions.video === 'object' && typeof internalOptions.video.deviceId === 'string') {
+      const deviceId = internalOptions.video.deviceId;
+      internalOptions.video.deviceId = {
+        exact: deviceId
+      };
+      attemptExactMatch = true;
+      retryVideoOptions = Object.assign(Object.assign({}, internalOptions.video), {
+        deviceId: {
+          ideal: deviceId
+        }
+      });
+    }
+    (_a = internalOptions.audio) !== null && _a !== void 0 ? _a : internalOptions.audio = {
       deviceId: 'default'
     };
-    (_b = options.video) !== null && _b !== void 0 ? _b : options.video = {
+    (_b = internalOptions.video) !== null && _b !== void 0 ? _b : internalOptions.video = {
       deviceId: 'default'
     };
     const {
       audioProcessor,
       videoProcessor
-    } = extractProcessorsFromOptions(options);
-    const opts = mergeDefaultOptions(options, audioDefaults, videoDefaults);
+    } = extractProcessorsFromOptions(internalOptions);
+    const opts = mergeDefaultOptions(internalOptions, audioDefaults, videoDefaults);
     const constraints = constraintsForOptions(opts);
     // Keep a reference to the promise on DeviceManager and await it in getLocalDevices()
     // works around iOS Safari Bug https://bugs.webkit.org/show_bug.cgi?id=179363
     const mediaPromise = navigator.mediaDevices.getUserMedia(constraints);
-    if (options.audio) {
+    if (internalOptions.audio) {
       DeviceManager.userMediaPromiseMap.set('audioinput', mediaPromise);
       mediaPromise.catch(() => DeviceManager.userMediaPromiseMap.delete('audioinput'));
     }
-    if (options.video) {
+    if (internalOptions.video) {
       DeviceManager.userMediaPromiseMap.set('videoinput', mediaPromise);
       mediaPromise.catch(() => DeviceManager.userMediaPromiseMap.delete('videoinput'));
     }
-    const stream = yield mediaPromise;
-    return Promise.all(stream.getTracks().map(mediaStreamTrack => __awaiter(this, void 0, void 0, function* () {
-      const isAudio = mediaStreamTrack.kind === 'audio';
-      isAudio ? opts.audio : opts.video;
-      let trackConstraints;
-      const conOrBool = isAudio ? constraints.audio : constraints.video;
-      if (typeof conOrBool !== 'boolean') {
-        trackConstraints = conOrBool;
-      }
-      // 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
-      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: newDeviceId
-        };
-      }
-      const track = mediaTrackToLocalTrack(mediaStreamTrack, trackConstraints);
-      if (track.kind === Track.Kind.Video) {
-        track.source = Track.Source.Camera;
-      } else if (track.kind === Track.Kind.Audio) {
-        track.source = Track.Source.Microphone;
-      }
-      track.mediaStream = stream;
-      if (isAudioTrack(track) && audioProcessor) {
-        yield track.setProcessor(audioProcessor);
-      } else if (isVideoTrack(track) && videoProcessor) {
-        yield track.setProcessor(videoProcessor);
+    try {
+      const stream = yield mediaPromise;
+      return yield Promise.all(stream.getTracks().map(mediaStreamTrack => __awaiter(this, void 0, void 0, function* () {
+        const isAudio = mediaStreamTrack.kind === 'audio';
+        let trackOptions = isAudio ? opts.audio : opts.video;
+        if (typeof trackOptions === 'boolean' || !trackOptions) {
+          trackOptions = {};
+        }
+        let trackConstraints;
+        const conOrBool = isAudio ? constraints.audio : constraints.video;
+        if (typeof conOrBool !== 'boolean') {
+          trackConstraints = conOrBool;
+        }
+        // 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
+        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: newDeviceId
+          };
+        }
+        const track = mediaTrackToLocalTrack(mediaStreamTrack, trackConstraints);
+        if (track.kind === Track.Kind.Video) {
+          track.source = Track.Source.Camera;
+        } else if (track.kind === Track.Kind.Audio) {
+          track.source = Track.Source.Microphone;
+        }
+        track.mediaStream = stream;
+        if (isAudioTrack(track) && audioProcessor) {
+          yield track.setProcessor(audioProcessor);
+        } else if (isVideoTrack(track) && videoProcessor) {
+          yield track.setProcessor(videoProcessor);
+        }
+        return track;
+      })));
+    } catch (e) {
+      if (!attemptExactMatch) {
+        throw e;
       }
-      return track;
-    })));
+      return createLocalTracks(Object.assign(Object.assign({}, options), {
+        audio: retryAudioOptions,
+        video: retryVideoOptions
+      }));
+    }
   });
 }
 /**