@automerge/automerge-repo-network-websocket 1.1.0-alpha.1 → 1.1.0-alpha.13

package/dist/BrowserWebSocketClientAdapter.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="ws" />
-import { NetworkAdapter, type PeerId, type StorageId } from "@automerge/automerge-repo";
+import { NetworkAdapter, PeerId, PeerMetadata } from "@automerge/automerge-repo";
 import WebSocket from "isomorphic-ws";
 import { FromClientMessage } from "./messages.js";
 declare abstract class WebSocketNetworkAdapter extends NetworkAdapter {
@@ -7,19 +7,20 @@ declare abstract class WebSocketNetworkAdapter extends NetworkAdapter {
 }
 export declare class BrowserWebSocketClientAdapter extends WebSocketNetworkAdapter {
     #private;
-    timerId?: ReturnType<typeof setTimeout>;
+    readonly url: string;
+    readonly retryInterval: number;
     remotePeerId?: PeerId;
-    url: string;
-    constructor(url: string);
-    connect(peerId: PeerId, storageId: StorageId | undefined, isEphemeral: boolean): void;
+    constructor(url: string, retryInterval?: number);
+    connect(peerId: PeerId, peerMetadata?: PeerMetadata): void;
     onOpen: () => void;
     onClose: () => void;
     onMessage: (event: WebSocket.MessageEvent) => void;
+    onError: (event: WebSocket.ErrorEvent) => void;
     join(): void;
     disconnect(): void;
     send(message: FromClientMessage): void;
-    announceConnection(peerId: PeerId, storageId: StorageId | undefined, isEphemeral: boolean): void;
-    receiveMessage(message: Uint8Array): void;
+    peerCandidate(remotePeerId: PeerId, peerMetadata: PeerMetadata): void;
+    receiveMessage(messageBytes: Uint8Array): void;
 }
 export {};
 //# sourceMappingURL=BrowserWebSocketClientAdapter.d.ts.map

package/dist/BrowserWebSocketClientAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BrowserWebSocketClientAdapter.d.ts","sourceRoot":"","sources":["../src/BrowserWebSocketClientAdapter.ts"],"names":[],"mappings":";AAAA,OAAO,EACL,cAAc,EACd,KAAK,MAAM,EAEX,KAAK,SAAS,EACf,MAAM,2BAA2B,CAAA;AAClC,OAAO,SAAS,MAAM,eAAe,CAAA;AAIrC,OAAO,EACL,iBAAiB,EAIlB,MAAM,eAAe,CAAA;AAKtB,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,CACL,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,SAAS,GAAG,SAAS,EAChC,WAAW,EAAE,OAAO;IAwCtB,MAAM,aAKL;IAGD,OAAO,aAYN;IAED,SAAS,UAAW,sBAAsB,UAEzC;IAED,IAAI;IAWJ,UAAU;IAOV,IAAI,CAAC,OAAO,EAAE,iBAAiB;IAwB/B,kBAAkB,CAChB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,SAAS,GAAG,SAAS,EAChC,WAAW,EAAE,OAAO;IAetB,cAAc,CAAC,OAAO,EAAE,UAAU;CA4BnC"}
+{"version":3,"file":"BrowserWebSocketClientAdapter.d.ts","sourceRoot":"","sources":["../src/BrowserWebSocketClientAdapter.ts"],"names":[],"mappings":";AAAA,OAAO,EACL,cAAc,EACd,MAAM,EACN,YAAY,EAEb,MAAM,2BAA2B,CAAA;AAClC,OAAO,SAAS,MAAM,eAAe,CAAA;AAIrC,OAAO,EACL,iBAAiB,EAKlB,MAAM,eAAe,CAAA;AAKtB,uBAAe,uBAAwB,SAAQ,cAAc;IAC3D,MAAM,CAAC,EAAE,SAAS,CAAA;CACnB;AAED,qBAAa,6BAA8B,SAAQ,uBAAuB;;aAQtD,GAAG,EAAE,MAAM;aACX,aAAa;IAJ/B,YAAY,CAAC,EAAE,MAAM,CAAA;gBAGH,GAAG,EAAE,MAAM,EACX,aAAa,SAAO;IAMtC,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,YAAY;IAqCnD,MAAM,aAKL;IAGD,OAAO,aAWN;IAED,SAAS,UAAW,sBAAsB,UAEzC;IAED,OAAO,UAAW,oBAAoB,UAQrC;IAQD,IAAI;IAUJ,UAAU;IAMV,IAAI,CAAC,OAAO,EAAE,iBAAiB;IAY/B,aAAa,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,YAAY;IAU9D,cAAc,CAAC,YAAY,EAAE,UAAU;CAiBxC"}

package/dist/BrowserWebSocketClientAdapter.js

@@ -1,150 +1,153 @@
 import { NetworkAdapter, cbor, } from "@automerge/automerge-repo";
 import WebSocket from "isomorphic-ws";
 import debug from "debug";
+import { isErrorMessage, isPeerMessage, } from "./messages.js";
 import { ProtocolV1 } from "./protocolVersion.js";
-const log = debug("WebsocketClient");
+import { assert } from "./assert.js";
+import { toArrayBuffer } from "./toArrayBuffer.js";
 class WebSocketNetworkAdapter extends NetworkAdapter {
     socket;
 }
 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) {
+    retryInterval;
+    #isReady = false;
+    #retryIntervalId;
+    #log = debug("automerge-repo:websocket:browser");
+    remotePeerId; // this adapter only connects to one remote client at a time
+    constructor(url, retryInterval = 5000) {
         super();
         this.url = url;
+        this.retryInterval = retryInterval;
+        this.#log = this.#log.extend(url);
     }
-    connect(peerId, storageId, isEphemeral) {
-        // If we're reconnecting  make sure we remove the old event listeners
-        // before creating a new connection.
-        if (this.socket) {
+    connect(peerId, 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);
         }
-        if (!this.timerId) {
-            this.timerId = setInterval(() => this.connect(peerId, storageId, isEphemeral), 5000);
-        }
-        this.peerId = peerId;
-        this.storageId = storageId;
-        this.isEphemeral = isEphemeral;
+        // Wire up retries
+        if (!this.#retryIntervalId)
+            this.#retryIntervalId = setInterval(() => {
+                this.connect(peerId, peerMetadata);
+            }, this.retryInterval);
         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);
-        // mark this adapter as ready if we haven't received an ack in 1 second.
+        this.socket.addEventListener("error", this.onError);
+        // 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.storageId, this.isEphemeral));
+        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.storageId, this.isEphemeral);
-            }
-        }
+        if (this.retryInterval > 0 && !this.#retryIntervalId)
+            // try to reconnect
+            setTimeout(() => {
+                assert(this.peerId);
+                return this.connect(this.peerId, this.peerMetadata);
+            }, this.retryInterval);
     };
     onMessage = (event) => {
         this.receiveMessage(event.data);
     };
-    join() {
-        if (!this.socket) {
-            throw new Error("WTF, get a socket");
+    onError = (event) => {
+        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.storageId, this.isEphemeral));
+            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");
-        }
+        assert(this.peerId);
+        assert(this.socket);
         this.send({ type: "leave", senderId: this.peerId });
     }
     send(message) {
-        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, storageId, isEphemeral) {
-        // 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, storageId, isEphemeral });
+    peerCandidate(remotePeerId, peerMetadata) {
+        assert(this.socket);
+        this.#ready();
+        this.remotePeerId = remotePeerId;
+        this.emit("peer-candidate", {
+            peerId: remotePeerId,
+            peerMetadata,
+        });
     }
-    receiveMessage(message) {
-        const decoded = cbor.decode(new Uint8Array(message));
-        const { type, senderId } = decoded;
-        const socket = this.socket;
-        if (!socket) {
-            throw new Error("Missing socket at receiveMessage");
-        }
-        if (message.byteLength === 0) {
+    receiveMessage(messageBytes) {
+        const message = cbor.decode(new Uint8Array(messageBytes));
+        assert(this.socket);
+        if (messageBytes.byteLength === 0)
             throw new Error("received a zero-length message");
+        if (isPeerMessage(message)) {
+            const { peerMetadata } = message;
+            this.#log(`peer: ${message.senderId}`);
+            this.peerCandidate(message.senderId, peerMetadata);
         }
-        switch (type) {
-            case "peer": {
-                const { storageId, isEphemeral } = decoded;
-                log(`peer: ${senderId}`);
-                this.announceConnection(senderId, storageId, isEphemeral);
-                break;
-            }
-            case "error":
-                log(`error: ${decoded.message}`);
-                break;
-            default:
-                this.emit("message", decoded);
+        else if (isErrorMessage(message)) {
+            this.#log(`error: ${message.message}`);
+        }
+        else {
+            this.emit("message", message);
         }
     }
 }
-function joinMessage(senderId, storageId, isEphemeral) {
+function joinMessage(senderId, peerMetadata) {
     return {
         type: "join",
         senderId,
-        storageId,
-        isEphemeral,
+        peerMetadata,
         supportedProtocolVersions: [ProtocolV1],
     };
 }

package/dist/NodeWSServerAdapter.d.ts

@@ -1,17 +1,19 @@
 /// <reference types="ws" />
 import WebSocket from "isomorphic-ws";
 import { type WebSocketServer } from "isomorphic-ws";
-import { NetworkAdapter, type PeerId, type StorageId } from "@automerge/automerge-repo";
+import { NetworkAdapter, type PeerMetadata, type PeerId } from "@automerge/automerge-repo";
 import { FromServerMessage } from "./messages.js";
 export declare class NodeWSServerAdapter extends NetworkAdapter {
-    server: WebSocketServer;
+    #private;
+    private server;
+    private keepAliveInterval;
     sockets: {
         [peerId: PeerId]: WebSocket;
     };
-    constructor(server: WebSocketServer);
-    connect(peerId: PeerId, storageId: StorageId | undefined, isEphemeral: boolean): void;
+    constructor(server: WebSocketServer, keepAliveInterval?: number);
+    connect(peerId: PeerId, peerMetadata: PeerMetadata): void;
     disconnect(): void;
     send(message: FromServerMessage): void;
-    receiveMessage(message: Uint8Array, socket: WebSocket): void;
+    receiveMessage(messageBytes: Uint8Array, socket: WebSocket): void;
 }
 //# sourceMappingURL=NodeWSServerAdapter.d.ts.map

package/dist/NodeWSServerAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NodeWSServerAdapter.d.ts","sourceRoot":"","sources":["../src/NodeWSServerAdapter.ts"],"names":[],"mappings":";AAAA,OAAO,SAAS,MAAM,eAAe,CAAA;AACrC,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,eAAe,CAAA;AAKpD,OAAO,EAEL,cAAc,EACd,KAAK,MAAM,EACX,KAAK,SAAS,EACf,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,CACL,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,SAAS,GAAG,SAAS,EAChC,WAAW,EAAE,OAAO;IAuDtB,UAAU;IAIV,IAAI,CAAC,OAAO,EAAE,iBAAiB;IAyB/B,cAAc,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS;CAwEtD"}
+{"version":3,"file":"NodeWSServerAdapter.d.ts","sourceRoot":"","sources":["../src/NodeWSServerAdapter.ts"],"names":[],"mappings":";AAAA,OAAO,SAAS,MAAM,eAAe,CAAA;AACrC,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,eAAe,CAAA;AAKpD,OAAO,EAEL,cAAc,EACd,KAAK,YAAY,EACjB,KAAK,MAAM,EACZ,MAAM,2BAA2B,CAAA;AAClC,OAAO,EAEL,iBAAiB,EAGlB,MAAM,eAAe,CAAA;AAOtB,qBAAa,mBAAoB,SAAQ,cAAc;;IAInD,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,iBAAiB;IAJ3B,OAAO,EAAE;QAAE,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,CAAK;gBAGnC,MAAM,EAAE,eAAe,EACvB,iBAAiB,SAAO;IAKlC,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,YAAY;IAyClD,UAAU;IAQV,IAAI,CAAC,OAAO,EAAE,iBAAiB;IAqB/B,cAAc,CAAC,YAAY,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS;CA0E3D"}

package/dist/NodeWSServerAdapter.js

@@ -2,31 +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, storageId, isEphemeral) {
+    connect(peerId, peerMetadata) {
         this.peerId = peerId;
-        this.storageId = storageId;
-        this.isEphemeral = isEphemeral;
-        this.server.on("close", function close() {
-            clearInterval(interval);
+        this.peerMetadata = peerMetadata;
+        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.
@@ -34,117 +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 { storageId, isEphemeral } = cbor;
-                    // Let the rest of the system know that we have a new connection.
-                    this.emit("peer-candidate", {
-                        peerId: senderId,
-                        storageId,
-                        isEphemeral,
-                    });
-                    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,
-                            storageId: this.storageId,
-                            isEphemeral: this.isEphemeral,
-                            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

@@ -1,4 +1,4 @@
-import type { Message, PeerId, StorageId } from "@automerge/automerge-repo";
+import type { Message, PeerId, PeerMetadata } from "@automerge/automerge-repo";
 import type { ProtocolVersion } from "./protocolVersion.js";
 /** The sender is disconnecting */
 export type LeaveMessage = {
@@ -10,11 +10,8 @@ export type JoinMessage = {
     type: "join";
     /** The PeerID of the client */
     senderId: PeerId;
-    /** Unique ID of the storage that the sender peer is using, is persistent across sessions */
-    storageId?: StorageId;
-    /** Indicates whether other peers should persist the sync state of the sender peer.
-     * Sync state is only persisted for non-ephemeral peers */
-    isEphemeral: boolean;
+    /** Metadata presented by the peer  */
+    peerMetadata: PeerMetadata;
     /** The protocol version the client supports */
     supportedProtocolVersions: ProtocolVersion[];
 };
@@ -23,11 +20,8 @@ export type PeerMessage = {
     type: "peer";
     /** The PeerID of the server */
     senderId: PeerId;
-    /** Unique ID of the storage that the sender peer is using, is persistent across sessions */
-    storageId?: StorageId;
-    /** Indicates whether other peers should persist the sync state of the sender peer.
-     * Sync state is only persisted for non-ephemeral peers */
-    isEphemeral: boolean;
+    /** Metadata presented by the peer  */
+    peerMetadata: PeerMetadata;
     /** The protocol version the server selected for this connection */
     selectedProtocolVersion: ProtocolVersion;
     /** The PeerID of the client */
@@ -47,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