livekit-client 2.22.1 → 2.22.2

package/dist/livekit-client.esm.mjs

@@ -12208,7 +12208,7 @@ function getMatch(exp, ua) {
 }
 function getOSVersion(ua) {
   return ua.includes('mac os') ? getMatch(/\(.+?(\d+_\d+(:?_\d+)?)/, ua, 1).replace(/_/g, '.') : undefined;
-}var version$1 = "2.22.1";const version = version$1;
+}var version$1 = "2.22.2";const version = version$1;
 const protocolVersion = 17;
 /** Initial client protocol. */
 const CLIENT_PROTOCOL_DEFAULT = 0;
@@ -14829,6 +14829,11 @@ function getAbortReasonAsString(signal) {
 const DECRYPTION_FAILURE_TOLERANCE = 10;
 // flag set to indicate that e2ee has been setup for sender/receiver;
 const E2EE_FLAG = 'lk_e2ee';
+/**
+ * trackId a receiver's/sender's encoded stream pipeline was last set up for.
+ * Needed to recover the right cryptor when a transceiver gets reused.
+ */
+const E2EE_TRACK_ID = 'lk_e2ee_track_id';
 const SALT = 'LKFrameEncryptionKey';
 const KEY_PROVIDER_DEFAULTS = {
   sharedKey: false,
@@ -15925,12 +15930,12 @@ class E2EEManager extends eventsExports.EventEmitter {
     });
   }
   setupEventListeners(room, keyProvider) {
-    room.on(RoomEvent.TrackPublished, (pub, participant) => this.setParticipantCryptorEnabled(pub.trackInfo.encryption !== Encryption_Type.NONE, participant.identity));
+    room.on(RoomEvent.TrackPublished, (pub, participant) => this.setParticipantCryptorEnabledForPublication(pub, participant.identity));
     room.on(RoomEvent.ConnectionStateChanged, state => {
       if (state === ConnectionState.Connected) {
         room.remoteParticipants.forEach(participant => {
           participant.trackPublications.forEach(pub => {
-            this.setParticipantCryptorEnabled(pub.trackInfo.encryption !== Encryption_Type.NONE, participant.identity);
+            this.setParticipantCryptorEnabledForPublication(pub, participant.identity);
           });
         });
       }
@@ -16100,6 +16105,22 @@ class E2EEManager extends eventsExports.EventEmitter {
     };
     this.worker.postMessage(msg);
   }
+  /**
+   * Derive the participant's encryption state from one of its publications.
+   * Publications without trackInfo are skipped rather than thrown on: throwing
+   * inside the forEach above would leave every remaining participant without an
+   * encryption state, and a cryptor with unknown state can no longer decrypt.
+   */
+  setParticipantCryptorEnabledForPublication(pub, participantIdentity) {
+    if (!pub.trackInfo) {
+      livekitLogger.warn('skipping e2ee enabled update for publication without trackInfo', {
+        participant: participantIdentity,
+        trackSid: pub.trackSid
+      });
+      return;
+    }
+    this.setParticipantCryptorEnabled(pub.trackInfo.encryption !== Encryption_Type.NONE, participantIdentity);
+  }
   setupE2EEReceiver(track, remoteId, trackInfo) {
     if (!track.receiver) {
       return;
@@ -16136,21 +16157,27 @@ class E2EEManager extends eventsExports.EventEmitter {
           codec,
           hasPacketTrailer
         };
-        // @ts-ignore
         receiver.transform = new RTCRtpScriptTransform(this.worker, options);
       } else {
-        if (E2EE_FLAG in receiver && codec) {
-          // update track-specific state when the transceiver is reused
+        if (E2EE_FLAG in receiver && E2EE_TRACK_ID in receiver) {
+          // The transceiver is being reused for a new track. We cannot set up a new
+          // pipeline from here: this receiver's encoded streams were transferred to
+          // the worker on first setup and a transferred stream can't be transferred
+          // again, while createEncodedStreams() may only be called once per receiver.
+          // So hand the worker the new track/participant and let it re-point (and if
+          // necessary rebuild) the cryptor that still owns those streams.
           const msg = {
             kind: 'updateCodec',
             data: {
               trackId,
+              previousTrackId: receiver[E2EE_TRACK_ID],
               codec,
               participantIdentity,
               hasPacketTrailer
             }
           };
           this.worker.postMessage(msg);
+          receiver[E2EE_TRACK_ID] = trackId;
           return;
         }
         // @ts-ignore
@@ -16175,7 +16202,6 @@ class E2EEManager extends eventsExports.EventEmitter {
             trackId: trackId,
             codec,
             participantIdentity: participantIdentity,
-            isReuse: E2EE_FLAG in receiver,
             hasPacketTrailer
           }
         };
@@ -16183,6 +16209,8 @@ class E2EEManager extends eventsExports.EventEmitter {
       }
       // @ts-ignore
       receiver[E2EE_FLAG] = true;
+      // @ts-ignore
+      receiver[E2EE_TRACK_ID] = trackId;
     });
   }
   /**
@@ -16222,7 +16250,6 @@ class E2EEManager extends eventsExports.EventEmitter {
           codec,
           trackId,
           participantIdentity: this.room.localParticipant.identity,
-          isReuse: false,
           hasPacketTrailer: hasFrameMetadataPublishOptions(frameMetadata),
           packetTrailer: frameMetadata
         }
@@ -18500,6 +18527,7 @@ class SignalClient {
       if (firstMessage) {
         this.handleSignalResponse(firstMessage);
       }
+      const attemptId = this.attemptId;
       while (true) {
         if (this.signalLatency) {
           yield sleep(this.signalLatency);
@@ -18517,7 +18545,7 @@ class SignalClient {
           this.log.error("error reading from signal stream", {
             error: e
           });
-          yield this.close(false, 'error in reading loop');
+          yield this.handleOnClose('error in reading loop', attemptId);
           break;
         }
       }
@@ -21074,13 +21102,21 @@ class PCTransportManager {
       this.updateState();
     });
   }
+  /**
+   * Restarts ICE on the transports that need it. Only the publisher: the server restarts the
+   * subscriber's ICE itself and follows with a fresh offer.
+   *
+   * The subscriber deliberately does NOT enter `restartingIce` here. Queueing its remote
+   * candidates would guard against candidates for a new generation arriving before the offer
+   * that introduces it, but the server does not send them in that order -- on a same-node
+   * resume it buffers them until the offer has gone out, and on a reconnect that lands on
+   * another node it withholds subscriber candidates until immediately before creating the
+   * offer. Setting the flag only risks withholding candidates during the window that decides
+   * whether the reconnect succeeded.
+   */
   triggerIceRestart() {
     return __awaiter(this, void 0, void 0, function* () {
       this.iceLog.warn('triggering ICE restart');
-      if (this.subscriber) {
-        this.subscriber.restartingIce = true;
-      }
-      // only restart publisher if it's needed
       if (this.needsPublisher) {
         yield this.createAndSendPublisherOffer({
           iceRestart: true
@@ -25911,8 +25947,11 @@ const DEFAULT_MAX_PAYLOAD_BYTE_LENGTH = 5000000000;class BaseStreamReader {
     this._info = info;
     this.bytesReceived = 0;
   }
-}
-class ByteStreamReader extends BaseStreamReader {
+  /**
+   * Counts a chunk's bytes against `totalByteSize` and reports progress. Chunk ordering and
+   * de-duplication happen upstream in the manager's `ensureOrderedChunks`, so every chunk reaching
+   * here is new and in order.
+   */
   handleChunkReceived(chunk) {
     var _a;
     this.bytesReceived += chunk.content.byteLength;
@@ -25920,6 +25959,8 @@ class ByteStreamReader extends BaseStreamReader {
     const currentProgress = this.totalByteSize ? this.bytesReceived / this.totalByteSize : undefined;
     (_a = this.onProgress) === null || _a === void 0 ? void 0 : _a.call(this, currentProgress);
   }
+}
+class ByteStreamReader extends BaseStreamReader {
   [Symbol.asyncIterator]() {
     const reader = this.reader.getReader();
     // Suppress unhandled rejection on reader.closed — errors are
@@ -26027,35 +26068,18 @@ class ByteStreamReader extends BaseStreamReader {
   }
 }
 /**
- * A class to read chunks from a ReadableStream and provide them in a structured format.
+ * A class to read chunks from a ReadableStream and decode them as UTF-8 text.
+ *
+ * NOTE: chunk-level `version` (resending a chunk at an already-received `chunkIndex` to supersede
+ * it) is not supported. The reader used to rebuild the whole string from a per-index chunk map and
+ * yield it as `TextStreamChunk.collected`, which made superseding work; 5d4a6346 (#1410, text auto
+ * chunking) changed the iterator to yield each chunk's text as it arrives, and a streaming reader
+ * cannot retract text it has already handed to the consumer. No sender emits a versioned chunk.
  */
 class TextStreamReader extends BaseStreamReader {
-  /**
-   * A TextStreamReader instance can be used as an AsyncIterator that returns the entire string
-   * that has been received up to the current point in time.
-   */
-  constructor(info, stream, totalChunkCount) {
-    super(info, stream, totalChunkCount);
-    this.receivedChunks = new Map();
-  }
-  handleChunkReceived(chunk) {
-    var _a;
-    const index = bigIntToNumber(chunk.chunkIndex);
-    const previousChunkAtIndex = this.receivedChunks.get(index);
-    if (previousChunkAtIndex && previousChunkAtIndex.version > chunk.version) {
-      // we have a newer version already, dropping the old one
-      return;
-    }
-    this.receivedChunks.set(index, chunk);
-    this.bytesReceived += chunk.content.byteLength;
-    this.validateBytesReceived();
-    const currentProgress = this.totalByteSize ? this.bytesReceived / this.totalByteSize : undefined;
-    (_a = this.onProgress) === null || _a === void 0 ? void 0 : _a.call(this, currentProgress);
-  }
   /**
    * Async iterator implementation to allow usage of `for await...of` syntax.
-   * Yields structured chunks from the stream.
-   *
+   * Yields each chunk's decoded text as it arrives - a delta, not the string accumulated so far.
    */
   [Symbol.asyncIterator]() {
     const reader = this.reader.getReader();
@@ -26326,7 +26350,7 @@ class TextStreamReader extends BaseStreamReader {
               });
             }
           });
-          streamHandlerCallback(new ByteStreamReader(info, compressed ? inflateRawByteChunkStream(stream, streamHeader.streamId, this.maxPayloadByteLength) : stream,
+          streamHandlerCallback(new ByteStreamReader(info, compressed ? inflateRawByteChunkStream(stream, streamHeader.streamId, this.maxPayloadByteLength) : stream.pipeThrough(ensureOrderedChunks(streamHeader.streamId)),
           // `totalLength` is the pre-compression size, and the reader counts decompressed bytes,
           // so it applies to both paths (mirrors text).
           bigIntToNumber(streamHeader.totalLength)), {
@@ -26398,7 +26422,7 @@ class TextStreamReader extends BaseStreamReader {
               });
             }
           });
-          streamHandlerCallback(new TextStreamReader(info, compressed ? inflateRawChunkStream(stream, streamHeader.streamId, this.maxPayloadByteLength) : stream,
+          streamHandlerCallback(new TextStreamReader(info, compressed ? inflateRawChunkStream(stream, streamHeader.streamId, this.maxPayloadByteLength) : stream.pipeThrough(ensureOrderedChunks(streamHeader.streamId)),
           // `totalLength` is the pre-compression size, and the reader sees decompressed bytes, so
           // it applies to both paths.
           bigIntToNumber(streamHeader.totalLength)), {
@@ -26414,7 +26438,7 @@ class TextStreamReader extends BaseStreamReader {
       if (fileBuffer.info.encryptionType !== encryptionType) {
         fileBuffer.controller.error(new DataStreamError("Encryption type mismatch for stream ".concat(chunk.streamId, ". Expected ").concat(encryptionType, ", got ").concat(fileBuffer.info.encryptionType), DataStreamErrorReason.EncryptionTypeMismatch));
         this.byteStreamControllers.delete(chunk.streamId);
-      } else if (chunk.content.length > 0) {
+      } else {
         fileBuffer.controller.enqueue(chunk);
       }
     }
@@ -26423,7 +26447,7 @@ class TextStreamReader extends BaseStreamReader {
       if (textBuffer.info.encryptionType !== encryptionType) {
         textBuffer.controller.error(new DataStreamError("Encryption type mismatch for stream ".concat(chunk.streamId, ". Expected ").concat(encryptionType, ", got ").concat(textBuffer.info.encryptionType), DataStreamErrorReason.EncryptionTypeMismatch));
         this.textStreamControllers.delete(chunk.streamId);
-      } else if (chunk.content.length > 0) {
+      } else {
         textBuffer.controller.enqueue(chunk);
       }
     }
@@ -26471,26 +26495,24 @@ class TextStreamReader extends BaseStreamReader {
 function createInlineStream(streamId, content) {
   return new ReadableStream({
     start: controller => __awaiter(this, void 0, void 0, function* () {
-      try {
-        const bytes = yield content;
-        controller.enqueue(new DataStream_Chunk({
-          streamId,
-          chunkIndex: BigInt(0),
-          content: bytes
-        }));
-        controller.close();
-      } catch (err) {
-        controller.error(err);
-      }
+      const bytes = yield content;
+      controller.enqueue(new DataStream_Chunk({
+        streamId,
+        chunkIndex: BigInt(0),
+        content: bytes
+      }));
+      controller.close();
     })
   });
 }
 /**
  * Validates that chunks are received in order, dropping duplicates and throwing if gaps are found.
  *
- * A stateful decompressor silently corrupts on duplicated or out-of-order input, so duplicates are
- * dropped (with a warning - in-order delivery is expected on the reliable channel, but reconnect
- * handling may replay) and a gap is a hard error. Shared by the text and byte deflate-raw decoders.
+ * Reassembly (and, for compressed streams, a stateful decompressor) silently corrupts on duplicated
+ * or out-of-order input, so duplicates are dropped (with a warning - in-order delivery is expected
+ * on the reliable channel, but reconnect handling may replay) and a gap is a hard error. Empty
+ * chunks consume their index and are then dropped, so they never reach the reader. Applied to every
+ * chunked stream, compressed or not.
  */
 function ensureOrderedChunks(streamId) {
   let lastChunkIndex = -1;
@@ -26498,13 +26520,16 @@ function ensureOrderedChunks(streamId) {
     transform: (value, controller) => {
       const index = bigIntToNumber(value.chunkIndex);
       if (index <= lastChunkIndex) {
-        livekitLogger.warn("ignoring duplicate chunk ".concat(index, " for compressed data stream ").concat(streamId, " (last processed: ").concat(lastChunkIndex, ")"));
+        livekitLogger.warn("ignoring duplicate chunk ".concat(index, " ").concat(value.version > 0 ? "(version ".concat(value.version, ")") : '', " for data stream ").concat(streamId, " (last processed: ").concat(lastChunkIndex, ")"));
         return;
       }
       if (index > lastChunkIndex + 1) {
-        throw new DataStreamError("Missing chunk(s) ".concat(lastChunkIndex + 1, "..").concat(index - 1, " for compressed data stream ").concat(streamId, " - cannot continue decompressing"), DataStreamErrorReason.Incomplete);
+        throw new DataStreamError("Missing chunk(s) ".concat(lastChunkIndex + 1, "..").concat(index - 1, " for data stream ").concat(streamId, " - cannot reassemble payload"), DataStreamErrorReason.Incomplete);
       }
       lastChunkIndex = index;
+      if (value.content.length === 0) {
+        return;
+      }
       controller.enqueue(value);
     }
   });