@peers-app/peers-sdk 0.30.3 → 0.30.5

package/dist/contracts/system/mesh-metrics-types.d.ts

@@ -5,20 +5,38 @@ export type MeshDialReason = "own-device" | "group-network-info" | "broadcast-an
 /** Bounded path categories used for lifetime counters; attempts also retain the address. */
 export type MeshPath = "websocket" | "webrtc" | "cloud" | "discovery";
 /** Failure categories, independent of free-form transport error messages. */
-export type MeshFailureReason = "ttl0" | "no-route" | "signaling-timeout" | "socket-error" | "socket-timeout" | "handshake" | "rejected" | "closed" | "superseded" | "unsupported";
+export type MeshFailureReason = "ttl0" | "no-route" | "signaling-timeout" | "socket-error" | "socket-timeout" | "handshake" | "rejected" | "closed" | "superseded" | "unsupported" | "sender-not-known"
+/** This device can't encrypt to the target yet: no owner-signed row or profile for it here. */
+ | "recipient-unknown" | "trust-refused" | "identity-mismatch" | "cancelled" | "capacity";
 /** Observed stage; timestamps are offsets in milliseconds from the attempt's queued time. */
 export type MeshStage = "queued" | "started" | "authenticated" | "admitted" | "ready" | "firstSync";
