@automerge/automerge-repo-network-websocket 1.1.0-alpha.7 → 1.1.1

package/dist/NodeWSServerAdapter.js

@@ -2,30 +2,31 @@ import WebSocket from "isomorphic-ws";
 import debug from "debug";
 const log = debug("WebsocketServer");
 import { cbor as cborHelpers, NetworkAdapter, } from "@automerge/automerge-repo";
+import { isJoinMessage, isLeaveMessage, } from "./messages.js";
 import { ProtocolV1 } from "./protocolVersion.js";
+import assert from "assert";
+import { toArrayBuffer } from "./toArrayBuffer.js";
 const { encode, decode } = cborHelpers;
 export class NodeWSServerAdapter extends NetworkAdapter {
     server;
+    keepAliveInterval;
     sockets = {};
-    constructor(server) {
+    constructor(server, keepAliveInterval = 5000) {
         super();
         this.server = server;
+        this.keepAliveInterval = keepAliveInterval;
     }
     connect(peerId, peerMetadata) {
         this.peerId = peerId;
         this.peerMetadata = peerMetadata;
-        this.server.on("close", function close() {
-            clearInterval(interval);
+        this.server.on("close", () => {
+            clearInterval(keepAliveId);
+            this.disconnect();
         });
         this.server.on("connection", (socket) => {
             // When a socket closes, or disconnects, remove it from our list
             socket.on("close", () => {
-                for (const [otherPeerId, otherSocket] of Object.entries(this.sockets)) {
-                    if (socket === otherSocket) {
-                        this.emit("peer-disconnected", { peerId: otherPeerId });
-                        delete this.sockets[otherPeerId];
-                    }
-                }
+                this.#removeSocket(socket);
             });
             socket.on("message", message => this.receiveMessage(message, socket));
             // Start out "alive", and every time we get a pong, reset that state.
@@ -33,115 +34,117 @@ export class NodeWSServerAdapter extends NetworkAdapter {
             socket.on("pong", () => (socket.isAlive = true));
             this.emit("ready", { network: this });
         });
-        // Every interval, terminate connections to lost clients,
-        // then mark all clients as potentially dead and then ping them.
-        const interval = setInterval(() => {
-            ;
-            this.server.clients.forEach(socket => {
-                if (socket.isAlive === false) {
-                    // Make sure we clean up this socket even though we're terminating.
-                    // This might be unnecessary but I have read reports of the close() not happening for 30s.
-                    for (const [otherPeerId, otherSocket] of Object.entries(this.sockets)) {
-                        if (socket === otherSocket) {
-                            this.emit("peer-disconnected", { peerId: otherPeerId });
-                            delete this.sockets[otherPeerId];
-                        }
-                    }
-                    return socket.terminate();
+        const keepAliveId = setInterval(() => {
+            // Terminate connections to lost clients
+            const clients = this.server.clients;
+            clients.forEach(socket => {
+                if (socket.isAlive) {
+                    // Mark all clients as potentially dead until we hear from them
+                    socket.isAlive = false;
+                    socket.ping();
+                }
+                else {
+                    this.#terminate(socket);
                 }
-                socket.isAlive = false;
-                socket.ping();
             });
-        }, 5000);
+        }, this.keepAliveInterval);
     }
     disconnect() {
-        // throw new Error("The server doesn't join channels.")
+        const clients = this.server.clients;
+        clients.forEach(socket => {
+            this.#terminate(socket);
+            this.#removeSocket(socket);
+        });
     }
     send(message) {
-        if ("data" in message && message.data.byteLength === 0) {
-            throw new Error("tried to send a zero-length message");
-        }
+        assert("targetId" in message && message.targetId !== undefined);
+        if ("data" in message && message.data?.byteLength === 0)
+            throw new Error("Tried to send a zero-length message");
         const senderId = this.peerId;
-        if (!senderId) {
-            throw new Error("No peerId set for the websocket server network adapter.");
-        }
-        if (this.sockets[message.targetId] === undefined) {
-            log(`Tried to send message to disconnected peer: ${message.targetId}`);
+        assert(senderId, "No peerId set for the websocket server network adapter.");
+        const socket = this.sockets[message.targetId];
+        if (!socket) {
+            log(`Tried to send to disconnected peer: ${message.targetId}`);
             return;
         }
         const encoded = encode(message);
-        // This incantation deals with websocket sending the whole
-        // underlying buffer even if we just have a uint8array view on it
-        const arrayBuf = encoded.buffer.slice(encoded.byteOffset, encoded.byteOffset + encoded.byteLength);
-        this.sockets[message.targetId]?.send(arrayBuf);
+        const arrayBuf = toArrayBuffer(encoded);
+        socket.send(arrayBuf);
     }
-    receiveMessage(message, socket) {
-        const cbor = decode(message);
-        const { type, senderId } = cbor;
+    receiveMessage(messageBytes, socket) {
+        const message = decode(messageBytes);
+        const { type, senderId } = message;
         const myPeerId = this.peerId;
-        if (!myPeerId) {
-            throw new Error("Missing my peer ID.");
-        }
-        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 });
-                    }
-                    const { peerMetadata } = cbor;
-                    // Let the rest of the system know that we have a new connection.
-                    this.emit("peer-candidate", {
-                        peerId: senderId,
-                        peerMetadata,
-                    });
-                    this.sockets[senderId] = socket;
-                    // In this client-server connection, there's only ever one peer: us!
-                    // (and we pretend to be joined to every channel)
-                    const selectedProtocolVersion = selectProtocol(cbor.supportedProtocolVersions);
-                    if (selectedProtocolVersion === null) {
-                        this.send({
-                            type: "error",
-                            senderId: this.peerId,
-                            message: "unsupported protocol version",
-                            targetId: senderId,
-                        });
-                        this.sockets[senderId].close();
-                        delete this.sockets[senderId];
-                    }
-                    else {
-                        this.send({
-                            type: "peer",
-                            senderId: this.peerId,
-                            peerMetadata: this.peerMetadata,
-                            selectedProtocolVersion: ProtocolV1,
-                            targetId: senderId,
-                        });
-                    }
+        assert(myPeerId);
+        const documentId = "documentId" in message ? "@" + message.documentId : "";
+        const { byteLength } = messageBytes;
+        log(`[${senderId}->${myPeerId}${documentId}] ${type} | ${byteLength} bytes`);
+        if (isJoinMessage(message)) {
+            const { peerMetadata, supportedProtocolVersions } = message;
+            const existingSocket = this.sockets[senderId];
+            if (existingSocket) {
+                if (existingSocket.readyState === WebSocket.OPEN) {
+                    existingSocket.close();
                 }
-                break;
-            case "leave":
-                // It doesn't seem like this gets called;
-                // we handle leaving in the socket close logic
-                // TODO: confirm this
-                // ?
-                break;
-            default:
-                this.emit("message", cbor);
-                break;
+                this.emit("peer-disconnected", { peerId: senderId });
+            }
+            // Let the repo know that we have a new connection.
+            this.emit("peer-candidate", { peerId: senderId, peerMetadata });
+            this.sockets[senderId] = socket;
+            const selectedProtocolVersion = selectProtocol(supportedProtocolVersions);
+            if (selectedProtocolVersion === null) {
+                this.send({
+                    type: "error",
+                    senderId: this.peerId,
+                    message: "unsupported protocol version",
+                    targetId: senderId,
+                });
+                this.sockets[senderId].close();
+                delete this.sockets[senderId];
+            }
+            else {
+                this.send({
+                    type: "peer",
+                    senderId: this.peerId,
+                    peerMetadata: this.peerMetadata,
+                    selectedProtocolVersion: ProtocolV1,
+                    targetId: senderId,
+                });
+            }
+        }
+        else if (isLeaveMessage(message)) {
+            const { senderId } = message;
+            const socket = this.sockets[senderId];
+            /* c8 ignore next */
+            if (!socket)
+                return;
+            this.#terminate(socket);
         }
+        else {
+            this.emit("message", message);
+        }
+    }
+    #terminate(socket) {
+        this.#removeSocket(socket);
+        socket.terminate();
+    }
+    #removeSocket(socket) {
+        const peerId = this.#peerIdBySocket(socket);
+        if (!peerId)
+            return;
+        this.emit("peer-disconnected", { peerId });
+        delete this.sockets[peerId];
     }
+    #peerIdBySocket = (socket) => {
+        const isThisSocket = (peerId) => this.sockets[peerId] === socket;
+        const result = Object.keys(this.sockets).find(isThisSocket);
+        return result ?? null;
+    };
 }
-function selectProtocol(versions) {
-    if (versions === undefined) {
+const selectProtocol = (versions) => {
+    if (versions === undefined)
         return ProtocolV1;
-    }
-    if (versions.includes(ProtocolV1)) {
+    if (versions.includes(ProtocolV1))
         return ProtocolV1;
-    }
     return null;
-}
+};

package/dist/assert.d.ts

@@ -0,0 +1,3 @@
+export declare function assert(value: boolean, message?: string): asserts value;
+export declare function assert<T>(value: T | undefined, message?: string): asserts value is T;
+//# sourceMappingURL=assert.d.ts.map

package/dist/assert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../src/assert.ts"],"names":[],"mappings":"AAEA,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAA;AACvE,wBAAgB,MAAM,CAAC,CAAC,EACtB,KAAK,EAAE,CAAC,GAAG,SAAS,EACpB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,KAAK,IAAI,CAAC,CAAA"}

package/dist/assert.js

@@ -0,0 +1,17 @@
+/* c8 ignore start */
+export function assert(value, message = "Assertion failed") {
+    if (value === false || value === null || value === undefined) {
+        const error = new Error(trimLines(message));
+        error.stack = removeLine(error.stack, "assert.ts");
+        throw error;
+    }
+}
+const trimLines = (s) => s
+    .split("\n")
+    .map(s => s.trim())
+    .join("\n");
+const removeLine = (s = "", targetText) => s
+    .split("\n")
+    .filter(line => !line.includes(targetText))
+    .join("\n");
+/* c8 ignore end */

package/dist/messages.d.ts

@@ -41,4 +41,8 @@ export type ErrorMessage = {
 export type FromClientMessage = JoinMessage | LeaveMessage | Message;
 /** A message from the server to the client */
 export type FromServerMessage = PeerMessage | ErrorMessage | Message;
+export declare const isJoinMessage: (message: FromClientMessage) => message is JoinMessage;
+export declare const isLeaveMessage: (message: FromClientMessage) => message is LeaveMessage;
+export declare const isPeerMessage: (message: FromServerMessage) => message is PeerMessage;
+export declare const isErrorMessage: (message: FromServerMessage) => message is ErrorMessage;
 //# sourceMappingURL=messages.d.ts.map

package/dist/messages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../src/messages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAC9E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAE3D,kCAAkC;AAClC,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,OAAO,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,6EAA6E;AAC7E,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,+BAA+B;IAC/B,QAAQ,EAAE,MAAM,CAAA;IAEhB,sCAAsC;IACtC,YAAY,EAAE,YAAY,CAAA;IAE1B,+CAA+C;IAC/C,yBAAyB,EAAE,eAAe,EAAE,CAAA;CAC7C,CAAA;AAED,yFAAyF;AACzF,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,+BAA+B;IAC/B,QAAQ,EAAE,MAAM,CAAA;IAEhB,sCAAsC;IACtC,YAAY,EAAE,YAAY,CAAA;IAE1B,mEAAmE;IACnE,uBAAuB,EAAE,eAAe,CAAA;IACxC,+BAA+B;IAC/B,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,gGAAgG;AAChG,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,OAAO,CAAA;IACb,mCAAmC;IACnC,QAAQ,EAAE,MAAM,CAAA;IAChB,gCAAgC;IAChC,OAAO,EAAE,MAAM,CAAA;IACf,+BAA+B;IAC/B,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAKD,8CAA8C;AAC9C,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG,YAAY,GAAG,OAAO,CAAA;AAEpE,8CAA8C;AAC9C,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG,YAAY,GAAG,OAAO,CAAA"}
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../src/messages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAC9E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAE3D,kCAAkC;AAClC,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,OAAO,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,6EAA6E;AAC7E,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,+BAA+B;IAC/B,QAAQ,EAAE,MAAM,CAAA;IAEhB,sCAAsC;IACtC,YAAY,EAAE,YAAY,CAAA;IAE1B,+CAA+C;IAC/C,yBAAyB,EAAE,eAAe,EAAE,CAAA;CAC7C,CAAA;AAED,yFAAyF;AACzF,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,+BAA+B;IAC/B,QAAQ,EAAE,MAAM,CAAA;IAEhB,sCAAsC;IACtC,YAAY,EAAE,YAAY,CAAA;IAE1B,mEAAmE;IACnE,uBAAuB,EAAE,eAAe,CAAA;IACxC,+BAA+B;IAC/B,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,gGAAgG;AAChG,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,OAAO,CAAA;IACb,mCAAmC;IACnC,QAAQ,EAAE,MAAM,CAAA;IAChB,gCAAgC;IAChC,OAAO,EAAE,MAAM,CAAA;IACf,+BAA+B;IAC/B,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,8CAA8C;AAC9C,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG,YAAY,GAAG,OAAO,CAAA;AAEpE,8CAA8C;AAC9C,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG,YAAY,GAAG,OAAO,CAAA;AAIpE,eAAO,MAAM,aAAa,YACf,iBAAiB,2BACwB,CAAA;AAEpD,eAAO,MAAM,cAAc,YAChB,iBAAiB,4BAC0B,CAAA;AAEtD,eAAO,MAAM,aAAa,YACf,iBAAiB,2BACwB,CAAA;AAEpD,eAAO,MAAM,cAAc,YAChB,iBAAiB,4BAC0B,CAAA"}

package/dist/messages.js

@@ -1 +1,5 @@
-export {};
+// TYPE GUARDS
+export const isJoinMessage = (message) => message.type === "join";
+export const isLeaveMessage = (message) => message.type === "leave";
+export const isPeerMessage = (message) => message.type === "peer";
+export const isErrorMessage = (message) => message.type === "error";

package/dist/toArrayBuffer.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This incantation deals with websocket sending the whole underlying buffer even if we just have a
+ * uint8array view on it
+ */
+export declare const toArrayBuffer: (bytes: Uint8Array) => ArrayBuffer;
+//# sourceMappingURL=toArrayBuffer.d.ts.map

package/dist/toArrayBuffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toArrayBuffer.d.ts","sourceRoot":"","sources":["../src/toArrayBuffer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,aAAa,UAAW,UAAU,gBAG9C,CAAA"}

package/dist/toArrayBuffer.js

@@ -0,0 +1,8 @@
+/**
+ * This incantation deals with websocket sending the whole underlying buffer even if we just have a
+ * uint8array view on it
+ */
+export const toArrayBuffer = (bytes) => {
+    const { buffer, byteOffset, byteLength } = bytes;
+    return buffer.slice(byteOffset, byteOffset + byteLength);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automerge/automerge-repo-network-websocket",
-  "version": "1.1.0-alpha.7",
+  "version": "1.1.1",
   "description": "isomorphic node/browser Websocket network adapter for Automerge Repo",
   "repository": "https://github.com/automerge/automerge-repo/tree/master/packages/automerge-repo-network-websocket",
   "author": "Peter van Hardenberg <pvh@pvh.ca>",
@@ -13,8 +13,9 @@
     "test": "vitest"
   },
   "dependencies": {
-    "@automerge/automerge-repo": "^1.1.0-alpha.7",
+    "@automerge/automerge-repo": "1.1.1",
     "cbor-x": "^1.3.0",
+    "debug": "^4.3.4",
     "eventemitter3": "^5.0.1",
     "isomorphic-ws": "^5.0.0",
     "ws": "^8.7.0"
@@ -30,5 +31,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "9a4711e39c93273d992c5686257246ddfaaafddd"
+  "gitHead": "7e0681014b8c5f672e2abc2a653a954ccb6d7aba"
 }

package/src/BrowserWebSocketClientAdapter.ts

@@ -1,7 +1,7 @@
 import {
   NetworkAdapter,
-  type PeerId,
-  type PeerMetadata,
+  PeerId,
+  PeerMetadata,
   cbor,
 } from "@automerge/automerge-repo"
 import WebSocket from "isomorphic-ws"
@@ -12,173 +12,163 @@ import {
   FromClientMessage,
   FromServerMessage,
   JoinMessage,
-  PeerMessage,
+  isErrorMessage,
+  isPeerMessage,
 } from "./messages.js"
 import { ProtocolV1 } from "./protocolVersion.js"
-
-const log = debug("WebsocketClient")
+import { assert } from "./assert.js"
+import { toArrayBuffer } from "./toArrayBuffer.js"
 
 abstract class WebSocketNetworkAdapter extends NetworkAdapter {
   socket?: WebSocket
 }
 
 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
+  #isReady = false
+  #retryIntervalId?: TimeoutId
+  #log = debug("automerge-repo:websocket:browser")
 
-  url: string
+  remotePeerId?: PeerId // this adapter only connects to one remote client at a time
 
-  constructor(url: string) {
+  constructor(
+    public readonly url: string,
+    public readonly retryInterval = 5000
+  ) {
     super()
-    this.url = url
+    this.#log = this.#log.extend(url)
   }
 
-  connect(peerId: PeerId, peerMetadata: PeerMetadata) {
-    // If we're reconnecting  make sure we remove the old event listeners
-    // before creating a new connection.
-    if (this.socket) {
+  connect(peerId: PeerId, peerMetadata?: PeerMetadata) {
+    if (!this.socket || !this.peerId) {
+      // first time connecting
+      this.#log("connecting")
+      this.peerId = peerId
+      this.peerMetadata = peerMetadata ?? {}
+    } else {
+      this.#log("reconnecting")
+      assert(peerId === this.peerId)
+      // Remove the old event listeners before creating a new connection.
       this.socket.removeEventListener("open", this.onOpen)
       this.socket.removeEventListener("close", this.onClose)
       this.socket.removeEventListener("message", this.onMessage)
+      this.socket.removeEventListener("error", this.onError)
     }
+    // Wire up retries
+    if (!this.#retryIntervalId)
+      this.#retryIntervalId = setInterval(() => {
+        this.connect(peerId, peerMetadata)
+      }, this.retryInterval)
 
-    if (!this.timerId) {
-      this.timerId = setInterval(() => this.connect(peerId, peerMetadata), 5000)
-    }
-
-    this.peerId = peerId
-    this.peerMetadata = peerMetadata
     this.socket = new WebSocket(this.url)
+
     this.socket.binaryType = "arraybuffer"
 
     this.socket.addEventListener("open", this.onOpen)
     this.socket.addEventListener("close", this.onClose)
     this.socket.addEventListener("message", this.onMessage)
+    this.socket.addEventListener("error", this.onError)
 
-    // mark this adapter as ready if we haven't received an ack in 1 second.
+    // Mark this adapter as ready if we haven't received an ack in 1 second.
     // We might hear back from the other end at some point but we shouldn't
     // hold up marking things as unavailable for any longer
-    setTimeout(() => {
-      if (!this.#startupComplete) {
-        this.#startupComplete = true
-        this.emit("ready", { network: this })
-      }
-    }, 1000)
-
+    setTimeout(() => this.#ready(), 1000)
     this.join()
   }
 
   onOpen = () => {
-    log(`@ ${this.url}: open`)
-    clearInterval(this.timerId)
-    this.timerId = undefined
-    this.send(joinMessage(this.peerId!, this.peerMetadata!))
+    this.#log("open")
+    clearInterval(this.#retryIntervalId)
+    this.#retryIntervalId = undefined
+    this.join()
   }
 
   // When a socket closes, or disconnects, remove it from the array.
   onClose = () => {
-    log(`${this.url}: close`)
-
-    if (this.remotePeerId) {
+    this.#log("close")
+    if (this.remotePeerId)
       this.emit("peer-disconnected", { peerId: this.remotePeerId })
-    }
 
-    if (!this.timerId) {
-      if (this.peerId) {
-        this.connect(this.peerId, this.peerMetadata!)
-      }
-    }
+    if (this.retryInterval > 0 && !this.#retryIntervalId)
+      // try to reconnect
+      setTimeout(() => {
+        assert(this.peerId)
+        return this.connect(this.peerId, this.peerMetadata)
+      }, this.retryInterval)
   }
 
   onMessage = (event: WebSocket.MessageEvent) => {
     this.receiveMessage(event.data as Uint8Array)
   }
 
-  join() {
-    if (!this.socket) {
-      throw new Error("WTF, get a socket")
+  onError = (event: WebSocket.ErrorEvent) => {
+    const { code } = event.error
+    if (code === "ECONNREFUSED") {
+      this.#log("Connection refused, retrying...")
+    } else {
+      /* c8 ignore next */
+      throw event.error
     }
+  }
+
+  #ready() {
+    if (this.#isReady) return
+    this.#isReady = true
+    this.emit("ready", { network: this })
+  }
+
+  join() {
+    assert(this.peerId)
+    assert(this.socket)
     if (this.socket.readyState === WebSocket.OPEN) {
       this.send(joinMessage(this.peerId!, this.peerMetadata!))
     } else {
-      // The onOpen handler automatically sends a join message
+      // We'll try again in the `onOpen` handler
     }
   }
 
   disconnect() {
-    if (!this.socket) {
-      throw new Error("WTF, get a socket")
-    }
-    this.send({ type: "leave", senderId: this.peerId! })
+    assert(this.peerId)
+    assert(this.socket)
+    this.send({ type: "leave", senderId: this.peerId })
   }
 
   send(message: FromClientMessage) {
-    if ("data" in message && message.data.byteLength === 0) {
-      throw new Error("tried to send a zero-length message")
-    }
-
-    if (!this.peerId) {
-      throw new Error("Why don't we have a PeerID?")
-    }
-
-    if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
-      throw new Error("Websocket Socket not ready!")
-    }
+    if ("data" in message && message.data?.byteLength === 0)
+      throw new Error("Tried to send a zero-length message")
+    assert(this.peerId)
+    assert(this.socket)
+    if (this.socket.readyState !== WebSocket.OPEN)
+      throw new Error(`Websocket not ready (${this.socket.readyState})`)
 
     const encoded = cbor.encode(message)
-    // This incantation deals with websocket sending the whole
-    // underlying buffer even if we just have a uint8array view on it
-    const arrayBuf = encoded.buffer.slice(
-      encoded.byteOffset,
-      encoded.byteOffset + encoded.byteLength
-    )
-
-    this.socket?.send(arrayBuf)
+    this.socket.send(toArrayBuffer(encoded))
   }
 
-  announceConnection(peerId: PeerId, peerMetadata: PeerMetadata) {
-    // return a peer object
-    const myPeerId = this.peerId
-    if (!myPeerId) {
-      throw new Error("we should have a peer ID by now")
-    }
-    if (!this.#startupComplete) {
-      this.#startupComplete = true
-      this.emit("ready", { network: this })
-    }
-    this.remotePeerId = peerId
-    this.emit("peer-candidate", { peerId, peerMetadata })
+  peerCandidate(remotePeerId: PeerId, peerMetadata: PeerMetadata) {
+    assert(this.socket)
+    this.#ready()
+    this.remotePeerId = remotePeerId
+    this.emit("peer-candidate", {
+      peerId: remotePeerId,
+      peerMetadata,
+    })
   }
 
-  receiveMessage(message: Uint8Array) {
-    const decoded: FromServerMessage = cbor.decode(new Uint8Array(message))
-
-    const { type, senderId } = decoded
-
-    const socket = this.socket
-    if (!socket) {
-      throw new Error("Missing socket at receiveMessage")
-    }
+  receiveMessage(messageBytes: Uint8Array) {
+    const message: FromServerMessage = cbor.decode(new Uint8Array(messageBytes))
 
-    if (message.byteLength === 0) {
+    assert(this.socket)
+    if (messageBytes.byteLength === 0)
       throw new Error("received a zero-length message")
-    }
 
-    switch (type) {
-      case "peer": {
-        const { peerMetadata } = decoded
-        log(`peer: ${senderId}`)
-        this.announceConnection(senderId, peerMetadata)
-        break
-      }
-      case "error":
-        log(`error: ${decoded.message}`)
-        break
-      default:
-        this.emit("message", decoded)
+    if (isPeerMessage(message)) {
+      const { peerMetadata } = message
+      this.#log(`peer: ${message.senderId}`)
+      this.peerCandidate(message.senderId, peerMetadata)
+    } else if (isErrorMessage(message)) {
+      this.#log(`error: ${message.message}`)
+    } else {
+      this.emit("message", message)
     }
   }
 }
@@ -194,3 +184,5 @@ function joinMessage(
     supportedProtocolVersions: [ProtocolV1],
   }
 }
+
+type TimeoutId = ReturnType<typeof setTimeout> //  https://stackoverflow.com/questions/45802988