@fairfox/polly 0.53.0 → 0.55.0

package/dist/src/mesh.js

@@ -1849,8 +1849,8 @@ import {
 } from "@automerge/automerge-repo/slim";
 
 // src/shared/lib/sync-fragment.ts
-var SYNC_FRAGMENT_THRESHOLD = 64 * 1024;
-var SYNC_FRAGMENT_CHUNK_SIZE = 64 * 1024;
+var SYNC_FRAGMENT_THRESHOLD = 60 * 1024;
+var SYNC_FRAGMENT_CHUNK_SIZE = 60 * 1024;
 function serialiseSyncFragment(header, data) {
   const headerBytes = new TextEncoder().encode(JSON.stringify(header));
   const size = 4 + headerBytes.length + data.length;
@@ -1933,6 +1933,132 @@ 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
+  };
+}
+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,11 +2067,15 @@ var DEFAULT_ICE_SERVERS = [
 class MeshWebRTCAdapter extends NetworkAdapter2 {
   signaling;
   iceServers;
+  iceTransportPolicy;
+  iceRelayEnforcement;
   dataChannelLabel;
   knownPeers;
   keyringSource;
   knownPeersRefreshTimer;
   knownPeersRefreshIntervalMs;
+  syncYieldEnabled;
+  syncFragmentChunkSize;
   presentPeers = new Set;
   localPeerId;
   RTCPeerConnectionCtor;
@@ -1969,10 +2099,14 @@ 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;
     this.knownPeersRefreshIntervalMs = options.knownPeersRefreshIntervalMs ?? 2000;
+    this.syncYieldEnabled = options.syncYieldEnabled ?? true;
+    this.syncFragmentChunkSize = options.syncFragmentChunkSizeOverride ?? SYNC_FRAGMENT_CHUNK_SIZE;
     this.localPeerId = options.peerId;
     const PC = options.RTCPeerConnection ?? globalThis.RTCPeerConnection;
     if (typeof PC !== "function") {
@@ -2004,14 +2138,7 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
         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
-        } : undefined
+        slot: slot ? serialiseSlotView(slot) : undefined
       });
     }
     return {
@@ -2133,15 +2260,29 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
       slot.pendingSends.push(bytes);
     }
   }
-  sendBytesMaybeFragmented(channel, bytes) {
+  static SEND_YIELD_EVERY_N_FRAGMENTS = 8;
+  async sendBytesMaybeFragmented(channel, bytes) {
     if (bytes.length <= SYNC_FRAGMENT_THRESHOLD) {
       channel.send(bytes);
       return;
     }
     const id = crypto.randomUUID();
-    const fragments = chunkSyncMessage(bytes, id);
+    const fragments = chunkSyncMessage(bytes, id, this.syncFragmentChunkSize);
+    if (!this.syncYieldEnabled) {
+      for (const fragment of fragments) {
+        channel.send(fragment);
+      }
+      return;
+    }
+    let i = 0;
     for (const fragment of fragments) {
       channel.send(fragment);
+      i += 1;
+      if (i % MeshWebRTCAdapter.SEND_YIELD_EVERY_N_FRAGMENTS === 0 && i < fragments.length) {
+        await new Promise((resolve) => {
+          setTimeout(resolve, 0);
+        });
+      }
     }
   }
   handleSignal(fromPeerId, rawPayload) {
@@ -2161,15 +2302,71 @@ 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,
       channel,
       pendingSends: [],
       pendingFragments: new Map,
-      pendingRemoteIce: []
+      pendingRemoteIce: [],
+      inFlightSync: undefined,
+      transport: undefined,
+      lastDataChannelError: undefined
     };
     this.slots.set(targetId, slot);
     this.wireConnection(targetId, connection);
@@ -2180,7 +2377,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);
@@ -2193,13 +2398,16 @@ 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: []
+      pendingRemoteIce: [],
+      inFlightSync: undefined,
+      transport: undefined,
+      lastDataChannelError: undefined
     };
     this.slots.set(fromPeerId, slot);
     this.wireConnection(fromPeerId, connection);
@@ -2207,13 +2415,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) {
@@ -2222,13 +2435,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;
@@ -2250,12 +2465,14 @@ 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;
@@ -2294,6 +2511,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 {
@@ -2310,9 +2555,56 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
         return;
       }
       const message = this.deserialiseMessage(bytes);
-      this.emit("message", message);
+      this.scheduleEmitMessage(fromPeerId, message, false);
     } catch {}
   }
