@decentnetwork/peer 0.1.0

package/dist/compat/packet.d.ts

@@ -0,0 +1,55 @@
+export declare const PACKET_TYPE_USERINFO = 3;
+export declare const PACKET_TYPE_FRIEND_REQUEST = 6;
+export declare const PACKET_TYPE_MESSAGE = 33;
+export type UserInfoPacket = {
+    type: typeof PACKET_TYPE_USERINFO;
+    avatar: boolean;
+    name: string;
+    descr: string;
+    phone: string;
+    gender: string;
+    email: string;
+    region: string;
+};
+export type FriendRequestPacket = {
+    type: typeof PACKET_TYPE_FRIEND_REQUEST;
+    name: string;
+    descr: string;
+    hello: string;
+};
+export type FriendMessagePacket = {
+    type: typeof PACKET_TYPE_MESSAGE;
+    ext?: string;
+    data: Uint8Array;
+};
+export type CarrierPacket = UserInfoPacket | FriendRequestPacket | FriendMessagePacket;
+/**
+ * Encode a Carrier `userinfo` packet (FB type 3). The Carrier C SDK sends
+ * this every time the local user's name / status message / profile fields
+ * change, transported via toxcore's PACKET_ID_STATUSMESSAGE (49).
+ *
+ * Field layout per src/carrier/packet.fbs:
+ *   field 0 = avatar : bool   (default false)
+ *   field 1 = name   : string
+ *   field 2 = descr  : string
+ *   field 3 = phone  : string
+ *   field 4 = gender : string
+ *   field 5 = email  : string
+ *   field 6 = region : string
+ */
+export declare function encodeUserInfoPacket(opts: {
+    avatar?: boolean;
+    name?: string;
+    descr?: string;
+    phone?: string;
+    gender?: string;
+    email?: string;
+    region?: string;
+}): Uint8Array;
+export declare function encodeFriendRequestPacket(opts: {
+    name?: string;
+    descr?: string;
+    hello?: string;
+}): Uint8Array;
+export declare function encodeFriendMessagePacket(data: Uint8Array | string, ext?: string): Uint8Array;
+export declare function decodeCarrierPacket(bytes: Uint8Array): CarrierPacket;

package/dist/compat/packet.js

