@decentnetwork/lan 0.1.282 → 0.1.284

package/dist/daemon/server.js

@@ -393,7 +393,11 @@ export class DaemonServer {
             this.ipcEvents.setMaxListeners(50);
             this.ipcServer = new IpcServer(ipcSocketPath(this.config.carrier.dataDir), {
                 friendRequest: async (address, hello) => {
-                    await this.peerManager.sendFriendRequest(address, hello);
+                    // sendFriendRequest waits for our own announce to store and then
+                    // walks the DHT toward the target — tens of seconds is normal, and
+                    // none of it changes what the caller should do. Awaiting it made
+                    // "add" look like a dead button for the whole walk.
+                    void this.peerManager.sendFriendRequest(address, hello).catch((e) => this.logger.warn(`friend-request to ${String(address).slice(0, 8)} failed: ${e.message}`));
                 },
                 friendsPending: async () => {
                     const entries = this.pendingFriends?.list() ?? [];
@@ -412,7 +416,14 @@ export class DaemonServer {
                     const entry = this.pendingFriends?.remove(userid);
                     if (!entry)
                         throw new Error(`No pending friend-request for userid ${userid}`);
-                    await this.peerManager.acceptFriendRequest(entry.pubkey);
+                    // Answer as soon as the entry is gone from pending — that is the part
+                    // the UI renders. The node call is effectively local (its session
+                    // attempt is already fire-and-forget), so waiting on it only delayed
+                    // the click. Put the entry back if it does refuse.
+                    void this.peerManager.acceptFriendRequest(entry.pubkey).catch((e) => {
+                        this.pendingFriends?.add(entry);
+                        this.logger.warn(`accept ${userid.slice(0, 8)} failed: ${e.message}`);
+                    });
                 },
                 friendsReject: async (userid) => {
                     const entry = this.pendingFriends?.remove(userid);
@@ -423,23 +434,37 @@ export class DaemonServer {
                 chatSend: async (userid, text) => {
                     if (!text)
                         return;
-                    // If the friend is online, deliver immediately. If they're offline (or
-                    // the live send throws), queue it: store as "queued" and flush on their
-                    // next reconnect — so chat works store-and-forward, not just live.
-                    if (this.peerManager?.isFriendOnline(userid)) {
+                    // Record the message BEFORE any network attempt, and return without
+                    // waiting for the wire.
+                    //
+                    // The offline branch already did this. The ONLINE branch awaited
+                    // sendText and only logged afterwards — and sendText is not quick:
+                    // with the ack path it retries for up to 15s. So a message to an
+                    // ONLINE friend did not appear in the sender's own thread until
+                    // delivery finished, while a message to an offline one appeared at
+                    // once. The faster the peer, the less you noticed; the slower, the
+                    // more it looked like the app had ignored you.
+                    //
+                    // 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");
+                    this.friendMeta?.ensure(userid);
+                    this.ipcEvents.emit("event", { type: "chat", userid, dir: "out" });
+                    if (!msg || !this.peerManager?.isFriendOnline(userid)) {
+                        this.logger.info(`Queued text for ${userid.slice(0, 8)} (delivers on reconnect)`);
+                        return;
+                    }
+                    // Deliver in the background; the reconnect flush covers a failure.
+                    void (async () => {
                         try {
                             await this.peerManager.sendText(userid, text);
-                            this.logChat(userid, "out", text);
-                            return;
+                            this.messageStore?.setStatus(userid, msg.id, undefined); // delivered
                         }
                         catch (e) {
-                            this.logger.warn(`sendText to ${userid.slice(0, 8)} failed, queuing: ${e.message}`);
+                            this.logger.warn(`sendText to ${userid.slice(0, 8)} failed, stays queued: ${e.message}`);
                         }
-                    }
-                    this.messageStore?.append(userid, "out", text, Date.now(), "queued");
-                    this.friendMeta?.ensure(userid);
-                    this.ipcEvents.emit("event", { type: "chat", userid, dir: "out" });
-                    this.logger.info(`Queued text for offline ${userid.slice(0, 8)} (delivers on reconnect)`);
+                        this.ipcEvents.emit("event", { type: "chat", userid, dir: "out" });
+                    })();
                 },
                 chatLogLocal: async (userid, dir, text) => {
                     if (!text)
@@ -564,57 +589,20 @@ 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): 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
-                        // left this machine; a half-open session swallowed them silently
-                        // while the sender stared at a checkmark (INBOX 2026-08-21 A).
-                        const safeName = sanitizeFileName(name);
-                        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" });
-                        // 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, 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}` +
-                                (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 };
-                    }
+                    // NATIVE friends (iOS/Android/C Carrier) stream like everyone else:
+                    // sendFile below reaches them as DNFT1 frames (peer >= 0.1.141 —
+                    // offset acks, FEC, resume; verified 100MB JS→iPad). There is NO
+                    // inline shortcut any more, at any size. The inline envelope has no
+                    // usable confirmation against a native peer — protoVersion is
+                    // structurally 0 (no text-ack), the bare FileModel carries no
+                    // deliveryId to ack, and the transport-ack signal (our send window
+                    // draining) was FIELD-FALSIFIED at every scale: a 282-BYTE
+                    // single-fragment PNG sat unconfirmed for 20s on the same session
+                    // that streamed 100MB with 0.0% loss moments earlier. Routing small
+                    // files inline just manufactured a daily stream of failed chips for
+                    // images that had actually arrived. DNFT1's contiguous ack is the
+                    // only true delivery signal a native can give us; the cost is one
+                    // offer round trip.
                     // Add the "out" chip immediately as STATUS=sending (not "sent" — the
                     // transfer is reliable+acked, so it only flips to "sent" once the
                     // receiver confirms every byte). Progress/complete/cancel events patch

package/dist/ui/desktop/app.js

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