@decentnetwork/lan 0.1.280 → 0.1.282

package/dist/daemon/ipc.d.ts

@@ -169,6 +169,9 @@ export declare class IpcServer {
     private socketPath;
     private handlers;
     private server?;
+    /** Live client connections, so stop() can end them instead of waiting on
+     *  a subscriber that never hangs up. */
+    private openSockets;
     private logger;
     constructor(socketPath: string, handlers: IpcHandlers);
     start(): Promise<void>;

package/dist/daemon/ipc.js

@@ -61,6 +61,9 @@ export class IpcServer {
     socketPath;
     handlers;
     server;
+    /** Live client connections, so stop() can end them instead of waiting on
+     *  a subscriber that never hangs up. */
+    openSockets = new Set();
     logger;
     constructor(socketPath, handlers) {
         this.socketPath = socketPath;
@@ -79,7 +82,14 @@ export class IpcServer {
                 this.logger.warn(`Could not remove stale socket ${this.socketPath}: ${err}`);
             }
         }
-        this.server = createServer((sock) => this.handleConnection(sock));
+        this.server = createServer((sock) => {
+            // Track every live connection so stop() can force them shut. Without
+            // this, server.close() waits for all of them and a single long-lived
+            // subscriber deadlocks shutdown (see stop()).
+            this.openSockets.add(sock);
+            sock.once("close", () => this.openSockets.delete(sock));
+            this.handleConnection(sock);
+        });
         await new Promise((resolve, reject) => {
             this.server.once("error", reject);
             this.server.listen(this.socketPath, () => {
@@ -103,6 +113,22 @@ export class IpcServer {
     async stop() {
         if (!this.server)
             return;
+        // server.close() only fires its callback once every EXISTING connection
+        // has closed — it stops new ones, it does not end open ones. Event
+        // subscribers ({op:"subscribe"}) hold their connection open by design and
+        // never close it, so waiting on that callback is an unbounded wait on a
+        // peer that is never going to hang up.
+        //
+        // That is not theoretical: a daemon logged "Stopping daemon" and then sat
+        // in teardown for 24h46m, finishing 300ms after an unrelated `pm2 restart`
+        // happened to drop the subscriber. The same bug is behind the SIGTERM
+        // hangs that ran out systemd's TimeoutStopSec — every journal entry with
+        // "Shutting down..." and no matching "Daemon stopped" is this.
+        //
+        // We are shutting down, so end them ourselves and let close() complete.
+        for (const sock of this.openSockets)
+            sock.destroy();
+        this.openSockets.clear();
         await new Promise((resolve) => {
             this.server.close(() => resolve());
         });

package/dist/daemon/server.js

@@ -564,20 +564,22 @@ export class DaemonServer {
                         this.logger.info(`Queued file "${name}" (${data.length}B) for offline ${userid.slice(0, 8)} (delivers on reconnect)`);
                         return { queued: true, name: safe, size: data.length };
                     }
-                    // NATIVE friends (iOS/Android/C Carrier): small files take the inline
-                    // FileModel-JSON-over-bulkmsg envelope (single blob, the Beagle apps'
-                    // own fast path); anything bigger falls through to the streaming
-                    // sendFile below, which peer >= 0.1.141 carries to natives as DNFT1
-                    // frames inside friend messages (offset acks, FEC, resume — verified
-                    // 100MB JS→iPad). This gate used to REJECT >11MB outright, which
-                    // blocked the very path built for large files.
-                    const INLINE_MAX = 11 * 1024 * 1024;
-                    if (this.peerManager?.isNativeFriend(userid) && data.length <= INLINE_MAX) {
-                        // The FileModel JSON envelope is base64 (inflates ~1.34x) + a little
-                        // JSON overhead, and the whole thing must fit the 16MB bulkmsg cap
-                        // (CARRIER_MAX_APP_BULKMSG_LEN, raised from 5MB alongside the receive
-                        // reorder buffer in peer >= 0.1.87). 11MB raw → ~14.7MB envelope,
-                        // safely under 16MB. Needs BOTH ends on the raised cap.
+                    // NATIVE friends (iOS/Android/C Carrier): only TINY files take the
+                    // inline FileModel envelope — a thumbnail/voice-note shortcut, one
+                    // blob, one round trip. Everything else streams via sendFile, which
+                    // peer >= 0.1.141 carries to natives as DNFT1 frames (offset acks,
+                    // FEC, resume — verified 100MB JS→iPad).
+                    //
+                    // The gate was 11MB, then 2.5MB; both sat inside a band where the
+                    // envelope's ONLY confirmation signal — the toxcore send window
+                    // draining — is structurally unreliable: an 8.5MB envelope is ~11k
+                    // bulkmsg fragments on a channel with no congestion control, and
+                    // three live 8.5MB sends all timed out unconfirmed at 180s while a
+                    // 5.2MB died silently in the native kernel. At 256KB (~350
+                    // fragments) the window drains in seconds and the transport ack
+                    // actually means something.
+                    const INLINE_NATIVE_MAX = 256 * 1024;
+                    if (this.peerManager?.isNativeFriend(userid) && data.length <= INLINE_NATIVE_MAX) {
                         // Append the chip as "sending" FIRST, then let the SDK's delivery
                         // verdict decide what it becomes. Marking "sent" the moment
                         // sendInlineFile resolved was a lie — that only meant the bytes
@@ -587,26 +589,31 @@ export class DaemonServer {
                         const chip = this.messageStore?.appendFile(userid, "out", { name: safeName, size: data.length, status: "sending", sent: 0 });
                         this.friendMeta?.ensure(userid);
                         this.ipcEvents.emit("event", { type: "chat", userid, dir: "out" });
-                        let delivery;
-                        try {
-                            delivery = await this.peerManager.sendInlineFile(userid, new Uint8Array(data), name);
-                        }
-                        catch (e) {
+                        // Sends are NON-BLOCKING (the 2026-08-05 rule): the delivery wait
+                        // scales with size (up to 180s), and holding the HTTP request open
+                        // that long froze the UI on an 8MB inline send. Return now; the
+                        // verdict patches the chip and the event stream repaints it.
+                        const bytes = new Uint8Array(data);
+                        void (async () => {
+                            let delivery;
+                            try {
+                                delivery = await this.peerManager.sendInlineFile(userid, bytes, name);
+                            }
+                            catch (e) {
+                                if (chip)
+                                    this.messageStore?.patchFile(userid, chip.id, { status: "failed" });
+                                this.ipcEvents.emit("event", { type: "chat", userid, dir: "out" });
+                                this.logger.warn(`Inline file "${name}" to native ${userid.slice(0, 8)} failed to send: ${e.message}`);
+                                return;
+                            }
+                            const status = delivery === "acked" ? "sent" : delivery === "offline" ? "queued" : "failed";
                             if (chip)
-                                this.messageStore?.patchFile(userid, chip.id, { status: "failed" });
+                                this.messageStore?.patchFile(userid, chip.id, { status, sent: delivery === "acked" ? data.length : 0 });
                             this.ipcEvents.emit("event", { type: "chat", userid, dir: "out" });
-                            throw e;
-                        }
-                        const status = delivery === "acked" ? "sent" : delivery === "offline" ? "queued" : "failed";
-                        if (chip)
-                            this.messageStore?.patchFile(userid, chip.id, { status, sent: delivery === "acked" ? data.length : 0 });
-                        this.ipcEvents.emit("event", { type: "chat", userid, dir: "out" });
-                        this.logger.info(`Inline file "${name}" (${data.length}B) to native ${userid.slice(0, 8)}: delivery=${delivery} → ${status}`);
-                        if (delivery === "accepted") {
-                            throw new Error(`The peer never confirmed receiving "${name}" — it likely did not arrive. ` +
-                                `Check that their app is in the foreground and try again.`);
-                        }
-                        return { inline: true, name, size: data.length, delivery };
+                            this.logger.info(`Inline file "${name}" (${data.length}B) to native ${userid.slice(0, 8)}: delivery=${delivery} → ${status}` +
+                                (delivery === "accepted" ? " (unconfirmed — the bytes went out and may have arrived, but the peer never acknowledged)" : ""));
+                        })();
+                        return { inline: true, name, size: data.length, pending: true };
                     }
                     // Add the "out" chip immediately as STATUS=sending (not "sent" — the
                     // transfer is reliable+acked, so it only flips to "sent" once the

package/dist/ui/desktop/app.js

@@ -1,4 +1,4 @@
-window.__DK_UI_VERSION="0.1.280";
+window.__DK_UI_VERSION="0.1.282";
 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.280",
+  "version": "0.1.282",
   "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",