@decentnetwork/peer 0.1.150 → 0.1.151

package/dist/peer.js

@@ -395,6 +395,7 @@ export class Peer {
     #textHandlers = new Set();
     #pendingTextAcks = new Map();
     #deliveredTextIds = new Set();
+    #deliveredPersistTimer;
     #deliveredTextOrder = [];
     #friendStoreFile;
     #persistSeq = 0; // makes atomic friend-store temp filenames unique per write
@@ -598,6 +599,7 @@ export class Peer {
         }
         this.#cookieSymmetricKey = randomBytes(32);
         await this.#loadPersistedFriends();
+        await this.#loadDeliveredTextIds();
         if (this.#opts.expressNodes && this.#opts.expressNodes.length > 0) {
             this.#express = new LegacyExpressClient({
                 nodes: this.#opts.expressNodes,
@@ -1623,6 +1625,63 @@ export class Peer {
             if (old)
                 this.#deliveredTextIds.delete(old);
         }
+        this.#persistDeliveredTextIds();
+    }
+    /** Where the delivered-id set lives between runs. Next to the friend store,
+     *  because it is the same kind of state: what this node already knows. */
+    get #deliveredStoreFile() {
+        return this.#friendStoreFile ? `${this.#friendStoreFile}.delivered.json` : undefined;
+    }
+    /** Persist the seen delivery ids.
+     *
+     *  In memory only, this set died with the process — and the moment it did,
+     *  every message the sender had retransmitted while we were down was
+     *  accepted as new. Restart the daemon during a conversation and the last
+     *  messages arrive TWICE, which is exactly what a restart-heavy evening
+     *  looked like. The sender is behaving correctly: it never got an ACK, so
+     *  it resent. Remembering is the receiver's job.
+     *
+     *  Debounced: a busy chat would otherwise write the file per message. */
+    #persistDeliveredTextIds() {
+        const file = this.#deliveredStoreFile;
+        if (!file || this.#deliveredPersistTimer)
+            return;
+        this.#deliveredPersistTimer = setTimeout(() => {
+            this.#deliveredPersistTimer = undefined;
+            const payload = JSON.stringify(this.#deliveredTextOrder);
+            const tmp = `${file}.tmp.${process.pid}.${this.#persistSeq++}`;
+            void mkdir(dirname(file), { recursive: true })
+                .then(() => writeFile(tmp, payload, "utf8"))
+                .then(() => rename(tmp, file))
+                .catch((error) => {
+                this.#debugLog(`persist delivered ids failed: ${error.message}`);
+            });
+        }, 1000);
+        this.#deliveredPersistTimer.unref?.();
+    }
+    async #loadDeliveredTextIds() {
+        const file = this.#deliveredStoreFile;
+        if (!file)
+            return;
+        try {
+            const raw = await readFile(file, "utf8");
+            const ids = JSON.parse(raw);
+            if (!Array.isArray(ids))
+                return;
+            for (const id of ids) {
+                if (typeof id !== "string")
+                    continue;
+                if (this.#deliveredTextIds.has(id))
+                    continue;
+                this.#deliveredTextIds.add(id);
+                this.#deliveredTextOrder.push(id);
+            }
+            this.#debugLog(`loaded ${this.#deliveredTextIds.size} delivered text id(s)`);
+        }
+        catch {
+            // Absent or unreadable: start empty. Worst case is the duplicate this
+            // was written to prevent, not a failure to start.
+        }
     }
     /** Files received inline over (bulk)messages — the iOS/C Carrier apps'
      *  native way of sending images/audio online (FileModel JSON envelope). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/peer",
-  "version": "0.1.150",
+  "version": "0.1.151",
   "description": "Pure TypeScript port of Elastos Carrier (toxcore-derived) P2P messaging. DHT, onion routing, TCP relay, FlatBuffers app payloads, Express offline relay. Wire-compatible with iOS Beagle and the Carrier C SDK.",
   "type": "module",
   "main": "./dist/index.js",