livekit-client 2.22.1 → 2.22.3

package/src/e2ee/worker/e2ee.worker.ts

@@ -18,6 +18,7 @@ import type {
   ScriptTransformOptions,
 } from '../types';
 import { DataCryptor } from './DataCryptor';
+import { ErrorRateLimiter } from './ErrorRateLimiter';
 import { FrameCryptor, encryptionEnabledMap } from './FrameCryptor';
 import { ParticipantKeyHandler } from './ParticipantKeyHandler';
 
@@ -36,8 +37,21 @@ let keyProviderOptions: KeyProviderOptions = KEY_PROVIDER_DEFAULTS;
 
 let rtpMap: Map<number, VideoCodec> = new Map();
 
+const dataDecryptErrorLimiter = new ErrorRateLimiter();
+
 workerLogger.setDefaultLevel('info');
 
+// Forward worker log calls to the main thread so they reach any
+// setLogExtension consumer installed there. The main-thread workerLogger
+// re-emits them, which invokes both the console and the extension.
+workerLogger.methodFactory = (methodName) => (msg, context) => {
+  postMessage({
+    kind: 'log',
+    data: { level: methodName, msg, context },
+  });
+};
+workerLogger.setLevel(workerLogger.getLevel());
+
 onmessage = (ev) => {
   messageQueue.run(async () => {
     const { kind, data }: E2EEWorkerMessage = ev.data;
@@ -45,7 +59,7 @@ onmessage = (ev) => {
     switch (kind) {
       case 'init':
         workerLogger.setLevel(data.loglevel);
-        workerLogger.info('worker initialized');
+        workerLogger.info('e2ee worker initialized');
         keyProviderOptions = data.keyProviderOptions;
         useSharedKey = !!data.keyProviderOptions.sharedKey;
         // acknowledge init successful
@@ -55,6 +69,9 @@ onmessage = (ev) => {
         };
         postMessage(ackMsg);
         break;
+      case 'setLogLevel':
+        workerLogger.setLevel(data.level);
+        break;
       case 'enable':
         setEncryptionEnabled(data.enabled, data.participantIdentity);
         workerLogger.info(
@@ -71,7 +88,6 @@ onmessage = (ev) => {
           data.readableStream,
           data.writableStream,
           data.trackId,
-          data.isReuse,
           data.codec,
         );
         break;
@@ -83,7 +99,6 @@ onmessage = (ev) => {
           data.readableStream,
           data.writableStream,
           data.trackId,
-          data.isReuse,
           data.codec,
           data.packetTrailer, // wire format still uses 'packetTrailer' field name
         );
@@ -98,11 +113,6 @@ onmessage = (ev) => {
           data.payload,
           getParticipantKeyHandler(data.participantIdentity),
         );
-        console.log('encrypted payload', {
-          original: data.payload,
-          encrypted: encryptedPayload,
-          iv,
-        });
         postMessage({
           kind: 'encryptDataResponse',
           data: {
@@ -127,12 +137,23 @@ onmessage = (ev) => {
             data: { payload: decryptedPayload, uuid: data.uuid },
           } satisfies DecryptDataResponseMessage);
         } catch (error) {
-          // Send error back to main thread with uuid so it can reject the corresponding promise
-          workerLogger.error('DataCryptor decryption failed', {
-            error,
-            participantIdentity: data.participantIdentity,
-            uuid: data.uuid,
+          // Send error back to main thread with uuid so it can reject the corresponding promise.
+          // The error response must always be posted so the awaiting future resolves; only the
+          // log is throttled to avoid flooding when a broken key keeps producing failures.
+          const errorKey = `${data.participantIdentity}-datadecrypt`;
+          const shouldLog = dataDecryptErrorLimiter.shouldEmit(errorKey, () => {
+            workerLogger.warn(
+              `Suppressing further data decryption errors for ${data.participantIdentity}`,
+              { errorKey },
+            );
           });
+          if (shouldLog) {
+            workerLogger.error('DataCryptor decryption failed', {
+              error,
+              participantIdentity: data.participantIdentity,
+              uuid: data.uuid,
+            });
+          }
           postMessage({
             kind: 'error',
             data: {
@@ -163,15 +184,32 @@ 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
@@ -210,8 +248,26 @@ async function handleRatchetRequest(data: RatchetRequestMessage['data']) {
   }
 }
 
-function getTrackCryptor(participantIdentity: string, trackId: string) {
+function getTrackCryptor(participantIdentity: string, trackId: string, previousTrackId?: string) {
   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) => {
@@ -351,7 +407,6 @@ if (self.RTCTransformEvent) {
         transformer.readable,
         transformer.writable,
         trackId,
-        false,
         codec,
         kind === 'encode' ? options.packetTrailer : undefined,
       );

package/src/logger.ts

@@ -131,3 +131,25 @@ export function setLogExtension(extension: LogExtension, logger?: StructuredLogg
 }
 
 export const workerLogger = log.getLogger(LoggerNames.E2EE) as StructuredLogger;
+
+const workerLogLevelListeners = new Set<(level: LogLevel) => void>();
+
+const originalWorkerSetLevel = workerLogger.setLevel.bind(workerLogger);
+workerLogger.setLevel = ((level: log.LogLevelDesc, persist?: boolean) => {
+  originalWorkerSetLevel(level, persist);
+  const numeric = workerLogger.getLevel() as LogLevel;
+  workerLogLevelListeners.forEach((cb) => cb(numeric));
+}) as typeof workerLogger.setLevel;
+
+/** @internal Subscribe to workerLogger level changes (so E2EE workers can be kept in sync). */
+export function onWorkerLogLevelChanged(cb: (level: LogLevel) => void): () => void {
+  workerLogLevelListeners.add(cb);
+  return () => {
+    workerLogLevelListeners.delete(cb);
+  };
+}
+
+/** @internal Test-only accessor: current number of workerLogger level listeners. */
+export function getWorkerLogLevelListenerCount(): number {
+  return workerLogLevelListeners.size;
+}

package/src/room/PCTransportManager.test.ts

@@ -279,3 +279,38 @@ describe('PCTransportManager.negotiate', () => {
     await expect(p).resolves.toBeUndefined();
   });
 });
+
+describe('PCTransportManager.triggerIceRestart', () => {
+  let originalRTCPeerConnection: unknown;
+
+  beforeEach(() => {
+    originalRTCPeerConnection = (globalThis as unknown as { RTCPeerConnection?: unknown })
+      .RTCPeerConnection;
+    (globalThis as unknown as { RTCPeerConnection: unknown }).RTCPeerConnection = StubPC;
+  });
+
+  afterEach(() => {
+    (globalThis as unknown as { RTCPeerConnection: unknown }).RTCPeerConnection =
+      originalRTCPeerConnection;
+  });
+
+  /**
+   * The subscriber must keep applying remote candidates across a reconnect.
+   *
+   * Putting it into `restartingIce` would queue them until a new remote description arrives —
+   * but the server only re-offers the subscriber when the reconnect moved us to another node,
+   * so on an ordinary signal-only resume nothing would ever flush that queue, and the
+   * transport would stop adopting new network paths for the rest of the session. The server
+   * also never sends candidates ahead of the offer that introduces them, so queueing buys
+   * nothing in exchange.
+   */
+  it('does not stop the subscriber applying remote candidates', async () => {
+    const manager = new PCTransportManager('subscriber-primary', {});
+    const publisher = new FakePublisher();
+    (manager as unknown as { publisher: FakePublisher }).publisher = publisher;
+
+    await manager.triggerIceRestart();
+
+    expect(manager.subscriber?.restartingIce).toBe(false);
+  });
+});

package/src/room/PCTransportManager.ts

@@ -162,12 +162,20 @@ export 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.
+   */
   async triggerIceRestart() {
     this.iceLog.warn('triggering ICE restart');
-    if (this.subscriber) {
-      this.subscriber.restartingIce = true;
-    }
-    // only restart publisher if it's needed
     if (this.needsPublisher) {
       await this.createAndSendPublisherOffer({ iceRestart: true });
     }

package/src/room/RTCEngine.ts

@@ -173,6 +173,14 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     return !!this.reconnectTimeout;
   }
 
+  get serverVersion(): string | undefined {
+    return (
+      this.latestJoinResponse?.serverInfo?.version ||
+      this.latestJoinResponse?.serverVersion ||
+      undefined
+    );
+  }
+
   /**
    * Owns the data channels: the three flow-controlled publisher wrappers (engine-lifetime; the
    * RTCDataChannel handles underneath are attached/detached as peer connections come and go, with
@@ -655,7 +663,11 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         sdp: sd.sdp,
         midToTrackId,
       });
-      this.midToTrackId = midToTrackId;
+      // in dual PC mode the publisher answer carries no mapping (the server's publisher
+      // transport has no sending tracks) and must not clobber the subscriber offer mapping
+      if (this.pcManager.mode === 'publisher-only') {
+        this.midToTrackId = midToTrackId;
+      }
       await this.pcManager.setPublisherAnswer(sd, offerId);
     };
 
@@ -918,12 +930,21 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
           this.log.error('Received encrypted packet but E2EE not set up');
           return;
         }
-        const decryptedData = await this.e2eeManager?.handleEncryptedData(
-          dp.value.value.encryptedValue as NonSharedUint8Array,
-          dp.value.value.iv as NonSharedUint8Array,
-          dp.participantIdentity,
-          dp.value.value.keyIndex,
-        );
+        let decryptedData;
+        try {
+          decryptedData = await this.e2eeManager.handleEncryptedData(
+            dp.value.value.encryptedValue as NonSharedUint8Array,
+            dp.value.value.iv as NonSharedUint8Array,
+            dp.participantIdentity,
+            dp.value.value.keyIndex,
+          );
+        } catch (err) {
+          this.log.debug('failed to decrypt data packet', {
+            error: err,
+            participantIdentity: dp.participantIdentity,
+          });
+          return;
+        }
         const decryptedPacket = EncryptedPacketPayload.fromBinary(decryptedData.payload);
         const newDp = new DataPacket({
           value: decryptedPacket.value,

package/src/room/Room.ts

@@ -339,7 +339,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       this.log,
       this.outgoingDataStreamManager,
       this.getRemoteParticipantClientProtocol,
-      () => this.engine.latestJoinResponse?.serverInfo?.version,
+      () => this.engine?.serverVersion,
     );
     this.rpcClientManager.on('sendDataPacket', ({ packet }) => {
       this.engine?.sendDataPacket(packet, DataChannelKind.RELIABLE);

package/src/room/data-stream/incoming/IncomingDataStreamManager.test.ts

@@ -1237,6 +1237,177 @@ describe('IncomingDataStreamManager', () => {
       await expect(reader.readAll()).rejects.toThrow('Missing chunk(s)');
     });
 
+    it('should error on a gap in chunk indices on an uncompressed text stream', async () => {
+      const manager = new IncomingDataStreamManager();
+      manager.setConnected(true);
+
+      const readerPromise = new Promise<TextStreamReader>((resolve) => {
+        manager.registerTextStreamHandler('my-topic', (reader) => resolve(reader));
+      });
+
+      const streamId = crypto.randomUUID();
+      const text = randomText(3_000);
+      const textBytes = new TextEncoder().encode(text);
+      const split = Math.floor(textBytes.length / 3);
+
+      manager.handleDataStreamPacket(
+        headerPacket(streamId, 'textHeader', {
+          totalLength: BigInt(textBytes.length),
+          compression: DataStream_CompressionType.NONE,
+        }),
+        Encryption_Type.NONE,
+      );
+      manager.handleDataStreamPacket(
+        chunkPacket(streamId, 0, textBytes.slice(0, split)),
+        Encryption_Type.NONE,
+      );
+      // Skip chunk index 1 entirely — a gap means the payload cannot be reassembled in order.
+      manager.handleDataStreamPacket(
+        chunkPacket(streamId, 2, textBytes.slice(split)),
+        Encryption_Type.NONE,
+      );
+
+      const reader = await readerPromise;
+      await expect(reader.readAll()).rejects.toThrow('Missing chunk(s)');
+    });
+
+    it('should error on a gap in chunk indices on an uncompressed byte stream', async () => {
+      const manager = new IncomingDataStreamManager();
+      manager.setConnected(true);
+
+      const readerPromise = new Promise<ByteStreamReader>((resolve) => {
+        manager.registerByteStreamHandler('my-topic', (reader) => resolve(reader));
+      });
+
+      const streamId = crypto.randomUUID();
+      const bytes = randomBytes(3_000);
+      const split = Math.floor(bytes.length / 3);
+
+      manager.handleDataStreamPacket(
+        headerPacket(streamId, 'byteHeader', {
+          totalLength: BigInt(bytes.length),
+          compression: DataStream_CompressionType.NONE,
+        }),
+        Encryption_Type.NONE,
+      );
+      manager.handleDataStreamPacket(
+        chunkPacket(streamId, 0, bytes.slice(0, split)),
+        Encryption_Type.NONE,
+      );
+      // Skip chunk index 1 entirely.
+      manager.handleDataStreamPacket(
+        chunkPacket(streamId, 2, bytes.slice(split)),
+        Encryption_Type.NONE,
+      );
+
+      const reader = await readerPromise;
+      await expect(reader.readAll()).rejects.toThrow('Missing chunk(s)');
+    });
+
+    it('should drop a duplicate chunk index on an uncompressed text stream and still decode', async () => {
+      const manager = new IncomingDataStreamManager();
+      manager.setConnected(true);
+
+      const readerPromise = new Promise<TextStreamReader>((resolve) => {
+        manager.registerTextStreamHandler('my-topic', (reader) => resolve(reader));
+      });
+
+      const streamId = crypto.randomUUID();
+      const text = randomText(3_000);
+      const textBytes = new TextEncoder().encode(text);
+      const split = Math.floor(textBytes.length / 2);
+
+      manager.handleDataStreamPacket(
+        headerPacket(streamId, 'textHeader', {
+          totalLength: BigInt(textBytes.length),
+          compression: DataStream_CompressionType.NONE,
+        }),
+        Encryption_Type.NONE,
+      );
+      const chunk0 = chunkPacket(streamId, 0, textBytes.slice(0, split));
+      manager.handleDataStreamPacket(chunk0, Encryption_Type.NONE);
+      // A replayed chunk (e.g. reconnect logic) must be dropped with a warning, not appended a
+      // second time — otherwise the payload is corrupted and exceeds `totalLength`.
+      manager.handleDataStreamPacket(chunk0, Encryption_Type.NONE);
+      manager.handleDataStreamPacket(
+        chunkPacket(streamId, 1, textBytes.slice(split)),
+        Encryption_Type.NONE,
+      );
+      manager.handleDataStreamPacket(trailerPacket(streamId), Encryption_Type.NONE);
+
+      const reader = await readerPromise;
+      expect(await reader.readAll()).toStrictEqual(text);
+    });
+
+    it('should drop a duplicate chunk index on an uncompressed byte stream and still decode', async () => {
+      const manager = new IncomingDataStreamManager();
+      manager.setConnected(true);
+
+      const readerPromise = new Promise<ByteStreamReader>((resolve) => {
+        manager.registerByteStreamHandler('my-topic', (reader) => resolve(reader));
+      });
+
+      const streamId = crypto.randomUUID();
+      const bytes = randomBytes(3_000);
+      const split = Math.floor(bytes.length / 2);
+
+      manager.handleDataStreamPacket(
+        headerPacket(streamId, 'byteHeader', {
+          totalLength: BigInt(bytes.length),
+          compression: DataStream_CompressionType.NONE,
+        }),
+        Encryption_Type.NONE,
+      );
+      const chunk0 = chunkPacket(streamId, 0, bytes.slice(0, split));
+      manager.handleDataStreamPacket(chunk0, Encryption_Type.NONE);
+      manager.handleDataStreamPacket(chunk0, Encryption_Type.NONE);
+      manager.handleDataStreamPacket(
+        chunkPacket(streamId, 1, bytes.slice(split)),
+        Encryption_Type.NONE,
+      );
+      manager.handleDataStreamPacket(trailerPacket(streamId), Encryption_Type.NONE);
+
+      const reader = await readerPromise;
+      expect(concatChunks(await reader.readAll())).toStrictEqual(bytes);
+    });
+
+    it('should drop chunks resent at an already-received index', async () => {
+      const manager = new IncomingDataStreamManager();
+      manager.setConnected(true);
+
+      const readerPromise = new Promise<TextStreamReader>((resolve) => {
+        manager.registerTextStreamHandler('my-topic', (reader) => resolve(reader));
+      });
+
+      const streamId = crypto.randomUUID();
+      const text = 'hello world';
+      const textBytes = new TextEncoder().encode(text);
+
+      manager.handleDataStreamPacket(
+        headerPacket(streamId, 'textHeader', { totalLength: BigInt(textBytes.length) }),
+        Encryption_Type.NONE,
+      );
+      // first assuring a version going from 1 -> 2 works as expected
+      manager.handleDataStreamPacket(chunkPacket(streamId, 0, textBytes, 1), Encryption_Type.NONE);
+      // Chunk-level `version` retcon is not supported: a reader that has already yielded chunk 0 to
+      // its consumer cannot retract it, so a resend at the same index is dropped like any other
+      // duplicate rather than superseding the original. See the note on
+      // `TextStreamReader.handleChunkReceived`.
+      manager.handleDataStreamPacket(
+        chunkPacket(streamId, 0, new TextEncoder().encode('goodbye world'), 2),
+        Encryption_Type.NONE,
+      );
+      // sending a lower version number again to ensure this one also gets dropped
+      manager.handleDataStreamPacket(
+        chunkPacket(streamId, 0, new TextEncoder().encode('goodbye world'), 0),
+        Encryption_Type.NONE,
+      );
+      manager.handleDataStreamPacket(trailerPacket(streamId), Encryption_Type.NONE);
+
+      const reader = await readerPromise;
+      expect(await reader.readAll()).toStrictEqual(text);
+    });
+
     it('should reframe multibyte UTF-8 on chunk boundaries when decompressing a text stream', async () => {
       const manager = new IncomingDataStreamManager();
       manager.setConnected(true);

package/src/room/data-stream/incoming/IncomingDataStreamManager.ts

@@ -241,7 +241,7 @@ export default class IncomingDataStreamManager {
             info,
             compressed
               ? inflateRawByteChunkStream(stream, streamHeader.streamId, this.maxPayloadByteLength)
-              : stream,
+              : 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),
@@ -344,7 +344,7 @@ export default class IncomingDataStreamManager {
             info,
             compressed
               ? inflateRawChunkStream(stream, streamHeader.streamId, this.maxPayloadByteLength)
-              : stream,
+              : 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),
@@ -367,7 +367,7 @@ export default class IncomingDataStreamManager {
           ),
         );
         this.byteStreamControllers.delete(chunk.streamId);
-      } else if (chunk.content.length > 0) {
+      } else {
         fileBuffer.controller.enqueue(chunk);
       }
     }
@@ -381,7 +381,7 @@ export default class IncomingDataStreamManager {
           ),
         );
         this.textStreamControllers.delete(chunk.streamId);
-      } else if (chunk.content.length > 0) {
+      } else {
         textBuffer.controller.enqueue(chunk);
       }
     }
@@ -455,15 +455,9 @@ function createInlineStream(
 ): ReadableStream<DataStream_Chunk> {
   return new ReadableStream<DataStream_Chunk>({
     start: async (controller) => {
-      try {
-        const bytes = await content;
-        controller.enqueue(
-          new DataStream_Chunk({ streamId, chunkIndex: BigInt(0), content: bytes }),
-        );
-        controller.close();
-      } catch (err) {
-        controller.error(err);
-      }
+      const bytes = await content;
+      controller.enqueue(new DataStream_Chunk({ streamId, chunkIndex: BigInt(0), content: bytes }));
+      controller.close();
     },
   });
 }
@@ -471,9 +465,11 @@ function createInlineStream(
 /**
  * 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: string,
@@ -484,17 +480,20 @@ function ensureOrderedChunks(
       const index = bigIntToNumber(value.chunkIndex);
       if (index <= lastChunkIndex) {
         log.warn(
-          `ignoring duplicate chunk ${index} for compressed data stream ${streamId} (last processed: ${lastChunkIndex})`,
+          `ignoring duplicate chunk ${index} ${value.version > 0 ? `(version ${value.version})` : ''} for data stream ${streamId} (last processed: ${lastChunkIndex})`,
         );
         return;
       }
       if (index > lastChunkIndex + 1) {
         throw new DataStreamError(
-          `Missing chunk(s) ${lastChunkIndex + 1}..${index - 1} for compressed data stream ${streamId} - cannot continue decompressing`,
+          `Missing chunk(s) ${lastChunkIndex + 1}..${index - 1} for data stream ${streamId} - cannot reassemble payload`,
           DataStreamErrorReason.Incomplete,
         );
       }
       lastChunkIndex = index;
+      if (value.content.length === 0) {
+        return;
+      }
       controller.enqueue(value);
     },
   });