@decentnetwork/lan 0.1.297 → 0.1.299

package/dist/daemon/message-store.d.ts

@@ -14,10 +14,19 @@ export interface ChatMessage {
     ts: number;
     /** Stable per-message id (ts + per-process sequence) for UI keys / dedup. */
     id: string;
-    /** Outgoing-text delivery state. "queued" means the peer was offline when the
-     *  user hit send, so the daemon stored it and will deliver it (in order) the
-     *  moment the friend reconnects. Cleared once actually sent. */
-    status?: "queued" | "sent" | "failed";
+    /** Outgoing-text delivery state. "sending" = the background delivery attempt
+     *  is still running (chat-send returns before the network is consulted).
+     *  "queued" = that attempt gave up, or the peer was offline when the user hit
+     *  send; the daemon delivers it (in order) the moment the friend reconnects.
+     *  Cleared once actually sent.
+     *
+     *  The two states must stay distinct: chat-send used to store the message as
+     *  "queued" while its own send was in flight, and the reconnect flush sends
+     *  everything "queued". sendText brings the session up first when it has to,
+     *  and the session coming up IS the reconnect event — so the flush sent the
+     *  message, then chat-send sent it again, 10-20 ms apart. Every friend of a
+     *  daemon saw those messages twice. */
+    status?: "sending" | "queued" | "sent" | "failed";
     /** How this message traversed the network, for the UI to distinguish at a
      *  glance (different colors). "online" = live net_crypto session (direct/relay);
      *  "offline" = express store-and-forward (the friend or we were offline). Lets
@@ -52,11 +61,11 @@ export declare class MessageStore {
     /** Append a message and schedule a flush. Returns the stored message.
      *  Pass `status: "queued"` for an outgoing text the peer wasn't online to
      *  receive — the daemon flushes it on reconnect. */
-    append(peer: string, dir: "in" | "out", text: string, ts?: number, status?: "queued" | "sent" | "failed", via?: "online" | "offline"): ChatMessage;
+    append(peer: string, dir: "in" | "out", text: string, ts?: number, status?: "sending" | "queued" | "sent" | "failed", via?: "online" | "offline"): ChatMessage;
     /** Set (or, with undefined, clear) the delivery status on a text message.
      *  Used to flip a "queued" message to delivered once it's actually sent.
      *  No-op if the id isn't found or is a file entry. Returns true if patched. */
-    setStatus(peer: string, id: string, status?: "queued" | "sent" | "failed"): boolean;
+    setStatus(peer: string, id: string, status?: "sending" | "queued" | "sent" | "failed"): boolean;
     /** Outgoing messages still awaiting delivery (peer was offline), oldest
      *  first — both queued text and queued file chips. The daemon drains this
      *  on a friend's reconnect. */

package/dist/daemon/message-store.js

@@ -33,6 +33,11 @@ export class MessageStore {
             let total = 0;
             for (const [peer, msgs] of Object.entries(raw)) {
                 if (Array.isArray(msgs)) {
+                    // A "sending" state cannot survive a restart — the attempt it
+                    // described died with the process. Requeue so the flush owns it.
+                    for (const m of msgs)
+                        if (m.status === "sending")
+                            m.status = "queued";
                     this.byPeer.set(peer, msgs);
                     total += msgs.length;
                 }

package/dist/daemon/server.js

@@ -458,14 +458,23 @@ export class DaemonServer {
                     //
                     // Same rule the embedded host and the browser client already follow:
                     // a delivery failure is a STATE on the message, never its absence.
-                    const msg = this.messageStore?.append(userid, "out", text, Date.now(), "queued");
+                    //
+                    // Stored as "sending", NOT "queued", while our own attempt runs. The
+                    // reconnect flush re-sends everything "queued", and sendText brings
+                    // the session up itself when it has to — which fires the very
+                    // friend-connection event that triggers the flush. Stored as "queued"
+                    // the message went out twice, 10-20 ms apart (seen on every daemon
+                    // sender in ~/.agentnet/messages.json). "queued" now means exactly
+                    // one thing: nobody is sending this, the flush must.
+                    const online = !!this.peerManager?.isFriendOnline(userid);
+                    const msg = this.messageStore?.append(userid, "out", text, Date.now(), online ? "sending" : "queued");
                     this.friendMeta?.ensure(userid);
                     this.ipcEvents.emit("event", { type: "chat", userid, dir: "out" });
-                    if (!msg || !this.peerManager?.isFriendOnline(userid)) {
+                    if (!msg || !online) {
                         this.logger.info(`Queued text for ${userid.slice(0, 8)} (delivers on reconnect)`);
                         return;
                     }
-                    // Deliver in the background; the reconnect flush covers a failure.
+                    // Deliver in the background; on failure hand it to the reconnect flush.
                     void (async () => {
                         try {
                             await this.peerManager.sendText(userid, text);
@@ -473,7 +482,8 @@ export class DaemonServer {
                             this.messageStore?.setStatus(userid, msg.id, undefined); // delivered
                         }
                         catch (e) {
-                            this.logger.warn(`sendText to ${userid.slice(0, 8)} failed, stays queued: ${e.message}`);
+                            this.logger.warn(`sendText to ${userid.slice(0, 8)} failed, queued for reconnect: ${e.message}`);
+                            this.messageStore?.setStatus(userid, msg.id, "queued");
                         }
                         this.ipcEvents.emit("event", { type: "chat", userid, dir: "out" });
                     })();

package/dist/router/paced-forwarder.d.ts

@@ -10,6 +10,10 @@ export interface PacedForwarderOptions {
     maxFlowBytes?: number;
     /** Max queued bytes across a destination before shed (backstop). */
     maxDestBytes?: number;
+    /** Longest a packet may sit queued before it is dropped instead of sent.
+     *  Bounds LATENCY, which the byte caps cannot: a low-rate flow never fills
+     *  256 KB and so was never shed, however long the path had been stalled. */
+    maxSojournMs?: number;
     /** Token-bucket burst ceiling as seconds-worth of rate. */
     burstSeconds?: number;
     now?: () => number;

package/dist/router/paced-forwarder.js

@@ -29,6 +29,10 @@
 const DEFAULT_RATE_BPS = 12_500_000; // 100 Mbps — effectively uncapped until measured
 const DEFAULT_MAX_FLOW_BYTES = 256 * 1024;
 const DEFAULT_MAX_DEST_BYTES = 4 * 1024 * 1024;
+// Generous next to any real mesh RTT (relay paths run in the hundreds of ms),
+// decisive against a stall measured in minutes. A packet older than this has
+// outlived whatever asked for it.
+const DEFAULT_MAX_SOJOURN_MS = 3_000;
 const DEFAULT_BURST_SECONDS = 0.05; // 50ms of rate as burst — smooths without adding latency
 const MIN_RATE_BPS = 32 * 1024; // never pace below 256 kbps
 // LOSS-DRIVEN pacing. The old rule paced to `delivered × headroom`, but the
@@ -98,6 +102,7 @@ export class PacedForwarder {
             send: opts.send,
             defaultRateBps: opts.defaultRateBps ?? DEFAULT_RATE_BPS,
             maxFlowBytes: opts.maxFlowBytes ?? DEFAULT_MAX_FLOW_BYTES,
+            maxSojournMs: opts.maxSojournMs ?? DEFAULT_MAX_SOJOURN_MS,
             maxDestBytes: opts.maxDestBytes ?? DEFAULT_MAX_DEST_BYTES,
             burstSeconds: opts.burstSeconds ?? DEFAULT_BURST_SECONDS,
             now: opts.now ?? Date.now,
@@ -162,7 +167,7 @@ export class PacedForwarder {
         }
         let f = d.flows.get(flowKey);
         if (!f) {
-            f = { key: flowKey, packets: [], bytes: 0 };
+            f = { key: flowKey, packets: [], enqueuedAt: [], bytes: 0 };
             d.flows.set(flowKey, f);
             d.order.push(flowKey);
         }
@@ -170,6 +175,7 @@ export class PacedForwarder {
         // congestion to just that flow's TCP without starving the others.
         if (f.bytes + packet.length > this.#opts.maxFlowBytes) {
             const oldest = f.packets.shift();
+            f.enqueuedAt.shift();
             if (oldest) {
                 f.bytes -= oldest.length;
                 d.totalBytes -= oldest.length;
@@ -177,6 +183,7 @@ export class PacedForwarder {
             }
         }
         f.packets.push(packet);
+        f.enqueuedAt.push(this.#opts.now());
         f.bytes += packet.length;
         d.totalBytes += packet.length;
         this.#drain(dstIp);
@@ -205,6 +212,19 @@ export class PacedForwarder {
         d.draining = true;
         this.#pump(dstIp, d);
     }
+    /** Discard packets that have waited past maxSojournMs. Returns true when the
+     *  flow emptied, so the caller can skip it this round. */
+    #dropStale(d, f) {
+        const cutoff = this.#opts.now() - this.#opts.maxSojournMs;
+        while (f.packets.length > 0 && f.enqueuedAt[0] < cutoff) {
+            const stale = f.packets.shift();
+            f.enqueuedAt.shift();
+            f.bytes -= stale.length;
+            d.totalBytes -= stale.length;
+            this.#dropped++;
+        }
+        return f.packets.length === 0;
+    }
     #pump(dstIp, d) {
         d.draining = false;
         const now = this.#opts.now();
@@ -237,8 +257,29 @@ export class PacedForwarder {
                 this.#opts.schedule(() => this.#pump(dstIp, d), ms);
                 return;
             }
+            // Drop what has waited too long, BEFORE spending a token on it.
+            //
+            // The queue was bounded by bytes only — 256 KB a flow — which a
+            // high-rate flow trips in a moment and a low-rate one never trips at
+            // all. Measured 2026-08-31 against a peer on a Thai mobile link: ICMP
+            // echo replies arriving with RTTs of 180 to 250 SECONDS, each one
+            // exactly 1000ms lower than the last, which is the shape of a backlog
+            // flushing after the path came back. At 84 bytes a ping and one a
+            // second, filling 256 KB would take fifty minutes; the packets simply
+            // sat there. Delivering a four-minute-old packet is worse than dropping
+            // it — the sender gave up long ago, and TCP above reads it as a wildly
+            // inflated RTT.
+            //
+            // Bound the SOJOURN TIME, which is what CoDel is about and what a byte
+            // cap cannot express.
+            if (this.#dropStale(d, f)) {
+                d.order.splice(d.cursor % d.order.length, 1);
+                d.flows.delete(f.key);
+                continue;
+            }
             // Emit one packet from this flow, then advance the cursor (fairness).
             const pkt = f.packets.shift();
+            f.enqueuedAt.shift();
             f.bytes -= size;
             d.totalBytes -= size;
             d.tokens -= size;

package/dist/ui/desktop/app.js

@@ -1,4 +1,4 @@
-window.__DK_UI_VERSION="0.1.297";
+window.__DK_UI_VERSION="0.1.299";
 const ICON_PATHS = {
   // ---- tab bar (the four must feel like one set) ----
   users: '<path d="M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2"/><circle cx="9" cy="7" r="4"/><path d="M22 21v-2a4 4 0 0 0-3-3.87"/><path d="M16 3.13a4 4 0 0 1 0 7.75"/>',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/lan",
-  "version": "0.1.297",
+  "version": "0.1.299",
   "description": "Private virtual LAN for self-hosted services and AI agents, built on Elastos Carrier. NAT-traversal, name service, ACL, all over a peer-to-peer mesh — no public IP required.",
   "type": "module",
   "main": "./dist/index.js",