@@ -0,0 +1,154 @@
+import { Builder, ByteBuffer, Encoding } from "flatbuffers";
+export const PACKET_TYPE_USERINFO = 3;
+export const PACKET_TYPE_FRIEND_REQUEST = 6;
+export const PACKET_TYPE_MESSAGE = 33;
+// Body type indices into FlatBuffers `anybody` union (carrier/packet.fbs).
+// The .fbs declares: userinfo, friendreq, friendmsg, invitereq, invitersp,
+// bulkmsg — flatbuffers maps those to 1, 2, 3, 4, 5, 6 (NONE = 0).
+const ANYBODY_USERINFO = 1;
+const ANYBODY_FRIENDREQ = 2;
+const ANYBODY_FRIENDMSG = 3;
+/**
+ * Encode a Carrier `userinfo` packet (FB type 3). The Carrier C SDK sends
+ * this every time the local user's name / status message / profile fields
+ * change, transported via toxcore's PACKET_ID_STATUSMESSAGE (49).
+ *
+ * Field layout per src/carrier/packet.fbs:
+ *   field 0 = avatar : bool   (default false)
+ *   field 1 = name   : string
+ *   field 2 = descr  : string
+ *   field 3 = phone  : string
+ *   field 4 = gender : string
+ *   field 5 = email  : string
+ *   field 6 = region : string
+ */
+export function encodeUserInfoPacket(opts) {
+    const builder = new Builder(256);
+    const name = builder.createString(opts.name ?? "");
+    const descr = builder.createString(opts.descr ?? "");
+    const phone = builder.createString(opts.phone ?? "");
+    const gender = builder.createString(opts.gender ?? "");
+    const email = builder.createString(opts.email ?? "");
+    const region = builder.createString(opts.region ?? "");
+    builder.startObject(7);
+    // Add high field numbers first so vtable reflects all slots.
+    builder.addFieldOffset(6, region, 0);
+    builder.addFieldOffset(5, email, 0);
+    builder.addFieldOffset(4, gender, 0);
+    builder.addFieldOffset(3, phone, 0);
+    builder.addFieldOffset(2, descr, 0);
+    builder.addFieldOffset(1, name, 0);
+    if (opts.avatar) {
+        builder.addFieldInt8(0, 1, 0);
+    }
+    const userinfo = builder.endObject();
+    return finishCarrierPacket(builder, PACKET_TYPE_USERINFO, ANYBODY_USERINFO, userinfo);
+}
+export function encodeFriendRequestPacket(opts) {
+    const builder = new Builder(256);
+    const name = builder.createString(opts.name ?? "");
+    const descr = builder.createString(opts.descr ?? "");
+    const hello = builder.createString(opts.hello ?? "");
+    builder.startObject(3);
+    builder.addFieldOffset(2, hello, 0);
+    builder.addFieldOffset(1, descr, 0);
+    builder.addFieldOffset(0, name, 0);
+    const friendReq = builder.endObject();
+    return finishCarrierPacket(builder, PACKET_TYPE_FRIEND_REQUEST, ANYBODY_FRIENDREQ, friendReq);
+}
+export function encodeFriendMessagePacket(data, ext) {
+    const builder = new Builder(256);
+    const messageData = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    const msg = builder.createByteVector(messageData);
+    const extOffset = ext ? builder.createString(ext) : 0;
+    builder.startObject(2);
+    builder.addFieldOffset(1, msg, 0);
+    if (extOffset) {
+        builder.addFieldOffset(0, extOffset, 0);
+    }
+    const friendMsg = builder.endObject();
+    return finishCarrierPacket(builder, PACKET_TYPE_MESSAGE, ANYBODY_FRIENDMSG, friendMsg);
+}
+export function decodeCarrierPacket(bytes) {
+    const bb = new ByteBuffer(bytes);
+    const root = bb.readInt32(bb.position()) + bb.position();
+    const packet = { bb, bb_pos: root };
+    const type = readUint8Field(packet, 0);
+    const bodyType = readUint8Field(packet, 1);
+    const body = readTableField(packet, 2);
+    if (!body) {
+        throw new Error("carrier packet body is missing");
+    }
+    if (type === PACKET_TYPE_USERINFO && bodyType === ANYBODY_USERINFO) {
+        return {
+            type,
+            avatar: readBoolField(body, 0),
+            name: readStringField(body, 1) ?? "",
+            descr: readStringField(body, 2) ?? "",
+            phone: readStringField(body, 3) ?? "",
+            gender: readStringField(body, 4) ?? "",
+            email: readStringField(body, 5) ?? "",
+            region: readStringField(body, 6) ?? ""
+        };
+    }
+    if (type === PACKET_TYPE_FRIEND_REQUEST && bodyType === ANYBODY_FRIENDREQ) {
+        return {
+            type,
+            name: readStringField(body, 0) ?? "",
+            descr: readStringField(body, 1) ?? "",
+            hello: readStringField(body, 2) ?? ""
+        };
+    }
+    if (type === PACKET_TYPE_MESSAGE && bodyType === ANYBODY_FRIENDMSG) {
+        return {
+            type,
+            ext: readStringField(body, 0) ?? undefined,
+            data: readByteVectorField(body, 1) ?? new Uint8Array()
+        };
+    }
+    throw new Error(`unsupported carrier packet type/body: ${type}/${bodyType}`);
+}
+function finishCarrierPacket(builder, type, bodyType, bodyOffset) {
+    builder.startObject(3);
+    builder.addFieldOffset(2, bodyOffset, 0);
+    builder.addFieldInt8(1, bodyType, 0);
+    builder.addFieldInt8(0, type, 0);
+    const packet = builder.endObject();
+    builder.finish(packet);
+    return builder.asUint8Array();
+}
+function readBoolField(table, field) {
+    const offset = table.bb.__offset(table.bb_pos, 4 + field * 2);
+    return offset ? table.bb.readUint8(table.bb_pos + offset) !== 0 : false;
+}
+function readUint8Field(table, field) {
+    const offset = table.bb.__offset(table.bb_pos, 4 + field * 2);
+    return offset ? table.bb.readUint8(table.bb_pos + offset) : 0;
+}
+function readStringField(table, field) {
+    const offset = table.bb.__offset(table.bb_pos, 4 + field * 2);
+    if (!offset) {
+        return undefined;
+    }
+    return table.bb.__string(table.bb_pos + offset, Encoding.UTF16_STRING);
+}
+function readTableField(table, field) {
+    const offset = table.bb.__offset(table.bb_pos, 4 + field * 2);
+    if (!offset) {
+        return undefined;
+    }
+    const tableOffset = table.bb_pos + offset;
+    return {
+        bb: table.bb,
+        bb_pos: tableOffset + table.bb.readInt32(tableOffset)
+    };
+}
+function readByteVectorField(table, field) {
+    const offset = table.bb.__offset(table.bb_pos, 4 + field * 2);
+    if (!offset) {
+        return undefined;
+    }
+    const vector = table.bb.__vector(table.bb_pos + offset);
+    const length = table.bb.__vector_len(table.bb_pos + offset);
+    return table.bb.bytes().slice(vector, vector + length);
+}

