@automerge/automerge-repo-network-websocket 1.0.9 → 1.0.11

package/dist/BrowserWebSocketClientAdapter.d.ts

@@ -8,6 +8,7 @@ declare abstract class WebSocketNetworkAdapter extends NetworkAdapter {
 export declare class BrowserWebSocketClientAdapter extends WebSocketNetworkAdapter {
     #private;
     timerId?: ReturnType<typeof setTimeout>;
+    remotePeerId?: PeerId;
     url: string;
     constructor(url: string);
     connect(peerId: PeerId): void;

package/dist/BrowserWebSocketClientAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BrowserWebSocketClientAdapter.d.ts","sourceRoot":"","sources":["../src/BrowserWebSocketClientAdapter.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,EAAQ,MAAM,2BAA2B,CAAA;AACxE,OAAO,SAAS,MAAM,eAAe,CAAA;AAIrC,OAAO,EACL,iBAAiB,EAGlB,MAAM,eAAe,CAAA;AAMtB,uBAAe,uBAAwB,SAAQ,cAAc;IAC3D,MAAM,CAAC,EAAE,SAAS,CAAA;CACnB;AAED,qBAAa,6BAA8B,SAAQ,uBAAuB;;IAGxE,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,CAAA;IAGvC,GAAG,EAAE,MAAM,CAAA;gBAEC,GAAG,EAAE,MAAM;IAKvB,OAAO,CAAC,MAAM,EAAE,MAAM;IAkCtB,MAAM,aAKL;IAGD,OAAO,aAON;IAED,SAAS,UAAW,sBAAsB,UAEzC;IAED,IAAI;IAWJ,UAAU;IAOV,IAAI,CAAC,OAAO,EAAE,iBAAiB;IAwB/B,kBAAkB,CAAC,MAAM,EAAE,MAAM;IAajC,cAAc,CAAC,OAAO,EAAE,UAAU;CA6BnC"}
+{"version":3,"file":"BrowserWebSocketClientAdapter.d.ts","sourceRoot":"","sources":["../src/BrowserWebSocketClientAdapter.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,EAAQ,MAAM,2BAA2B,CAAA;AACxE,OAAO,SAAS,MAAM,eAAe,CAAA;AAIrC,OAAO,EACL,iBAAiB,EAGlB,MAAM,eAAe,CAAA;AAMtB,uBAAe,uBAAwB,SAAQ,cAAc;IAC3D,MAAM,CAAC,EAAE,SAAS,CAAA;CACnB;AAED,qBAAa,6BAA8B,SAAQ,uBAAuB;;IAGxE,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,CAAA;IACvC,YAAY,CAAC,EAAE,MAAM,CAAA;IAGrB,GAAG,EAAE,MAAM,CAAA;gBAEC,GAAG,EAAE,MAAM;IAKvB,OAAO,CAAC,MAAM,EAAE,MAAM;IAkCtB,MAAM,aAKL;IAGD,OAAO,aAYN;IAED,SAAS,UAAW,sBAAsB,UAEzC;IAED,IAAI;IAWJ,UAAU;IAOV,IAAI,CAAC,OAAO,EAAE,iBAAiB;IAwB/B,kBAAkB,CAAC,MAAM,EAAE,MAAM;IAcjC,cAAc,CAAC,OAAO,EAAE,UAAU;CA6BnC"}

package/dist/BrowserWebSocketClientAdapter.js

@@ -11,6 +11,7 @@ export class BrowserWebSocketClientAdapter extends WebSocketNetworkAdapter {
     // Type trickery required for platform independence,
     // see https://stackoverflow.com/questions/45802988/typescript-use-correct-version-of-settimeout-node-vs-window
     timerId;
+    remotePeerId; // this adapter only connects to one remote client at a time
     #startupComplete = false;
     url;
     constructor(url) {
@@ -54,6 +55,9 @@ export class BrowserWebSocketClientAdapter extends WebSocketNetworkAdapter {
     // When a socket closes, or disconnects, remove it from the array.
     onClose = () => {
         log(`${this.url}: close`);
+        if (this.remotePeerId) {
+            this.emit("peer-disconnected", { peerId: this.remotePeerId });
+        }
         if (!this.timerId) {
             if (this.peerId) {
                 this.connect(this.peerId);
@@ -106,6 +110,7 @@ export class BrowserWebSocketClientAdapter extends WebSocketNetworkAdapter {
             this.#startupComplete = true;
             this.emit("ready", { network: this });
         }
+        this.remotePeerId = peerId;
         this.emit("peer-candidate", { peerId });
     }
     receiveMessage(message) {

package/dist/NodeWSServerAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NodeWSServerAdapter.d.ts","sourceRoot":"","sources":["../src/NodeWSServerAdapter.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,eAAe,EAAE,MAAM,eAAe,CAAA;AAK/D,OAAO,EAEL,cAAc,EACd,KAAK,MAAM,EACZ,MAAM,2BAA2B,CAAA;AAClC,OAAO,EAAqB,iBAAiB,EAAE,MAAM,eAAe,CAAA;AASpE,qBAAa,mBAAoB,SAAQ,cAAc;IACrD,MAAM,EAAE,eAAe,CAAA;IACvB,OAAO,EAAE;QAAE,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,CAAK;gBAEjC,MAAM,EAAE,eAAe;IAKnC,OAAO,CAAC,MAAM,EAAE,MAAM;IAoDtB,UAAU;IAIV,IAAI,CAAC,OAAO,EAAE,iBAAiB;IAyB/B,cAAc,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS;CAuDtD"}
+{"version":3,"file":"NodeWSServerAdapter.d.ts","sourceRoot":"","sources":["../src/NodeWSServerAdapter.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,eAAe,EAAE,MAAM,eAAe,CAAA;AAK/D,OAAO,EAEL,cAAc,EACd,KAAK,MAAM,EACZ,MAAM,2BAA2B,CAAA;AAClC,OAAO,EAAqB,iBAAiB,EAAE,MAAM,eAAe,CAAA;AASpE,qBAAa,mBAAoB,SAAQ,cAAc;IACrD,MAAM,EAAE,eAAe,CAAA;IACvB,OAAO,EAAE;QAAE,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,CAAK;gBAEjC,MAAM,EAAE,eAAe;IAKnC,OAAO,CAAC,MAAM,EAAE,MAAM;IAoDtB,UAAU;IAIV,IAAI,CAAC,OAAO,EAAE,iBAAiB;IAyB/B,cAAc,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS;CA+DtD"}

package/dist/NodeWSServerAdapter.js

@@ -1,3 +1,4 @@
+import { WebSocket } from "isomorphic-ws";
 import debug from "debug";
 const log = debug("WebsocketServer");
 import { cbor as cborHelpers, NetworkAdapter, } from "@automerge/automerge-repo";
@@ -50,7 +51,7 @@ export class NodeWSServerAdapter extends NetworkAdapter {
                 socket.isAlive = false;
                 socket.ping();
             });
-        }, 30000);
+        }, 5000);
     }
     disconnect() {
         // throw new Error("The server doesn't join channels.")
@@ -83,6 +84,13 @@ export class NodeWSServerAdapter extends NetworkAdapter {
         log(`[${senderId}->${myPeerId}${"documentId" in cbor ? "@" + cbor.documentId : ""}] ${type} | ${message.byteLength} bytes`);
         switch (type) {
             case "join":
+                const existingSocket = this.sockets[senderId];
+                if (existingSocket) {
+                    if (existingSocket.readyState === WebSocket.OPEN) {
+                        existingSocket.close();
+                    }
+                    this.emit("peer-disconnected", { peerId: senderId });
+                }
                 // Let the rest of the system know that we have a new connection.
                 this.emit("peer-candidate", { peerId: senderId });
                 this.sockets[senderId] = socket;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automerge/automerge-repo-network-websocket",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "isomorphic node/browser Websocket network adapter for Automerge Repo",
   "peerDependencies": {
     "@automerge/automerge": "^2.1.0"
@@ -16,7 +16,7 @@
     "test": "vitest"
   },
   "dependencies": {
-    "@automerge/automerge-repo": "^1.0.9",
+    "@automerge/automerge-repo": "^1.0.11",
     "cbor-x": "^1.3.0",
     "eventemitter3": "^5.0.1",
     "isomorphic-ws": "^5.0.0",
@@ -33,5 +33,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "c277a6e8546cdd14236070d033ca62db68dfdeb3"
+  "gitHead": "aaead1625f7b1b79d239bef5bce9b3cf3d725332"
 }

package/src/BrowserWebSocketClientAdapter.ts

@@ -21,6 +21,7 @@ export class BrowserWebSocketClientAdapter extends WebSocketNetworkAdapter {
   // Type trickery required for platform independence,
   // see https://stackoverflow.com/questions/45802988/typescript-use-correct-version-of-settimeout-node-vs-window
   timerId?: ReturnType<typeof setTimeout>
+  remotePeerId?: PeerId // this adapter only connects to one remote client at a time
   #startupComplete: boolean = false
 
   url: string
@@ -74,6 +75,11 @@ export class BrowserWebSocketClientAdapter extends WebSocketNetworkAdapter {
   // When a socket closes, or disconnects, remove it from the array.
   onClose = () => {
     log(`${this.url}: close`)
+
+    if (this.remotePeerId) {
+      this.emit("peer-disconnected", { peerId: this.remotePeerId })
+    }
+
     if (!this.timerId) {
       if (this.peerId) {
         this.connect(this.peerId)
@@ -137,6 +143,7 @@ export class BrowserWebSocketClientAdapter extends WebSocketNetworkAdapter {
       this.#startupComplete = true
       this.emit("ready", { network: this })
     }
+    this.remotePeerId = peerId
     this.emit("peer-candidate", { peerId })
   }
 

package/src/NodeWSServerAdapter.ts

@@ -75,7 +75,7 @@ export class NodeWSServerAdapter extends NetworkAdapter {
         socket.isAlive = false
         socket.ping()
       })
-    }, 30000)
+    }, 5000)
   }
 
   disconnect() {
@@ -123,6 +123,14 @@ export class NodeWSServerAdapter extends NetworkAdapter {
     )
     switch (type) {
       case "join":
+        const existingSocket = this.sockets[senderId]
+        if (existingSocket) {
+          if (existingSocket.readyState === WebSocket.OPEN) {
+            existingSocket.close()
+          }
+          this.emit("peer-disconnected", {peerId: senderId})
+        }
+
         // Let the rest of the system know that we have a new connection.
         this.emit("peer-candidate", { peerId: senderId })
         this.sockets[senderId] = socket

package/test/Websocket.test.ts

@@ -1,39 +1,42 @@
-import { runAdapterTests } from "../../automerge-repo/src/helpers/tests/network-adapter-tests.js"
-import { BrowserWebSocketClientAdapter } from "../src/BrowserWebSocketClientAdapter.js"
-import { NodeWSServerAdapter } from "../src/NodeWSServerAdapter.js"
-import { startServer } from "./utilities/WebSockets.js"
-import * as CBOR from "cbor-x"
-import WebSocket, { AddressInfo } from "ws"
+import { next as A } from "@automerge/automerge"
+import { AutomergeUrl, DocumentId, PeerId, Repo, SyncMessage, parseAutomergeUrl } from "@automerge/automerge-repo"
 import assert from "assert"
-import { PeerId, Repo } from "@automerge/automerge-repo"
+import * as CBOR from "cbor-x"
 import { once } from "events"
+import http from "http"
 import { describe, it } from "vitest"
+import WebSocket, { AddressInfo } from "ws"
+import { runAdapterTests } from "../../automerge-repo/src/helpers/tests/network-adapter-tests.js"
+import { DummyStorageAdapter } from "../../automerge-repo/test/helpers/DummyStorageAdapter.js"
+import { BrowserWebSocketClientAdapter } from "../src/BrowserWebSocketClientAdapter.js"
+import { NodeWSServerAdapter } from "../src/NodeWSServerAdapter.js"
+import {headsAreSame} from "@automerge/automerge-repo/src/helpers/headsAreSame.js"
 
-describe("Websocket adapters", async () => {
-  let port = 8080
+describe("Websocket adapters", () => {
+  const setup = async (clientCount = 1) => {
+    const server = http.createServer()
+    const socket = new WebSocket.Server({ server })
 
-  runAdapterTests(async () => {
-    let socket: WebSocket.Server | undefined = undefined
-    let server: any
-
-    while (socket === undefined) {
-      try {
-        ;({ socket, server } = await startServer(port))
-      } catch (e: any) {
-        if (e.code === "EADDRINUSE") {
-          port++
-        } else {
-          throw e
-        }
-      }
-    }
+    await new Promise<void>(resolve => server.listen(0, resolve))
+    const { port } = server.address() as AddressInfo
+    const serverUrl = `ws://localhost:${port}`
 
-    const serverAdapter = new NodeWSServerAdapter(socket)
+    const clients = [] as BrowserWebSocketClientAdapter[]
+    for (let i = 0; i < clientCount; i++) {
+      clients.push(new BrowserWebSocketClientAdapter(serverUrl))
+    }
 
-    const serverUrl = `ws://localhost:${port}`
+    return { socket, server, port, serverUrl, clients }
+  }
 
-    const aliceAdapter = new BrowserWebSocketClientAdapter(serverUrl)
-    const bobAdapter = new BrowserWebSocketClientAdapter(serverUrl)
+  // run adapter acceptance tests
+  runAdapterTests(async () => {
+    const {
+      clients: [aliceAdapter, bobAdapter],
+      socket,
+      server,
+    } = await setup(2)
+    const serverAdapter = new NodeWSServerAdapter(socket)
 
     const teardown = () => {
       server.close()
@@ -41,140 +44,350 @@ describe("Websocket adapters", async () => {
 
     return { adapters: [aliceAdapter, serverAdapter, bobAdapter], teardown }
   })
-})
 
-describe("The BrowserWebSocketClientAdapter", () => {
-  it("should advertise the protocol versions it supports in its join message", async () => {
-    const { socket, server } = await startServer(0)
-    let port = (server.address()!! as AddressInfo).port
-    const serverUrl = `ws://localhost:${port}`
-    const helloPromise = firstMessage(socket)
+  describe("BrowserWebSocketClientAdapter", () => {
+    const firstMessage = async (socket: WebSocket.Server<any>) =>
+      new Promise((resolve, reject) => {
+        socket.once("connection", ws => {
+          ws.once("message", (message: any) => resolve(message))
+          ws.once("error", (error: any) => reject(error))
+        })
+        socket.once("error", error => reject(error))
+      })
 
-    const client = new BrowserWebSocketClientAdapter(serverUrl)
-    const repo = new Repo({ network: [client], peerId: "browser" as PeerId })
+    it("should advertise the protocol versions it supports in its join message", async () => {
+      const {
+        socket,
+        clients: [browser],
+      } = await setup()
 
-    const hello = await helloPromise
+      const helloPromise = firstMessage(socket)
 
-    const message = CBOR.decode(hello as Uint8Array)
-    assert.deepEqual(message, {
-      type: "join",
-      senderId: "browser",
-      supportedProtocolVersions: ["1"],
-    })
-  })
-})
+      const _repo = new Repo({
+        network: [browser],
+        peerId: "browser" as PeerId,
+      })
 
-describe("The NodeWSServerAdapter", () => {
-  it("should send the negotiated protocol version in its hello message", async () => {
-    const response = await serverHelloGivenClientHello({
-      type: "join",
-      senderId: "browser",
-      supportedProtocolVersions: ["1"],
-    })
-    assert.deepEqual<any>(response, {
-      type: "peer",
-      senderId: "server",
-      targetId: "browser",
-      selectedProtocolVersion: "1",
+      const encodedMessage = await helloPromise
+      const message = CBOR.decode(encodedMessage as Uint8Array)
+      assert.deepEqual(message, {
+        type: "join",
+        senderId: "browser",
+        supportedProtocolVersions: ["1"],
+      })
     })
-  })
 
-  it("should return an error message if the protocol version is not supported", async () => {
-    const response = await serverHelloGivenClientHello({
-      type: "join",
-      senderId: "browser",
-      supportedProtocolVersions: ["fake"],
+    it.skip("should announce disconnections", async () => {
+      const {
+        server,
+        socket,
+        clients: [browserAdapter],
+      } = await setup()
+
+      const _browserRepo = new Repo({
+        network: [browserAdapter],
+        peerId: "browser" as PeerId,
+      })
+
+      const serverAdapter = new NodeWSServerAdapter(socket)
+      const _serverRepo = new Repo({
+        network: [serverAdapter],
+        peerId: "server" as PeerId,
+      })
+
+      const disconnectPromise = new Promise<void>(resolve => {
+        browserAdapter.on("peer-disconnected", () => resolve())
+      })
+
+      server.close()
+      await disconnectPromise
     })
-    assert.deepEqual<any>(response, {
-      type: "error",
-      senderId: "server",
-      targetId: "browser",
-      message: "unsupported protocol version",
+
+    it("should correctly clear event handlers on reconnect", async () => {
+      // This reproduces an issue where the BrowserWebSocketClientAdapter.connect
+      // call registered event handlers on the websocket but didn't clear them
+      // up again on a second call to connect. This combined with the reconnect
+      // timer to produce the following sequence of events:
+      //
+      // - first call to connect creates a socket and registers an "open"
+      //   handler. The "open" handler will attempt to send a join message
+      // - The connection is slow, so the reconnect timer fires before "open",
+      //   the reconnect timer calls connect again. this.socket is now a new socket
+      // - The other end replies to the first socket, "open"
+      // - The original "open" handler attempts to send a message, but on the new
+      //   socket (because it uses `this.socket`), which isn't open yet, so we get an
+      //   error that the socket is not ready
+      const {
+        clients: [browser],
+      } = await setup()
+
+      const peerId = "testclient" as PeerId
+      browser.connect(peerId)
+
+      // simulate the reconnect timer firing before the other end has responded
+      // (which works here because we haven't yielded to the event loop yet so
+      // the server, which is on the same event loop as us, can't respond)
+      browser.connect(peerId)
+
+      // Now yield, so the server responds on the first socket, if the listeners
+      // are cleaned up correctly we shouldn't throw
+      await pause(1)
     })
   })
 
-  it("should respond with protocol v1 if no protocol version is specified", async () => {
-    const response = await serverHelloGivenClientHello({
-      type: "join",
-      senderId: "browser",
+  describe("NodeWSServerAdapter", () => {
+    const serverResponse = async (clientHello: Object) => {
+      const { socket, serverUrl } = await setup(0)
+      const server = new NodeWSServerAdapter(socket)
+      const _serverRepo = new Repo({
+        network: [server],
+        peerId: "server" as PeerId,
+      })
+
+      const clientSocket = new WebSocket(serverUrl)
+      await once(clientSocket, "open")
+      const serverHelloPromise = once(clientSocket, "message")
+
+      clientSocket.send(CBOR.encode(clientHello))
+
+      const serverHello = await serverHelloPromise
+      const message = CBOR.decode(serverHello[0] as Uint8Array)
+      return message
+    }
+
+    async function recvOrTimeout(socket: WebSocket): Promise<Buffer | null> {
+      return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+          resolve(null)
+        }, 1000)
+        socket.once("message", (msg) => {
+          clearTimeout(timer)
+          resolve(msg as Buffer)
+        })
+      })
+    }
+
+    it("should send the negotiated protocol version in its hello message", async () => {
+      const response = await serverResponse({
+        type: "join",
+        senderId: "browser",
+        supportedProtocolVersions: ["1"],
+      })
+      assert.deepEqual(response, {
+        type: "peer",
+        senderId: "server",
+        targetId: "browser",
+        selectedProtocolVersion: "1",
+      })
     })
-    assert.deepEqual<any>(response, {
-      type: "peer",
-      senderId: "server",
-      targetId: "browser",
-      selectedProtocolVersion: "1",
+
+    it("should return an error message if the protocol version is not supported", async () => {
+      const response = await serverResponse({
+        type: "join",
+        senderId: "browser",
+        supportedProtocolVersions: ["fake"],
+      })
+      assert.deepEqual(response, {
+        type: "error",
+        senderId: "server",
+        targetId: "browser",
+        message: "unsupported protocol version",
+      })
     })
-  })
-  
-  it("should correctly clear event handlers on reconnect", async () => {
-    // This reproduces an issue where the BrowserWebSocketClientAdapter.connect
-    // call registered event handlers on the websocket but didn't clear them
-    // up again on a second call to connect. This combined with the reconnect
-    // timer to produce the following sequence of events:
-    //
-    // * first call to connect creates a socket and registers an "open"
-    //   handler. The "open" handler will attempt to send a join message
-    // * The connection is slow, so the reconnect timer fires before "open",
-    //   the reconnect timer calls connect again. this.socket is now a new socket
-    // * The other end replies to the first socket, "open"
-    // * The original "open" handler attempts to send a message, but on the new
-    //   socket (because it uses this.socket), which isn't open yet, so we get an
-    //   error that the socket is not ready
-    const { socket, server } = await startServer(0)
-    let port = (server.address()!! as AddressInfo).port
-    const serverUrl = `ws://localhost:${port}`
-    const serverAdapter = new NodeWSServerAdapter(socket)
-    const browserAdapter = new BrowserWebSocketClientAdapter(serverUrl)
-
-    const peerId = "testclient" as PeerId
-    browserAdapter.connect(peerId)
-    // simulate the reconnect timer firing before the other end has responded
-    // (which works here because we haven't yielded to the event loop yet so
-    // the server, which is on the same event loop as us, can't respond)
-    browserAdapter.connect(peerId)
-    // Now await, so the server responds on the first socket, if the listeners
-    // are cleaned up correctly we shouldn't throw
-    await pause(1)
-  })
-})
 
-async function serverHelloGivenClientHello(
-  clientHello: Object
-): Promise<Object | null> {
-  const { socket, server } = await startServer(0)
-  let port = (server.address()!! as AddressInfo).port
-  const serverUrl = `ws://localhost:${port}`
-  const adapter = new NodeWSServerAdapter(socket)
-  const repo = new Repo({ network: [adapter], peerId: "server" as PeerId })
-
-  const clientSocket = new WebSocket(serverUrl)
-  await once(clientSocket, "open")
-  const serverHelloPromise = once(clientSocket, "message")
-
-  clientSocket.send(CBOR.encode(clientHello))
-
-  const serverHello = await serverHelloPromise
-  const message = CBOR.decode(serverHello[0] as Uint8Array)
-  return message
-}
-
-async function firstMessage(
-  socket: WebSocket.Server<any>
-): Promise<Object | null> {
-  return new Promise((resolve, reject) => {
-    socket.once("connection", ws => {
-      ws.once("message", (message: any) => {
-        resolve(message)
+    it("should respond with protocol v1 if no protocol version is specified", async () => {
+      const response = await serverResponse({
+        type: "join",
+        senderId: "browser",
       })
-      ws.once("error", (error: any) => {
-        reject(error)
+      assert.deepEqual(response, {
+        type: "peer",
+        senderId: "server",
+        targetId: "browser",
+        selectedProtocolVersion: "1",
       })
     })
-    socket.once("error", error => {
-      reject(error)
+
+    /** 
+     *  Create a new document, initialized with the given contents and return a
+     *  storage containign that document as well as the URL and a fork of the
+     *  document
+     *
+     *  @param contents - The contents to initialize the document with
+     */
+    async function initDocAndStorage<T extends Record<string, unknown>>(contents: T): Promise<{
+          storage: DummyStorageAdapter,
+          url: AutomergeUrl,
+          doc: A.Doc<T>,
+          documentId: DocumentId
+        }> {
+      const storage = new DummyStorageAdapter()
+      const silentRepo = new Repo({storage, network: []})
+      const doc = A.from<T>(contents)
+      const handle = silentRepo.create()
+      handle.update(() => A.clone(doc))
+      const { documentId } = parseAutomergeUrl(handle.url)
+      await pause(150)
+      return {
+        url: handle.url,
+        doc,
+        documentId,
+        storage,
+      }
+    }
+
+    function assertIsPeerMessage(msg: Buffer | null) {
+      if (msg == null) {
+        throw new Error("expected a peer message, got null")
+      }
+      let decoded = CBOR.decode(msg)
+      if (decoded.type !== "peer") {
+        throw new Error(`expected a peer message, got type: ${decoded.type}`)
+      }
+    }
+
+    function assertIsSyncMessage(forDocument: DocumentId, msg: Buffer | null): SyncMessage {
+      if (msg == null) {
+        throw new Error("expected a peer message, got null")
+      }
+      let decoded = CBOR.decode(msg)
+      if (decoded.type !== "sync") {
+        throw new Error(`expected a peer message, got type: ${decoded.type}`)
+      }
+      if (decoded.documentId !== forDocument) {
+        throw new Error(`expected a sync message for ${forDocument}, not for ${decoded.documentId}`)
+      }
+      return decoded
+    }
+
+    it("should disconnect existing peers on reconnect before announcing them", async () => {
+      // This test exercises a sync loop which is exposed in the following 
+      // sequence of events:
+      //
+      // 1. A document exists on both the server and the client with divergent
+      //    heads (both sides have changes the other does not have)
+      // 2. The client sends a sync message to the server
+      // 3. The server responds, but for some reason the server response is
+      //    dropped
+      // 4. The client reconnects due to not receiving a response or a ping
+      // 5. The peers exchange sync messages, but the server thinks it has
+      //    already sent its changes to the client, so it doesn't sent them.
+      // 6. The client notices that it doesn't have the servers changes so it
+      //    asks for them
+      // 7. The server responds with an empty sync message because it thinks it
+      //    has already sent the changes
+      // 
+      // 6 and 7 continue in an infinite loop. The root cause is the servers
+      // failure to clear the sync state associated with the given peer when
+      // it receives a new connection from the same peer ID.
+      const { socket, serverUrl } = await setup(0)
+
+      // Create a doc, populate a DummyStorageAdapter with that doc
+      const {storage, url, doc, documentId} = await initDocAndStorage({foo: "bar"})
+
+      // Create a copy of the document to represent the client state
+      let clientDoc = A.clone<{foo: string}>(doc)
+      clientDoc = A.change(clientDoc, d => d.foo = "qux")
+
+      // Now create a websocket sync server with the original document in it's storage
+      const adapter = new NodeWSServerAdapter(socket)
+      const repo = new Repo({ network: [adapter], storage, peerId: "server" as PeerId })
+
+      // make a change to the handle on the sync server
+      const handle = repo.find<{foo: string}>(url)
+      await handle.whenReady()
+      handle.change(d => d.foo = "baz")
+
+      // Okay, so now there is a document on both the client and the server
+      // which has concurrent changes on each peer.
+
+      // Simulate the initial websocket connection
+      let clientSocket = new WebSocket(serverUrl)
+      await once(clientSocket, "open")
+
+      // Run through the client/server hello
+      clientSocket.send(CBOR.encode({
+        type: "join",
+        senderId: "client",
+        supportedProtocolVersions: ["1"],
+      }))
+
+      let response = await recvOrTimeout(clientSocket)
+      assertIsPeerMessage(response)
+
+      // Okay now we start syncing
+
+      let clientState = A.initSyncState()
+      let [newSyncState, message] = A.generateSyncMessage(clientDoc, clientState)
+      clientState = newSyncState
+
+      // Send the initial sync state
+      clientSocket.send(CBOR.encode({
+        type: "request",
+        documentId,
+        targetId: "server",
+        senderId: "client",
+        data: message
+      }))
+
+      response = await recvOrTimeout(clientSocket)
+      assertIsSyncMessage(documentId, response)
+
+      // Now, assume either the network or the server is going slow, so the 
+      // server thinks it has sent the response above, but for whatever reason
+      // it never gets to the client. In that case the reconnect timer in the 
+      // BrowserWebSocketClientAdapter will fire and we'll create a new
+      // websocket and connect it. To simulate this we drop the above response
+      // on the floor and start connecting again.
+
+      clientSocket = new WebSocket(serverUrl)
+      await once(clientSocket, "open")
+
+      // and we also make a change to the client doc
+      clientDoc = A.change(clientDoc, d => d.foo = "quoxen")
+
+      // Run through the whole client/server hello dance again
+      clientSocket.send(CBOR.encode({
+        type: "join",
+        senderId: "client",
+        supportedProtocolVersions: ["1"],
+      }))
+
+      response = await recvOrTimeout(clientSocket)
+      assertIsPeerMessage(response)
+
+      // Now, we start syncing. If we're not buggy, this loop should terminate.
+      while(true) {
+        ;[clientState, message] = A.generateSyncMessage(clientDoc, clientState)
+        if (message) {
+          clientSocket.send(CBOR.encode({
+            type: "sync",
+            documentId,
+            targetId: "server",
+            senderId: "client",
+            data: message
+          }))
+        }
+        const response = await recvOrTimeout(clientSocket)
+        if (response) {
+          const decoded = assertIsSyncMessage(documentId, response)
+          ;[clientDoc, clientState] = A.receiveSyncMessage(clientDoc, clientState, decoded.data)
+        }
+        if (response == null && message == null) {
+          break
+        }
+        // Make sure shit has time to happen
+        await pause(50)
+      }
+
+      let localHeads = A.getHeads(clientDoc)
+      let remoteHeads = A.getHeads(handle.docSync())
+      if (!headsAreSame(localHeads, remoteHeads)) {
+        throw new Error("heads not equal")
+      }
     })
   })
-}
+})
 
 export const pause = (t = 0) =>
   new Promise<void>(resolve => setTimeout(() => resolve(), t))

package/test/utilities/CreateWebSocketServer.ts

@@ -1,8 +0,0 @@
-import http from "http"
-import WebSocket from "ws"
-
-function createWebSocketServer(server: http.Server) {
-  return new WebSocket.Server({ server })
-}
-
-export { createWebSocketServer }

package/test/utilities/WebSockets.ts

@@ -1,34 +0,0 @@
-import http from "http"
-import { createWebSocketServer } from "./CreateWebSocketServer.js"
-import WebSocket from "ws"
-
-function startServer(port: number) {
-  const server = http.createServer()
-  const socket = createWebSocketServer(server)
-  return new Promise<{
-    socket: WebSocket.Server
-    server: http.Server
-  }>(resolve => {
-    server.listen(port, () => resolve({ socket, server }))
-  })
-}
-
-type WebSocketState =
-  | typeof WebSocket.CONNECTING
-  | typeof WebSocket.OPEN
-  | typeof WebSocket.CLOSING
-  | typeof WebSocket.CLOSED
-
-function waitForSocketState(socket: WebSocket, state: WebSocketState) {
-  return new Promise<void>(function (resolve) {
-    setTimeout(function () {
-      if (socket.readyState === state) {
-        resolve()
-      } else {
-        waitForSocketState(socket, state).then(resolve)
-      }
-    }, 5)
-  })
-}
-
-export { startServer, waitForSocketState }