@fairfox/polly 0.49.0 → 0.51.0

package/dist/src/mesh.js

@@ -1019,12 +1019,15 @@ var DEFAULT_MESH_KEY_ID = "polly-mesh-default";
 
 class MeshNetworkAdapter extends NetworkAdapter {
   base;
-  keyring;
+  keyringSource;
   encryptionEnabled;
+  get keyring() {
+    return this.keyringSource();
+  }
   constructor(options) {
     super();
     this.base = options.base;
-    this.keyring = options.keyring;
+    this.keyringSource = options.keyringSource;
     this.encryptionEnabled = options.encryptionEnabled ?? true;
     this.base.on("close", () => this.emit("close"));
     this.base.on("peer-candidate", (payload) => this.emit("peer-candidate", payload));
@@ -1057,10 +1060,11 @@ class MeshNetworkAdapter extends NetworkAdapter {
     this.base.send(wrapped);
   }
   wrap(message) {
+    const keyring = this.keyringSource();
     const serialised = serialiseMessage(message);
     let payloadToSign;
     if (this.encryptionEnabled) {
-      const docKey = this.keyring.documentKeys.get(DEFAULT_MESH_KEY_ID);
+      const docKey = keyring.documentKeys.get(DEFAULT_MESH_KEY_ID);
       if (!docKey) {
         throw new Error(`MeshNetworkAdapter: missing document encryption key under id "${DEFAULT_MESH_KEY_ID}". Provision the key in the keyring before sending.`);
       }
@@ -1069,7 +1073,7 @@ class MeshNetworkAdapter extends NetworkAdapter {
     } else {
       payloadToSign = serialised;
     }
-    const signed = signEnvelope(payloadToSign, message.senderId, this.keyring.identity.secretKey);
+    const signed = signEnvelope(payloadToSign, message.senderId, keyring.identity.secretKey);
     const signedBytes = encodeSignedEnvelope(signed);
     return {
       type: message.type,
@@ -1087,10 +1091,11 @@ class MeshNetworkAdapter extends NetworkAdapter {
     } catch {
       return;
     }
-    if (this.keyring.revokedPeers.has(signed.senderId)) {
+    const keyring = this.keyringSource();
+    if (keyring.revokedPeers.has(signed.senderId)) {
       return;
     }
-    const senderKey = this.keyring.knownPeers.get(signed.senderId);
+    const senderKey = keyring.knownPeers.get(signed.senderId);
     if (!senderKey) {
       return;
     }
@@ -1109,7 +1114,7 @@ class MeshNetworkAdapter extends NetworkAdapter {
     } catch {
       return;
     }
-    const docKey = this.keyring.documentKeys.get(encrypted.documentId);
+    const docKey = keyring.documentKeys.get(encrypted.documentId);
     if (!docKey) {
       return;
     }
@@ -1842,6 +1847,92 @@ function $meshList(key, initialValue, options = {}) {
 import {
   NetworkAdapter as NetworkAdapter2
 } from "@automerge/automerge-repo/slim";
+
+// src/shared/lib/sync-fragment.ts
+var SYNC_FRAGMENT_THRESHOLD = 64 * 1024;
+var SYNC_FRAGMENT_CHUNK_SIZE = 64 * 1024;
+function serialiseSyncFragment(header, data) {
+  const headerBytes = new TextEncoder().encode(JSON.stringify(header));
+  const size = 4 + headerBytes.length + data.length;
+  const buffer = new ArrayBuffer(size);
+  const out = new Uint8Array(buffer);
+  const view = new DataView(buffer);
+  view.setUint32(0, headerBytes.length, false);
+  out.set(headerBytes, 4);
+  out.set(data, 4 + headerBytes.length);
+  return out;
+}
+function parseSyncFragment(bytes) {
+  if (bytes.length < 4)
+    return;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const headerLen = view.getUint32(0, false);
+  if (bytes.length < 4 + headerLen)
+    return;
+  try {
+    const header = JSON.parse(new TextDecoder().decode(bytes.subarray(4, 4 + headerLen)));
+    if (header.type !== "sync-fragment")
+      return;
+    const data = bytes.subarray(4 + headerLen);
+    return { header, data };
+  } catch {
+    return;
+  }
+}
+function isSyncFragmentType(bytes) {
+  if (bytes.length < 4)
+    return false;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const headerLen = view.getUint32(0, false);
+  if (bytes.length < 4 + headerLen)
+    return false;
+  const headerSlice = bytes.subarray(4, 4 + headerLen);
+  const needle = new TextEncoder().encode('"type":"sync-fragment"');
+  return findSubarray2(headerSlice, needle) !== -1;
+}
+function chunkSyncMessage(bytes, id, chunkSize = SYNC_FRAGMENT_CHUNK_SIZE) {
+  const total = Math.max(1, Math.ceil(bytes.length / chunkSize));
+  const fragments = [];
+  for (let index = 0;index < total; index++) {
+    const start = index * chunkSize;
+    const end = Math.min(start + chunkSize, bytes.length);
+    fragments.push(serialiseSyncFragment({ type: "sync-fragment", id, index, total }, bytes.subarray(start, end)));
+  }
+  return fragments;
+}
+function reassembleSyncFragments(chunks, total) {
+  let totalBytes = 0;
+  for (let i = 0;i < total; i++) {
+    const chunk = chunks.get(i);
+    if (!chunk) {
+      throw new Error(`reassembleSyncFragments: missing fragment ${i} of ${total}`);
+    }
+    totalBytes += chunk.length;
+  }
+  const out = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (let i = 0;i < total; i++) {
+    const chunk = chunks.get(i);
+    out.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return out;
+}
+function findSubarray2(haystack, needle) {
+  if (needle.length === 0)
+    return 0;
+  outer:
+    for (let i = 0;i <= haystack.length - needle.length; i++) {
+      for (let j = 0;j < needle.length; j++) {
+        if (haystack[i + j] !== needle[j])
+          continue outer;
+      }
+      return i;
+    }
+  return -1;
+}
+
+// src/shared/lib/mesh-webrtc-adapter.ts
 var DEFAULT_ICE_SERVERS = [
   { urls: "stun:stun.l.google.com:19302" },
   { urls: "stun:stun1.l.google.com:19302" }
@@ -1960,11 +2051,22 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
       slot = this.createInitiatingSlot(targetId);
     }
     if (slot.channel && slot.channel.readyState === "open") {
-      slot.channel.send(bytes);
+      this.sendBytesMaybeFragmented(slot.channel, bytes);
     } else {
       slot.pendingSends.push(bytes);
     }
   }
+  sendBytesMaybeFragmented(channel, bytes) {
+    if (bytes.length <= SYNC_FRAGMENT_THRESHOLD) {
+      channel.send(bytes);
+      return;
+    }
+    const id = crypto.randomUUID();
+    const fragments = chunkSyncMessage(bytes, id);
+    for (const fragment of fragments) {
+      channel.send(fragment);
+    }
+  }
   handleSignal(fromPeerId, rawPayload) {
     const payload = rawPayload;
     if (!payload || typeof payload !== "object" || !("kind" in payload)) {
@@ -1985,7 +2087,12 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
   createInitiatingSlot(targetId) {
     const connection = new this.RTCPeerConnectionCtor({ iceServers: this.iceServers });
     const channel = connection.createDataChannel(this.dataChannelLabel, { ordered: true });
-    const slot = { connection, channel, pendingSends: [] };
+    const slot = {
+      connection,
+      channel,
+      pendingSends: [],
+      pendingFragments: new Map
+    };
     this.slots.set(targetId, slot);
     this.wireConnection(targetId, connection);
     this.wireDataChannel(targetId, channel);
@@ -2009,7 +2116,12 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
       this.slots.delete(fromPeerId);
     }
     const connection = new this.RTCPeerConnectionCtor({ iceServers: this.iceServers });
-    const slot = { connection, channel: undefined, pendingSends: [] };
+    const slot = {
+      connection,
+      channel: undefined,
+      pendingSends: [],
+      pendingFragments: new Map
+    };
     this.slots.set(fromPeerId, slot);
     this.wireConnection(fromPeerId, connection);
     connection.ondatachannel = (event) => {
@@ -2068,7 +2180,7 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
       if (!slot)
         return;
       for (const bytes of slot.pendingSends) {
-        channel.send(bytes);
+        this.sendBytesMaybeFragmented(channel, bytes);
       }
       slot.pendingSends = [];
     };
@@ -2089,6 +2201,10 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
   }
   dispatchMessage(fromPeerId, bytes) {
     try {
+      if (isSyncFragmentType(bytes)) {
+        this.handleSyncFragment(fromPeerId, bytes);
+        return;
+      }
       if (this.onBlobMessage && isBlobMessageType(bytes)) {
         const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
         const headerLen = view.getUint32(0, false);
@@ -2101,6 +2217,26 @@ class MeshWebRTCAdapter extends NetworkAdapter2 {
       this.emit("message", message);
     } catch {}
   }
+  handleSyncFragment(fromPeerId, bytes) {
+    const parsed = parseSyncFragment(bytes);
+    if (!parsed)
+      return;
+    const slot = this.slots.get(fromPeerId);
+    if (!slot)
+      return;
+    const { header, data } = parsed;
+    let entry = slot.pendingFragments.get(header.id);
+    if (!entry) {
+      entry = { chunks: new Map, total: header.total };
+      slot.pendingFragments.set(header.id, entry);
+    }
+    entry.chunks.set(header.index, data.slice());
+    if (entry.chunks.size < entry.total)
+      return;
+    slot.pendingFragments.delete(header.id);
+    const reassembled = reassembleSyncFragments(entry.chunks, entry.total);
+    this.dispatchMessage(fromPeerId, reassembled);
+  }
   get connectedPeerIds() {
     const ids = [];
     for (const [peerId, slot] of this.slots) {
@@ -2165,7 +2301,8 @@ async function resolveIceServers(rtc) {
   return rtc?.iceServers;
 }
 async function createMeshClient(options) {
-  const keyring = await resolveKeyring(options.keyring);
+  const keyringSource = await resolveKeyringSource(options.keyring);
+  const keyring = keyringSource();
   const encryptionEnabled = options.encryptionEnabled ?? true;
   if (encryptionEnabled && !keyring.documentKeys.has(DEFAULT_MESH_KEY_ID)) {
     throw new Error(`createMeshClient: encryption is enabled but the keyring has no document key for "${DEFAULT_MESH_KEY_ID}". Bootstrap or apply a pairing token that carries the document key before connecting.`);
@@ -2210,7 +2347,7 @@ async function createMeshClient(options) {
   webrtcAdapter = new MeshWebRTCAdapter(webrtcAdapterOptions);
   const networkAdapter = new MeshNetworkAdapter({
     base: webrtcAdapter,
-    keyring,
+    keyringSource,
     encryptionEnabled
   });
   const repo = new Repo({
@@ -2222,7 +2359,9 @@ async function createMeshClient(options) {
   await signaling.connect();
   return {
     repo,
-    keyring,
+    get keyring() {
+      return keyringSource();
+    },
     signaling,
     networkAdapter,
     webrtcAdapter,
@@ -2233,15 +2372,18 @@ async function createMeshClient(options) {
     }
   };
 }
-async function resolveKeyring(source) {
+async function resolveKeyringSource(source) {
+  if (typeof source === "object" && source !== null && "source" in source) {
+    return source.source;
+  }
   if ("storage" in source) {
     const loaded = await source.storage.load();
     if (loaded === null) {
       throw new Error("createMeshClient: keyring storage returned null (no saved keyring). In a Node CLI, bootstrap with `bootstrapCliKeyring` from `@fairfox/polly/mesh/node`; in a browser, run your pairing flow first and save the keyring through the storage adapter before constructing the client.");
     }
-    return loaded;
+    return () => loaded;
   }
-  return source;
+  return () => source;
 }
 // src/shared/lib/pairing.ts
 init_encryption();
@@ -2637,4 +2779,4 @@ export {
   $meshCounter
 };
 
-//# debugId=1DAAF5727BCAB57A64756E2164756E21
+//# debugId=FD1853161F9E945F64756E2164756E21