package/dist/compat/session.d.ts

@@ -0,0 +1,3 @@
+export declare class LegacySessionClient {
+    startSession(pubkey: string): Promise<never>;
+}

package/dist/compat/session.js

@@ -0,0 +1,7 @@
+import { LegacyProtocolNotImplementedError } from "../runtime/errors.js";
+export class LegacySessionClient {
+    async startSession(pubkey) {
+        void pubkey;
+        throw new LegacyProtocolNotImplementedError("Legacy session");
+    }
+}

package/dist/compat/tcp-relay-pool.d.ts

@@ -0,0 +1,85 @@
+import { EventEmitter } from "node:events";
+import type { KeyPair } from "../crypto/keypair.js";
+import type { NetworkNode } from "../types/peer.js";
+export type TcpRelayPoolOptions = {
+    relays: NetworkNode[];
+    selfKeyPair: KeyPair;
+    maxConnections?: number;
+    /** Optional debug label inherited by underlying TcpRelayClients. */
+    label?: string;
+};
+export type TcpRelayPoolEvents = {
+    /** A friend is now online on at least one relay. */
+    friendOnline: (friendPublicKey: Uint8Array) => void;
+    /** A friend is no longer online on any relay. */
+    friendOffline: (friendPublicKey: Uint8Array) => void;
+    /** Inbound DATA forwarded by some relay. */
+    peerData: (friendPublicKey: Uint8Array, payload: Uint8Array) => void;
+    /** Inbound OOB_RECV (used for friend requests via TCP). */
+    oob: (senderPublicKey: Uint8Array, payload: Uint8Array) => void;
+    /** Number of currently-connected relays changed (for diagnostics). */
+    status: (connected: number, total: number) => void;
+};
+export declare class TcpRelayPool extends EventEmitter {
+    #private;
+    constructor(opts: TcpRelayPoolOptions);
+    /**
+     * Initialize the pool. Selects up to `maxConnections` relays from the
+     * supplied list (picks them in order; the operator can prioritize by
+     * sorting). Returns the count of initial connections successfully
+     * opened.
+     */
+    start(): Promise<number>;
+    /** Tear down all relay connections. */
+    stop(): Promise<void>;
+    /**
+     * Dynamically add a TCP relay to the pool — used when a friend's
+     * DHT-PK extras advertise a relay address we weren't already on.
+     * Without this, two peers on disjoint relay sets can never establish
+     * a TCP path even if both relays are reachable. Idempotent: skips if
+     * the host:port pair is already in the pool.
+     *
+     * Returns the index of the relay (existing or newly added).
+     */
+    addRelay(node: NetworkNode): number;
+    /**
+     * Ask every connected relay to route packets for this friend. Idempotent;
+     * subsequent calls for an already-requested key are no-ops on each
+     * underlying client.
+     */
+    requestRoute(friendPublicKey: Uint8Array): void;
+    /** True if at least one relay reports this friend currently online. */
+    isFriendOnline(friendPublicKey: Uint8Array): boolean;
+    /**
+     * OOB_SEND — fire-and-forget delivery to any peer connected to any of
+     * our relays, bypassing routing. Used for the initial cookie request
+     * / cookie response / crypto handshake exchange before either side
+     * has issued ROUTING_REQUEST. Mirrors toxcore's tcp_send_oob_packet
+     * which net_crypto.c calls via send_oob_packet for the same purpose.
+     * Returns the count of relays the OOB packet was written to.
+     */
+    sendOobToFriend(friendPublicKey: Uint8Array, payload: Uint8Array): number;
+    /**
+     * Forward a DATA payload to a friend through any relay where they're
+     * online. Returns the count of relays that accepted the write — 0 if
+     * the friend isn't online on any TCP relay.
+     */
+    sendToFriend(friendPublicKey: Uint8Array, payload: Uint8Array): number;
+    /** Diagnostics. */
+    connectedCount(): number;
+    /**
+     * Snapshot of currently-connected relays for inclusion in DHT-PK
+     * announce extras. Mirrors toxcore's `tcp_copy_connected_relays`.
+     * Returns up to `max` entries, each with the relay's public key and
+     * its host:port — enough for the receiver to add the relay to its
+     * own pool via TcpRelayPool.addRelay and start routing through it.
+     */
+    connectedRelays(max?: number): Array<{
+        host: string;
+        port: number;
+        serverPublicKey: Uint8Array;
+    }>;
+    on<E extends keyof TcpRelayPoolEvents>(event: E, listener: TcpRelayPoolEvents[E]): this;
+    once<E extends keyof TcpRelayPoolEvents>(event: E, listener: TcpRelayPoolEvents[E]): this;
+    off<E extends keyof TcpRelayPoolEvents>(event: E, listener: TcpRelayPoolEvents[E]): this;
+}

