@decentnetwork/beagle 0.1.6 → 0.1.7

package/dist/call-ice.js

@@ -1,13 +1,10 @@
 // Carrier bootstrap TURN credentials for browser WebRTC.
 //
 // Android online calls use CarrierExtension.getTurnServerInfo() →
-// carrier_get_turn_server(). Prefer @decentnetwork/peer getIceServers() when
-// the installed peer version exports it; otherwise fall back to
-// deriveCarrierTurnCreds via the package dist path (older peer builds).
+// carrier_get_turn_server(). We call @decentnetwork/peer getIceServers()
+// (0.1.136+) with the same credential scheme.
 import { readFileSync, existsSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { base58ToBytes, carrierIdFromPublicKey } from "@decentnetwork/peer";
+import { carrierIdFromPublicKey, getIceServers } from "@decentnetwork/peer";
 function hexToBytes(hex) {
     const clean = hex.trim().replace(/^0x/i, "");
     if (clean.length % 2 !== 0)
@@ -38,29 +35,11 @@ export async function buildCarrierCallIceServers(opts) {
     if (!nodes.length)
         throw new Error("no bootstrap nodes for TURN");
     const { publicKey, secretKey } = loadKeyPair(opts.keyFile);
-    const userid = carrierIdFromPublicKey(publicKey);
-    const peerRoot = dirname(fileURLToPath(import.meta.resolve("@decentnetwork/peer")));
-    const peerMod = (await import(pathToFileURL(join(peerRoot, "index.js")).href));
-    if (typeof peerMod.getIceServers === "function") {
-        return peerMod.getIceServers({
-            bootstrapNodes: nodes,
-            ourUserid: userid,
-            ourSecretKey: secretKey,
-            limit: opts.limit ?? 3,
-            includeTcpTurn: true,
-        });
-    }
-    const { deriveCarrierTurnCreds } = (await import(pathToFileURL(join(peerRoot, "turn-creds.js")).href));
-    const iceServers = [];
-    for (const n of nodes) {
-        const creds = deriveCarrierTurnCreds({
-            bootnodeHost: n.host,
-            bootnodePublicKey: base58ToBytes(n.pk),
-            ourUserid: userid,
-            ourSecretKey: secretKey,
-        });
-        const base = `${creds.host}:${creds.port}`;
-        iceServers.push({ urls: `stun:${base}`, username: creds.username, credential: creds.password }, { urls: `turn:${base}`, username: creds.username, credential: creds.password }, { urls: `turn:${base}?transport=tcp`, username: creds.username, credential: creds.password });
-    }
-    return iceServers;
+    return getIceServers({
+        bootstrapNodes: nodes,
+        ourUserid: carrierIdFromPublicKey(publicKey),
+        ourSecretKey: secretKey,
+        limit: opts.limit ?? 3,
+        includeTcpTurn: true,
+    });
 }

package/dist/desktop/app.js

@@ -1,4 +1,4 @@
-window.__DK_UI_VERSION="0.1.6";
+window.__DK_UI_VERSION="0.1.7";
 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"/>',
@@ -1964,7 +1964,15 @@ function Msg({ m, peer, T, onTheater, onDelete, onCancel, onRetry, onReveal, onC
         style: { background: "none", border: "none", cursor: "pointer", padding: 0, marginLeft: 2, display: "inline-flex", opacity: 0.55 }
       },
       /* @__PURE__ */ React.createElement(Icon, { name: "trash", size: 11, stroke: 2, color: "var(--faint)" })
-    ), mine && m.status === "queued" ? /* @__PURE__ */ React.createElement("span", { style: { display: "inline-flex", alignItems: "center", gap: 2 }, title: "waiting for peer \u2014 will send when they're online" }, /* @__PURE__ */ React.createElement(Icon, { name: "clock", size: 11, stroke: 2.2, color: "var(--faint)" }), /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 10, color: "var(--faint)" } }, T.queued || "queued")) : mine && m.status && /* @__PURE__ */ React.createElement(Icon, { name: "checkCheck", size: 12, stroke: 2.2, color: m.status === "read" ? "var(--accent)" : "var(--faint)" })))
+    ), mine && (m.status === "queued" || m.status === "sending") ? /* @__PURE__ */ React.createElement(
+      "span",
+      {
+        style: { display: "inline-flex", alignItems: "center", gap: 2 },
+        title: m.status === "sending" ? "delivering\u2026" : "waiting for peer \u2014 will send when they're online"
+      },
+      /* @__PURE__ */ React.createElement(Icon, { name: "clock", size: 11, stroke: 2.2, color: "var(--faint)" }),
+      /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 10, color: "var(--faint)" } }, m.status === "sending" ? T.sendingMsg || "sending" : T.queued || "queued")
+    ) : mine && m.status && /* @__PURE__ */ React.createElement(Icon, { name: "checkCheck", size: 12, stroke: 2.2, color: m.status === "read" ? "var(--accent)" : "var(--faint)" })))
   );
 }
 function Conversation({ T, peer, lang, thread: threadProp, onSend, onSendFile, onSendRtcFile, onAlias, onRemove, onOpenNet, onCall, onReloadThread }) {
@@ -3466,6 +3474,7 @@ const STR = {
     send: "Send",
     pickPeer: "Select a peer to open the conversation",
     queued: "queued",
+    sendingMsg: "sending",
     open: "open",
     retry: "Retry",
     cancel: "Cancel",
@@ -3560,6 +3569,7 @@ const STR = {
     send: "\u53D1\u9001",
     pickPeer: "\u9009\u62E9\u4E00\u4F4D\u597D\u53CB\u5F00\u59CB\u4F1A\u8BDD",
     queued: "\u5F85\u53D1\u9001",
+    sendingMsg: "\u53D1\u9001\u4E2D",
     open: "\u6253\u5F00",
     retry: "\u91CD\u8BD5",
     cancel: "\u53D6\u6D88",

package/dist/embedded-host.js

@@ -47,6 +47,10 @@ export class EmbeddedHost {
     #logger = new Logger({ prefix: "Beagle" });
     #opts;
     #events = new EventEmitter();
+    /** Per-peer delivery chains: background sends to one peer run strictly in
+     *  order, so a new message can never overtake an older one whose ACK is
+     *  still pending. Entry removed when the chain drains. */
+    #sendChains = new Map();
     /** Friend requests held for manual accept when auto-accept is off. */
     #pending = new Map();
     /** Inbound call signals waiting for the UI's long-poll to collect them. */
@@ -368,27 +372,37 @@ export class EmbeddedHost {
                 // user's own words vanish from their own thread — they watched the
                 // peer answer a question that wasn't on screen (INBOX 2026-08-02).
                 // A send failure is a delivery state ON the message, never its absence.
-                const msg = this.#messages.append(uid, "out", text, Date.now());
+                const msg = this.#messages.append(uid, "out", text, Date.now(), "sending");
                 this.#meta.ensure(uid);
                 this.#events.emit("event", { type: "chat", userid: uid, dir: "out" });
-                // Anything already queued for this peer goes first — the new message
-                // must not overtake older ones the moment the path recovers.
-                await this.#flushOutbox(uid).catch(() => { });
-                try {
-                    await this.#node.sendText(uid, text);
-                    this.#messages.setStatus(uid, msg.id, "sent");
-                    return {};
-                }
-                catch (e) {
-                    // Offline peer or failed delivery: same recovery either way — keep
-                    // the message "queued" (the UI shows the clock) and deliver it on
-                    // the friend's reconnect via #flushOutbox. This is a success from
-                    // the caller's side: the store owns the message; only its delivery
-                    // is pending.
-                    this.#logger.info(`send to ${uid.slice(0, 8)} queued: ${e.message}`);
-                    this.#messages.setStatus(uid, msg.id, "queued");
-                    return { queued: true };
-                }
+                // Return NOW. The delivery attempt runs in the background — an ACK
+                // that takes 15s per hop must cost the network 15s, never the user
+                // (INBOX 2026-08-05: a peer that never ACKed made every send block
+                // the UI for 30s, which reads as "stuck" and provokes re-sends).
+                // Per-peer chaining keeps FIFO: anything queued flushes first, and a
+                // second send waits for this one's attempt before its own.
+                const prev = this.#sendChains.get(uid) ?? Promise.resolve();
+                const job = prev.then(async () => {
+                    await this.#flushOutbox(uid).catch(() => { });
+                    try {
+                        await this.#node.sendText(uid, text);
+                        this.#messages.setStatus(uid, msg.id, "sent");
+                    }
+                    catch (e) {
+                        // Offline peer or failed delivery: same recovery either way —
+                        // "queued" (the UI shows the clock) and #flushOutbox delivers it
+                        // on the friend's reconnect. A status update, not a failure.
+                        this.#logger.info(`send to ${uid.slice(0, 8)} queued: ${e.message}`);
+                        this.#messages.setStatus(uid, msg.id, "queued");
+                    }
+                    this.#events.emit("event", { type: "chat", userid: uid, dir: "out" });
+                });
+                this.#sendChains.set(uid, job);
+                void job.finally(() => {
+                    if (this.#sendChains.get(uid) === job)
+                        this.#sendChains.delete(uid);
+                });
+                return {};
             }
             case "chat-log-local":
                 this.#messages.append(uid, req.dir ?? "in", String(req.text ?? ""), Date.now());

package/dist/message-store.d.ts

@@ -14,10 +14,12 @@ 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, so
+     *  the UI never blocks on a slow peer). "queued" = that attempt gave up; the
+     *  daemon will deliver it (in order) the moment the friend reconnects.
+     *  Cleared once actually sent. */
+    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 +54,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/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 #flushOutbox owns it.
+                    for (const m of msgs)
+                        if (m.status === "sending")
+                            m.status = "queued";
                     this.byPeer.set(peer, msgs);
                     total += msgs.length;
                 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@decentnetwork/beagle",
-  "version": "0.1.6",
-  "description": "Beagle \u2014 P2P chat, file transfer and calls for regular users, on the Decent Network. No admin privilege required.",
+  "version": "0.1.7",
+  "description": "Beagle — P2P chat, file transfer and calls for regular users, on the Decent Network. No admin privilege required.",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {