@peers-app/peers-sdk 0.14.0 → 0.15.0

package/dist/device/connection.test.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("../utils");
 const keys_1 = require("../keys");
+const utils_1 = require("../utils");
 const connection_1 = require("./connection");
 const device_1 = require("./device");
 function createTestSocket(localHandlers, remoteHandlers) {
@@ -17,7 +17,7 @@ function createTestSocket(localHandlers, remoteHandlers) {
         on(eventName, handler) {
             localHandlers.push({
                 eventName,
-                handler: async (...args) => handler(...args)
+                handler: async (...args) => handler(...args),
             });
         },
         removeAllListeners(eventName) {
@@ -28,7 +28,7 @@ function createTestSocket(localHandlers, remoteHandlers) {
         },
         disconnect() {
             // Simulate disconnection logic if needed
-        }
+        },
     };
     return socket;
 }
@@ -51,35 +51,35 @@ describe(connection_1.Connection, () => {
         const clientDevice = new device_1.Device();
         const serverDevice = new device_1.Device();
         const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
-        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ['localhost']);
+        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ["localhost"]);
         expect(clientConnection.connectionId).toBe(serverConnection.connectionId);
-        const response = await clientConnection.doHandshake('localhost');
+        const response = await clientConnection.doHandshake("localhost");
         expect(response.userId).toBe(serverDevice.userId);
         expect(response.deviceId).toBe(serverDevice.deviceId);
         expect(response.publicKey).toBe(serverDevice.publicKey);
         expect(response.publicBoxKey).toBe(serverDevice.publicBoxKey);
-        expect(response.serverAddress).toBe('localhost');
+        expect(response.serverAddress).toBe("localhost");
         expect(response.connectionId).toBe(serverConnection.connectionId);
