@leofcoin/peernet 1.1.97 → 1.1.99

package/exports/browser/{client-BDXkFVRR.js → client-BfWOZz0W.js}

@@ -1,4 +1,4 @@
-import { L as LittlePubSub } from './peernet-O_tySEFY.js';
+import { L as LittlePubSub } from './peernet-BQUef8u4.js';
 import './identity-Cn0iQbY3.js';
 import './value-C3vAp-wb.js';
 
@@ -132,10 +132,9 @@ class Api {
                     throw e;
                 }
             },
-            peers: async (params) => {
+            peers: async () => {
                 try {
-                    params.peers = true;
-                    const requested = { url: 'peernet', params };
+                    const requested = { url: 'peernet', params: { peers: true } };
                     const { result, id, handler } = await this.request(client, requested);
                     this.unsubscribe(id, handler);
                     return result;
@@ -206,7 +205,7 @@ class SocketRequestClient {
     clientConnection;
     #tries = 0;
     #retry = false;
-    #timeout = 10000;
+    #timeout = 10_000;
     #times = 10;
     #options;
     #protocol;
@@ -342,16 +341,16 @@ class Peer extends SimplePeer {
     channelName;
     version;
     bw = { up: 0, down: 0 };
-    get connected() {
-        return super.connected;
-    }
     constructor(options) {
-        const { from, to, initiator, trickle, config, version } = options;
-        const channelName = initiator ? `${from}:${to}` : `${to}:${from}`;
+        const { from, to, trickle, config, version } = options;
+        // Canonical initiator and channel label based on sorted IDs
+        const [a, b] = [from, to].sort();
+        const channelName = `${a}:${b}`;
+        const initiator = from === a;
         super({
             channelName,
             initiator,
-            trickle: trickle || true,
+            trickle: trickle ?? true,
             config: { iceServers, ...config },
             wrtc: globalThis.wrtc
         });
@@ -428,7 +427,11 @@ class Client {
     #peerId;
     #connections = {};
     #stars = {};
+    #starListeners = {};
+    #handlersSetup = false;
+    #reinitLock = null;
     #connectEvent = 'peer:connected';
+    #retryOptions = { retries: 5, factor: 2, minTimeout: 1000, maxTimeout: 30000 };
     id;
     networkVersion;
     starsConfig;
@@ -467,21 +470,80 @@ class Client {
         this.version = version;
         this.#connectEvent = connectEvent;
         this.starsConfig = stars;
+        if (options?.retry)
+            this.#retryOptions = { ...this.#retryOptions, ...options.retry };
         this._init();
     }
-    async _init() {
-        // reconnectJob()
-        if (!globalThis.RTCPeerConnection)
-            globalThis.wrtc = (await import('./browser-Cjcx-T47.js').then(function (n) { return n.b; })).default;
-        for (const star of this.starsConfig) {
+    /**
+     * Safely reinitialize the client (used after system resume/sleep).
+     * It closes existing connections and reconnects to configured stars.
+     */
+    async reinit() {
+        // avoid concurrent reinit runs
+        if (this.#reinitLock)
+            return this.#reinitLock;
+        this.#reinitLock = (async () => {
+            debug('reinit: start');
+            try {
+                await this.close();
+                // clear internal maps so setupStar starts fresh
+                this.#stars = {};
+                this.#connections = {};
+                for (const star of this.starsConfig) {
+                    try {
+                        await this.setupStar(star);
+                    }
+                    catch (e) {
+                        // If last star fails and none connected, surface error
+                        if (this.starsConfig.indexOf(star) === this.starsConfig.length - 1 &&
+                            Object.keys(this.#stars).length === 0)
+                            throw new Error(`No star available to connect`);
+                    }
+                }
+            }
+            finally {
+                debug('reinit: done');
+                this.#reinitLock = null;
+            }
+        })();
+        return this.#reinitLock;
+    }
+    async setupStar(star) {
+        const { retries, factor, minTimeout, maxTimeout } = this.#retryOptions;
+        const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+        let attempt = 0;
+        let lastErr;
+        while (attempt <= retries) {
             try {
                 const client = new SocketRequestClient(star, this.networkVersion);
                 this.#stars[star] = await client.init();
-                this.setupStarListeners(this.#stars[star]);
+                this.setupStarListeners(this.#stars[star], star);
                 this.#stars[star].send({
                     url: 'join',
                     params: { version: this.version, peerId: this.peerId }
                 });
+                return this.#stars[star];
+            }
+            catch (e) {
+                lastErr = e;
+                attempt += 1;
+                if (attempt > retries)
+                    break;
+                const delay = Math.min(maxTimeout, Math.round(minTimeout * Math.pow(factor, attempt - 1)));
+                debug(`setupStar ${star} failed, retrying in ${delay}ms (attempt ${attempt})`);
+                // eslint-disable-next-line no-await-in-loop
+                await sleep(delay);
+            }
+        }
+        throw lastErr;
+    }
+    async _init() {
+        // reconnectJob()
+        if (!globalThis.RTCPeerConnection)
+            globalThis.wrtc = (await import('./browser-Cjcx-T47.js').then(function (n) { return n.b; })).default;
+        for (const star of this.starsConfig) {
+            try {
+                await this.setupStar(star);
             }
             catch (e) {
                 if (this.starsConfig.indexOf(star) === this.starsConfig.length - 1 &&
@@ -499,13 +561,68 @@ class Client {
         else {
             globalThis.addEventListener('beforeunload', this.close.bind(this));
         }
+        // Setup resume/sleep detection so we can reinit connections after wake
+        this._setupResumeHandler();
+    }
+    setupStarListeners(starConnection, starId) {
+        // create stable references to handlers so we can unsubscribe later
+        const onPeerJoined = (id) => this.#peerJoined(id, starConnection);
+        const onPeerLeft = (id) => this.#peerLeft(id, starConnection);
+        const onStarJoined = this.#starJoined;
+        const onStarLeft = this.#starLeft;
+        const onSignal = (message) => this.#inComingSignal(message, starConnection);
+        starConnection.pubsub.subscribe('peer:joined', onPeerJoined);
+        starConnection.pubsub.subscribe('peer:left', onPeerLeft);
+        starConnection.pubsub.subscribe('star:joined', onStarJoined);
+        starConnection.pubsub.subscribe('star:left', onStarLeft);
+        starConnection.pubsub.subscribe('signal', onSignal);
+        this.#starListeners[starId] = [
+            { topic: 'peer:joined', handler: onPeerJoined },
+            { topic: 'peer:left', handler: onPeerLeft },
+            { topic: 'star:joined', handler: onStarJoined },
+            { topic: 'star:left', handler: onStarLeft },
+            { topic: 'signal', handler: onSignal }
+        ];
     }
-    setupStarListeners(star) {
-        star.pubsub.subscribe('peer:joined', (id) => this.#peerJoined(id, star));
-        star.pubsub.subscribe('peer:left', (id) => this.#peerLeft(id, star));
-        star.pubsub.subscribe('star:joined', this.#starJoined);
-        star.pubsub.subscribe('star:left', this.#starLeft);
-        star.pubsub.subscribe('signal', (message) => this.#inComingSignal(message, star));
+    _setupResumeHandler() {
+        if (this.#handlersSetup)
+            return;
+        this.#handlersSetup = true;
+        const THRESHOLD = 10 * 1000; // 10s gap indicates sleep/wake
+        let last = Date.now();
+        const check = () => {
+            const now = Date.now();
+            const delta = now - last;
+            last = now;
+            if (delta > THRESHOLD) {
+                debug(`resume detected (gap ${delta}ms)`);
+                this.reinit().catch((e) => debug('reinit error', e));
+            }
+        };
+        // Start interval checker
+        const iv = setInterval(check, 2000);
+        // Browser specific events
+        if (typeof document !== 'undefined' && document.addEventListener) {
+            document.addEventListener('visibilitychange', () => {
+                if (document.visibilityState === 'visible') {
+                    // small delay to let timers update
+                    setTimeout(() => check(), 50);
+                }
+            });
+            window.addEventListener('online', () => setTimeout(() => check(), 50));
+        }
+        // Node: listen for SIGCONT (process continued) as well
+        if (globalThis.process?.on) {
+            try {
+                process.on('SIGCONT', () => setTimeout(() => check(), 50));
+            }
+            catch (e) {
+                // ignore
+            }
+        }
+        // keep reference so it can be cleared on close
+        // @ts-ignore
+        this._resumeInterval = iv;
     }
     #starJoined = (id) => {
         if (this.#stars[id]) {
@@ -519,20 +636,16 @@ class Client {
             this.#stars[id].close(0);
             delete this.#stars[id];
         }
+        // if we lost all stars, try to reconnect to configured stars with backoff
         if (Object.keys(this.#stars).length === 0) {
             for (const star of this.starsConfig) {
                 try {
-                    const socketClient = await new SocketRequestClient(star, this.networkVersion).init();
-                    if (!socketClient?.client?.OPEN)
-                        return;
-                    this.#stars[star] = socketClient;
-                    this.#stars[star].send({
-                        url: 'join',
-                        params: { peerId: this.peerId, version: this.version }
-                    });
-                    this.setupStarListeners(socketClient);
+                    await this.setupStar(star);
+                    // stop at first success
+                    return;
                 }
                 catch (e) {
+                    debug(`reconnect star ${star} failed: ${e.message || e}`);
                     if (this.starsConfig.indexOf(star) === this.starsConfig.length - 1)
                         throw new Error(`No star available to connect`);
                 }
@@ -548,7 +661,7 @@ class Client {
         }
         debug(`peer ${id} left`);
     };
-    connect(peerId, star, initiator = true) {
+    connect(peerId, star) {
         if (this.#connections[peerId]) {
             debug(`peer ${peerId} already connected`);
             return;
@@ -557,16 +670,15 @@ class Client {
             console.warn(`Star ${star} is not connected, cannot reconnect to peer ${peerId}`);
             return;
         }
-        this.#createRTCPeerConnection(peerId, star, this.version, initiator);
+        this.#createRTCPeerConnection(peerId, star, this.version);
     }
-    reconnect(peerId, star, initiator = true) {
+    reconnect(peerId, star) {
         delete this.#connections[peerId];
         debug(`reconnecting to peer ${peerId}`);
-        return this.connect(peerId, star, initiator);
+        return this.connect(peerId, star);
     }
-    #createRTCPeerConnection = (peerId, star, version, initiator = false) => {
+    #createRTCPeerConnection = (peerId, star, version) => {
         const peer = new Peer({
-            initiator: initiator,
             from: this.peerId,
             to: peerId,
             version
@@ -585,7 +697,7 @@ class Client {
             delete this.#connections[peerId];
         }
         if (this.peerId !== peerId)
-            this.#createRTCPeerConnection(peerId, star, version, true);
+            this.#createRTCPeerConnection(peerId, star, version);
         debug(`peer ${peerId} joined`);
     };
     #inComingSignal = async ({ from, signal, channelName, version }, star) => {
@@ -611,9 +723,10 @@ class Client {
             // Destroy the existing peer connection
             // peer.destroy()
             // delete this.#connections[from]
-            // // Create a new peer connection with the correct configuration
+            // // // Create a new peer connection with the correct configuration
             // this.#createRTCPeerConnection(from, star, version, false)
             // peer = this.#connections[from]
+            return;
         }
         peer.signal(signal);
     };
@@ -685,15 +798,53 @@ class Client {
         peer.destroy();
     };
     async close() {
+        // clear resume interval if set
+        // @ts-ignore
+        if (this._resumeInterval) {
+            // @ts-ignore
+            clearInterval(this._resumeInterval);
+            // @ts-ignore
+            this._resumeInterval = null;
+        }
         for (const star in this.#stars) {
-            if (this.#stars[star].connectionState() === 'open')
+            if (this.#stars[star].connectionState() === 'open') {
                 await this.#stars[star].send({ url: 'leave', params: this.peerId });
+                // unsubscribe handlers we registered earlier
+                const listeners = this.#starListeners[star];
+                if (listeners && listeners.length) {
+                    for (const { topic, handler } of listeners) {
+                        try {
+                            this.#stars[star].pubsub.unsubscribe(topic, handler);
+                        }
+                        catch (e) {
+                            // ignore
+                        }
+                    }
+                }
+            }
         }
-        const promises = [
-            Object.values(this.#connections).map((connection) => connection.destroy()),
-            Object.values(this.#stars).map((connection) => connection.close(0))
-        ];
-        return Promise.allSettled(promises);
+        // Ensure we wait for all peer and star close/destroy operations.
+        // Previous code passed an array of arrays to Promise.allSettled which
+        // resolves immediately; flatten into a single array of promises (or
+        // values) so we actually wait for async close operations.
+        const peerClosers = Object.values(this.#connections).map((connection) => {
+            try {
+                // destroy() may be sync or return a promise
+                return connection.destroy();
+            }
+            catch (e) {
+                return undefined;
+            }
+        });
+        const starClosers = Object.values(this.#stars).map((connection) => {
+            try {
+                return connection.close(0);
+            }
+            catch (e) {
+                return undefined;
+            }
+        });
+        return Promise.allSettled([...peerClosers, ...starClosers]);
     }
 }
 

package/exports/browser/{messages-DDEOxfJp.js → messages-B2WVXv2a.js}

@@ -1,4 +1,4 @@
-import { F as FormatInterface } from './peernet-O_tySEFY.js';
+import { F as FormatInterface } from './peernet-BQUef8u4.js';
 import './identity-Cn0iQbY3.js';
 import './value-C3vAp-wb.js';
 

package/exports/browser/{peernet-O_tySEFY.js → peernet-BQUef8u4.js}

@@ -8367,7 +8367,7 @@ class Peernet {
         this.root = options.root;
         const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile
         // FolderMessageResponse
-         } = await import(/* webpackChunkName: "messages" */ './messages-DDEOxfJp.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-B2WVXv2a.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -8461,7 +8461,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-BDXkFVRR.js');
+        const importee = await import('./client-BfWOZz0W.js');
         /**
          * @access public
          * @type {PeernetClient}

package/exports/browser/peernet.js

@@ -1,3 +1,3 @@
-export { P as default } from './peernet-O_tySEFY.js';
+export { P as default } from './peernet-BQUef8u4.js';
 import './identity-Cn0iQbY3.js';
 import './value-C3vAp-wb.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/peernet",
-  "version": "1.1.97",
+  "version": "1.1.99",
   "description": "",
   "browser": "./exports/browser/peernet.js",
   "exports": {
@@ -37,34 +37,34 @@
     "@leofcoin/identity-utils": "^1.0.2",
     "@leofcoin/multi-wallet": "^3.1.8",
     "@leofcoin/storage": "^3.5.38",
-    "@netpeer/swarm": "^0.8.21",
+    "@netpeer/swarm": "^0.8.29",
     "@vandeurenglenn/base32": "^1.2.4",
     "@vandeurenglenn/base58": "^1.1.9",
     "@vandeurenglenn/debug": "^1.2.6",
     "@vandeurenglenn/is-hex": "^1.1.1",
     "@vandeurenglenn/little-pubsub": "^1.5.1",
-    "inquirer": "^12.9.0",
+    "inquirer": "^12.10.0",
     "multi-signature": "^1.3.1",
     "qr-scanner": "^1.4.2",
     "qrcode": "^1.5.4",
-    "socket-request-client": "^2.1.0",
-    "socket-request-server": "^1.7.1"
+    "socket-request-client": "^2.1.2",
+    "socket-request-server": "^1.7.2"
   },
   "devDependencies": {
-    "@jest/globals": "^30.0.5",
-    "@rollup/plugin-commonjs": "^28.0.6",
+    "@jest/globals": "^30.2.0",
+    "@rollup/plugin-commonjs": "^28.0.8",
     "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-typescript": "^12.1.4",
     "@rollup/plugin-wasm": "^6.2.2",
-    "@types/bs58check": "^2.1.2",
-    "@types/node": "^24.1.0",
+    "@types/bs58check": "^3.0.1",
+    "@types/node": "^24.9.1",
     "@types/qrcode": "^1.5.5",
-    "@types/secp256k1": "^4.0.6",
+    "@types/secp256k1": "^4.0.7",
     "@types/varint": "^6.0.3",
-    "chai": "^5.2.1",
-    "cross-env": "^10.0.0",
-    "rollup": "^4.46.2",
+    "chai": "^6.2.0",
+    "cross-env": "^10.1.0",
+    "rollup": "^4.52.5",
     "sinon": "^21.0.0"
   }
 }