@peers-app/peers-device 0.15.0 → 0.15.2

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

@@ -75,11 +75,15 @@ async function connectDeviceManagers(connMan1, connMan2) {
     const connMan1Device = new peers_sdk_1.Device(connMan1.userContext.userId, connMan1.userContext.deviceId(), keys1);
     const connMan2Device = new peers_sdk_1.Device(connMan2.userContext.userId, connMan2.userContext.deviceId(), keys2);
     // Connection for connMan1 - represents the remote connMan2
-    const connMan1Connection = new peers_sdk_1.Connection(connMan1Socket, connMan1Device, ['http://localhost:3000']);
+    const connMan1Connection = new peers_sdk_1.Connection(connMan1Socket, connMan1Device, [
+        "http://localhost:3000",
+    ]);
     // Connection for connMan2 - represents the remote connMan1
-    const connMan2Connection = new peers_sdk_1.Connection(connMan2Socket, connMan2Device, ['http://localhost:3000']);
+    const connMan2Connection = new peers_sdk_1.Connection(connMan2Socket, connMan2Device, [
+        "http://localhost:3000",
+    ]);
     // Perform handshake from connMan1 to connMan2
-    await connMan1Connection.doHandshake('http://localhost:3000');
+    await connMan1Connection.doHandshake("http://localhost:3000");
     connMan1Connection.secureLocal = true;
     connMan1Connection.secureRemote = true;
     connMan2Connection.secureLocal = true;
@@ -96,7 +100,7 @@ async function connectionManagerFactory(userId = (0, peers_sdk_1.newid)(), devic
     const groupDbs = {};
     function getDb(dataContextId) {
         const dbKey = `${deviceId}_${dataContextId}`;
-        const db = groupDbs[dbKey] || new local_data_source_1.DBLocal(':memory:');
+        const db = groupDbs[dbKey] || new local_data_source_1.DBLocal(":memory:");
         groupDbs[dataContextId] = db;
         return db;
     }
@@ -121,7 +125,9 @@ async function connectionManagerFactory(userId = (0, peers_sdk_1.newid)(), devic
     const userContext = new peers_sdk_1.UserContext(userId, dataSourceFactory, true);
     await userContext.loadingPromise; // Wait for initialization to complete
     userContext.deviceId(deviceId); // Now set the deviceId after DB load
-    const connMan = new connection_manager_1.ConnectionManager(userContext, changeTrackingTableFactory, localDevice, groupId => { throw new Error('group keys not supported'); });
+    const connMan = new connection_manager_1.ConnectionManager(userContext, changeTrackingTableFactory, localDevice, (groupId) => {
+        throw new Error("group keys not supported");
+    });
     return connMan;
 }
 describe("connection-manager", () => {
@@ -132,7 +138,7 @@ describe("connection-manager", () => {
     });
     describe("sendDeviceMessage", () => {
         // Shared network topology for tests
-        const userId = '00mhiuq9q3ik7moqqjt00000u';
+        const userId = "00mhiuq9q3ik7moqqjt00000u";
         let connMan1;
         let connMan2;
         let connMan2b;
@@ -145,13 +151,13 @@ describe("connection-manager", () => {
             // connMan1 <-> connMan2 <-> connMan3
             //    |            |
             //    +<- connMan2b <-+
-            connMan1 = await connectionManagerFactory(userId, '00mhiuq9q3ik7moqqjt000010');
-            connMan2 = await connectionManagerFactory(userId, '00mhiuq9q3ik7moqqjt000020');
-            connMan2b = await connectionManagerFactory(userId, '00mhiuq9q3ik7moqqjt00002b');
-            connMan2c = await connectionManagerFactory(userId, '00mhiuq9q3ik7moqqjt00002c');
-            connMan3 = await connectionManagerFactory(userId, '00mhiuq9q3ik7moqqjt000030');
-            connMan3b = await connectionManagerFactory(userId, '00mhiuq9q3ik7moqqjt00003b');
-            connMan4 = await connectionManagerFactory(userId, '00mhiuq9q3ik7moqqjt000040');
+            connMan1 = await connectionManagerFactory(userId, "00mhiuq9q3ik7moqqjt000010");
+            connMan2 = await connectionManagerFactory(userId, "00mhiuq9q3ik7moqqjt000020");
+            connMan2b = await connectionManagerFactory(userId, "00mhiuq9q3ik7moqqjt00002b");
+            connMan2c = await connectionManagerFactory(userId, "00mhiuq9q3ik7moqqjt00002c");
+            connMan3 = await connectionManagerFactory(userId, "00mhiuq9q3ik7moqqjt000030");
+            connMan3b = await connectionManagerFactory(userId, "00mhiuq9q3ik7moqqjt00003b");
+            connMan4 = await connectionManagerFactory(userId, "00mhiuq9q3ik7moqqjt000040");
             await Promise.all([
                 connectDeviceManagers(connMan1, connMan2),
                 connectDeviceManagers(connMan1, connMan2b),
@@ -210,7 +216,7 @@ describe("connection-manager", () => {
                 dataContextId: (0, peers_sdk_1.newid)(),
                 ttl: 3,
                 payload: null,
-                hops: []
+                hops: [],
             };
             // This should not hang - should resolve immediately with TTL0 when there are no connections
             const response = await connMan.sendDeviceMessage(message);
@@ -228,12 +234,12 @@ describe("connection-manager", () => {
                 dataContextId: nonExistentGroupId, // But this group doesn't exist
                 ttl: 3,
                 payload: null,
-                hops: []
+                hops: [],
             };
             const response = await connMan.sendDeviceMessage(message);
             expect(response.isError).toBe(true);
             expect(response.statusCode).toBe(400);
-            expect(response.statusMessage).toBe('Device does not support specified dataContext: ' + nonExistentGroupId);
+            expect(response.statusMessage).toBe(`Device does not support specified dataContext: ${nonExistentGroupId}`);
             await connMan.dispose();
         });
         it("should return TTL0 when TTL becomes 1 and no direct connection exists", async () => {
@@ -245,7 +251,7 @@ describe("connection-manager", () => {
                 dataContextId: (0, peers_sdk_1.newid)(),
                 ttl: 2, // Will decrement to 1
                 payload: null,
-                hops: []
+                hops: [],
             };
             const response = await connMan.sendDeviceMessage(message);
             // Should return TTL0 because after decrement ttl=1 and there's no direct connection
@@ -264,7 +270,7 @@ describe("connection-manager", () => {
                 dataContextId: user1Id, // Use userId as the dataContext (personal group)
                 ttl: 3,
                 payload: null,
-                hops: []
+                hops: [],
             };
             // Send message - it should be processed by the groupDevice
             const response = await connMan1.sendDeviceMessage(message);
@@ -277,7 +283,7 @@ describe("connection-manager", () => {
         it("should return error for oversized message payload", async () => {
             const connMan = await connectionManagerFactory();
             // Create a payload larger than 64KB
-            const largePayload = new Array(64 * 100).fill(0).map(c => Math.random());
+            const largePayload = new Array(64 * 100).fill(0).map((c) => Math.random());
             const message = {
                 deviceMessageId: (0, peers_sdk_1.newid)(),
                 fromDeviceId: (0, peers_sdk_1.newid)(),
@@ -295,8 +301,8 @@ describe("connection-manager", () => {
             await connMan.dispose();
         });
         it("should forward message directly to connected device", async () => {
-            const connMan2SendSpy = jest.spyOn(connMan2, 'sendDeviceMessage');
-            const connMan3SendSpy = jest.spyOn(connMan3, 'sendDeviceMessage');
+            const connMan2SendSpy = jest.spyOn(connMan2, "sendDeviceMessage");
+            const connMan3SendSpy = jest.spyOn(connMan3, "sendDeviceMessage");
             const message = {
                 deviceMessageId: (0, peers_sdk_1.newid)(),
                 fromDeviceId: connMan1.userContext.deviceId(),
@@ -319,7 +325,7 @@ describe("connection-manager", () => {
             connMan3SendSpy.mockRestore();
         });
         it("should forward message through indirect connections", async () => {
-            const connMan2bSendSpy = jest.spyOn(connMan2b, 'sendDeviceMessage');
+            const connMan2bSendSpy = jest.spyOn(connMan2b, "sendDeviceMessage");
             const message = {
                 deviceMessageId: (0, peers_sdk_1.newid)(),
                 fromDeviceId: connMan1.userContext.deviceId(),
@@ -327,13 +333,13 @@ describe("connection-manager", () => {
                 dataContextId: userId, // both devices are same user so both will have this dataContext
                 ttl: 3,
                 payload: { test: "data", customField: "value123" },
-                hops: []
+                hops: [],
             };
             // Send message from connMan1 - it should be forwarded through the network to connMan3
             const response = await connMan1.sendDeviceMessage(message);
             // The message should have been forwarded successfully and return "No handler for message"
             expect(response).toBeDefined();
-            expect(typeof response).toEqual('object');
+            expect(typeof response).toEqual("object");
             expect(response.statusCode).toBe(404);
             expect(response.statusMessage).toBe("No handler for message");
             // Verify message was only sent through connMan2 (not 2b) since that had the indirect connection
@@ -346,15 +352,15 @@ describe("connection-manager", () => {
             const hub3 = [];
             const hub4 = [];
             const mocks = new Map();
-            for (let [i, hub] of [hub1, hub2, hub3, hub4].entries()) {
-                const hubNum = (i + 1).toString().padStart(2, '0');
+            for (const [i, hub] of [hub1, hub2, hub3, hub4].entries()) {
+                const hubNum = (i + 1).toString().padStart(2, "0");
                 for (let j = 0; j < 4; j++) {
-                    const deviceNum = (j + 1).toString().padStart(2, '0');
+                    const deviceNum = (j + 1).toString().padStart(2, "0");
                     const deviceId = `000000000hub${hubNum}000device${deviceNum}`;
                     const connMan = await connectionManagerFactory(userId, deviceId);
                     // NOTE: Limit to 2 to force ConnectionManager to try to limit calls
                     connMan.MAX_CONNECTIONS_TO_FORWARD_MESSAGES_TO = 2;
-                    mocks.set(connMan, jest.spyOn(connMan, 'sendDeviceMessage'));
+                    mocks.set(connMan, jest.spyOn(connMan, "sendDeviceMessage"));
                     if (j > 0) {
                         await connectDeviceManagers(hub[0], connMan);
                     }
@@ -366,10 +372,10 @@ describe("connection-manager", () => {
             await connectDeviceManagers(hub2[0], hub3[0]);
             await connectDeviceManagers(hub1[0], hub4[0]); // another hub off hub1 with no path to hub3
             await Promise.all([
-                ...hub1.map(d => d.refreshAllNetworkInfo()),
-                ...hub2.map(d => d.refreshAllNetworkInfo()),
-                ...hub3.map(d => d.refreshAllNetworkInfo()),
-                ...hub4.map(d => d.refreshAllNetworkInfo()),
+                ...hub1.map((d) => d.refreshAllNetworkInfo()),
+                ...hub2.map((d) => d.refreshAllNetworkInfo()),
+                ...hub3.map((d) => d.refreshAllNetworkInfo()),
+                ...hub4.map((d) => d.refreshAllNetworkInfo()),
             ]);
             // send message from hub1[-1] to hub3[-1]
             const sourceConnMan = hub1[hub1.length - 1];
@@ -380,8 +386,8 @@ describe("connection-manager", () => {
                 toDeviceId: targetConnMan.userContext.deviceId(),
                 dataContextId: userId,
                 ttl: 5,
-                payload: ['getNetworkInfo'],
-                hops: []
+                payload: ["getNetworkInfo"],
+                hops: [],
             };
             const response = await sourceConnMan.sendDeviceMessage(message);
             expect(response).toBeDefined();
@@ -393,8 +399,15 @@ describe("connection-manager", () => {
                 hub3[0].userContext.deviceId(),
                 hub3[hub3.length - 1].userContext.deviceId(),
             ]);
-            const expectCalled = [hub1[hub1.length - 1], hub1[0], hub4[0], hub2[0], hub3[0], hub3[hub3.length - 1]];
-            for (let connMan of [...hub1, ...hub2, ...hub3, ...hub4]) {
+            const expectCalled = [
+                hub1[hub1.length - 1],
+                hub1[0],
+                hub4[0],
+                hub2[0],
+                hub3[0],
+                hub3[hub3.length - 1],
+            ];
+            for (const connMan of [...hub1, ...hub2, ...hub3, ...hub4]) {
                 const mock = mocks.get(connMan);
                 const numCalls = mock.mock.calls.length;
                 const deviceId = connMan.userContext.deviceId();
@@ -410,10 +423,10 @@ describe("connection-manager", () => {
                 }
             }
             // Clean up
-            for (let connMan of [...hub1, ...hub2, ...hub3, ...hub4]) {
+            for (const connMan of [...hub1, ...hub2, ...hub3, ...hub4]) {
                 await connMan.dispose();
             }
-            for (let mock of mocks.values()) {
+            for (const mock of mocks.values()) {
                 mock.mockRestore();
             }
         });
@@ -422,13 +435,13 @@ describe("connection-manager", () => {
             const hub2 = [];
             const hub3 = [];
             const mocks = new Map();
-            for (let [i, hub] of [hub1, hub2, hub3].entries()) {
-                const hubNum = (i + 1).toString().padStart(2, '0');
+            for (const [i, hub] of [hub1, hub2, hub3].entries()) {
+                const hubNum = (i + 1).toString().padStart(2, "0");
                 for (let j = 0; j < 10; j++) {
-                    const deviceNum = (j + 1).toString().padStart(2, '0');
+                    const deviceNum = (j + 1).toString().padStart(2, "0");
                     const deviceId = `000000000hub${hubNum}000device${deviceNum}`;
                     const connMan = await connectionManagerFactory(userId, deviceId);
-                    mocks.set(connMan, jest.spyOn(connMan, 'sendDeviceMessage'));
+                    mocks.set(connMan, jest.spyOn(connMan, "sendDeviceMessage"));
                     if (j > 0) {
                         await connectDeviceManagers(hub[0], connMan);
                     }
@@ -440,9 +453,9 @@ describe("connection-manager", () => {
             await connectDeviceManagers(hub1[0], hub2[0]);
             await connectDeviceManagers(hub2[0], hub3[0]);
             await Promise.all([
-                ...hub1.map(d => d.refreshAllNetworkInfo()),
-                ...hub2.map(d => d.refreshAllNetworkInfo()),
-                ...hub3.map(d => d.refreshAllNetworkInfo()),
+                ...hub1.map((d) => d.refreshAllNetworkInfo()),
+                ...hub2.map((d) => d.refreshAllNetworkInfo()),
+                ...hub3.map((d) => d.refreshAllNetworkInfo()),
             ]);
             // send message from hub1[-1] to hub3[-1]
             const sourceConnMan = hub1[hub1.length - 1];
@@ -453,23 +466,29 @@ describe("connection-manager", () => {
                 toDeviceId: targetConnMan.userContext.deviceId(),
                 dataContextId: userId,
                 ttl: 5,
-                payload: ['getNetworkInfo'],
-                hops: []
+                payload: ["getNetworkInfo"],
+                hops: [],
             };
             const response = await sourceConnMan.sendDeviceMessage(message);
             expect(response).toBeDefined();
             expect(response.statusCode).toBe(200);
             expect(response.hops).toEqual([
-                '000000000hub01000device10',
-                '000000000hub01000device01',
-                '000000000hub02000device01',
-                '000000000hub03000device01',
-                '000000000hub03000device10',
+                "000000000hub01000device10",
+                "000000000hub01000device01",
+                "000000000hub02000device01",
+                "000000000hub03000device01",
+                "000000000hub03000device10",
             ]);
             // NOTE the blind calls only happen in the first hub. By hub2, the path is known since it's only two hops away
             //      ALSO NOTE: because of the trimming of leaf nodes, only hub1[0] is called even though MAX is 6
-            const expectCalled = [hub1[hub1.length - 1], hub1[0], hub2[0], hub3[0], hub3[hub3.length - 1]];
-            for (let connMan of [...hub1, ...hub2, ...hub3]) {
+            const expectCalled = [
+                hub1[hub1.length - 1],
+                hub1[0],
+                hub2[0],
+                hub3[0],
+                hub3[hub3.length - 1],
+            ];
+            for (const connMan of [...hub1, ...hub2, ...hub3]) {
                 const mock = mocks.get(connMan);
                 const numCalls = mock.mock.calls.length;
                 const deviceId = connMan.userContext.deviceId();
@@ -485,10 +504,10 @@ describe("connection-manager", () => {
                 }
             }
             // Clean up
-            for (let connMan of [...hub1, ...hub2, ...hub3]) {
+            for (const connMan of [...hub1, ...hub2, ...hub3]) {
                 await connMan.dispose();
             }
-            for (let mock of mocks.values()) {
+            for (const mock of mocks.values()) {
                 mock.mockRestore();
             }
         });
@@ -501,14 +520,14 @@ describe("connection-manager", () => {
             const hub4 = [];
             const mocks = new Map();
             // Create 4 hubs with 4 devices each
-            for (let [i, hub] of [hub1, hub2, hub3, hub4].entries()) {
-                const hubNum = (i + 1).toString().padStart(2, '0');
+            for (const [i, hub] of [hub1, hub2, hub3, hub4].entries()) {
+                const hubNum = (i + 1).toString().padStart(2, "0");
                 for (let j = 0; j < 7; j++) {
-                    const deviceNum = (j + 1).toString().padStart(2, '0');
+                    const deviceNum = (j + 1).toString().padStart(2, "0");
                     const deviceId = `000000000hub${hubNum}000device${deviceNum}`;
                     const connMan = await connectionManagerFactory(userId, deviceId);
                     connMan.MAX_CONNECTIONS_TO_FORWARD_MESSAGES_TO = 4;
-                    mocks.set(connMan, jest.spyOn(connMan, 'sendDeviceMessage'));
+                    mocks.set(connMan, jest.spyOn(connMan, "sendDeviceMessage"));
                     hub.push(connMan);
                 }
             }
@@ -540,10 +559,10 @@ describe("connection-manager", () => {
             // random side path from 1 to 4 to 3
             await connectDeviceManagers(hub4[0], hub3[0]);
             await Promise.all([
-                ...hub1.map(d => d.refreshAllNetworkInfo()),
-                ...hub2.map(d => d.refreshAllNetworkInfo()),
-                ...hub3.map(d => d.refreshAllNetworkInfo()),
-                ...hub4.map(d => d.refreshAllNetworkInfo()),
+                ...hub1.map((d) => d.refreshAllNetworkInfo()),
+                ...hub2.map((d) => d.refreshAllNetworkInfo()),
+                ...hub3.map((d) => d.refreshAllNetworkInfo()),
+                ...hub4.map((d) => d.refreshAllNetworkInfo()),
             ]);
             // Send message from a leaf device in hub1 to a leaf device in hub3
             const sourceConnMan = hub1[hub1.length - 1]; // Leaf device in hub1
@@ -554,14 +573,14 @@ describe("connection-manager", () => {
                 toDeviceId: targetConnMan.userContext.deviceId(),
                 dataContextId: userId,
                 ttl: 5,
-                payload: ['getNetworkInfo'],
+                payload: ["getNetworkInfo"],
                 hops: [],
             };
             const response = await sourceConnMan.sendDeviceMessage(message);
             // count number of times each connMan was called
             let totalCalls = 0;
-            let callStrs = [];
-            for (let connMan of [...hub1, ...hub2, ...hub3, ...hub4]) {
+            const callStrs = [];
+            for (const connMan of [...hub1, ...hub2, ...hub3, ...hub4]) {
                 const mock = mocks.get(connMan);
                 const numCalls = mock.mock.calls.length;
                 if (!numCalls)
@@ -594,10 +613,10 @@ describe("connection-manager", () => {
             ]);
             expect(totalCalls).toBe(21);
             // Clean up
-            for (let connMan of [...hub1, ...hub2, ...hub3, ...hub4]) {
+            for (const connMan of [...hub1, ...hub2, ...hub3, ...hub4]) {
                 await connMan.dispose();
             }
-            for (let mock of mocks.values()) {
+            for (const mock of mocks.values()) {
                 mock.mockRestore();
             }
         });
@@ -608,14 +627,14 @@ describe("connection-manager", () => {
             const hub2 = [];
             const mocks = new Map();
             // Create 2 hubs with 7 devices each
-            for (let [i, hub] of [hub1, hub2].entries()) {
-                const hubNum = (i + 1).toString().padStart(2, '0');
+            for (const [i, hub] of [hub1, hub2].entries()) {
+                const hubNum = (i + 1).toString().padStart(2, "0");
                 for (let j = 0; j < 7; j++) {
-                    const deviceNum = (j + 1).toString().padStart(2, '0');
+                    const deviceNum = (j + 1).toString().padStart(2, "0");
                     const deviceId = `000000000hub${hubNum}000device${deviceNum}`;
                     const connMan = await connectionManagerFactory(userId, deviceId);
                     connMan.MAX_CONNECTIONS_TO_FORWARD_MESSAGES_TO = 4;
-                    mocks.set(connMan, jest.spyOn(connMan, 'sendDeviceMessage'));
+                    mocks.set(connMan, jest.spyOn(connMan, "sendDeviceMessage"));
                     hub.push(connMan);
                 }
             }
@@ -635,8 +654,8 @@ describe("connection-manager", () => {
                 }
             }
             await Promise.all([
-                ...hub1.map(d => d.refreshAllNetworkInfo()),
-                ...hub2.map(d => d.refreshAllNetworkInfo()),
+                ...hub1.map((d) => d.refreshAllNetworkInfo()),
+                ...hub2.map((d) => d.refreshAllNetworkInfo()),
             ]);
             // Send message from a leaf device in hub1 to a leaf device in hub2
             const sourceConnMan = hub1[hub1.length - 1]; // Leaf device in hub1
@@ -647,14 +666,14 @@ describe("connection-manager", () => {
                 toDeviceId: targetConnMan.userContext.deviceId(),
                 dataContextId: userId,
                 ttl: 5,
-                payload: ['getNetworkInfo'],
-                hops: []
+                payload: ["getNetworkInfo"],
+                hops: [],
             };
             const response = await sourceConnMan.sendDeviceMessage(message);
             // count number of times each connMan was called
             let totalCalls = 0;
-            let callStrs = [];
-            for (let connMan of [...hub1, ...hub2]) {
+            const callStrs = [];
+            for (const connMan of [...hub1, ...hub2]) {
                 const mock = mocks.get(connMan);
                 const numCalls = mock.mock.calls.length;
                 if (!numCalls)
@@ -674,21 +693,21 @@ describe("connection-manager", () => {
             ]);
             console.log(callStrs.sort());
             expect(callStrs.sort()).toEqual([
-                'Device 000000000hub01000device01 was called 1 times',
-                'Device 000000000hub01000device02 was called 1 times',
-                'Device 000000000hub01000device03 was called 1 times',
-                'Device 000000000hub01000device04 was called 1 times',
-                'Device 000000000hub01000device07 was called 1 times',
-                'Device 000000000hub02000device01 was called 4 times',
-                'Device 000000000hub02000device02 was called 4 times',
-                'Device 000000000hub02000device07 was called 1 times'
+                "Device 000000000hub01000device01 was called 1 times",
+                "Device 000000000hub01000device02 was called 1 times",
+                "Device 000000000hub01000device03 was called 1 times",
+                "Device 000000000hub01000device04 was called 1 times",
+                "Device 000000000hub01000device07 was called 1 times",
+                "Device 000000000hub02000device01 was called 4 times",
+                "Device 000000000hub02000device02 was called 4 times",
+                "Device 000000000hub02000device07 was called 1 times",
             ]);
             expect(totalCalls).toBe(14);
             // Clean up
-            for (let connMan of [...hub1, ...hub2]) {
+            for (const connMan of [...hub1, ...hub2]) {
                 await connMan.dispose();
             }
-            for (let mock of mocks.values()) {
+            for (const mock of mocks.values()) {
                 mock.mockRestore();
             }
         });
@@ -706,8 +725,8 @@ describe("connection-manager", () => {
                     toDeviceId: connMan3.userContext.deviceId(),
                     dataContextId: userId,
                     ttl: 5,
-                    payload: ['ping', Date.now()],
-                    hops: []
+                    payload: ["ping", Date.now()],
+                    hops: [],
                 };
                 await connMan1.sendDeviceMessage(message);
                 // connMan2 should have recorded the hop path
@@ -751,8 +770,8 @@ describe("connection-manager", () => {
                     toDeviceId: iso1.userContext.deviceId(),
                     dataContextId: isolatedUserId,
                     ttl: 5,
-                    payload: ['ping', 1],
-                    hops: []
+                    payload: ["ping", 1],
+                    hops: [],
                 };
                 await iso4.sendDeviceMessage(firstMessage);
                 // Now iso2 should know about the path iso3 -> iso4 from the message hops
@@ -763,15 +782,15 @@ describe("connection-manager", () => {
                 []);
                 expect(iso2KnowsPathToIso4).toContain(iso3Id);
                 // Second message: iso1 -> iso4 should use hop-derived knowledge
-                const sendSpy = jest.spyOn(iso3, 'sendDeviceMessage');
+                const sendSpy = jest.spyOn(iso3, "sendDeviceMessage");
                 const secondMessage = {
                     deviceMessageId: (0, peers_sdk_1.newid)(),
                     fromDeviceId: iso1.userContext.deviceId(),
                     toDeviceId: iso4.userContext.deviceId(),
                     dataContextId: isolatedUserId,
                     ttl: 5,
-                    payload: ['ping', 2],
-                    hops: []
+                    payload: ["ping", 2],
+                    hops: [],
                 };
                 const response = await iso1.sendDeviceMessage(secondMessage);
                 expect(response.statusCode).toBe(200);
@@ -791,16 +810,16 @@ describe("connection-manager", () => {
                 const devices = [];
                 // Create longer chain: outer1 <-> center <-> outer2 <-> outer3
                 // This tests indirect path discovery (outer3 is 2 hops from center)
-                const center = await connectionManagerFactory(isolatedUserId, 'center-device-id-0000');
-                const outer1 = await connectionManagerFactory(isolatedUserId, 'outer1-device-id-0000');
-                const outer2 = await connectionManagerFactory(isolatedUserId, 'outer2-device-id-0000');
-                const outer3 = await connectionManagerFactory(isolatedUserId, 'outer3-device-id-0000');
+                const center = await connectionManagerFactory(isolatedUserId, "center-device-id-0000");
+                const outer1 = await connectionManagerFactory(isolatedUserId, "outer1-device-id-0000");
+                const outer2 = await connectionManagerFactory(isolatedUserId, "outer2-device-id-0000");
+                const outer3 = await connectionManagerFactory(isolatedUserId, "outer3-device-id-0000");
                 devices.push(center, outer1, outer2, outer3);
                 await connectDeviceManagers(outer1, center);
                 await connectDeviceManagers(center, outer2);
                 await connectDeviceManagers(outer2, outer3);
                 // Clear all hops data
-                devices.forEach(d => d.deviceMessages.hopsMap.clear());
+                devices.forEach((d) => d.deviceMessages.hopsMap.clear());
                 const centerId = center.userContext.deviceId();
                 const outer1Id = outer1.userContext.deviceId();
                 const outer2Id = outer2.userContext.deviceId();
@@ -813,8 +832,8 @@ describe("connection-manager", () => {
                     toDeviceId: outer1Id,
                     dataContextId: isolatedUserId,
                     ttl: 5,
-                    payload: ['ping'],
-                    hops: []
+                    payload: ["ping"],
+                    hops: [],
                 });
                 // Center should have learned about the path outer3 <-> outer2 <-> center
                 // Center's hopsMap now knows: outer3<->outer2, outer2<->center
@@ -826,25 +845,25 @@ describe("connection-manager", () => {
                 // outer2 has path to outer3 (distance 1), outer1 does not
                 expect(centerToOuter3).toContain(outer2Id);
                 expect(centerToOuter3).not.toContain(outer1Id);
-                await Promise.all(devices.map(d => d.dispose()));
+                await Promise.all(devices.map((d) => d.dispose()));
             });
             it("should prioritize shorter hop-derived paths", async () => {
                 const isolatedUserId = (0, peers_sdk_1.newid)();
                 // Create network with multiple paths of different lengths:
                 // source -> shortPath -> target (2 hops)
                 // source -> longPath1 -> longPath2 -> target (3 hops)
-                const source = await connectionManagerFactory(isolatedUserId, 'source-device-id-000');
-                const shortPath = await connectionManagerFactory(isolatedUserId, 'shortpath-device-id-0');
-                const longPath1 = await connectionManagerFactory(isolatedUserId, 'longpath1-device-id-0');
-                const longPath2 = await connectionManagerFactory(isolatedUserId, 'longpath2-device-id-0');
-                const target = await connectionManagerFactory(isolatedUserId, 'target-device-id-0000');
+                const source = await connectionManagerFactory(isolatedUserId, "source-device-id-000");
+                const shortPath = await connectionManagerFactory(isolatedUserId, "shortpath-device-id-0");
+                const longPath1 = await connectionManagerFactory(isolatedUserId, "longpath1-device-id-0");
+                const longPath2 = await connectionManagerFactory(isolatedUserId, "longpath2-device-id-0");
+                const target = await connectionManagerFactory(isolatedUserId, "target-device-id-0000");
                 await connectDeviceManagers(source, shortPath);
                 await connectDeviceManagers(source, longPath1);
                 await connectDeviceManagers(shortPath, target);
                 await connectDeviceManagers(longPath1, longPath2);
                 await connectDeviceManagers(longPath2, target);
                 // Clear hops
-                [source, shortPath, longPath1, longPath2, target].forEach(d => d.deviceMessages.hopsMap.clear());
+                [source, shortPath, longPath1, longPath2, target].forEach((d) => d.deviceMessages.hopsMap.clear());
                 // First, learn the topology by sending messages through both paths
                 // Short path message
                 await target.sendDeviceMessage({
@@ -853,8 +872,8 @@ describe("connection-manager", () => {
                     toDeviceId: source.userContext.deviceId(),
                     dataContextId: isolatedUserId,
                     ttl: 5,
-                    payload: ['learn-short'],
-                    hops: []
+                    payload: ["learn-short"],
+                    hops: [],
                 });
                 // Long path message (force it through longPath by sending from longPath2)
                 await longPath2.sendDeviceMessage({
@@ -863,24 +882,27 @@ describe("connection-manager", () => {
                     toDeviceId: source.userContext.deviceId(),
                     dataContextId: isolatedUserId,
                     ttl: 5,
-                    payload: ['learn-long'],
-                    hops: []
+                    payload: ["learn-long"],
+                    hops: [],
                 });
                 // Source should now know both paths to target
                 // When querying, it should prioritize shortPath (distance 1 to target) over longPath1 (distance 2)
-                const sourceConnections = [shortPath.userContext.deviceId(), longPath1.userContext.deviceId()];
+                const sourceConnections = [
+                    shortPath.userContext.deviceId(),
+                    longPath1.userContext.deviceId(),
+                ];
                 const candidates = source.deviceMessages.hopsMap.getDevicesLikelyToReach(target.userContext.deviceId(), sourceConnections, []);
                 // shortPath should be first (shorter distance)
                 if (candidates.length >= 2) {
                     expect(candidates[0]).toBe(shortPath.userContext.deviceId());
                 }
-                await Promise.all([source, shortPath, longPath1, longPath2, target].map(d => d.dispose()));
+                await Promise.all([source, shortPath, longPath1, longPath2, target].map((d) => d.dispose()));
             });
             it("should cleanup stale hop entries during periodic cleanup", async () => {
                 const isolatedUserId = (0, peers_sdk_1.newid)();
                 const device = await connectionManagerFactory(isolatedUserId, (0, peers_sdk_1.newid)());
                 // Manually add some hop observations
-                device.deviceMessages.hopsMap.addHopsObservation(['deviceA', 'deviceB', 'deviceC']);
+                device.deviceMessages.hopsMap.addHopsObservation(["deviceA", "deviceB", "deviceC"]);
                 expect(device.deviceMessages.hopsMap.size).toBeGreaterThan(0);
                 // Cleanup with 0ms threshold should clear everything
                 device.deviceMessages.hopsMap.cleanupStaleEntries(0);
@@ -894,7 +916,8 @@ describe("connection-manager", () => {
             const connMan1 = await connectionManagerFactory();
             const connMan2 = await connectionManagerFactory();
             await connectDeviceManagers(connMan1, connMan2);
-            const connection = Array.from(connMan1['connectionStates'].keys())[0];
+            // biome-ignore lint/complexity/useLiteralKeys: bracket access required — private `connectionStates` is not visible with dot notation from this test module
+            const connection = Array.from(connMan1["connectionStates"].keys())[0];
             const indirectIds = connMan1.getConnectionIndirectRemoteDeviceIds(connection);
             expect(indirectIds).toEqual([]);
             await Promise.all([connMan1.dispose(), connMan2.dispose()]);
@@ -917,9 +940,7 @@ describe("connection-manager", () => {
             const connection = connMan1.getDeviceConnection(connMan2.userContext.deviceId());
             expect(connection).toBeDefined();
             const indirectIds = connMan1.getConnectionIndirectRemoteDeviceIds(connection);
-            expect(indirectIds).toEqual([
-                connMan3.userContext.deviceId(),
-            ]);
+            expect(indirectIds).toEqual([connMan3.userContext.deviceId()]);
             await Promise.all([connMan1.dispose(), connMan2.dispose(), connMan3.dispose()]);
         });
         it("should exclude specified device IDs", async () => {
@@ -942,16 +963,11 @@ describe("connection-manager", () => {
                 connMan5.refreshAllNetworkInfo(),
             ]);
             const connection = connMan1.getDeviceConnection(connMan2.userContext.deviceId());
-            const excludeList = [
-                connMan3.userContext.deviceId(),
-                connMan4.userContext.deviceId(),
-            ];
+            const excludeList = [connMan3.userContext.deviceId(), connMan4.userContext.deviceId()];
             const filteredIds = connMan1.getConnectionIndirectRemoteDeviceIds(connection, excludeList);
             expect(filteredIds).not.toContain(connMan3.userContext.deviceId());
             expect(filteredIds).not.toContain(connMan4.userContext.deviceId());
-            expect(filteredIds.sort()).toEqual([
-                connMan5.userContext.deviceId(),
-            ]);
+            expect(filteredIds.sort()).toEqual([connMan5.userContext.deviceId()]);
             await Promise.all([
                 connMan1.dispose(),
                 connMan2.dispose(),
@@ -988,12 +1004,12 @@ describe("connection-manager", () => {
                 spokes.push(spoke);
                 await connectDeviceManagers(hub, spoke);
             }
-            await Promise.all([hub, ...spokes].map(cm => cm.refreshAllNetworkInfo()));
+            await Promise.all([hub, ...spokes].map((cm) => cm.refreshAllNetworkInfo()));
             // From hub's perspective, each spoke should report the hub and other spokes
             const firstSpokeConnection = hub.getDeviceConnection(spokes[0].userContext.deviceId());
             const indirectIds = hub.getConnectionIndirectRemoteDeviceIds(firstSpokeConnection);
             expect(indirectIds.sort()).toEqual([]);
-            await Promise.all([hub, ...spokes].map(cm => cm.dispose()));
+            await Promise.all([hub, ...spokes].map((cm) => cm.dispose()));
         });
         it("should return empty array when all indirect devices are excluded", async () => {
             const userId = (0, peers_sdk_1.newid)();
@@ -1025,7 +1041,7 @@ describe("connection-manager", () => {
                     await connectDeviceManagers(chain[i - 1], connMan);
                 }
             }
-            await Promise.all(chain.map(cm => cm.refreshAllNetworkInfo()));
+            await Promise.all(chain.map((cm) => cm.refreshAllNetworkInfo()));
             // From chain[0]'s perspective, check chain[1]'s indirect connections
             // chain[1] is connected to chain[0] and chain[2] so chain[0] can see chain[2] indirectly
             const connection = chain[0].getDeviceConnection(chain[1].userContext.deviceId());
@@ -1035,15 +1051,17 @@ describe("connection-manager", () => {
                 // chain[0].userContext.deviceId(),
                 chain[2].userContext.deviceId(),
             ].sort());
-            await Promise.all(chain.map(cm => cm.dispose()));
+            await Promise.all(chain.map((cm) => cm.dispose()));
         });
         it("should handle connection with no peer group devices", async () => {
             const connMan1 = await connectionManagerFactory();
             const connMan2 = await connectionManagerFactory();
             await connectDeviceManagers(connMan1, connMan2);
             // Clear peer group devices to test edge case
-            connMan1['syncGroups'] = {};
-            const connection = Array.from(connMan1['connectionStates'].keys())[0];
+            // biome-ignore lint/complexity/useLiteralKeys: private `syncGroups` — bracket access only from outside this module
+            connMan1["syncGroups"] = {};
+            // biome-ignore lint/complexity/useLiteralKeys: private `connectionStates` — bracket access only from outside this module
+            const connection = Array.from(connMan1["connectionStates"].keys())[0];
             const indirectIds = connMan1.getConnectionIndirectRemoteDeviceIds(connection);
             expect(indirectIds).toEqual([]);
             await Promise.all([connMan1.dispose(), connMan2.dispose()]);
@@ -1093,7 +1111,7 @@ describe("connection-manager", () => {
             const connMan2 = await connectionManagerFactory(userId, (0, peers_sdk_1.newid)());
             await connectDeviceManagers(connMan1, connMan2);
             const path = connMan1.getPathToDevice(connMan2.userContext.deviceId());
-            expect(path.pathType).toBe('direct');
+            expect(path.pathType).toBe("direct");
             expect(path.throughDeviceIds).toEqual([connMan1.userContext.deviceId()]);
             await Promise.all([connMan1.dispose(), connMan2.dispose()]);
         });
@@ -1101,7 +1119,7 @@ describe("connection-manager", () => {
             const connMan = await connectionManagerFactory();
             const nonExistentDeviceId = (0, peers_sdk_1.newid)();
             const path = connMan.getPathToDevice(nonExistentDeviceId);
-            expect(path.pathType).toBe('unknown');
+            expect(path.pathType).toBe("unknown");
             expect(path.throughDeviceIds).toEqual([]);
             await connMan.dispose();
         });
@@ -1119,7 +1137,7 @@ describe("connection-manager", () => {
                 connMan3.refreshAllNetworkInfo(),
             ]);
             const path = connMan1.getPathToDevice(connMan3.userContext.deviceId());
-            expect(path.pathType).toBe('indirect');
+            expect(path.pathType).toBe("indirect");
             expect(path.throughDeviceIds).toContain(connMan2.userContext.deviceId());
             await Promise.all([connMan1.dispose(), connMan2.dispose(), connMan3.dispose()]);
         });
@@ -1132,7 +1150,7 @@ describe("connection-manager", () => {
             await connectDeviceManagers(connMan2, connMan3);
             // Don't refresh network info - connMan1 won't know about connMan3
             const path = connMan1.getPathToDevice(connMan3.userContext.deviceId());
-            expect(path.pathType).toBe('unknown');
+            expect(path.pathType).toBe("unknown");
             expect(path.throughDeviceIds).toEqual([]);
             await Promise.all([connMan1.dispose(), connMan2.dispose(), connMan3.dispose()]);
         });
@@ -1149,7 +1167,7 @@ describe("connection-manager", () => {
                 connMan3.refreshAllNetworkInfo(),
             ]);
             const path = connMan1.getPathToDevice(connMan3.userContext.deviceId());
-            expect(path.pathType).not.toBe('unknown');
+            expect(path.pathType).not.toBe("unknown");
             expect(path.throughDeviceIds.length).toBeGreaterThan(0);
             await Promise.all([connMan1.dispose(), connMan2.dispose(), connMan3.dispose()]);
         });
@@ -1171,7 +1189,7 @@ describe("connection-manager", () => {
             ]);
             const path = connMan1.getPathToDevice(connMan3.userContext.deviceId());
             // Should return direct path since it checks allConnections first
-            expect(path.pathType).toBe('direct');
+            expect(path.pathType).toBe("direct");
             expect(path.throughDeviceIds).toEqual([connMan1.userContext.deviceId()]);
             await Promise.all([connMan1.dispose(), connMan2.dispose(), connMan3.dispose()]);
         });
@@ -1198,7 +1216,7 @@ describe("connection-manager", () => {
                 connMan4.refreshAllNetworkInfo(),
             ]);
             const path = connMan1.getPathToDevice(connMan4.userContext.deviceId());
-            expect(path.pathType).toBe('indirect');
+            expect(path.pathType).toBe("indirect");
             expect(path.throughDeviceIds.length).toBeGreaterThan(0);
             // Should include either connMan2 or connMan3 as intermediate device
             const hasValidPath = path.throughDeviceIds.includes(connMan2.userContext.deviceId()) ||
@@ -1222,20 +1240,20 @@ describe("connection-manager", () => {
                     await connectDeviceManagers(chain[i - 1], connMan);
                 }
             }
-            await Promise.all(chain.map(cm => cm.refreshAllNetworkInfo()));
+            await Promise.all(chain.map((cm) => cm.refreshAllNetworkInfo()));
             // Check path from chain[0] to chain[2] (2 hops away)
             const path = chain[0].getPathToDevice(chain[2].userContext.deviceId());
-            expect(path.pathType).toBe('indirect');
+            expect(path.pathType).toBe("indirect");
             expect(path.throughDeviceIds.length).toBeGreaterThan(0);
             // Should include chain[1] as intermediate device
             expect(path.throughDeviceIds).toContain(chain[1].userContext.deviceId());
-            await Promise.all(chain.map(cm => cm.dispose()));
+            await Promise.all(chain.map((cm) => cm.dispose()));
         });
         it("should return 'unknown' when device has no connections", async () => {
             const connMan = await connectionManagerFactory();
             const targetDeviceId = (0, peers_sdk_1.newid)();
             const path = connMan.getPathToDevice(targetDeviceId);
-            expect(path.pathType).toBe('unknown');
+            expect(path.pathType).toBe("unknown");
             expect(path.throughDeviceIds).toEqual([]);
             await connMan.dispose();
         });
@@ -1244,7 +1262,7 @@ describe("connection-manager", () => {
             const ownDeviceId = connMan.userContext.deviceId();
             const path = connMan.getPathToDevice(ownDeviceId);
             // Querying for own device should return unknown (not in allConnections)
-            expect(path.pathType).toBe('unknown');
+            expect(path.pathType).toBe("unknown");
             await connMan.dispose();
         });
         it("should return first non-unknown path from sync devices", async () => {
@@ -1261,7 +1279,7 @@ describe("connection-manager", () => {
             ]);
             const path = connMan1.getPathToDevice(connMan3.userContext.deviceId());
             // Should find path through syncDevice
-            expect(path.pathType).not.toBe('unknown');
+            expect(path.pathType).not.toBe("unknown");
             expect(path.throughDeviceIds.length).toBeGreaterThan(0);
             await Promise.all([connMan1.dispose(), connMan2.dispose(), connMan3.dispose()]);
         });