+  scheduleEmitMessage(fromPeerId, message, viaFragmentPath) {
+    if (!this.syncYieldEnabled) {
+      this.emit("message", message);
+      if (viaFragmentPath) {
+        this.finishInFlightSyncApply(fromPeerId);
+      }
+      return;
+    }
+    if (viaFragmentPath) {
+      const slot = this.slots.get(fromPeerId);
+      if (slot?.inFlightSync) {
+        slot.inFlightSync.applyBacklog += 1;
+      }
+    }
+    setTimeout(() => {
+      try {
+        this.emit("message", message);
+      } finally {
+        if (viaFragmentPath) {
+          this.finishInFlightSyncApply(fromPeerId);
+        }
+      }
+    }, 0);
+  }
+  finishInFlightSyncApply(fromPeerId) {
+    const slot = this.slots.get(fromPeerId);
+    if (!slot?.inFlightSync)
+      return;
+    slot.inFlightSync.applyBacklog = Math.max(0, slot.inFlightSync.applyBacklog - 1);
+    this.emitSyncProgress(fromPeerId, "dispatch-applied", 0);
+    if (slot.inFlightSync.applyBacklog === 0 && slot.pendingFragments.size === 0) {
+      slot.inFlightSync = undefined;
+    }
+  }
+  emitSyncProgress(fromPeerId, kind, bytesDelta) {
+    const slot = this.slots.get(fromPeerId);
+    const inFlightSync = slot?.inFlightSync;
+    this.emit("sync-progress", {
+      peerId: fromPeerId,
+      kind,
+      bytesDelta,
+      chunksReceived: inFlightSync?.chunksReceived ?? 0,
+      bytesReceived: inFlightSync?.bytesReceived ?? 0,
+      applyBacklog: inFlightSync?.applyBacklog ?? 0,
+      at: performance.now()
+    });
+  }
   handleSyncFragment(fromPeerId, bytes) {
     const parsed = parseSyncFragment(bytes);
     if (!parsed)
@@ -2327,11 +2619,46 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
       slot.pendingFragments.set(header.id, entry);
     }
     entry.chunks.set(header.index, data.slice());
+    if (!slot.inFlightSync) {
+      slot.inFlightSync = {
+        chunksReceived: 0,
+        bytesReceived: 0,
+        lastChunkAt: performance.now(),
+        applyBacklog: 0
+      };
+    }
+    slot.inFlightSync.chunksReceived += 1;
+    slot.inFlightSync.bytesReceived += data.byteLength;
+    slot.inFlightSync.lastChunkAt = performance.now();
+    this.emitSyncProgress(fromPeerId, "fragment-received", data.byteLength);
     if (entry.chunks.size < entry.total)
       return;
     slot.pendingFragments.delete(header.id);
     const reassembled = reassembleSyncFragments(entry.chunks, entry.total);
-    this.dispatchMessage(fromPeerId, reassembled);
+    if (!this.syncYieldEnabled) {
+      this.dispatchReassembled(fromPeerId, reassembled);
+      return;
+    }
+    setTimeout(() => {
+      this.dispatchReassembled(fromPeerId, reassembled);
+    }, 0);
+  }
+  dispatchReassembled(fromPeerId, bytes) {
+    try {
+      if (this.onBlobMessage && isBlobMessageType(bytes)) {
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        const headerLen = view.getUint32(0, false);
+        const header = JSON.parse(new TextDecoder().decode(bytes.subarray(4, 4 + headerLen)));
+        const data = bytes.subarray(4 + headerLen);
+        this.onBlobMessage(fromPeerId, header, data);
+        this.finishInFlightSyncApply(fromPeerId);
+        return;
+      }
+      const message = this.deserialiseMessage(bytes);
+      this.scheduleEmitMessage(fromPeerId, message, true);
+    } catch {
+      this.finishInFlightSyncApply(fromPeerId);
+    }
   }
   get connectedPeerIds() {
     const ids = [];
@@ -2411,6 +2738,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
     },
@@ -2419,6 +2752,12 @@ async function createMeshClient(options) {
     },
     ...options.rtc?.knownPeersRefreshIntervalMs !== undefined && {
       knownPeersRefreshIntervalMs: options.rtc.knownPeersRefreshIntervalMs
+    },
+    ...options.rtc?.syncYieldEnabled !== undefined && {
+      syncYieldEnabled: options.rtc.syncYieldEnabled
+    },
+    ...options.rtc?.syncFragmentChunkSizeOverride !== undefined && {
+      syncFragmentChunkSizeOverride: options.rtc.syncFragmentChunkSizeOverride
     }
   };
   let webrtcAdapter;
@@ -2479,6 +2818,11 @@ async function createMeshClient(options) {
       }
       return webrtcAdapter.getPeerStateSnapshot();
     },
+    refreshTransportStats: async () => {
+      if (!webrtcAdapter)
+        return;
+      await webrtcAdapter.refreshAllTransportStats();
+    },
     close: async () => {
       signaling.close();
       webrtcAdapter?.disconnect();
@@ -2893,4 +3237,4 @@ export {
   $meshCounter
 };
 
-//# debugId=51457A626E5A2F2B64756E2164756E21
+//# debugId=15751E988ED47F0264756E2164756E21