livekit-client 2.15.9 → 2.15.11

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.9";
+var version$1 = "2.15.11";
 
 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) {
@@ -14755,9 +14801,18 @@ class SignalClient {
           const signals = abortSignal ? [timeoutAbortController.signal, abortSignal] : [timeoutAbortController.signal];
           const combinedAbort = AbortSignal.any(signals);
           const abortHandler = event => __awaiter(this, void 0, void 0, function* () {
-            this.close();
-            clearTimeout(wsTimeout);
             const target = event.currentTarget;
+            const reason = getAbortReasonAsString(target, 'Abort handler called');
+            // send leave if we have an active stream writer (connection is open)
+            if (this.streamWriter && !this.isDisconnected) {
+              this.sendLeave().then(() => this.close(reason)).catch(e => {
+                this.log.error(e);
+                this.close();
+              });
+            } else {
+              this.close();
+            }
+            clearTimeout(wsTimeout);
             reject(target instanceof AbortSignal ? target.reason : target);
           });
           combinedAbort.addEventListener('abort', abortHandler);
@@ -14778,9 +14833,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) {
@@ -14818,6 +14871,7 @@ class SignalClient {
               return;
             }
             const signalReader = connection.readable.getReader();
+            this.streamWriter = connection.writable.getWriter();
             const firstMessage = yield signalReader.read();
             signalReader.releaseLock();
             if (!firstMessage.value) {
@@ -14880,6 +14934,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 {
@@ -14890,7 +14945,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;
@@ -15110,12 +15165,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);
@@ -15218,7 +15273,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
       }));
@@ -15286,7 +15341,6 @@ class SignalClient {
     clearTimeout(timeoutHandle);
     this.startPingInterval();
     this.startReadingLoop(connection.readable.getReader(), firstMessage);
-    this.streamWriter = connection.writable.getWriter();
   }
   /**
    * Validates the first message received from the signal server
@@ -17176,6 +17230,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);
   }
@@ -19336,6 +19395,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 {
@@ -19758,13 +19818,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
+        RTCSdpType: sd.type,
+        sdp: sd.sdp,
+        midToTrackId
       }));
+      this.midToTrackId = midToTrackId;
       yield this.pcManager.setPublisherAnswer(sd, offerId);
     });
     // add candidate on trickle
@@ -19779,11 +19842,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);
@@ -20569,6 +20633,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) {
@@ -24246,10 +24323,11 @@ class LocalParticipant extends Participant {
         destinationIdentity,
         method,
         payload,
-        responseTimeout = 10000
+        responseTimeout = 15000
       } = _ref3;
       return function* () {
-        const maxRoundTripLatency = 2000;
+        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) {
@@ -24260,8 +24338,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'));
@@ -26352,6 +26431,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();
       };
@@ -26389,6 +26473,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') {
@@ -26892,6 +26994,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