@peers-app/peers-sdk 0.30.3 → 0.30.4

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

@@ -5,20 +5,30 @@ 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" | "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;
 }
 /** 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 +43,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 +70,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 +83,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 +135,11 @@ export interface IMeshStats {
             probes: number;
             connected: number;
         };
+        /** Lifetime episodes excluded from latency percentiles, by reason. */
+        unmeasuredEpisodes?: {
+            pageHidden: number;
+            stillCovered: number;
+        };
         unfinishedAttempts: number;
         doubleDials: number;
         offlineDials: number;
@@ -137,6 +156,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/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.4",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/peers-app/peers-sdk.git"