livekit-client 2.15.10 → 2.15.12

package/dist/livekit-client.esm.mjs

@@ -4262,6 +4262,9 @@ const ParticipantInfo_Kind = /* @__PURE__ */proto3.makeEnum("livekit.Participant
 }, {
   no: 4,
   name: "AGENT"
+}, {
+  no: 7,
+  name: "CONNECTOR"
 }]);
 const ParticipantInfo_KindDetail = /* @__PURE__ */proto3.makeEnum("livekit.ParticipantInfo.KindDetail", [{
   no: 0,
@@ -5348,6 +5351,19 @@ const DataStream_Trailer = /* @__PURE__ */proto3.makeMessageType("livekit.DataSt
 }], {
   localName: "DataStream_Trailer"
 });
+const FilterParams = /* @__PURE__ */proto3.makeMessageType("livekit.FilterParams", () => [{
+  no: 1,
+  name: "include_events",
+  kind: "scalar",
+  T: 9,
+  repeated: true
+}, {
+  no: 2,
+  name: "exclude_events",
+  kind: "scalar",
+  T: 9,
+  repeated: true
+}]);
 const WebhookConfig = /* @__PURE__ */proto3.makeMessageType("livekit.WebhookConfig", () => [{
   no: 1,
   name: "url",
@@ -5360,6 +5376,11 @@ const WebhookConfig = /* @__PURE__ */proto3.makeMessageType("livekit.WebhookConf
   kind: "scalar",
   T: 9
   /* ScalarType.STRING */
+}, {
+  no: 3,
+  name: "filter_params",
+  kind: "message",
+  T: FilterParams
 }]);
 const SubscribedAudioCodec = /* @__PURE__ */proto3.makeMessageType("livekit.SubscribedAudioCodec", () => [{
   no: 1,
@@ -6706,6 +6727,16 @@ const SessionDescription = /* @__PURE__ */proto3.makeMessageType("livekit.Sessio
   kind: "scalar",
   T: 13
   /* ScalarType.UINT32 */
+}, {
+  no: 4,
+  name: "mid_to_track_id",
+  kind: "map",
+  K: 9,
+  V: {
+    kind: "scalar",
+    T: 9
+    /* ScalarType.STRING */
+  }
 }]);
 const ParticipantUpdate = /* @__PURE__ */proto3.makeMessageType("livekit.ParticipantUpdate", () => [{
   no: 1,
@@ -12570,7 +12601,7 @@ function getOSVersion(ua) {
   return ua.includes('mac os') ? getMatch(/\(.+?(\d+_\d+(:?_\d+)?)/, ua, 1).replace(/_/g, '.') : undefined;
 }
 
-var version$1 = "2.15.10";
+var version$1 = "2.15.12";
 
 const version = version$1;
 const protocolVersion = 16;
@@ -14641,6 +14672,21 @@ function parseSignalResponse(value) {
   }
   throw new Error("could not decode websocket message: ".concat(typeof value));
 }
+function getAbortReasonAsString(signal) {
+  let defaultMessage = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'Unknown reason';
+  if (!(signal instanceof AbortSignal)) {
+    return defaultMessage;
+  }
+  const reason = signal.reason;
+  switch (typeof reason) {
+    case 'string':
+      return reason;
+    case 'object':
+      return reason instanceof Error ? reason.message : defaultMessage;
+    default:
+      return 'toString' in reason ? reason.toString() : defaultMessage;
+  }
+}
 
 const passThroughQueueSignals = ['syncState', 'trickle', 'offer', 'answer', 'simulate', 'leave'];
 function canPassThroughQueue(req) {
@@ -14751,26 +14797,33 @@ class SignalClient {
       return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
         var _a, _b;
         try {
-          const timeoutAbortController = new AbortController();
-          const signals = abortSignal ? [timeoutAbortController.signal, abortSignal] : [timeoutAbortController.signal];
-          const combinedAbort = AbortSignal.any(signals);
-          const abortHandler = event => __awaiter(this, void 0, void 0, function* () {
+          let alreadyAborted = false;
+          const abortHandler = eventOrError => __awaiter(this, void 0, void 0, function* () {
+            if (alreadyAborted) {
+              return;
+            }
+            alreadyAborted = true;
+            const target = eventOrError instanceof Event ? eventOrError.currentTarget : eventOrError;
+            const reason = getAbortReasonAsString(target, 'Abort handler called');
             // send leave if we have an active stream writer (connection is open)
-            if (this.streamWriter) {
-              this.sendLeave().then(() => this.close()).catch(e => {
+            if (this.streamWriter && !this.isDisconnected) {
+              this.sendLeave().then(() => this.close(reason)).catch(e => {
                 this.log.error(e);
                 this.close();
               });
             } else {
               this.close();
             }
-            clearTimeout(wsTimeout);
-            const target = event.currentTarget;
+            cleanupAbortHandlers();
             reject(target instanceof AbortSignal ? target.reason : target);
           });
-          combinedAbort.addEventListener('abort', abortHandler);
+          abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.addEventListener('abort', abortHandler);
+          const cleanupAbortHandlers = () => {
+            clearTimeout(wsTimeout);
+            abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.removeEventListener('abort', abortHandler);
+          };
           const wsTimeout = setTimeout(() => {
-            timeoutAbortController.abort(new ConnectionError('room connection has timed out (signal)', ConnectionErrorReason.ServerUnreachable));
+            abortHandler(new ConnectionError('room connection has timed out (signal)', ConnectionErrorReason.ServerUnreachable));
           }, opts.websocketTimeout);
           const handleSignalConnected = (connection, firstMessage) => {
             this.handleSignalConnected(connection, wsTimeout, firstMessage);
@@ -14786,9 +14839,7 @@ class SignalClient {
           if (this.ws) {
             yield this.close(false);
           }
-          this.ws = new WebSocketStream(rtcUrl, {
-            signal: combinedAbort
-          });
+          this.ws = new WebSocketStream(rtcUrl);
           try {
             this.ws.closed.then(closeInfo => {
               if (this.isEstablishingConnection) {
@@ -14855,8 +14906,9 @@ class SignalClient {
             handleSignalConnected(connection, firstMessageToProcess);
             resolve(validation.response);
           } catch (e) {
-            clearTimeout(wsTimeout);
             reject(e);
+          } finally {
+            cleanupAbortHandlers();
           }
         } finally {
           unlock();
@@ -14889,6 +14941,7 @@ class SignalClient {
     return __awaiter(this, arguments, void 0, function () {
       var _this = this;
       let updateState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      let reason = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'Close method called on signal client';
       return function* () {
         const unlock = yield _this.closingLock.lock();
         try {
@@ -14899,7 +14952,7 @@ class SignalClient {
           if (_this.ws) {
             _this.ws.close({
               closeCode: 1000,
-              reason: 'Close method called on signal client'
+              reason
             });
             // calling `ws.close()` only starts the closing handshake (CLOSING state), prefer to wait until state is actually CLOSED
             const closePromise = _this.ws.closed;
@@ -15119,12 +15172,12 @@ class SignalClient {
     if (msg.case === 'answer') {
       const sd = fromProtoSessionDescription(msg.value);
       if (this.onAnswer) {
-        this.onAnswer(sd, msg.value.id);
+        this.onAnswer(sd, msg.value.id, msg.value.midToTrackId);
       }
     } else if (msg.case === 'offer') {
       const sd = fromProtoSessionDescription(msg.value);
       if (this.onOffer) {
-        this.onOffer(sd, msg.value.id);
+        this.onOffer(sd, msg.value.id, msg.value.midToTrackId);
       }
     } else if (msg.case === 'trickle') {
       const candidate = JSON.parse(msg.value.candidateInit);
@@ -15227,7 +15280,7 @@ class SignalClient {
     return __awaiter(this, void 0, void 0, function* () {
       if (this.state === SignalConnectionState.DISCONNECTED) return;
       const onCloseCallback = this.onClose;
-      yield this.close();
+      yield this.close(undefined, reason);
       this.log.debug("websocket connection closed: ".concat(reason), Object.assign(Object.assign({}, this.logContext), {
         reason
       }));
@@ -17184,6 +17237,11 @@ class PCTransportManager {
   addPublisherTransceiverOfKind(kind, transceiverInit) {
     return this.publisher.addTransceiverOfKind(kind, transceiverInit);
   }
+  getMidForReceiver(receiver) {
+    const transceivers = this.subscriber ? this.subscriber.getTransceivers() : this.publisher.getTransceivers();
+    const matchingTransceiver = transceivers.find(transceiver => transceiver.receiver === receiver);
+    return matchingTransceiver === null || matchingTransceiver === void 0 ? void 0 : matchingTransceiver.mid;
+  }
   addPublisherTrack(track) {
     return this.publisher.addTrack(track);
   }
@@ -19344,6 +19402,7 @@ class RTCEngine extends eventsExports.EventEmitter {
     this.reliableDataSequence = 1;
     this.reliableMessageBuffer = new DataPacketBuffer();
     this.reliableReceivedState = new TTLMap(reliabeReceiveStateTTL);
+    this.midToTrackId = {};
     this.handleDataChannel = _a => __awaiter(this, [_a], void 0, function (_ref) {
       var _this = this;
       let {
@@ -19766,14 +19825,16 @@ class RTCEngine extends eventsExports.EventEmitter {
   }
   setupSignalClientCallbacks() {
     // configure signaling client
-    this.client.onAnswer = (sd, offerId) => __awaiter(this, void 0, void 0, function* () {
+    this.client.onAnswer = (sd, offerId, midToTrackId) => __awaiter(this, void 0, void 0, function* () {
       if (!this.pcManager) {
         return;
       }
       this.log.debug('received server answer', Object.assign(Object.assign({}, this.logContext), {
         RTCSdpType: sd.type,
-        sdp: sd.sdp
+        sdp: sd.sdp,
+        midToTrackId
       }));
+      this.midToTrackId = midToTrackId;
       yield this.pcManager.setPublisherAnswer(sd, offerId);
     });
     // add candidate on trickle
@@ -19788,11 +19849,12 @@ class RTCEngine extends eventsExports.EventEmitter {
       this.pcManager.addIceCandidate(candidate, target);
     };
     // when server creates an offer for the client
-    this.client.onOffer = (sd, offerId) => __awaiter(this, void 0, void 0, function* () {
+    this.client.onOffer = (sd, offerId, midToTrackId) => __awaiter(this, void 0, void 0, function* () {
       this.latestRemoteOfferId = offerId;
       if (!this.pcManager) {
         return;
       }
+      this.midToTrackId = midToTrackId;
       const answer = yield this.pcManager.createSubscriberAnswerFromOffer(sd, offerId);
       if (answer) {
         this.client.sendAnswer(answer, offerId);
@@ -20578,6 +20640,19 @@ class RTCEngine extends eventsExports.EventEmitter {
       window.removeEventListener('online', this.handleBrowserOnLine);
     }
   }
+  getTrackIdForReceiver(receiver) {
+    var _a;
+    const mid = (_a = this.pcManager) === null || _a === void 0 ? void 0 : _a.getMidForReceiver(receiver);
+    if (mid) {
+      const match = Object.entries(this.midToTrackId).find(_ref2 => {
+        let [key] = _ref2;
+        return key === mid;
+      });
+      if (match) {
+        return match[1];
+      }
+    }
+  }
 }
 class SignalReconnectError extends Error {}
 function supportOptionalDatachannel(protocol) {
@@ -24259,6 +24334,7 @@ class LocalParticipant extends Participant {
       } = _ref3;
       return function* () {
         const maxRoundTripLatency = 7000;
+        const minEffectiveTimeout = maxRoundTripLatency + 1000;
         return new Promise((resolve, reject) => __awaiter(_this5, void 0, void 0, function* () {
           var _a, _b, _c, _d;
           if (byteLength(payload) > MAX_PAYLOAD_BYTES) {
@@ -24269,8 +24345,9 @@ class LocalParticipant extends Participant {
             reject(RpcError.builtIn('UNSUPPORTED_SERVER'));
             return;
           }
+          const effectiveTimeout = Math.max(responseTimeout, minEffectiveTimeout);
           const id = crypto.randomUUID();
-          yield this.publishRpcRequest(destinationIdentity, id, method, payload, responseTimeout - maxRoundTripLatency);
+          yield this.publishRpcRequest(destinationIdentity, id, method, payload, effectiveTimeout);
           const ackTimeoutId = setTimeout(() => {
             this.pendingAcks.delete(id);
             reject(RpcError.builtIn('CONNECTION_TIMEOUT'));
@@ -26361,6 +26438,11 @@ class Room extends eventsExports.EventEmitter {
     // We'll defer these events until when the room is connected or eventually disconnected.
     if (this.state === ConnectionState.Connecting || this.state === ConnectionState.Reconnecting) {
       const reconnectedHandler = () => {
+        this.log.debug('deferring on track for later', {
+          mediaTrackId: mediaTrack.id,
+          mediaStreamId: stream.id,
+          tracksInStream: stream.getTracks().map(track => track.id)
+        });
         this.onTrackAdded(mediaTrack, stream, receiver);
         cleanup();
       };
@@ -26398,6 +26480,24 @@ class Room extends eventsExports.EventEmitter {
       this.log.error("Tried to add a track for a participant, that's not present. Sid: ".concat(participantSid), this.logContext);
       return;
     }
+    // in single peer connection case, the trackID is locally generated,
+    // not the TR_ prefixed one generated by the server,
+    // use `mid` to find the appropriate track.
+    if (!trackId.startsWith('TR')) {
+      const id = this.engine.getTrackIdForReceiver(receiver);
+      if (!id) {
+        this.log.error("Tried to add a track whose 'sid' could not be found for a participant, that's not present. Sid: ".concat(participantSid), this.logContext);
+        return;
+      }
+      trackId = id;
+    }
+    if (!trackId.startsWith('TR')) {
+      this.log.warn("Tried to add a track whose 'sid' could not be determined for a participant, that's not present. Sid: ".concat(participantSid, ", streamId: ").concat(streamId, ", trackId: ").concat(trackId), Object.assign(Object.assign({}, this.logContext), {
+        rpID: participantSid,
+        streamId,
+        trackId
+      }));
+    }
     let adaptiveStreamSettings;
     if (this.options.adaptiveStream) {
       if (typeof this.options.adaptiveStream === 'object') {
@@ -26901,6 +27001,12 @@ class Room extends eventsExports.EventEmitter {
     if (event !== RoomEvent.ActiveSpeakersChanged && event !== RoomEvent.TranscriptionReceived) {
       // only extract logContext from arguments in order to avoid logging the whole object tree
       const minimizedArgs = mapArgs(args).filter(arg => arg !== undefined);
+      if (event === RoomEvent.TrackSubscribed || event === RoomEvent.TrackUnsubscribed) {
+        this.log.trace("subscribe trace: ".concat(event), Object.assign(Object.assign({}, this.logContext), {
+          event,
+          args: minimizedArgs
+        }));
+      }
       this.log.debug("room event ".concat(event), Object.assign(Object.assign({}, this.logContext), {
         event,
         args: minimizedArgs