package/dist/compat/tcp-relay-pool.js

@@ -0,0 +1,342 @@
+// Multi-relay TCP pool — owns a small number of TcpRelayClient
+// connections to the operator-configured Carrier bootstrap nodes (each
+// of which also runs a TCP relay server) and provides a unified
+// per-friend send/receive surface to the Peer class.
+//
+// Design choices:
+//  - Up to N parallel relays (default 3, matches toxcore's
+//    TCP_CONNECTIONS_PER_FRIEND constant).
+//  - For every friend the Peer cares about, we issue ROUTING_REQUEST on
+//    every connected relay. The first relay where the friend is also
+//    routed produces a CONNECTION_NOTIFICATION. From then on we can
+//    forward DATA through that relay.
+//  - Inbound peerData from any relay is surfaced to a single event so
+//    the Peer doesn't need to know which relay delivered the bytes.
+//  - Outbound sendToFriend tries every relay that has the friend
+//    online, returning true if at least one accepted the write. iOS
+//    Beagle does the same — sends in parallel and lets net_crypto's
+//    packet number dedup handle duplicates.
+//  - Reconnect: if a relay socket drops, we re-open and re-issue route
+//    requests for all known friends. Bounded backoff so a permanently
+//    down relay doesn't burn CPU.
+import { EventEmitter } from "node:events";
+import { base58ToBytes } from "../utils/base58.js";
+import { TcpRelayClient } from "./tcp-relay.js";
+const KEY_SIZE = 32;
+const MAX_RELAY_CONNECTIONS = 3;
+const RECONNECT_BASE_MS = 5_000;
+const RECONNECT_MAX_MS = 120_000;
+export class TcpRelayPool extends EventEmitter {
+    #opts;
+    #relays = [];
+    #stopped = false;
+    // Friends we want routed on every connected relay. Re-asserted on
+    // reconnect.
+    #wantedFriends = new Map(); // hex -> raw pubkey
+    // Friend -> set of relay-indices currently reporting the friend online.
+    // We emit `friendOnline` on first transition to size 1, `friendOffline`
+    // on transition back to 0.
+    #onlineRelaysByFriend = new Map();
+    #debug = process.env.DECENT_DEBUG === "1";
+    constructor(opts) {
+        super();
+        this.#opts = opts;
+    }
+    /**
+     * Initialize the pool. Selects up to `maxConnections` relays from the
+     * supplied list (picks them in order; the operator can prioritize by
+     * sorting). Returns the count of initial connections successfully
+     * opened.
+     */
+    async start() {
+        const max = Math.min(this.#opts.maxConnections ?? MAX_RELAY_CONNECTIONS, this.#opts.relays.length);
+        for (let i = 0; i < max; i++) {
+            const node = this.#opts.relays[i];
+            if (!node.pk)
+                continue;
+            let serverPk;
+            try {
+                serverPk = base58ToBytes(node.pk);
+            }
+            catch {
+                continue;
+            }
+            if (serverPk.length !== KEY_SIZE)
+                continue;
+            this.#relays.push({ node, serverPublicKey: serverPk, reconnectAttempt: 0 });
+        }
+        // Open all in parallel; tolerate failures (each will reconnect).
+        const results = await Promise.allSettled(this.#relays.map((_, idx) => this.#openOne(idx)));
+        const opened = results.filter((r) => r.status === "fulfilled").length;
+        this.#emitStatus();
+        return opened;
+    }
+    /** Tear down all relay connections. */
+    async stop() {
+        this.#stopped = true;
+        for (const r of this.#relays) {
+            if (r.reconnectTimer)
+                clearTimeout(r.reconnectTimer);
+            r.reconnectTimer = undefined;
+            try {
+                r.client?.close("pool stop");
+            }
+            catch { /* ignore */ }
+            r.client = undefined;
+        }
+        this.#relays = [];
+        this.#wantedFriends.clear();
+        this.#onlineRelaysByFriend.clear();
+    }
+    /**
+     * Dynamically add a TCP relay to the pool — used when a friend's
+     * DHT-PK extras advertise a relay address we weren't already on.
+     * Without this, two peers on disjoint relay sets can never establish
+     * a TCP path even if both relays are reachable. Idempotent: skips if
+     * the host:port pair is already in the pool.
+     *
+     * Returns the index of the relay (existing or newly added).
+     */
+    addRelay(node) {
+        if (this.#stopped)
+            return -1;
+        if (!node.pk)
+            return -1;
+        let serverPk;
+        try {
+            serverPk = base58ToBytes(node.pk);
+        }
+        catch {
+            return -1;
+        }
+        if (serverPk.length !== KEY_SIZE)
+            return -1;
+        // Already in pool?
+        for (let i = 0; i < this.#relays.length; i++) {
+            const r = this.#relays[i];
+            if (r.node.host === node.host && r.node.port === node.port) {
+                return i;
+            }
+        }
+        const idx = this.#relays.length;
+        this.#relays.push({ node, serverPublicKey: serverPk, reconnectAttempt: 0 });
+        this.#log(`addRelay ${node.host}:${node.port} (idx=${idx})`);
+        void this.#openOne(idx).catch(() => { });
+        return idx;
+    }
+    /**
+     * Ask every connected relay to route packets for this friend. Idempotent;
+     * subsequent calls for an already-requested key are no-ops on each
+     * underlying client.
+     */
+    requestRoute(friendPublicKey) {
+        if (friendPublicKey.length !== KEY_SIZE)
+            return;
+        const hex = Buffer.from(friendPublicKey).toString("hex");
+        this.#wantedFriends.set(hex, new Uint8Array(friendPublicKey));
+        for (const r of this.#relays) {
+            if (r.client?.state() === "connected") {
+                r.client.requestRoute(friendPublicKey);
+            }
+        }
+    }
+    /** True if at least one relay reports this friend currently online. */
+    isFriendOnline(friendPublicKey) {
+        if (friendPublicKey.length !== KEY_SIZE)
+            return false;
+        const set = this.#onlineRelaysByFriend.get(Buffer.from(friendPublicKey).toString("hex"));
+        return !!(set && set.size > 0);
+    }
+    /**
+     * OOB_SEND — fire-and-forget delivery to any peer connected to any of
+     * our relays, bypassing routing. Used for the initial cookie request
+     * / cookie response / crypto handshake exchange before either side
+     * has issued ROUTING_REQUEST. Mirrors toxcore's tcp_send_oob_packet
+     * which net_crypto.c calls via send_oob_packet for the same purpose.
+     * Returns the count of relays the OOB packet was written to.
+     */
+    sendOobToFriend(friendPublicKey, payload) {
+        if (friendPublicKey.length !== KEY_SIZE)
+            return 0;
+        let sent = 0;
+        for (const r of this.#relays) {
+            if (r.client?.state() !== "connected")
+                continue;
+            if (r.client.sendOob(friendPublicKey, payload)) {
+                sent += 1;
+            }
+        }
+        return sent;
+    }
+    /**
+     * Forward a DATA payload to a friend through any relay where they're
+     * online. Returns the count of relays that accepted the write — 0 if
+     * the friend isn't online on any TCP relay.
+     */
+    sendToFriend(friendPublicKey, payload) {
+        if (friendPublicKey.length !== KEY_SIZE)
+            return 0;
+        // Send via the FIRST connected relay where the friend is online; only
+        // fall over to the next relay if the send call returns false. Sending
+        // via every relay simultaneously (the previous behavior) caused each
+        // application-level message to be delivered N times to the receiver,
+        // where N = number of shared relays. The receiver's net_crypto layer
+        // does deduplicate by packet_number, but only after the duplicate has
+        // already been propagated through the message dispatcher — so peer
+        // callbacks (onText etc.) and any IP packet forwarding built on top
+        // get the duplicate too. With this change, redundancy still kicks in
+        // automatically when a relay rejects the write.
+        for (const r of this.#relays) {
+            if (r.client?.state() !== "connected")
+                continue;
+            if (!r.client.hasFriendOnline(friendPublicKey))
+                continue;
+            if (r.client.sendToFriend(friendPublicKey, payload)) {
+                return 1;
+            }
+        }
+        return 0;
+    }
+    /** Diagnostics. */
+    connectedCount() {
+        return this.#relays.filter((r) => r.client?.state() === "connected").length;
+    }
+    /**
+     * Snapshot of currently-connected relays for inclusion in DHT-PK
+     * announce extras. Mirrors toxcore's `tcp_copy_connected_relays`.
+     * Returns up to `max` entries, each with the relay's public key and
+     * its host:port — enough for the receiver to add the relay to its
+     * own pool via TcpRelayPool.addRelay and start routing through it.
+     */
+    connectedRelays(max = 4) {
+        const out = [];
+        for (const r of this.#relays) {
+            if (out.length >= max)
+                break;
+            if (r.client?.state() === "connected") {
+                out.push({
+                    host: r.node.host,
+                    port: r.node.port,
+                    serverPublicKey: r.serverPublicKey
+                });
+            }
+        }
+        return out;
+    }
+    async #openOne(idx) {
+        if (this.#stopped)
+            return;
+        const managed = this.#relays[idx];
+        if (!managed)
+            return;
+        if (managed.client)
+            return; // already trying
+        const client = new TcpRelayClient({
+            host: managed.node.host,
+            port: managed.node.port,
+            serverPublicKey: managed.serverPublicKey,
+            selfKeyPair: this.#opts.selfKeyPair,
+            label: this.#opts.label
+                ? `${this.#opts.label}#${idx}`
+                : `relay#${idx}`
+        });
+        managed.client = client;
+        client.on("open", () => {
+            managed.reconnectAttempt = 0;
+            this.#log(`relay ${idx} ${managed.node.host}:${managed.node.port} open`);
+            // (Re-)issue routes for all wanted friends.
+            for (const friend of this.#wantedFriends.values()) {
+                client.requestRoute(friend);
+            }
+            this.#emitStatus();
+        });
+        client.on("close", (reason) => {
+            this.#log(`relay ${idx} ${managed.node.host}:${managed.node.port} closed: ${reason}`);
+            // Demote any "online" markers held by this relay for our friends.
+            for (const [friendHex, set] of this.#onlineRelaysByFriend) {
+                if (set.delete(idx) && set.size === 0) {
+                    const raw = this.#wantedFriends.get(friendHex);
+                    if (raw)
+                        this.emit("friendOffline", raw);
+                    this.#onlineRelaysByFriend.delete(friendHex);
+                }
+            }
+            managed.client = undefined;
+            this.#emitStatus();
+            this.#scheduleReconnect(idx);
+        });
+        client.on("friendOnline", (friendKey) => {
+            const hex = Buffer.from(friendKey).toString("hex");
+            let set = this.#onlineRelaysByFriend.get(hex);
+            if (!set) {
+                set = new Set();
+                this.#onlineRelaysByFriend.set(hex, set);
+            }
+            const wasEmpty = set.size === 0;
+            set.add(idx);
+            if (wasEmpty) {
+                this.emit("friendOnline", new Uint8Array(friendKey));
+            }
+        });
+        client.on("friendOffline", (friendKey) => {
+            const hex = Buffer.from(friendKey).toString("hex");
+            const set = this.#onlineRelaysByFriend.get(hex);
+            if (!set)
+                return;
+            if (set.delete(idx) && set.size === 0) {
+                this.#onlineRelaysByFriend.delete(hex);
+                this.emit("friendOffline", new Uint8Array(friendKey));
+            }
+        });
+        client.on("peerData", (friendKey, payload) => {
+            this.emit("peerData", new Uint8Array(friendKey), payload);
+        });
+        client.on("oob", (senderKey, payload) => {
+            this.emit("oob", new Uint8Array(senderKey), payload);
+        });
+        try {
+            await client.connect(10_000);
+        }
+        catch (err) {
+            this.#log(`relay ${idx} ${managed.node.host}:${managed.node.port} connect failed: ${err.message}`);
+            managed.client = undefined;
+            this.#scheduleReconnect(idx);
+            throw err;
+        }
+    }
+    #scheduleReconnect(idx) {
+        if (this.#stopped)
+            return;
+        const managed = this.#relays[idx];
+        if (!managed)
+            return;
+        if (managed.reconnectTimer)
+            return;
+        managed.reconnectAttempt = Math.min(managed.reconnectAttempt + 1, 8);
+        const delay = Math.min(RECONNECT_MAX_MS, RECONNECT_BASE_MS * Math.pow(1.5, managed.reconnectAttempt - 1));
+        managed.reconnectTimer = setTimeout(() => {
+            managed.reconnectTimer = undefined;
+            void this.#openOne(idx).catch(() => { });
+        }, delay);
+        managed.reconnectTimer.unref?.();
+        this.#log(`relay ${idx} ${managed.node.host}:${managed.node.port} reconnect in ${Math.round(delay)}ms (attempt ${managed.reconnectAttempt})`);
+    }
+    #emitStatus() {
+        this.emit("status", this.connectedCount(), this.#relays.length);
+    }
+    #log(message) {
+        if (!this.#debug)
+            return;
+        const label = this.#opts.label ? `:${this.#opts.label}` : "";
+        console.log(`[peer-debug:tcp-pool${label}] ${message}`);
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    once(event, listener) {
+        return super.once(event, listener);
+    }
+    off(event, listener) {
+        return super.off(event, listener);
+    }
+}