livekit-client 2.17.1 → 2.17.3

package/dist/ts4.2/room/utils.d.ts

@@ -1,6 +1,7 @@
 import { ChatMessage as ChatMessageModel, ClientInfo, DisconnectReason, Transcription as TranscriptionModel } from '@livekit/protocol';
 import TypedPromise from '../utils/TypedPromise';
 import type { BrowserDetails } from '../utils/browserParser';
+import type { Throws } from '../utils/throws';
 import type { ConnectionError } from './errors';
 import type LocalParticipant from './participant/LocalParticipant';
 import type Participant from './participant/Participant';
@@ -71,8 +72,12 @@ export declare function getEmptyVideoStreamTrack(): MediaStreamTrack;
 export declare function createDummyVideoStreamTrack(width?: number, height?: number, enabled?: boolean, paintContent?: boolean): MediaStreamTrack;
 export declare function getEmptyAudioStreamTrack(): MediaStreamTrack;
 export declare function getStereoAudioStreamTrack(): MediaStreamTrack;
+/** An object that represents a serialized version of a `new Promise((resolve, reject) => {})`
+ * constructor. Wait for a promise resolution with `await future.promise` and explicitly resolve or
+ * reject the inner promise with `future.resolve(...)` or `future.reject(...)`.
+ */
 export declare class Future<T, E extends Error> {
-    promise: Promise<T>;
+    promise: Promise<Throws<T, E>>;
     resolve?: (arg: T) => void;
     reject?: (e: E) => void;
     onFinally?: () => void;

package/dist/ts4.2/utils/subscribeToEvents.d.ts

@@ -0,0 +1,12 @@
+import type { EventMap } from 'typed-emitter';
+import type TypedEventEmitter from 'typed-emitter';
+/** A test helper to listen to events received by an event emitter and allow them to be imperatively
+ * queried after the fact. */
+export declare function subscribeToEvents<Callbacks extends EventMap, EventNames extends keyof Callbacks = keyof Callbacks>(eventEmitter: TypedEventEmitter<Callbacks>, eventNames: Array<EventNames>): {
+    /** Listen for the next occurrance of an event to be emitted, or return the last event that was
+     * buffered (but hasn't been processed yet). */
+    waitFor<EventPayload extends Parameters<Callbacks[EventName]>[0], EventName extends EventNames = EventNames>(eventName: EventName): Promise<EventPayload>;
+    /** Cleanup any lingering subscriptions. */
+    unsubscribe: () => void;
+};
+//# sourceMappingURL=subscribeToEvents.d.ts.map

package/dist/ts4.2/utils/throws.d.ts

@@ -1,3 +1,4 @@
+type Primitives = null | undefined | string | number | bigint | boolean | symbol;
 /**
  * Branded type that encodes possible thrown errors in the return type.
  *
@@ -11,9 +12,9 @@
  *
  * For more info about how this is checked, see ./throws-transformer at the root of this repo.
  */
-export type Throws<T, E extends Error> = T & {
+export type Throws<T, E extends Error> = (T & {
     readonly __throws?: E;
-};
+}) | Extract<T, Primitives>;
 /**
  * Extract the error types from a Throws type.
  */
@@ -34,4 +35,5 @@ export type CombineErrors<T extends any[]> = T extends [
  * throwing functions and wants to propagate their errors.
  */
 export type PropagatesErrors<T, AdditionalErrors extends Error = never> = Throws<ExtractSuccess<T>, ExtractErrors<T> | AdditionalErrors>;
+export {};
 //# sourceMappingURL=throws.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "2.17.1",
+  "version": "2.17.3",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",
@@ -42,7 +42,6 @@
     "jose": "^6.1.0",
     "loglevel": "^1.9.2",
     "sdp-transform": "^2.15.0",
-    "ts-debounce": "^4.0.0",
     "tslib": "2.8.1",
     "typed-emitter": "^2.1.0",
     "webrtc-adapter": "^9.0.1"
@@ -79,11 +78,11 @@
     "eslint-plugin-import-x": "^4.16.1",
     "eslint-plugin-prettier": "^5.5.4",
     "gh-pages": "6.3.0",
-    "glob": "^13.0.0",
-    "happy-dom": "^17.2.0",
+    "glob": "^13.0.6",
+    "happy-dom": "^20.0.0",
     "jsdom": "^26.1.0",
     "prettier": "^3.4.2",
-    "rollup": "4.57.1",
+    "rollup": "4.59.0",
     "rollup-plugin-delete": "^2.1.0",
     "rollup-plugin-typescript2": "0.36.0",
     "size-limit": "^11.2.0",

package/src/e2ee/E2eeManager.ts

@@ -169,7 +169,7 @@ export class E2EEManager
       case 'initAck':
         if (data.enabled) {
           this.keyProvider.getKeys().forEach((keyInfo) => {
-            this.postKey(keyInfo);
+            this.postKey(keyInfo, false);
           });
         }
         break;
@@ -177,7 +177,7 @@ export class E2EEManager
       case 'enable':
         if (data.enabled) {
           this.keyProvider.getKeys().forEach((keyInfo) => {
-            this.postKey(keyInfo);
+            this.postKey(keyInfo, false);
           });
         }
         if (
@@ -274,8 +274,9 @@ export class E2EEManager
         if (!this.room) {
           throw new TypeError(`expected room to be present on signal connect`);
         }
+        const latestKeyIndex = keyProvider.getLatestManuallySetKeyIndex();
         keyProvider.getKeys().forEach((keyInfo) => {
-          this.postKey(keyInfo);
+          this.postKey(keyInfo, latestKeyIndex === (keyInfo.keyIndex ?? 0));
         });
         this.setParticipantCryptorEnabled(
           this.room.localParticipant.isE2EEEnabled,
@@ -305,7 +306,9 @@ export class E2EEManager
     });
 
     keyProvider
-      .on(KeyProviderEvent.SetKey, (keyInfo) => this.postKey(keyInfo))
+      .on(KeyProviderEvent.SetKey, (keyInfo, updateCurrentKeyIndex) =>
+        this.postKey(keyInfo, updateCurrentKeyIndex ?? true),
+      )
       .on(KeyProviderEvent.RatchetRequest, (participantId, keyIndex) =>
         this.postRatchetRequest(participantId, keyIndex),
       );
@@ -376,7 +379,7 @@ export class E2EEManager
     this.worker.postMessage(msg);
   }
 
-  private postKey({ key, participantIdentity, keyIndex }: KeyInfo) {
+  private postKey({ key, participantIdentity, keyIndex }: KeyInfo, updateCurrentKeyIndex: boolean) {
     if (!this.worker) {
       throw Error('could not set key, worker is missing');
     }
@@ -387,6 +390,7 @@ export class E2EEManager
         isPublisher: participantIdentity === this.room?.localParticipant.identity,
         key,
         keyIndex,
+        updateCurrentKeyIndex,
       },
     };
     this.worker.postMessage(msg);

package/src/e2ee/KeyProvider.ts

@@ -14,6 +14,8 @@ export class BaseKeyProvider extends (EventEmitter as new () => TypedEventEmitte
 
   private readonly options: KeyProviderOptions;
 
+  private latestManuallySetKeyIndex = 0;
+
   constructor(options: Partial<KeyProviderOptions> = {}) {
     super();
     this.keyInfoMap = new Map();
@@ -35,7 +37,10 @@ export class BaseKeyProvider extends (EventEmitter as new () => TypedEventEmitte
       );
     }
     this.keyInfoMap.set(`${participantIdentity ?? 'shared'}-${keyIndex ?? 0}`, keyInfo);
-    this.emit(KeyProviderEvent.SetKey, keyInfo);
+    if (keyIndex !== undefined) {
+      this.latestManuallySetKeyIndex = keyIndex;
+    }
+    this.emit(KeyProviderEvent.SetKey, keyInfo, keyIndex !== undefined);
   }
 
   /**
@@ -59,6 +64,10 @@ export class BaseKeyProvider extends (EventEmitter as new () => TypedEventEmitte
     return Array.from(this.keyInfoMap.values());
   }
 
+  getLatestManuallySetKeyIndex() {
+    return this.latestManuallySetKeyIndex;
+  }
+
   getOptions() {
     return this.options;
   }

package/src/e2ee/events.ts

@@ -12,7 +12,7 @@ export enum KeyProviderEvent {
 }
 
 export type KeyProviderCallbacks = {
-  [KeyProviderEvent.SetKey]: (keyInfo: KeyInfo) => void;
+  [KeyProviderEvent.SetKey]: (keyInfo: KeyInfo, updateCurrentKeyIndex: boolean) => void;
   [KeyProviderEvent.RatchetRequest]: (participantIdentity?: string, keyIndex?: number) => void;
   [KeyProviderEvent.KeyRatcheted]: (
     ratchetedResult: RatchetResult,

package/src/e2ee/types.ts

@@ -23,6 +23,7 @@ export interface SetKeyMessage extends BaseMessage {
     isPublisher: boolean;
     key: CryptoKey;
     keyIndex?: number;
+    updateCurrentKeyIndex: boolean;
   };
 }
 

package/src/e2ee/worker/ParticipantKeyHandler.ts

@@ -154,9 +154,11 @@ export class ParticipantKeyHandler extends (EventEmitter as new () => TypedEvent
    * together with the material
    * also resets the valid key property and updates the currentKeyIndex
    */
-  async setKey(material: CryptoKey, keyIndex = 0) {
-    await this.setKeyFromMaterial(material, keyIndex);
-    this.resetKeyStatus(keyIndex);
+  async setKey(material: CryptoKey, keyIndex = 0, updateCurrentKeyIndex = true) {
+    await this.setKeyFromMaterial(material, keyIndex, null, updateCurrentKeyIndex);
+    if (updateCurrentKeyIndex) {
+      this.resetKeyStatus(keyIndex);
+    }
   }
 
   /**
@@ -169,6 +171,7 @@ export class ParticipantKeyHandler extends (EventEmitter as new () => TypedEvent
     material: CryptoKey,
     keyIndex: number,
     ratchetedResult: RatchetResult | null = null,
+    updateCurrentKeyIndex = true,
   ) {
     const keySet = await deriveKeys(material, this.keyProviderOptions.ratchetSalt);
     const newIndex = keyIndex >= 0 ? keyIndex % this.cryptoKeyRing.length : this.currentKeyIndex;
@@ -178,7 +181,7 @@ export class ParticipantKeyHandler extends (EventEmitter as new () => TypedEvent
       ratchetSalt: this.keyProviderOptions.ratchetSalt,
     });
     this.setKeySet(keySet, newIndex, ratchetedResult);
-    if (newIndex >= 0) this.currentKeyIndex = newIndex;
+    if (newIndex >= 0 && updateCurrentKeyIndex) this.currentKeyIndex = newIndex;
   }
 
   setKeySet(keySet: KeySet, keyIndex: number, ratchetedResult: RatchetResult | null = null) {

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

@@ -141,12 +141,16 @@ onmessage = (ev) => {
 
       case 'setKey':
         if (useSharedKey) {
-          await setSharedKey(data.key, data.keyIndex);
+          await setSharedKey(data.key, data.keyIndex, data.updateCurrentKeyIndex);
         } else if (data.participantIdentity) {
           workerLogger.info(
             `set participant sender key ${data.participantIdentity} index ${data.keyIndex}`,
           );
-          await getParticipantKeyHandler(data.participantIdentity).setKey(data.key, data.keyIndex);
+          await getParticipantKeyHandler(data.participantIdentity).setKey(
+            data.key,
+            data.keyIndex,
+            data.updateCurrentKeyIndex,
+          );
         } else {
           workerLogger.error('no participant Id was provided and shared key usage is disabled');
         }
@@ -281,9 +285,9 @@ function setEncryptionEnabled(enable: boolean, participantIdentity: string) {
   encryptionEnabledMap.set(participantIdentity, enable);
 }
 
-async function setSharedKey(key: CryptoKey, index?: number) {
+async function setSharedKey(key: CryptoKey, index?: number, updateCurrentKeyIndex?: boolean) {
   workerLogger.info('set shared key', { index });
-  await getSharedKeyHandler().setKey(key, index);
+  await getSharedKeyHandler().setKey(key, index, updateCurrentKeyIndex);
 }
 
 function setupCryptorErrorEvents(cryptor: FrameCryptor) {
@@ -325,17 +329,23 @@ function handleSifTrailer(trailer: Uint8Array) {
 // Operations using RTCRtpScriptTransform.
 // @ts-ignore
 if (self.RTCTransformEvent) {
-  workerLogger.debug('setup transform event');
   // @ts-ignore
   self.onrtctransform = (event: RTCTransformEvent) => {
     // @ts-ignore
     const transformer = event.transformer;
-    workerLogger.debug('transformer', transformer);
-
     const { kind, participantIdentity, trackId, codec } =
       transformer.options as ScriptTransformOptions;
-    const cryptor = getTrackCryptor(participantIdentity, trackId);
-    workerLogger.debug('transform', { codec });
-    cryptor.setupTransform(kind, transformer.readable, transformer.writable, trackId, false, codec);
+    messageQueue.run(async () => {
+      const cryptor = getTrackCryptor(participantIdentity, trackId);
+      workerLogger.debug('onrtctransform setup', { participantIdentity, trackId, codec });
+      cryptor.setupTransform(
+        kind,
+        transformer.readable,
+        transformer.writable,
+        trackId,
+        false,
+        codec,
+      );
+    });
   };
 }

package/src/index.ts

@@ -9,11 +9,18 @@ import {
 import { LogLevel, LoggerNames, getLogger, setLogExtension, setLogLevel } from './logger';
 import DefaultReconnectPolicy from './room/DefaultReconnectPolicy';
 import type { ReconnectContext, ReconnectPolicy } from './room/ReconnectPolicy';
-import Room, { ConnectionState } from './room/Room';
-import type { RoomEventCallbacks } from './room/Room';
+import Room, { ConnectionState, type RoomEventCallbacks } from './room/Room';
 import * as attributes from './room/attribute-typings';
+// FIXME: remove this import in a follow up data track pull request.
+import './room/data-track/depacketizer';
+// FIXME: remove this import in a follow up data track pull request.
+import './room/data-track/outgoing/OutgoingDataTrackManager';
 import LocalParticipant from './room/participant/LocalParticipant';
-import Participant, { ConnectionQuality, ParticipantKind } from './room/participant/Participant';
+import Participant, {
+  ConnectionQuality,
+  type ParticipantEventCallbacks,
+  ParticipantKind,
+} from './room/participant/Participant';
 import type { ParticipantTrackPermission } from './room/participant/ParticipantTrackPermission';
 import RemoteParticipant from './room/participant/RemoteParticipant';
 import type {
@@ -32,8 +39,8 @@ import RemoteTrack from './room/track/RemoteTrack';
 import RemoteTrackPublication from './room/track/RemoteTrackPublication';
 import type { ElementInfo } from './room/track/RemoteVideoTrack';
 import RemoteVideoTrack from './room/track/RemoteVideoTrack';
-import { TrackPublication } from './room/track/TrackPublication';
-import type { LiveKitReactNativeInfo } from './room/types';
+import { type PublicationEventCallbacks, TrackPublication } from './room/track/TrackPublication';
+import type { LiveKitReactNativeInfo, TextStreamInfo } from './room/types';
 import type { AudioAnalyserOptions } from './room/utils';
 import {
   compareVersions,
@@ -140,6 +147,7 @@ export type {
   AudioAnalyserOptions,
   ElementInfo,
   LiveKitReactNativeInfo,
+  TextStreamInfo,
   ParticipantTrackPermission,
   AudioReceiverStats,
   AudioSenderStats,
@@ -148,6 +156,8 @@ export type {
   ReconnectContext,
   ReconnectPolicy,
   RoomEventCallbacks,
+  ParticipantEventCallbacks,
+  PublicationEventCallbacks,
 };
 export { DataTrackPacket, type DataTrackPacketHeader } from './room/data-track/packet';
 export {

package/src/logger.ts

@@ -21,6 +21,7 @@ export enum LoggerNames {
   PCManager = 'livekit-pc-manager',
   PCTransport = 'livekit-pc-transport',
   E2EE = 'lk-e2ee',
+  DataTracks = 'livekit-data-tracks',
 }
 
 type LogLevelString = keyof typeof LogLevel;

package/src/room/PCTransport.ts

@@ -1,9 +1,9 @@
 import { Mutex } from '@livekit/mutex';
 import { EventEmitter } from 'events';
 import { parse, write } from 'sdp-transform';
-import { debounce } from 'ts-debounce';
 import type { MediaDescription, SessionDescription } from 'sdp-transform';
 import log, { LoggerNames, getLogger } from '../logger';
+import { debounce } from './debounce';
 import { NegotiationError, UnexpectedConnectionState } from './errors';
 import type { LoggerOptions } from './types';
 import { ddExtensionURI, isSVCCodec, isSafari } from './utils';
@@ -278,6 +278,7 @@ export default class PCTransport extends EventEmitter {
           await this._pc.setRemoteDescription(currentSD);
         } else {
           this.renegotiate = true;
+          this.log.debug('requesting renegotiation', { ...this.logContext });
           return;
         }
       } else if (!this._pc || this._pc.signalingState === 'closed') {

package/src/room/PCTransportManager.ts

@@ -229,28 +229,46 @@ export class PCTransportManager {
 
   async negotiate(abortController: AbortController) {
     return new TypedPromise<void, NegotiationError | Error>(async (resolve, reject) => {
-      const negotiationTimeout = setTimeout(() => {
+      let negotiationTimeout = setTimeout(() => {
         reject(new NegotiationError('negotiation timed out'));
       }, this.peerConnectionTimeout);
 
-      const abortHandler = () => {
+      const cleanup = () => {
         clearTimeout(negotiationTimeout);
+        this.publisher.off(PCEvents.NegotiationStarted, onNegotiationStarted);
+        abortController.signal.removeEventListener('abort', abortHandler);
+      };
+
+      const abortHandler = () => {
+        cleanup();
         reject(new NegotiationError('negotiation aborted'));
       };
 
-      abortController.signal.addEventListener('abort', abortHandler);
-      this.publisher.once(PCEvents.NegotiationStarted, () => {
+      // Reset the timeout each time a renegotiation cycle starts. This
+      // prevents premature timeouts when the negotiation machinery is
+      // actively renegotiating (offers going out, answers coming back) but
+      // NegotiationComplete hasn't fired yet because new requirements keep
+      // arriving between offer/answer round-trips.
+      const onNegotiationStarted = () => {
         if (abortController.signal.aborted) {
           return;
         }
-        this.publisher.once(PCEvents.NegotiationComplete, () => {
-          clearTimeout(negotiationTimeout);
-          resolve();
-        });
+        clearTimeout(negotiationTimeout);
+        negotiationTimeout = setTimeout(() => {
+          cleanup();
+          reject(new NegotiationError('negotiation timed out'));
+        }, this.peerConnectionTimeout);
+      };
+
+      abortController.signal.addEventListener('abort', abortHandler);
+      this.publisher.on(PCEvents.NegotiationStarted, onNegotiationStarted);
+      this.publisher.once(PCEvents.NegotiationComplete, () => {
+        cleanup();
+        resolve();
       });
 
       await this.publisher.negotiate((e) => {
-        clearTimeout(negotiationTimeout);
+        cleanup();
         if (e instanceof Error) {
           reject(e);
         } else {

package/src/room/RTCEngine.ts

@@ -1477,8 +1477,11 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     if (!this.pcManager) {
       return false;
     }
-    // primary connection
-    if (this.pcManager.currentState !== PCTransportState.CONNECTED) {
+    const allowedConnectionStates: PCTransportState[] = [
+      PCTransportState.CONNECTING,
+      PCTransportState.CONNECTED,
+    ];
+    if (!allowedConnectionStates.includes(this.pcManager.currentState)) {
       return false;
     }
 
@@ -1521,6 +1524,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         reject(new NegotiationError('cannot negotiate on closed engine'));
       }
       this.on(EngineEvent.Closing, handleClosed);
+      this.on(EngineEvent.Restarting, handleClosed);
 
       this.pcManager.publisher.once(
         PCEvents.RTPVideoPayloadTypes,
@@ -1540,6 +1544,12 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         await this.pcManager.negotiate(abortController);
         resolve();
       } catch (e: unknown) {
+        if (abortController.signal.aborted) {
+          // negotiation was aborted due to engine close or restart, resolve
+          // cleanly to avoid triggering a cascading reconnect loop
+          resolve();
+          return;
+        }
         if (e instanceof NegotiationError) {
           this.fullReconnectOnNext = true;
         }
@@ -1551,6 +1561,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         }
       } finally {
         this.off(EngineEvent.Closing, handleClosed);
+        this.off(EngineEvent.Restarting, handleClosed);
       }
     });
   }

package/src/room/Room.ts

@@ -740,7 +740,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
               `Initial connection failed with ConnectionError: ${error.message}. Retrying with another region: ${nextUrl}`,
               this.logContext,
             );
-            this.recreateEngine();
+            this.recreateEngine(true);
             await connectFn(resolve, reject, nextUrl);
           } else {
             this.handleDisconnect(
@@ -866,7 +866,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     ) {
       this.log.info('Reconnection attempt replaced by new connection attempt', this.logContext);
       // make sure we close and recreate the existing engine in order to get rid of any potentially ongoing reconnection attempts
-      this.recreateEngine();
+      this.recreateEngine(true);
     } else {
       // create engine if previously disconnected
       this.maybeCreateEngine();
@@ -1380,8 +1380,14 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       );
   }
 
-  private recreateEngine() {
-    this.engine?.close();
+  private recreateEngine(sendLeave?: boolean) {
+    const oldEngine = this.engine;
+
+    if (sendLeave && oldEngine && !oldEngine.client.isDisconnected) {
+      oldEngine.client.sendLeave().finally(() => oldEngine.close());
+    } else {
+      oldEngine?.close();
+    }
     /* @ts-ignore */
     this.engine = undefined;
     this.isResuming = false;
@@ -2307,7 +2313,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
           engine: this.engine
             ? {
                 closed: this.engine.isClosed,
-                transportsConnected: this.engine.verifyTransport(),
+                transportsConnectedOrConnecting: this.engine.verifyTransport(),
               }
             : undefined,
         });

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