-        serverConnection.removeAllListeners('ping');
-        serverConnection.exposeRPC('ping', async (n, s) => `pong - ${n}, ${s}`);
-        const pong = await clientConnection.emit('ping', 1, "hello");
-        expect(pong).toBe('pong - 1, hello');
+        serverConnection.removeAllListeners("ping");
+        serverConnection.exposeRPC("ping", async (n, s) => `pong - ${n}, ${s}`);
+        const pong = await clientConnection.emit("ping", 1, "hello");
+        expect(pong).toBe("pong - 1, hello");
     });
     it("should create a new id if socket doesn't have one", async () => {
         const socket = {
             id: (0, utils_1.newid)(),
-            emit(eventName, args, callback) {
+            emit(_eventName, _args, _callback) {
                 // do nothing
             },
-            on(eventName, handler) {
+            on(_eventName, _handler) {
                 // do nothing
             },
-            removeAllListeners(eventName) {
+            removeAllListeners(_eventName) {
                 // do nothing
             },
             disconnect() {
                 // do nothing
-            }
+            },
         };
         const connection = new connection_1.Connection(socket, new device_1.Device());
         expect(connection.connectionId).toBeTruthy();
@@ -89,11 +89,11 @@ describe(connection_1.Connection, () => {
         const clientDevice = new device_1.Device();
         const serverDevice = new device_1.Device();
         const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
-        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ['https://localhost']);
-        await clientConnection.doHandshake('https://localhost');
+        const _serverConnection = new connection_1.Connection(serverSocket, serverDevice, ["https://localhost"]);
+        await clientConnection.doHandshake("https://localhost");
         expect(clientConnection.encryptTraffic).toBe(false);
         // and allow forcing insecure
-        clientConnection.overrideEncryption = 'encrypt-traffic-regardless-of-protocol';
+        clientConnection.overrideEncryption = "encrypt-traffic-regardless-of-protocol";
         expect(clientConnection.encryptTraffic).toBe(true);
         // and only return a copy of the remoteDeviceInfo
         expect(clientConnection.remoteDeviceInfo).not.toBe(clientConnection.remoteDeviceInfo);
@@ -103,13 +103,15 @@ describe(connection_1.Connection, () => {
         const clientDevice = new device_1.Device();
         const serverDevice = new device_1.Device();
         const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
-        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ['https://localhost']);
-        await clientConnection.doHandshake('https://localhost');
+        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ["https://localhost"]);
+        await clientConnection.doHandshake("https://localhost");
         expect(clientConnection.encryptTraffic).toBe(false);
         expect(serverConnection.encryptTraffic).toBe(false);
-        serverConnection.removeAllListeners('ping');
-        serverConnection.exposeRPC('ping', async () => { throw new Error("fake error"); });
-        const response = await clientConnection.emit('ping').catch((err) => err);
+        serverConnection.removeAllListeners("ping");
+        serverConnection.exposeRPC("ping", async () => {
+            throw new Error("fake error");
+        });
+        const response = await clientConnection.emit("ping").catch((err) => err);
         expect(response).toEqual({
             errorType: "RPC_ERROR",
             error: "fake error",
@@ -120,13 +122,15 @@ describe(connection_1.Connection, () => {
         const clientDevice = new device_1.Device();
         const serverDevice = new device_1.Device();
         const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
-        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ['http://localhost']);
-        await clientConnection.doHandshake('http://localhost');
+        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ["http://localhost"]);
+        await clientConnection.doHandshake("http://localhost");
         expect(clientConnection.encryptTraffic).toBe(true);
         expect(serverConnection.encryptTraffic).toBe(true);
-        serverConnection.removeAllListeners('ping');
-        serverConnection.exposeRPC('ping', async () => { throw new Error("fake error"); });
-        const response = await clientConnection.emit('ping').catch((err) => err);
+        serverConnection.removeAllListeners("ping");
+        serverConnection.exposeRPC("ping", async () => {
+            throw new Error("fake error");
+        });
+        const response = await clientConnection.emit("ping").catch((err) => err);
         expect(response).toEqual({
             errorType: "RPC_ERROR",
             error: "fake error",
@@ -137,74 +141,74 @@ describe(connection_1.Connection, () => {
         const clientDevice = new device_1.Device();
         const serverDevice = new device_1.Device();
         const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
-        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ['https://localhost']);
-        serverConnection.exposeRPC('ping', async () => 'pong');
+        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ["https://localhost"]);
+        serverConnection.exposeRPC("ping", async () => "pong");
         expect(serverConnection.verified).toBe(false);
         expect(clientConnection.verified).toBe(false);
-        const response = await clientConnection.emit('ping').catch((err) => err);
+        const response = await clientConnection.emit("ping").catch((err) => err);
         expect(response).toMatch(/Connection not verified/);
     });
     it("client should detect different connection ids during handshake", async () => {
-        const serverAddress = 'http://localhost';
+        const serverAddress = "http://localhost";
         const { clientSocket, serverSocket } = createTestSocketPair();
         const clientDevice = new device_1.Device();
         const serverDevice = new device_1.Device();
         const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
         const serverConnection = new connection_1.Connection(serverSocket, serverDevice, [serverAddress]);
-        serverConnection.exposeRPC('ping', async () => 'pong');
-        serverConnection.socket.removeAllListeners('completeHandshake');
-        serverConnection.exposeRPC('completeHandshake', async (handshakeBox) => {
+        serverConnection.exposeRPC("ping", async () => "pong");
+        serverConnection.socket.removeAllListeners("completeHandshake");
+        serverConnection.exposeRPC("completeHandshake", async (handshakeBox) => {
             const handshake = await serverConnection.completeHandshake(handshakeBox);
-            handshake.connectionId = 'fake';
+            handshake.connectionId = "fake";
             return handshake;
         });
         const result = await clientConnection.doHandshake(serverAddress).catch((err) => String(err));
         expect(result).toMatch(/Invalid connectionId/);
     });
     it("client should detect different device ids during handshake", async () => {
-        const serverAddress = 'http://localhost';
+        const serverAddress = "http://localhost";
         const { clientSocket, serverSocket } = createTestSocketPair();
         const clientDevice = new device_1.Device();
         const serverDevice = new device_1.Device();
         const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
         const serverConnection = new connection_1.Connection(serverSocket, serverDevice, [serverAddress]);
-        serverConnection.exposeRPC('ping', async () => 'pong');
-        serverConnection.socket.removeAllListeners('completeHandshake');
-        serverConnection.exposeRPC('completeHandshake', async (handshakeBox) => {
+        serverConnection.exposeRPC("ping", async () => "pong");
+        serverConnection.socket.removeAllListeners("completeHandshake");
+        serverConnection.exposeRPC("completeHandshake", async (handshakeBox) => {
             const handshake = await serverConnection.completeHandshake(handshakeBox);
-            handshake.deviceId = 'fake';
+            handshake.deviceId = "fake";
             return handshake;
         });
         const result = await clientConnection.doHandshake(serverAddress).catch((err) => String(err));
         expect(result).toMatch(/Inconsistent device info/);
     });
     it("client should detect different device ids during handshake", async () => {
-        const serverAddress = 'http://localhost';
+        const serverAddress = "http://localhost";
         const { clientSocket, serverSocket } = createTestSocketPair();
         const clientDevice = new device_1.Device();
         const serverDevice = new device_1.Device();
         const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
         const serverConnection = new connection_1.Connection(serverSocket, serverDevice, [serverAddress]);
-        serverConnection.exposeRPC('ping', async () => 'pong');
-        serverConnection.socket.removeAllListeners('completeHandshake');
-        serverConnection.exposeRPC('completeHandshake', async (handshakeBox) => {
+        serverConnection.exposeRPC("ping", async () => "pong");
+        serverConnection.socket.removeAllListeners("completeHandshake");
+        serverConnection.exposeRPC("completeHandshake", async (handshakeBox) => {
             const handshake = await serverConnection.completeHandshake(handshakeBox);
-            handshake.userId = 'fake';
+            handshake.userId = "fake";
             return handshake;
         });
         const result = await clientConnection.doHandshake(serverAddress).catch((err) => String(err));
         expect(result).toMatch(/Inconsistent device info/);
     });
     it("client should detect different box key during handshake", async () => {
-        const serverAddress = 'http://localhost';
+        const serverAddress = "http://localhost";
         const { clientSocket, serverSocket } = createTestSocketPair();
         const clientDevice = new device_1.Device();
         const serverDevice = new device_1.Device();
         const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
         const serverConnection = new connection_1.Connection(serverSocket, serverDevice, [serverAddress]);
-        serverConnection.exposeRPC('ping', async () => 'pong');
-        serverConnection.socket.removeAllListeners('completeHandshake');
-        serverConnection.exposeRPC('completeHandshake', async (handshakeBox) => {
+        serverConnection.exposeRPC("ping", async () => "pong");
+        serverConnection.socket.removeAllListeners("completeHandshake");
+        serverConnection.exposeRPC("completeHandshake", async (handshakeBox) => {
             const handshake = await serverConnection.completeHandshake(handshakeBox);
             const _keys = (0, keys_1.newKeys)();
             handshake.publicBoxKey = _keys.publicBoxKey;
@@ -214,15 +218,15 @@ describe(connection_1.Connection, () => {
         expect(result).toMatch(/Inconsistent public keys/);
     });
     it("client should detect different public key during handshake", async () => {
-        const serverAddress = 'http://localhost';
+        const serverAddress = "http://localhost";
         const { clientSocket, serverSocket } = createTestSocketPair();
         const clientDevice = new device_1.Device();
         const serverDevice = new device_1.Device();
         const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
         const serverConnection = new connection_1.Connection(serverSocket, serverDevice, [serverAddress]);
-        serverConnection.exposeRPC('ping', async () => 'pong');
-        serverConnection.socket.removeAllListeners('completeHandshake');
-        serverConnection.exposeRPC('completeHandshake', async (handshakeBox) => {
+        serverConnection.exposeRPC("ping", async () => "pong");
+        serverConnection.socket.removeAllListeners("completeHandshake");
+        serverConnection.exposeRPC("completeHandshake", async (handshakeBox) => {
             const handshake = await serverConnection.completeHandshake(handshakeBox);
             const _keys = (0, keys_1.newKeys)();
             handshake.publicKey = _keys.publicKey;
@@ -236,21 +240,21 @@ describe(connection_1.Connection, () => {
         const clientDevice = new device_1.Device();
         const serverDevice = new device_1.Device();
         const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
-        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ['localhost']);
-        await clientConnection.doHandshake('localhost');
+        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ["localhost"]);
+        await clientConnection.doHandshake("localhost");
         // Create large data
         const largeData = {
             message: "A".repeat(500),
             metadata: "B".repeat(300),
-            payload: "C".repeat(400)
+            payload: "C".repeat(400),
         };
-        serverConnection.exposeRPC('processLargeData', async (data) => {
+        serverConnection.exposeRPC("processLargeData", async (data) => {
             return {
                 received: data,
-                processedSize: JSON.stringify(data).length
+                processedSize: JSON.stringify(data).length,
             };
         });
-        const result = await clientConnection.emit('processLargeData', largeData);
+        const result = await clientConnection.emit("processLargeData", largeData);
         expect(result.received.message).toBe("A".repeat(500));
         expect(result.received.metadata).toBe("B".repeat(300));
         expect(result.received.payload).toBe("C".repeat(400));
@@ -261,18 +265,20 @@ describe(connection_1.Connection, () => {
         const clientDevice = new device_1.Device();
         const serverDevice = new device_1.Device();
         const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
-        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ['localhost']);
+        const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ["localhost"]);
         // Set a very strict timestamp tolerance (1 second) to make test reliable
         serverConnection.handshakeTimestampToleranceMs = 1000;
         // Mock the client device to send an old timestamp
         const originalGetHandshake = clientDevice.getHandshake.bind(clientDevice);
-        clientDevice.getHandshake = function (connectionId, serverAddress) {
+        clientDevice.getHandshake = (connectionId, serverAddress) => {
             const handshake = originalGetHandshake(connectionId, serverAddress);
             // Make timestamp 2 seconds in the past (beyond tolerance)
             handshake.contents.timestamp = Date.now() - 2000;
             return handshake;
         };
-        const result = await clientConnection.doHandshake('localhost').catch((err) => err.message || err.error || String(err));
+        const result = await clientConnection
+            .doHandshake("localhost")
+            .catch((err) => err.message || err.error || String(err));
         expect(result).toMatch(/Remote device's system clock is too far out of sync/);
     });
     it.todo("should handle RPC calls that return undefined");
@@ -289,9 +295,9 @@ describe(connection_1.Connection, () => {
     // Fix: after openSignedObject succeeds, assert
     //   signedHandshake.publicKey === signedHandshake.contents.publicKey
     //
-    describe('Security: key confusion — signing key vs claimed identity key', () => {
-        it('rejects handshake where signing key (KA) differs from claimed identity key in contents (KV)', async () => {
-            const serverAddress = 'http://localhost';
+    describe("Security: key confusion — signing key vs claimed identity key", () => {
+        it("rejects handshake where signing key (KA) differs from claimed identity key in contents (KV)", async () => {
+            const serverAddress = "http://localhost";
             const { clientSocket, serverSocket } = createTestSocketPair();
             const attackerDevice = new device_1.Device();
             const victimDevice = new device_1.Device(); // identity the attacker wants to impersonate
@@ -307,7 +313,7 @@ describe(connection_1.Connection, () => {
             //                                    the attacker can decrypt it to finish the
             //                                    handshake — making the whole flow succeed)
             const originalGetHandshake = attackerDevice.getHandshake.bind(attackerDevice);
-            attackerDevice.getHandshake = function (connectionId, addr) {
+            attackerDevice.getHandshake = (connectionId, addr) => {
                 const real = originalGetHandshake(connectionId, addr);
                 const maliciousContents = {
                     ...real.contents, // keep connectionId, timestamp, serverAddress
@@ -325,8 +331,8 @@ describe(connection_1.Connection, () => {
             // claimed identity key in the payload contents (KV).
             // Server-side errors travel back through the RPC layer as plain objects
             // { error: '...', errorType: 'RPC_ERROR' } rather than Error instances.
-            const result = await attackerConnection.doHandshake(serverAddress).catch(err => err);
-            const errorMessage = result instanceof Error ? result.message : result?.error ?? String(result);
+            const result = await attackerConnection.doHandshake(serverAddress).catch((err) => err);
+            const errorMessage = result instanceof Error ? result.message : (result?.error ?? String(result));
             expect(errorMessage).toMatch(/signing key does not match claimed identity key/i);
             // Neither side should be left in a verified state
             expect(attackerConnection.verified).toBe(false);

package/dist/device/device-election.d.ts

@@ -1,10 +1,10 @@
-import { IDeviceConnection, INetworkInfo } from "../types/peer-device";
+import type { IDeviceConnection, INetworkInfo } from "../types/peer-device";
 export interface IElectionData {
     deviceId: string;
     myConnections: IDeviceConnection[];
     allNetworkInfo: INetworkInfo[];
 }
-export declare function electDevices({ deviceId, myConnections, allNetworkInfo, }: IElectionData): {
+export declare function electDevices({ deviceId, myConnections, allNetworkInfo }: IElectionData): {
     preferredDeviceIds: string[];
     preferredByDeviceIds: string[];
 };

package/dist/device/device-election.js

@@ -3,19 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.electDevices = electDevices;
 exports.getLeastPreferredConnection = getLeastPreferredConnection;
 const lodash_1 = require("lodash");
-function electDevices({ deviceId, myConnections, allNetworkInfo, }) {
+function electDevices({ deviceId, myConnections, allNetworkInfo }) {
     const allDeviceIdsSet = new Set();
     const _preferredByDeviceIdsSet = new Set();
-    const allConnectionInfos = allNetworkInfo.map(networkInfo => {
-        const deviceIds = [networkInfo.deviceId, ...networkInfo.connections.map(c => c.deviceId)];
-        deviceIds.forEach(id => allDeviceIdsSet.add(id));
+    const allConnectionInfos = allNetworkInfo.map((networkInfo) => {
+        const deviceIds = [networkInfo.deviceId, ...networkInfo.connections.map((c) => c.deviceId)];
+        deviceIds.forEach((id) => {
+            allDeviceIdsSet.add(id);
+        });
         allDeviceIdsSet.add(networkInfo.deviceId);
         if (networkInfo.preferredDeviceIds.includes(deviceId)) {
             _preferredByDeviceIdsSet.add(networkInfo.deviceId);
         }
-        const preferredByDeviceIds = allNetworkInfo.filter(n => n.preferredDeviceIds.includes(networkInfo.deviceId))
-            .map(n => n.deviceId);
-        const myConnection = myConnections.find(c => c.deviceId === networkInfo.deviceId);
+        const preferredByDeviceIds = allNetworkInfo
+            .filter((n) => n.preferredDeviceIds.includes(networkInfo.deviceId))
+            .map((n) => n.deviceId);
+        const myConnection = myConnections.find((c) => c.deviceId === networkInfo.deviceId);
         return {
             ...networkInfo,
             myConnection,
@@ -25,25 +28,27 @@ function electDevices({ deviceId, myConnections, allNetworkInfo, }) {
     });
     allDeviceIdsSet.delete(deviceId);
     const preferredConnections = [];
-    let sortedConnections = allConnectionInfos.filter(c => c.myConnection);
+    let sortedConnections = allConnectionInfos.filter((c) => c.myConnection);
     while (allDeviceIdsSet.size && sortedConnections.length) {
         // sort connections (best will be first)
         sortedConnections = sortConnections({
             myDeviceId: deviceId,
             connections: sortedConnections,
-            unconnectedDeviceIds: allDeviceIdsSet
+            unconnectedDeviceIds: allDeviceIdsSet,
         });
         const connection = sortedConnections.shift();
         if (connection) {
             preferredConnections.push(connection.myConnection);
-            connection.connectedDeviceIds.forEach(id => allDeviceIdsSet.delete(id));
+            connection.connectedDeviceIds.forEach((id) => {
+                allDeviceIdsSet.delete(id);
+            });
         }
         else {
             break;
         }
     }
     return {
-        preferredDeviceIds: preferredConnections.map(c => c.deviceId),
+        preferredDeviceIds: preferredConnections.map((c) => c.deviceId),
         preferredByDeviceIds: Array.from(_preferredByDeviceIdsSet),
     };
 }
@@ -57,8 +62,8 @@ function electDevices({ deviceId, myConnections, allNetworkInfo, }) {
 function sortConnections({ myDeviceId, connections, unconnectedDeviceIds }) {
     // sort by latency * error rate (smaller is better)
     connections.sort((a, b) => {
-        const aLatency = (a.myConnection.latencyMs || 1) * (a.myConnection.errorRate || 0.00001);
-        const bLatency = (b.myConnection.latencyMs || 1) * (b.myConnection.errorRate || 0.00001);
+        const aLatency = (a.myConnection?.latencyMs || 1) * (a.myConnection?.errorRate || 0.00001);
+        const bLatency = (b.myConnection?.latencyMs || 1) * (b.myConnection?.errorRate || 0.00001);
         return aLatency - bLatency;
     });
     // sort by preferred by other devices count (higher is better)
@@ -69,8 +74,8 @@ function sortConnections({ myDeviceId, connections, unconnectedDeviceIds }) {
     });
     // sort by links to new devices - in general, this is most important except for the later edge-cases
     connections.sort((a, b) => {
-        const linksToDeviceA = a.connectedDeviceIds.filter(id => unconnectedDeviceIds.has(id)).length;
-        const linksToDeviceB = b.connectedDeviceIds.filter(id => unconnectedDeviceIds.has(id)).length;
+        const linksToDeviceA = a.connectedDeviceIds.filter((id) => unconnectedDeviceIds.has(id)).length;
+        const linksToDeviceB = b.connectedDeviceIds.filter((id) => unconnectedDeviceIds.has(id)).length;
         return linksToDeviceB - linksToDeviceA;
     });
     //=============================================
@@ -89,8 +94,8 @@ function sortConnections({ myDeviceId, connections, unconnectedDeviceIds }) {
     // prefer devices that have a connection back to me
     //   I think this is an artifact of testing and in the real world this should be a no-op (connections should be bidirectional)
     connections.sort((a, b) => {
-        const aHasConn = a.connections.some(c => c.deviceId === myDeviceId);
-        const bHasConn = b.connections.some(c => c.deviceId === myDeviceId);
+        const aHasConn = a.connections.some((c) => c.deviceId === myDeviceId);
+        const bHasConn = b.connections.some((c) => c.deviceId === myDeviceId);
         if (aHasConn && !bHasConn)
             return -1;
         if (!aHasConn && bHasConn)
@@ -101,14 +106,14 @@ function sortConnections({ myDeviceId, connections, unconnectedDeviceIds }) {
 }
 function getLeastPreferredConnection({ connections, preferredDeviceIds, preferredByDeviceIds, }) {
     // first consider connections that are not critical to me and I'm not critical to them
-    let candidates = connections.filter(c => !(preferredByDeviceIds.includes(c.deviceId) || preferredDeviceIds.includes(c.deviceId)));
+    let candidates = connections.filter((c) => !(preferredByDeviceIds.includes(c.deviceId) || preferredDeviceIds.includes(c.deviceId)));
     if (!candidates.length) {
         // if none, next consider connections that are not critical to me
-        candidates = connections.filter(c => !preferredDeviceIds.includes(c.deviceId));
+        candidates = connections.filter((c) => !preferredDeviceIds.includes(c.deviceId));
     }
     if (!candidates.length) {
         // if none, next consider connections that I am not critical to
-        candidates = connections.filter(c => !preferredByDeviceIds.includes(c.deviceId));
+        candidates = connections.filter((c) => !preferredByDeviceIds.includes(c.deviceId));
     }
     if (!candidates.length) {
         // if none, then just consider all connections

package/dist/device/device-election.test.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const device_election_1 = require("./device-election");
-const utils_1 = require("../utils");
 const lodash_1 = require("lodash");
+const utils_1 = require("../utils");
+const device_election_1 = require("./device-election");
 describe("device-election", () => {
     const createConnection = (deviceId, latencyMs = 10, errorRate = 0.001) => ({
         deviceId,
@@ -41,9 +41,7 @@ describe("device-election", () => {
                 createConnection(device2),
                 createConnection(device3),
             ]);
-            const networkInfo2 = createNetworkInfo(device2, [
-                createConnection(device1),
-            ]);
+            const networkInfo2 = createNetworkInfo(device2, [createConnection(device1)]);
             const result = (0, device_election_1.electDevices)({
                 deviceId: myDeviceId,
                 myConnections: [myConnection1, myConnection2],
@@ -120,9 +118,7 @@ describe("device-election", () => {
                 createConnection(device4),
             ]);
             // device2 only connects to device3
-            const networkInfo2 = createNetworkInfo(device2, [
-                createConnection(device3),
-            ]);
+            const networkInfo2 = createNetworkInfo(device2, [createConnection(device3)]);
             const result = (0, device_election_1.electDevices)({
                 deviceId: myDeviceId,
                 myConnections: [myConnection1, myConnection2],
@@ -170,9 +166,7 @@ describe("device-election", () => {
             const myConnection1 = createConnection(device1);
             const myConnection2 = createConnection(device2);
             // device1 has a connection back to me
-            const networkInfo1 = createNetworkInfo(device1, [
-                createConnection(myDeviceId),
-            ]);
+            const networkInfo1 = createNetworkInfo(device1, [createConnection(myDeviceId)]);
             // device2 doesn't have a connection back to me
             const networkInfo2 = createNetworkInfo(device2, []);
             const result = (0, device_election_1.electDevices)({
@@ -316,7 +310,7 @@ describe("device-election", () => {
         });
     });
     describe("Network simulations", () => {
-        it.skip('should work as connections grow', () => {
+        it.skip("should work as connections grow", () => {
             const MAX_CONNECTIONS = 100;
             const groupId = (0, utils_1.newid)();
             const deviceInfos = [];
@@ -329,10 +323,10 @@ describe("device-election", () => {
                 };
                 deviceInfos.push(newDevice);
             }
-            function removeDevice(d) {
+            function _removeDevice(d) {
                 deviceInfos.splice(deviceInfos.indexOf(d), 1);
-                d.connections.forEach(c => {
-                    const d2 = deviceInfos.find(d2 => d2.deviceId === c.deviceId);
+                d.connections.forEach((c) => {
+                    const d2 = deviceInfos.find((d2) => d2.deviceId === c.deviceId);
                     if (d2) {
                         disconnectDevices(d, d2);
                     }
@@ -344,7 +338,7 @@ describe("device-election", () => {
                     return;
                 }
                 // already connected
-                if (d1.connections.some(c => c.deviceId === d2.deviceId)) {
+                if (d1.connections.some((c) => c.deviceId === d2.deviceId)) {
                     return;
                 }
                 d1.connections.push({
@@ -361,15 +355,19 @@ describe("device-election", () => {
                 });
             }
             function disconnectDevices(d1, d2) {
-                d1.connections = d1.connections.filter(c => c.deviceId !== d2.deviceId);
-                d2.connections = d2.connections.filter(c => c.deviceId !== d1.deviceId);
-                d1.preferredByDeviceIds = d1.preferredByDeviceIds.filter(id => id !== d2.deviceId);
-                d2.preferredByDeviceIds = d2.preferredByDeviceIds.filter(id => id !== d1.deviceId);
-                d1.preferredDeviceIds = d1.preferredDeviceIds.filter(id => id !== d2.deviceId);
-                d2.preferredDeviceIds = d2.preferredDeviceIds.filter(id => id !== d1.deviceId);
+                d1.connections = d1.connections.filter((c) => c.deviceId !== d2.deviceId);
+                d2.connections = d2.connections.filter((c) => c.deviceId !== d1.deviceId);
+                d1.preferredByDeviceIds = d1.preferredByDeviceIds.filter((id) => id !== d2.deviceId);
+                d2.preferredByDeviceIds = d2.preferredByDeviceIds.filter((id) => id !== d1.deviceId);
+                d1.preferredDeviceIds = d1.preferredDeviceIds.filter((id) => id !== d2.deviceId);
+                d2.preferredDeviceIds = d2.preferredDeviceIds.filter((id) => id !== d1.deviceId);
             }
             // pre-populate with devices
-            Array(25).fill(undefined).forEach(() => addDevice());
+            Array(25)
+                .fill(undefined)
+                .forEach(() => {
+                addDevice();
+            });
             const totalTicks = 200;
             for (let tick = 0; tick < totalTicks; tick++) {
                 addDevice();
@@ -381,28 +379,29 @@ describe("device-election", () => {
                     // }
                     // // randomly disconnect
                     // if (Math.random() < 0.1) {
-                    //   const disconnect = 
-                    //   disconnectDevices()            
+                    //   const disconnect =
+                    //   disconnectDevices()
                     // }
                     // simulate a device wanting to maintain a "well connected" network
                     while (device.connections.length < 25) {
-                        const otherPreferredIds = device.connections.map(c => deviceInfos.find(d => d.deviceId === c.deviceId)?.preferredDeviceIds ?? []).flat();
-                        const newDeviceId = otherPreferredIds.find(deviceId => !device.connections.some(c => c.deviceId == deviceId) && deviceId !== device.deviceId);
-                        const newDevice = deviceInfos.find(d => d.deviceId === newDeviceId);
+                        const otherPreferredIds = device.connections.flatMap((c) => deviceInfos.find((d) => d.deviceId === c.deviceId)?.preferredDeviceIds ?? []);
+                        const newDeviceId = otherPreferredIds.find((deviceId) => !device.connections.some((c) => c.deviceId === deviceId) &&
+                            deviceId !== device.deviceId);
+                        const newDevice = deviceInfos.find((d) => d.deviceId === newDeviceId);
                         if (newDevice) {
                             connectDevices(device, newDevice);
                         }
                         else {
-                            const unconnectedDevices = deviceInfos.filter(d => !device.connections.some(c => c.deviceId === d.deviceId));
+                            const unconnectedDevices = deviceInfos.filter((d) => !device.connections.some((c) => c.deviceId === d.deviceId));
                             connectDevices(device, (0, lodash_1.shuffle)(unconnectedDevices)[0]);
                         }
                     }
                     // do elections
-                    const networkInfo = device.connections.map(c => {
-                        const remoteDevice = deviceInfos.find(d => d.deviceId === c.deviceId);
+                    const networkInfo = device.connections.map((c) => {
+                        const remoteDevice = deviceInfos.find((d) => d.deviceId === c.deviceId);
                         return {
                             deviceId: remoteDevice.deviceId,
-                            connections: [...remoteDevice?.connections],
+                            connections: [...remoteDevice.connections],
                             connectionSlotsAvailable: MAX_CONNECTIONS - remoteDevice.connections.length,
                             cpuPercent: 0.1,
                             memPercent: 0.2,
@@ -413,23 +412,23 @@ describe("device-election", () => {
                     const result = (0, device_election_1.electDevices)({
                         deviceId: device.deviceId,
                         myConnections: [...device.connections],
-                        allNetworkInfo: networkInfo
+                        allNetworkInfo: networkInfo,
                     });
                     device.preferredDeviceIds = result.preferredDeviceIds;
                     device.preferredByDeviceIds = result.preferredByDeviceIds;
                     // now that we've done elections, remove connections if we have too many (note this is slightly unrealistic as this usually happens before elections in the real code)
                     while (device.connections.length >= MAX_CONNECTIONS) {
                         const removeConn = (0, device_election_1.getLeastPreferredConnection)({
-                            connections: device.connections.map(c => ({ ...c, groups: [groupId] })),
+                            connections: device.connections.map((c) => ({ ...c, groups: [groupId] })),
                             preferredDeviceIds: [...device.preferredDeviceIds],
                             preferredByDeviceIds: [...device.preferredByDeviceIds],
                         });
-                        const disconnectDevice = deviceInfos.find(d => d.deviceId === removeConn?.deviceId);
+                        const disconnectDevice = deviceInfos.find((d) => d.deviceId === removeConn?.deviceId);
                         disconnectDevices(device, disconnectDevice);
                     }
                 }
             }
-            const output = (0, lodash_1.sortBy)(deviceInfos, d => -d.preferredByDeviceIds.length).map(d => {
+            const output = (0, lodash_1.sortBy)(deviceInfos, (d) => -d.preferredByDeviceIds.length).map((d) => {
                 return {
                     preferredBy: d.preferredByDeviceIds.length,
                     preferred: d.preferredDeviceIds.length,

package/dist/device/device.d.ts

@@ -1,5 +1,5 @@
-import { IDataBox, ISignedObject } from "../keys";
-import { IDeviceHandshake, IDeviceInfo } from "../data";
+import type { IDeviceHandshake, IDeviceInfo } from "../data";
+import { type IDataBox, type ISignedObject } from "../keys";
 export declare class Device implements IDeviceInfo {
     readonly userId: string;
     readonly deviceId: string;