fix: changes are not delivered after a sync message wasn't delivered

packages/automerge-repo/src/helpers/DummyNetworkAdapter.ts

@@ -5,11 +5,22 @@ export class DummyNetworkAdapter extends NetworkAdapter {
   #sendMessage?: SendMessageFn
 
   #ready = false
+  #isDroppingMessages = false
   #readyResolver?: () => void
   #readyPromise: Promise<void> = new Promise<void>(resolve => {
     this.#readyResolver = resolve
   })
 
+  #droppedMessages: Message[] = []
+
+  dropMessages(drop: boolean) {
+    this.#isDroppingMessages = drop
+  }
+
+  getDroppedMessages() {
+    return [...this.#droppedMessages]
+  }
+
   isReady() {
     return this.#ready
   }
@@ -49,11 +60,19 @@ export class DummyNetworkAdapter extends NetworkAdapter {
   }
 
   override send(message: Message) {
-    this.#sendMessage?.(message)
+    if (this.#isDroppingMessages) {
+      this.#droppedMessages.push(message)
+    } else {
+      this.#sendMessage?.(message)
+    }
   }
 
   receive(message: Message) {
-    this.emit("message", message)
+    if (this.#isDroppingMessages) {
+      this.#droppedMessages.push(message)
+    } else {
+      this.emit("message", message)
+    }
   }
 
   static createConnectedPair({ latency = 10 }: { latency?: number } = {}) {

packages/automerge-repo/src/synchronizer/DocSynchronizer.ts

@@ -351,6 +351,11 @@ export class DocSynchronizer extends Synchronizer {
 
     this.#withSyncState(message.senderId, syncState => {
       this.#handle.update(doc => {
+        // Retry if message sending failed.
+        for (const need of A.decodeSyncMessage(message.data).need) {
+          delete (syncState.sentHashes as any)[need]
+        }
+
         const [newDoc, newSyncState] = A.receiveSyncMessage(
           doc,
           syncState,

packages/automerge-repo/test/Repo.test.ts

@@ -1275,6 +1275,82 @@ describe("Repo", () => {
     assert.equal(bobDoc.isReady(), true)
   })
 
+  it("changes get replicated after the next change if a sync message was dropped", async () => {
+    const alice = "alice" as PeerId
+    const bob = "bob" as PeerId
+    const [aliceAdapter, bobAdapter] = DummyNetworkAdapter.createConnectedPair()
+    const aliceRepo = new Repo({
+      network: [aliceAdapter],
+      peerId: alice,
+    })
+    const bobRepo = new Repo({
+      network: [bobAdapter],
+      peerId: bob,
+    })
+    aliceAdapter.peerCandidate(bob)
+    bobAdapter.peerCandidate(alice)
+
+    const bobHandle = bobRepo.create<TestDoc>()
+    bobHandle.change(d => {
+      d.foo = "bar"
+    })
+    const aliceHandle = await aliceRepo.find(bobHandle.documentId)
+    await eventPromise(aliceHandle, "heads-changed")
+    assert.deepEqual(aliceHandle.docSync(), bobHandle.docSync())
+
+    bobAdapter.dropMessages(true)
+    bobHandle.change(d => {
+      d.bar = "foo"
+    })
+    await pause(10)
+    assert.equal(bobAdapter.getDroppedMessages()[0].type, "sync")
+
+    bobAdapter.dropMessages(false)
+    bobHandle.change(d => {
+      d.baz = "42"
+    })
+    await eventPromise(aliceHandle, "heads-changed")
+  })
+
+  it("changes get replicated the peer's next change if a sync message was dropped", async () => {
+    const alice = "alice" as PeerId
+    const bob = "bob" as PeerId
+    const [aliceAdapter, bobAdapter] = DummyNetworkAdapter.createConnectedPair()
+    const aliceRepo = new Repo({
+      network: [aliceAdapter],
+      peerId: alice,
+    })
+    const bobRepo = new Repo({
+      network: [bobAdapter],
+      peerId: bob,
+    })
+    aliceAdapter.peerCandidate(bob)
+    bobAdapter.peerCandidate(alice)
+
+    const bobHandle = bobRepo.create<TestDoc>()
+    bobHandle.change(d => {
+      d.foo = "bar"
+    })
+    const aliceHandle = await aliceRepo.find(bobHandle.documentId)
+    await eventPromise(aliceHandle, "heads-changed")
+    assert.deepEqual(aliceHandle.docSync(), bobHandle.docSync())
+
+    bobAdapter.dropMessages(true)
+    bobHandle.change(d => {
+      d.bar = "foo"
+    })
+    await pause(10)
+    assert.equal(bobAdapter.getDroppedMessages()[0].type, "sync")
+
+    bobAdapter.dropMessages(false)
+    aliceHandle.change(d => {
+      d.baz = "42"
+    })
+    await eventPromise(bobHandle, "heads-changed")
+    await pause(200)
+    assert.deepEqual(aliceHandle.docSync(), bobHandle.docSync())
+  })
+
   describe("with peers (mesh network)", () => {
     const setup = async () => {
       // Set up three repos; connect Alice to Bob, Bob to Charlie, and Alice to Charlie