@@ -8,7 +8,7 @@ import {
 import log from '../../../logger';
 import { DataStreamError, DataStreamErrorReason } from '../../errors';
 import { type ByteStreamInfo, type StreamController, type TextStreamInfo } from '../../types';
-import { Future, bigIntToNumber } from '../../utils';
+import { bigIntToNumber } from '../../utils';
 import {
   type ByteStreamHandler,
   ByteStreamReader,
@@ -78,11 +78,11 @@ export default class IncomingDataStreamManager {
         DataStreamErrorReason.AbnormalEnd,
       );
       for (const [id, controller] of byteStreamsBeingSentByDisconnectingParticipant) {
-        controller.outOfBandFailureRejectingFuture.reject?.(abnormalEndError);
+        controller.controller.error(abnormalEndError);
         this.byteStreamControllers.delete(id);
       }
       for (const [id, controller] of textStreamsBeingSentByDisconnectingParticipant) {
-        controller.outOfBandFailureRejectingFuture.reject?.(abnormalEndError);
+        controller.controller.error(abnormalEndError);
         this.textStreamControllers.delete(id);
       }
     }
@@ -121,10 +121,6 @@ export default class IncomingDataStreamManager {
       }
 
       let streamController: ReadableStreamDefaultController<DataStream_Chunk>;
-      const outOfBandFailureRejectingFuture = new Future<never, Error>();
-      outOfBandFailureRejectingFuture.promise.catch((err) => {
-        this.log.error(err);
-      });
 
       const info: ByteStreamInfo = {
         id: streamHeader.streamId,
@@ -152,17 +148,11 @@ export default class IncomingDataStreamManager {
             controller: streamController,
             startTime: Date.now(),
             sendingParticipantIdentity: participantIdentity,
-            outOfBandFailureRejectingFuture,
           });
         },
       });
       streamHandlerCallback(
-        new ByteStreamReader(
-          info,
-          stream,
-          bigIntToNumber(streamHeader.totalLength),
-          outOfBandFailureRejectingFuture,
-        ),
+        new ByteStreamReader(info, stream, bigIntToNumber(streamHeader.totalLength)),
         {
           identity: participantIdentity,
         },
@@ -178,10 +168,6 @@ export default class IncomingDataStreamManager {
       }
 
       let streamController: ReadableStreamDefaultController<DataStream_Chunk>;
-      const outOfBandFailureRejectingFuture = new Future<never, Error>();
-      outOfBandFailureRejectingFuture.promise.catch((err) => {
-        this.log.error(err);
-      });
 
       const info: TextStreamInfo = {
         id: streamHeader.streamId,
@@ -210,17 +196,11 @@ export default class IncomingDataStreamManager {
             controller: streamController,
             startTime: Date.now(),
             sendingParticipantIdentity: participantIdentity,
-            outOfBandFailureRejectingFuture,
           });
         },
       });
       streamHandlerCallback(
-        new TextStreamReader(
-          info,
-          stream,
-          bigIntToNumber(streamHeader.totalLength),
-          outOfBandFailureRejectingFuture,
-        ),
+        new TextStreamReader(info, stream, bigIntToNumber(streamHeader.totalLength)),
         { identity: participantIdentity },
       );
     }