@peers-app/peers-sdk 0.27.3 → 0.27.5

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

@@ -1,730 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const nacl = require("tweetnacl");
-const keys_1 = require("../keys");
-const utils_1 = require("../utils");
-const binary_peer_connection_v2_1 = require("./binary-peer-connection-v2");
-const device_1 = require("./device");
-const frame_cipher_1 = require("./frame-cipher");
-// Mock binary peer for testing - simulates WebRTC peers
-class MockBinaryPeer {
-    dataHandlers = [];
-    closeHandlers = [];
-    drainHandlers = [];
-    otherPeer;
-    _bufferedAmount = 0;
-    destroyed = false;
-    /** Every frame handed to send(), in order (the "wire tap"). */
-    sent = [];
-    on(event, handler) {
-        if (event === "data") {
-            this.dataHandlers.push(handler);
-        }
-        else if (event === "close") {
-            this.closeHandlers.push(handler);
-        }
-        else if (event === "drain") {
-            this.drainHandlers.push(handler);
-        }
-    }
-    send(data) {
-        const bytes = typeof data === "string"
-            ? Buffer.from(data)
-            : Buffer.isBuffer(data)
-                ? data
-                : Buffer.from(data);
-        this.sent.push(bytes);
-        if (this.otherPeer) {
-            // Simulate async delivery
-            setImmediate(() => {
-                const handlers = this.otherPeer?.dataHandlers;
-                if (handlers) {
-                    for (const handler of handlers) {
-                        handler(bytes);
-                    }
-                }
-            });
-        }
-    }
-    destroy() {
-        this.destroyed = true;
-        for (const handler of this.closeHandlers) {
-            handler();
-        }
-        this.dataHandlers = [];
-        this.closeHandlers = [];
-    }
-    getBufferedAmount() {
-        return this._bufferedAmount;
-    }
-    receive(data) {
-        for (const handler of this.dataHandlers) {
-            handler(data);
-        }
-    }
-}
-function rpcStartFrame(messageId, totalSize, chunk = new Uint8Array()) {
-    const frame = new Uint8Array(9 + chunk.length);
-    frame[0] = 0x01;
-    const view = new DataView(frame.buffer);
-    view.setUint32(1, messageId, false);
-    view.setUint32(5, totalSize, false);
-    frame.set(chunk, 9);
-    return frame;
-}
-async function getMockPeerPair() {
-    const iPeer = new MockBinaryPeer();
-    const rPeer = new MockBinaryPeer();
-    // Connect the peers
-    iPeer.otherPeer = rPeer;
-    rPeer.otherPeer = iPeer;
-    await (0, utils_1.sleep)(10);
-    return { iPeer, rPeer };
-}
-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) => {
-                iPeerDataReceived += data.toString();
-            });
-            let rPeerDataReceived = "";
-            rPeer.on("data", (data) => {
-                rPeerDataReceived += data.toString();
-            });
-            rPeer.send("rPeer");
-            iPeer.send("iPeer");
-            await (0, utils_1.sleep)(50);
-            expect(iPeerDataReceived).toBe("rPeer");
-            expect(rPeerDataReceived).toBe("iPeer");
-            iPeer.destroy();
-            rPeer.destroy();
-        });
-    });
-    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");
-            socketB.on("test-event", (args, callback) => {
-                callback(null, { echo: args, added: "from-B" });
-            });
-            const result = await new Promise((resolve, reject) => {
-                socketA.emit("test-event", { hello: "world", num: 42 }, (err, res) => {
-                    if (err)
-                        reject(err);
-                    else
-                        resolve(res);
-                });
-            });
-            expect(result).toEqual({ echo: { hello: "world", num: 42 }, added: "from-B" });
-            iPeer.destroy();
-            rPeer.destroy();
-        });
-        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");
-            socketB.on("error-event", (_args, callback) => {
-                callback("something went wrong", null);
-            });
-            const error = await new Promise((resolve) => {
-                socketA.emit("error-event", {}, (err, _res) => {
-                    resolve(err);
-                });
-            });
-            expect(error).toBe("something went wrong");
-            iPeer.destroy();
-            rPeer.destroy();
-        });
-        it("should return an error when the remote event has no handler", async () => {
-            const { iPeer, rPeer } = await getMockPeerPair();
-            const socketA = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("a", iPeer, "ws");
-            (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("b", rPeer, "ws");
-            const warning = jest.spyOn(console, "warn").mockImplementation(() => { });
-            try {
-                const response = await new Promise((resolve) => {
-                    socketA.emit("missing-event", {}, (error, result) => {
-                        resolve({ error, result });
-                    });
-                });
-                expect(response).toEqual({
-                    error: "No handler registered for event: missing-event",
-                    result: undefined,
-                });
-                expect(warning).toHaveBeenCalledWith("No handler registered for event: missing-event");
-            }
-            finally {
-                warning.mockRestore();
-                iPeer.destroy();
-                rPeer.destroy();
-            }
-        });
-        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],
-                });
-            });
-            const result = await new Promise((resolve, reject) => {
-                socketA.emit("binary-event", testPayload, (err, res) => {
-                    if (err)
-                        reject(err);
-                    else
-                        resolve(res);
-                });
-            });
-            expect(result.size).toBe(8);
-            expect(result.first).toBe(1);
-            expect(result.last).toBe(8);
-            iPeer.destroy();
-            rPeer.destroy();
-        });
-        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");
-            socketB.on("get-binary", (_args, callback) => {
-                callback(null, new Uint8Array([10, 20, 30, 40, 50]));
-            });
-            const result = await new Promise((resolve, reject) => {
-                socketA.emit("get-binary", {}, (err, res) => {
-                    if (err)
-                        reject(err);
-                    else
-                        resolve(res);
-                });
-            });
-            const received = result instanceof Uint8Array ? result : new Uint8Array(result);
-            expect(received.length).toBe(5);
-            expect(received[0]).toBe(10);
-            expect(received[4]).toBe(50);
-            iPeer.destroy();
-            rPeer.destroy();
-        });
-        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");
-            const socketB = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("b", rPeer, "wrtc");
-            // 200KB payload - will need chunking at 64KB frame size
-            const largePayload = new Uint8Array(200 * 1024);
-            for (let i = 0; i < largePayload.length; i++) {
-                largePayload[i] = i % 256;
-            }
-            socketB.on("large-rpc", (args, callback) => {
-                const received = args instanceof Uint8Array ? args : new Uint8Array(args);
-                callback(null, { size: received.length, intact: received.length === 200 * 1024 });
-            });
-            const result = await new Promise((resolve, reject) => {
-                socketA.emit("large-rpc", largePayload, (err, res) => {
-                    if (err)
-                        reject(new Error(String(err)));
-                    else
-                        resolve(res);
-                });
-            });
-            expect(result.size).toBe(200 * 1024);
-            expect(result.intact).toBe(true);
-            iPeer.destroy();
-            rPeer.destroy();
-        });
-        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");
-            const responseSize = 200 * 1024;
-            socketB.on("request-large", (_args, callback) => {
-                const big = new Uint8Array(responseSize);
-                for (let i = 0; i < big.length; i++)
-                    big[i] = (i * 7) % 256;
-                callback(null, big);
-            });
-            const result = await new Promise((resolve, reject) => {
-                socketA.emit("request-large", {}, (err, res) => {
-                    if (err)
-                        reject(new Error(String(err)));
-                    else
-                        resolve(res);
-                });
-            });
-            const received = result instanceof Uint8Array ? result : new Uint8Array(result);
-            expect(received.length).toBe(responseSize);
-            expect(received[0]).toBe(0);
-            expect(received[1000]).toBe((1000 * 7) % 256);
-            iPeer.destroy();
-            rPeer.destroy();
-        });
-        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");
-            socketB.on("echo", (args, callback) => {
-                callback(null, { id: args.id, value: args.value * 2 });
-            });
-            const promises = [];
-            for (let i = 0; i < 10; i++) {
-                promises.push(new Promise((resolve, reject) => {
-                    socketA.emit("echo", { id: i, value: i * 10 }, (err, res) => {
-                        if (err)
-                            reject(err);
-                        else
-                            resolve(res);
-                    });
-                }));
-            }
-            const results = await Promise.all(promises);
-            for (let i = 0; i < 10; i++) {
-                const r = results.find((r) => r.id === i);
-                expect(r).toBeDefined();
-                expect(r?.value).toBe(i * 10 * 2);
-            }
-            iPeer.destroy();
-            rPeer.destroy();
-        });
-    });
-    describe("receive limits", () => {
-        it("closes before allocating an oversized declared RPC", async () => {
-            const { iPeer } = await getMockPeerPair();
-            (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("limited", iPeer, "wrtc", {
-                maxRpcMessageBytes: 32,
-            });
-            iPeer.receive(rpcStartFrame(1, 33));
-            expect(iPeer.destroyed).toBe(true);
-        });
-        it("bounds aggregate and concurrent incomplete reassemblies", async () => {
-            const { iPeer } = await getMockPeerPair();
-            (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("limited", iPeer, "wrtc", {
-                maxRpcMessageBytes: 32,
-                maxInFlightReassemblyBytes: 16,
-                maxConcurrentReassemblies: 2,
-            });
-            iPeer.receive(rpcStartFrame(1, 12, new Uint8Array([1])));
-            expect(iPeer.destroyed).toBe(false);
-            iPeer.receive(rpcStartFrame(2, 12, new Uint8Array([2])));
-            expect(iPeer.destroyed).toBe(true);
-        });
-        it("closes when an incomplete reassembly outlives its deadline", async () => {
-            const { iPeer } = await getMockPeerPair();
-            jest.useFakeTimers();
-            try {
-                (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("limited", iPeer, "wrtc", {
-                    reassemblyTimeoutMs: 10,
-                });
-                iPeer.receive(rpcStartFrame(1, 32, new Uint8Array([1])));
-                jest.advanceTimersByTime(10);
-                expect(iPeer.destroyed).toBe(true);
-            }
-            finally {
-                jest.useRealTimers();
-            }
-        });
-        it("closes when continuation bytes exceed the declared RPC size", async () => {
-            const { iPeer } = await getMockPeerPair();
-            (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("limited", iPeer, "wrtc");
-            iPeer.receive(rpcStartFrame(1, 2, new Uint8Array([1])));
-            iPeer.receive(new Uint8Array([0x02, 0, 0, 0, 1, 2, 3]));
-            expect(iPeer.destroyed).toBe(true);
-        });
-    });
-    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) => {
-                    resolve(data);
-                });
-            });
-            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 () => {
-            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 results = {
-                "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]));
-            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 () => {
-            const { iPeer, rPeer } = await getMockPeerPair();
-            // Use wrtc for 64KB max frame size
-            const socketA = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("a", iPeer, "wrtc");
-            const socketB = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("b", rPeer, "wrtc");
-            const largeData = new Uint8Array(200 * 1024);
-            for (let i = 0; i < largeData.length; i++) {
-                largeData[i] = i % 256;
-            }
-            const received = new Promise((resolve) => {
-                socketB.onRawBytes?.("large-stream", (data) => {
-                    resolve(data);
-                });
-            });
-            await socketA.sendRawBytes?.("large-stream", largeData);
-            const result = await received;
-            expect(result.length).toBe(largeData.length);
-            // Verify content
-            for (let i = 0; i < 100; i++) {
-                expect(result[i]).toBe(i % 256);
-            }
-            expect(result[result.length - 1]).toBe((largeData.length - 1) % 256);
-            iPeer.destroy();
-            rPeer.destroy();
-        });
-        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]));
-            await (0, utils_1.sleep)(50);
-            expect(callCount).toBe(1);
-            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("frame cipher", () => {
-        function keyPair() {
-            const ab = nacl.randomBytes(32);
-            const ba = nacl.randomBytes(32);
-            return {
-                a: { sendKey: ab.slice(), receiveKey: ba.slice() },
-                b: { sendKey: ba.slice(), receiveKey: ab.slice() },
-            };
-        }
-        async function armedPair(protocol, connectionId = "conn") {
-            const { iPeer, rPeer } = await getMockPeerPair();
-            const socketA = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)(connectionId, iPeer, protocol);
-            const socketB = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)(connectionId, rPeer, protocol);
-            const keys = keyPair();
-            socketA.armFrameCipher?.(keys.a);
-            socketB.armFrameCipher?.(keys.b);
-            return { iPeer, rPeer, socketA, socketB };
-        }
-        function emit(socket, eventName, args) {
-            return new Promise((resolve, reject) => {
-                socket.emit(eventName, args, (err, res) => (err ? reject(err) : resolve(res)));
-            });
-        }
-        for (const protocol of ["ws", "wrtc"]) {
-            it(`round-trips RPC and streams when armed on ${protocol}, sealing every frame`, async () => {
-                const { iPeer, rPeer, socketA, socketB } = await armedPair(protocol);
-                expect(socketA.frameCipherArmed).toBe(true);
-                expect(socketB.frameCipherArmed).toBe(true);
-                const marker = `RPC-MARKER-${(0, utils_1.newid)()}`;
-                socketB.on("echo", (args, callback) => {
-                    callback(null, { got: args.marker, reply: `${marker}-reply` });
-                });
-                const result = await emit(socketA, "echo", { marker });
-                expect(result).toEqual({ got: marker, reply: `${marker}-reply` });
-                const streamMarker = nacl.randomBytes(64);
-                const received = new Promise((resolve) => socketB.onRawBytes?.("s", (d) => resolve(d)));
-                await socketA.sendRawBytes?.("s", streamMarker);
-                expect(Buffer.from(await received)).toEqual(Buffer.from(streamMarker));
-                // Wire tap: every frame is FRAME_ENC and neither marker appears on the wire.
-                const wire = [...iPeer.sent, ...rPeer.sent];
-                expect(wire.length).toBeGreaterThanOrEqual(3);
-                for (const frame of wire) {
-                    expect(frame[0]).toBe(frame_cipher_1.FRAME_ENC);
-                    expect(frame.indexOf(Buffer.from(marker))).toBe(-1);
-                    expect(frame.indexOf(Buffer.from(streamMarker))).toBe(-1);
-                }
-                iPeer.destroy();
-                rPeer.destroy();
-            });
-        }
-        it("seals an RPC reply that is sent after the local peer has already closed", async () => {
-            const { iPeer, rPeer, socketA, socketB } = await armedPair("wrtc");
-            const sentBefore = rPeer.sent.length;
-            socketB.on("echo", async (_args, callback) => {
-                // Tear down before the reply, as a handshake failure does when the
-                // confirmation handler resumes in a later microtask.
-                rPeer.destroy();
-                expect(socketB.connected).toBe(false);
-                await Promise.resolve();
-                callback(null, { ok: true });
-            });
-            await expect(emit(socketA, "echo", { n: 1 })).resolves.toEqual({ ok: true });
-            const replies = rPeer.sent.slice(sentBefore);
-            expect(replies.length).toBeGreaterThan(0);
-            for (const frame of replies) {
-                expect(frame[0]).toBe(frame_cipher_1.FRAME_ENC);
-            }
-            expect(socketB.frameCipherArmed).toBe(false);
-            iPeer.destroy();
-        });
-        it("keeps chunked RPC and stream frames within maxFramePayload including overhead", async () => {
-            const { iPeer, rPeer, socketA, socketB } = await armedPair("wrtc");
-            const maxFrame = 64 * 1024;
-            const large = new Uint8Array(200 * 1024);
-            for (let i = 0; i < large.length; i++)
-                large[i] = i % 256;
-            socketB.on("big", (args, callback) => {
-                callback(null, args.length);
-            });
-            expect(await emit(socketA, "big", large)).toBe(large.length);
-            const received = new Promise((resolve) => socketB.onRawBytes?.("big-stream", (d) => resolve(d)));
-            await socketA.sendRawBytes?.("big-stream", large);
-            expect((await received).length).toBe(large.length);
-            expect(iPeer.sent.length).toBeGreaterThan(6);
-            for (const frame of iPeer.sent) {
-                expect(frame.length).toBeLessThanOrEqual(maxFrame);
-                expect(frame[0]).toBe(frame_cipher_1.FRAME_ENC);
-            }
-            // Bytes the sealed frames are budgeted for are actually used: at least one full frame.
-            expect(iPeer.sent.some((f) => f.length === maxFrame)).toBe(true);
-            iPeer.destroy();
-            rPeer.destroy();
-        });
-        it("closes the connection when a plaintext frame arrives after arming", async () => {
-            const { iPeer } = await getMockPeerPair();
-            const socket = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("conn", iPeer, "ws");
-            const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
-            try {
-                socket.armFrameCipher?.(keyPair().a);
-                iPeer.receive(new Uint8Array([0x00, 0, 0, 0, 0]));
-                expect(iPeer.destroyed).toBe(true);
-                expect(socket.connected).toBe(false);
-                expect(warn).toHaveBeenCalledWith(expect.stringContaining("plaintext frame"));
-            }
-            finally {
-                warn.mockRestore();
-            }
-        });
-        it("closes the connection when a sealed frame arrives before arming", async () => {
-            const { iPeer } = await getMockPeerPair();
-            (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("conn", iPeer, "ws");
-            const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
-            try {
-                iPeer.receive(new Uint8Array([frame_cipher_1.FRAME_ENC, ...new Uint8Array(20)]));
-                expect(iPeer.destroyed).toBe(true);
-                expect(warn).toHaveBeenCalledWith(expect.stringContaining("before frame cipher"));
-            }
-            finally {
-                warn.mockRestore();
-            }
-        });
-        it("closes the connection when a sealed frame fails authentication", async () => {
-            const { iPeer, rPeer, socketA } = await armedPair("ws");
-            const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
-            try {
-                // Re-arm B with unrelated keys so A's frames fail to open.
-                const socketB = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("conn", rPeer, "ws");
-                socketB.armFrameCipher?.(keyPair().b);
-                socketA.emit("x", {}, () => { });
-                await (0, utils_1.sleep)(20);
-                expect(rPeer.destroyed).toBe(true);
-                expect(warn).toHaveBeenCalledWith(expect.stringContaining("failed authentication"));
-            }
-            finally {
-                warn.mockRestore();
-                iPeer.destroy();
-            }
-        });
-        it("drops plaintext stream frames when plaintext streams are disallowed and not armed", async () => {
-            const { iPeer, rPeer } = await getMockPeerPair();
-            const socketA = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("conn", iPeer, "ws");
-            const socketB = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("conn", rPeer, "ws");
-            socketB.setPlaintextStreamsAllowed?.(false);
-            let delivered = 0;
-            socketB.onRawBytes?.("gated", () => delivered++);
-            await socketA.sendRawBytes?.("gated", new Uint8Array([1, 2, 3]));
-            await (0, utils_1.sleep)(20);
-            expect(delivered).toBe(0);
-            expect(rPeer.destroyed).toBe(false);
-            // Plaintext RPC still works before the handshake.
-            socketB.on("ping", (_a, cb) => cb(null, "pong"));
-            expect(await emit(socketA, "ping", {})).toBe("pong");
-            // Re-allowing (legacy peer path) delivers again.
-            socketB.setPlaintextStreamsAllowed?.(true);
-            await socketA.sendRawBytes?.("gated", new Uint8Array([4]));
-            await (0, utils_1.sleep)(20);
-            expect(delivered).toBe(1);
-            iPeer.destroy();
-            rPeer.destroy();
-        });
-        it("arms send after the reply frame when the callback carries armFrameCipherAfter", async () => {
-            const { iPeer, rPeer } = await getMockPeerPair();
-            const client = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("conn", iPeer, "ws");
-            const server = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("conn", rPeer, "ws");
-            const keys = keyPair();
-            server.on("completeHandshake", (_args, callback) => {
-                // Server: arm receive now, send after this reply (as Connection does).
-                server.armFrameCipher?.(keys.b, "receive");
-                expect(server.frameCipherArmed).toBe(false);
-                callback(null, { ok: true }, { armFrameCipherAfter: keys.b });
-            });
-            server.on("afterwards", (args, cb) => cb(null, `sealed:${args}`));
-            const reply = await emit(client, "completeHandshake", {});
-            expect(reply).toEqual({ ok: true });
-            // The reply itself was plaintext...
-            expect(rPeer.sent.length).toBe(1);
-            expect(rPeer.sent[0][0]).not.toBe(frame_cipher_1.FRAME_ENC);
-            // ...and the server is now fully armed.
-            expect(server.frameCipherArmed).toBe(true);
-            // Client arms both on receipt and everything after is sealed both ways.
-            client.armFrameCipher?.(keys.a);
-            expect(await emit(client, "afterwards", "x")).toBe("sealed:x");
-            expect(iPeer.sent[iPeer.sent.length - 1][0]).toBe(frame_cipher_1.FRAME_ENC);
-            expect(rPeer.sent[rPeer.sent.length - 1][0]).toBe(frame_cipher_1.FRAME_ENC);
-            iPeer.destroy();
-            rPeer.destroy();
-        });
-        it("arms send after the last chunk of a chunked reply", async () => {
-            const { iPeer, rPeer } = await getMockPeerPair();
-            const client = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("conn", iPeer, "wrtc");
-            const server = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("conn", rPeer, "wrtc");
-            const keys = keyPair();
-            const bigReply = new Uint8Array(150 * 1024);
-            server.on("hs", (_args, callback) => {
-                server.armFrameCipher?.(keys.b, "receive");
-                callback(null, bigReply, { armFrameCipherAfter: keys.b });
-            });
-            const reply = await emit(client, "hs", {});
-            expect(reply.length).toBe(bigReply.length);
-            expect(rPeer.sent.length).toBeGreaterThan(1);
-            for (const frame of rPeer.sent)
-                expect(frame[0]).not.toBe(frame_cipher_1.FRAME_ENC);
-            expect(server.frameCipherArmed).toBe(true);
-            iPeer.destroy();
-            rPeer.destroy();
-        });
-    });
-    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");
-            socketB.on("ping", (_args, callback) => {
-                callback(null, "pong");
-            });
-            await new Promise((resolve, reject) => {
-                socketA.emit("ping", "hello", (err, res) => {
-                    if (err)
-                        reject(err);
-                    else
-                        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);
-            iPeer.destroy();
-            rPeer.destroy();
-        });
-    });
-    describe("wrapBinaryPeer", () => {
-        it("should successfully handshake over wrtc protocol", async () => {
-            const { iPeer, rPeer } = await getMockPeerPair();
-            const userId = (0, utils_1.newid)();
-            const keys = (0, keys_1.newKeys)();
-            const connectionId = `00000000000000000conn001`;
-            const iPeerDeviceId = (0, utils_1.newid)();
-            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 rPeerDeviceId = (0, utils_1.newid)();
-            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}`);
-            expect(rPeerConnection.remoteDeviceInfo).toBeDefined();
-            expect(rPeerConnection.remoteDeviceInfo?.deviceId).toBe(iPeerDeviceId);
-            expect(iPeerConnection.remoteDeviceInfo).toBeDefined();
-            expect(iPeerConnection.remoteDeviceInfo?.deviceId).toBe(rPeerDeviceId);
-            iPeer.destroy();
-            rPeer.destroy();
-        });
-        it("should set secureLocal/secureRemote when markTransportSecure is true", async () => {
-            const { iPeer, rPeer } = await getMockPeerPair();
-            const userId = (0, utils_1.newid)();
-            const keys = (0, keys_1.newKeys)();
-            const connectionId = `00000000000000000conn001`;
-            const iPeerDeviceId = (0, utils_1.newid)();
-            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,
-            });
-            const rPeerDeviceId = (0, utils_1.newid)();
-            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,
-            });
-            expect(iPeerConnection.secureLocal).toBe(true);
-            expect(iPeerConnection.secureRemote).toBe(true);
-            expect(rPeerConnection.secureLocal).toBe(true);
-            expect(rPeerConnection.secureRemote).toBe(true);
-            iPeer.destroy();
-            rPeer.destroy();
-        });
-    });
-    describe("backwards compatibility", () => {
-        it("wrapWrtc should work as alias and set secure flags", async () => {
-            const { iPeer, rPeer } = await getMockPeerPair();
-            const userId = (0, utils_1.newid)();
-            const keys = (0, keys_1.newKeys)();
-            const connectionId = `00000000000000000conn001`;
-            const iPeerDeviceId = (0, utils_1.newid)();
-            const iPeerDevice = new device_1.Device(userId, iPeerDeviceId, keys);
-            const iPeerConnection = (0, binary_peer_connection_v2_1.wrapWrtc)(connectionId, iPeer, iPeerDevice, true);
-            const rPeerDeviceId = (0, utils_1.newid)();
-            const rPeerDevice = new device_1.Device(userId, rPeerDeviceId, keys);
-            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}`);
-            expect(rPeerConnection.remoteDeviceInfo).toBeDefined();
-            expect(rPeerConnection.remoteDeviceInfo?.deviceId).toBe(iPeerDeviceId);
-            iPeer.destroy();
-            rPeer.destroy();
-        });
-        it("binary peers should bypass StreamedSocket (handlesOwnEncoding)", async () => {
-            const { iPeer } = await getMockPeerPair();
-            const userId = (0, utils_1.newid)();
-            const keys = (0, keys_1.newKeys)();
-            const connectionId = `00000000000000000conn001`;
-            const deviceId = (0, utils_1.newid)();
-            const device = new device_1.Device(userId, deviceId, keys);
-            const connection = (0, binary_peer_connection_v2_1.wrapWrtc)(connectionId, iPeer, device, true);
-            expect(connection.socket.handlesOwnEncoding).toBe(true);
-            iPeer.destroy();
-        });
-    });
-});