@peers-app/peers-device 0.15.0 → 0.15.2

package/dist/sync-group.js

@@ -25,7 +25,10 @@ class SyncGroup {
     static getNetworkInfoCount = 0;
     static electPreferredConnectionsCount = 0;
     static syncWithRemoteDeviceCount = 0;
-    static averageSyncTimeMs = { count: 0, avgTimeMs: 0 };
+    static averageSyncTimeMs = {
+        count: 0,
+        avgTimeMs: 0,
+    };
     electionInterval = null;
     preferredDeviceIds = [];
     preferredByDeviceIds = [];
@@ -81,13 +84,13 @@ class SyncGroup {
     async notifyRemoteDevicesOfChanges() {
         this.pendingChangeCount = 0;
         this.pendingChangeTimeout = null;
-        let priorityDevicesIds = this.priorityDeviceIds.priorityDeviceIds;
-        let priorityDevices = this.remoteDevices.filter(d => priorityDevicesIds.includes(d.deviceId));
+        const priorityDevicesIds = this.priorityDeviceIds.priorityDeviceIds;
+        let priorityDevices = this.remoteDevices.filter((d) => priorityDevicesIds.includes(d.deviceId));
         if (!priorityDevices.length) {
             priorityDevices = (0, lodash_1.shuffle)(this.remoteDevices);
         }
-        priorityDevices.forEach(device => {
-            device.notifyOfChanges(this.deviceId, this.timestampLastApplied).catch(err => {
+        priorityDevices.forEach((device) => {
+            device.notifyOfChanges(this.deviceId, this.timestampLastApplied).catch((err) => {
                 // console.error("error notifying remote device of changes", err);
             });
         });
@@ -99,26 +102,28 @@ class SyncGroup {
             // if we have preferred connections and this isn't one of them, don't sync
             return;
         }
-        const remoteDevice = this.remoteDevices.find(c => c.deviceId === deviceId);
-        const connection = this.connections.find(c => c.deviceId === deviceId);
-        if (!remoteDevice || !connection || (connection.timestampLastApplied ?? 0) >= timestampLastApplied) {
+        const remoteDevice = this.remoteDevices.find((c) => c.deviceId === deviceId);
+        const connection = this.connections.find((c) => c.deviceId === deviceId);
+        if (!remoteDevice ||
+            !connection ||
+            (connection.timestampLastApplied ?? 0) >= timestampLastApplied) {
             return; // device not connected or already up to date
         }
-        this.syncWithRemoteDevice(remoteDevice).catch(err => {
+        this.syncWithRemoteDevice(remoteDevice).catch((err) => {
             console.error("error syncing with remote device", err);
         });
     }
     addConnection(remoteDevice, opts) {
-        if (this.connections.some(c => c.deviceId === remoteDevice.deviceId)) {
+        if (this.connections.some((c) => c.deviceId === remoteDevice.deviceId)) {
             this.removeConnection(remoteDevice.deviceId);
         }
         const resyncInterval = opts?.resyncInterval ?? SyncGroup.RESYNC_INTERVAL;
-        if (this.remoteDevices.some(p => p.deviceId === remoteDevice.deviceId)) {
+        if (this.remoteDevices.some((p) => p.deviceId === remoteDevice.deviceId)) {
             // TODO test this, used to be just return;
-            this.remoteDevices = this.remoteDevices.filter(p => p.deviceId !== remoteDevice.deviceId);
+            this.remoteDevices = this.remoteDevices.filter((p) => p.deviceId !== remoteDevice.deviceId);
         }
         // default to max latency of existing connections or 200ms - this discourages new peers from being used until they are proven
-        const defaultLatency = (0, lodash_1.maxBy)(this.connections, 'latencyMs')?.latencyMs || 200;
+        const defaultLatency = (0, lodash_1.maxBy)(this.connections, "latencyMs")?.latencyMs || 200;
         const connection = {
             deviceId: remoteDevice.deviceId,
             latencyMs: defaultLatency,
@@ -134,7 +139,7 @@ class SyncGroup {
                 return (0, peers_sdk_1.retryOnErrorOrTimeout)({
                     connection,
                     fn: () => rawRemoteDevice.listChanges(filter, opts),
-                }).catch(err => {
+                }).catch((err) => {
                     console.error("error listing changes on remote device", err);
                     throw err;
                 });
@@ -143,7 +148,7 @@ class SyncGroup {
                 return (0, peers_sdk_1.retryOnErrorOrTimeout)({
                     connection,
                     fn: () => rawRemoteDevice.getNetworkInfo(),
-                }).catch(err => {
+                }).catch((err) => {
                     console.error("error getting network info on remote device", err);
                     throw err;
                 });
@@ -152,7 +157,7 @@ class SyncGroup {
                 return (0, peers_sdk_1.retryOnErrorOrTimeout)({
                     connection,
                     fn: () => rawRemoteDevice.notifyOfChanges(deviceId, timestampLastApplied),
-                }).catch(err => {
+                }).catch((err) => {
                     console.error("error notifying remote device of changes", err);
                     throw err;
                 });
@@ -166,16 +171,17 @@ class SyncGroup {
             }
             this.syncTimeout = setTimeout(async () => {
                 // removing connections that are too slow or have too many errors
-                if (connection.errorRate > 0.8 || connection.latencyMs > (SyncGroup.TIMEOUT_MAX / 2)) {
+                if (connection.errorRate > 0.8 || connection.latencyMs > SyncGroup.TIMEOUT_MAX / 2) {
                     console.warn(`removing connection to ${remoteDevice.deviceId} due to high error rate or latency`);
                     this.removeConnection(remoteDevice.deviceId);
                     return;
                 }
-                if (!this.connections.find(c => c.deviceId === remoteDevice.deviceId)) {
+                if (!this.connections.find((c) => c.deviceId === remoteDevice.deviceId)) {
                     return;
                 }
                 // if we have preferred connections, only sync with those
-                if (this.preferredDeviceIds.length && !this.preferredDeviceIds.includes(remoteDevice.deviceId)) {
+                if (this.preferredDeviceIds.length &&
+                    !this.preferredDeviceIds.includes(remoteDevice.deviceId)) {
                     return queueSync();
                 }
                 await this.syncWithRemoteDevice(remoteDevice).finally(queueSync);
@@ -197,18 +203,18 @@ class SyncGroup {
         return addConnectionPromise;
     }
     removeConnection(deviceId) {
-        const connection = this.connections.find(conn => conn.deviceId === deviceId);
+        const connection = this.connections.find((conn) => conn.deviceId === deviceId);
         if (!connection)
             return;
         connection.closed = true;
-        this.connections = this.connections.filter(conn => conn.deviceId !== deviceId);
-        this.remoteDevices = this.remoteDevices.filter(cd => cd.deviceId !== deviceId);
-        this.preferredByDeviceIds = this.preferredByDeviceIds.filter(id => id !== deviceId);
+        this.connections = this.connections.filter((conn) => conn.deviceId !== deviceId);
+        this.remoteDevices = this.remoteDevices.filter((cd) => cd.deviceId !== deviceId);
+        this.preferredByDeviceIds = this.preferredByDeviceIds.filter((id) => id !== deviceId);
         const isPreferred = this.preferredDeviceIds.includes(deviceId);
         connection?.onClose?.();
         delete this.cachedNetworkInfos[deviceId];
         if (isPreferred && !this.disposed) {
-            this.preferredDeviceIds = this.preferredDeviceIds.filter(id => id !== deviceId);
+            this.preferredDeviceIds = this.preferredDeviceIds.filter((id) => id !== deviceId);
             this.electPreferredConnections();
         }
     }
@@ -219,7 +225,7 @@ class SyncGroup {
             while (!networkInfo && retryCnt < 10 && !this.disposed) {
                 retryCnt++;
                 networkInfo = await Promise.race([
-                    remoteDevice.getNetworkInfo().catch(err => null),
+                    remoteDevice.getNetworkInfo().catch((err) => null),
                     (0, peers_sdk_1.sleep)(400 * retryCnt),
                 ]);
                 if (networkInfo) {
@@ -240,21 +246,22 @@ class SyncGroup {
     }
     syncPromise = Promise.resolve();
     async syncWithRemoteDevice(remoteDevice, opts) {
-        this.syncPromise = this.syncPromise.then(async () => {
+        this.syncPromise = this.syncPromise
+            .then(async () => {
             const sTime = Date.now();
             await this._syncWithRemoteDevice(remoteDevice, opts);
             const syncTime = Date.now() - sTime;
             const oldAvgTimeMs = SyncGroup.averageSyncTimeMs.avgTimeMs;
             const oldCount = SyncGroup.averageSyncTimeMs.count;
             const newCount = Math.min(oldCount + 1, 100);
-            const newAvgTimeMs = ((oldAvgTimeMs * oldCount) + syncTime) / newCount;
+            const newAvgTimeMs = (oldAvgTimeMs * oldCount + syncTime) / newCount;
             SyncGroup.averageSyncTimeMs = {
                 count: newCount,
                 avgTimeMs: newAvgTimeMs,
             };
         })
-            .catch(err => {
-            console.error('error syncing with remote device', err);
+            .catch((err) => {
+            console.error("error syncing with remote device", err);
         });
         return this.syncPromise;
     }
@@ -269,21 +276,22 @@ class SyncGroup {
                 timestampAppliedLast: 0,
             };
         }
-        const connection = this.connections.find(c => c.deviceId === remoteDevice.deviceId);
+        const connection = this.connections.find((c) => c.deviceId === remoteDevice.deviceId);
         if (connection && !connection.timestampLastApplied && syncInfo.timestampAppliedLast) {
             connection.timestampLastApplied = syncInfo.timestampAppliedLast;
         }
-        const networkInfoStart = opts?.networkInfo || await this.getRemoteNetworkInfo(remoteDevice, { force: true });
-        if (connection?.timestampLastApplied && networkInfoStart.timestampLastApplied <= connection.timestampLastApplied) {
+        const networkInfoStart = opts?.networkInfo || (await this.getRemoteNetworkInfo(remoteDevice, { force: true }));
+        if (connection?.timestampLastApplied &&
+            networkInfoStart.timestampLastApplied <= connection.timestampLastApplied) {
             return; // already synced
         }
         // Sync table definitions so we know about all table schemas before applying other changes
         // Also sync groups first so they are as up-to-date as possible (security and sync performance)
-        const tablesToSyncFirst = ['TableDefinitions', 'Groups'];
+        const tablesToSyncFirst = ["TableDefinitions", "Groups"];
         const tableAndGroupChanges = await remoteDevice.listChanges({
             supersededAt: { $exists: false },
             appliedAt: { $gte: syncInfo.timestampAppliedLast },
-            tableName: { $in: tablesToSyncFirst }
+            tableName: { $in: tablesToSyncFirst },
         });
         if (tableAndGroupChanges.length) {
             console.warn(`table definitions and/or group changes found ${tableAndGroupChanges.length}, applying first`);
@@ -300,7 +308,7 @@ class SyncGroup {
         const startTime = Date.now();
         const batchSize = (0, lodash_1.clamp)(opts?.pageSize ?? SyncGroup.CHANGES_PAGE_SIZE, 2, 50_000);
         const changeCursor = (0, peers_sdk_1.dataSourceCursor)({
-            primaryKeyName: 'changeId',
+            primaryKeyName: "changeId",
             list: remoteDevice.listChanges.bind(remoteDevice),
         }, {
             // If we decide to support change history preservation, we'll need to set this conditionally
@@ -309,15 +317,15 @@ class SyncGroup {
                 { appliedAt: { $gte: syncInfo.timestampAppliedLast } },
                 // We don't want to go past the current applied changes because we might skip changes that are actively being synced from other device to the remote device
                 { appliedAt: { $lte: networkInfoStart.timestampLastApplied } },
-                { tableName: { $nin: tablesToSyncFirst } }
-            ]
-        }, { sortBy: ['createdAt'], pageSize: batchSize });
+                { tableName: { $nin: tablesToSyncFirst } },
+            ],
+        }, { sortBy: ["createdAt"], pageSize: batchSize });
         const changeBatch = [];
         let maxTimestampApplied = syncInfo.timestampAppliedLast;
         let totalChangesSynced = 0;
         const applyBatch = async () => {
             if (changeBatch.length) {
-                maxTimestampApplied = (0, lodash_1.max)([maxTimestampApplied, ...changeBatch.map(c => c.appliedAt)]);
+                maxTimestampApplied = (0, lodash_1.max)([maxTimestampApplied, ...changeBatch.map((c) => c.appliedAt)]);
                 const sTime = Date.now();
                 await this.applyChanges(changeBatch, remoteDevice);
                 totalChangesSynced += changeBatch.length;
@@ -346,7 +354,7 @@ class SyncGroup {
         if (connection) {
             connection.timestampLastApplied = syncInfo.timestampAppliedLast;
         }
-        // transitive device syncing 
+        // transitive device syncing
         for (const conn of networkInfoStart.connections) {
             if (!conn.timestampLastApplied) {
                 continue;
@@ -367,21 +375,28 @@ class SyncGroup {
     }
     async applyChanges(changes, remoteDevice) {
         const tableTimestamps = {};
-        changes.forEach(c => {
+        changes.forEach((c) => {
             if (c.createdAt < (tableTimestamps[c.tableName] || Number.MAX_VALUE)) {
                 tableTimestamps[c.tableName] = c.createdAt;
             }
         });
         // always load Users, Devices, Groups, PersistentVars, PeerTypes, Packages, and TableDefinitions first since they can affect how other tables are handled
         const tableNames = (0, lodash_1.sortBy)(Object.keys(tableTimestamps), (t) => {
-            return t === "Users" ? -7 :
-                t === "Devices" ? -6 :
-                    t === "Groups" ? -5 :
-                        t === "PersistentVars" ? -4 :
-                            t === "PeerTypes" ? -3 :
-                                t === "Packages" ? -2 :
-                                    t === "Files" ? 0 :
-                                        tableTimestamps[t];
+            return t === "Users"
+                ? -7
+                : t === "Devices"
+                    ? -6
+                    : t === "Groups"
+                        ? -5
+                        : t === "PersistentVars"
+                            ? -4
+                            : t === "PeerTypes"
+                                ? -3
+                                : t === "Packages"
+                                    ? -2
+                                    : t === "Files"
+                                        ? 0
+                                        : tableTimestamps[t];
         });
         const tables = (0, lodash_1.keyBy)(this.tableContainer.getAllTables(), "tableName");
         // WARNING: by grouping changes by table name, we're not necessarily applying them in the order they were created
@@ -396,14 +411,14 @@ class SyncGroup {
             }
             const table = tables[tableName];
             let ds = table;
-            while (typeof ds?.applyChanges !== 'function' && ds.dataSource) {
+            while (typeof ds?.applyChanges !== "function" && ds.dataSource) {
                 ds = ds.dataSource;
             }
-            if (typeof ds?.applyChanges !== 'function') {
+            if (typeof ds?.applyChanges !== "function") {
                 console.warn(`Table or underlying data sources does not have an applyChanges function: ${tableName} - cannot continue with applyChanges`);
                 continue;
             }
-            const tableChanges = changes.filter(c => c.tableName === tableName);
+            const tableChanges = changes.filter((c) => c.tableName === tableName);
             await ds.applyChanges(tableChanges, remoteDevice, this.dataContext);
             SyncGroup.applyChangesCount++;
         }
@@ -422,7 +437,7 @@ class SyncGroup {
      */
     async resolveInsertChangeValues(changes) {
         // Find insert changes that need resolution (value is null/undefined)
-        const insertChanges = changes.filter(c => c.op === 'set' && c.path === '/' && (c.value === null || c.value === undefined));
+        const insertChanges = changes.filter((c) => c.op === "set" && c.path === "/" && (c.value === null || c.value === undefined));
         if (insertChanges.length === 0)
             return;
         // Group by tableName so we can batch-lookup from the right table
@@ -446,7 +461,7 @@ class SyncGroup {
                 }
             }
             const tableChanges = byTable[tableName];
-            const recordIds = [...new Set(tableChanges.map(c => c.recordId))];
+            const recordIds = [...new Set(tableChanges.map((c) => c.recordId))];
             const primaryKeyName = table.primaryKeyName || table.dataSource?.primaryKeyName;
             try {
                 const records = await table.list({
@@ -473,7 +488,7 @@ class SyncGroup {
         if (this.electionInterval) {
             clearInterval(this.electionInterval);
         }
-        this.connections.forEach(c => {
+        this.connections.forEach((c) => {
             this.removeConnection(c.deviceId);
         });
         this.connections.length = 0;
@@ -486,7 +501,7 @@ class SyncGroup {
     async getNetworkInfo() {
         SyncGroup.getNetworkInfoCount++;
         if (!this.timestampLastApplied) {
-            const lastChangesApplied = await this.changeTrackingTable.list({}, { sortBy: ['-appliedAt'], pageSize: 1 });
+            const lastChangesApplied = await this.changeTrackingTable.list({}, { sortBy: ["-appliedAt"], pageSize: 1 });
             if (lastChangesApplied.length) {
                 this.timestampLastApplied = lastChangesApplied[0].appliedAt;
             }
@@ -495,7 +510,7 @@ class SyncGroup {
         const networkInfo = {
             deviceId: this.deviceId,
             timestampLastApplied: this.timestampLastApplied,
-            connections: this.connections.map(c => {
+            connections: this.connections.map((c) => {
                 const connData = { ...c };
                 delete connData.onClose;
                 return connData;
@@ -503,7 +518,7 @@ class SyncGroup {
             preferredDeviceIds: [...this.preferredDeviceIds],
             cpuPercent: _machineStats.cpu.average,
             memPercent: _machineStats.memory.current,
-            connectionSlotsAvailable: 0, // set by connection manager      
+            connectionSlotsAvailable: 0, // set by connection manager
         };
         return networkInfo;
     }
@@ -531,42 +546,44 @@ class SyncGroup {
     }
     async _electPreferredConnections() {
         SyncGroup.electPreferredConnectionsCount++;
-        if (this.preferredDeviceIds.length && this.preferredDeviceIds.every((id) => this.connections.find(c => c.deviceId === id))) {
+        if (this.preferredDeviceIds.length &&
+            this.preferredDeviceIds.every((id) => this.connections.find((c) => c.deviceId === id))) {
             // if we already have preferred connections, chill out for a bit
-            // in testing, waiting 20ms before re-electing seems to help prevent overabundance of elections      
+            // in testing, waiting 20ms before re-electing seems to help prevent overabundance of elections
             // await sleep(20 * Math.random());
         }
-        const allNetworkInfo = (await Promise.all(this.remoteDevices.map(d => this.getRemoteNetworkInfo(d).catch(err => null))))
-            .filter(d => d);
+        const allNetworkInfo = (await Promise.all(this.remoteDevices.map((d) => this.getRemoteNetworkInfo(d).catch((err) => null)))).filter((d) => d);
         const myConnections = this.getConnections();
         const electionResult = (0, peers_sdk_1.electDevices)({
             deviceId: this.deviceId,
             myConnections,
             allNetworkInfo,
         });
-        const newPreferredDeviceIds = electionResult.preferredDeviceIds.filter(id => !this.preferredDeviceIds.includes(id));
+        const newPreferredDeviceIds = electionResult.preferredDeviceIds.filter((id) => !this.preferredDeviceIds.includes(id));
         this.preferredDeviceIds = electionResult.preferredDeviceIds;
         this.preferredByDeviceIds = electionResult.preferredByDeviceIds;
         for (const deviceId of newPreferredDeviceIds) {
-            const remoteDevice = this.remoteDevices.find(c => c.deviceId === deviceId);
+            const remoteDevice = this.remoteDevices.find((c) => c.deviceId === deviceId);
             if (remoteDevice) {
-                const networkInfo = allNetworkInfo.find(c => c.deviceId === deviceId);
-                await this.syncWithRemoteDevice(remoteDevice, { networkInfo }).catch(err => {
+                const networkInfo = allNetworkInfo.find((c) => c.deviceId === deviceId);
+                await this.syncWithRemoteDevice(remoteDevice, { networkInfo }).catch((err) => {
                     console.error("error syncing with remote device", err);
                 });
             }
         }
     }
     async getRemoteNetworkInfo(device, opts) {
-        const deviceId = typeof device === 'string' ? device : device.deviceId;
+        const deviceId = typeof device === "string" ? device : device.deviceId;
         // if (1 + 1 === 2) {
         //   return this.remoteDevices.find(d => d.deviceId === deviceId)!.getNetworkInfo();
         // }
         const cachedNetworkInfo = this.cachedNetworkInfos[deviceId];
-        if (!opts?.force && cachedNetworkInfo && (Date.now() - cachedNetworkInfo.lastUpdated) < SyncGroup.NETWORK_INFO_CACHE_TIME) {
+        if (!opts?.force &&
+            cachedNetworkInfo &&
+            Date.now() - cachedNetworkInfo.lastUpdated < SyncGroup.NETWORK_INFO_CACHE_TIME) {
             return cachedNetworkInfo.networkInfo;
         }
-        const remoteDevice = typeof device !== 'string' ? device : this.remoteDevices.find(c => c.deviceId === deviceId);
+        const remoteDevice = typeof device !== "string" ? device : this.remoteDevices.find((c) => c.deviceId === deviceId);
         if (!remoteDevice) {
             throw new Error(`Device not connected: ${deviceId}`);
         }
@@ -575,10 +592,12 @@ class SyncGroup {
             networkInfo: networkInfoPromise,
             lastUpdated: Date.now(),
         };
-        return networkInfoPromise.then(networkInfo => {
+        return networkInfoPromise
+            .then((networkInfo) => {
             this.rebuildNetworkMap();
             return networkInfo;
-        }).catch(err => {
+        })
+            .catch((err) => {
             delete this.cachedNetworkInfos[deviceId];
             throw err;
         });
@@ -604,7 +623,7 @@ class SyncGroup {
             return [];
         }
         // Delete all orphaned entries in a single SQL call
-        const placeholders = orphanedTableNames.map(() => '?').join(', ');
+        const placeholders = orphanedTableNames.map(() => "?").join(", ");
         await db.exec(`DELETE FROM "${changeTrackingTableName}" WHERE tableName IN (${placeholders})`, orphanedTableNames);
         for (const tableName of orphanedTableNames) {
             console.log(`Cleaned up orphaned change tracking entries for deleted table: ${tableName}`);
@@ -620,7 +639,7 @@ class SyncGroup {
         try {
             const orphaned = await this.cleanupOrphanedChangeTrackingEntries();
             if (orphaned.length > 0) {
-                console.log(`Cleaned up orphaned change tracking entries for ${orphaned.length} deleted table(s): ${orphaned.join(', ')}`);
+                console.log(`Cleaned up orphaned change tracking entries for ${orphaned.length} deleted table(s): ${orphaned.join(", ")}`);
             }
         }
         catch (err) {
@@ -630,11 +649,14 @@ class SyncGroup {
         const dataLocksTableName = (0, peers_sdk_1.DataLocks)(this.dataContext).tableName;
         try {
             const changeTrackingTableId = this.changeTrackingTable.metaData.name;
-            const oneDayAgoMs = Date.now() - (24 * 60 * 60 * 1000);
+            const oneDayAgoMs = Date.now() - 24 * 60 * 60 * 1000;
             // ensure tables are initialized
             await this.changeTrackingTable.initTable();
             await (0, peers_sdk_1.DataLocks)().list({}, { pageSize: 1 });
-            await db.exec(`DELETE FROM ${changeTrackingTableId} WHERE tableName = ? AND createdAt < ?`, [dataLocksTableName, oneDayAgoMs]);
+            await db.exec(`DELETE FROM ${changeTrackingTableId} WHERE tableName = ? AND createdAt < ?`, [
+                dataLocksTableName,
+                oneDayAgoMs,
+            ]);
             await db.exec(`DELETE FROM ${dataLocksTableName} WHERE lockedUntil < ?`, [oneDayAgoMs]);
         }
         catch (err) {
@@ -720,7 +742,7 @@ class SyncGroup {
                 hops: message.hops,
             };
         }
-        if ((0, lodash_1.isEqual)(message.payload, ['getNetworkInfo'])) {
+        if ((0, lodash_1.isEqual)(message.payload, ["getNetworkInfo"])) {
             return {
                 statusCode: 200,
                 statusMessage: "OK",
@@ -728,12 +750,12 @@ class SyncGroup {
                 payload: await this.getNetworkInfo(),
             };
         }
-        if ((0, lodash_1.isArray)(message.payload) && (0, lodash_1.isEqual)(message.payload[0], 'ping')) {
+        if ((0, lodash_1.isArray)(message.payload) && (0, lodash_1.isEqual)(message.payload[0], "ping")) {
             return {
                 statusCode: 200,
                 statusMessage: "OK",
                 hops: message.hops,
-                payload: ['pong', Date.now(), ...message.payload.slice(1)],
+                payload: ["pong", Date.now(), ...message.payload.slice(1)],
             };
         }
         // default behavior
@@ -750,11 +772,11 @@ class SyncGroup {
         const networkMap = {};
         const NETWORK_INFO_MAX_AGE = SyncGroup.RESYNC_INTERVAL + SyncGroup.TIMEOUT_MAX;
         for (const [deviceId, cachedNetworkInfo] of Object.entries(this.cachedNetworkInfos)) {
-            if ((Date.now() - cachedNetworkInfo.lastUpdated) > NETWORK_INFO_MAX_AGE) {
+            if (Date.now() - cachedNetworkInfo.lastUpdated > NETWORK_INFO_MAX_AGE) {
                 continue;
             }
-            const networkInfo = await cachedNetworkInfo.networkInfo.catch(err => undefined);
-            networkInfo?.connections.forEach(c => {
+            const networkInfo = await cachedNetworkInfo.networkInfo.catch((err) => undefined);
+            networkInfo?.connections.forEach((c) => {
                 networkMap[c.deviceId] ??= new Set();
                 networkMap[c.deviceId].add(deviceId);
                 networkMap[deviceId] ??= new Set();
@@ -764,25 +786,25 @@ class SyncGroup {
         this.networkMap = networkMap;
     }
     getPathToDevice(deviceId) {
-        if (this.connections.some(c => c.deviceId === deviceId)) {
+        if (this.connections.some((c) => c.deviceId === deviceId)) {
             return {
-                pathType: 'direct',
+                pathType: "direct",
                 throughDeviceIds: [this.deviceId],
             };
         }
         if (this.networkMap[deviceId]?.size) {
             return {
-                pathType: 'indirect',
-                throughDeviceIds: Array.from(this.networkMap[deviceId].values())
+                pathType: "indirect",
+                throughDeviceIds: Array.from(this.networkMap[deviceId].values()),
             };
         }
         return {
-            pathType: 'unknown',
-            throughDeviceIds: []
+            pathType: "unknown",
+            throughDeviceIds: [],
         };
     }
     reportRemoteDeviceConnectedIds(deviceId, connectedDeviceIds) {
-        this.networkMap[deviceId]?.forEach(connectedDeviceId => {
+        this.networkMap[deviceId]?.forEach((connectedDeviceId) => {
             connectedDeviceIds.add(connectedDeviceId);
         });
     }