livekit-client 2.5.2 → 2.5.4

package/dist/livekit-client.esm.mjs

@@ -3397,6 +3397,218 @@ target => {
   }
 });
 
+// Copyright 2021-2024 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+/**
+ * A Timestamp represents a point in time independent of any time zone or local
+ * calendar, encoded as a count of seconds and fractions of seconds at
+ * nanosecond resolution. The count is relative to an epoch at UTC midnight on
+ * January 1, 1970, in the proleptic Gregorian calendar which extends the
+ * Gregorian calendar backwards to year one.
+ *
+ * All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
+ * second table is needed for interpretation, using a [24-hour linear
+ * smear](https://developers.google.com/time/smear).
+ *
+ * The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
+ * restricting to that range, we ensure that we can convert to and from [RFC
+ * 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
+ *
+ * # Examples
+ *
+ * Example 1: Compute Timestamp from POSIX `time()`.
+ *
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds(time(NULL));
+ *     timestamp.set_nanos(0);
+ *
+ * Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+ *
+ *     struct timeval tv;
+ *     gettimeofday(&tv, NULL);
+ *
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds(tv.tv_sec);
+ *     timestamp.set_nanos(tv.tv_usec * 1000);
+ *
+ * Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+ *
+ *     FILETIME ft;
+ *     GetSystemTimeAsFileTime(&ft);
+ *     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+ *
+ *     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+ *     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+ *     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+ *
+ * Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+ *
+ *     long millis = System.currentTimeMillis();
+ *
+ *     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+ *         .setNanos((int) ((millis % 1000) * 1000000)).build();
+ *
+ * Example 5: Compute Timestamp from Java `Instant.now()`.
+ *
+ *     Instant now = Instant.now();
+ *
+ *     Timestamp timestamp =
+ *         Timestamp.newBuilder().setSeconds(now.getEpochSecond())
+ *             .setNanos(now.getNano()).build();
+ *
+ * Example 6: Compute Timestamp from current time in Python.
+ *
+ *     timestamp = Timestamp()
+ *     timestamp.GetCurrentTime()
+ *
+ * # JSON Mapping
+ *
+ * In JSON format, the Timestamp type is encoded as a string in the
+ * [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
+ * format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
+ * where {year} is always expressed using four digits while {month}, {day},
+ * {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
+ * seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
+ * are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
+ * is required. A proto3 JSON serializer should always use UTC (as indicated by
+ * "Z") when printing the Timestamp type and a proto3 JSON parser should be
+ * able to accept both UTC and other timezones (as indicated by an offset).
+ *
+ * For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
+ * 01:30 UTC on January 15, 2017.
+ *
+ * In JavaScript, one can convert a Date object to this format using the
+ * standard
+ * [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
+ * method. In Python, a standard `datetime.datetime` object can be converted
+ * to this format using
+ * [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
+ * the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
+ * the Joda Time's [`ISODateTimeFormat.dateTime()`](
+ * http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
+ * ) to obtain a formatter capable of generating timestamps in this format.
+ *
+ *
+ * @generated from message google.protobuf.Timestamp
+ */
+class Timestamp extends Message {
+  constructor(data) {
+    super();
+    /**
+     * Represents seconds of UTC time since Unix epoch
+     * 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
+     * 9999-12-31T23:59:59Z inclusive.
+     *
+     * @generated from field: int64 seconds = 1;
+     */
+    this.seconds = protoInt64.zero;
+    /**
+     * Non-negative fractions of a second at nanosecond resolution. Negative
+     * second values with fractions must still have non-negative nanos values
+     * that count forward in time. Must be from 0 to 999,999,999
+     * inclusive.
+     *
+     * @generated from field: int32 nanos = 2;
+     */
+    this.nanos = 0;
+    proto3.util.initPartial(data, this);
+  }
+  fromJson(json, options) {
+    if (typeof json !== "string") {
+      throw new Error("cannot decode google.protobuf.Timestamp from JSON: ".concat(proto3.json.debug(json)));
+    }
+    const matches = json.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/);
+    if (!matches) {
+      throw new Error("cannot decode google.protobuf.Timestamp from JSON: invalid RFC 3339 string");
+    }
+    const ms = Date.parse(matches[1] + "-" + matches[2] + "-" + matches[3] + "T" + matches[4] + ":" + matches[5] + ":" + matches[6] + (matches[8] ? matches[8] : "Z"));
+    if (Number.isNaN(ms)) {
+      throw new Error("cannot decode google.protobuf.Timestamp from JSON: invalid RFC 3339 string");
+    }
+    if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z")) {
+      throw new Error("cannot decode message google.protobuf.Timestamp from JSON: must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive");
+    }
+    this.seconds = protoInt64.parse(ms / 1000);
+    this.nanos = 0;
+    if (matches[7]) {
+      this.nanos = parseInt("1" + matches[7] + "0".repeat(9 - matches[7].length)) - 1000000000;
+    }
+    return this;
+  }
+  toJson(options) {
+    const ms = Number(this.seconds) * 1000;
+    if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z")) {
+      throw new Error("cannot encode google.protobuf.Timestamp to JSON: must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive");
+    }
+    if (this.nanos < 0) {
+      throw new Error("cannot encode google.protobuf.Timestamp to JSON: nanos must not be negative");
+    }
+    let z = "Z";
+    if (this.nanos > 0) {
+      const nanosStr = (this.nanos + 1000000000).toString().substring(1);
+      if (nanosStr.substring(3) === "000000") {
+        z = "." + nanosStr.substring(0, 3) + "Z";
+      } else if (nanosStr.substring(6) === "000") {
+        z = "." + nanosStr.substring(0, 6) + "Z";
+      } else {
+        z = "." + nanosStr + "Z";
+      }
+    }
+    return new Date(ms).toISOString().replace(".000Z", z);
+  }
+  toDate() {
+    return new Date(Number(this.seconds) * 1000 + Math.ceil(this.nanos / 1000000));
+  }
+  static now() {
+    return Timestamp.fromDate(new Date());
+  }
+  static fromDate(date) {
+    const ms = date.getTime();
+    return new Timestamp({
+      seconds: protoInt64.parse(Math.floor(ms / 1000)),
+      nanos: ms % 1000 * 1000000
+    });
+  }
+  static fromBinary(bytes, options) {
+    return new Timestamp().fromBinary(bytes, options);
+  }
+  static fromJson(jsonValue, options) {
+    return new Timestamp().fromJson(jsonValue, options);
+  }
+  static fromJsonString(jsonString, options) {
+    return new Timestamp().fromJsonString(jsonString, options);
+  }
+  static equals(a, b) {
+    return proto3.util.equals(Timestamp, a, b);
+  }
+}
+Timestamp.runtime = proto3;
+Timestamp.typeName = "google.protobuf.Timestamp";
+Timestamp.fields = proto3.util.newFieldList(() => [{
+  no: 1,
+  name: "seconds",
+  kind: "scalar",
+  T: 3 /* ScalarType.INT64 */
+}, {
+  no: 2,
+  name: "nanos",
+  kind: "scalar",
+  T: 5 /* ScalarType.INT32 */
+}]);
+
 // @generated by protoc-gen-es v1.10.0 with parameter "target=js+dts"
 // @generated from file livekit_metrics.proto (package livekit, syntax proto3)
 /* eslint-disable */
@@ -3408,18 +3620,28 @@ target => {
  */
 const MetricsBatch = /*@__PURE__*/proto3.makeMessageType("livekit.MetricsBatch", () => [{
   no: 1,
+  name: "timestamp_ms",
+  kind: "scalar",
+  T: 3 /* ScalarType.INT64 */
+}, {
+  no: 2,
+  name: "normalized_timestamp",
+  kind: "message",
+  T: Timestamp
+}, {
+  no: 3,
   name: "str_data",
   kind: "scalar",
   T: 9 /* ScalarType.STRING */,
   repeated: true
 }, {
-  no: 2,
+  no: 4,
   name: "time_series",
   kind: "message",
   T: TimeSeriesMetric,
   repeated: true
 }, {
-  no: 3,
+  no: 5,
   name: "events",
   kind: "message",
   T: EventMetric,
@@ -3446,16 +3668,6 @@ const TimeSeriesMetric = /*@__PURE__*/proto3.makeMessageType("livekit.TimeSeries
   T: 13 /* ScalarType.UINT32 */
 }, {
   no: 4,
-  name: "start_timestamp",
-  kind: "scalar",
-  T: 3 /* ScalarType.INT64 */
-}, {
-  no: 5,
-  name: "end_timestamp",
-  kind: "scalar",
-  T: 3 /* ScalarType.INT64 */
-}, {
-  no: 6,
   name: "samples",
   kind: "message",
   T: MetricSample,
@@ -3467,11 +3679,16 @@ const TimeSeriesMetric = /*@__PURE__*/proto3.makeMessageType("livekit.TimeSeries
  */
 const MetricSample = /*@__PURE__*/proto3.makeMessageType("livekit.MetricSample", () => [{
   no: 1,
-  name: "timestamp",
+  name: "timestamp_ms",
   kind: "scalar",
   T: 3 /* ScalarType.INT64 */
 }, {
   no: 2,
+  name: "normalized_timestamp",
+  kind: "message",
+  T: Timestamp
+}, {
+  no: 3,
   name: "value",
   kind: "scalar",
   T: 2 /* ScalarType.FLOAT */
@@ -3497,17 +3714,28 @@ const EventMetric = /*@__PURE__*/proto3.makeMessageType("livekit.EventMetric", (
   T: 13 /* ScalarType.UINT32 */
 }, {
   no: 4,
-  name: "start_timestamp",
+  name: "start_timestamp_ms",
   kind: "scalar",
   T: 3 /* ScalarType.INT64 */
 }, {
   no: 5,
-  name: "end_timestamp",
+  name: "end_timestamp_ms",
   kind: "scalar",
   T: 3 /* ScalarType.INT64 */,
   opt: true
 }, {
   no: 6,
+  name: "normalized_start_timestamp",
+  kind: "message",
+  T: Timestamp
+}, {
+  no: 7,
+  name: "normalized_end_timestamp",
+  kind: "message",
+  T: Timestamp,
+  opt: true
+}, {
+  no: 8,
   name: "metadata",
   kind: "scalar",
   T: 9 /* ScalarType.STRING */
@@ -4185,6 +4413,12 @@ const DataPacket = /*@__PURE__*/proto3.makeMessageType("livekit.DataPacket", ()
   kind: "message",
   T: MetricsBatch,
   oneof: "value"
+}, {
+  no: 9,
+  name: "chat_message",
+  kind: "message",
+  T: ChatMessage,
+  oneof: "value"
 }]);
 
 /**
@@ -4356,6 +4590,42 @@ const TranscriptionSegment = /*@__PURE__*/proto3.makeMessageType("livekit.Transc
   T: 9 /* ScalarType.STRING */
 }]);
 
+/**
+ * @generated from message livekit.ChatMessage
+ */
+const ChatMessage = /*@__PURE__*/proto3.makeMessageType("livekit.ChatMessage", () => [{
+  no: 1,
+  name: "id",
+  kind: "scalar",
+  T: 9 /* ScalarType.STRING */
+}, {
+  no: 2,
+  name: "timestamp",
+  kind: "scalar",
+  T: 3 /* ScalarType.INT64 */
+}, {
+  no: 3,
+  name: "edit_timestamp",
+  kind: "scalar",
+  T: 3 /* ScalarType.INT64 */,
+  opt: true
+}, {
+  no: 4,
+  name: "message",
+  kind: "scalar",
+  T: 9 /* ScalarType.STRING */
+}, {
+  no: 5,
+  name: "deleted",
+  kind: "scalar",
+  T: 8 /* ScalarType.BOOL */
+}, {
+  no: 6,
+  name: "generated",
+  kind: "scalar",
+  T: 8 /* ScalarType.BOOL */
+}]);
+
 /**
  * @generated from message livekit.ParticipantTracks
  */
@@ -4518,6 +4788,12 @@ const ClientInfo_SDK = /*@__PURE__*/proto3.makeEnum("livekit.ClientInfo.SDK", [{
 }, {
   no: 10,
   name: "CPP"
+}, {
+  no: 11,
+  name: "UNITY_WEB"
+}, {
+  no: 12,
+  name: "NODE"
 }]);
 
 /**
@@ -10320,6 +10596,7 @@ var RoomEvent;
    * args: (kind: MediaDeviceKind, deviceId: string)
    */
   RoomEvent["ActiveDeviceChanged"] = "activeDeviceChanged";
+  RoomEvent["ChatMessage"] = "chatMessage";
   /**
    * fired when the first remote participant has subscribed to the localParticipant's track
    */
@@ -10491,6 +10768,8 @@ var ParticipantEvent;
    * fired on local participant only, when the first remote participant has subscribed to the track specified in the payload
    */
   ParticipantEvent["LocalTrackSubscribed"] = "localTrackSubscribed";
+  /** only emitted on local participant */
+  ParticipantEvent["ChatMessage"] = "chatMessage";
 })(ParticipantEvent || (ParticipantEvent = {}));
 /** @internal */
 var EngineEvent;
@@ -10714,7 +10993,7 @@ function getOSVersion(ua) {
   return ua.includes('mac os') ? getMatch(/\(.+?(\d+_\d+(:?_\d+)?)/, ua, 1).replace(/_/g, '.') : undefined;
 }
 
-var version$1 = "2.5.2";
+var version$1 = "2.5.4";
 
 const version = version$1;
 const protocolVersion = 15;
@@ -11872,6 +12151,20 @@ function extractTranscriptionSegments(transcription, firstReceivedTimesMap) {
     };
   });
 }
+function extractChatMessage(msg) {
+  const {
+    id,
+    timestamp,
+    message,
+    editTimestamp
+  } = msg;
+  return {
+    id,
+    timestamp: Number.parseInt(timestamp.toString()),
+    editTimestamp: editTimestamp ? Number.parseInt(editTimestamp.toString()) : undefined,
+    message
+  };
+}
 
 const defaultId = 'default';
 class DeviceManager {
@@ -18973,6 +19266,9 @@ class LocalParticipant extends Participant {
         source,
         enabled
       }));
+      if (this.republishPromise) {
+        yield this.republishPromise;
+      }
       let track = this.getTrackPublication(source);
       if (enabled) {
         if (track) {
@@ -18980,11 +19276,14 @@ class LocalParticipant extends Participant {
         } else {
           let localTracks;
           if (this.pendingPublishing.has(source)) {
-            this.log.info('skipping duplicate published source', Object.assign(Object.assign({}, this.logContext), {
-              source
-            }));
-            // no-op it's already been requested
-            return;
+            const pendingTrack = yield this.waitForPendingPublicationOfSource(source);
+            if (!pendingTrack) {
+              this.log.info('skipping duplicate published source', Object.assign(Object.assign({}, this.logContext), {
+                source
+              }));
+            }
+            yield pendingTrack === null || pendingTrack === void 0 ? void 0 : pendingTrack.unmute();
+            return pendingTrack;
           }
           this.pendingPublishing.add(source);
           try {
@@ -19026,16 +19325,22 @@ class LocalParticipant extends Participant {
             this.pendingPublishing.delete(source);
           }
         }
-      } else if (track && track.track) {
-        // screenshare cannot be muted, unpublish instead
-        if (source === Track.Source.ScreenShare) {
-          track = yield this.unpublishTrack(track.track);
-          const screenAudioTrack = this.getTrackPublication(Track.Source.ScreenShareAudio);
-          if (screenAudioTrack && screenAudioTrack.track) {
-            this.unpublishTrack(screenAudioTrack.track);
+      } else {
+        if (!(track === null || track === void 0 ? void 0 : track.track)) {
+          // if there's no track available yet first wait for pending publishing promises of that source to see if it becomes available
+          track = yield this.waitForPendingPublicationOfSource(source);
+        }
+        if (track && track.track) {
+          // screenshare cannot be muted, unpublish instead
+          if (source === Track.Source.ScreenShare) {
+            track = yield this.unpublishTrack(track.track);
+            const screenAudioTrack = this.getTrackPublication(Track.Source.ScreenShareAudio);
+            if (screenAudioTrack && screenAudioTrack.track) {
+              this.unpublishTrack(screenAudioTrack.track);
+            }
+          } else {
+            yield track.mute();
           }
-        } else {
-          yield track.mute();
         }
       }
       return track;
@@ -19182,109 +19487,121 @@ class LocalParticipant extends Participant {
    */
   publishTrack(track, options) {
     return __awaiter(this, void 0, void 0, function* () {
-      var _a, _b, _c, _d;
-      if (track instanceof LocalAudioTrack) {
-        track.setAudioContext(this.audioContext);
-      }
-      yield (_a = this.reconnectFuture) === null || _a === void 0 ? void 0 : _a.promise;
-      if (track instanceof LocalTrack && this.pendingPublishPromises.has(track)) {
-        yield this.pendingPublishPromises.get(track);
-      }
-      let defaultConstraints;
-      if (track instanceof MediaStreamTrack) {
-        defaultConstraints = track.getConstraints();
-      } else {
-        // we want to access constraints directly as `track.mediaStreamTrack`
-        // might be pointing to a non-device track (e.g. processed track) already
-        defaultConstraints = track.constraints;
-        let deviceKind = undefined;
-        switch (track.source) {
-          case Track.Source.Microphone:
-            deviceKind = 'audioinput';
-            break;
-          case Track.Source.Camera:
-            deviceKind = 'videoinput';
+      return this.publishOrRepublishTrack(track, options);
+    });
+  }
+  publishOrRepublishTrack(track_1, options_1) {
+    return __awaiter(this, arguments, void 0, function (track, options) {
+      var _this2 = this;
+      let isRepublish = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      return function* () {
+        var _a, _b, _c, _d;
+        if (track instanceof LocalAudioTrack) {
+          track.setAudioContext(_this2.audioContext);
         }
-        if (deviceKind && this.activeDeviceMap.has(deviceKind)) {
-          defaultConstraints = Object.assign(Object.assign({}, defaultConstraints), {
-            deviceId: this.activeDeviceMap.get(deviceKind)
-          });
+        yield (_a = _this2.reconnectFuture) === null || _a === void 0 ? void 0 : _a.promise;
+        if (_this2.republishPromise && !isRepublish) {
+          yield _this2.republishPromise;
         }
-      }
-      // convert raw media track into audio or video track
-      if (track instanceof MediaStreamTrack) {
-        switch (track.kind) {
-          case 'audio':
-            track = new LocalAudioTrack(track, defaultConstraints, true, this.audioContext, {
-              loggerName: this.roomOptions.loggerName,
-              loggerContextCb: () => this.logContext
-            });
-            break;
-          case 'video':
-            track = new LocalVideoTrack(track, defaultConstraints, true, {
-              loggerName: this.roomOptions.loggerName,
-              loggerContextCb: () => this.logContext
+        if (track instanceof LocalTrack && _this2.pendingPublishPromises.has(track)) {
+          yield _this2.pendingPublishPromises.get(track);
+        }
+        let defaultConstraints;
+        if (track instanceof MediaStreamTrack) {
+          defaultConstraints = track.getConstraints();
+        } else {
+          // we want to access constraints directly as `track.mediaStreamTrack`
+          // might be pointing to a non-device track (e.g. processed track) already
+          defaultConstraints = track.constraints;
+          let deviceKind = undefined;
+          switch (track.source) {
+            case Track.Source.Microphone:
+              deviceKind = 'audioinput';
+              break;
+            case Track.Source.Camera:
+              deviceKind = 'videoinput';
+          }
+          if (deviceKind && _this2.activeDeviceMap.has(deviceKind)) {
+            defaultConstraints = Object.assign(Object.assign({}, defaultConstraints), {
+              deviceId: _this2.activeDeviceMap.get(deviceKind)
             });
-            break;
-          default:
-            throw new TrackInvalidError("unsupported MediaStreamTrack kind ".concat(track.kind));
+          }
         }
-      } else {
-        track.updateLoggerOptions({
-          loggerName: this.roomOptions.loggerName,
-          loggerContextCb: () => this.logContext
+        // convert raw media track into audio or video track
+        if (track instanceof MediaStreamTrack) {
+          switch (track.kind) {
+            case 'audio':
+              track = new LocalAudioTrack(track, defaultConstraints, true, _this2.audioContext, {
+                loggerName: _this2.roomOptions.loggerName,
+                loggerContextCb: () => _this2.logContext
+              });
+              break;
+            case 'video':
+              track = new LocalVideoTrack(track, defaultConstraints, true, {
+                loggerName: _this2.roomOptions.loggerName,
+                loggerContextCb: () => _this2.logContext
+              });
+              break;
+            default:
+              throw new TrackInvalidError("unsupported MediaStreamTrack kind ".concat(track.kind));
+          }
+        } else {
+          track.updateLoggerOptions({
+            loggerName: _this2.roomOptions.loggerName,
+            loggerContextCb: () => _this2.logContext
+          });
+        }
+        // is it already published? if so skip
+        let existingPublication;
+        _this2.trackPublications.forEach(publication => {
+          if (!publication.track) {
+            return;
+          }
+          if (publication.track === track) {
+            existingPublication = publication;
+          }
         });
-      }
-      // is it already published? if so skip
-      let existingPublication;
-      this.trackPublications.forEach(publication => {
-        if (!publication.track) {
-          return;
+        if (existingPublication) {
+          _this2.log.warn('track has already been published, skipping', Object.assign(Object.assign({}, _this2.logContext), getLogContextFromTrack(existingPublication)));
+          return existingPublication;
+        }
+        const isStereoInput = 'channelCount' in track.mediaStreamTrack.getSettings() &&
+        // @ts-ignore `channelCount` on getSettings() is currently only available for Safari, but is generally the best way to determine a stereo track https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackSettings/channelCount
+        track.mediaStreamTrack.getSettings().channelCount === 2 || track.mediaStreamTrack.getConstraints().channelCount === 2;
+        const isStereo = (_b = options === null || options === void 0 ? void 0 : options.forceStereo) !== null && _b !== void 0 ? _b : isStereoInput;
+        // disable dtx for stereo track if not enabled explicitly
+        if (isStereo) {
+          if (!options) {
+            options = {};
+          }
+          if (options.dtx === undefined) {
+            _this2.log.info("Opus DTX will be disabled for stereo tracks by default. Enable them explicitly to make it work.", Object.assign(Object.assign({}, _this2.logContext), getLogContextFromTrack(track)));
+          }
+          if (options.red === undefined) {
+            _this2.log.info("Opus RED will be disabled for stereo tracks by default. Enable them explicitly to make it work.");
+          }
+          (_c = options.dtx) !== null && _c !== void 0 ? _c : options.dtx = false;
+          (_d = options.red) !== null && _d !== void 0 ? _d : options.red = false;
         }
-        if (publication.track === track) {
-          existingPublication = publication;
+        const opts = Object.assign(Object.assign({}, _this2.roomOptions.publishDefaults), options);
+        if (!isE2EESimulcastSupported() && _this2.roomOptions.e2ee) {
+          _this2.log.info("End-to-end encryption is set up, simulcast publishing will be disabled on Safari versions and iOS browsers running iOS < v17.2", Object.assign({}, _this2.logContext));
+          opts.simulcast = false;
         }
-      });
-      if (existingPublication) {
-        this.log.warn('track has already been published, skipping', Object.assign(Object.assign({}, this.logContext), getLogContextFromTrack(existingPublication)));
-        return existingPublication;
-      }
-      const isStereoInput = 'channelCount' in track.mediaStreamTrack.getSettings() &&
-      // @ts-ignore `channelCount` on getSettings() is currently only available for Safari, but is generally the best way to determine a stereo track https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackSettings/channelCount
-      track.mediaStreamTrack.getSettings().channelCount === 2 || track.mediaStreamTrack.getConstraints().channelCount === 2;
-      const isStereo = (_b = options === null || options === void 0 ? void 0 : options.forceStereo) !== null && _b !== void 0 ? _b : isStereoInput;
-      // disable dtx for stereo track if not enabled explicitly
-      if (isStereo) {
-        if (!options) {
-          options = {};
-        }
-        if (options.dtx === undefined) {
-          this.log.info("Opus DTX will be disabled for stereo tracks by default. Enable them explicitly to make it work.", Object.assign(Object.assign({}, this.logContext), getLogContextFromTrack(track)));
-        }
-        if (options.red === undefined) {
-          this.log.info("Opus RED will be disabled for stereo tracks by default. Enable them explicitly to make it work.");
-        }
-        (_c = options.dtx) !== null && _c !== void 0 ? _c : options.dtx = false;
-        (_d = options.red) !== null && _d !== void 0 ? _d : options.red = false;
-      }
-      const opts = Object.assign(Object.assign({}, this.roomOptions.publishDefaults), options);
-      if (!isE2EESimulcastSupported() && this.roomOptions.e2ee) {
-        this.log.info("End-to-end encryption is set up, simulcast publishing will be disabled on Safari versions and iOS browsers running iOS < v17.2", Object.assign({}, this.logContext));
-        opts.simulcast = false;
-      }
-      if (opts.source) {
-        track.source = opts.source;
-      }
-      const publishPromise = this.publish(track, opts, isStereo);
-      this.pendingPublishPromises.set(track, publishPromise);
-      try {
-        const publication = yield publishPromise;
-        return publication;
-      } catch (e) {
-        throw e;
-      } finally {
-        this.pendingPublishPromises.delete(track);
-      }
+        if (opts.source) {
+          track.source = opts.source;
+        }
+        const publishPromise = _this2.publish(track, opts, isStereo);
+        _this2.pendingPublishPromises.set(track, publishPromise);
+        try {
+          const publication = yield publishPromise;
+          return publication;
+        } catch (e) {
+          throw e;
+        } finally {
+          _this2.pendingPublishPromises.delete(track);
+        }
+      }();
     });
   }
   publish(track, opts, isStereo) {
@@ -19670,31 +19987,44 @@ class LocalParticipant extends Participant {
   }
   republishAllTracks(options_1) {
     return __awaiter(this, arguments, void 0, function (options) {
-      var _this2 = this;
+      var _this3 = this;
       let restartTracks = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
       return function* () {
-        const localPubs = [];
-        _this2.trackPublications.forEach(pub => {
-          if (pub.track) {
-            if (options) {
-              pub.options = Object.assign(Object.assign({}, pub.options), options);
-            }
-            localPubs.push(pub);
-          }
-        });
-        yield Promise.all(localPubs.map(pub => __awaiter(_this2, void 0, void 0, function* () {
-          const track = pub.track;
-          yield this.unpublishTrack(track, false);
-          if (restartTracks && !track.isMuted && track.source !== Track.Source.ScreenShare && track.source !== Track.Source.ScreenShareAudio && (track instanceof LocalAudioTrack || track instanceof LocalVideoTrack) && !track.isUserProvided) {
-            // generally we need to restart the track before publishing, often a full reconnect
-            // is necessary because computer had gone to sleep.
-            this.log.debug('restarting existing track', Object.assign(Object.assign({}, this.logContext), {
-              track: pub.trackSid
-            }));
-            yield track.restartTrack();
+        if (_this3.republishPromise) {
+          yield _this3.republishPromise;
+        }
+        _this3.republishPromise = new Promise((resolve, reject) => __awaiter(_this3, void 0, void 0, function* () {
+          try {
+            const localPubs = [];
+            this.trackPublications.forEach(pub => {
+              if (pub.track) {
+                if (options) {
+                  pub.options = Object.assign(Object.assign({}, pub.options), options);
+                }
+                localPubs.push(pub);
+              }
+            });
+            yield Promise.all(localPubs.map(pub => __awaiter(this, void 0, void 0, function* () {
+              const track = pub.track;
+              yield this.unpublishTrack(track, false);
+              if (restartTracks && !track.isMuted && track.source !== Track.Source.ScreenShare && track.source !== Track.Source.ScreenShareAudio && (track instanceof LocalAudioTrack || track instanceof LocalVideoTrack) && !track.isUserProvided) {
+                // generally we need to restart the track before publishing, often a full reconnect
+                // is necessary because computer had gone to sleep.
+                this.log.debug('restarting existing track', Object.assign(Object.assign({}, this.logContext), {
+                  track: pub.trackSid
+                }));
+                yield track.restartTrack();
+              }
+              yield this.publishOrRepublishTrack(track, pub.options, true);
+            })));
+            resolve();
+          } catch (error) {
+            reject(error);
+          } finally {
+            this.republishPromise = undefined;
           }
-          yield this.publishTrack(track, pub.options);
-        })));
+        }));
+        yield _this3.republishPromise;
       }();
     });
   }
@@ -19707,7 +20037,7 @@ class LocalParticipant extends Participant {
    */
   publishData(data_1) {
     return __awaiter(this, arguments, void 0, function (data) {
-      var _this3 = this;
+      var _this4 = this;
       let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       return function* () {
         const kind = options.reliable ? DataPacket_Kind.RELIABLE : DataPacket_Kind.LOSSY;
@@ -19718,17 +20048,57 @@ class LocalParticipant extends Participant {
           value: {
             case: 'user',
             value: new UserPacket({
-              participantIdentity: _this3.identity,
+              participantIdentity: _this4.identity,
               payload: data,
               destinationIdentities,
               topic
             })
           }
         });
-        yield _this3.engine.sendDataPacket(packet, kind);
+        yield _this4.engine.sendDataPacket(packet, kind);
       }();
     });
   }
+  sendChatMessage(text) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const msg = {
+        id: crypto.randomUUID(),
+        message: text,
+        timestamp: Date.now()
+      };
+      const packet = new DataPacket({
+        value: {
+          case: 'chatMessage',
+          value: new ChatMessage(Object.assign(Object.assign({}, msg), {
+            timestamp: protoInt64.parse(msg.timestamp)
+          }))
+        }
+      });
+      yield this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+      this.emit(ParticipantEvent.ChatMessage, msg);
+      return msg;
+    });
+  }
+  editChatMessage(editText, originalMessage) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const msg = Object.assign(Object.assign({}, originalMessage), {
+        message: editText,
+        editTimestamp: Date.now()
+      });
+      const packet = new DataPacket({
+        value: {
+          case: 'chatMessage',
+          value: new ChatMessage(Object.assign(Object.assign({}, msg), {
+            timestamp: protoInt64.parse(msg.timestamp),
+            editTimestamp: protoInt64.parse(msg.editTimestamp)
+          }))
+        }
+      });
+      yield this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+      this.emit(ParticipantEvent.ChatMessage, msg);
+      return msg;
+    });
+  }
   /**
    * Control who can subscribe to LocalParticipant's published tracks.
    *
@@ -19806,6 +20176,17 @@ class LocalParticipant extends Participant {
     });
     return publication;
   }
+  waitForPendingPublicationOfSource(source) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const publishPromiseEntry = Array.from(this.pendingPublishPromises.entries()).find(_ref3 => {
+        let [pendingTrack] = _ref3;
+        return pendingTrack.source === source;
+      });
+      if (publishPromiseEntry) {
+        return publishPromiseEntry[1];
+      }
+    });
+  }
 }
 
 class RemoteTrackPublication extends TrackPublication {
@@ -20876,6 +21257,8 @@ class Room extends eventsExports.EventEmitter {
         this.handleTranscription(participant, packet.value.value);
       } else if (packet.value.case === 'sipDtmf') {
         this.handleSipDtmf(participant, packet.value.value);
+      } else if (packet.value.case === 'chatMessage') {
+        this.handleChatMessage(participant, packet.value.value);
       }
     };
     this.handleUserPacket = (participant, userPacket, kind) => {
@@ -20898,6 +21281,10 @@ class Room extends eventsExports.EventEmitter {
       participant === null || participant === void 0 ? void 0 : participant.emit(ParticipantEvent.TranscriptionReceived, segments, publication);
       this.emit(RoomEvent.TranscriptionReceived, segments, participant, publication);
     };
+    this.handleChatMessage = (participant, chatMessage) => {
+      const msg = extractChatMessage(chatMessage);
+      this.emit(RoomEvent.ChatMessage, msg, participant);
+    };
     this.handleAudioPlaybackStarted = () => {
       if (this.canPlaybackAudio) {
         return;
@@ -20928,7 +21315,8 @@ class Room extends eventsExports.EventEmitter {
       }
     };
     this.handleDeviceChange = () => __awaiter(this, void 0, void 0, function* () {
-      const availableDevices = yield DeviceManager.getInstance().getDevices();
+      // check for available devices, but don't request permissions in order to avoid prompts for kinds that haven't been used before
+      const availableDevices = yield DeviceManager.getInstance().getDevices(undefined, false);
       // inputs are automatically handled via TrackEvent.Ended causing a TrackEvent.Restarted. Here we only need to worry about audiooutputs changing
       const kinds = ['audiooutput'];
       for (let kind of kinds) {
@@ -21024,6 +21412,9 @@ class Room extends eventsExports.EventEmitter {
     this.onLocalParticipantPermissionsChanged = prevPermissions => {
       this.emit(RoomEvent.ParticipantPermissionsChanged, prevPermissions, this.localParticipant);
     };
+    this.onLocalChatMessageSent = msg => {
+      this.emit(RoomEvent.ChatMessage, msg, this.localParticipant);
+    };
     this.setMaxListeners(100);
     this.remoteParticipants = new Map();
     this.sidToIdentity = new Map();
@@ -21483,7 +21874,7 @@ class Room extends eventsExports.EventEmitter {
     });
   }
   setupLocalParticipantEvents() {
-    this.localParticipant.on(ParticipantEvent.ParticipantMetadataChanged, this.onLocalParticipantMetadataChanged).on(ParticipantEvent.ParticipantNameChanged, this.onLocalParticipantNameChanged).on(ParticipantEvent.AttributesChanged, this.onLocalAttributesChanged).on(ParticipantEvent.TrackMuted, this.onLocalTrackMuted).on(ParticipantEvent.TrackUnmuted, this.onLocalTrackUnmuted).on(ParticipantEvent.LocalTrackPublished, this.onLocalTrackPublished).on(ParticipantEvent.LocalTrackUnpublished, this.onLocalTrackUnpublished).on(ParticipantEvent.ConnectionQualityChanged, this.onLocalConnectionQualityChanged).on(ParticipantEvent.MediaDevicesError, this.onMediaDevicesError).on(ParticipantEvent.AudioStreamAcquired, this.startAudio).on(ParticipantEvent.ParticipantPermissionsChanged, this.onLocalParticipantPermissionsChanged);
+    this.localParticipant.on(ParticipantEvent.ParticipantMetadataChanged, this.onLocalParticipantMetadataChanged).on(ParticipantEvent.ParticipantNameChanged, this.onLocalParticipantNameChanged).on(ParticipantEvent.AttributesChanged, this.onLocalAttributesChanged).on(ParticipantEvent.TrackMuted, this.onLocalTrackMuted).on(ParticipantEvent.TrackUnmuted, this.onLocalTrackUnmuted).on(ParticipantEvent.LocalTrackPublished, this.onLocalTrackPublished).on(ParticipantEvent.LocalTrackUnpublished, this.onLocalTrackUnpublished).on(ParticipantEvent.ConnectionQualityChanged, this.onLocalConnectionQualityChanged).on(ParticipantEvent.MediaDevicesError, this.onMediaDevicesError).on(ParticipantEvent.AudioStreamAcquired, this.startAudio).on(ParticipantEvent.ChatMessage, this.onLocalChatMessageSent).on(ParticipantEvent.ParticipantPermissionsChanged, this.onLocalParticipantPermissionsChanged);
   }
   recreateEngine() {
     var _a;
@@ -21577,7 +21968,7 @@ class Room extends eventsExports.EventEmitter {
           (_b = pub.track) === null || _b === void 0 ? void 0 : _b.stop();
         }
       });
-      this.localParticipant.off(ParticipantEvent.ParticipantMetadataChanged, this.onLocalParticipantMetadataChanged).off(ParticipantEvent.ParticipantNameChanged, this.onLocalParticipantNameChanged).off(ParticipantEvent.AttributesChanged, this.onLocalAttributesChanged).off(ParticipantEvent.TrackMuted, this.onLocalTrackMuted).off(ParticipantEvent.TrackUnmuted, this.onLocalTrackUnmuted).off(ParticipantEvent.LocalTrackPublished, this.onLocalTrackPublished).off(ParticipantEvent.LocalTrackUnpublished, this.onLocalTrackUnpublished).off(ParticipantEvent.ConnectionQualityChanged, this.onLocalConnectionQualityChanged).off(ParticipantEvent.MediaDevicesError, this.onMediaDevicesError).off(ParticipantEvent.AudioStreamAcquired, this.startAudio).off(ParticipantEvent.ParticipantPermissionsChanged, this.onLocalParticipantPermissionsChanged);
+      this.localParticipant.off(ParticipantEvent.ParticipantMetadataChanged, this.onLocalParticipantMetadataChanged).off(ParticipantEvent.ParticipantNameChanged, this.onLocalParticipantNameChanged).off(ParticipantEvent.AttributesChanged, this.onLocalAttributesChanged).off(ParticipantEvent.TrackMuted, this.onLocalTrackMuted).off(ParticipantEvent.TrackUnmuted, this.onLocalTrackUnmuted).off(ParticipantEvent.LocalTrackPublished, this.onLocalTrackPublished).off(ParticipantEvent.LocalTrackUnpublished, this.onLocalTrackUnpublished).off(ParticipantEvent.ConnectionQualityChanged, this.onLocalConnectionQualityChanged).off(ParticipantEvent.MediaDevicesError, this.onMediaDevicesError).off(ParticipantEvent.AudioStreamAcquired, this.startAudio).off(ParticipantEvent.ChatMessage, this.onLocalChatMessageSent).off(ParticipantEvent.ParticipantPermissionsChanged, this.onLocalParticipantPermissionsChanged);
       this.localParticipant.trackPublications.clear();
       this.localParticipant.videoTrackPublications.clear();
       this.localParticipant.audioTrackPublications.clear();