@livekit/rtc-node 0.13.24 → 0.13.26

package/dist/participant.cjs

@@ -24,13 +24,13 @@ __export(participant_exports, {
 });
 module.exports = __toCommonJS(participant_exports);
 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_data_streams = require("./data_streams/index.cjs");
 var import_ffi_client = require("./ffi_client.cjs");
 var import_log = require("./log.cjs");
-var import_participant_pb = require("./proto/participant_pb.cjs");
-var import_room_pb = require("./proto/room_pb.cjs");
-var import_rpc_pb = require("./proto/rpc_pb.cjs");
 var import_rpc = require("./rpc.cjs");
 var import_track_publication = require("./track_publication.cjs");
 var import_utils = require("./utils.cjs");
@@ -57,24 +57,51 @@ class Participant {
     return this.info.attributes ?? {};
   }
   get kind() {
-    return this.info.kind ?? import_participant_pb.ParticipantKind.STANDARD;
+    return this.info.kind ?? import_rtc_ffi_bindings.ParticipantKind.STANDARD;
   }
   get disconnectReason() {
-    if (this.info.disconnectReason === import_participant_pb.DisconnectReason.UNKNOWN_REASON) {
+    if (this.info.disconnectReason === import_rtc_ffi_bindings.DisconnectReason.UNKNOWN_REASON) {
       return void 0;
     }
     return this.info.disconnectReason;
   }
 }
 class LocalParticipant extends Participant {
-  constructor(info, ffiEventLock) {
+  constructor(info, ffiEventLock, disconnectSignal) {
     super(info);
     this.rpcHandlers = /* @__PURE__ */ new Map();
     this.trackPublications = /* @__PURE__ */ new Map();
+    this.sendStreamChunk = async (req) => {
+      const type = "sendStreamChunk";
+      const res = import_ffi_client.FfiClient.instance.request({
+        message: { case: type, value: req }
+      });
+      const cb = await import_ffi_client.FfiClient.instance.waitFor(
+        (ev) => ev.message.case == type && ev.message.value.asyncId == res.asyncId,
+        { signal: this.disconnectSignal }
+      );
+      if (cb.error) {
+        throw new Error(cb.error);
+      }
+    };
+    this.sendStreamTrailer = async (req) => {
+      const type = "sendStreamTrailer";
+      const res = import_ffi_client.FfiClient.instance.request({
+        message: { case: type, value: req }
+      });
+      const cb = await import_ffi_client.FfiClient.instance.waitFor(
+        (ev) => ev.message.case == type && ev.message.value.asyncId == res.asyncId,
+        { signal: this.disconnectSignal }
+      );
+      if (cb.error) {
+        throw new Error(cb.error);
+      }
+    };
     this.ffiEventLock = ffiEventLock;
+    this.disconnectSignal = disconnectSignal;
   }
   async publishData(data, options) {
-    const req = new import_room_pb.PublishDataRequest({
+    const req = new import_rtc_ffi_bindings2.PublishDataRequest({
       localParticipantHandle: this.ffi_handle.handle,
       dataPtr: import_ffi_client.FfiClient.instance.retrievePtr(data),
       dataLen: BigInt(data.byteLength),
@@ -85,15 +112,16 @@ class LocalParticipant extends Participant {
     const res = import_ffi_client.FfiClient.instance.request({
       message: { case: "publishData", value: req }
     });
-    const cb = await import_ffi_client.FfiClient.instance.waitFor((ev) => {
-      return ev.message.case == "publishData" && ev.message.value.asyncId == res.asyncId;
-    });
+    const cb = await import_ffi_client.FfiClient.instance.waitFor(
+      (ev) => ev.message.case == "publishData" && ev.message.value.asyncId == res.asyncId,
+      { signal: this.disconnectSignal }
+    );
     if (cb.error) {
       throw new Error(cb.error);
     }
   }
   async publishDtmf(code, digit) {
-    const req = new import_room_pb.PublishSipDtmfRequest({
+    const req = new import_rtc_ffi_bindings2.PublishSipDtmfRequest({
       localParticipantHandle: this.ffi_handle.handle,
       code,
       digit
@@ -101,19 +129,20 @@ class LocalParticipant extends Participant {
     const res = import_ffi_client.FfiClient.instance.request({
       message: { case: "publishSipDtmf", value: req }
     });
-    const cb = await import_ffi_client.FfiClient.instance.waitFor((ev) => {
-      return ev.message.case == "publishSipDtmf" && ev.message.value.asyncId == res.asyncId;
-    });
+    const cb = await import_ffi_client.FfiClient.instance.waitFor(
+      (ev) => ev.message.case == "publishSipDtmf" && ev.message.value.asyncId == res.asyncId,
+      { signal: this.disconnectSignal }
+    );
     if (cb.error) {
       throw new Error(cb.error);
     }
   }
   async publishTranscription(transcription) {
-    const req = new import_room_pb.PublishTranscriptionRequest({
+    const req = new import_rtc_ffi_bindings2.PublishTranscriptionRequest({
       localParticipantHandle: this.ffi_handle.handle,
       participantIdentity: transcription.participantIdentity,
       segments: transcription.segments.map(
-        (s) => new import_room_pb.TranscriptionSegment({
+        (s) => new import_rtc_ffi_bindings2.TranscriptionSegment({
           id: s.id,
           text: s.text,
           startTime: s.startTime,
@@ -127,24 +156,26 @@ class LocalParticipant extends Participant {
     const res = import_ffi_client.FfiClient.instance.request({
       message: { case: "publishTranscription", value: req }
     });
-    const cb = await import_ffi_client.FfiClient.instance.waitFor((ev) => {
-      return ev.message.case == "publishTranscription" && ev.message.value.asyncId == res.asyncId;
-    });
+    const cb = await import_ffi_client.FfiClient.instance.waitFor(
+      (ev) => ev.message.case == "publishTranscription" && ev.message.value.asyncId == res.asyncId,
+      { signal: this.disconnectSignal }
+    );
     if (cb.error) {
       throw new Error(cb.error);
     }
   }
   async updateMetadata(metadata) {
-    const req = new import_room_pb.SetLocalMetadataRequest({
+    const req = new import_rtc_ffi_bindings2.SetLocalMetadataRequest({
       localParticipantHandle: this.ffi_handle.handle,
       metadata
     });
     const res = import_ffi_client.FfiClient.instance.request({
       message: { case: "setLocalMetadata", value: req }
     });
-    await import_ffi_client.FfiClient.instance.waitFor((ev) => {
-      return ev.message.case == "setLocalMetadata" && ev.message.value.asyncId == res.asyncId;
-    });
+    await import_ffi_client.FfiClient.instance.waitFor(
+      (ev) => ev.message.case == "setLocalMetadata" && ev.message.value.asyncId == res.asyncId,
+      { signal: this.disconnectSignal }
+    );
   }
   /**
    * Returns a `StreamWriter` instance that allows to write individual chunks of text to a stream.
@@ -160,11 +191,11 @@ class LocalParticipant extends Participant {
       topic: (options == null ? void 0 : options.topic) ?? "",
       timestamp: Date.now()
     };
-    const headerReq = new import_room_pb.SendStreamHeaderRequest({
+    const headerReq = new import_rtc_ffi_bindings2.SendStreamHeaderRequest({
       senderIdentity,
       destinationIdentities,
       localParticipantHandle: this.ffi_handle.handle,
-      header: new import_room_pb.DataStream_Header({
+      header: new import_rtc_ffi_bindings2.DataStream_Header({
         streamId,
         mimeType: info.mimeType,
         topic: info.topic,
@@ -172,8 +203,8 @@ class LocalParticipant extends Participant {
         attributes: options == null ? void 0 : options.attributes,
         contentHeader: {
           case: "textHeader",
-          value: new import_room_pb.DataStream_TextHeader({
-            operationType: import_room_pb.DataStream_OperationType.CREATE,
+          value: new import_rtc_ffi_bindings2.DataStream_TextHeader({
+            operationType: import_rtc_ffi_bindings2.DataStream_OperationType.CREATE,
             version: 0,
             replyToStreamId: "",
             generated: false
@@ -190,11 +221,11 @@ class LocalParticipant extends Participant {
       // Implement the sink
       async write(text) {
         for (const textByteChunk of (0, import_utils.splitUtf8)(text, STREAM_CHUNK_SIZE)) {
-          const chunkRequest = new import_room_pb.SendStreamChunkRequest({
+          const chunkRequest = new import_rtc_ffi_bindings2.SendStreamChunkRequest({
             senderIdentity,
             localParticipantHandle: localHandle,
             destinationIdentities,
-            chunk: new import_room_pb.DataStream_Chunk({
+            chunk: new import_rtc_ffi_bindings2.DataStream_Chunk({
               content: textByteChunk,
               streamId,
               chunkIndex: (0, import_utils.numberToBigInt)(nextChunkId)
@@ -205,19 +236,34 @@ class LocalParticipant extends Participant {
         }
       },
       async close() {
-        const trailerReq = new import_room_pb.SendStreamTrailerRequest({
+        const trailerReq = new import_rtc_ffi_bindings2.SendStreamTrailerRequest({
           senderIdentity,
           localParticipantHandle: localHandle,
           destinationIdentities,
-          trailer: new import_room_pb.DataStream_Trailer({
+          trailer: new import_rtc_ffi_bindings2.DataStream_Trailer({
             streamId,
             reason: ""
           })
         });
         await sendTrailer(trailerReq);
       },
-      abort(err) {
-        import_log.log.error("Sink error:", err);
+      // Send a trailer 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) {
+        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);
+        } catch {
+        }
       }
     });
     const writer = new import_data_streams.TextStreamWriter(writableStream, info);
@@ -242,11 +288,11 @@ class LocalParticipant extends Participant {
       totalSize: options == null ? void 0 : options.totalSize,
       name: (options == null ? void 0 : options.name) ?? "unknown"
     };
-    const headerReq = new import_room_pb.SendStreamHeaderRequest({
+    const headerReq = new import_rtc_ffi_bindings2.SendStreamHeaderRequest({
       senderIdentity,
       destinationIdentities,
       localParticipantHandle: this.ffi_handle.handle,
-      header: new import_room_pb.DataStream_Header({
+      header: new import_rtc_ffi_bindings2.DataStream_Header({
         streamId,
         mimeType: info.mimeType,
         topic: info.topic,
@@ -255,7 +301,7 @@ class LocalParticipant extends Participant {
         totalLength: (0, import_utils.numberToBigInt)(info.totalSize),
         contentHeader: {
           case: "byteHeader",
-          value: new import_room_pb.DataStream_ByteHeader({
+          value: new import_rtc_ffi_bindings2.DataStream_ByteHeader({
             name: info.name
           })
         }
@@ -274,11 +320,11 @@ class LocalParticipant extends Participant {
         try {
           while (byteOffset < chunk.byteLength) {
             const subChunk = chunk.slice(byteOffset, byteOffset + STREAM_CHUNK_SIZE);
-            const chunkRequest = new import_room_pb.SendStreamChunkRequest({
+            const chunkRequest = new import_rtc_ffi_bindings2.SendStreamChunkRequest({
               senderIdentity,
               localParticipantHandle: localHandle,
               destinationIdentities,
-              chunk: new import_room_pb.DataStream_Chunk({
+              chunk: new import_rtc_ffi_bindings2.DataStream_Chunk({
                 content: subChunk,
                 streamId,
                 chunkIndex: (0, import_utils.numberToBigInt)(chunkId)
@@ -293,19 +339,34 @@ class LocalParticipant extends Participant {
         }
       },
       async close() {
-        const trailerReq = new import_room_pb.SendStreamTrailerRequest({
+        const trailerReq = new import_rtc_ffi_bindings2.SendStreamTrailerRequest({
           senderIdentity,
           localParticipantHandle: localHandle,
           destinationIdentities,
-          trailer: new import_room_pb.DataStream_Trailer({
+          trailer: new import_rtc_ffi_bindings2.DataStream_Trailer({
             streamId,
             reason: ""
           })
         });
         await sendTrailer(trailerReq);
       },
-      abort(err) {
-        import_log.log.error("Sink error:", err);
+      // Send a trailer 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) {
+        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);
+        } catch {
+        }
       }
     });
     const byteWriter = new import_data_streams.ByteStreamWriter(writableStream, info);
@@ -341,33 +402,10 @@ class LocalParticipant extends Participant {
     const res = import_ffi_client.FfiClient.instance.request({
       message: { case: type, value: req }
     });
-    const cb = await import_ffi_client.FfiClient.instance.waitFor((ev) => {
-      return ev.message.case == type && ev.message.value.asyncId == res.asyncId;
-    });
-    if (cb.error) {
-      throw new Error(cb.error);
-    }
-  }
-  async sendStreamChunk(req) {
-    const type = "sendStreamChunk";
-    const res = import_ffi_client.FfiClient.instance.request({
-      message: { case: type, value: req }
-    });
-    const cb = await import_ffi_client.FfiClient.instance.waitFor((ev) => {
-      return ev.message.case == type && ev.message.value.asyncId == res.asyncId;
-    });
-    if (cb.error) {
-      throw new Error(cb.error);
-    }
-  }
-  async sendStreamTrailer(req) {
-    const type = "sendStreamTrailer";
-    const res = import_ffi_client.FfiClient.instance.request({
-      message: { case: type, value: req }
-    });
-    const cb = await import_ffi_client.FfiClient.instance.waitFor((ev) => {
-      return ev.message.case == type && ev.message.value.asyncId == res.asyncId;
-    });
+    const cb = await import_ffi_client.FfiClient.instance.waitFor(
+      (ev) => ev.message.case == type && ev.message.value.asyncId == res.asyncId,
+      { signal: this.disconnectSignal }
+    );
     if (cb.error) {
       throw new Error(cb.error);
     }
@@ -381,7 +419,7 @@ class LocalParticipant extends Participant {
    *
    */
   async sendChatMessage(text, destinationIdentities, senderIdentity) {
-    const req = new import_room_pb.SendChatMessageRequest({
+    const req = new import_rtc_ffi_bindings2.SendChatMessageRequest({
       localParticipantHandle: this.ffi_handle.handle,
       message: text,
       destinationIdentities,
@@ -390,9 +428,10 @@ class LocalParticipant extends Participant {
     const res = import_ffi_client.FfiClient.instance.request({
       message: { case: "sendChatMessage", value: req }
     });
-    const cb = await import_ffi_client.FfiClient.instance.waitFor((ev) => {
-      return ev.message.case == "chatMessage" && ev.message.value.asyncId == res.asyncId;
-    });
+    const cb = await import_ffi_client.FfiClient.instance.waitFor(
+      (ev) => ev.message.case == "chatMessage" && ev.message.value.asyncId == res.asyncId,
+      { signal: this.disconnectSignal }
+    );
     switch (cb.message.case) {
       case "chatMessage":
         const { id, timestamp, editTimestamp, message } = cb.message.value;
@@ -411,10 +450,10 @@ class LocalParticipant extends Participant {
    * @experimental
    */
   async editChatMessage(editText, originalMessage, destinationIdentities, senderIdentity) {
-    const req = new import_room_pb.EditChatMessageRequest({
+    const req = new import_rtc_ffi_bindings2.EditChatMessageRequest({
       localParticipantHandle: this.ffi_handle.handle,
       editText,
-      originalMessage: new import_room_pb.ChatMessage({
+      originalMessage: new import_rtc_ffi_bindings2.ChatMessage({
         ...originalMessage,
         timestamp: BigInt(originalMessage.timestamp),
         editTimestamp: originalMessage.editTimestamp ? BigInt(originalMessage.editTimestamp) : void 0
@@ -425,9 +464,10 @@ class LocalParticipant extends Participant {
     const res = import_ffi_client.FfiClient.instance.request({
       message: { case: "editChatMessage", value: req }
     });
-    const cb = await import_ffi_client.FfiClient.instance.waitFor((ev) => {
-      return ev.message.case == "chatMessage" && ev.message.value.asyncId == res.asyncId;
-    });
+    const cb = await import_ffi_client.FfiClient.instance.waitFor(
+      (ev) => ev.message.case == "chatMessage" && ev.message.value.asyncId == res.asyncId,
+      { signal: this.disconnectSignal }
+    );
     switch (cb.message.case) {
       case "chatMessage":
         const { id, timestamp, editTimestamp, message } = cb.message.value;
@@ -443,31 +483,33 @@ class LocalParticipant extends Participant {
     }
   }
   async updateName(name) {
-    const req = new import_room_pb.SetLocalNameRequest({
+    const req = new import_rtc_ffi_bindings2.SetLocalNameRequest({
       localParticipantHandle: this.ffi_handle.handle,
       name
     });
     const res = import_ffi_client.FfiClient.instance.request({
       message: { case: "setLocalName", value: req }
     });
-    await import_ffi_client.FfiClient.instance.waitFor((ev) => {
-      return ev.message.case == "setLocalName" && ev.message.value.asyncId == res.asyncId;
-    });
+    await import_ffi_client.FfiClient.instance.waitFor(
+      (ev) => ev.message.case == "setLocalName" && ev.message.value.asyncId == res.asyncId,
+      { signal: this.disconnectSignal }
+    );
   }
   async setAttributes(attributes) {
-    const req = new import_room_pb.SetLocalAttributesRequest({
+    const req = new import_rtc_ffi_bindings2.SetLocalAttributesRequest({
       localParticipantHandle: this.ffi_handle.handle,
       attributes: Object.entries(attributes).map(([key, value]) => ({ key, value }))
     });
     const res = import_ffi_client.FfiClient.instance.request({
       message: { case: "setLocalAttributes", value: req }
     });
-    await import_ffi_client.FfiClient.instance.waitFor((ev) => {
-      return ev.message.case == "setLocalAttributes" && ev.message.value.asyncId == res.asyncId;
-    });
+    await import_ffi_client.FfiClient.instance.waitFor(
+      (ev) => ev.message.case == "setLocalAttributes" && ev.message.value.asyncId == res.asyncId,
+      { signal: this.disconnectSignal }
+    );
   }
   async publishTrack(track, options) {
-    const req = new import_room_pb.PublishTrackRequest({
+    const req = new import_rtc_ffi_bindings2.PublishTrackRequest({
       localParticipantHandle: this.ffi_handle.handle,
       trackHandle: track.ffi_handle.handle,
       options
@@ -477,9 +519,10 @@ class LocalParticipant extends Participant {
       message: { case: "publishTrack", value: req }
     });
     try {
-      const cb = await import_ffi_client.FfiClient.instance.waitFor((ev) => {
-        return ev.message.case == "publishTrack" && ev.message.value.asyncId == res.asyncId;
-      });
+      const cb = await import_ffi_client.FfiClient.instance.waitFor(
+        (ev) => ev.message.case == "publishTrack" && ev.message.value.asyncId == res.asyncId,
+        { signal: this.disconnectSignal }
+      );
       switch (cb.message.case) {
         case "publication":
           const track_publication = new import_track_publication.LocalTrackPublication(cb.message.value);
@@ -497,7 +540,7 @@ class LocalParticipant extends Participant {
   async unpublishTrack(trackSid, stopOnUnpublish) {
     const unlock = await this.ffiEventLock.lock();
     try {
-      const req = new import_room_pb.UnpublishTrackRequest({
+      const req = new import_rtc_ffi_bindings2.UnpublishTrackRequest({
         localParticipantHandle: this.ffi_handle.handle,
         trackSid,
         stopOnUnpublish: stopOnUnpublish ?? true
@@ -505,9 +548,10 @@ class LocalParticipant extends Participant {
       const res = import_ffi_client.FfiClient.instance.request({
         message: { case: "unpublishTrack", value: req }
       });
-      const cb = await import_ffi_client.FfiClient.instance.waitFor((ev) => {
-        return ev.message.case == "unpublishTrack" && ev.message.value.asyncId == res.asyncId;
-      });
+      const cb = await import_ffi_client.FfiClient.instance.waitFor(
+        (ev) => ev.message.case == "unpublishTrack" && ev.message.value.asyncId == res.asyncId,
+        { signal: this.disconnectSignal }
+      );
       if (cb.error) {
         throw new Error(cb.error);
       }
@@ -532,7 +576,7 @@ class LocalParticipant extends Participant {
     payload,
     responseTimeout
   }) {
-    const req = new import_rpc_pb.PerformRpcRequest({
+    const req = new import_rtc_ffi_bindings3.PerformRpcRequest({
       localParticipantHandle: this.ffi_handle.handle,
       destinationIdentity,
       method,
@@ -542,9 +586,10 @@ class LocalParticipant extends Participant {
     const res = import_ffi_client.FfiClient.instance.request({
       message: { case: "performRpc", value: req }
     });
-    const cb = await import_ffi_client.FfiClient.instance.waitFor((ev) => {
-      return ev.message.case === "performRpc" && ev.message.value.asyncId === res.asyncId;
-    });
+    const cb = await import_ffi_client.FfiClient.instance.waitFor(
+      (ev) => ev.message.case === "performRpc" && ev.message.value.asyncId === res.asyncId,
+      { signal: this.disconnectSignal }
+    );
     if (cb.error) {
       throw import_rpc.RpcError.fromProto(cb.error);
     }
@@ -580,7 +625,7 @@ class LocalParticipant extends Participant {
    */
   registerRpcMethod(method, handler) {
     this.rpcHandlers.set(method, handler);
-    const req = new import_rpc_pb.RegisterRpcMethodRequest({
+    const req = new import_rtc_ffi_bindings3.RegisterRpcMethodRequest({
       localParticipantHandle: this.ffi_handle.handle,
       method
     });
@@ -595,7 +640,7 @@ class LocalParticipant extends Participant {
    */
   unregisterRpcMethod(method) {
     this.rpcHandlers.delete(method);
-    const req = new import_rpc_pb.UnregisterRpcMethodRequest({
+    const req = new import_rtc_ffi_bindings3.UnregisterRpcMethodRequest({
       localParticipantHandle: this.ffi_handle.handle,
       method
     });
@@ -625,7 +670,7 @@ class LocalParticipant extends Participant {
         }
       }
     }
-    const req = new import_rpc_pb.RpcMethodInvocationResponseRequest({
+    const req = new import_rtc_ffi_bindings3.RpcMethodInvocationResponseRequest({
       localParticipantHandle: this.ffi_handle.handle,
       invocationId,
       error: responseError ? responseError.toProto() : void 0,