@fairfox/polly 0.52.0 → 0.54.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;
@@ -1943,6 +1943,11 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
   iceServers;
   dataChannelLabel;
   knownPeers;
+  keyringSource;
+  knownPeersRefreshTimer;
+  knownPeersRefreshIntervalMs;
+  syncYieldEnabled;
+  syncFragmentChunkSize;
   presentPeers = new Set;
   localPeerId;
   RTCPeerConnectionCtor;
@@ -1950,8 +1955,17 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
   ready = false;
   readyResolver;
   get knownPeerIds() {
+    if (this.keyringSource !== undefined) {
+      return [...this.keyringSource().knownPeers.keys()].filter((id) => id !== this.localPeerId);
+    }
     return [...this.knownPeers];
   }
+  hasKnownPeer(remotePeerId) {
+    if (this.keyringSource !== undefined) {
+      return this.keyringSource().knownPeers.has(remotePeerId);
+    }
+    return this.knownPeers.has(remotePeerId);
+  }
   onBlobMessage;
   constructor(options) {
     super();
@@ -1959,6 +1973,10 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
     this.iceServers = options.iceServers ?? DEFAULT_ICE_SERVERS;
     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") {
@@ -1972,6 +1990,42 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
   peerSlotCount() {
     return this.slots.size;
   }
+  getPeerStateSnapshot() {
+    const knownPeerIds = this.knownPeerIds;
+    const presentPeerIds = [...this.presentPeers];
+    const knownPeerSet = new Set(knownPeerIds);
+    const allPeers = new Set;
+    for (const id of knownPeerIds)
+      allPeers.add(id);
+    for (const id of presentPeerIds)
+      allPeers.add(id);
+    for (const id of this.slots.keys())
+      allPeers.add(id);
+    const peers = [];
+    for (const peerId of allPeers) {
+      const slot = this.slots.get(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
+      });
+    }
+    return {
+      localPeerId: this.localPeerId,
+      knownPeerIds,
+      presentPeerIds,
+      peers
+    };
+  }
   handlePeerJoined(remotePeerId) {
     this.presentPeers.add(remotePeerId);
     if (!this.shouldInitiateTo(remotePeerId))
@@ -1998,19 +2052,28 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
   addKnownPeer(remotePeerId) {
     if (remotePeerId === this.localPeerId)
       return;
-    if (this.knownPeers.has(remotePeerId))
-      return;
-    this.knownPeers.add(remotePeerId);
+    if (this.keyringSource === undefined) {
+      if (this.knownPeers.has(remotePeerId))
+        return;
+      this.knownPeers.add(remotePeerId);
+    }
     if (!this.presentPeers.has(remotePeerId))
       return;
     if (!this.shouldInitiateTo(remotePeerId))
       return;
     this.createInitiatingSlot(remotePeerId);
   }
+  refreshKnownPeers() {
+    for (const remotePeerId of this.presentPeers) {
+      if (!this.shouldInitiateTo(remotePeerId))
+        continue;
+      this.createInitiatingSlot(remotePeerId);
+    }
+  }
   shouldInitiateTo(remotePeerId) {
     if (remotePeerId === this.localPeerId)
       return false;
-    if (!this.knownPeers.has(remotePeerId))
+    if (!this.hasKnownPeer(remotePeerId))
       return false;
     if (this.slots.has(remotePeerId))
       return false;
@@ -2032,8 +2095,10 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
     }
     this.ready = true;
     this.readyResolver?.();
+    this.startKnownPeersSweep();
   }
   disconnect() {
+    this.stopKnownPeersSweep();
     for (const slot of this.slots.values()) {
       slot.channel?.close();
       slot.connection.close();
@@ -2043,6 +2108,23 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
     this.ready = false;
     this.emit("close");
   }
+  startKnownPeersSweep() {
+    if (this.keyringSource === undefined)
+      return;
+    if (this.knownPeersRefreshIntervalMs <= 0)
+      return;
+    if (this.knownPeersRefreshTimer !== undefined)
+      return;
+    this.knownPeersRefreshTimer = setInterval(() => {
+      this.refreshKnownPeers();
+    }, this.knownPeersRefreshIntervalMs);
+  }
+  stopKnownPeersSweep() {
+    if (this.knownPeersRefreshTimer === undefined)
+      return;
+    clearInterval(this.knownPeersRefreshTimer);
+    this.knownPeersRefreshTimer = undefined;
+  }
   send(message) {
     const targetId = message.targetId;
     const bytes = this.serialiseMessage(message);
@@ -2056,15 +2138,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) {
@@ -2092,7 +2188,8 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
       channel,
       pendingSends: [],
       pendingFragments: new Map,
-      pendingRemoteIce: []
+      pendingRemoteIce: [],
+      inFlightSync: undefined
     };
     this.slots.set(targetId, slot);
     this.wireConnection(targetId, connection);
@@ -2122,7 +2219,8 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
       channel: undefined,
       pendingSends: [],
       pendingFragments: new Map,
-      pendingRemoteIce: []
+      pendingRemoteIce: [],
+      inFlightSync: undefined
     };
     this.slots.set(fromPeerId, slot);
     this.wireConnection(fromPeerId, connection);
@@ -2233,9 +2331,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)
@@ -2250,11 +2395,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 = [];
@@ -2332,12 +2512,22 @@ async function createMeshClient(options) {
     signaling: undefined,
     peerId: options.signaling.peerId,
     knownPeerIds,
+    keyringSource,
     ...resolvedIceServers !== undefined && { iceServers: resolvedIceServers },
     ...options.rtc?.dataChannelLabel !== undefined && {
       dataChannelLabel: options.rtc.dataChannelLabel
     },
     ...options.rtc?.RTCPeerConnection !== undefined && {
       RTCPeerConnection: options.rtc.RTCPeerConnection
+    },
+    ...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;
@@ -2384,6 +2574,20 @@ async function createMeshClient(options) {
     signaling,
     networkAdapter,
     webrtcAdapter,
+    refreshKnownPeers: () => {
+      webrtcAdapter?.refreshKnownPeers();
+    },
+    getPeerStateSnapshot: () => {
+      if (!webrtcAdapter) {
+        return {
+          localPeerId: options.signaling.peerId,
+          knownPeerIds: [],
+          presentPeerIds: [],
+          peers: []
+        };
+      }
+      return webrtcAdapter.getPeerStateSnapshot();
+    },
     close: async () => {
       signaling.close();
       webrtcAdapter?.disconnect();
@@ -2798,4 +3002,4 @@ export {
   $meshCounter
 };
 
-//# debugId=0A403673455F136164756E2164756E21
+//# debugId=18409B674B254AA864756E2164756E21