@peers-app/peers-device 0.15.0 → 0.15.2

package/dist/connection-manager/connection-manager-priorities.test.js

@@ -8,10 +8,10 @@ const connection_manager_priorities_1 = require("./connection-manager-priorities
 describe("getLeastPreferredManagerConnection", () => {
     const syncGroups = [];
     afterAll(async () => {
-        await Promise.all(syncGroups.map(d => d.dispose()));
+        await Promise.all(syncGroups.map((d) => d.dispose()));
     });
     function createMockSyncGroup(userId = (0, peers_sdk_1.newid)(), deviceId = (0, peers_sdk_1.newid)(), groupId = (0, peers_sdk_1.newid)()) {
-        const db = new local_data_source_1.DBLocal(':memory:');
+        const db = new local_data_source_1.DBLocal(":memory:");
         const changeTrackingTable = new peers_sdk_1.ChangeTrackingTable({ db });
         const mockUserContext = {
             userId: () => userId,
@@ -22,13 +22,13 @@ describe("getLeastPreferredManagerConnection", () => {
                     return sqlDS;
                 }
                 return new tracked_data_source_1.TrackedDataSource(sqlDS, changeTrackingTable);
-            }
+            },
         };
         const dataContext = new peers_sdk_1.DataContext(mockUserContext);
         // Mock the dataContextId getter
-        Object.defineProperty(dataContext, 'dataContextId', {
+        Object.defineProperty(dataContext, "dataContextId", {
             get: () => groupId,
-            configurable: true
+            configurable: true,
         });
         const syncGroup = new sync_group_1.SyncGroup(dataContext, changeTrackingTable);
         syncGroups.push(syncGroup);
@@ -56,7 +56,7 @@ describe("getLeastPreferredManagerConnection", () => {
             id,
             send: jest.fn(),
             on: jest.fn(),
-            dispose: jest.fn()
+            dispose: jest.fn(),
         };
     }
     afterEach(() => {
@@ -70,8 +70,8 @@ describe("getLeastPreferredManagerConnection", () => {
     it("should return undefined when devices have no connections", () => {
         const device1 = createMockSyncGroup();
         const device2 = createMockSyncGroup();
-        jest.spyOn(device1, 'getConnections').mockReturnValue([]);
-        jest.spyOn(device2, 'getConnections').mockReturnValue([]);
+        jest.spyOn(device1, "getConnections").mockReturnValue([]);
+        jest.spyOn(device2, "getConnections").mockReturnValue([]);
         const connectionStates = new Map();
         const result = (0, connection_manager_priorities_1.getLeastPreferredManagerConnection)([device1, device2], connectionStates);
         expect(result).toBeUndefined();
@@ -80,17 +80,17 @@ describe("getLeastPreferredManagerConnection", () => {
         it("should prioritize removing null group connections over regular connections", () => {
             const device1 = createMockSyncGroup("user1", "device1", "group1");
             const connection1 = createMockConnection("remote1", 0.9, 500); // High error rate but in a group
-            jest.spyOn(device1, 'getConnections').mockReturnValue([connection1]);
-            jest.spyOn(device1, 'priorityDeviceIds', 'get').mockReturnValue({
+            jest.spyOn(device1, "getConnections").mockReturnValue([connection1]);
+            jest.spyOn(device1, "priorityDeviceIds", "get").mockReturnValue({
                 preferredDeviceIds: [],
                 preferredByDeviceIds: [],
-                priorityDeviceIds: []
+                priorityDeviceIds: [],
             });
             // Create connection states: one with groups, one without
             const socketConn1 = createMockSocketConnection("conn1");
             const socketConn2 = createMockSocketConnection("conn2");
             const connectionStates = new Map();
-            connectionStates.set(socketConn1, createMockConnectionState("user1", { "group1_device1": {} }));
+            connectionStates.set(socketConn1, createMockConnectionState("user1", { group1_device1: {} }));
             connectionStates.set(socketConn2, createMockConnectionState("user2", {})); // No groups - null connection
             const result = (0, connection_manager_priorities_1.getLeastPreferredManagerConnection)([device1], connectionStates);
             expect(result).toBeDefined();
@@ -99,11 +99,11 @@ describe("getLeastPreferredManagerConnection", () => {
         });
         it("should randomly select one null group connection when multiple exist", () => {
             const device1 = createMockSyncGroup("user1", "device1", "group1");
-            jest.spyOn(device1, 'getConnections').mockReturnValue([]);
-            jest.spyOn(device1, 'priorityDeviceIds', 'get').mockReturnValue({
+            jest.spyOn(device1, "getConnections").mockReturnValue([]);
+            jest.spyOn(device1, "priorityDeviceIds", "get").mockReturnValue({
                 preferredDeviceIds: [],
                 preferredByDeviceIds: [],
-                priorityDeviceIds: []
+                priorityDeviceIds: [],
             });
             // Create multiple null group connections
             const socketConn1 = createMockSocketConnection("conn1");
@@ -121,16 +121,16 @@ describe("getLeastPreferredManagerConnection", () => {
         it("should fall back to priority logic when no null group connections exist", () => {
             const device1 = createMockSyncGroup("user1", "device1", "group1");
             const connection1 = createMockConnection("remote1", 0.5, 100);
-            jest.spyOn(device1, 'getConnections').mockReturnValue([connection1]);
-            jest.spyOn(device1, 'priorityDeviceIds', 'get').mockReturnValue({
+            jest.spyOn(device1, "getConnections").mockReturnValue([connection1]);
+            jest.spyOn(device1, "priorityDeviceIds", "get").mockReturnValue({
                 preferredDeviceIds: [],
                 preferredByDeviceIds: [],
-                priorityDeviceIds: []
+                priorityDeviceIds: [],
             });
             // All connections have groups
             const socketConn1 = createMockSocketConnection("conn1");
             const connectionStates = new Map();
-            connectionStates.set(socketConn1, createMockConnectionState("user1", { "group1_device1": {} }));
+            connectionStates.set(socketConn1, createMockConnectionState("user1", { group1_device1: {} }));
             const result = (0, connection_manager_priorities_1.getLeastPreferredManagerConnection)([device1], connectionStates);
             expect(result).toBeDefined();
             // Should fall back to the device connection from priority logic
@@ -139,11 +139,11 @@ describe("getLeastPreferredManagerConnection", () => {
         it("should handle empty connectionStates map", () => {
             const device1 = createMockSyncGroup("user1", "device1", "group1");
             const connection1 = createMockConnection("remote1", 0.5, 100);
-            jest.spyOn(device1, 'getConnections').mockReturnValue([connection1]);
-            jest.spyOn(device1, 'priorityDeviceIds', 'get').mockReturnValue({
+            jest.spyOn(device1, "getConnections").mockReturnValue([connection1]);
+            jest.spyOn(device1, "priorityDeviceIds", "get").mockReturnValue({
                 preferredDeviceIds: [],
                 preferredByDeviceIds: [],
-                priorityDeviceIds: []
+                priorityDeviceIds: [],
             });
             const connectionStates = new Map();
             const result = (0, connection_manager_priorities_1.getLeastPreferredManagerConnection)([device1], connectionStates);
@@ -157,17 +157,17 @@ describe("getLeastPreferredManagerConnection", () => {
         const connection1 = createMockConnection("remote1", 0.1, 100);
         const connection2 = createMockConnection("remote1", 0.2, 200);
         const connection3 = createMockConnection("remote2", 0.5, 50);
-        jest.spyOn(device1, 'getConnections').mockReturnValue([connection1, connection3]);
-        jest.spyOn(device2, 'getConnections').mockReturnValue([connection2]);
-        jest.spyOn(device1, 'priorityDeviceIds', 'get').mockReturnValue({
+        jest.spyOn(device1, "getConnections").mockReturnValue([connection1, connection3]);
+        jest.spyOn(device2, "getConnections").mockReturnValue([connection2]);
+        jest.spyOn(device1, "priorityDeviceIds", "get").mockReturnValue({
             preferredDeviceIds: [],
             preferredByDeviceIds: [],
-            priorityDeviceIds: []
+            priorityDeviceIds: [],
         });
-        jest.spyOn(device2, 'priorityDeviceIds', 'get').mockReturnValue({
+        jest.spyOn(device2, "priorityDeviceIds", "get").mockReturnValue({
             preferredDeviceIds: [],
             preferredByDeviceIds: [],
-            priorityDeviceIds: []
+            priorityDeviceIds: [],
         });
         const connectionStates = new Map();
         const result = (0, connection_manager_priorities_1.getLeastPreferredManagerConnection)([device1, device2], connectionStates);
@@ -183,17 +183,17 @@ describe("getLeastPreferredManagerConnection", () => {
         // Same remote device connected to both groups with different metrics
         const connection1 = createMockConnection("remote1", 0.1, 100);
         const connection2 = createMockConnection("remote1", 0.3, 200);
-        jest.spyOn(device1, 'getConnections').mockReturnValue([connection1]);
-        jest.spyOn(device2, 'getConnections').mockReturnValue([connection2]);
-        jest.spyOn(device1, 'priorityDeviceIds', 'get').mockReturnValue({
+        jest.spyOn(device1, "getConnections").mockReturnValue([connection1]);
+        jest.spyOn(device2, "getConnections").mockReturnValue([connection2]);
+        jest.spyOn(device1, "priorityDeviceIds", "get").mockReturnValue({
             preferredDeviceIds: [],
             preferredByDeviceIds: [],
-            priorityDeviceIds: []
+            priorityDeviceIds: [],
         });
-        jest.spyOn(device2, 'priorityDeviceIds', 'get').mockReturnValue({
+        jest.spyOn(device2, "priorityDeviceIds", "get").mockReturnValue({
             preferredDeviceIds: [],
             preferredByDeviceIds: [],
-            priorityDeviceIds: []
+            priorityDeviceIds: [],
         });
         const connectionStates = new Map();
         const result = (0, connection_manager_priorities_1.getLeastPreferredManagerConnection)([device1, device2], connectionStates);
@@ -209,11 +209,11 @@ describe("getLeastPreferredManagerConnection", () => {
         const connection1 = createMockConnection("remote1", 0.1, 100);
         const connection2 = createMockConnection("remote2", 0.5, 200); // Higher error rate
         const connection3 = createMockConnection("remote3", 0.2, 150);
-        jest.spyOn(device1, 'getConnections').mockReturnValue([connection1, connection2, connection3]);
-        jest.spyOn(device1, 'priorityDeviceIds', 'get').mockReturnValue({
-            preferredDeviceIds: ['remote1'], // remote1 is preferred, so shouldn't be removed
+        jest.spyOn(device1, "getConnections").mockReturnValue([connection1, connection2, connection3]);
+        jest.spyOn(device1, "priorityDeviceIds", "get").mockReturnValue({
+            preferredDeviceIds: ["remote1"], // remote1 is preferred, so shouldn't be removed
             preferredByDeviceIds: [],
-            priorityDeviceIds: ['remote1']
+            priorityDeviceIds: ["remote1"],
         });
         const connectionStates = new Map();
         const result = (0, connection_manager_priorities_1.getLeastPreferredManagerConnection)([device1], connectionStates);
@@ -228,11 +228,11 @@ describe("getLeastPreferredManagerConnection", () => {
         const connection1 = createMockConnection("remote1", 0.1, 100);
         const connection2 = createMockConnection("remote2", 0.5, 200);
         const connection3 = createMockConnection("remote3", 0.2, 150);
-        jest.spyOn(device1, 'getConnections').mockReturnValue([connection1, connection2, connection3]);
-        jest.spyOn(device1, 'priorityDeviceIds', 'get').mockReturnValue({
+        jest.spyOn(device1, "getConnections").mockReturnValue([connection1, connection2, connection3]);
+        jest.spyOn(device1, "priorityDeviceIds", "get").mockReturnValue({
             preferredDeviceIds: [],
             preferredByDeviceIds: [],
-            priorityDeviceIds: []
+            priorityDeviceIds: [],
         });
         const connectionStates = new Map();
         const result = (0, connection_manager_priorities_1.getLeastPreferredManagerConnection)([device1], connectionStates);
@@ -244,11 +244,11 @@ describe("getLeastPreferredManagerConnection", () => {
     });
     it("should handle empty connections gracefully", () => {
         const device1 = createMockSyncGroup("user1", "device1", "group1");
-        jest.spyOn(device1, 'getConnections').mockReturnValue([]);
-        jest.spyOn(device1, 'priorityDeviceIds', 'get').mockReturnValue({
+        jest.spyOn(device1, "getConnections").mockReturnValue([]);
+        jest.spyOn(device1, "priorityDeviceIds", "get").mockReturnValue({
             preferredDeviceIds: [],
             preferredByDeviceIds: [],
-            priorityDeviceIds: []
+            priorityDeviceIds: [],
         });
         const connectionStates = new Map();
         const result = (0, connection_manager_priorities_1.getLeastPreferredManagerConnection)([device1], connectionStates);
@@ -262,23 +262,23 @@ describe("getLeastPreferredManagerConnection", () => {
         const connection1 = createMockConnection("remote1", 0.1, 100);
         const connection2 = createMockConnection("remote1", 0.2, 200);
         const connection3 = createMockConnection("remote1", 0.3, 300);
-        jest.spyOn(device1, 'getConnections').mockReturnValue([connection1]);
-        jest.spyOn(device2, 'getConnections').mockReturnValue([connection2]);
-        jest.spyOn(device3, 'getConnections').mockReturnValue([connection3]);
-        jest.spyOn(device1, 'priorityDeviceIds', 'get').mockReturnValue({
+        jest.spyOn(device1, "getConnections").mockReturnValue([connection1]);
+        jest.spyOn(device2, "getConnections").mockReturnValue([connection2]);
+        jest.spyOn(device3, "getConnections").mockReturnValue([connection3]);
+        jest.spyOn(device1, "priorityDeviceIds", "get").mockReturnValue({
             preferredDeviceIds: [],
             preferredByDeviceIds: [],
-            priorityDeviceIds: []
+            priorityDeviceIds: [],
         });
-        jest.spyOn(device2, 'priorityDeviceIds', 'get').mockReturnValue({
+        jest.spyOn(device2, "priorityDeviceIds", "get").mockReturnValue({
             preferredDeviceIds: [],
             preferredByDeviceIds: [],
-            priorityDeviceIds: []
+            priorityDeviceIds: [],
         });
-        jest.spyOn(device3, 'priorityDeviceIds', 'get').mockReturnValue({
+        jest.spyOn(device3, "priorityDeviceIds", "get").mockReturnValue({
             preferredDeviceIds: [],
             preferredByDeviceIds: [],
-            priorityDeviceIds: []
+            priorityDeviceIds: [],
         });
         const connectionStates = new Map();
         const result = (0, connection_manager_priorities_1.getLeastPreferredManagerConnection)([device1, device2, device3], connectionStates);
@@ -296,24 +296,24 @@ describe("getLeastPreferredManagerConnection", () => {
         const connection2 = createMockConnection("remote2", 0.2, 200);
         const connection3 = createMockConnection("remote3", 0.3, 150);
         const connection4 = createMockConnection("remote4", 0.8, 1); // Highest error rate
-        jest.spyOn(device1, 'getConnections').mockReturnValue([connection1, connection4]);
-        jest.spyOn(device2, 'getConnections').mockReturnValue([connection2]);
-        jest.spyOn(device3, 'getConnections').mockReturnValue([connection3]);
+        jest.spyOn(device1, "getConnections").mockReturnValue([connection1, connection4]);
+        jest.spyOn(device2, "getConnections").mockReturnValue([connection2]);
+        jest.spyOn(device3, "getConnections").mockReturnValue([connection3]);
         // Different priority lists for each group
-        jest.spyOn(device1, 'priorityDeviceIds', 'get').mockReturnValue({
-            preferredDeviceIds: ['remote1', 'remote2'],
-            preferredByDeviceIds: ['remote3'],
-            priorityDeviceIds: ['remote1', 'remote2', 'remote3']
+        jest.spyOn(device1, "priorityDeviceIds", "get").mockReturnValue({
+            preferredDeviceIds: ["remote1", "remote2"],
+            preferredByDeviceIds: ["remote3"],
+            priorityDeviceIds: ["remote1", "remote2", "remote3"],
         });
-        jest.spyOn(device2, 'priorityDeviceIds', 'get').mockReturnValue({
-            preferredDeviceIds: ['remote2', 'remote3'],
-            preferredByDeviceIds: ['remote1'],
-            priorityDeviceIds: ['remote1', 'remote2', 'remote3']
+        jest.spyOn(device2, "priorityDeviceIds", "get").mockReturnValue({
+            preferredDeviceIds: ["remote2", "remote3"],
+            preferredByDeviceIds: ["remote1"],
+            priorityDeviceIds: ["remote1", "remote2", "remote3"],
         });
-        jest.spyOn(device3, 'priorityDeviceIds', 'get').mockReturnValue({
-            preferredDeviceIds: ['remote1'],
-            preferredByDeviceIds: ['remote2', 'remote3'],
-            priorityDeviceIds: ['remote1', 'remote2', 'remote3']
+        jest.spyOn(device3, "priorityDeviceIds", "get").mockReturnValue({
+            preferredDeviceIds: ["remote1"],
+            preferredByDeviceIds: ["remote2", "remote3"],
+            priorityDeviceIds: ["remote1", "remote2", "remote3"],
         });
         const connectionStates = new Map();
         const result = (0, connection_manager_priorities_1.getLeastPreferredManagerConnection)([device1, device2, device3], connectionStates);
@@ -336,24 +336,26 @@ describe("getLeastPreferredManagerConnection", () => {
         const connection2b = createMockConnection("remote2", 0.1, 100);
         // remote3: connected to only 1 group (least critical - should be removed)
         const connection3 = createMockConnection("remote3", 0.1, 100);
-        jest.spyOn(device1, 'getConnections').mockReturnValue([connection1a, connection2a, connection3]);
-        jest.spyOn(device2, 'getConnections').mockReturnValue([connection1b, connection2b]);
-        jest.spyOn(device3, 'getConnections').mockReturnValue([connection1c]);
+        jest
+            .spyOn(device1, "getConnections")
+            .mockReturnValue([connection1a, connection2a, connection3]);
+        jest.spyOn(device2, "getConnections").mockReturnValue([connection1b, connection2b]);
+        jest.spyOn(device3, "getConnections").mockReturnValue([connection1c]);
         // No preferences - should select based on group count
-        jest.spyOn(device1, 'priorityDeviceIds', 'get').mockReturnValue({
+        jest.spyOn(device1, "priorityDeviceIds", "get").mockReturnValue({
             preferredDeviceIds: [],
             preferredByDeviceIds: [],
-            priorityDeviceIds: []
+            priorityDeviceIds: [],
         });
-        jest.spyOn(device2, 'priorityDeviceIds', 'get').mockReturnValue({
+        jest.spyOn(device2, "priorityDeviceIds", "get").mockReturnValue({
             preferredDeviceIds: [],
             preferredByDeviceIds: [],
-            priorityDeviceIds: []
+            priorityDeviceIds: [],
         });
-        jest.spyOn(device3, 'priorityDeviceIds', 'get').mockReturnValue({
+        jest.spyOn(device3, "priorityDeviceIds", "get").mockReturnValue({
             preferredDeviceIds: [],
             preferredByDeviceIds: [],
-            priorityDeviceIds: []
+            priorityDeviceIds: [],
         });
         const connectionStates = new Map();
         const result = (0, connection_manager_priorities_1.getLeastPreferredManagerConnection)([device1, device2, device3], connectionStates);
@@ -370,17 +372,17 @@ describe("getLeastPreferredManagerConnection", () => {
         const connection1b = createMockConnection("remote1", 0.1, 100);
         // remote2: connected to only 1 group but with zero errors
         const connection2 = createMockConnection("remote2", 0, 200);
-        jest.spyOn(device1, 'getConnections').mockReturnValue([connection1a, connection2]);
-        jest.spyOn(device2, 'getConnections').mockReturnValue([connection1b]);
-        jest.spyOn(device1, 'priorityDeviceIds', 'get').mockReturnValue({
+        jest.spyOn(device1, "getConnections").mockReturnValue([connection1a, connection2]);
+        jest.spyOn(device2, "getConnections").mockReturnValue([connection1b]);
+        jest.spyOn(device1, "priorityDeviceIds", "get").mockReturnValue({
             preferredDeviceIds: [],
             preferredByDeviceIds: [],
-            priorityDeviceIds: []
+            priorityDeviceIds: [],
         });
-        jest.spyOn(device2, 'priorityDeviceIds', 'get').mockReturnValue({
+        jest.spyOn(device2, "priorityDeviceIds", "get").mockReturnValue({
             preferredDeviceIds: [],
             preferredByDeviceIds: [],
-            priorityDeviceIds: []
+            priorityDeviceIds: [],
         });
         const connectionStates = new Map();
         const result = (0, connection_manager_priorities_1.getLeastPreferredManagerConnection)([device1, device2], connectionStates);
@@ -395,11 +397,11 @@ describe("getLeastPreferredManagerConnection", () => {
         // Both connections are only in 1 group, so should use error rate to decide
         const connection1 = createMockConnection("remote1", 0.1, 100); // Lower error rate
         const connection2 = createMockConnection("remote2", 0.5, 200); // Higher error rate
-        jest.spyOn(device1, 'getConnections').mockReturnValue([connection1, connection2]);
-        jest.spyOn(device1, 'priorityDeviceIds', 'get').mockReturnValue({
+        jest.spyOn(device1, "getConnections").mockReturnValue([connection1, connection2]);
+        jest.spyOn(device1, "priorityDeviceIds", "get").mockReturnValue({
             preferredDeviceIds: [],
             preferredByDeviceIds: [],
-            priorityDeviceIds: []
+            priorityDeviceIds: [],
         });
         const connectionStates = new Map();
         const result = (0, connection_manager_priorities_1.getLeastPreferredManagerConnection)([device1], connectionStates);
@@ -413,10 +415,10 @@ describe("getLeastPreferredManagerConnection", () => {
 describe("getPreferredDeviceIds", () => {
     const devices = [];
     afterAll(async () => {
-        await Promise.all(devices.map(d => d.dispose()));
+        await Promise.all(devices.map((d) => d.dispose()));
     });
     function createMockDeviceSync(userId = (0, peers_sdk_1.newid)(), deviceId = (0, peers_sdk_1.newid)(), groupId = (0, peers_sdk_1.newid)()) {
-        const db = new local_data_source_1.DBLocal(':memory:');
+        const db = new local_data_source_1.DBLocal(":memory:");
         const changeTrackingTable = new peers_sdk_1.ChangeTrackingTable({ db });
         const mockUserContext = {
             userId: () => userId,
@@ -427,13 +429,13 @@ describe("getPreferredDeviceIds", () => {
                     return sqlDS;
                 }
                 return new tracked_data_source_1.TrackedDataSource(sqlDS, changeTrackingTable);
-            }
+            },
         };
         const dataContext = new peers_sdk_1.DataContext(mockUserContext);
         // Mock the dataContextId getter
-        Object.defineProperty(dataContext, 'dataContextId', {
+        Object.defineProperty(dataContext, "dataContextId", {
             get: () => groupId,
-            configurable: true
+            configurable: true,
         });
         const deviceSync = new sync_group_1.SyncGroup(dataContext, changeTrackingTable);
         devices.push(deviceSync);
@@ -447,15 +449,15 @@ describe("getPreferredDeviceIds", () => {
     it("should return empty arrays when devices have no priority device IDs", () => {
         const device1 = createMockDeviceSync();
         const device2 = createMockDeviceSync();
-        jest.spyOn(device1, 'priorityDeviceIds', 'get').mockReturnValue({
+        jest.spyOn(device1, "priorityDeviceIds", "get").mockReturnValue({
             preferredDeviceIds: [],
             preferredByDeviceIds: [],
-            priorityDeviceIds: []
+            priorityDeviceIds: [],
         });
-        jest.spyOn(device2, 'priorityDeviceIds', 'get').mockReturnValue({
+        jest.spyOn(device2, "priorityDeviceIds", "get").mockReturnValue({
             preferredDeviceIds: [],
             preferredByDeviceIds: [],
-            priorityDeviceIds: []
+            priorityDeviceIds: [],
         });
         const result = (0, connection_manager_priorities_1.getConnectionManagerPreferredDeviceIds)([device1, device2]);
         expect(result.preferredDeviceIds).toEqual([]);
@@ -463,45 +465,41 @@ describe("getPreferredDeviceIds", () => {
     });
     it("should collect preferred device IDs from a single device", () => {
         const device1 = createMockDeviceSync();
-        jest.spyOn(device1, 'priorityDeviceIds', 'get').mockReturnValue({
-            preferredDeviceIds: ['device1', 'device2'],
-            preferredByDeviceIds: ['device3'],
-            priorityDeviceIds: ['device1', 'device2', 'device3']
+        jest.spyOn(device1, "priorityDeviceIds", "get").mockReturnValue({
+            preferredDeviceIds: ["device1", "device2"],
+            preferredByDeviceIds: ["device3"],
+            priorityDeviceIds: ["device1", "device2", "device3"],
         });
         const result = (0, connection_manager_priorities_1.getConnectionManagerPreferredDeviceIds)([device1]);
-        expect(result.preferredDeviceIds).toEqual(expect.arrayContaining(['device1', 'device2']));
+        expect(result.preferredDeviceIds).toEqual(expect.arrayContaining(["device1", "device2"]));
         expect(result.preferredDeviceIds.length).toBe(2);
-        expect(result.preferredByDeviceIds).toEqual(['device3']);
+        expect(result.preferredByDeviceIds).toEqual(["device3"]);
     });
     it("should merge preferred device IDs from multiple devices", () => {
         const device1 = createMockDeviceSync();
         const device2 = createMockDeviceSync();
         const device3 = createMockDeviceSync();
-        jest.spyOn(device1, 'priorityDeviceIds', 'get').mockReturnValue({
-            preferredDeviceIds: ['device1', 'device2'],
-            preferredByDeviceIds: ['device3'],
-            priorityDeviceIds: ['device1', 'device2', 'device3']
+        jest.spyOn(device1, "priorityDeviceIds", "get").mockReturnValue({
+            preferredDeviceIds: ["device1", "device2"],
+            preferredByDeviceIds: ["device3"],
+            priorityDeviceIds: ["device1", "device2", "device3"],
         });
-        jest.spyOn(device2, 'priorityDeviceIds', 'get').mockReturnValue({
-            preferredDeviceIds: ['device2', 'device4'],
-            preferredByDeviceIds: ['device5', 'device6'],
-            priorityDeviceIds: ['device2', 'device4', 'device5', 'device6']
+        jest.spyOn(device2, "priorityDeviceIds", "get").mockReturnValue({
+            preferredDeviceIds: ["device2", "device4"],
+            preferredByDeviceIds: ["device5", "device6"],
+            priorityDeviceIds: ["device2", "device4", "device5", "device6"],
         });
-        jest.spyOn(device3, 'priorityDeviceIds', 'get').mockReturnValue({
-            preferredDeviceIds: ['device7'],
-            preferredByDeviceIds: ['device3', 'device8'],
-            priorityDeviceIds: ['device3', 'device7', 'device8']
+        jest.spyOn(device3, "priorityDeviceIds", "get").mockReturnValue({
+            preferredDeviceIds: ["device7"],
+            preferredByDeviceIds: ["device3", "device8"],
+            priorityDeviceIds: ["device3", "device7", "device8"],
         });
         const result = (0, connection_manager_priorities_1.getConnectionManagerPreferredDeviceIds)([device1, device2, device3]);
         // Should contain all unique preferred device IDs
-        expect(result.preferredDeviceIds).toEqual(expect.arrayContaining([
-            'device1', 'device2', 'device4', 'device7'
-        ]));
+        expect(result.preferredDeviceIds).toEqual(expect.arrayContaining(["device1", "device2", "device4", "device7"]));
         expect(result.preferredDeviceIds.length).toBe(4);
         // Should contain all unique preferredBy device IDs
-        expect(result.preferredByDeviceIds).toEqual(expect.arrayContaining([
-            'device3', 'device5', 'device6', 'device8'
-        ]));
+        expect(result.preferredByDeviceIds).toEqual(expect.arrayContaining(["device3", "device5", "device6", "device8"]));
         expect(result.preferredByDeviceIds.length).toBe(4);
     });
     it("should deduplicate device IDs across multiple devices", () => {
@@ -509,118 +507,118 @@ describe("getPreferredDeviceIds", () => {
         const device2 = createMockDeviceSync();
         const device3 = createMockDeviceSync();
         // All devices prefer the same devices
-        jest.spyOn(device1, 'priorityDeviceIds', 'get').mockReturnValue({
-            preferredDeviceIds: ['deviceA', 'deviceB'],
-            preferredByDeviceIds: ['deviceC'],
-            priorityDeviceIds: ['deviceA', 'deviceB', 'deviceC']
+        jest.spyOn(device1, "priorityDeviceIds", "get").mockReturnValue({
+            preferredDeviceIds: ["deviceA", "deviceB"],
+            preferredByDeviceIds: ["deviceC"],
+            priorityDeviceIds: ["deviceA", "deviceB", "deviceC"],
         });
-        jest.spyOn(device2, 'priorityDeviceIds', 'get').mockReturnValue({
-            preferredDeviceIds: ['deviceA', 'deviceB'],
-            preferredByDeviceIds: ['deviceC'],
-            priorityDeviceIds: ['deviceA', 'deviceB', 'deviceC']
+        jest.spyOn(device2, "priorityDeviceIds", "get").mockReturnValue({
+            preferredDeviceIds: ["deviceA", "deviceB"],
+            preferredByDeviceIds: ["deviceC"],
+            priorityDeviceIds: ["deviceA", "deviceB", "deviceC"],
         });
-        jest.spyOn(device3, 'priorityDeviceIds', 'get').mockReturnValue({
-            preferredDeviceIds: ['deviceA', 'deviceB'],
-            preferredByDeviceIds: ['deviceC'],
-            priorityDeviceIds: ['deviceA', 'deviceB', 'deviceC']
+        jest.spyOn(device3, "priorityDeviceIds", "get").mockReturnValue({
+            preferredDeviceIds: ["deviceA", "deviceB"],
+            preferredByDeviceIds: ["deviceC"],
+            priorityDeviceIds: ["deviceA", "deviceB", "deviceC"],
         });
         const result = (0, connection_manager_priorities_1.getConnectionManagerPreferredDeviceIds)([device1, device2, device3]);
         // Should only contain unique entries
-        expect(result.preferredDeviceIds).toEqual(expect.arrayContaining(['deviceA', 'deviceB']));
+        expect(result.preferredDeviceIds).toEqual(expect.arrayContaining(["deviceA", "deviceB"]));
         expect(result.preferredDeviceIds.length).toBe(2);
-        expect(result.preferredByDeviceIds).toEqual(['deviceC']);
+        expect(result.preferredByDeviceIds).toEqual(["deviceC"]);
         expect(result.preferredByDeviceIds.length).toBe(1);
     });
     it("should handle devices with only preferredDeviceIds", () => {
         const device1 = createMockDeviceSync();
-        jest.spyOn(device1, 'priorityDeviceIds', 'get').mockReturnValue({
-            preferredDeviceIds: ['device1', 'device2', 'device3'],
+        jest.spyOn(device1, "priorityDeviceIds", "get").mockReturnValue({
+            preferredDeviceIds: ["device1", "device2", "device3"],
             preferredByDeviceIds: [],
-            priorityDeviceIds: ['device1', 'device2', 'device3']
+            priorityDeviceIds: ["device1", "device2", "device3"],
         });
         const result = (0, connection_manager_priorities_1.getConnectionManagerPreferredDeviceIds)([device1]);
-        expect(result.preferredDeviceIds).toEqual(expect.arrayContaining(['device1', 'device2', 'device3']));
+        expect(result.preferredDeviceIds).toEqual(expect.arrayContaining(["device1", "device2", "device3"]));
         expect(result.preferredDeviceIds.length).toBe(3);
         expect(result.preferredByDeviceIds).toEqual([]);
     });
     it("should handle devices with only preferredByDeviceIds", () => {
         const device1 = createMockDeviceSync();
-        jest.spyOn(device1, 'priorityDeviceIds', 'get').mockReturnValue({
+        jest.spyOn(device1, "priorityDeviceIds", "get").mockReturnValue({
             preferredDeviceIds: [],
-            preferredByDeviceIds: ['device1', 'device2', 'device3'],
-            priorityDeviceIds: ['device1', 'device2', 'device3']
+            preferredByDeviceIds: ["device1", "device2", "device3"],
+            priorityDeviceIds: ["device1", "device2", "device3"],
         });
         const result = (0, connection_manager_priorities_1.getConnectionManagerPreferredDeviceIds)([device1]);
         expect(result.preferredDeviceIds).toEqual([]);
-        expect(result.preferredByDeviceIds).toEqual(expect.arrayContaining(['device1', 'device2', 'device3']));
+        expect(result.preferredByDeviceIds).toEqual(expect.arrayContaining(["device1", "device2", "device3"]));
         expect(result.preferredByDeviceIds.length).toBe(3);
     });
     it("should handle a mix of devices with and without priority IDs", () => {
         const device1 = createMockDeviceSync();
         const device2 = createMockDeviceSync();
         const device3 = createMockDeviceSync();
-        jest.spyOn(device1, 'priorityDeviceIds', 'get').mockReturnValue({
-            preferredDeviceIds: ['device1'],
-            preferredByDeviceIds: ['device2'],
-            priorityDeviceIds: ['device1', 'device2']
+        jest.spyOn(device1, "priorityDeviceIds", "get").mockReturnValue({
+            preferredDeviceIds: ["device1"],
+            preferredByDeviceIds: ["device2"],
+            priorityDeviceIds: ["device1", "device2"],
         });
-        jest.spyOn(device2, 'priorityDeviceIds', 'get').mockReturnValue({
+        jest.spyOn(device2, "priorityDeviceIds", "get").mockReturnValue({
             preferredDeviceIds: [],
             preferredByDeviceIds: [],
-            priorityDeviceIds: []
+            priorityDeviceIds: [],
         });
-        jest.spyOn(device3, 'priorityDeviceIds', 'get').mockReturnValue({
-            preferredDeviceIds: ['device3'],
+        jest.spyOn(device3, "priorityDeviceIds", "get").mockReturnValue({
+            preferredDeviceIds: ["device3"],
             preferredByDeviceIds: [],
-            priorityDeviceIds: ['device3']
+            priorityDeviceIds: ["device3"],
         });
         const result = (0, connection_manager_priorities_1.getConnectionManagerPreferredDeviceIds)([device1, device2, device3]);
-        expect(result.preferredDeviceIds).toEqual(expect.arrayContaining(['device1', 'device3']));
+        expect(result.preferredDeviceIds).toEqual(expect.arrayContaining(["device1", "device3"]));
         expect(result.preferredDeviceIds.length).toBe(2);
-        expect(result.preferredByDeviceIds).toEqual(['device2']);
+        expect(result.preferredByDeviceIds).toEqual(["device2"]);
     });
     it("should handle the same device ID appearing in both preferred lists", () => {
         const device1 = createMockDeviceSync();
         const device2 = createMockDeviceSync();
         // device1 prefers deviceX, device2 is preferred by deviceX
-        jest.spyOn(device1, 'priorityDeviceIds', 'get').mockReturnValue({
-            preferredDeviceIds: ['deviceX', 'deviceY'],
+        jest.spyOn(device1, "priorityDeviceIds", "get").mockReturnValue({
+            preferredDeviceIds: ["deviceX", "deviceY"],
             preferredByDeviceIds: [],
-            priorityDeviceIds: ['deviceX', 'deviceY']
+            priorityDeviceIds: ["deviceX", "deviceY"],
         });
-        jest.spyOn(device2, 'priorityDeviceIds', 'get').mockReturnValue({
+        jest.spyOn(device2, "priorityDeviceIds", "get").mockReturnValue({
             preferredDeviceIds: [],
-            preferredByDeviceIds: ['deviceX', 'deviceZ'],
-            priorityDeviceIds: ['deviceX', 'deviceZ']
+            preferredByDeviceIds: ["deviceX", "deviceZ"],
+            priorityDeviceIds: ["deviceX", "deviceZ"],
         });
         const result = (0, connection_manager_priorities_1.getConnectionManagerPreferredDeviceIds)([device1, device2]);
         // deviceX can appear in both lists
-        expect(result.preferredDeviceIds).toEqual(expect.arrayContaining(['deviceX', 'deviceY']));
+        expect(result.preferredDeviceIds).toEqual(expect.arrayContaining(["deviceX", "deviceY"]));
         expect(result.preferredDeviceIds.length).toBe(2);
-        expect(result.preferredByDeviceIds).toEqual(expect.arrayContaining(['deviceX', 'deviceZ']));
+        expect(result.preferredByDeviceIds).toEqual(expect.arrayContaining(["deviceX", "deviceZ"]));
         expect(result.preferredByDeviceIds.length).toBe(2);
     });
     it("should work correctly when devices have no connections", () => {
         const device1 = createMockDeviceSync();
         const device2 = createMockDeviceSync();
         // Devices have priority IDs but no actual connections
-        jest.spyOn(device1, 'getConnections').mockReturnValue([]);
-        jest.spyOn(device2, 'getConnections').mockReturnValue([]);
-        jest.spyOn(device1, 'priorityDeviceIds', 'get').mockReturnValue({
-            preferredDeviceIds: ['device1', 'device2'],
-            preferredByDeviceIds: ['device3'],
-            priorityDeviceIds: ['device1', 'device2', 'device3']
-        });
-        jest.spyOn(device2, 'priorityDeviceIds', 'get').mockReturnValue({
-            preferredDeviceIds: ['device4'],
-            preferredByDeviceIds: ['device5'],
-            priorityDeviceIds: ['device4', 'device5']
+        jest.spyOn(device1, "getConnections").mockReturnValue([]);
+        jest.spyOn(device2, "getConnections").mockReturnValue([]);
+        jest.spyOn(device1, "priorityDeviceIds", "get").mockReturnValue({
+            preferredDeviceIds: ["device1", "device2"],
+            preferredByDeviceIds: ["device3"],
+            priorityDeviceIds: ["device1", "device2", "device3"],
+        });
+        jest.spyOn(device2, "priorityDeviceIds", "get").mockReturnValue({
+            preferredDeviceIds: ["device4"],
+            preferredByDeviceIds: ["device5"],
+            priorityDeviceIds: ["device4", "device5"],
         });
         const result = (0, connection_manager_priorities_1.getConnectionManagerPreferredDeviceIds)([device1, device2]);
         // Should still collect priority IDs even without connections
-        expect(result.preferredDeviceIds).toEqual(expect.arrayContaining(['device1', 'device2', 'device4']));
+        expect(result.preferredDeviceIds).toEqual(expect.arrayContaining(["device1", "device2", "device4"]));
         expect(result.preferredDeviceIds.length).toBe(3);
-        expect(result.preferredByDeviceIds).toEqual(expect.arrayContaining(['device3', 'device5']));
+        expect(result.preferredByDeviceIds).toEqual(expect.arrayContaining(["device3", "device5"]));
         expect(result.preferredByDeviceIds.length).toBe(2);
     });
     it("should work correctly when connections don't share any groups", () => {
@@ -630,21 +628,21 @@ describe("getPreferredDeviceIds", () => {
         const connection1 = createMockConnection("remote1", 0.1, 100);
         const connection2 = createMockConnection("remote2", 0.2, 200);
         // Mock connections that exist but aren't in any shared groups
-        jest.spyOn(device1, 'getConnections').mockReturnValue([connection1]);
-        jest.spyOn(device2, 'getConnections').mockReturnValue([connection2]);
-        jest.spyOn(device1, 'priorityDeviceIds', 'get').mockReturnValue({
-            preferredDeviceIds: ['remote1'],
+        jest.spyOn(device1, "getConnections").mockReturnValue([connection1]);
+        jest.spyOn(device2, "getConnections").mockReturnValue([connection2]);
+        jest.spyOn(device1, "priorityDeviceIds", "get").mockReturnValue({
+            preferredDeviceIds: ["remote1"],
             preferredByDeviceIds: [],
-            priorityDeviceIds: ['remote1']
+            priorityDeviceIds: ["remote1"],
         });
-        jest.spyOn(device2, 'priorityDeviceIds', 'get').mockReturnValue({
-            preferredDeviceIds: ['remote2'],
+        jest.spyOn(device2, "priorityDeviceIds", "get").mockReturnValue({
+            preferredDeviceIds: ["remote2"],
             preferredByDeviceIds: [],
-            priorityDeviceIds: ['remote2']
+            priorityDeviceIds: ["remote2"],
         });
         const result = (0, connection_manager_priorities_1.getConnectionManagerPreferredDeviceIds)([device1, device2]);
         // Should still return priority IDs regardless of group membership
-        expect(result.preferredDeviceIds).toEqual(expect.arrayContaining(['remote1', 'remote2']));
+        expect(result.preferredDeviceIds).toEqual(expect.arrayContaining(["remote1", "remote2"]));
         expect(result.preferredDeviceIds.length).toBe(2);
         expect(result.preferredByDeviceIds).toEqual([]);
     });
@@ -653,26 +651,26 @@ describe("getPreferredDeviceIds", () => {
         const device2 = createMockDeviceSync();
         const device3 = createMockDeviceSync();
         // Mix of devices: some with connections in groups, some without
-        jest.spyOn(device1, 'priorityDeviceIds', 'get').mockReturnValue({
-            preferredDeviceIds: ['deviceA', 'deviceB'],
-            preferredByDeviceIds: ['deviceC'],
-            priorityDeviceIds: ['deviceA', 'deviceB', 'deviceC']
+        jest.spyOn(device1, "priorityDeviceIds", "get").mockReturnValue({
+            preferredDeviceIds: ["deviceA", "deviceB"],
+            preferredByDeviceIds: ["deviceC"],
+            priorityDeviceIds: ["deviceA", "deviceB", "deviceC"],
         });
-        jest.spyOn(device2, 'priorityDeviceIds', 'get').mockReturnValue({
+        jest.spyOn(device2, "priorityDeviceIds", "get").mockReturnValue({
             preferredDeviceIds: [],
             preferredByDeviceIds: [],
-            priorityDeviceIds: []
+            priorityDeviceIds: [],
         });
-        jest.spyOn(device3, 'priorityDeviceIds', 'get').mockReturnValue({
-            preferredDeviceIds: ['deviceD'],
-            preferredByDeviceIds: ['deviceE'],
-            priorityDeviceIds: ['deviceD', 'deviceE']
+        jest.spyOn(device3, "priorityDeviceIds", "get").mockReturnValue({
+            preferredDeviceIds: ["deviceD"],
+            preferredByDeviceIds: ["deviceE"],
+            priorityDeviceIds: ["deviceD", "deviceE"],
         });
         const result = (0, connection_manager_priorities_1.getConnectionManagerPreferredDeviceIds)([device1, device2, device3]);
         // Should aggregate all priority IDs regardless of connection state
-        expect(result.preferredDeviceIds).toEqual(expect.arrayContaining(['deviceA', 'deviceB', 'deviceD']));
+        expect(result.preferredDeviceIds).toEqual(expect.arrayContaining(["deviceA", "deviceB", "deviceD"]));
         expect(result.preferredDeviceIds.length).toBe(3);
-        expect(result.preferredByDeviceIds).toEqual(expect.arrayContaining(['deviceC', 'deviceE']));
+        expect(result.preferredByDeviceIds).toEqual(expect.arrayContaining(["deviceC", "deviceE"]));
         expect(result.preferredByDeviceIds.length).toBe(2);
     });
     function createMockConnection(deviceId, errorRate = 0, latencyMs = 10, timestampLastApplied = Date.now()) {