@livekit/rtc-node 0.13.32 → 0.13.34

package/dist/room.cjs

@@ -40,8 +40,10 @@ var import_rtc_ffi_bindings = require("@livekit/rtc-ffi-bindings");
 var import_rtc_ffi_bindings2 = require("@livekit/rtc-ffi-bindings");
 var import_rtc_ffi_bindings3 = require("@livekit/rtc-ffi-bindings");
 var import_rtc_ffi_bindings4 = require("@livekit/rtc-ffi-bindings");
+var import_rtc_ffi_bindings5 = require("@livekit/rtc-ffi-bindings");
 var import_events = __toESM(require("events"), 1);
 var import_stream_reader = require("./data_streams/stream_reader.cjs");
+var import_types = require("./data_streams/types.cjs");
 var import_e2ee = require("./e2ee.cjs");
 var import_ffi_client = require("./ffi_client.cjs");
 var import_log = require("./log.cjs");
@@ -50,11 +52,11 @@ var import_track = require("./track.cjs");
 var import_track_publication = require("./track_publication.cjs");
 var import_utils = require("./utils.cjs");
 const defaultRtcConfiguration = {
-  iceTransportType: import_rtc_ffi_bindings3.IceTransportType.TRANSPORT_ALL,
-  continualGatheringPolicy: import_rtc_ffi_bindings3.ContinualGatheringPolicy.GATHER_CONTINUALLY,
+  iceTransportType: import_rtc_ffi_bindings4.IceTransportType.TRANSPORT_ALL,
+  continualGatheringPolicy: import_rtc_ffi_bindings4.ContinualGatheringPolicy.GATHER_CONTINUALLY,
   iceServers: []
 };
