@leofcoin/peernet 1.1.96 → 1.1.98

package/exports/browser/{client-BlYwNU8G.js → client-UwSHOtRi.js}

@@ -1,4 +1,4 @@
-import { L as LittlePubSub } from './peernet-BXonj_o8.js';
+import { L as LittlePubSub } from './peernet-DzeROp0A.js';
 import './identity-Cn0iQbY3.js';
 import './value-C3vAp-wb.js';
 
@@ -428,7 +428,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 +471,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 +562,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 +637,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`);
                 }
@@ -611,7 +725,7 @@ 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]
         }
@@ -685,15 +799,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-Y4l0mXGt.js → messages-CFqwXbrQ.js}

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

package/exports/browser/{peernet-BXonj_o8.js → peernet-DzeROp0A.js}

@@ -7968,9 +7968,9 @@ const lastFetched = {
 const fetchedCoordinates = {};
 const getAddress = async () => {
     const { address } = lastFetched;
-    if (address) {
-        address.value = await fetch('https://icanhazip.com/');
-        address.value = await address.value.text();
+    if (!address) {
+        const value = await fetch('https://icanhazip.com/');
+        address.value = await value.text();
         address.timestamp = Math.round(new Date().getTime() / 1000);
         lastFetched.address = address;
     }
@@ -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-Y4l0mXGt.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-CFqwXbrQ.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-BlYwNU8G.js');
+        const importee = await import('./client-UwSHOtRi.js');
         /**
          * @access public
          * @type {PeernetClient}

package/exports/browser/peernet.js

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

package/exports/peernet.js

@@ -159,9 +159,9 @@ const lastFetched = {
 const fetchedCoordinates = {};
 const getAddress = async () => {
     const { address } = lastFetched;
-    if (address) {
-        address.value = await fetch('https://icanhazip.com/');
-        address.value = await address.value.text();
+    if (!address) {
+        const value = await fetch('https://icanhazip.com/');
+        address.value = await value.text();
         address.timestamp = Math.round(new Date().getTime() / 1000);
         lastFetched.address = address;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/peernet",
-  "version": "1.1.96",
+  "version": "1.1.98",
   "description": "",
   "browser": "./exports/browser/peernet.js",
   "exports": {
@@ -37,13 +37,13 @@
     "@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.24",
     "@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.9.2",
     "multi-signature": "^1.3.1",
     "qr-scanner": "^1.4.2",
     "qrcode": "^1.5.4",
@@ -57,8 +57,8 @@
     "@rollup/plugin-node-resolve": "^16.0.1",
     "@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.3.0",
     "@types/qrcode": "^1.5.5",
     "@types/secp256k1": "^4.0.6",
     "@types/varint": "^6.0.3",

package/src/dht/dht.ts

@@ -38,9 +38,9 @@ const fetchedCoordinates = {}
 
 export const getAddress = async () => {
   const { address } = lastFetched
-  if (address) {
-    address.value = await fetch('https://icanhazip.com/')
-    address.value = await address.value.text()
+  if (!address) {
+    const value = await fetch('https://icanhazip.com/')
+    address.value = await value.text()
     address.timestamp = Math.round(new Date().getTime() / 1000)
     lastFetched.address = address
   }