-/** Optional observational metadata passed through a dial without affecting its result. */
+/** Local dial metadata and cancellation; never serialized into device messages. */
 export interface IMeshDial {
+    /** Cancels pending transport work; an admitted winner is retained. */
+    signal?: AbortSignal;
+    /** Scheduler priority: bootstrap, coverage, repair, then redundancy. */
+    priority?: 1 | 2 | 3 | 4;
     attemptId?: string;
     reason?: MeshDialReason;
     targetDeviceId?: string;
+    /** One-based retry number; absent for the initial dial. */
+    retry?: number;
+    /**
+     * Metrics only: the logical dial this transport races alongside (a published address tried
+     * next to the device-id path). It's recorded as an attempt of its own but counted as part of
+     * that dial, and its failures don't end the dial.
+     */
+    siblingOf?: string;
 }
 /** One dial or inbound connection. Missing stages have not been observed. */
 export interface IMeshAttempt {
     attemptId: string;
     targetDeviceId?: string;
     reason: MeshDialReason;
+    /** One-based retry number; absent for initial and incoming attempts. */
+    retry?: number;
+    /** Scheduler priority when this was planned locally. */
+    priority?: 1 | 2 | 3 | 4;
     direction: "outgoing" | "incoming";
     path: MeshPath;
     address?: string;
@@ -33,7 +51,7 @@ export interface IMeshAttempt {
     };
     ready: Record<string, number>;
     firstSync: Record<string, number>;
-    outcome: "pending" | "admitted" | "failed" | "unfinished";
+    outcome: "pending" | "admitted" | "failed" | "cancelled" | "unfinished";
     endReason?: "buffer-evicted" | "disposed";
     endedAt?: number;
     durationMs?: number;
@@ -60,6 +78,10 @@ export interface IMeshContextCoverage {
     possibleSourceDeviceIds: string[];
     usableDeviceIds: string[];
     excluded: boolean;
+    /** True when an unmet context cannot currently fit at the connection cap. */
+    limitedByCapacity?: boolean;
+    /** Planner target; zero means no possible source. */
+    target?: number;
 }
 /** One connectivity episode, independent of any other episode in flight. */
 export interface IMeshEpisode {
@@ -69,8 +91,8 @@ export interface IMeshEpisode {
     startedAt: number;
     endedAt?: number;
     durationMs?: number;
-    outcome: "active" | "covered" | "unfinished";
-    endReason?: "covered" | "deadline" | "buffer-evicted" | "disposed";
+    outcome: "active" | "covered" | "unfinished" | "not-measured";
+    endReason?: "covered" | "deadline" | "buffer-evicted" | "disposed" | "page-hidden" | "still-covered";
     metrics: IMeshDurations;
     contexts: IMeshContextCoverage[];
 }
@@ -121,6 +143,22 @@ export interface IMeshStats {
             probes: number;
             connected: number;
         };
+        /**
+         * Dials helped by what devices publish: dials that tried a device's published addresses,
+         * those an address won, and the relayed protocol queries made and skipped because the
+         * device's protocols were known. Absent from devices older than these counters.
+         */
+        dialHints?: {
+            addressDials: number;
+            addressWins: number;
+            protocolQueries: number;
+            protocolQueriesSkipped: number;
+        };
+        /** Lifetime episodes excluded from latency percentiles, by reason. */
+        unmeasuredEpisodes?: {
+            pageHidden: number;
+            stillCovered: number;
+        };
         unfinishedAttempts: number;
         doubleDials: number;
         offlineDials: number;
@@ -137,6 +175,8 @@ export interface IMeshStats {
     };
     recentAttempts: IMeshAttempt[];
     recentBroadcasts: IMeshBroadcast[];
+    /** Latest planner coverage, including zero targets and capacity limitations. */
+    coverage?: IMeshContextCoverage[];
 }
 /** A discovery broadcast and its observed reply, bounded with the attempt history. */
 export interface IMeshBroadcast {

package/dist/data/authority-write-checks.js

@@ -312,6 +312,14 @@ async function checkDevice(existing, candidate, context) {
         !signed(candidate)) {
         throw (0, write_checks_1.writeNotAuthorized)("Devices", "the ownership claim doesn't verify");
     }
+    // Only the owner publishes how to dial its device. Sync keeps the stored block when a writer
+    // drops it or holds an older one (retainDeviceReachability), so this refuses only a forgery.
+    if (candidate?.reachability &&
+        (candidate.userId !== existing?.userId ||
+            !(0, devices_1.sameDeviceReachability)(candidate.reachability, existing?.reachability)) &&
+        !(0, devices_1.isDeviceReachabilitySigned)(candidate, users.get(ownerId ?? candidate.userId)?.publicKey)) {
+        throw (0, write_checks_1.writeNotAuthorized)("Devices", "reachability isn't signed by the device's owner");
+    }
 }
 (0, write_checks_1.registerTableWriteCheck)("Users", checkUser);
 (0, write_checks_1.registerTableWriteCheck)("Devices", checkDevice);

package/dist/data/devices.d.ts

@@ -5,6 +5,34 @@ import { TrustLevel } from "../device/socket.type";
 export declare const DISPLAY_NAME_MAX_LENGTH = 128;
 /** Shared schema for bounded user and device display names. */
 export declare const displayNameSchema: z.ZodString;
+/** Most origins one device publishes: every LAN interface plus a configured public origin. */
+export declare const DEVICE_REACHABILITY_MAX_ADDRESSES = 16;
+/** Most protocol names one device publishes. */
+export declare const DEVICE_REACHABILITY_MAX_PROTOCOLS = 8;
+/**
+ * How a device can be dialed, published by its owner on its own Devices row: the origins its peer
+ * listener accepts connections on, and the protocols it supports. Only the owner writes it, signed
+ * with the owner's key, and the newest signed `updatedAt` wins. Addresses are a fast path; every
+ * dial still checks that the expected device answers.
+ */
+export declare const deviceReachabilitySchema: z.ZodObject<{
+    addresses: z.ZodArray<z.ZodString, "many">;
+    protocols: z.ZodArray<z.ZodString, "many">;
+    updatedAt: z.ZodNumber;
+    signature: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    signature: string;
+    updatedAt: number;
+    addresses: string[];
+    protocols: string[];
+}, {
+    signature: string;
+    updatedAt: number;
+    addresses: string[];
+    protocols: string[];
+}>;
+/** How a device can be dialed, as its owner published it (see {@link deviceReachabilitySchema}). */
+export type IDeviceReachability = z.infer<typeof deviceReachabilitySchema>;
 /** Schema for a persisted, context-scoped device record. */
 export declare const deviceSchema: z.ZodObject<{
     deviceId: z.ZodEffects<z.ZodString, string, string>;
@@ -16,6 +44,22 @@ export declare const deviceSchema: z.ZodObject<{
     serverUrl: z.ZodOptional<z.ZodString>;
     trustLevel: z.ZodNativeEnum<typeof TrustLevel>;
     ownerSignature: z.ZodOptional<z.ZodString>;
+    reachability: z.ZodOptional<z.ZodObject<{
+        addresses: z.ZodArray<z.ZodString, "many">;
+        protocols: z.ZodArray<z.ZodString, "many">;
+        updatedAt: z.ZodNumber;
+        signature: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        signature: string;
+        updatedAt: number;
+        addresses: string[];
+        protocols: string[];
+    }, {
+        signature: string;
+        updatedAt: number;
+        addresses: string[];
+        protocols: string[];
+    }>>;
 }, "strip", z.ZodTypeAny, {
     userId: string;
     deviceId: string;
@@ -26,6 +70,12 @@ export declare const deviceSchema: z.ZodObject<{
     reportedName?: string | undefined;
     serverUrl?: string | undefined;
     ownerSignature?: string | undefined;
+    reachability?: {
+        signature: string;
+        updatedAt: number;
+        addresses: string[];
+        protocols: string[];
+    } | undefined;
 }, {
     userId: string;
     deviceId: string;
@@ -36,6 +86,12 @@ export declare const deviceSchema: z.ZodObject<{
     reportedName?: string | undefined;
     serverUrl?: string | undefined;
     ownerSignature?: string | undefined;
+    reachability?: {
+        signature: string;
+        updatedAt: number;
+        addresses: string[];
+        protocols: string[];
+    } | undefined;
 }>;
 /** A context-scoped device record containing local state and owner-reported metadata. */
 export type IDevice = z.infer<typeof deviceSchema>;
@@ -58,6 +114,41 @@ export declare function deviceOwnerStatement(device: Pick<IDevice, "deviceId" |
  * @param ownerPublicKey - The signing key of `device.userId`, as this device knows it.
  */
 export declare function isDeviceOwnerSigned(device: Pick<IDevice, "deviceId" | "userId" | "ownerSignature">, ownerPublicKey: string | undefined): boolean;
+/**
+ * What a device's owner signs to publish how to dial it: the contents of
+ * `reachability.signature`. Arrays are signed in the order given, so publishers sort them.
+ *
+ * @param deviceId - The device the reachability is for.
+ * @param reachability - Its addresses, protocols and publishing time.
+ */
+export declare function deviceReachabilityStatement(deviceId: string, reachability: Pick<IDeviceReachability, "addresses" | "protocols" | "updatedAt">): {
+    purpose: string;
+    deviceId: string;
+    addresses: string[];
+    protocols: string[];
+    updatedAt: number;
+};
+/**
+ * Whether `device.reachability` carries `ownerPublicKey`'s signature over
+ * {@link deviceReachabilityStatement}: the device's owner published it, not whoever wrote the row.
+ *
+ * @param device - A Devices row.
+ * @param ownerPublicKey - The signing key of the device's owner, as this device knows it.
+ */
+export declare function isDeviceReachabilitySigned(device: Pick<IDevice, "deviceId" | "reachability">, ownerPublicKey: string | undefined): boolean;
+/** Whether two reachability blocks are the same publication. */
+export declare function sameDeviceReachability(a: IDeviceReachability | undefined, b: IDeviceReachability | undefined): boolean;
+/**
+ * The row to store when `candidate` replaces `existing`: the candidate, keeping the stored
+ * `reachability` when the candidate has none or an older one (a tie keeps the stored one too).
+ * Writers that don't know the field (older builds) or hold a stale copy never roll it back;
+ * only a newer publication replaces it. Signatures are checked separately, by the group write
+ * check and by whoever dials.
+ *
+ * @param existing - The row as stored now, if any.
+ * @param candidate - The row about to be stored.
+ */
+export declare function retainDeviceReachability<T extends Partial<IDevice>>(existing: Partial<IDevice> | undefined, candidate: T): T;
 /** Schema for the signed identity and bounded presentation hints exchanged by devices. */
 export declare const deviceInfoSchema: z.ZodObject<{
     userId: z.ZodEffects<z.ZodString, string, string>;
@@ -237,6 +328,12 @@ export declare function Devices(dataContext?: DataContext): import("..").Table<{
     reportedName?: string | undefined;
     serverUrl?: string | undefined;
     ownerSignature?: string | undefined;
+    reachability?: {
+        signature: string;
+        updatedAt: number;
+        addresses: string[];
+        protocols: string[];
+    } | undefined;
 }>;
 /** Persistent identifier for the current physical/runtime device. */
 export declare const thisDeviceId: import("./persistent-vars").PersistentVar<string | undefined>;

package/dist/data/devices.js

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.thisDeviceId = exports.deviceHandshakeSchema = exports.handshakeFrameCryptoSchema = exports.deviceInfoSchema = exports.deviceSchema = exports.displayNameSchema = exports.DISPLAY_NAME_MAX_LENGTH = void 0;
+exports.thisDeviceId = exports.deviceHandshakeSchema = exports.handshakeFrameCryptoSchema = exports.deviceInfoSchema = exports.deviceSchema = exports.deviceReachabilitySchema = exports.DEVICE_REACHABILITY_MAX_PROTOCOLS = exports.DEVICE_REACHABILITY_MAX_ADDRESSES = exports.displayNameSchema = exports.DISPLAY_NAME_MAX_LENGTH = void 0;
 exports.deviceOwnerStatement = deviceOwnerStatement;
 exports.isDeviceOwnerSigned = isDeviceOwnerSigned;
+exports.deviceReachabilityStatement = deviceReachabilityStatement;
+exports.isDeviceReachabilitySigned = isDeviceReachabilitySigned;
+exports.sameDeviceReachability = sameDeviceReachability;
+exports.retainDeviceReachability = retainDeviceReachability;
 exports.Devices = Devices;
 const zod_1 = require("zod");
 const user_context_singleton_1 = require("../context/user-context-singleton");
@@ -17,6 +21,30 @@ const persistent_vars_1 = require("./persistent-vars");
 exports.DISPLAY_NAME_MAX_LENGTH = 128;
 /** Shared schema for bounded user and device display names. */
 exports.displayNameSchema = zod_1.z.string().max(exports.DISPLAY_NAME_MAX_LENGTH);
+/** Most origins one device publishes: every LAN interface plus a configured public origin. */
+exports.DEVICE_REACHABILITY_MAX_ADDRESSES = 16;
+/** Most protocol names one device publishes. */
+exports.DEVICE_REACHABILITY_MAX_PROTOCOLS = 8;
+/**
+ * How a device can be dialed, published by its owner on its own Devices row: the origins its peer
+ * listener accepts connections on, and the protocols it supports. Only the owner writes it, signed
+ * with the owner's key, and the newest signed `updatedAt` wins. Addresses are a fast path; every
+ * dial still checks that the expected device answers.
+ */
+exports.deviceReachabilitySchema = zod_1.z.object({
+    addresses: zod_1.z
+        .array(zod_1.z.string().max(256))
+        .max(exports.DEVICE_REACHABILITY_MAX_ADDRESSES)
+        .describe("Origins the device's peer listener accepts connections on, in a stable order"),
+    protocols: zod_1.z
+        .array(zod_1.z.string().max(32))
+        .max(exports.DEVICE_REACHABILITY_MAX_PROTOCOLS)
+        .describe("Protocols the device can be dialed with, such as ws and wrtc"),
+    updatedAt: zod_1.z.number().describe("When the owner published this, in ms; the newest one wins"),
+    signature: zod_1.z
+        .string()
+        .describe("The owner's signature over deviceReachabilityStatement, without the key prefix"),
+});
 /** Schema for a persisted, context-scoped device record. */
 exports.deviceSchema = zod_1.z.object({
     deviceId: zod_types_1.zodPeerId,
@@ -31,6 +59,9 @@ exports.deviceSchema = zod_1.z.object({
         .string()
         .optional()
         .describe("The owner's signature claiming this device for userId (see deviceOwnerStatement). In a group, only a row with a valid one says who a device belongs to, and it stays theirs"),
+    reachability: exports.deviceReachabilitySchema
+        .optional()
+        .describe("How to dial this device, published and signed by its owner. Sync keeps the newest signed copy, so a writer without it never clears it"),
 });
 /**
  * What a device's owner signs to claim it: the contents of `ownerSignature`. Each device signs
@@ -56,6 +87,74 @@ function isDeviceOwnerSigned(device, ownerPublicKey) {
         signature: `${ownerPublicKey}:${device.ownerSignature}`,
     }) === ownerPublicKey);
 }
+/**
+ * What a device's owner signs to publish how to dial it: the contents of
+ * `reachability.signature`. Arrays are signed in the order given, so publishers sort them.
+ *
+ * @param deviceId - The device the reachability is for.
+ * @param reachability - Its addresses, protocols and publishing time.
+ */
+function deviceReachabilityStatement(deviceId, reachability) {
+    return {
+        purpose: "peers-device-reachability",
+        deviceId,
+        addresses: reachability.addresses,
+        protocols: reachability.protocols,
+        updatedAt: reachability.updatedAt,
+    };
+}
+/**
+ * Whether `device.reachability` carries `ownerPublicKey`'s signature over
+ * {@link deviceReachabilityStatement}: the device's owner published it, not whoever wrote the row.
+ *
+ * @param device - A Devices row.
+ * @param ownerPublicKey - The signing key of the device's owner, as this device knows it.
+ */
+function isDeviceReachabilitySigned(device, ownerPublicKey) {
+    const reachability = device.reachability;
+    if (!reachability?.signature || !ownerPublicKey)
+        return false;
+    return ((0, keys_1.signedByKey)({
+        ...deviceReachabilityStatement(device.deviceId, reachability),
+        signature: `${ownerPublicKey}:${reachability.signature}`,
+    }) === ownerPublicKey);
+}
+/** Whether two reachability blocks are the same publication. */
+function sameDeviceReachability(a, b) {
+    if (!a || !b)
+        return a === b;
+    return (a.updatedAt === b.updatedAt &&
+        a.signature === b.signature &&
+        a.addresses.length === b.addresses.length &&
+        a.addresses.every((address, i) => address === b.addresses[i]) &&
+        a.protocols.length === b.protocols.length &&
+        a.protocols.every((protocol, i) => protocol === b.protocols[i]));
+}
+/**
+ * The row to store when `candidate` replaces `existing`: the candidate, keeping the stored
+ * `reachability` when the candidate has none or an older one (a tie keeps the stored one too).
+ * Writers that don't know the field (older builds) or hold a stale copy never roll it back;
+ * only a newer publication replaces it. Signatures are checked separately, by the group write
+ * check and by whoever dials.
+ *
+ * @param existing - The row as stored now, if any.
+ * @param candidate - The row about to be stored.
+ */
+function retainDeviceReachability(existing, candidate) {
+    const stored = existing?.reachability;
+    if (!stored)
+        return candidate;
+    // An unclaimed discovery row can acquire a different owner. Its former owner's
+    // publication must neither follow that claim nor prevent the new owner's publication.
+    if (existing.userId && candidate.userId && existing.userId !== candidate.userId)
+        return candidate;
+    const incoming = candidate.reachability;
+    if (incoming && incoming.updatedAt > stored.updatedAt)
+        return candidate;
+    if (incoming && sameDeviceReachability(incoming, stored))
+        return candidate;
+    return { ...candidate, reachability: stored };
+}
 /** Schema for the signed identity and bounded presentation hints exchanged by devices. */
 exports.deviceInfoSchema = zod_1.z.object({
     userId: zod_types_1.zodPeerId,

package/dist/device/connection.d.ts

@@ -42,6 +42,8 @@ export declare class Connection {
     private pendingSendArm;
     /** Bumped by every {@link Connection.reset}, so a handshake can tell it was cut short. */
     private handshakeGeneration;
+    /** Local close intent, retained through reset so retry owners do not penalize orderly shedding. */
+    closeIntent?: "remote" | "policy";
     constructor(socket: ISocket, localDevice: Device, localDeviceServerAddresses?: string[] | undefined, getTrustLevel?: GetTrustLevel);
     /** True once the remote identity has been authenticated by the handshake. */
     get verified(): boolean;
@@ -151,5 +153,8 @@ export declare class Connection {
      */
     close(): Promise<void>;
 }
-/** Normalizes a peer address for transport and security comparisons. */
+/** Lowercases a peer address and removes a trailing slash; preserves its scheme. */
 export declare function normalizeAddress(address: string): string;
+/** Local handshake refusal. Its existing Error text remains compatible with older peers. */
+export declare class ConnectionTrustError extends Error {
+}

package/dist/device/connection.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Connection = void 0;
+exports.ConnectionTrustError = exports.Connection = void 0;
 exports.normalizeAddress = normalizeAddress;
 const user_context_singleton_1 = require("../context/user-context-singleton");
 const data_1 = require("../data");
@@ -62,6 +62,8 @@ class Connection {
     pendingSendArm;
     /** Bumped by every {@link Connection.reset}, so a handshake can tell it was cut short. */
     handshakeGeneration = 0;
+    /** Local close intent, retained through reset so retry owners do not penalize orderly shedding. */
+    closeIntent;
     constructor(socket, localDevice, localDeviceServerAddresses, getTrustLevel = () => Promise.resolve(socket_type_1.TrustLevel.Unknown)) {
         this.localDevice = localDevice;
         this.localDeviceServerAddresses = localDeviceServerAddresses;
@@ -76,6 +78,7 @@ class Connection {
         socket.setPlaintextStreamsAllowed?.(false);
         // Only the server side of a connection should expose these methods
         this.exposeRPC("close", () => {
+            this.closeIntent ??= "remote";
             (0, utils_1.sleep)(100).then(() => {
                 this.closeLocal();
             });
@@ -404,7 +407,7 @@ class Connection {
         this.assertHandshakeCurrent(generation);
         if (trustLevel < socket_type_1.TrustLevel.Unknown) {
             this.resetRemote();
-            throw new Error("Untrusted connection");
+            throw new ConnectionTrustError("Untrusted connection");
         }
         // The client seals everything after it reads our response, so receive
         // can arm now; send arms after the response frame goes out.
@@ -466,7 +469,7 @@ class Connection {
             this.trustLevel = trustLevel;
             if (this.trustLevel < socket_type_1.TrustLevel.Unknown) {
                 this.resetRemote();
-                throw new Error("Untrusted connection");
+                throw new ConnectionTrustError("Untrusted connection");
             }
             return handshakeResponse;
         }
@@ -613,7 +616,11 @@ async function noteHandshakeContest(contest) {
         console.warn("Could not apply a key contest from the handshake", err);
     }
 }
-/** Normalizes a peer address for transport and security comparisons. */
+/** Lowercases a peer address and removes a trailing slash; preserves its scheme. */
 function normalizeAddress(address) {
     return address.toLowerCase().replace(/\/$/, "");
 }
+/** Local handshake refusal. Its existing Error text remains compatible with older peers. */
+class ConnectionTrustError extends Error {
+}
+exports.ConnectionTrustError = ConnectionTrustError;

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

@@ -14,6 +14,7 @@ import type { IBinaryPeer } from "./binary-peer-connection-v2";
 interface ISocketIO {
     id?: string;
     on(event: string, handler: (...args: any[]) => void): void;
+    off(event: string, handler: (...args: any[]) => void): void;
     emit(event: string, ...args: any[]): void;
     removeAllListeners(event?: string): void;
     disconnect(): void;

package/dist/device/socket-io-binary-peer.js

@@ -22,8 +22,11 @@ function wrapSocketIOAsBinaryPeer(socket) {
     const closeHandlers = [];
     const drainHandlers = [];
     let pendingBytes = 0;
+    let closed = false;
     // Listen for binary data
-    socket.on(BINARY_EVENT, (data) => {
+    const onData = (data) => {
+        if (closed)
+            return;
         // Ensure we have a proper Uint8Array
         const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
         dataHandlers.forEach((handler) => {
@@ -34,9 +37,16 @@ function wrapSocketIOAsBinaryPeer(socket) {
                 console.error("[socket-io-binary] Error in data handler:", err);
             }
         });
-    });
+    };
     // Listen for disconnect
-    socket.on("disconnect", () => {
+    const onDisconnect = () => {
+        if (closed)
+            return;
+        closed = true;
+        // This adapter belongs to one connection incarnation. A delayed close from it
+        // must never disconnect a reconnected Socket.IO socket or remove its listeners.
+        socket.off(BINARY_EVENT, onData);
+        socket.off("disconnect", onDisconnect);
         closeHandlers.forEach((handler) => {
             try {
                 handler();
@@ -45,7 +55,9 @@ function wrapSocketIOAsBinaryPeer(socket) {
                 console.error("[socket-io-binary] Error in close handler:", err);
             }
         });
-    });
+    };
+    socket.on(BINARY_EVENT, onData);
+    socket.on("disconnect", onDisconnect);
     return {
         on(event, handler) {
             if (event === "data") {
@@ -59,6 +71,8 @@ function wrapSocketIOAsBinaryPeer(socket) {
             }
         },
         send(data) {
+            if (closed)
+                return;
             const bytes = typeof data === "string"
                 ? Buffer.from(data)
                 : data instanceof Uint8Array
@@ -79,7 +93,9 @@ function wrapSocketIOAsBinaryPeer(socket) {
             });
         },
         destroy() {
-            socket.removeAllListeners(BINARY_EVENT);
+            if (closed)
+                return;
+            onDisconnect();
             socket.disconnect();
         },
         getBufferedAmount() {

package/dist/types/peer-device.d.ts

@@ -26,7 +26,11 @@ export interface IDeviceMessage<T = any> {
     deviceMessageId: string;
     /** Device that originated the message. */
     fromDeviceId: string;
-    /** Signed source identity used to bootstrap fresh same-user devices. */
+    /**
+     * Signed source identity. Lets a receiver accept a device it hasn't met yet when the device
+     * belongs to the receiver's own user (personal context) or to a counted member of the
+     * message's group.
+     */
     fromDeviceInfo?: ISignedObject<IDeviceInfo>;
     /** Intended destination device. */
     toDeviceId: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peers-app/peers-sdk",
-  "version": "0.30.3",
+  "version": "0.30.5",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/peers-app/peers-sdk.git"