-const defaultRoomOptions = new import_rtc_ffi_bindings3.RoomOptions({
+const defaultRoomOptions = new import_rtc_ffi_bindings4.RoomOptions({
   autoSubscribe: true,
   dynacast: false,
   e2ee: void 0,
@@ -72,8 +74,9 @@ class Room extends import_events.default {
      * before processing the next events
      */
     this.ffiEventLock = new import_mutex.Mutex();
-    this.byteStreamControllers = /* @__PURE__ */ new Map();
-    this.textStreamControllers = /* @__PURE__ */ new Map();
+    // Active incoming stream readers keyed by their FFI reader handle id. Each entry
+    // owns the FfiClient listener feeding reader events into the ReadableStream.
+    this.streamReaders = /* @__PURE__ */ new Map();
     this.byteStreamHandlers = /* @__PURE__ */ new Map();
     this.textStreamHandlers = /* @__PURE__ */ new Map();
     this.preConnectEvents = [];
@@ -84,7 +87,7 @@ class Room extends import_events.default {
     // events fire exactly once, no matter which path (explicit disconnect()
     // vs. FFI 'disconnected' event) wins the race.
     this.hasCleanedUp = false;
-    this._connectionState = import_rtc_ffi_bindings3.ConnectionState.CONN_DISCONNECTED;
+    this._connectionState = import_rtc_ffi_bindings4.ConnectionState.CONN_DISCONNECTED;
     this.remoteParticipants = /* @__PURE__ */ new Map();
     this.onFfiEvent = async (ffiEvent) => {
       const unlock = await this.ffiEventLock.lock();
@@ -211,9 +214,9 @@ class Room extends import_events.default {
             trackInfo.sid
           );
           publication.subscribed = true;
-          if (trackInfo.kind == import_rtc_ffi_bindings4.TrackKind.KIND_VIDEO) {
+          if (trackInfo.kind == import_rtc_ffi_bindings5.TrackKind.KIND_VIDEO) {
             publication.track = new import_track.RemoteVideoTrack(ownedTrack);
-          } else if (trackInfo.kind == import_rtc_ffi_bindings4.TrackKind.KIND_AUDIO) {
+          } else if (trackInfo.kind == import_rtc_ffi_bindings5.TrackKind.KIND_AUDIO) {
             publication.track = new import_track.RemoteAudioTrack(ownedTrack);
           }
           (_b = publication.track) == null ? void 0 : _b.setRoom(this);
@@ -384,12 +387,10 @@ class Room extends import_events.default {
         this.emit("reconnected" /* Reconnected */);
       } else if (ev.case == "roomSidChanged") {
         this.emit("roomSidChanged" /* RoomSidChanged */, ev.value.sid);
-      } else if (ev.case === "streamHeaderReceived" && ev.value.header) {
-        this.handleStreamHeader(ev.value.header, ev.value.participantIdentity);
-      } else if (ev.case === "streamChunkReceived" && ev.value.chunk) {
-        this.handleStreamChunk(ev.value.chunk);
-      } else if (ev.case === "streamTrailerReceived" && ev.value.trailer) {
-        this.handleStreamTrailer(ev.value.trailer);
+      } else if (ev.case === "byteStreamOpened" && ev.value.reader) {
+        this.handleByteStreamOpened(ev.value.reader, ev.value.participantIdentity);
+      } else if (ev.case === "textStreamOpened" && ev.value.reader) {
+        this.handleTextStreamOpened(ev.value.reader, ev.value.participantIdentity);
       } else if (ev.case === "roomUpdated") {
         this.info = ev.value;
         this.emit("roomUpdated" /* RoomUpdated */);
@@ -432,7 +433,7 @@ class Room extends import_events.default {
     return (_a = this.info) == null ? void 0 : _a.metadata;
   }
   get isConnected() {
-    return this.ffiHandle != void 0 && this.connectionState != import_rtc_ffi_bindings3.ConnectionState.CONN_DISCONNECTED;
+    return this.ffiHandle != void 0 && this.connectionState != import_rtc_ffi_bindings4.ConnectionState.CONN_DISCONNECTED;
   }
   /** @internal */
   get token() {
@@ -547,13 +548,33 @@ class Room extends import_events.default {
    * @throws ConnectError - if connection fails
    */
   async connect(url, token, opts) {
-    const options = { ...defaultRoomOptions, ...opts };
+    const { dataStream, ...restOpts } = opts ?? {};
+    const options = { ...defaultRoomOptions, ...restOpts };
     const e2eeEnabled = options.encryption || options.e2ee;
-    const e2eeOptions = options.encryption ? { ...import_e2ee.defaultE2EEOptions, ...options.encryption } : { ...import_e2ee.defaultE2EEOptions, ...options.e2ee };
-    const req = new import_rtc_ffi_bindings3.ConnectRequest({
+    const userE2EEOptions = options.encryption ?? options.e2ee;
+    const e2eeOptions = {
+      ...import_e2ee.defaultE2EEOptions,
+      ...userE2EEOptions,
+      keyProviderOptions: {
+        ...import_e2ee.defaultE2EEOptions.keyProviderOptions,
+        ...userE2EEOptions == null ? void 0 : userE2EEOptions.keyProviderOptions
+      }
+    };
+    const mergedOptions = { ...options };
+    if (options.encryption) {
+      mergedOptions.encryption = e2eeOptions;
+    } else if (options.e2ee) {
+      mergedOptions.e2ee = e2eeOptions;
+    }
+    if (dataStream) {
+      mergedOptions.dataStream = new import_rtc_ffi_bindings4.RoomDataStreamOptions({
+        maxPayloadByteLength: (0, import_utils.numberToBigInt)(dataStream.maxPayloadByteLength)
+      });
+    }
+    const req = new import_rtc_ffi_bindings4.ConnectRequest({
       url,
       token,
-      options
+      options: mergedOptions
     });
     import_ffi_client.FfiClient.instance.on(import_ffi_client.FfiClientEvent.FfiEvent, this.onFfiEvent);
     try {
@@ -588,7 +609,7 @@ class Room extends import_events.default {
               rp.trackPublications.set(publication.sid, publication);
             }
           }
-          this.updateConnectionState(import_rtc_ffi_bindings3.ConnectionState.CONN_CONNECTED);
+          this.updateConnectionState(import_rtc_ffi_bindings4.ConnectionState.CONN_CONNECTED);
           import_ffi_client.FfiClient.instance.request({
             message: {
               case: "readyForRoomEvent",
@@ -674,21 +695,16 @@ class Room extends import_events.default {
     var _a, _b;
     if (this.hasCleanedUp) return;
     this.hasCleanedUp = true;
-    for (const [, streamController] of this.byteStreamControllers) {
-      try {
-        streamController.controller.error(new Error("Disconnected while receiving"));
-      } catch {
-      }
-    }
-    this.byteStreamControllers.clear();
-    for (const [, streamController] of this.textStreamControllers) {
+    for (const [, { controller, listener }] of this.streamReaders) {
+      import_ffi_client.FfiClient.instance.off(import_ffi_client.FfiClientEvent.FfiEvent, listener);
       try {
-        streamController.controller.error(new Error("Disconnected while receiving"));
+        controller.error(new Error("Disconnected while receiving"));
       } catch {
       }
     }
-    this.textStreamControllers.clear();
+    this.streamReaders.clear();
     if (this.localParticipant) {
+      this.localParticipant.disposeOpenStreamWriters();
       for (const pub of this.localParticipant.trackPublications.values()) {
         (_a = pub.track) == null ? void 0 : _a.setRoom(null);
       }
@@ -700,7 +716,7 @@ class Room extends import_events.default {
     }
     this.sidPromise = void 0;
     this.disconnectController.abort();
-    this.updateConnectionState(import_rtc_ffi_bindings3.ConnectionState.CONN_DISCONNECTED);
+    this.updateConnectionState(import_rtc_ffi_bindings4.ConnectionState.CONN_DISCONNECTED);
     this.emit("disconnected" /* Disconnected */, reason);
   }
   /**
@@ -784,100 +800,130 @@ class Room extends import_events.default {
     this.remoteParticipants.set(ownedInfo.info.identity, participant);
     return participant;
   }
-  handleStreamHeader(streamHeader, participantIdentity) {
-    if (streamHeader.contentHeader.case === "byteHeader") {
-      const streamHandlerCallback = this.byteStreamHandlers.get(streamHeader.topic ?? "");
-      if (!streamHandlerCallback) {
-        import_log.log.debug(
-          "ignoring incoming byte stream due to no handler for topic: %s",
-          streamHeader.topic ?? "undefined"
-        );
-        return;
-      }
-      let streamController;
-      const stream = new ReadableStream({
-        start: (controller) => {
-          streamController = controller;
-          this.byteStreamControllers.set(streamHeader.streamId, {
-            header: streamHeader,
-            controller: streamController,
-            startTime: Date.now()
-          });
-        }
-      });
-      const info = {
-        streamId: streamHeader.streamId,
-        name: streamHeader.contentHeader.value.name ?? "unknown",
-        mimeType: streamHeader.mimeType,
-        totalSize: streamHeader.totalLength ? Number(streamHeader.totalLength) : void 0,
-        topic: streamHeader.topic,
-        timestamp: (0, import_utils.bigIntToNumber)(streamHeader.timestamp),
-        attributes: streamHeader.attributes
-      };
-      streamHandlerCallback(
-        new import_stream_reader.ByteStreamReader(info, stream, (0, import_utils.bigIntToNumber)(streamHeader.totalLength)),
-        { identity: participantIdentity }
-      );
-    } else if (streamHeader.contentHeader.case === "textHeader") {
-      const streamHandlerCallback = this.textStreamHandlers.get(streamHeader.topic ?? "");
-      if (!streamHandlerCallback) {
-        import_log.log.debug(
-          "ignoring incoming text stream due to no handler for topic: %s",
-          streamHeader.topic ?? "undefined"
-        );
+  handleByteStreamOpened(ownedReader, participantIdentity) {
+    const info = (0, import_utils.byteStreamInfoFromProto)(ownedReader.info);
+    const readerHandle = ownedReader.handle.id;
+    const streamHandlerCallback = this.byteStreamHandlers.get(info.topic);
+    if (!streamHandlerCallback) {
+      import_log.log.debug("ignoring incoming byte stream due to no handler for topic: %s", info.topic);
+      new import_ffi_client.FfiHandle(readerHandle).dispose();
+      return;
+    }
+    let listener = null;
+    const unsubscribe = () => {
+      if (!listener) {
         return;
       }
-      let streamController;
-      const stream = new ReadableStream({
-        start: (controller) => {
-          streamController = controller;
-          this.textStreamControllers.set(streamHeader.streamId, {
-            header: streamHeader,
-            controller: streamController,
-            startTime: Date.now()
-          });
-        }
-      });
-      const info = {
-        streamId: streamHeader.streamId,
-        mimeType: streamHeader.mimeType,
-        totalSize: streamHeader.totalLength ? Number(streamHeader.totalLength) : void 0,
-        topic: streamHeader.topic,
-        timestamp: Number(streamHeader.timestamp),
-        attributes: streamHeader.attributes
-      };
-      streamHandlerCallback(
-        new import_stream_reader.TextStreamReader(info, stream, (0, import_utils.bigIntToNumber)(streamHeader.totalLength)),
-        { identity: participantIdentity }
-      );
-    }
+      import_ffi_client.FfiClient.instance.off(import_ffi_client.FfiClientEvent.FfiEvent, listener);
+      listener = null;
+      this.streamReaders.delete(readerHandle);
+    };
+    const stream = new ReadableStream({
+      start: (controller) => {
+        listener = (ev) => {
+          if (ev.message.case !== "byteStreamReaderEvent" || ev.message.value.readerHandle !== readerHandle) {
+            return;
+          }
+          const detail = ev.message.value.detail;
+          if (detail.case === "chunkReceived") {
+            const content = detail.value.content;
+            if (content.length > 0) {
+              controller.enqueue(new import_rtc_ffi_bindings4.DataStream_Chunk({ content }));
+            }
+          } else if (detail.case === "eos") {
+            unsubscribe();
+            const error = detail.value.error;
+            if (error) {
+              controller.error(new Error(error.description ?? "stream terminated"));
+            } else {
+              controller.close();
+            }
+          }
+        };
+        import_ffi_client.FfiClient.instance.on(import_ffi_client.FfiClientEvent.FfiEvent, listener);
+        this.streamReaders.set(readerHandle, { controller, listener });
+        import_ffi_client.FfiClient.instance.request({
+          message: {
+            case: "byteReadIncremental",
+            value: new import_rtc_ffi_bindings4.ByteStreamReaderReadIncrementalRequest({ readerHandle })
+          }
+        });
+      },
+      // The consumer stopped reading before end-of-stream — ByteStreamReader
+      // .close(), or breaking out of a for-await. The eos event that would have
+      // unsubscribed is never consumed, so the listener would otherwise be run
+      // against every FFI event for the rest of the process. Only the
+      // subscription is released: the reader handle was consumed by the
+      // readIncremental request above, so there is nothing left to dispose.
+      cancel: () => unsubscribe()
+    });
+    streamHandlerCallback(
+      new import_stream_reader.ByteStreamReader(info, stream, (0, import_utils.bigIntToNumber)(ownedReader.info.totalLength)),
+      { identity: participantIdentity }
+    );
   }
-  handleStreamChunk(chunk) {
-    const fileBuffer = this.byteStreamControllers.get(chunk.streamId);
-    if (fileBuffer) {
-      if (chunk.content.length > 0) {
-        fileBuffer.controller.enqueue(chunk);
-      }
+  handleTextStreamOpened(ownedReader, participantIdentity) {
+    const info = (0, import_utils.textStreamInfoFromProto)(ownedReader.info);
+    const readerHandle = ownedReader.handle.id;
+    const streamHandlerCallback = this.textStreamHandlers.get(info.topic);
+    if (!streamHandlerCallback) {
+      import_log.log.debug("ignoring incoming text stream due to no handler for topic: %s", info.topic);
+      new import_ffi_client.FfiHandle(readerHandle).dispose();
+      return;
     }
-    const textBuffer = this.textStreamControllers.get(chunk.streamId);
-    if (textBuffer) {
-      if (chunk.content.length > 0) {
-        textBuffer.controller.enqueue(chunk);
+    const textEncoder = new TextEncoder();
+    let listener = null;
+    const unsubscribe = () => {
+      if (!listener) {
+        return;
       }
-    }
-  }
-  handleStreamTrailer(trailer) {
-    const streamId = trailer.streamId;
-    const fileBuffer = this.byteStreamControllers.get(streamId);
-    if (fileBuffer) {
-      fileBuffer.controller.close();
-      this.byteStreamControllers.delete(streamId);
-    }
-    const textBuffer = this.textStreamControllers.get(streamId);
-    if (textBuffer) {
-      textBuffer.controller.close();
-      this.textStreamControllers.delete(streamId);
-    }
+      import_ffi_client.FfiClient.instance.off(import_ffi_client.FfiClientEvent.FfiEvent, listener);
+      listener = null;
+      this.streamReaders.delete(readerHandle);
+    };
+    const stream = new ReadableStream({
+      start: (controller) => {
+        listener = (ev) => {
+          if (ev.message.case !== "textStreamReaderEvent" || ev.message.value.readerHandle !== readerHandle) {
+            return;
+          }
+          const detail = ev.message.value.detail;
+          if (detail.case === "chunkReceived") {
+            const content = textEncoder.encode(detail.value.content);
+            if (content.length > 0) {
+              controller.enqueue(new import_rtc_ffi_bindings4.DataStream_Chunk({ content }));
+            }
+          } else if (detail.case === "eos") {
+            unsubscribe();
+            const error = detail.value.error;
+            if (error) {
+              controller.error(new Error(error.description ?? "stream terminated"));
+            } else {
+              controller.close();
+            }
+          }
+        };
+        import_ffi_client.FfiClient.instance.on(import_ffi_client.FfiClientEvent.FfiEvent, listener);
+        this.streamReaders.set(readerHandle, { controller, listener });
+        import_ffi_client.FfiClient.instance.request({
+          message: {
+            case: "textReadIncremental",
+            value: new import_rtc_ffi_bindings4.TextStreamReaderReadIncrementalRequest({ readerHandle })
+          }
+        });
+      },
+      // The consumer stopped reading before end-of-stream — TextStreamReader
+      // .close(), or breaking out of a for-await. The eos event that would have
+      // unsubscribed is never consumed, so the listener would otherwise be run
+      // against every FFI event for the rest of the process. Only the
+      // subscription is released: the reader handle was consumed by the
+      // readIncremental request above, so there is nothing left to dispose.
+      cancel: () => unsubscribe()
+    });
+    streamHandlerCallback(
+      new import_stream_reader.TextStreamReader(info, stream, (0, import_utils.bigIntToNumber)(ownedReader.info.totalLength)),
+      { identity: participantIdentity }
+    );
   }
 }
 class ConnectError extends Error {