@livekit/rtc-node 0.13.32 → 0.13.34

package/dist/log.d.ts

@@ -1,11 +1,9 @@
-import * as pino from 'pino';
-import { LevelWithSilent } from 'pino';
-
+import type { LevelWithSilent } from 'pino';
 /**
  * temporarily disabling the transport option as there might be a memory leak in some corner cases related to it
  * see https://github.com/pinojs/pino/issues/2370
  */
-declare const log: pino.Logger<never, boolean>;
-type LogLevel = LevelWithSilent;
-
-export { type LogLevel, log };
+declare const log: import("pino").Logger<never, boolean>;
+export type LogLevel = LevelWithSilent;
+export { log };
+//# sourceMappingURL=log.d.ts.map

package/dist/participant.cjs

@@ -27,14 +27,14 @@ var import_mutex = require("@livekit/mutex");
 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_promises = require("node:fs/promises");
+var import_node_url = require("node:url");
 var import_data_streams = require("./data_streams/index.cjs");
 var import_ffi_client = require("./ffi_client.cjs");
 var import_log = require("./log.cjs");
 var import_rpc = require("./rpc.cjs");
 var import_track_publication = require("./track_publication.cjs");
 var import_utils = require("./utils.cjs");
-const STREAM_CHUNK_SIZE = 15e3;
+var import_utils2 = require("./utils.cjs");
 class Participant {
   constructor(owned_info) {
     this.trackPublications = /* @__PURE__ */ new Map();
@@ -73,31 +73,60 @@ class LocalParticipant extends Participant {
   constructor(info, ffiEventLock, disconnectSignal) {
     super(info);
     this.rpcHandlers = /* @__PURE__ */ new Map();
+    // Handle ids of data stream writers that have been opened but not yet
+    // closed. The FFI close request consumes the handle (take_handle), so an
+    // entry is removed as soon as a close is sent for it; whatever is left when
+    // the room disconnects is dropped by disposeOpenStreamWriters(). Only the
+    // ids are kept — wrapping them in FfiHandle would make GC drop a handle the
+    // close request already consumed.
+    this.openStreamWriters = /* @__PURE__ */ new Set();
     this.trackPublications = /* @__PURE__ */ new Map();
-    this.sendStreamChunk = async (req) => {
-      const type = "sendStreamChunk";
+    this.textStreamWriterWrite = async (req) => {
       const res = import_ffi_client.FfiClient.instance.request({
-        message: { case: type, value: req }
+        message: { case: "textStreamWrite", value: req }
       });
       const cb = await import_ffi_client.FfiClient.instance.waitFor(
-        (ev) => ev.message.case == type && ev.message.value.asyncId == res.asyncId,
+        (ev) => ev.message.case == "textStreamWriterWrite" && ev.message.value.asyncId == res.asyncId,
         { signal: this.disconnectSignal }
       );
       if (cb.error) {
-        throw new Error(cb.error);
+        throw new Error(cb.error.description);
       }
     };
-    this.sendStreamTrailer = async (req) => {
-      const type = "sendStreamTrailer";
+    this.textStreamWriterClose = async (req) => {
       const res = import_ffi_client.FfiClient.instance.request({
-        message: { case: type, value: req }
+        message: { case: "textStreamClose", value: req }
       });
       const cb = await import_ffi_client.FfiClient.instance.waitFor(
-        (ev) => ev.message.case == type && ev.message.value.asyncId == res.asyncId,
+        (ev) => ev.message.case == "textStreamWriterClose" && ev.message.value.asyncId == res.asyncId,
         { signal: this.disconnectSignal }
       );
       if (cb.error) {
-        throw new Error(cb.error);
+        throw new Error(cb.error.description);
+      }
+    };
+    this.byteStreamWriterWrite = async (req) => {
+      const res = import_ffi_client.FfiClient.instance.request({
+        message: { case: "byteStreamWrite", value: req }
+      });
+      const cb = await import_ffi_client.FfiClient.instance.waitFor(
+        (ev) => ev.message.case == "byteStreamWriterWrite" && ev.message.value.asyncId == res.asyncId,
+        { signal: this.disconnectSignal }
+      );
+      if (cb.error) {
+        throw new Error(cb.error.description);
+      }
+    };
+    this.byteStreamWriterClose = async (req) => {
+      const res = import_ffi_client.FfiClient.instance.request({
+        message: { case: "byteStreamClose", value: req }
+      });
+      const cb = await import_ffi_client.FfiClient.instance.waitFor(
+        (ev) => ev.message.case == "byteStreamWriterClose" && ev.message.value.asyncId == res.asyncId,
+        { signal: this.disconnectSignal }
+      );
+      if (cb.error) {
+        throw new Error(cb.error.description);
       }
     };
     this.ffiEventLock = ffiEventLock;
@@ -185,86 +214,55 @@ class LocalParticipant extends Participant {
    * Well suited for TTS and/or streaming LLM output. If you want to simply send a text then use sendText() instead
    */
   async streamText(options) {
-    const senderIdentity = (options == null ? void 0 : options.senderIdentity) ?? this.identity;
-    const streamId = (options == null ? void 0 : options.streamId) ?? crypto.randomUUID();
-    const destinationIdentities = options == null ? void 0 : options.destinationIdentities;
-    const info = {
-      streamId,
-      mimeType: "text/plain",
-      topic: (options == null ? void 0 : options.topic) ?? "",
-      timestamp: Date.now()
-    };
-    const headerReq = new import_rtc_ffi_bindings2.SendStreamHeaderRequest({
-      senderIdentity,
-      destinationIdentities,
+    const req = new import_rtc_ffi_bindings2.TextStreamOpenRequest({
       localParticipantHandle: this.ffi_handle.handle,
-      header: new import_rtc_ffi_bindings2.DataStream_Header({
-        streamId,
-        mimeType: info.mimeType,
-        topic: info.topic,
-        timestamp: (0, import_utils.numberToBigInt)(info.timestamp),
+      options: new import_rtc_ffi_bindings2.StreamTextOptions({
+        topic: (options == null ? void 0 : options.topic) ?? "",
         attributes: options == null ? void 0 : options.attributes,
-        contentHeader: {
-          case: "textHeader",
-          value: new import_rtc_ffi_bindings2.DataStream_TextHeader({
-            operationType: import_rtc_ffi_bindings2.DataStream_OperationType.CREATE,
-            version: 0,
-            replyToStreamId: "",
-            generated: false
-          })
-        }
+        destinationIdentities: options == null ? void 0 : options.destinationIdentities,
+        id: options == null ? void 0 : options.streamId,
+        senderIdentity: (options == null ? void 0 : options.senderIdentity) ?? this.identity
       })
     });
-    await this.sendStreamHeader(headerReq);
-    let nextChunkId = 0;
-    const localHandle = this.ffi_handle.handle;
-    const sendTrailer = this.sendStreamTrailer;
-    const sendChunk = this.sendStreamChunk;
+    const res = import_ffi_client.FfiClient.instance.request({
+      message: { case: "textStreamOpen", value: req }
+    });
+    const cb = await import_ffi_client.FfiClient.instance.waitFor(
+      (ev) => ev.message.case == "textStreamOpen" && ev.message.value.asyncId == res.asyncId,
+      { signal: this.disconnectSignal }
+    );
+    if (cb.result.case !== "writer") {
+      throw new Error(cb.result.case === "error" ? cb.result.value.description : "unknown error");
+    }
+    const writerHandle = cb.result.value.handle.id;
+    const info = (0, import_utils.textStreamInfoFromProto)(cb.result.value.info);
+    this.openStreamWriters.add(writerHandle);
+    const closeWriter = async (reason) => {
+      if (!this.openStreamWriters.delete(writerHandle)) {
+        return;
+      }
+      await this.textStreamWriterClose(new import_rtc_ffi_bindings2.TextStreamWriterCloseRequest({ writerHandle, reason }));
+    };
     const writableStream = new WritableStream({
       // Implement the sink
-      async write(text) {
-        for (const textByteChunk of (0, import_utils.splitUtf8)(text, STREAM_CHUNK_SIZE)) {
-          const chunkRequest = new import_rtc_ffi_bindings2.SendStreamChunkRequest({
-            senderIdentity,
-            localParticipantHandle: localHandle,
-            destinationIdentities,
-            chunk: new import_rtc_ffi_bindings2.DataStream_Chunk({
-              content: textByteChunk,
-              streamId,
-              chunkIndex: (0, import_utils.numberToBigInt)(nextChunkId)
-            })
+      write: async (text) => {
+        try {
+          await this.textStreamWriterWrite(
+            new import_rtc_ffi_bindings2.TextStreamWriterWriteRequest({ writerHandle, text })
+          );
+        } catch (err) {
+          await closeWriter(err instanceof Error ? err.message : String(err ?? "")).catch(() => {
           });
-          await sendChunk(chunkRequest);
-          nextChunkId += 1;
+          throw err;
         }
       },
-      async close() {
-        const trailerReq = new import_rtc_ffi_bindings2.SendStreamTrailerRequest({
-          senderIdentity,
-          localParticipantHandle: localHandle,
-          destinationIdentities,
-          trailer: new import_rtc_ffi_bindings2.DataStream_Trailer({
-            streamId,
-            reason: ""
-          })
-        });
-        await sendTrailer(trailerReq);
-      },
-      // Send a trailer with the error reason so the remote side's stream
+      close: () => closeWriter(),
+      // Close the stream with the error reason so the remote side's stream
       // controller is closed instead of waiting for data that won't arrive.
-      async abort(err) {
+      abort: async (err) => {
         import_log.log.error(err, "Sink Error");
         try {
-          const trailerReq = new import_rtc_ffi_bindings2.SendStreamTrailerRequest({
-            senderIdentity,
-            localParticipantHandle: localHandle,
-            destinationIdentities,
-            trailer: new import_rtc_ffi_bindings2.DataStream_Trailer({
-              streamId,
-              reason: err instanceof Error ? err.message : String(err ?? "")
-            })
-          });
-          await sendTrailer(trailerReq);
+          await closeWriter(err instanceof Error ? err.message : String(err ?? ""));
         } catch {
         }
       }
@@ -273,101 +271,82 @@ class LocalParticipant extends Participant {
     return writer;
   }
   async sendText(text, options) {
-    const writer = await this.streamText(options);
-    await writer.write(text);
-    await writer.close();
-    return writer.info;
+    const req = new import_rtc_ffi_bindings2.StreamSendTextRequest({
+      localParticipantHandle: this.ffi_handle.handle,
+      options: new import_rtc_ffi_bindings2.StreamTextOptions({
+        topic: (options == null ? void 0 : options.topic) ?? "",
+        attributes: options == null ? void 0 : options.attributes,
+        destinationIdentities: options == null ? void 0 : options.destinationIdentities,
+        id: options == null ? void 0 : options.streamId,
+        senderIdentity: this.identity,
+        compress: options == null ? void 0 : options.compress
+      }),
+      text
+    });
+    const res = import_ffi_client.FfiClient.instance.request({
+      message: { case: "sendText", value: req }
+    });
+    const cb = await import_ffi_client.FfiClient.instance.waitFor(
+      (ev) => ev.message.case == "sendText" && ev.message.value.asyncId == res.asyncId,
+      { signal: this.disconnectSignal }
+    );
+    if (cb.result.case !== "info") {
+      throw new Error(cb.result.case === "error" ? cb.result.value.description : "unknown error");
+    }
+    return (0, import_utils.textStreamInfoFromProto)(cb.result.value);
   }
   async streamBytes(options) {
-    const senderIdentity = this.identity;
-    const streamId = (options == null ? void 0 : options.streamId) ?? crypto.randomUUID();
-    const destinationIdentities = options == null ? void 0 : options.destinationIdentities;
-    const info = {
-      streamId,
-      mimeType: (options == null ? void 0 : options.mimeType) ?? "application/octet-stream",
-      topic: (options == null ? void 0 : options.topic) ?? "",
-      timestamp: Date.now(),
-      attributes: options == null ? void 0 : options.attributes,
-      totalSize: options == null ? void 0 : options.totalSize,
-      name: (options == null ? void 0 : options.name) ?? "unknown"
-    };
-    const headerReq = new import_rtc_ffi_bindings2.SendStreamHeaderRequest({
-      senderIdentity,
-      destinationIdentities,
+    const req = new import_rtc_ffi_bindings2.ByteStreamOpenRequest({
       localParticipantHandle: this.ffi_handle.handle,
-      header: new import_rtc_ffi_bindings2.DataStream_Header({
-        streamId,
-        mimeType: info.mimeType,
-        topic: info.topic,
-        timestamp: (0, import_utils.numberToBigInt)(info.timestamp),
-        attributes: info.attributes,
-        totalLength: (0, import_utils.numberToBigInt)(info.totalSize),
-        contentHeader: {
-          case: "byteHeader",
-          value: new import_rtc_ffi_bindings2.DataStream_ByteHeader({
-            name: info.name
-          })
-        }
+      options: new import_rtc_ffi_bindings2.StreamByteOptions({
+        topic: (options == null ? void 0 : options.topic) ?? "",
+        attributes: options == null ? void 0 : options.attributes,
+        destinationIdentities: options == null ? void 0 : options.destinationIdentities,
+        id: options == null ? void 0 : options.streamId,
+        name: (options == null ? void 0 : options.name) ?? "unknown",
+        mimeType: (options == null ? void 0 : options.mimeType) ?? "application/octet-stream",
+        totalLength: (0, import_utils2.numberToBigInt)(options == null ? void 0 : options.totalSize),
+        senderIdentity: this.identity
       })
     });
-    await this.sendStreamHeader(headerReq);
-    let chunkId = 0;
-    const localHandle = this.ffi_handle.handle;
-    const sendTrailer = this.sendStreamTrailer;
-    const sendChunk = this.sendStreamChunk;
-    const writeMutex = new import_mutex.Mutex();
+    const res = import_ffi_client.FfiClient.instance.request({
+      message: { case: "byteStreamOpen", value: req }
+    });
+    const cb = await import_ffi_client.FfiClient.instance.waitFor(
+      (ev) => ev.message.case == "byteStreamOpen" && ev.message.value.asyncId == res.asyncId,
+      { signal: this.disconnectSignal }
+    );
+    if (cb.result.case !== "writer") {
+      throw new Error(cb.result.case === "error" ? cb.result.value.description : "unknown error");
+    }
+    const writerHandle = cb.result.value.handle.id;
+    const info = (0, import_utils.byteStreamInfoFromProto)(cb.result.value.info);
+    this.openStreamWriters.add(writerHandle);
+    const closeWriter = async (reason) => {
+      if (!this.openStreamWriters.delete(writerHandle)) {
+        return;
+      }
+      await this.byteStreamWriterClose(new import_rtc_ffi_bindings2.ByteStreamWriterCloseRequest({ writerHandle, reason }));
+    };
     const writableStream = new WritableStream({
-      async write(chunk) {
-        const unlock = await writeMutex.lock();
-        let byteOffset = 0;
+      write: async (chunk) => {
         try {
-          while (byteOffset < chunk.byteLength) {
-            const subChunk = chunk.slice(byteOffset, byteOffset + STREAM_CHUNK_SIZE);
-            const chunkRequest = new import_rtc_ffi_bindings2.SendStreamChunkRequest({
-              senderIdentity,
-              localParticipantHandle: localHandle,
-              destinationIdentities,
-              chunk: new import_rtc_ffi_bindings2.DataStream_Chunk({
-                content: subChunk,
-                streamId,
-                chunkIndex: (0, import_utils.numberToBigInt)(chunkId)
-              })
-            });
-            await sendChunk(chunkRequest);
-            chunkId += 1;
-            byteOffset += subChunk.byteLength;
-          }
-        } finally {
-          unlock();
+          await this.byteStreamWriterWrite(
+            new import_rtc_ffi_bindings2.ByteStreamWriterWriteRequest({ writerHandle, bytes: chunk })
+          );
+        } catch (err) {
+          await closeWriter(err instanceof Error ? err.message : String(err ?? "")).catch(() => {
+          });
+          throw err;
         }
       },
-      async close() {
-        const trailerReq = new import_rtc_ffi_bindings2.SendStreamTrailerRequest({
-          senderIdentity,
-          localParticipantHandle: localHandle,
-          destinationIdentities,
-          trailer: new import_rtc_ffi_bindings2.DataStream_Trailer({
-            streamId,
-            reason: ""
-          })
-        });
-        await sendTrailer(trailerReq);
-      },
-      // Send a trailer with the error reason so the remote side's stream
+      close: () => closeWriter(),
+      // Close the stream with the error reason so the remote side's stream
       // controller is closed instead of waiting for data that won't arrive.
-      async abort(err) {
+      abort: async (err) => {
         import_log.log.error(err, "Sink error");
         try {
-          const trailerReq = new import_rtc_ffi_bindings2.SendStreamTrailerRequest({
-            senderIdentity,
-            localParticipantHandle: localHandle,
-            destinationIdentities,
-            trailer: new import_rtc_ffi_bindings2.DataStream_Trailer({
-              streamId,
-              reason: err instanceof Error ? err.message : String(err ?? "")
-            })
-          });
-          await sendTrailer(trailerReq);
+          await closeWriter(err instanceof Error ? err.message : String(err ?? ""));
         } catch {
         }
       }
@@ -377,41 +356,49 @@ class LocalParticipant extends Participant {
   }
   /** Sends a file provided as PathLike to specified recipients */
   async sendFile(path, options) {
-    const fileStats = await (0, import_promises.stat)(path);
-    const file = await (0, import_promises.open)(path);
-    try {
-      const stream = file.readableWebStream();
-      const streamId = crypto.randomUUID();
-      const destinationIdentities = options == null ? void 0 : options.destinationIdentities;
-      const writer = await this.streamBytes({
-        streamId,
-        name: options == null ? void 0 : options.name,
-        totalSize: fileStats.size,
-        destinationIdentities,
-        topic: options == null ? void 0 : options.topic,
-        mimeType: options == null ? void 0 : options.mimeType,
-        attributes: options == null ? void 0 : options.attributes
-      });
-      for await (const chunk of stream) {
-        await writer.write(chunk);
-      }
-      await writer.close();
-    } finally {
-      await file.close();
-    }
-  }
-  async sendStreamHeader(req) {
-    const type = "sendStreamHeader";
+    const filePath = path instanceof URL ? (0, import_node_url.fileURLToPath)(path) : path.toString();
+    const req = new import_rtc_ffi_bindings2.StreamSendFileRequest({
+      localParticipantHandle: this.ffi_handle.handle,
+      options: new import_rtc_ffi_bindings2.StreamByteOptions({
+        topic: (options == null ? void 0 : options.topic) ?? "",
+        attributes: options == null ? void 0 : options.attributes,
+        destinationIdentities: options == null ? void 0 : options.destinationIdentities,
+        name: (options == null ? void 0 : options.name) ?? "unknown",
+        mimeType: (options == null ? void 0 : options.mimeType) ?? "application/octet-stream",
+        senderIdentity: this.identity,
+        compress: options == null ? void 0 : options.compress
+      }),
+      filePath
+    });
     const res = import_ffi_client.FfiClient.instance.request({
-      message: { case: type, value: req }
+      message: { case: "sendFile", value: req }
     });
     const cb = await import_ffi_client.FfiClient.instance.waitFor(
-      (ev) => ev.message.case == type && ev.message.value.asyncId == res.asyncId,
+      (ev) => ev.message.case == "sendFile" && ev.message.value.asyncId == res.asyncId,
       { signal: this.disconnectSignal }
     );
-    if (cb.error) {
-      throw new Error(cb.error);
+    if (cb.result.case === "error") {
+      throw new Error(cb.result.value.description);
+    }
+  }
+  /**
+   * Drops the native writers of any data streams that were opened but never
+   * closed — a writer the caller abandoned, or one whose write failed. Their
+   * handles would otherwise be held by the FFI server for the lifetime of the
+   * process. The room is already gone at this point, so the handles are dropped
+   * directly rather than closed: there is no end-of-stream left to deliver.
+   *
+   * @internal
+   */
+  disposeOpenStreamWriters() {
+    for (const writerHandle of this.openStreamWriters) {
+      try {
+        new import_ffi_client.FfiHandle(writerHandle).dispose();
+      } catch (err) {
+        import_log.log.warn("failed to dispose data stream writer handle: %s", err);
+      }
     }
+    this.openStreamWriters.clear();
   }
   /**
    * Sends a chat message to participants in the room