@fairfox/polly 0.54.0 → 0.56.0

package/dist/src/mesh.d.ts

@@ -29,7 +29,7 @@ export type { MeshSignalingClientOptions, SignalingMessage as MeshSignalingMessa
 export { MeshSignalingClient } from "./shared/lib/mesh-signaling-client";
 export type { MeshStateOptions } from "./shared/lib/mesh-state";
 export { $meshCounter, $meshList, $meshState, $meshText, configureMeshState, resetMeshState, } from "./shared/lib/mesh-state";
-export type { MeshWebRTCAdapterOptions } from "./shared/lib/mesh-webrtc-adapter";
+export type { InFlightSyncSnapshot, MeshWebRTCAdapterOptions, SlotInitiationDecision, SlotInitiationRejectionReason, SweepSnapshot, SyncHandshakeAttemptSnapshot, SyncProgressEvent, TransportSnapshot, } from "./shared/lib/mesh-webrtc-adapter";
 export { DEFAULT_ICE_SERVERS, MeshWebRTCAdapter } from "./shared/lib/mesh-webrtc-adapter";
 export type { CreatePairingTokenOptions, PairingToken, } from "./shared/lib/pairing";
 export { applyPairingToken, createPairingToken, createPairingTokenWithFreshIdentity, DEFAULT_PAIRING_TTL_MS, decodePairingToken, encodePairingToken, isPairingTokenExpired, PAIRING_NONCE_BYTES, PAIRING_TOKEN_VERSION, PairingError, parsePairingToken, serialisePairingToken, } from "./shared/lib/pairing";

package/dist/src/mesh.js

@@ -1933,6 +1933,141 @@ function findSubarray2(haystack, needle) {
 }
 
 // src/shared/lib/mesh-webrtc-adapter.ts
+async function collectTransportSnapshot(connection, lastDataChannelError) {
+  const at = performance.now();
+  let report;
+  try {
+    report = await connection.getStats();
+  } catch {
+    return emptyTransportSnapshot(lastDataChannelError, at);
+  }
+  const parsed = partitionStats(report);
+  const selectedPair = selectActivePair(parsed);
+  const selectedCandidatePair = selectedPair ? buildCandidatePairView(selectedPair, parsed.localCands, parsed.remoteCands) : undefined;
+  return {
+    selectedCandidatePair,
+    retransmittedPacketsSent: parsed.retransmittedPacketsSent,
+    retransmittedBytesSent: parsed.retransmittedBytesSent,
+    lastDataChannelError,
+    at
+  };
+}
+function emptyTransportSnapshot(lastDataChannelError, at) {
+  return {
+    selectedCandidatePair: undefined,
+    retransmittedPacketsSent: undefined,
+    retransmittedBytesSent: undefined,
+    lastDataChannelError,
+    at
+  };
+}
+function partitionStats(report) {
+  const out = {
+    localCands: new Map,
+    remoteCands: new Map,
+    pairs: new Map,
+    selectedPairId: undefined,
+    retransmittedPacketsSent: undefined,
+    retransmittedBytesSent: undefined
+  };
+  const iter = report.values?.() ?? [];
+  for (const raw of iter) {
+    if (!raw || typeof raw !== "object")
+      continue;
+    const stat = raw;
+    ingestStat(stat, out);
+  }
+  return out;
+}
+function ingestStat(stat, out) {
+  const id = String(stat["id"]);
+  switch (stat["type"]) {
+    case "local-candidate":
+      out.localCands.set(id, stat);
+      return;
+    case "remote-candidate":
+      out.remoteCands.set(id, stat);
+      return;
+    case "candidate-pair":
+      out.pairs.set(id, stat);
+      return;
+    case "transport":
+      ingestTransport(stat, out);
+      return;
+    case "data-channel":
+      ingestDataChannel(stat, out);
+      return;
+  }
+}
+function ingestTransport(stat, out) {
+  const selectedId = stat["selectedCandidatePairId"];
+  if (typeof selectedId === "string")
+    out.selectedPairId = selectedId;
+  const rp = stat["retransmittedPacketsSent"];
+  const rb = stat["retransmittedBytesSent"];
+  if (typeof rp === "number")
+    out.retransmittedPacketsSent = rp;
+  if (typeof rb === "number")
+    out.retransmittedBytesSent = rb;
+}
+function ingestDataChannel(stat, out) {
+  const rp = stat["retransmittedPacketsSent"];
+  const rb = stat["retransmittedBytesSent"];
+  if (out.retransmittedPacketsSent === undefined && typeof rp === "number") {
+    out.retransmittedPacketsSent = rp;
+  }
+  if (out.retransmittedBytesSent === undefined && typeof rb === "number") {
+    out.retransmittedBytesSent = rb;
+  }
+}
+function selectActivePair(parsed) {
+  if (parsed.selectedPairId) {
+    const named = parsed.pairs.get(parsed.selectedPairId);
+    if (named)
+      return named;
+  }
+  for (const pair of parsed.pairs.values()) {
+    if (pair["nominated"])
+      return pair;
+  }
+  return;
+}
+function serialiseSlotView(slot) {
+  return {
+    signalingState: slot.connection.signalingState,
+    iceConnectionState: slot.connection.iceConnectionState,
+    connectionState: slot.connection.connectionState,
+    dataChannelState: slot.channel?.readyState ?? "no-channel",
+    pendingSendCount: slot.pendingSends.length,
+    pendingRemoteIceCount: slot.pendingRemoteIce.length,
+    inFlightSync: slot.inFlightSync ? { ...slot.inFlightSync } : undefined,
+    transport: slot.transport ? {
+      ...slot.transport,
+      selectedCandidatePair: slot.transport.selectedCandidatePair ? { ...slot.transport.selectedCandidatePair } : undefined
+    } : undefined,
+    lastSyncHandshakeAttempt: { ...slot.lastSyncHandshakeAttempt }
+  };
+}
+function emptySyncHandshakeAttempt() {
+  return {
+    dataChannelOpenedAt: undefined,
+    peerCandidateEmittedAt: undefined,
+    firstOutboundSendAt: undefined,
+    firstInboundMessageAt: undefined
+  };
+}
+function buildCandidatePairView(pair, localCands, remoteCands) {
+  const local = localCands.get(String(pair["localCandidateId"]));
+  const remote = remoteCands.get(String(pair["remoteCandidateId"]));
+  return {
+    localCandidateType: String(local?.["candidateType"] ?? "?"),
+    remoteCandidateType: String(remote?.["candidateType"] ?? "?"),
+    state: String(pair["state"] ?? ""),
+    nominated: Boolean(pair["nominated"]),
+    bytesSent: Number(pair["bytesSent"] ?? 0),
+    bytesReceived: Number(pair["bytesReceived"] ?? 0)
+  };
+}
 var DEFAULT_ICE_SERVERS = [
   { urls: "stun:stun.l.google.com:19302" },
   { urls: "stun:stun1.l.google.com:19302" }
@@ -1941,6 +2076,8 @@ var DEFAULT_ICE_SERVERS = [
 class MeshWebRTCAdapter extends NetworkAdapter2 {
   signaling;
   iceServers;
+  iceTransportPolicy;
+  iceRelayEnforcement;
   dataChannelLabel;
   knownPeers;
   keyringSource;
@@ -1954,6 +2091,9 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
   slots = new Map;
   ready = false;
   readyResolver;
+  lastSlotInitiationDecisions = new Map;
+  sweepRunCount = 0;
+  lastSweepAt;
   get knownPeerIds() {
     if (this.keyringSource !== undefined) {
       return [...this.keyringSource().knownPeers.keys()].filter((id) => id !== this.localPeerId);
@@ -1971,6 +2111,8 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
     super();
     this.signaling = options.signaling;
     this.iceServers = options.iceServers ?? DEFAULT_ICE_SERVERS;
+    this.iceTransportPolicy = options.iceTransportPolicy;
+    this.iceRelayEnforcement = options.iceRelayEnforcement ?? true;
     this.dataChannelLabel = options.dataChannelLabel ?? "polly-mesh";
     this.knownPeers = new Set(options.knownPeerIds ?? []);
     this.keyringSource = options.keyringSource;
@@ -2004,25 +2146,26 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
     const peers = [];
     for (const peerId of allPeers) {
       const slot = this.slots.get(peerId);
+      const decision = this.snapshotInitiationDecision(peerId);
       peers.push({
         peerId,
         knownInKeyring: knownPeerSet.has(peerId),
         presentInSignalling: this.presentPeers.has(peerId),
-        slot: slot ? {
-          signalingState: slot.connection.signalingState,
-          iceConnectionState: slot.connection.iceConnectionState,
-          connectionState: slot.connection.connectionState,
-          dataChannelState: slot.channel?.readyState ?? "no-channel",
-          pendingSendCount: slot.pendingSends.length,
-          pendingRemoteIceCount: slot.pendingRemoteIce.length,
-          inFlightSync: slot.inFlightSync ? { ...slot.inFlightSync } : undefined
-        } : undefined
+        slotInitiationRejectionReason: decision.reason,
+        slotInitiationDecision: decision,
+        slot: slot ? serialiseSlotView(slot) : undefined
       });
     }
     return {
       localPeerId: this.localPeerId,
       knownPeerIds,
       presentPeerIds,
+      sweep: {
+        enabled: this.knownPeersRefreshTimer !== undefined,
+        intervalMs: this.knownPeersRefreshIntervalMs,
+        runCount: this.sweepRunCount,
+        lastRunAt: this.lastSweepAt
+      },
       peers
     };
   }
@@ -2030,14 +2173,27 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
     this.presentPeers.add(remotePeerId);
     if (!this.shouldInitiateTo(remotePeerId))
       return;
-    this.createInitiatingSlot(remotePeerId);
+    this.tryCreateInitiatingSlot(remotePeerId);
   }
   handlePeersPresent(peerIds) {
     for (const remotePeerId of peerIds) {
       this.presentPeers.add(remotePeerId);
       if (!this.shouldInitiateTo(remotePeerId))
         continue;
+      this.tryCreateInitiatingSlot(remotePeerId);
+    }
+  }
+  tryCreateInitiatingSlot(remotePeerId) {
+    try {
       this.createInitiatingSlot(remotePeerId);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.lastSlotInitiationDecisions.set(remotePeerId, {
+        decision: "rejected",
+        reason: "fatal-error",
+        error: message,
+        at: performance.now()
+      });
     }
   }
   handlePeerLeft(remotePeerId) {
@@ -2061,25 +2217,49 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
       return;
     if (!this.shouldInitiateTo(remotePeerId))
       return;
-    this.createInitiatingSlot(remotePeerId);
+    this.tryCreateInitiatingSlot(remotePeerId);
   }
   refreshKnownPeers() {
     for (const remotePeerId of this.presentPeers) {
       if (!this.shouldInitiateTo(remotePeerId))
         continue;
-      this.createInitiatingSlot(remotePeerId);
+      this.tryCreateInitiatingSlot(remotePeerId);
     }
   }
   shouldInitiateTo(remotePeerId) {
+    const reason = this.evaluateInitiation(remotePeerId);
+    this.lastSlotInitiationDecisions.set(remotePeerId, {
+      decision: reason === undefined ? "accepted" : "rejected",
+      reason,
+      error: undefined,
+      at: performance.now()
+    });
+    return reason === undefined;
+  }
+  evaluateInitiation(remotePeerId) {
     if (remotePeerId === this.localPeerId)
-      return false;
+      return "self";
     if (!this.hasKnownPeer(remotePeerId))
-      return false;
+      return "not-in-keyring";
+    if (!this.presentPeers.has(remotePeerId))
+      return "not-present";
     if (this.slots.has(remotePeerId))
-      return false;
+      return "slot-already-exists";
     if (this.localPeerId <= remotePeerId)
-      return false;
-    return true;
+      return "tie-break-other-side";
+    return;
+  }
+  snapshotInitiationDecision(remotePeerId) {
+    const cached = this.lastSlotInitiationDecisions.get(remotePeerId);
+    if (cached?.reason === "fatal-error")
+      return cached;
+    const reason = this.evaluateInitiation(remotePeerId);
+    return {
+      decision: reason === undefined ? "accepted" : "rejected",
+      reason,
+      error: undefined,
+      at: performance.now()
+    };
   }
   whenReady() {
     if (this.ready)
@@ -2116,7 +2296,11 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
     if (this.knownPeersRefreshTimer !== undefined)
       return;
     this.knownPeersRefreshTimer = setInterval(() => {
-      this.refreshKnownPeers();
+      this.sweepRunCount += 1;
+      this.lastSweepAt = performance.now();
+      try {
+        this.refreshKnownPeers();
+      } catch {}
     }, this.knownPeersRefreshIntervalMs);
   }
   stopKnownPeersSweep() {
@@ -2132,6 +2316,9 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
     if (!slot) {
       slot = this.createInitiatingSlot(targetId);
     }
+    if (slot.lastSyncHandshakeAttempt.firstOutboundSendAt === undefined) {
+      slot.lastSyncHandshakeAttempt.firstOutboundSendAt = performance.now();
+    }
     if (slot.channel && slot.channel.readyState === "open") {
       this.sendBytesMaybeFragmented(slot.channel, bytes);
     } else {
@@ -2180,8 +2367,61 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
         return;
     }
   }
+  buildRtcConfiguration() {
+    const config = { iceServers: this.iceServers };
+    if (this.iceTransportPolicy !== undefined) {
+      config.iceTransportPolicy = this.iceTransportPolicy;
+    }
+    return config;
+  }
+  isRelayCandidateInit(init) {
+    const candidateStr = init.candidate ?? "";
+    const m = candidateStr.match(/\btyp\s+(\S+)/i);
+    return m?.[1]?.toLowerCase() === "relay";
+  }
+  shouldSendCandidate(candidate) {
+    if (!this.iceRelayEnforcement)
+      return true;
+    if (this.iceTransportPolicy !== "relay")
+      return true;
+    const typed = candidate.type;
+    const match = candidate.candidate.match(/\btyp\s+(\S+)/i);
+    const candidateType = (typed ?? match?.[1] ?? "").toLowerCase();
+    return candidateType === "relay";
+  }
+  filterSdpCandidatesByPolicy(sdp) {
+    if (!this.iceRelayEnforcement)
+      return sdp;
+    if (this.iceTransportPolicy !== "relay")
+      return sdp;
+    if (!sdp)
+      return sdp;
+    const lines = sdp.split(/\r?\n/);
+    const filtered = [];
+    for (const line of lines) {
+      if (!line.startsWith("a=candidate:")) {
+        filtered.push(line);
+        continue;
+      }
+      const m = line.match(/\btyp\s+(\S+)/i);
+      if (m?.[1]?.toLowerCase() === "relay")
+        filtered.push(line);
+    }
+    return filtered.join(`\r
+`);
+  }
+  applySdpPolicyFilter(description) {
+    if (!this.iceRelayEnforcement)
+      return description;
+    if (this.iceTransportPolicy !== "relay")
+      return description;
+    const filtered = this.filterSdpCandidatesByPolicy(description.sdp);
+    if (filtered === description.sdp)
+      return description;
+    return { ...description, sdp: filtered };
+  }
   createInitiatingSlot(targetId) {
-    const connection = new this.RTCPeerConnectionCtor({ iceServers: this.iceServers });
+    const connection = new this.RTCPeerConnectionCtor(this.buildRtcConfiguration());
     const channel = connection.createDataChannel(this.dataChannelLabel, { ordered: true });
     const slot = {
       connection,
@@ -2189,7 +2429,10 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
       pendingSends: [],
       pendingFragments: new Map,
       pendingRemoteIce: [],
-      inFlightSync: undefined
+      inFlightSync: undefined,
+      transport: undefined,
+      lastDataChannelError: undefined,
+      lastSyncHandshakeAttempt: emptySyncHandshakeAttempt()
     };
     this.slots.set(targetId, slot);
     this.wireConnection(targetId, connection);
@@ -2200,7 +2443,15 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
   async initiateOffer(targetId, connection) {
     const offer = await connection.createOffer();
     await connection.setLocalDescription(offer);
-    this.signaling.sendSignal(targetId, { kind: "offer", sdp: offer });
+    const localOffer = connection.localDescription ?? offer;
+    const sdpToSend = this.applySdpPolicyFilter({
+      type: localOffer.type,
+      sdp: localOffer.sdp ?? offer.sdp
+    });
+    this.signaling.sendSignal(targetId, {
+      kind: "offer",
+      sdp: sdpToSend
+    });
   }
   async handleOffer(fromPeerId, sdp) {
     const existing = this.slots.get(fromPeerId);
@@ -2213,14 +2464,17 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
       existing.connection.close();
       this.slots.delete(fromPeerId);
     }
-    const connection = new this.RTCPeerConnectionCtor({ iceServers: this.iceServers });
+    const connection = new this.RTCPeerConnectionCtor(this.buildRtcConfiguration());
     const slot = {
       connection,
       channel: undefined,
       pendingSends: [],
       pendingFragments: new Map,
       pendingRemoteIce: [],
-      inFlightSync: undefined
+      inFlightSync: undefined,
+      transport: undefined,
+      lastDataChannelError: undefined,
+      lastSyncHandshakeAttempt: emptySyncHandshakeAttempt()
     };
     this.slots.set(fromPeerId, slot);
     this.wireConnection(fromPeerId, connection);
@@ -2228,13 +2482,18 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
       slot.channel = event.channel;
       this.wireDataChannel(fromPeerId, event.channel);
     };
-    await connection.setRemoteDescription(sdp);
+    await connection.setRemoteDescription(this.applySdpPolicyFilter(sdp));
     await this.flushPendingRemoteIce(slot);
     const answer = await connection.createAnswer();
     await connection.setLocalDescription(answer);
+    const localAnswer = connection.localDescription ?? answer;
+    const sdpToSend = this.applySdpPolicyFilter({
+      type: localAnswer.type,
+      sdp: localAnswer.sdp ?? answer.sdp
+    });
     this.signaling.sendSignal(fromPeerId, {
       kind: "answer",
-      sdp: answer
+      sdp: sdpToSend
     });
   }
   async handleAnswer(fromPeerId, sdp) {
@@ -2243,13 +2502,15 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
       return;
     if (slot.connection.signalingState !== "have-local-offer")
       return;
-    await slot.connection.setRemoteDescription(sdp);
+    await slot.connection.setRemoteDescription(this.applySdpPolicyFilter(sdp));
     await this.flushPendingRemoteIce(slot);
   }
   async handleIceCandidate(fromPeerId, candidate) {
     const slot = this.slots.get(fromPeerId);
     if (!slot)
       return;
+    if (this.iceRelayEnforcement && this.iceTransportPolicy === "relay" && !this.isRelayCandidateInit(candidate))
+      return;
     if (slot.connection.remoteDescription === null) {
       slot.pendingRemoteIce.push(candidate);
       return;
@@ -2271,31 +2532,44 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
   }
   wireConnection(peerId, connection) {
     connection.onicecandidate = (event) => {
-      if (event.candidate) {
-        this.signaling.sendSignal(peerId, {
-          kind: "ice",
-          candidate: event.candidate.toJSON()
-        });
-      }
+      if (!event.candidate)
+        return;
+      if (!this.shouldSendCandidate(event.candidate))
+        return;
+      this.signaling.sendSignal(peerId, {
+        kind: "ice",
+        candidate: event.candidate.toJSON()
+      });
     };
     connection.onconnectionstatechange = () => {
       const state = connection.connectionState;
       if (state === "connected") {
-        this.emit("peer-candidate", {
-          peerId,
-          peerMetadata: {}
-        });
+        this.emitPeerCandidateOnce(peerId);
       } else if (state === "disconnected" || state === "failed" || state === "closed") {
         this.slots.delete(peerId);
         this.emit("peer-disconnected", { peerId });
       }
     };
   }
+  emitPeerCandidateOnce(peerId) {
+    const slot = this.slots.get(peerId);
+    if (!slot)
+      return;
+    if (slot.lastSyncHandshakeAttempt.peerCandidateEmittedAt !== undefined)
+      return;
+    slot.lastSyncHandshakeAttempt.peerCandidateEmittedAt = performance.now();
+    this.emit("peer-candidate", {
+      peerId,
+      peerMetadata: {}
+    });
+  }
   wireDataChannel(peerId, channel) {
     channel.onopen = () => {
       const slot = this.slots.get(peerId);
       if (!slot)
         return;
+      slot.lastSyncHandshakeAttempt.dataChannelOpenedAt = performance.now();
+      this.emitPeerCandidateOnce(peerId);
       for (const bytes of slot.pendingSends) {
         this.sendBytesMaybeFragmented(channel, bytes);
       }
@@ -2315,6 +2589,34 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
         slot.channel = undefined;
       }
     };
+    channel.onerror = (event) => {
+      const slot = this.slots.get(peerId);
+      if (!slot)
+        return;
+      const ev = event;
+      const message = typeof ev.error?.message === "string" ? ev.error.message : typeof ev.message === "string" ? ev.message : "unknown data channel error";
+      slot.lastDataChannelError = message;
+    };
+  }
+  async refreshTransportStats(peerId) {
+    const slot = this.slots.get(peerId);
+    if (!slot)
+      return;
+    const snapshot = await collectTransportSnapshot(slot.connection, slot.lastDataChannelError);
+    slot.transport = snapshot;
+    return snapshot;
+  }
+  async refreshAllTransportStats() {
+    const out = new Map;
+    const peerIds = [...this.slots.keys()];
+    const results = await Promise.all(peerIds.map((id) => this.refreshTransportStats(id)));
+    for (let i = 0;i < peerIds.length; i += 1) {
+      const r = results[i];
+      const id = peerIds[i];
+      if (r && id !== undefined)
+        out.set(id, r);
+    }
+    return out;
   }
   dispatchMessage(fromPeerId, bytes) {
     try {
@@ -2335,6 +2637,7 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
     } catch {}
   }
   scheduleEmitMessage(fromPeerId, message, viaFragmentPath) {
+    this.stampFirstInboundMessage(fromPeerId);
     if (!this.syncYieldEnabled) {
       this.emit("message", message);
       if (viaFragmentPath) {
@@ -2358,6 +2661,14 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
       }
     }, 0);
   }
+  stampFirstInboundMessage(fromPeerId) {
+    const slot = this.slots.get(fromPeerId);
+    if (!slot)
+      return;
+    if (slot.lastSyncHandshakeAttempt.firstInboundMessageAt !== undefined)
+      return;
+    slot.lastSyncHandshakeAttempt.firstInboundMessageAt = performance.now();
+  }
   finishInFlightSyncApply(fromPeerId) {
     const slot = this.slots.get(fromPeerId);
     if (!slot?.inFlightSync)
@@ -2514,6 +2825,12 @@ async function createMeshClient(options) {
     knownPeerIds,
     keyringSource,
     ...resolvedIceServers !== undefined && { iceServers: resolvedIceServers },
+    ...options.rtc?.iceTransportPolicy !== undefined && {
+      iceTransportPolicy: options.rtc.iceTransportPolicy
+    },
+    ...options.rtc?.iceRelayEnforcement !== undefined && {
+      iceRelayEnforcement: options.rtc.iceRelayEnforcement
+    },
     ...options.rtc?.dataChannelLabel !== undefined && {
       dataChannelLabel: options.rtc.dataChannelLabel
     },
@@ -2583,11 +2900,22 @@ async function createMeshClient(options) {
           localPeerId: options.signaling.peerId,
           knownPeerIds: [],
           presentPeerIds: [],
+          sweep: {
+            enabled: false,
+            intervalMs: 0,
+            runCount: 0,
+            lastRunAt: undefined
+          },
           peers: []
         };
       }
       return webrtcAdapter.getPeerStateSnapshot();
     },
+    refreshTransportStats: async () => {
+      if (!webrtcAdapter)
+        return;
+      await webrtcAdapter.refreshAllTransportStats();
+    },
     close: async () => {
       signaling.close();
       webrtcAdapter?.disconnect();
@@ -3002,4 +3330,4 @@ export {
   $meshCounter
 };
 
-//# debugId=18409B674B254AA864756E2164756E21
+//# debugId=27D9577FC215E14564756E2164756E21