@peers-app/peers-sdk 0.14.0 → 0.15.0

package/dist/device/device.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Device = void 0;
-const utils_1 = require("../utils");
 const keys_1 = require("../keys");
+const utils_1 = require("../utils");
 class Device {
     userId;
     deviceId;
@@ -45,11 +45,17 @@ class Device {
         if (!response) {
             return response;
         }
-        if (typeof response === 'object' && 'contents' in response && 'nonce' in response && 'fromPublicKey' in response) {
+        if (typeof response === "object" &&
+            "contents" in response &&
+            "nonce" in response &&
+            "fromPublicKey" in response) {
             const signedResponse = this.openBoxWithSecretKey(response);
             return this.unwrapResponse(signedResponse);
         }
-        if (typeof response === 'object' && 'contents' in response && 'signature' in response && 'publicKey' in response) {
+        if (typeof response === "object" &&
+            "contents" in response &&
+            "signature" in response &&
+            "publicKey" in response) {
             const signedResponse = response;
             return (0, keys_1.openSignedObject)(signedResponse);
         }
@@ -81,7 +87,7 @@ class Device {
         try {
             const deviceInfo = (0, keys_1.openSignedObject)(remoteHandshake);
             if (remoteHandshake.publicKey !== deviceInfo.publicKey) {
-                throw new Error('Handshake signing key does not match claimed identity key');
+                throw new Error("Handshake signing key does not match claimed identity key");
             }
             if (deviceInfo.connectionId !== connectionId) {
                 throw new Error(`Invalid connectionId ${deviceInfo.connectionId}, expected ${connectionId}`);

package/dist/device/device.test.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("../utils");
 const keys_1 = require("../keys");
+const utils_1 = require("../utils");
 const device_1 = require("./device");
 describe(device_1.Device, () => {
     it("should create a new device with valid keys", async () => {
@@ -44,7 +44,7 @@ describe(device_1.Device, () => {
         describe("getHandshake", () => {
             it("should return a valid and correct handshake object", async () => {
                 const connectionId = (0, utils_1.newid)();
-                const handshake = client.getHandshake(connectionId, 'localhost');
+                const handshake = client.getHandshake(connectionId, "localhost");
                 expect(handshake.publicKey).toBe(client.publicKey);
                 expect(handshake.contents.userId).toBe(userId1);
                 expect(handshake.contents.publicKey).toBe(client.publicKey);
@@ -55,8 +55,8 @@ describe(device_1.Device, () => {
         describe("handshakeResponse", () => {
             it("should return a valid and correct handshake response object", async () => {
                 const connectionId = (0, utils_1.newid)();
-                const handshake = client.getHandshake(connectionId, 'localhost');
-                const handshakeResponse = server.handshakeResponse(handshake, connectionId, 'localhost');
+                const handshake = client.getHandshake(connectionId, "localhost");
+                const handshakeResponse = server.handshakeResponse(handshake, connectionId, "localhost");
                 expect(handshakeResponse.userId).toBe(userId2);
                 expect(handshakeResponse.deviceId).toBe(server.deviceId);
                 expect(handshakeResponse.publicKey).toBe(server.publicKey);
@@ -70,8 +70,8 @@ describe(device_1.Device, () => {
                 const c2 = {
                     connectionId: (0, utils_1.newid)(),
                 };
-                const handshake = client.getHandshake(c1.connectionId, 'localhost');
-                expect(() => server.handshakeResponse(handshake, c2.connectionId, 'localhost')).toThrow(/Invalid connectionId/);
+                const handshake = client.getHandshake(c1.connectionId, "localhost");
+                expect(() => server.handshakeResponse(handshake, c2.connectionId, "localhost")).toThrow(/Invalid connectionId/);
             });
             it("should reject a handshake signed by a different key than the one claimed in the payload (key confusion)", async () => {
                 const connectionId = (0, utils_1.newid)();
@@ -80,36 +80,35 @@ describe(device_1.Device, () => {
                 const clientImposter = new device_1.Device(userId1, client.deviceId, {
                     secretKey: (0, keys_1.newKeys)().secretKey,
                     publicKey: client.publicKey,
-                    publicBoxKey: client.publicBoxKey
+                    publicBoxKey: client.publicBoxKey,
                 });
-                const handshake = clientImposter.getHandshake(connectionId, 'localhost');
-                expect(() => server.handshakeResponse(handshake, connectionId, 'localhost'))
-                    .toThrow(/signing key does not match claimed identity key/i);
+                const handshake = clientImposter.getHandshake(connectionId, "localhost");
+                expect(() => server.handshakeResponse(handshake, connectionId, "localhost")).toThrow(/signing key does not match claimed identity key/i);
             });
             it("should detect when requests and responses are being forwarded through a different address", async () => {
                 const connToServer = {
                     connectionId: (0, utils_1.newid)(),
                 };
-                const connToClient = {
+                const _connToClient = {
                     connectionId: connToServer.connectionId,
                 };
-                const manInTheMiddle = new device_1.Device(userId2);
+                const _manInTheMiddle = new device_1.Device(userId2);
                 // const mitmAddress = manInTheMiddle.publicAddress || manInTheMiddle.localAddress;
                 // const connToManInTheMiddle = {
                 //   connectionId: connToServer.connectionId,
                 //   remoteAddress: mitmAddress
                 // };
-                // // client is being intercepted 
+                // // client is being intercepted
                 // {
                 //   expect(() => {
                 //     doHandshake(client, connToManInTheMiddle, server, connToClient);
-                //   }).toThrow(/Invalid client address/);                  
+                //   }).toThrow(/Invalid client address/);
                 // }
-                // // server is being intercepted 
+                // // server is being intercepted
                 // {
                 //   expect(() => {
                 //     doHandshake(client, connToServer, server, connToManInTheMiddle);
-                //   }).toThrow(/Invalid server address/);        
+                //   }).toThrow(/Invalid server address/);
                 // }
             });
         });
@@ -197,4 +196,4 @@ describe(ServerDevice, () => {
     });
   });
 })
-*/ 
+*/

package/dist/device/get-trust-level-fn.d.ts

@@ -1,3 +1,3 @@
-import { IDeviceInfo } from "../data";
+import { type IDeviceInfo } from "../data";
 import { TrustLevel } from "./socket.type";
-export declare function getTrustLevelFn(me: Pick<IDeviceInfo, 'userId' | 'publicKey' | 'publicBoxKey'>, serverUrl?: string): (deviceInfo: IDeviceInfo, registerNew?: boolean) => Promise<TrustLevel>;
+export declare function getTrustLevelFn(me: Pick<IDeviceInfo, "userId" | "publicKey" | "publicBoxKey">, serverUrl?: string): (deviceInfo: IDeviceInfo, _registerNew?: boolean) => Promise<TrustLevel>;

package/dist/device/get-trust-level-fn.js

@@ -5,11 +5,13 @@ const context_1 = require("../context");
 const data_1 = require("../data");
 const socket_type_1 = require("./socket.type");
 function getTrustLevelFn(me, serverUrl) {
-    return async function getTrustLevel(deviceInfo, registerNew) {
+    return async function getTrustLevel(deviceInfo, _registerNew) {
         const userContext = await (0, context_1.getUserContext)();
         const userDataContext = userContext.userDataContext;
         // if this is my own device it is trusted
-        if (deviceInfo.userId === me.userId && deviceInfo.publicKey === me.publicKey && deviceInfo.publicBoxKey === me.publicBoxKey) {
+        if (deviceInfo.userId === me.userId &&
+            deviceInfo.publicKey === me.publicKey &&
+            deviceInfo.publicBoxKey === me.publicBoxKey) {
             // if (deviceInfo.deviceId === thisDeviceId()) {
             //   return TrustLevel.Untrusted;
             // }
@@ -56,24 +58,33 @@ function getTrustLevelFn(me, serverUrl) {
                 groupUser = groupUser ?? found; // all groups sync the same signed record
                 const gtl = await (0, data_1.UserTrustLevels)(groupContext).get(deviceInfo.userId);
                 if (gtl?.trustLevel !== undefined) {
-                    groupTrustLevel = groupTrustLevel === undefined
-                        ? gtl.trustLevel
-                        : Math.min(groupTrustLevel, gtl.trustLevel);
+                    groupTrustLevel =
+                        groupTrustLevel === undefined
+                            ? gtl.trustLevel
+                            : Math.min(groupTrustLevel, gtl.trustLevel);
                 }
             }
         }
         const effectiveUser = user ?? groupUser;
-        if (effectiveUser && device && !(deviceInfo.userId === device.userId && deviceInfo.userId === effectiveUser.userId && deviceInfo.publicKey === effectiveUser.publicKey && deviceInfo.publicBoxKey === effectiveUser.publicBoxKey)) {
+        if (effectiveUser &&
+            device &&
+            !(deviceInfo.userId === device.userId &&
+                deviceInfo.userId === effectiveUser.userId &&
+                deviceInfo.publicKey === effectiveUser.publicKey &&
+                deviceInfo.publicBoxKey === effectiveUser.publicBoxKey)) {
             // deviceInfo does not align with local info about user and device, return Untrusted
             // TODO check if user has changed their public keys
             return socket_type_1.TrustLevel.Untrusted;
         }
-        if (userTrustLevel?.trustLevel && userTrustLevel.trustLevel >= socket_type_1.TrustLevel.Trusted && device?.trustLevel && device.trustLevel >= socket_type_1.TrustLevel.Trusted) {
+        if (userTrustLevel?.trustLevel &&
+            userTrustLevel.trustLevel >= socket_type_1.TrustLevel.Trusted &&
+            device?.trustLevel &&
+            device.trustLevel >= socket_type_1.TrustLevel.Trusted) {
             device.lastSeen = new Date();
             await (0, data_1.Devices)(userDataContext).save(device, { restoreIfDeleted: true });
             return socket_type_1.TrustLevel.Trusted;
         }
-        let trustLevel = device?.trustLevel ?? socket_type_1.TrustLevel.Unknown;
+        let _trustLevel = device?.trustLevel ?? socket_type_1.TrustLevel.Unknown;
         const lastSeen = new Date();
         if (!device) {
             device = {
@@ -97,7 +108,7 @@ function getTrustLevelFn(me, serverUrl) {
                 device.trustLevel = socket_type_1.TrustLevel.Known;
             }
         }
-        trustLevel = device.trustLevel;
+        _trustLevel = device.trustLevel;
         let newUser = false;
         if (!user && !groupUser) {
             // Truly unknown user — create an unsigned stub in the personal DB so
@@ -109,7 +120,7 @@ function getTrustLevelFn(me, serverUrl) {
                 publicBoxKey: deviceInfo.publicBoxKey,
                 name: serverUrl || `Unnamed_${deviceInfo.userId.substring(20)}`,
             };
-            trustLevel = socket_type_1.TrustLevel.NewUser;
+            _trustLevel = socket_type_1.TrustLevel.NewUser;
             newUser = true;
         }
         // TODO - reimplement this, checks with peers to see if this is an untrusted device
@@ -139,7 +150,7 @@ function getTrustLevelFn(me, serverUrl) {
         //     trustLevel: remoteTrustLevel,
         //     assignedAt: new Date(),
         //   }, { restoreIfDeleted: true });
-        // } 
+        // }
         if (newUser) {
             // TODO: I'm not sure we immediately want to save this user to the my personal db...
             await (0, data_1.Users)(userDataContext).save(user, {

package/dist/device/get-trust-level-fn.test.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
 const get_trust_level_fn_1 = require("./get-trust-level-fn");
 const socket_type_1 = require("./socket.type");
-const utils_1 = require("../utils");
-jest.mock('../context', () => ({
+jest.mock("../context", () => ({
     getUserContext: jest.fn(),
 }));
-jest.mock('../data', () => ({
+jest.mock("../data", () => ({
     Devices: jest.fn(),
     Users: jest.fn(),
     UserTrustLevels: jest.fn(),
@@ -56,13 +56,13 @@ function setupMocks(deviceRecord = null, userRecord = null, trustRecord = null)
     mockUserTrustLevels.mockReturnValue(trustTable);
     return { devTable, usersTable, trustTable };
 }
-describe('getTrustLevelFn', () => {
+describe("getTrustLevelFn", () => {
     beforeEach(() => {
         jest.clearAllMocks();
     });
     // ─── Own-device fast path ───────────────────────────────────────────────────
-    describe('own device (userId + publicKey + publicBoxKey all match)', () => {
-        it('returns NewDevice when device is newly seen (< 2 days old)', async () => {
+    describe("own device (userId + publicKey + publicBoxKey all match)", () => {
+        it("returns NewDevice when device is newly seen (< 2 days old)", async () => {
             const me = makeTestIdentity();
             const deviceInfo = { ...me };
             const recentDate = new Date(Date.now() - 1000 * 60 * 60 * 24); // 1 day ago
@@ -79,7 +79,7 @@ describe('getTrustLevelFn', () => {
             expect(result).toBe(socket_type_1.TrustLevel.NewDevice);
             expect(devTable.save).toHaveBeenCalledWith(expect.objectContaining({ trustLevel: socket_type_1.TrustLevel.NewDevice }), expect.objectContaining({ restoreIfDeleted: true, weakInsert: true }));
         });
-        it('returns Trusted when own device has been seen for more than 2 days', async () => {
+        it("returns Trusted when own device has been seen for more than 2 days", async () => {
             const me = makeTestIdentity();
             const deviceInfo = { ...me };
             const oldDate = new Date(Date.now() - 1000 * 60 * 60 * 24 * 3); // 3 days ago
@@ -95,21 +95,21 @@ describe('getTrustLevelFn', () => {
             const result = await getTrustLevel(deviceInfo);
             expect(result).toBe(socket_type_1.TrustLevel.Trusted);
         });
-        it('creates a new device record if own device has not been seen before', async () => {
+        it("creates a new device record if own device has not been seen before", async () => {
             const me = makeTestIdentity();
             const deviceInfo = { ...me };
             const { devTable } = setupMocks(null); // no existing device
-            const getTrustLevel = (0, get_trust_level_fn_1.getTrustLevelFn)(me, 'https://myserver.example.com');
+            const getTrustLevel = (0, get_trust_level_fn_1.getTrustLevelFn)(me, "https://myserver.example.com");
             const result = await getTrustLevel(deviceInfo);
             expect(result).toBe(socket_type_1.TrustLevel.NewDevice);
             expect(devTable.save).toHaveBeenCalledWith(expect.objectContaining({
                 deviceId: me.deviceId,
                 userId: me.userId,
-                serverUrl: 'https://myserver.example.com',
+                serverUrl: "https://myserver.example.com",
                 trustLevel: socket_type_1.TrustLevel.NewDevice,
             }), expect.objectContaining({ restoreIfDeleted: true, weakInsert: true }));
         });
-        it('does not look up Users or UserTrustLevels for own device', async () => {
+        it("does not look up Users or UserTrustLevels for own device", async () => {
             const me = makeTestIdentity();
             const deviceInfo = { ...me };
             setupMocks(null);
@@ -118,7 +118,7 @@ describe('getTrustLevelFn', () => {
             expect(mockUsers).not.toHaveBeenCalled();
             expect(mockUserTrustLevels).not.toHaveBeenCalled();
         });
-        it('updates lastSeen on every call for own device', async () => {
+        it("updates lastSeen on every call for own device", async () => {
             const me = makeTestIdentity();
             const deviceInfo = { ...me };
             const pastDate = new Date(Date.now() - 1000 * 60 * 5); // 5 minutes ago
@@ -139,8 +139,8 @@ describe('getTrustLevelFn', () => {
         });
     });
     // ─── Blocked device early exit ──────────────────────────────────────────────
-    describe('explicitly blocked device (trustLevel < Unknown)', () => {
-        it('returns Untrusted immediately without saving any records', async () => {
+    describe("explicitly blocked device (trustLevel < Unknown)", () => {
+        it("returns Untrusted immediately without saving any records", async () => {
             const me = makeTestIdentity();
             const other = makeTestIdentity();
             const blockedDevice = {
@@ -158,7 +158,7 @@ describe('getTrustLevelFn', () => {
             // Should not save anything — returns early before any writes
             expect(devTable.save).not.toHaveBeenCalled();
         });
-        it('returns Malicious immediately for malicious-flagged devices', async () => {
+        it("returns Malicious immediately for malicious-flagged devices", async () => {
             const me = makeTestIdentity();
             const other = makeTestIdentity();
             const maliciousDevice = {
@@ -175,15 +175,15 @@ describe('getTrustLevelFn', () => {
         });
     });
     // ─── Key-mismatch guard ─────────────────────────────────────────────────────
-    describe('key-mismatch guard (user AND device both exist)', () => {
-        it('returns Untrusted when publicKey does not match stored user record', async () => {
+    describe("key-mismatch guard (user AND device both exist)", () => {
+        it("returns Untrusted when publicKey does not match stored user record", async () => {
             const me = makeTestIdentity();
             const other = makeTestIdentity();
             const existingUser = {
                 userId: other.userId,
                 publicKey: `different_pk_${(0, utils_1.newid)()}`,
                 publicBoxKey: other.publicBoxKey,
-                name: 'Alice',
+                name: "Alice",
             };
             const existingDevice = {
                 deviceId: other.deviceId,
@@ -197,14 +197,14 @@ describe('getTrustLevelFn', () => {
             const result = await getTrustLevel(other);
             expect(result).toBe(socket_type_1.TrustLevel.Untrusted);
         });
-        it('returns Untrusted when publicBoxKey does not match stored user record', async () => {
+        it("returns Untrusted when publicBoxKey does not match stored user record", async () => {
             const me = makeTestIdentity();
             const other = makeTestIdentity();
             const existingUser = {
                 userId: other.userId,
                 publicKey: other.publicKey,
                 publicBoxKey: `different_pbk_${(0, utils_1.newid)()}`,
-                name: 'Alice',
+                name: "Alice",
             };
             const existingDevice = {
                 deviceId: other.deviceId,
@@ -218,14 +218,14 @@ describe('getTrustLevelFn', () => {
             const result = await getTrustLevel(other);
             expect(result).toBe(socket_type_1.TrustLevel.Untrusted);
         });
-        it('returns Untrusted when device.userId does not match deviceInfo.userId', async () => {
+        it("returns Untrusted when device.userId does not match deviceInfo.userId", async () => {
             const me = makeTestIdentity();
             const other = makeTestIdentity();
             const existingUser = {
                 userId: other.userId,
                 publicKey: other.publicKey,
                 publicBoxKey: other.publicBoxKey,
-                name: 'Alice',
+                name: "Alice",
             };
             const existingDevice = {
                 deviceId: other.deviceId,
@@ -239,7 +239,7 @@ describe('getTrustLevelFn', () => {
             const result = await getTrustLevel(other);
             expect(result).toBe(socket_type_1.TrustLevel.Untrusted);
         });
-        it('does NOT return Untrusted when only device exists (no user record yet)', async () => {
+        it("does NOT return Untrusted when only device exists (no user record yet)", async () => {
             const me = makeTestIdentity();
             const other = makeTestIdentity();
             const existingDevice = {
@@ -255,14 +255,14 @@ describe('getTrustLevelFn', () => {
             const result = await getTrustLevel(other);
             expect(result).not.toBe(socket_type_1.TrustLevel.Untrusted);
         });
-        it('does NOT return Untrusted when only user exists (no device record yet)', async () => {
+        it("does NOT return Untrusted when only user exists (no device record yet)", async () => {
             const me = makeTestIdentity();
             const other = makeTestIdentity();
             const existingUser = {
                 userId: other.userId,
                 publicKey: `different_pk_${(0, utils_1.newid)()}`, // key mismatch present but device is missing
                 publicBoxKey: other.publicBoxKey,
-                name: 'Alice',
+                name: "Alice",
             };
             // device record is null — mismatch check is skipped
             setupMocks(null, existingUser);
@@ -272,15 +272,15 @@ describe('getTrustLevelFn', () => {
         });
     });
     // ─── Trusted fast path ──────────────────────────────────────────────────────
-    describe('trusted fast path', () => {
-        it('returns Trusted immediately when device and userTrustLevel are both >= Trusted', async () => {
+    describe("trusted fast path", () => {
+        it("returns Trusted immediately when device and userTrustLevel are both >= Trusted", async () => {
             const me = makeTestIdentity();
             const other = makeTestIdentity();
             const existingUser = {
                 userId: other.userId,
                 publicKey: other.publicKey,
                 publicBoxKey: other.publicBoxKey,
-                name: 'Alice',
+                name: "Alice",
             };
             const existingDevice = {
                 deviceId: other.deviceId,
@@ -299,14 +299,14 @@ describe('getTrustLevelFn', () => {
             expect(result).toBe(socket_type_1.TrustLevel.Trusted);
             expect(devTable.save).toHaveBeenCalledWith(expect.objectContaining({ trustLevel: socket_type_1.TrustLevel.Trusted }), expect.objectContaining({ restoreIfDeleted: true }));
         });
-        it('does NOT trigger fast path when device is Trusted but userTrustLevel is not', async () => {
+        it("does NOT trigger fast path when device is Trusted but userTrustLevel is not", async () => {
             const me = makeTestIdentity();
             const other = makeTestIdentity();
             const existingUser = {
                 userId: other.userId,
                 publicKey: other.publicKey,
                 publicBoxKey: other.publicBoxKey,
-                name: 'Alice',
+                name: "Alice",
             };
             const existingDevice = {
                 deviceId: other.deviceId,
@@ -325,14 +325,14 @@ describe('getTrustLevelFn', () => {
             // save was called via the normal path (weakInsert), not the fast path
             expect(devTable.save).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ weakInsert: true }));
         });
-        it('does NOT trigger fast path when userTrustLevel is Trusted but device is not', async () => {
+        it("does NOT trigger fast path when userTrustLevel is Trusted but device is not", async () => {
             const me = makeTestIdentity();
             const other = makeTestIdentity();
             const existingUser = {
                 userId: other.userId,
                 publicKey: other.publicKey,
                 publicBoxKey: other.publicBoxKey,
-                name: 'Alice',
+                name: "Alice",
             };
             const existingDevice = {
                 deviceId: other.deviceId,
@@ -352,12 +352,12 @@ describe('getTrustLevelFn', () => {
         });
     });
     // ─── New user / new device resolution ───────────────────────────────────────
-    describe('new user and new device', () => {
-        it('returns NewDevice and saves a user stub when both user and device are unseen', async () => {
+    describe("new user and new device", () => {
+        it("returns NewDevice and saves a user stub when both user and device are unseen", async () => {
             const me = makeTestIdentity();
             const other = makeTestIdentity();
             const { devTable, usersTable } = setupMocks(null, null, null);
-            const getTrustLevel = (0, get_trust_level_fn_1.getTrustLevelFn)(me, 'https://server.example.com');
+            const getTrustLevel = (0, get_trust_level_fn_1.getTrustLevelFn)(me, "https://server.example.com");
             const result = await getTrustLevel(other);
             // The local `trustLevel` variable is set to NewUser (10), but the function returns
             // `device.trustLevel` which remains NewDevice (20). The NewUser assignment was
@@ -367,16 +367,16 @@ describe('getTrustLevelFn', () => {
                 userId: other.userId,
                 publicKey: other.publicKey,
                 publicBoxKey: other.publicBoxKey,
-                name: 'https://server.example.com',
+                name: "https://server.example.com",
             }), expect.objectContaining({ restoreIfDeleted: true, weakInsert: true }));
             expect(devTable.save).toHaveBeenCalledWith(expect.objectContaining({
                 deviceId: other.deviceId,
                 userId: other.userId,
-                serverUrl: 'https://server.example.com',
+                serverUrl: "https://server.example.com",
                 trustLevel: socket_type_1.TrustLevel.NewDevice,
             }), expect.objectContaining({ restoreIfDeleted: true, weakInsert: true }));
         });
-        it('uses a fallback name from userId suffix when serverUrl is not provided', async () => {
+        it("uses a fallback name from userId suffix when serverUrl is not provided", async () => {
             const me = makeTestIdentity();
             const other = makeTestIdentity();
             const { usersTable } = setupMocks(null, null, null);
@@ -385,14 +385,14 @@ describe('getTrustLevelFn', () => {
             const savedUser = usersTable.save.mock.calls[0][0];
             expect(savedUser.name).toBe(`Unnamed_${other.userId.substring(20)}`);
         });
-        it('does not save a user stub when user already exists', async () => {
+        it("does not save a user stub when user already exists", async () => {
             const me = makeTestIdentity();
             const other = makeTestIdentity();
             const existingUser = {
                 userId: other.userId,
                 publicKey: other.publicKey,
                 publicBoxKey: other.publicBoxKey,
-                name: 'Alice',
+                name: "Alice",
             };
             const { usersTable } = setupMocks(null, existingUser, null);
             const getTrustLevel = (0, get_trust_level_fn_1.getTrustLevelFn)(me);
@@ -401,15 +401,15 @@ describe('getTrustLevelFn', () => {
         });
     });
     // ─── Device aging ────────────────────────────────────────────────────────────
-    describe('device aging', () => {
-        it('returns NewDevice for a device first seen < 7 days ago', async () => {
+    describe("device aging", () => {
+        it("returns NewDevice for a device first seen < 7 days ago", async () => {
             const me = makeTestIdentity();
             const other = makeTestIdentity();
             const existingUser = {
                 userId: other.userId,
                 publicKey: other.publicKey,
                 publicBoxKey: other.publicBoxKey,
-                name: 'Alice',
+                name: "Alice",
             };
             const existingDevice = {
                 deviceId: other.deviceId,
@@ -423,14 +423,14 @@ describe('getTrustLevelFn', () => {
             const result = await getTrustLevel(other);
             expect(result).toBe(socket_type_1.TrustLevel.NewDevice);
         });
-        it('promotes device to Known when first seen > 7 days ago', async () => {
+        it("promotes device to Known when first seen > 7 days ago", async () => {
             const me = makeTestIdentity();
             const other = makeTestIdentity();
             const existingUser = {
                 userId: other.userId,
                 publicKey: other.publicKey,
                 publicBoxKey: other.publicBoxKey,
-                name: 'Alice',
+                name: "Alice",
             };
             const existingDevice = {
                 deviceId: other.deviceId,
@@ -445,14 +445,14 @@ describe('getTrustLevelFn', () => {
             expect(result).toBe(socket_type_1.TrustLevel.Known);
             expect(devTable.save).toHaveBeenCalledWith(expect.objectContaining({ trustLevel: socket_type_1.TrustLevel.Known }), expect.anything());
         });
-        it('bumps existing device with Unknown trust level up to NewDevice', async () => {
+        it("bumps existing device with Unknown trust level up to NewDevice", async () => {
             const me = makeTestIdentity();
             const other = makeTestIdentity();
             const existingUser = {
                 userId: other.userId,
                 publicKey: other.publicKey,
                 publicBoxKey: other.publicBoxKey,
-                name: 'Alice',
+                name: "Alice",
             };
             const existingDevice = {
                 deviceId: other.deviceId,
@@ -467,14 +467,14 @@ describe('getTrustLevelFn', () => {
             expect(result).toBe(socket_type_1.TrustLevel.NewDevice);
             expect(devTable.save).toHaveBeenCalledWith(expect.objectContaining({ trustLevel: socket_type_1.TrustLevel.NewDevice }), expect.anything());
         });
-        it('does not downgrade a device already at Known when re-evaluated before 7 days', async () => {
+        it("does not downgrade a device already at Known when re-evaluated before 7 days", async () => {
             const me = makeTestIdentity();
             const other = makeTestIdentity();
             const existingUser = {
                 userId: other.userId,
                 publicKey: other.publicKey,
                 publicBoxKey: other.publicBoxKey,
-                name: 'Alice',
+                name: "Alice",
             };
             const existingDevice = {
                 deviceId: other.deviceId,
@@ -488,14 +488,14 @@ describe('getTrustLevelFn', () => {
             const result = await getTrustLevel(other);
             expect(result).toBe(socket_type_1.TrustLevel.Known);
         });
-        it('updates lastSeen on the device record each time', async () => {
+        it("updates lastSeen on the device record each time", async () => {
             const me = makeTestIdentity();
             const other = makeTestIdentity();
             const existingUser = {
                 userId: other.userId,
                 publicKey: other.publicKey,
                 publicBoxKey: other.publicBoxKey,
-                name: 'Alice',
+                name: "Alice",
             };
             const pastDate = new Date(Date.now() - 1000 * 60 * 60); // 1 hour ago
             const existingDevice = {
@@ -515,31 +515,31 @@ describe('getTrustLevelFn', () => {
         });
     });
     // ─── Existing user, no device ────────────────────────────────────────────────
-    describe('existing user but no device record', () => {
-        it('creates a new device record with NewDevice trust level', async () => {
+    describe("existing user but no device record", () => {
+        it("creates a new device record with NewDevice trust level", async () => {
             const me = makeTestIdentity();
             const other = makeTestIdentity();
             const existingUser = {
                 userId: other.userId,
                 publicKey: other.publicKey,
                 publicBoxKey: other.publicBoxKey,
-                name: 'Alice',
+                name: "Alice",
             };
             const { devTable } = setupMocks(null, existingUser, null);
-            const getTrustLevel = (0, get_trust_level_fn_1.getTrustLevelFn)(me, 'https://relay.example.com');
+            const getTrustLevel = (0, get_trust_level_fn_1.getTrustLevelFn)(me, "https://relay.example.com");
             const result = await getTrustLevel(other);
             expect(result).toBe(socket_type_1.TrustLevel.NewDevice);
             expect(devTable.save).toHaveBeenCalledWith(expect.objectContaining({
                 deviceId: other.deviceId,
                 userId: other.userId,
-                serverUrl: 'https://relay.example.com',
+                serverUrl: "https://relay.example.com",
                 trustLevel: socket_type_1.TrustLevel.NewDevice,
             }), expect.anything());
         });
     });
     // ─── Parallel DB lookups ────────────────────────────────────────────────────
-    describe('parallel DB lookups for non-self devices', () => {
-        it('queries Users, Devices and UserTrustLevels in parallel', async () => {
+    describe("parallel DB lookups for non-self devices", () => {
+        it("queries Users, Devices and UserTrustLevels in parallel", async () => {
             const me = makeTestIdentity();
             const other = makeTestIdentity();
             setupMocks(null, null, null);

package/dist/device/socket-io-binary-peer.d.ts

@@ -7,7 +7,7 @@
  * Uses a single binary event '_bin' for all data transfer, achieving
  * ~130 MB/s throughput with proper backpressure handling.
  */
-import { IBinaryPeer } from './binary-peer-connection-v2';
+import type { IBinaryPeer } from "./binary-peer-connection-v2";
 /**
  * Minimal socket.io interface - works with both client and server sockets
  */