@peers-app/peers-sdk 0.14.0 → 0.15.0

package/dist/device/binary-peer-connection-v2.test.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const keys_1 = require("../keys");
-const device_1 = require("./device");
 const utils_1 = require("../utils");
 const binary_peer_connection_v2_1 = require("./binary-peer-connection-v2");
+const device_1 = require("./device");
 // Mock binary peer for testing - simulates WebRTC peers
 class MockBinaryPeer {
     dataHandlers = [];
@@ -12,27 +12,30 @@ class MockBinaryPeer {
     otherPeer;
     _bufferedAmount = 0;
     on(event, handler) {
-        if (event === 'data') {
+        if (event === "data") {
             this.dataHandlers.push(handler);
         }
-        else if (event === 'close') {
+        else if (event === "close") {
             this.closeHandlers.push(handler);
         }
-        else if (event === 'drain') {
+        else if (event === "drain") {
             this.drainHandlers.push(handler);
         }
     }
     send(data) {
         if (this.otherPeer) {
-            const bytes = typeof data === 'string'
+            const bytes = typeof data === "string"
                 ? Buffer.from(data)
                 : Buffer.isBuffer(data)
                     ? data
                     : Buffer.from(data);
             // Simulate async delivery
             setImmediate(() => {
-                for (const handler of this.otherPeer.dataHandlers) {
-                    handler(bytes);
+                const handlers = this.otherPeer?.dataHandlers;
+                if (handlers) {
+                    for (const handler of handlers) {
+                        handler(bytes);
+                    }
                 }
             });
         }
@@ -57,29 +60,29 @@ async function getMockPeerPair() {
     await (0, utils_1.sleep)(10);
     return { iPeer, rPeer };
 }
-describe('binary-peer-connection-v2', () => {
-    describe('MockBinaryPeer', () => {
-        it('should exchange data between mock peers', async () => {
+describe("binary-peer-connection-v2", () => {
+    describe("MockBinaryPeer", () => {
+        it("should exchange data between mock peers", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
-            let iPeerDataReceived = '';
-            iPeer.on('data', (data) => {
+            let iPeerDataReceived = "";
+            iPeer.on("data", (data) => {
                 iPeerDataReceived += data.toString();
             });
-            let rPeerDataReceived = '';
-            rPeer.on('data', (data) => {
+            let rPeerDataReceived = "";
+            rPeer.on("data", (data) => {
                 rPeerDataReceived += data.toString();
             });
-            rPeer.send('rPeer');
-            iPeer.send('iPeer');
+            rPeer.send("rPeer");
+            iPeer.send("iPeer");
             await (0, utils_1.sleep)(50);
-            expect(iPeerDataReceived).toBe('rPeer');
-            expect(rPeerDataReceived).toBe('iPeer');
+            expect(iPeerDataReceived).toBe("rPeer");
+            expect(rPeerDataReceived).toBe("iPeer");
             iPeer.destroy();
             rPeer.destroy();
         });
     });
-    describe('createBinaryPeerSocket RPC', () => {
-        it('should do RPC emit/on round-trip', async () => {
+    describe("createBinaryPeerSocket RPC", () => {
+        it("should do RPC emit/on round-trip", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
             const socketA = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("a", iPeer, "ws");
             const socketB = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("b", rPeer, "ws");
@@ -98,7 +101,7 @@ describe('binary-peer-connection-v2', () => {
             iPeer.destroy();
             rPeer.destroy();
         });
-        it('should handle RPC errors', async () => {
+        it("should handle RPC errors", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
             const socketA = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("a", iPeer, "ws");
             const socketB = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("b", rPeer, "ws");
@@ -114,14 +117,18 @@ describe('binary-peer-connection-v2', () => {
             iPeer.destroy();
             rPeer.destroy();
         });
-        it('should handle Uint8Array args without txEncode', async () => {
+        it("should handle Uint8Array args without txEncode", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
             const socketA = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("a", iPeer, "ws");
             const socketB = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("b", rPeer, "ws");
             const testPayload = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
             socketB.on("binary-event", (args, callback) => {
                 const received = args instanceof Uint8Array ? args : new Uint8Array(args);
-                callback(null, { size: received.length, first: received[0], last: received[received.length - 1] });
+                callback(null, {
+                    size: received.length,
+                    first: received[0],
+                    last: received[received.length - 1],
+                });
             });
             const result = await new Promise((resolve, reject) => {
                 socketA.emit("binary-event", testPayload, (err, res) => {
@@ -137,7 +144,7 @@ describe('binary-peer-connection-v2', () => {
             iPeer.destroy();
             rPeer.destroy();
         });
-        it('should handle Uint8Array response without txEncode', async () => {
+        it("should handle Uint8Array response without txEncode", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
             const socketA = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("a", iPeer, "ws");
             const socketB = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("b", rPeer, "ws");
@@ -159,7 +166,7 @@ describe('binary-peer-connection-v2', () => {
             iPeer.destroy();
             rPeer.destroy();
         });
-        it('should chunk large RPC messages (>maxFramePayload)', async () => {
+        it("should chunk large RPC messages (>maxFramePayload)", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
             // Use 'wrtc' to get 64KB maxFramePayload
             const socketA = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("a", iPeer, "wrtc");
@@ -186,7 +193,7 @@ describe('binary-peer-connection-v2', () => {
             iPeer.destroy();
             rPeer.destroy();
         });
-        it('should handle large RPC response (>maxFramePayload)', async () => {
+        it("should handle large RPC response (>maxFramePayload)", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
             const socketA = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("a", iPeer, "wrtc");
             const socketB = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("b", rPeer, "wrtc");
@@ -212,7 +219,7 @@ describe('binary-peer-connection-v2', () => {
             iPeer.destroy();
             rPeer.destroy();
         });
-        it('should handle concurrent RPC calls correctly', async () => {
+        it("should handle concurrent RPC calls correctly", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
             const socketA = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("a", iPeer, "ws");
             const socketB = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("b", rPeer, "ws");
@@ -232,32 +239,32 @@ describe('binary-peer-connection-v2', () => {
             }
             const results = await Promise.all(promises);
             for (let i = 0; i < 10; i++) {
-                const r = results.find(r => r.id === i);
+                const r = results.find((r) => r.id === i);
                 expect(r).toBeDefined();
-                expect(r.value).toBe(i * 10 * 2);
+                expect(r?.value).toBe(i * 10 * 2);
             }
             iPeer.destroy();
             rPeer.destroy();
         });
     });
-    describe('createBinaryPeerSocket raw bytes (stream mode)', () => {
-        it('should send/receive raw bytes', async () => {
+    describe("createBinaryPeerSocket raw bytes (stream mode)", () => {
+        it("should send/receive raw bytes", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
             const socketA = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("a", iPeer, "ws");
             const socketB = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("b", rPeer, "ws");
             const testData = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
             const received = new Promise((resolve) => {
-                socketB.onRawBytes("test-stream", (data) => {
+                socketB.onRawBytes?.("test-stream", (data) => {
                     resolve(data);
                 });
             });
-            await socketA.sendRawBytes("test-stream", testData);
+            await socketA.sendRawBytes?.("test-stream", testData);
             const result = await received;
             expect(Buffer.from(result)).toEqual(Buffer.from(testData));
             iPeer.destroy();
             rPeer.destroy();
         });
-        it('should multiplex multiple streams', async () => {
+        it("should multiplex multiple streams", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
             const socketA = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("a", iPeer, "ws");
             const socketB = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("b", rPeer, "ws");
@@ -265,18 +272,18 @@ describe('binary-peer-connection-v2', () => {
                 "stream-alpha": [],
                 "stream-beta": [],
             };
-            socketB.onRawBytes("stream-alpha", (data) => results["stream-alpha"].push(new Uint8Array(data)));
-            socketB.onRawBytes("stream-beta", (data) => results["stream-beta"].push(new Uint8Array(data)));
-            await socketA.sendRawBytes("stream-alpha", new Uint8Array([10, 20, 30]));
-            await socketA.sendRawBytes("stream-beta", new Uint8Array([40, 50, 60]));
-            await socketA.sendRawBytes("stream-alpha", new Uint8Array([70, 80, 90]));
+            socketB.onRawBytes?.("stream-alpha", (data) => results["stream-alpha"].push(new Uint8Array(data)));
+            socketB.onRawBytes?.("stream-beta", (data) => results["stream-beta"].push(new Uint8Array(data)));
+            await socketA.sendRawBytes?.("stream-alpha", new Uint8Array([10, 20, 30]));
+            await socketA.sendRawBytes?.("stream-beta", new Uint8Array([40, 50, 60]));
+            await socketA.sendRawBytes?.("stream-alpha", new Uint8Array([70, 80, 90]));
             await (0, utils_1.sleep)(100);
             expect(results["stream-alpha"].length).toBe(2);
             expect(results["stream-beta"].length).toBe(1);
             iPeer.destroy();
             rPeer.destroy();
         });
-        it('should chunk large stream data (>maxFramePayload)', async () => {
+        it("should chunk large stream data (>maxFramePayload)", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
             // Use wrtc for 64KB max frame size
             const socketA = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("a", iPeer, "wrtc");
@@ -286,11 +293,11 @@ describe('binary-peer-connection-v2', () => {
                 largeData[i] = i % 256;
             }
             const received = new Promise((resolve) => {
-                socketB.onRawBytes("large-stream", (data) => {
+                socketB.onRawBytes?.("large-stream", (data) => {
                     resolve(data);
                 });
             });
-            await socketA.sendRawBytes("large-stream", largeData);
+            await socketA.sendRawBytes?.("large-stream", largeData);
             const result = await received;
             expect(result.length).toBe(largeData.length);
             // Verify content
@@ -301,25 +308,27 @@ describe('binary-peer-connection-v2', () => {
             iPeer.destroy();
             rPeer.destroy();
         });
-        it('should remove raw bytes handlers', async () => {
+        it("should remove raw bytes handlers", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
             const socketA = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("a", iPeer, "ws");
             const socketB = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("b", rPeer, "ws");
             let callCount = 0;
-            socketB.onRawBytes("temp-stream", () => { callCount++; });
-            await socketA.sendRawBytes("temp-stream", new Uint8Array([1]));
+            socketB.onRawBytes?.("temp-stream", () => {
+                callCount++;
+            });
+            await socketA.sendRawBytes?.("temp-stream", new Uint8Array([1]));
             await (0, utils_1.sleep)(50);
             expect(callCount).toBe(1);
-            socketB.removeRawBytesHandler("temp-stream");
-            await socketA.sendRawBytes("temp-stream", new Uint8Array([2]));
+            socketB.removeRawBytesHandler?.("temp-stream");
+            await socketA.sendRawBytes?.("temp-stream", new Uint8Array([2]));
             await (0, utils_1.sleep)(50);
             expect(callCount).toBe(1); // Should not have increased
             iPeer.destroy();
             rPeer.destroy();
         });
     });
-    describe('stats tracking', () => {
-        it('should track bytes sent and received', async () => {
+    describe("stats tracking", () => {
+        it("should track bytes sent and received", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
             const socketA = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("a", iPeer, "ws");
             const socketB = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("b", rPeer, "ws");
@@ -334,27 +343,31 @@ describe('binary-peer-connection-v2', () => {
                         resolve(res);
                 });
             });
-            expect(socketA.stats.bytesSent).toBeGreaterThan(0);
-            expect(socketA.stats.messagesSent).toBeGreaterThan(0);
-            expect(socketB.stats.bytesReceived).toBeGreaterThan(0);
-            expect(socketB.stats.messagesReceived).toBeGreaterThan(0);
+            expect(socketA.stats?.bytesSent).toBeGreaterThan(0);
+            expect(socketA.stats?.messagesSent).toBeGreaterThan(0);
+            expect(socketB.stats?.bytesReceived).toBeGreaterThan(0);
+            expect(socketB.stats?.messagesReceived).toBeGreaterThan(0);
             iPeer.destroy();
             rPeer.destroy();
         });
     });
-    describe('wrapBinaryPeer', () => {
-        it('should successfully handshake over wrtc protocol', async () => {
+    describe("wrapBinaryPeer", () => {
+        it("should successfully handshake over wrtc protocol", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
             const userId = `00000000000000000user001`;
             const keys = (0, keys_1.newKeys)();
             const connectionId = `00000000000000000conn001`;
             const iPeerDeviceId = `000000000000000device001`;
             const iPeerDevice = new device_1.Device(userId, iPeerDeviceId, keys);
-            const iPeerConnection = (0, binary_peer_connection_v2_1.wrapBinaryPeer)(connectionId, iPeer, iPeerDevice, true, { protocol: 'wrtc' });
+            const iPeerConnection = (0, binary_peer_connection_v2_1.wrapBinaryPeer)(connectionId, iPeer, iPeerDevice, true, {
+                protocol: "wrtc",
+            });
             const rPeerDeviceId = `000000000000000device002`;
             const rPeerDevice = new device_1.Device(userId, rPeerDeviceId, keys);
-            const rPeerConnection = (0, binary_peer_connection_v2_1.wrapBinaryPeer)(connectionId, rPeer, rPeerDevice, false, { protocol: 'wrtc' });
-            await iPeerConnection.doHandshake('wrtc://' + connectionId);
+            const rPeerConnection = (0, binary_peer_connection_v2_1.wrapBinaryPeer)(connectionId, rPeer, rPeerDevice, false, {
+                protocol: "wrtc",
+            });
+            await iPeerConnection.doHandshake(`wrtc://${connectionId}`);
             expect(rPeerConnection.remoteDeviceInfo).toBeDefined();
             expect(rPeerConnection.remoteDeviceInfo?.deviceId).toBe(iPeerDeviceId);
             expect(iPeerConnection.remoteDeviceInfo).toBeDefined();
@@ -362,7 +375,7 @@ describe('binary-peer-connection-v2', () => {
             iPeer.destroy();
             rPeer.destroy();
         });
-        it('should set secureLocal/secureRemote when markTransportSecure is true', async () => {
+        it("should set secureLocal/secureRemote when markTransportSecure is true", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
             const userId = `00000000000000000user001`;
             const keys = (0, keys_1.newKeys)();
@@ -370,14 +383,14 @@ describe('binary-peer-connection-v2', () => {
             const iPeerDeviceId = `000000000000000device001`;
             const iPeerDevice = new device_1.Device(userId, iPeerDeviceId, keys);
             const iPeerConnection = (0, binary_peer_connection_v2_1.wrapBinaryPeer)(connectionId, iPeer, iPeerDevice, true, {
-                protocol: 'wrtc',
-                markTransportSecure: true
+                protocol: "wrtc",
+                markTransportSecure: true,
             });
             const rPeerDeviceId = `000000000000000device002`;
             const rPeerDevice = new device_1.Device(userId, rPeerDeviceId, keys);
             const rPeerConnection = (0, binary_peer_connection_v2_1.wrapBinaryPeer)(connectionId, rPeer, rPeerDevice, false, {
-                protocol: 'wrtc',
-                markTransportSecure: true
+                protocol: "wrtc",
+                markTransportSecure: true,
             });
             expect(iPeerConnection.secureLocal).toBe(true);
             expect(iPeerConnection.secureRemote).toBe(true);
@@ -387,8 +400,8 @@ describe('binary-peer-connection-v2', () => {
             rPeer.destroy();
         });
     });
-    describe('backwards compatibility', () => {
-        it('wrapWrtc should work as alias and set secure flags', async () => {
+    describe("backwards compatibility", () => {
+        it("wrapWrtc should work as alias and set secure flags", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
             const userId = `00000000000000000user001`;
             const keys = (0, keys_1.newKeys)();
@@ -401,13 +414,13 @@ describe('binary-peer-connection-v2', () => {
             const rPeerConnection = (0, binary_peer_connection_v2_1.wrapWrtc)(connectionId, rPeer, rPeerDevice, false);
             expect(iPeerConnection.secureLocal).toBe(true);
             expect(iPeerConnection.secureRemote).toBe(true);
-            await iPeerConnection.doHandshake('wrtc://' + connectionId);
+            await iPeerConnection.doHandshake(`wrtc://${connectionId}`);
             expect(rPeerConnection.remoteDeviceInfo).toBeDefined();
             expect(rPeerConnection.remoteDeviceInfo?.deviceId).toBe(iPeerDeviceId);
             iPeer.destroy();
             rPeer.destroy();
         });
-        it('binary peers should bypass StreamedSocket (handlesOwnEncoding)', async () => {
+        it("binary peers should bypass StreamedSocket (handlesOwnEncoding)", async () => {
             const { iPeer } = await getMockPeerPair();
             const userId = `00000000000000000user001`;
             const keys = (0, keys_1.newKeys)();

package/dist/device/binary-peer-connection.d.ts

@@ -1,15 +1,15 @@
 import { Connection } from "./connection";
-import { Device } from "./device";
-import { ISocket } from "./socket.type";
-type ITrustLevelFn = Connection['getTrustLevel'];
+import type { Device } from "./device";
+import type { ISocket } from "./socket.type";
+type ITrustLevelFn = Connection["getTrustLevel"];
 /**
  * Generic binary peer interface supporting WebRTC and WebSocket transports.
  * Provides a unified abstraction for binary data channel communication.
  */
 export interface IBinaryPeer {
-    on(event: 'data', handler: (data: Buffer | Uint8Array) => void): void;
-    on(event: 'close', handler: () => void): void;
-    on(event: 'drain', handler: () => void): void;
+    on(event: "data", handler: (data: Buffer | Uint8Array) => void): void;
+    on(event: "close", handler: () => void): void;
+    on(event: "drain", handler: () => void): void;
     send(data: string | Uint8Array | Buffer): void;
     destroy(): void;
     /**
@@ -21,7 +21,7 @@ export interface IBinaryPeer {
 export type IWebRTCPeer = IBinaryPeer;
 export interface WrapBinaryPeerOptions {
     /** Protocol identifier used for server address (e.g., 'wrtc' or 'ws') */
-    protocol: 'wrtc' | 'ws';
+    protocol: "wrtc" | "ws";
     /**
      * Mark the transport as already secure (encrypted at transport layer).
      * When true, sets secureLocal and secureRemote to skip application-level encryption.

package/dist/device/binary-peer-connection.js

@@ -4,10 +4,10 @@ exports.createBinaryPeerSocket = createBinaryPeerSocket;
 exports.wrapBinaryPeer = wrapBinaryPeer;
 exports.wrapWrtc = wrapWrtc;
 const msgpack_1 = require("@msgpack/msgpack");
+const utils_1 = require("../utils");
 const connection_1 = require("./connection");
 const get_trust_level_fn_1 = require("./get-trust-level-fn");
 const streamed_socket_1 = require("./streamed-socket");
-const utils_1 = require("../utils");
 const tx_encoding_1 = require("./tx-encoding");
 // Protocol discriminator bytes for multiplexing RPC and raw byte streams
 const PROTOCOL_RPC = 0x00;
@@ -21,7 +21,7 @@ const LARGE_MESSAGE_THRESHOLD = 64 * 1024; // 64KB
 const RPC_CHUNK_SIZE_WRTC = 16 * 1024; // 16KB for WebRTC (fits in Unix socket kernel buffer)
 const RPC_CHUNK_SIZE_DEFAULT = 512 * 1024; // 512KB for WebSocket
 // Reserved stream ID for RPC messages sent via raw bytes
-const RPC_STREAM_ID = '__rpc';
+const RPC_STREAM_ID = "__rpc";
 // Flags for __rpc stream chunking protocol:
 // Each message on the __rpc stream starts with a 1-byte flag.
 const RPC_FLAG_SINGLE = 0x00; // [0x00][encoded message] - complete in one message
@@ -56,10 +56,10 @@ function decodeStreamId(bytes) {
 function encodeMessage(message) {
     // Check if args/result is a Uint8Array - if so, flag it to keep it as raw bytes
     let isUint8ArrayData = false;
-    if (message.type === 'call' && message.args instanceof Uint8Array) {
+    if (message.type === "call" && message.args instanceof Uint8Array) {
         isUint8ArrayData = true;
     }
-    else if (message.type === 'callback' && message.result instanceof Uint8Array) {
+    else if (message.type === "callback" && message.result instanceof Uint8Array) {
         isUint8ArrayData = true;
     }
     // Encode metadata using msgpack (without args/result/error - those go in data)
@@ -73,7 +73,7 @@ function encodeMessage(message) {
     const metadataLength = metadataBytes.length;
     // Encode the data payload (args, result, or error)
     let dataBytes;
-    if (message.type === 'call' && message.args !== undefined) {
+    if (message.type === "call" && message.args !== undefined) {
         // If args is already a Uint8Array, use it directly without txEncode
         if (isUint8ArrayData) {
             dataBytes = message.args;
@@ -82,7 +82,7 @@ function encodeMessage(message) {
             dataBytes = (0, tx_encoding_1.txEncode)(message.args);
         }
     }
-    else if (message.type === 'callback') {
+    else if (message.type === "callback") {
         if (message.error !== undefined) {
             dataBytes = (0, tx_encoding_1.txEncode)({ error: message.error });
         }
@@ -125,7 +125,7 @@ function decodeMessage(bytes) {
     };
     // Decode the data payload
     if (dataBytes.length > 0) {
-        if (message.type === 'call') {
+        if (message.type === "call") {
             // If it was a Uint8Array, use it directly without txDecode
             if (metadata.isUint8ArrayData) {
                 message.args = dataBytes;
@@ -134,7 +134,7 @@ function decodeMessage(bytes) {
                 message.args = (0, tx_encoding_1.txDecode)(dataBytes);
             }
         }
-        else if (message.type === 'callback') {
+        else if (message.type === "callback") {
             if (metadata.isUint8ArrayData) {
                 // If it was a Uint8Array result, use it directly
                 message.result = dataBytes;
@@ -156,19 +156,18 @@ function decodeMessage(bytes) {
  * Creates an ISocket from a binary peer without creating a full Connection.
  * Useful when you need to pass custom localServerAddresses to the Connection.
  */
-function createBinaryPeerSocket(connectionId, peer, protocol = 'binary') {
+function createBinaryPeerSocket(connectionId, peer, protocol = "binary") {
     const handlers = {};
     const callbacks = {};
     const rawBytesHandlers = {};
     let isClosed = false;
     const stats = (0, streamed_socket_1.createSocketStats)();
     // Map protocol string to TransportType (needed early for threshold calculations)
-    const transportType = protocol === 'wrtc' ? 'wrtc' :
-        protocol === 'ws' ? 'ws' : 'unknown';
+    const transportType = protocol === "wrtc" ? "wrtc" : protocol === "ws" ? "ws" : "unknown";
     // Transport-specific thresholds (computed once)
-    const HIGH_WATER_MARK = transportType === 'wrtc' ? 128 * 1024 : 4 * 1024 * 1024;
-    const LOW_WATER_MARK = transportType === 'wrtc' ? 32 * 1024 : 2 * 1024 * 1024;
-    const RPC_CHUNK_SIZE = transportType === 'wrtc' ? RPC_CHUNK_SIZE_WRTC : RPC_CHUNK_SIZE_DEFAULT;
+    const HIGH_WATER_MARK = transportType === "wrtc" ? 128 * 1024 : 4 * 1024 * 1024;
+    const LOW_WATER_MARK = transportType === "wrtc" ? 32 * 1024 : 2 * 1024 * 1024;
+    const RPC_CHUNK_SIZE = transportType === "wrtc" ? RPC_CHUNK_SIZE_WRTC : RPC_CHUNK_SIZE_DEFAULT;
     // Core sendRawBytes implementation - defined early so sendRPCData can use it
     const sendRawBytesImpl = async (streamId, data) => {
         const sidBytes = getStreamIdBytes(streamId);
@@ -181,7 +180,7 @@ function createBinaryPeerSocket(connectionId, peer, protocol = 'binary') {
         packet.set(data, headerLen);
         // Backpressure: wait for buffer to drain before sending more
         if (peer.getBufferedAmount && peer.getBufferedAmount() > HIGH_WATER_MARK) {
-            await new Promise(resolve => {
+            await new Promise((resolve) => {
                 const checkDrain = () => {
                     if (!peer.getBufferedAmount || peer.getBufferedAmount() < LOW_WATER_MARK) {
                         resolve();
@@ -190,7 +189,7 @@ function createBinaryPeerSocket(connectionId, peer, protocol = 'binary') {
                         setTimeout(checkDrain, 5);
                     }
                 };
-                peer.on('drain', resolve);
+                peer.on("drain", resolve);
                 checkDrain();
             });
         }
@@ -248,7 +247,7 @@ function createBinaryPeerSocket(connectionId, peer, protocol = 'binary') {
     let rpcReassemblyBuffer = null;
     let rpcReassemblyOffset = 0;
     // Handle incoming data
-    peer.on('data', async (data) => {
+    peer.on("data", async (data) => {
         try {
             const bytes = new Uint8Array(data);
             stats.bytesReceived += bytes.length;
@@ -332,7 +331,7 @@ function createBinaryPeerSocket(connectionId, peer, protocol = 'binary') {
         }
     });
     // Handle closure
-    peer.on('close', () => {
+    peer.on("close", () => {
         if (isClosed)
             return;
         isClosed = true;
@@ -347,7 +346,7 @@ function createBinaryPeerSocket(connectionId, peer, protocol = 'binary') {
         emit(eventName, args, callback) {
             const callbackId = (0, utils_1.newid)();
             callbacks[callbackId] = callback;
-            const message = { type: 'call', eventName, args, callbackId };
+            const message = { type: "call", eventName, args, callbackId };
             const encoded = encodeMessage(message);
             sendRPCData(encoded);
         },
@@ -359,7 +358,9 @@ function createBinaryPeerSocket(connectionId, peer, protocol = 'binary') {
                 delete handlers[eventName];
             }
             else {
-                Object.keys(handlers).forEach(key => delete handlers[key]);
+                for (const key of Object.keys(handlers)) {
+                    delete handlers[key];
+                }
             }
         },
         disconnect() {
@@ -371,7 +372,7 @@ function createBinaryPeerSocket(connectionId, peer, protocol = 'binary') {
         },
         removeRawBytesHandler(streamId) {
             delete rawBytesHandlers[streamId];
-        }
+        },
     };
     return socket;
 }
@@ -379,7 +380,7 @@ function createBinaryPeerSocket(connectionId, peer, protocol = 'binary') {
 // sendRPCData automatically routes large messages through raw bytes streaming
 function handleRPCMessage(bytes, handlers, callbacks, sendRPCData) {
     const message = decodeMessage(bytes);
-    if (message.type === 'callback') {
+    if (message.type === "callback") {
         const callback = callbacks[message.callbackId];
         if (callback) {
             delete callbacks[message.callbackId];
@@ -387,7 +388,7 @@ function handleRPCMessage(bytes, handlers, callbacks, sendRPCData) {
         }
         return;
     }
-    if (message.type === 'call') {
+    if (message.type === "call") {
         const handler = handlers[message.eventName];
         if (!handler) {
             console.warn(`No handler for event: ${message.eventName}`);
@@ -396,7 +397,7 @@ function handleRPCMessage(bytes, handlers, callbacks, sendRPCData) {
         try {
             const callback = (err, result) => {
                 const responseMessage = {
-                    type: 'callback',
+                    type: "callback",
                     callbackId: message.callbackId,
                 };
                 if (err)
@@ -412,9 +413,9 @@ function handleRPCMessage(bytes, handlers, callbacks, sendRPCData) {
         catch (error) {
             console.error("Error in handler", { eventName: message.eventName, error });
             const errorMessage = {
-                type: 'callback',
+                type: "callback",
                 callbackId: message.callbackId,
-                error: error.message
+                error: error.message,
             };
             const encoded = encodeMessage(errorMessage);
             sendRPCData(encoded);
@@ -431,7 +432,7 @@ function wrapBinaryPeer(connectionId, peer, localDevice, initiator, options, get
     const socket = createBinaryPeerSocket(connectionId, peer, protocol);
     const serverAddress = `${protocol}://${connectionId}`;
     const localServerAddresses = initiator ? undefined : [serverAddress];
-    if (process.env.NODE_ENV !== 'test') {
+    if (process.env.NODE_ENV !== "test") {
         getTrustLevel ??= (0, get_trust_level_fn_1.getTrustLevelFn)(localDevice, serverAddress);
     }
     const connection = new connection_1.Connection(socket, localDevice, localServerAddresses, getTrustLevel);
@@ -448,5 +449,5 @@ function wrapBinaryPeer(connectionId, peer, localDevice, initiator, options, get
  * WebRTC is encrypted at the transport layer (DTLS-SRTP), so we skip application-level encryption.
  */
 function wrapWrtc(connectionId, peer, localDevice, initiator, getTrustLevel) {
-    return wrapBinaryPeer(connectionId, peer, localDevice, initiator, { protocol: 'wrtc', markTransportSecure: true }, getTrustLevel);
+    return wrapBinaryPeer(connectionId, peer, localDevice, initiator, { protocol: "wrtc", markTransportSecure: true }, getTrustLevel);
 }