livekit-client 2.18.3 → 2.18.4

package/dist/livekit-client.esm.mjs

@@ -8704,6 +8704,11 @@ function wrapPeerConnectionEvent(window, eventNameToWrap, wrapper) {
   if (!window.RTCPeerConnection) {
     return;
   }
+  const addEventListener = Object.getOwnPropertyDescriptor(EventTarget.prototype, 'addEventListener');
+  if (!addEventListener.writable) {
+    log$4('Unable to polyfill events');
+    return;
+  }
   const proto = window.RTCPeerConnection.prototype;
   const nativeAddEventListener = proto.addEventListener;
   proto.addEventListener = function (nativeEventName, cb) {
@@ -8846,7 +8851,7 @@ function detectBrowser(window) {
     // Chrome 74 removed webkitGetUserMedia on http as well so we need the
     // more complicated fallback to webkitRTCPeerConnection.
     result.browser = 'chrome';
-    result.version = parseInt(extractVersion(navigator.userAgent, /Chrom(e|ium)\/(\d+)\./, 2));
+    result.version = parseInt(extractVersion(navigator.userAgent, /Chrom(e|ium)\/(\d+)\./, 2)) || null;
   } else if (window.RTCPeerConnection && navigator.userAgent.match(/AppleWebKit\/(\d+)\./)) {
     // Safari.
     result.browser = 'safari';
@@ -9120,7 +9125,11 @@ function shimGetUserMedia$2(window, browserDetails) {
 function shimMediaStream(window) {
   window.MediaStream = window.MediaStream || window.webkitMediaStream;
 }
-function shimOnTrack$1(window) {
+function shimOnTrack$1(window, browserDetails) {
+  if (browserDetails.version > 102) {
+    // Unified plan is supported so no need to do anything.
+    return;
+  }
   if (typeof window === 'object' && window.RTCPeerConnection && !('ontrack' in window.RTCPeerConnection.prototype)) {
     Object.defineProperty(window.RTCPeerConnection.prototype, 'ontrack', {
       get() {
@@ -9283,7 +9292,10 @@ function shimGetSendersWithDtmf(window) {
     });
   }
 }
-function shimSenderReceiverGetStats(window) {
+function shimSenderReceiverGetStats(window, browserDetails) {
+  if (browserDetails.version >= 67) {
+    return;
+  }
   if (!(typeof window === 'object' && window.RTCPeerConnection && window.RTCRtpSender && window.RTCRtpReceiver)) {
     return;
   }
@@ -9650,6 +9662,10 @@ function shimPeerConnection$1(window, browserDetails) {
 
 // Attempt to fix ONN in plan-b mode.
 function fixNegotiationNeeded(window, browserDetails) {
+  if (browserDetails.version > 102) {
+    // Plan-B is no longer supported.
+    return;
+  }
   wrapPeerConnectionEvent(window, 'negotiationneeded', e => {
     const pc = e.target;
     if (browserDetails.version < 72 || pc.getConfiguration && pc.getConfiguration().sdpSemantics === 'plan-b') {
@@ -9785,6 +9801,15 @@ function shimPeerConnection(window, browserDetails) {
       window.RTCPeerConnection.prototype[method] = methodObj[method];
     });
   }
+}
+function shimGetStats(window, browserDetails) {
+  if (typeof window !== 'object' || !(window.RTCPeerConnection || window.mozRTCPeerConnection)) {
+    return; // probably media.peerconnection.enabled=false in about:config
+  }
+  if (browserDetails.version >= 151) {
+    // https://bugzilla.mozilla.org/show_bug.cgi?id=1056433
+    return;
+  }
   const modernStatsTypes = {
     inboundrtp: 'inbound-rtp',
     outboundrtp: 'outbound-rtp',
@@ -9795,6 +9820,10 @@ function shimPeerConnection(window, browserDetails) {
   const nativeGetStats = window.RTCPeerConnection.prototype.getStats;
   window.RTCPeerConnection.prototype.getStats = function getStats() {
     const [selector, onSucc, onErr] = arguments;
+    if (this.signalingState === 'closed') {
+      // No longer required in FF151+
+      return Promise.resolve(new Map());
+    }
     return nativeGetStats.apply(this, [selector || null]).then(stats => {
       if (browserDetails.version < 53 && !onSucc) {
         // Shim only promise getStats with spec-hyphens in type names
@@ -10009,7 +10038,7 @@ function shimCreateAnswer(window) {
     }
     return origCreateAnswer.apply(this, arguments);
   };
-}var firefoxShim=/*#__PURE__*/Object.freeze({__proto__:null,shimAddTransceiver:shimAddTransceiver,shimCreateAnswer:shimCreateAnswer,shimCreateOffer:shimCreateOffer,shimGetDisplayMedia:shimGetDisplayMedia,shimGetParameters:shimGetParameters,shimGetUserMedia:shimGetUserMedia$1,shimOnTrack:shimOnTrack,shimPeerConnection:shimPeerConnection,shimRTCDataChannel:shimRTCDataChannel,shimReceiverGetStats:shimReceiverGetStats,shimRemoveStream:shimRemoveStream,shimSenderGetStats:shimSenderGetStats});/*
+}var firefoxShim=/*#__PURE__*/Object.freeze({__proto__:null,shimAddTransceiver:shimAddTransceiver,shimCreateAnswer:shimCreateAnswer,shimCreateOffer:shimCreateOffer,shimGetDisplayMedia:shimGetDisplayMedia,shimGetParameters:shimGetParameters,shimGetStats:shimGetStats,shimGetUserMedia:shimGetUserMedia$1,shimOnTrack:shimOnTrack,shimPeerConnection:shimPeerConnection,shimRTCDataChannel:shimRTCDataChannel,shimReceiverGetStats:shimReceiverGetStats,shimRemoveStream:shimRemoveStream,shimSenderGetStats:shimSenderGetStats});/*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
@@ -10444,7 +10473,7 @@ function requireSdp() {
       const type = candidate.type;
       sdp.push('typ');
       sdp.push(type);
-      if (type !== 'host' && candidate.relatedAddress && candidate.relatedPort) {
+      if (type !== 'host' && candidate.relatedAddress && candidate.relatedPort !== undefined) {
         sdp.push('raddr');
         sdp.push(candidate.relatedAddress);
         sdp.push('rport');
@@ -10517,6 +10546,8 @@ function requireSdp() {
     // Parses a fmtp line, returns dictionary. Sample input:
     // a=fmtp:96 vbr=on;cng=on
     // Also deals with vbr=on; cng=on
+    // Non-key-value such as telephone-events `0-15` get parsed as
+    // {`0-15`:undefined}
     SDPUtils.parseFmtp = function (line) {
       const parsed = {};
       let kv;
@@ -11290,15 +11321,21 @@ function shimMaxMessageSize(window, browserDetails) {
     return origSetRemoteDescription.apply(this, arguments);
   };
 }
-function shimSendThrowTypeError(window) {
+function shimSendThrowTypeError(window, browserDetails) {
   if (!(window.RTCPeerConnection && 'createDataChannel' in window.RTCPeerConnection.prototype)) {
     return;
   }
+  if (browserDetails.browser === 'chrome' && browserDetails.version > 149) {
+    // Fixed by https://issues.chromium.org/issues/490588131
+    return;
+  }
 
   // Note: Although Firefox >= 57 has a native implementation, the maximum
   //       message size can be reset for all data channels at a later stage.
   //       See: https://bugzilla.mozilla.org/show_bug.cgi?id=1426831
-
+  if (browserDetails.browser === 'firefox' && browserDetails.version > 60) {
+    return;
+  }
   function wrapDcSend(dc, pc) {
     const origDataChannelSend = dc.send;
     dc.send = function send() {
@@ -11536,16 +11573,16 @@ function adapterFactory() {
       shimGetUserMedia$2(window, browserDetails);
       shimMediaStream(window);
       shimPeerConnection$1(window, browserDetails);
-      shimOnTrack$1(window);
+      shimOnTrack$1(window, browserDetails);
       shimAddTrackRemoveTrack(window, browserDetails);
       shimGetSendersWithDtmf(window);
-      shimSenderReceiverGetStats(window);
+      shimSenderReceiverGetStats(window, browserDetails);
       fixNegotiationNeeded(window, browserDetails);
       shimRTCIceCandidate(window);
       shimRTCIceCandidateRelayProtocol(window);
       shimConnectionState(window);
       shimMaxMessageSize(window, browserDetails);
-      shimSendThrowTypeError(window);
+      shimSendThrowTypeError(window, browserDetails);
       removeExtmapAllowMixed(window, browserDetails);
       break;
     case 'firefox':
@@ -11562,6 +11599,7 @@ function adapterFactory() {
       shimParameterlessSetLocalDescription(window);
       shimGetUserMedia$1(window, browserDetails);
       shimPeerConnection(window, browserDetails);
+      shimGetStats(window, browserDetails);
       shimOnTrack(window);
       shimRemoveStream(window);
       shimSenderGetStats(window);
@@ -11574,7 +11612,7 @@ function adapterFactory() {
       shimRTCIceCandidate(window);
       shimConnectionState(window);
       shimMaxMessageSize(window, browserDetails);
-      shimSendThrowTypeError(window);
+      shimSendThrowTypeError(window, browserDetails);
       break;
     case 'safari':
       if (!safariShim || !options.shimSafari) {
@@ -11599,7 +11637,7 @@ function adapterFactory() {
       shimRTCIceCandidate(window);
       shimRTCIceCandidateRelayProtocol(window);
       shimMaxMessageSize(window, browserDetails);
-      shimSendThrowTypeError(window);
+      shimSendThrowTypeError(window, browserDetails);
       removeExtmapAllowMixed(window, browserDetails);
       break;
     default:
@@ -11706,7 +11744,7 @@ function getMatch(exp, ua) {
 }
 function getOSVersion(ua) {
   return ua.includes('mac os') ? getMatch(/\(.+?(\d+_\d+(:?_\d+)?)/, ua, 1).replace(/_/g, '.') : undefined;
-}var version$1 = "2.18.3";const version = version$1;
+}var version$1 = "2.18.4";const version = version$1;
 const protocolVersion = 16;/** Base error that all LiveKit specific custom errors inherit from. */
 class LivekitError extends Error {
   constructor(code, message, options) {
@@ -17120,6 +17158,7 @@ class PCTransport extends eventsExports.EventEmitter {
       if (!this._pc) {
         return;
       }
+      this.pendingInitialOffer = undefined;
       this._pc.close();
       this._pc.onconnectionstatechange = null;
       this._pc.oniceconnectionstatechange = null;
@@ -17207,7 +17246,7 @@ class PCTransport extends eventsExports.EventEmitter {
         this.remoteStereoMids = stereoMids;
         this.remoteNackMids = nackMids;
       } else if (sd.type === 'answer') {
-        if (this.pendingInitialOffer) {
+        if (this.pendingInitialOffer && this._pc) {
           const initialOffer = this.pendingInitialOffer;
           this.pendingInitialOffer = undefined;
           const sdpParsed = libExports.parse((_a = initialOffer.sdp) !== null && _a !== void 0 ? _a : '');
@@ -17529,6 +17568,7 @@ class PCTransport extends eventsExports.EventEmitter {
   }
   setMungedSDP(sd, munged, remote) {
     return __awaiter(this, void 0, void 0, function* () {
+      var _a, _b;
       if (munged) {
         const originalSdp = sd.sdp;
         sd.sdp = munged;
@@ -17550,9 +17590,9 @@ class PCTransport extends eventsExports.EventEmitter {
       }
       try {
         if (remote) {
-          yield this.pc.setRemoteDescription(sd);
+          yield (_a = this._pc) === null || _a === void 0 ? void 0 : _a.setRemoteDescription(sd);
         } else {
-          yield this.pc.setLocalDescription(sd);
+          yield (_b = this._pc) === null || _b === void 0 ? void 0 : _b.setLocalDescription(sd);
         }
       } catch (e) {
         let msg = 'unknown error';
@@ -20333,6 +20373,7 @@ class RTCEngine extends eventsExports.EventEmitter {
     /** specifies how often an initial join connection is allowed to retry */
     this.maxJoinAttempts = 1;
     this.shouldFailNext = false;
+    this.shouldFailOnV1Path = false;
     this.log = livekitLogger;
     this.reliableDataSequence = 1;
     this.reliableMessageBuffer = new DataPacketBuffer();
@@ -20634,6 +20675,11 @@ class RTCEngine extends eventsExports.EventEmitter {
           if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
             throw ConnectionError.cancelled('Connection aborted');
           }
+          if (!useV0Path && _this2.shouldFailOnV1Path) {
+            _this2.shouldFailOnV1Path = false;
+            throw ConnectionError.serviceNotFound('Simulated v1 path failure', 'v0-rtc');
+          }
+          livekitLogger.warn('joining signal with ', url);
           const joinResponse = yield _this2.client.join(url, token, opts, abortSignal, useV0Path, offerProto);
           _this2._isClosed = false;
           _this2.latestJoinResponse = joinResponse;
@@ -20683,6 +20729,10 @@ class RTCEngine extends eventsExports.EventEmitter {
               }
             } else if (e.reason === ConnectionErrorReason.ServiceNotFound) {
               _this2.log.warn("Initial connection failed: ".concat(e.message, " \u2013 Retrying"));
+              if (_this2.pcManager) {
+                _this2.pcManager.onStateChange = undefined;
+                yield _this2.cleanupPeerConnections();
+              }
               return _this2.join(url, token, opts, abortSignal, true);
             }
           }
@@ -21783,6 +21833,11 @@ class RTCEngine extends eventsExports.EventEmitter {
     // debugging method to fail the next reconnect/resume attempt
     this.shouldFailNext = true;
   }
+  /* @internal */
+  failNextV1Path() {
+    // debugging method to fail the next connection attempt for /rtc/v1 to trigger the fallback version
+    this.shouldFailOnV1Path = true;
+  }
   dataChannelsInfo() {
     const infos = [];
     const getInfo = (dc, target) => {
@@ -23540,55 +23595,82 @@ class IncomingDataTrackManager extends eventsExports.EventEmitter {
     let bufferSize = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : READABLE_STREAM_DEFAULT_BUFFER_SIZE;
     let streamController = null;
     const sfuSubscriptionComplete = new Future();
+    const detachSignal = () => {
+      signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', onAbort);
+    };
+    const cleanup = () => {
+      detachSignal();
+      if (!streamController) {
+        log$1.warn("ReadableStream subscribed to ".concat(sid, " was not started."));
+        return;
+      }
+      const descriptor = this.descriptors.get(sid);
+      if (!descriptor) {
+        log$1.warn("Unknown track ".concat(sid, ", skipping cancel..."));
+        return;
+      }
+      if (descriptor.subscription.type !== 'active') {
+        log$1.warn("Subscription for track ".concat(sid, " is not active, skipping cancel..."));
+        return;
+      }
+      descriptor.subscription.streamControllers.delete(streamController);
+      // If no active stream controllers are left, also unsubscribe on the SFU end.
+      if (descriptor.subscription.streamControllers.size === 0) {
+        this.unSubscribeRequest(descriptor.info.sid);
+      }
+    };
+    const onAbort = () => {
+      var _a;
+      if (!streamController) {
+        return;
+      }
+      const currentDescriptor = this.descriptors.get(sid);
+      if ((currentDescriptor === null || currentDescriptor === void 0 ? void 0 : currentDescriptor.subscription.type) === 'active') {
+        currentDescriptor.subscription.streamControllers.delete(streamController);
+      }
+      streamController.error(DataTrackSubscribeError.cancelled());
+      (_a = sfuSubscriptionComplete.reject) === null || _a === void 0 ? void 0 : _a.call(sfuSubscriptionComplete, DataTrackSubscribeError.cancelled());
+      cleanup();
+    };
     const stream = new ReadableStream({
       start: controller => {
         streamController = controller;
-        const onAbort = () => {
-          var _a;
-          controller.error(DataTrackSubscribeError.cancelled());
-          (_a = sfuSubscriptionComplete.reject) === null || _a === void 0 ? void 0 : _a.call(sfuSubscriptionComplete, DataTrackSubscribeError.cancelled());
-        };
         this.subscribeRequest(sid, signal).then(() => __awaiter(this, void 0, void 0, function* () {
-          var _a;
-          signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', onAbort);
+          var _a, _b, _c;
           const descriptor = this.descriptors.get(sid);
           if (!descriptor) {
             log$1.error("Unknown track ".concat(sid));
+            const err = DataTrackSubscribeError.disconnected();
+            controller.error(err);
+            (_a = sfuSubscriptionComplete.reject) === null || _a === void 0 ? void 0 : _a.call(sfuSubscriptionComplete, err);
             return;
           }
           if (descriptor.subscription.type !== 'active') {
             log$1.error("Subscription for track ".concat(sid, " is not active"));
+            const err = DataTrackSubscribeError.disconnected();
+            controller.error(err);
+            (_b = sfuSubscriptionComplete.reject) === null || _b === void 0 ? void 0 : _b.call(sfuSubscriptionComplete, err);
             return;
           }
-          descriptor.subscription.streamControllers.add(controller);
-          (_a = sfuSubscriptionComplete.resolve) === null || _a === void 0 ? void 0 : _a.call(sfuSubscriptionComplete);
+          // Attach the abort signal, aborting immediately if the abort signal was fired while
+          // subscribeRequest was in flight.
+          if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            onAbort();
+            return;
+          }
+          signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', onAbort);
+          descriptor.subscription.streamControllers.set(controller, detachSignal);
+          (_c = sfuSubscriptionComplete.resolve) === null || _c === void 0 ? void 0 : _c.call(sfuSubscriptionComplete);
         })).catch(err => {
           var _a;
+          // subscribeRequest rejected (cancelled, timed out, disconnected). The signal
+          // listener was never attached in this path, so nothing to detach.
           controller.error(err);
           (_a = sfuSubscriptionComplete.reject) === null || _a === void 0 ? void 0 : _a.call(sfuSubscriptionComplete, err);
-        }).finally(() => {
-          signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', onAbort);
         });
       },
       cancel: () => {
-        if (!streamController) {
-          log$1.warn("ReadableStream subscribed to ".concat(sid, " was not started."));
-          return;
-        }
-        const descriptor = this.descriptors.get(sid);
-        if (!descriptor) {
-          log$1.warn("Unknown track ".concat(sid, ", skipping cancel..."));
-          return;
-        }
-        if (descriptor.subscription.type !== 'active') {
-          log$1.warn("Subscription for track ".concat(sid, " is not active, skipping cancel..."));
-          return;
-        }
-        descriptor.subscription.streamControllers.delete(streamController);
-        // If no active stream controllers are left, also unsubscribe on the SFU end.
-        if (descriptor.subscription.streamControllers.size === 0) {
-          this.unSubscribeRequest(descriptor.info.sid);
-        }
+        cleanup();
       }
     }, new CountQueuingStrategy({
       highWaterMark: bufferSize
@@ -23726,9 +23808,7 @@ class IncomingDataTrackManager extends eventsExports.EventEmitter {
       log$1.warn("Unexpected descriptor state in unSubscribeRequest, expected active, found ".concat((_a = descriptor.subscription) === null || _a === void 0 ? void 0 : _a.type));
       return;
     }
-    for (const controller of descriptor.subscription.streamControllers) {
-      controller.close();
-    }
+    this.closeStreamControllers(descriptor.subscription.streamControllers, sid);
     // FIXME: this might be wrong? Shouldn't this only occur if it is the last subscription to
     // terminate?
     const previousDescriptorSubscription = descriptor.subscription;
@@ -23741,6 +23821,23 @@ class IncomingDataTrackManager extends eventsExports.EventEmitter {
       subscribe: false
     });
   }
+  /** Detach abort-signal listeners and close all downstream stream controllers for an active
+   * subscription. Used when the subscription is being torn down by the manager (unsubscribe,
+   * unpublish, or shutdown). */
+  closeStreamControllers(streamControllers, sid) {
+    for (const [controller, detachSignal] of streamControllers) {
+      // Detach before close so we don't leak a listener on the user's AbortSignal.
+      detachSignal();
+      try {
+        controller.close();
+      } catch (err) {
+        // Defensive: if the controller has already been errored (e.g. by a racing abort whose
+        // listener removed itself before we got here), close() throws. There's nothing
+        // meaningful to do other than log — the stream is already terminal.
+        log$1.warn("Failed to close readable stream for track ".concat(sid, ": ").concat(err));
+      }
+    }
+  }
   /** SFU notification that track publications have changed.
    *
    * This event is produced from both {@link JoinResponse} and {@link ParticipantUpdate}
@@ -23822,9 +23919,7 @@ class IncomingDataTrackManager extends eventsExports.EventEmitter {
     }
     this.descriptors.delete(sid);
     if (descriptor.subscription.type === 'active') {
-      descriptor.subscription.streamControllers.forEach(controller => {
-        controller.close();
-      });
+      this.closeStreamControllers(descriptor.subscription.streamControllers, sid);
       this.subscriptionHandles.delete(descriptor.subscription.subcriptionHandle);
     }
     this.emit('trackUnpublished', {
@@ -23874,7 +23969,7 @@ class IncomingDataTrackManager extends eventsExports.EventEmitter {
             type: 'active',
             subcriptionHandle: assignedHandle,
             pipeline,
-            streamControllers: new Set()
+            streamControllers: new Map()
           };
           this.subscriptionHandles.set(assignedHandle, sid);
           (_b = (_a = previousDescriptorSubscription.completionFuture).resolve) === null || _b === void 0 ? void 0 : _b.call(_a);
@@ -23911,7 +24006,7 @@ class IncomingDataTrackManager extends eventsExports.EventEmitter {
         return;
       }
       // Broadcast to all downstream subscribers
-      for (const controller of descriptor.subscription.streamControllers) {
+      for (const controller of descriptor.subscription.streamControllers.keys()) {
         if (controller.desiredSize !== null && controller.desiredSize <= 0) {
           log$1.warn("Cannot send frame to subscribers: readable stream is full (desiredSize is ".concat(controller.desiredSize, "). To increase this threshold, set a higher 'options.highWaterMark' when calling .subscribe()."));
           continue;
@@ -23969,7 +24064,7 @@ class IncomingDataTrackManager extends eventsExports.EventEmitter {
         (_b = (_a = descriptor.subscription.completionFuture).reject) === null || _b === void 0 ? void 0 : _b.call(_a, DataTrackSubscribeError.disconnected());
       }
       if (descriptor.subscription.type === 'active') {
-        descriptor.subscription.streamControllers.forEach(controller => controller.close());
+        this.closeStreamControllers(descriptor.subscription.streamControllers, descriptor.info.sid);
       }
     }
     this.descriptors.clear();
@@ -27718,14 +27813,14 @@ class DeferrableMap extends Map {
     this.pending = new Map();
   }
   set(key, value) {
-    var _a;
+    var _a, _b;
     super.set(key, value);
     // Resolve any futures waiting on this key.
-    const futures = this.pending.get(key);
+    const futures = (_a = this.pending) === null || _a === void 0 ? void 0 : _a.get(key);
     if (futures) {
       for (const future of futures) {
         if (!future.isResolved) {
-          (_a = future.resolve) === null || _a === void 0 ? void 0 : _a.call(future, value);
+          (_b = future.resolve) === null || _b === void 0 ? void 0 : _b.call(future, value);
         }
       }
       this.pending.delete(key);
@@ -27733,7 +27828,7 @@ class DeferrableMap extends Map {
     return this;
   }
   get [Symbol.toStringTag]() {
-    return 'WaitableMap';
+    return 'DeferrableMap';
   }
   getDeferred(key, signal) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -28056,8 +28151,13 @@ class DeferrableMap extends Map {
   }
 }class RemoteParticipant extends Participant {
   /** @internal */
-  static fromParticipantInfo(signalClient, pi, loggerOptions) {
-    return new RemoteParticipant(signalClient, pi.sid, pi.identity, pi.name, pi.metadata, pi.attributes, loggerOptions, pi.kind);
+  static fromParticipantInfo(signalClient, pi, loggerOptions, manager) {
+    return new RemoteParticipant(signalClient, pi.sid, pi.identity, pi.name, pi.metadata, pi.attributes, loggerOptions, pi.kind, pi.dataTracks.map(dti => {
+      const info = DataTrackInfo.from(dti);
+      return new RemoteDataTrack(info, manager, {
+        publisherIdentity: pi.identity
+      });
+    }));
   }
   get logContext() {
     return Object.assign(Object.assign({}, super.logContext), {
@@ -28068,12 +28168,15 @@ class DeferrableMap extends Map {
   /** @internal */
   constructor(signalClient, sid, identity, name, metadata, attributes, loggerOptions) {
     let kind = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : ParticipantInfo_Kind.STANDARD;
+    let remoteDataTracks = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : [];
     super(sid, identity || '', name, metadata, attributes, loggerOptions, kind);
     this.signalClient = signalClient;
     this.trackPublications = new Map();
     this.audioTrackPublications = new Map();
     this.videoTrackPublications = new Map();
-    this.dataTracks = new DeferrableMap();
+    this.dataTracks = new DeferrableMap(remoteDataTracks.map(remoteDataTrack => {
+      return [remoteDataTrack.info.name, remoteDataTrack];
+    }));
     this.volumeMap = new Map();
   }
   addTrackPublication(publication) {
@@ -29367,18 +29470,7 @@ class Room extends eventsExports.EventEmitter {
     }).on(EngineEvent.DCBufferStatusChanged, (status, kind) => {
       this.emit(RoomEvent.DCBufferStatusChanged, status, kind);
     }).on(EngineEvent.LocalTrackSubscribed, subscribedSid => {
-      const trackPublication = this.localParticipant.getTrackPublications().find(_ref2 => {
-        let {
-          trackSid
-        } = _ref2;
-        return trackSid === subscribedSid;
-      });
-      if (!trackPublication) {
-        this.log.warn('could not find local track subscription for subscribed event', this.logContext);
-        return;
-      }
-      this.localParticipant.emit(ParticipantEvent.LocalTrackSubscribed, trackPublication);
-      this.emitWhenConnected(RoomEvent.LocalTrackSubscribed, trackPublication, this.localParticipant);
+      this.handleLocalTrackSubscribed(subscribedSid);
     }).on(EngineEvent.RoomMoved, roomMoved => {
       this.log.debug('room moved', roomMoved);
       if (roomMoved.room) {
@@ -29414,8 +29506,8 @@ class Room extends eventsExports.EventEmitter {
       }
       this.outgoingDataTrackManager.receivedSfuUnpublishResponse(event.info.pubHandle);
     }).on(EngineEvent.DataTrackSubscriberHandles, event => {
-      const handleToSidMapping = new Map(Object.entries(event.subHandles).map(_ref3 => {
-        let [key, value] = _ref3;
+      const handleToSidMapping = new Map(Object.entries(event.subHandles).map(_ref2 => {
+        let [key, value] = _ref2;
         return [parseInt(key, 10), value.trackSid];
       }));
       this.incomingDataTrackManager.receivedSfuSubscriberHandles(handleToSidMapping);
@@ -29521,6 +29613,9 @@ class Room extends eventsExports.EventEmitter {
           // @ts-expect-error function is private
           yield this.engine.client.handleOnClose('simulate disconnect');
           break;
+        case 'fail-on-v1-path':
+          this.engine.failNextV1Path();
+          break;
         case 'speaker':
           req = new SimulateScenario({
             scenario: {
@@ -29844,6 +29939,56 @@ class Room extends eventsExports.EventEmitter {
       this.emit(RoomEvent.EncryptionError, new Error("Encrypted ".concat(publication.source, " track received from participant ").concat(participant.sid, ", but room does not have encryption enabled!")));
     }
   }
+  handleLocalTrackSubscribed(subscribedSid) {
+    const findPublication = () => this.localParticipant.getTrackPublications().find(_ref3 => {
+      let {
+        trackSid
+      } = _ref3;
+      return trackSid === subscribedSid;
+    });
+    const trackPublication = findPublication();
+    if (trackPublication) {
+      this.emitLocalTrackSubscribed(trackPublication);
+      return;
+    }
+    // the track publication may not be registered yet if the server signals
+    // the subscription before publishTrack has finished adding the publication.
+    // defer with a timeout until LocalTrackPublished fires for the matching trackSid
+    this.log.debug('deferring LocalTrackSubscribed, publication not yet available', Object.assign(Object.assign({}, this.logContext), {
+      subscribedSid
+    }));
+    const TIMEOUT_MS = 10000;
+    let timer;
+    const onPublished = pub => {
+      if (pub.trackSid === subscribedSid) {
+        cleanup();
+        this.emitLocalTrackSubscribed(pub);
+      }
+    };
+    const cleanup = () => {
+      clearTimeout(timer);
+      this.localParticipant.off(ParticipantEvent.LocalTrackPublished, onPublished);
+      this.off(RoomEvent.Disconnected, cleanup);
+    };
+    this.localParticipant.on(ParticipantEvent.LocalTrackPublished, onPublished);
+    this.once(RoomEvent.Disconnected, cleanup);
+    timer = setTimeout(() => {
+      cleanup();
+      // final attempt in case the publication was added without emitting the event
+      const pub = findPublication();
+      if (pub) {
+        this.emitLocalTrackSubscribed(pub);
+      } else {
+        this.log.warn('could not find local track publication for LocalTrackSubscribed event after timeout', Object.assign(Object.assign({}, this.logContext), {
+          subscribedSid
+        }));
+      }
+    }, TIMEOUT_MS);
+  }
+  emitLocalTrackSubscribed(trackPublication) {
+    this.localParticipant.emit(ParticipantEvent.LocalTrackSubscribed, trackPublication);
+    this.emitWhenConnected(RoomEvent.LocalTrackSubscribed, trackPublication, this.localParticipant);
+  }
   handleDisconnect() {
     let shouldStopTracks = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
     let reason = arguments.length > 1 ? arguments[1] : undefined;
@@ -30048,7 +30193,7 @@ class Room extends eventsExports.EventEmitter {
       participant = RemoteParticipant.fromParticipantInfo(this.engine.client, info, {
         loggerContextCb: () => this.logContext,
         loggerName: this.options.loggerName
-      });
+      }, this.incomingDataTrackManager);
     } else {
       participant = new RemoteParticipant(this.engine.client, '', identity, undefined, undefined, undefined, {
         loggerContextCb: () => this.logContext,