livekit-client 2.22.1 → 2.22.2

package/dist/livekit-client.e2ee.worker.mjs

@@ -6694,6 +6694,8 @@ class FrameCryptor extends BaseFrameCryptor {
     this.ERROR_THROTTLE_MS = 1000; // Emit error at most once per second
     this.MAX_ERRORS_PER_MINUTE = 5; // Maximum errors to emit per minute per key
     this.ERROR_WINDOW_MS = 60000; // 1 minute window
+    /** grace period for a teardown or a resubscribe to land before we report a stalled track */
+    this.UNDECRYPTED_TRACK_GRACE_MS = 2000;
     /**
      * Tracks (participant, trackId, payloadType) tuples for which we've already logged a NALU
      * fallback, so a persistent bad state doesn't flood the console (Firefox doesn't filter debug).
@@ -6738,9 +6740,13 @@ class FrameCryptor extends BaseFrameCryptor {
   }
   unsetParticipant() {
     workerLogger.debug('unsetting participant', this.logContext);
-    if (this.currentTransform) {
-      this.currentTransform = undefined;
-    }
+    // NOTE: deliberately does not clear `currentTransform`. Nothing here cancels
+    // the pipe, so the transform really is still running and clearing it would
+    // desync our bookkeeping from reality -- which previously let a later
+    // resubscribe skip setup while frames kept flowing through a cryptor with no
+    // participant assigned.
+    clearTimeout(this.undecryptedTrackTimeout);
+    this.undecryptedTrackTimeout = undefined;
     this.participantIdentity = undefined;
     this.lastErrorTimestamp = new Map();
     this.errorCounts = new Map();
@@ -6758,6 +6764,72 @@ class FrameCryptor extends BaseFrameCryptor {
   getTrackId() {
     return this.trackId;
   }
+  /**
+   * Re-point this cryptor at a new trackId, keeping its (already transferred)
+   * encoded streams. Used when a transceiver is reused for a new track.
+   */
+  setTrackId(trackId) {
+    if (this.trackId === trackId) {
+      return;
+    }
+    workerLogger.debug('re-pointing cryptor at new trackId', Object.assign(Object.assign({}, this.logContext), {
+      newTrackId: trackId
+    }));
+    this.trackId = trackId;
+  }
+  hasActiveTransform() {
+    return !!this.currentTransform;
+  }
+  /**
+   * A track that is subscribed and known to be encrypted, but has no transform to
+   * decrypt it, will never produce a decodable frame again. That state used to be
+   * completely silent (a black tile and endless PLIs), so report it.
+   *
+   * Deferred, because on teardown the encoded streams routinely close before the
+   * 'removeTransform' message arrives -- checking immediately would cry wolf on
+   * every unsubscribe.
+   *
+   * Only meaningful while decoding: a sender's pipe closing on unpublish is
+   * routine and has no 'removeTransform' equivalent to quiet it down.
+   */
+  scheduleUndecryptedTrackWatchdog(operation) {
+    clearTimeout(this.undecryptedTrackTimeout);
+    this.undecryptedTrackTimeout = undefined;
+    if (operation !== 'decode') {
+      return;
+    }
+    this.undecryptedTrackTimeout = setTimeout(() => {
+      if (this.currentTransform || !this.isEnabled()) {
+        return;
+      }
+      workerLogger.warn('encrypted track has no active decrypt transform', this.logContext);
+      this.emitThrottledError(new CryptorError("no active decrypt transform for encrypted track ".concat(this.trackId), CryptorErrorReason.InternalError, this.participantIdentity));
+    }, this.UNDECRYPTED_TRACK_GRACE_MS);
+  }
+  /**
+   * Re-establish the transform if it is gone while we still own the encoded
+   * streams, e.g. after a pipe died on its own (the swallowed
+   * 'Destination stream closed') or when a reused transceiver never got a new
+   * pipeline. Without this the frames pile up in a readable nobody reads and the
+   * decoder starves, which shows up as a permanently black tile.
+   */
+  ensureTransform() {
+    if (this.currentTransform) {
+      return true;
+    }
+    if (!this.retainedStreams || this.trackId === undefined) {
+      workerLogger.warn('no streams retained, cannot re-establish transform', this.logContext);
+      return false;
+    }
+    const _this$retainedStreams = this.retainedStreams,
+      readable = _this$retainedStreams.readable,
+      writable = _this$retainedStreams.writable,
+      operation = _this$retainedStreams.operation;
+    workerLogger.info('re-establishing transform', Object.assign(Object.assign({}, this.logContext), {
+      operation
+    }));
+    return this.setupTransform(operation, readable, writable, this.trackId);
+  }
   /**
    * Update the video codec used by the mediaStreamTrack
    * @param codec
@@ -6784,7 +6856,8 @@ class FrameCryptor extends BaseFrameCryptor {
     this.frameMetadataOpts = frameMetadata;
     this.frameMetadataFrameId = 0;
   }
-  setupTransform(operation, readable, writable, trackId, isReuse, codec, frameMetadata) {
+  setupTransform(operation, readable, writable, trackId, codec, frameMetadata) {
+    var _a;
     if (codec) {
       workerLogger.info('setting codec on cryptor to', {
         codec
@@ -6798,18 +6871,17 @@ class FrameCryptor extends BaseFrameCryptor {
       operation,
       passedTrackId: trackId,
       codec,
-      isReuse,
       hasCurrentTransform: !!this.currentTransform
     }, this.logContext));
-    // Always update trackId, even on reuse
     this.trackId = trackId;
-    // If we're reusing and have an active transform skip setup
-    if (isReuse && this.currentTransform && readable === this.currentTransform.readable && writable === this.currentTransform.writable) {
-      workerLogger.debug('reusing existing transform', Object.assign(Object.assign({}, this.logContext), {
-        trackId
-      }));
-      return;
-    }
+    // Retain the streams so we can rebuild the pipe later even if this cryptor
+    // gets detached from its participant in between (see `ensureTransform`).
+    this.retainedStreams = {
+      readable,
+      writable,
+      operation
+    };
+    clearTimeout(this.undecryptedTrackTimeout);
     const symbol = Symbol('transform');
     const transformFn = operation === 'encode' ? this.encodeFunction : this.decodeFunction;
     const transformStream = new TransformStream({
@@ -6823,26 +6895,43 @@ class FrameCryptor extends BaseFrameCryptor {
       trackId,
       symbol
     };
-    readable.pipeThrough(transformStream).pipeTo(writable).catch(e => {
-      if (e instanceof TypeError && e.message === 'Destination stream closed') {
-        // this can happen when subscriptions happen in quick successions, but doesn't influence functionality
-        workerLogger.debug('destination stream closed');
-      } else {
-        workerLogger.warn('transform error', Object.assign({
-          error: e
-        }, this.logContext));
-        this.emit(CryptorEvent.Error, e instanceof CryptorError ? e : new CryptorError(e.message, undefined, this.participantIdentity));
-      }
-    }).finally(() => {
-      var _a;
-      // Only clear currentTransform if it's still the same one we started
+    // pipeThrough/pipeTo throw synchronously on an already locked stream, which
+    // would bypass the .catch below and leave us with no transform at all.
+    try {
+      readable.pipeThrough(transformStream).pipeTo(writable).catch(e => {
+        if (e instanceof TypeError && e.message === 'Destination stream closed') {
+          // this can happen when subscriptions happen in quick successions, but doesn't influence functionality
+          workerLogger.debug('destination stream closed');
+        } else {
+          workerLogger.warn('transform error', Object.assign({
+            error: e
+          }, this.logContext));
+          this.emit(CryptorEvent.Error, e instanceof CryptorError ? e : new CryptorError(e.message, undefined, this.participantIdentity));
+        }
+      }).finally(() => {
+        var _a;
+        // Only clear currentTransform if it's still the same one we started
+        if (((_a = this.currentTransform) === null || _a === void 0 ? void 0 : _a.symbol) === symbol) {
+          workerLogger.debug('transform completed', Object.assign(Object.assign({}, this.logContext), {
+            trackId
+          }));
+          this.currentTransform = undefined;
+        }
+        // A pipe ending while the track is still assigned to a participant that
+        // publishes encrypted media means we have silently stopped decrypting.
+        this.scheduleUndecryptedTrackWatchdog(operation);
+      });
+    } catch (e) {
       if (((_a = this.currentTransform) === null || _a === void 0 ? void 0 : _a.symbol) === symbol) {
-        workerLogger.debug('transform completed', Object.assign(Object.assign({}, this.logContext), {
-          trackId
-        }));
         this.currentTransform = undefined;
       }
-    });
+      workerLogger.error('failed to set up transform', Object.assign({
+        error: e
+      }, this.logContext));
+      this.emit(CryptorEvent.Error, e instanceof CryptorError ? e : new CryptorError(e.message, CryptorErrorReason.InternalError, this.participantIdentity));
+      return false;
+    }
+    return true;
   }
   setSifTrailer(trailer) {
     workerLogger.debug('setting SIF trailer', Object.assign(Object.assign({}, this.logContext), {
@@ -7023,9 +7112,29 @@ class FrameCryptor extends BaseFrameCryptor {
           // best-effort: never break the media pipeline if trailer parsing fails
         }
       }
-      if (!this.isEnabled() ||
-      // skip for decryption for empty dtx frames
-      encodedFrame.data.byteLength === 0) {
+      // skip decryption for empty dtx frames
+      if (encodedFrame.data.byteLength === 0) {
+        return controller.enqueue(encodedFrame);
+      }
+      const encryptionEnabled = this.isEnabled();
+      if (encryptionEnabled === undefined) {
+        // Either way we drop: forwarding would hand ciphertext straight to the
+        // decoder, which renders as a black frame and logs nothing.
+        if (this.participantIdentity === undefined) {
+          // The pipe outlived its subscription. Expected on unsubscribe/disconnect:
+          // we deliberately leave the pipe running so a reused transceiver can be
+          // re-pointed at a new track, so in-flight frames still arrive here for a
+          // moment. Not worth reporting -- the watchdog covers a track that stays
+          // subscribed without a transform.
+          workerLogger.debug('dropping frame for unassigned cryptor', this.logContext);
+          return;
+        }
+        // A live subscription whose encryption state we were never told about.
+        this.emitThrottledError(new CryptorError("encryption state unknown for track ".concat(this.trackId, ", dropping frame"), CryptorErrorReason.InternalError, this.participantIdentity));
+        return;
+      }
+      if (!encryptionEnabled) {
+        // participant is known to publish unencrypted media
         return controller.enqueue(encodedFrame);
       }
       if (isFrameServerInjected(encodedFrame.data, this.sifTrailer)) {
@@ -7527,12 +7636,12 @@ onmessage = ev => {
       case 'decode':
         let cryptor = getTrackCryptor(data.participantIdentity, data.trackId);
         cryptor.setHasFrameMetadata(data.hasPacketTrailer);
-        cryptor.setupTransform(kind, data.readableStream, data.writableStream, data.trackId, data.isReuse, data.codec);
+        cryptor.setupTransform(kind, data.readableStream, data.writableStream, data.trackId, data.codec);
         break;
       case 'encode':
         let pubCryptor = getTrackCryptor(data.participantIdentity, data.trackId);
         pubCryptor.setHasFrameMetadata(data.hasPacketTrailer);
-        pubCryptor.setupTransform(kind, data.readableStream, data.writableStream, data.trackId, data.isReuse, data.codec, data.packetTrailer);
+        pubCryptor.setupTransform(kind, data.readableStream, data.writableStream, data.trackId, data.codec, data.packetTrailer);
         break;
       case 'encryptDataRequest':
         const _yield$DataCryptor$en = yield DataCryptor.encrypt(data.payload, getParticipantKeyHandler(data.participantIdentity)),
@@ -7595,15 +7704,28 @@ onmessage = ev => {
         unsetCryptorParticipant(data.trackId, data.participantIdentity);
         break;
       case 'updateCodec':
-        const trackCryptor = getTrackCryptor(data.participantIdentity, data.trackId);
-        trackCryptor.setVideoCodec(data.codec);
+        const trackCryptor = getTrackCryptor(data.participantIdentity, data.trackId, data.previousTrackId);
+        if (data.codec) {
+          trackCryptor.setVideoCodec(data.codec);
+        }
         trackCryptor.setHasFrameMetadata(data.hasPacketTrailer);
         workerLogger.info('updated codec', {
           participantIdentity: data.participantIdentity,
           trackId: data.trackId,
+          previousTrackId: data.previousTrackId,
           codec: data.codec,
           hasPacketTrailer: data.hasPacketTrailer
         });
+        // Sent on transceiver reuse, where the main thread cannot hand us a new
+        // pipeline. If the previous one died in the meantime we have to rebuild it
+        // here or no frame ever gets decrypted again.
+        if (data.previousTrackId !== undefined && !trackCryptor.ensureTransform()) {
+          workerLogger.error('could not re-establish transform for reused receiver', {
+            participantIdentity: data.participantIdentity,
+            trackId: data.trackId,
+            previousTrackId: data.previousTrackId
+          });
+        }
         break;
       case 'setRTPMap':
         // this is only used for the local participant
@@ -7638,8 +7760,24 @@ function handleRatchetRequest(data) {
     }
   });
 }
-function getTrackCryptor(participantIdentity, trackId) {
+function getTrackCryptor(participantIdentity, trackId, previousTrackId) {
   let cryptors = participantCryptors.filter(c => c.getTrackId() === trackId);
+  if (cryptors.length === 0 && previousTrackId !== undefined && previousTrackId !== trackId) {
+    // A reused transceiver carries a new trackId, but the cryptor that owns this
+    // receiver's encoded streams is still keyed on the old one. Re-point it instead
+    // of creating a fresh cryptor that has no pipeline (and leaving the old one
+    // piping frames with no participant assigned).
+    const previous = participantCryptors.filter(c => c.getTrackId() === previousTrackId);
+    if (previous.length > 0) {
+      workerLogger.info('reusing cryptor from previous trackId', {
+        participantIdentity,
+        trackId,
+        previousTrackId
+      });
+      previous[0].setTrackId(trackId);
+      cryptors = previous;
+    }
+  }
   if (cryptors.length > 1) {
     const debugInfo = cryptors.map(c => {
       return {
@@ -7775,7 +7913,7 @@ if (self.RTCTransformEvent) {
         trackId,
         codec
       });
-      cryptor.setupTransform(kind, transformer.readable, transformer.writable, trackId, false, codec, kind === 'encode' ? options.packetTrailer : undefined);
+      cryptor.setupTransform(kind, transformer.readable, transformer.writable, trackId, codec, kind === 'encode' ? options.packetTrailer : undefined);
     }));
   };
 }