@bobfrankston/mailx 1.0.216 → 1.0.218

package/client/components/message-list.js

@@ -335,6 +335,15 @@ function appendMessages(body, accountId, items) {
             tag.title = msgAccountId;
             from.prepend(tag);
         }
+        // Search/cross-folder results carry folderName — show a tag so the user
+        // can tell which folder each hit lives in.
+        if (msg.folderName) {
+            const folderTag = document.createElement("span");
+            folderTag.className = "ml-folder-tag";
+            folderTag.textContent = msg.folderName;
+            folderTag.title = `In folder: ${msg.folderName}`;
+            from.prepend(folderTag);
+        }
         const subject = document.createElement("span");
         subject.className = "ml-subject";
         subject.innerHTML = escapeHtml(msg.subject);

package/client/compose/compose.css

@@ -75,6 +75,22 @@ body {
     background: var(--color-bg-hover);
 }
 
+.compose-status {
+    margin-left: auto;
+    align-self: center;
+    font-size: var(--font-size-xs);
+    color: var(--color-text-muted);
+    padding: 0 var(--gap-md);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    max-width: 20em;
+}
+.compose-status.compose-status-error {
+    color: oklch(0.65 0.2 25);
+    font-weight: 500;
+}
+
 #btn-send {
     background: var(--color-accent);
     color: white;

package/client/compose/compose.html

@@ -38,6 +38,7 @@
         <button class="tb-btn" id="btn-send">Send</button>
         <button class="tb-btn" id="btn-attach">Attach</button>
         <button class="tb-btn" id="btn-discard">Discard</button>
+        <span id="compose-status" class="compose-status"></span>
     </div>
     <div id="compose-editor"></div>
 </body>

package/client/compose/compose.js

@@ -292,30 +292,23 @@ function applyInit(init) {
     else
         editor.focus();
 }
-// ── Load init data from sessionStorage, then ensure From is populated ──
-const stored = sessionStorage.getItem("composeInit");
-if (stored) {
-    sessionStorage.removeItem("composeInit");
-    applyInit(JSON.parse(stored));
-}
-else {
-    // New compose — focus To
-    toInput.focus();
-}
-// If From dropdown is empty (new compose without init, or init had no accounts), fetch from API
-if (fromSelect.options.length === 0) {
-    getAccounts()
-        .then((accounts) => {
-        populateFromSelect(accounts);
-    })
-        .catch((e) => console.error("Failed to load accounts:", e));
-}
-// ── Auto-save drafts every 5 seconds ──
+// ── Compose state (declared before init so the async IIFE can reference them) ──
+const DRAFT_INPUT_DEBOUNCE_MS = 1500; // save ~1.5s after the last keystroke
+const DRAFT_INTERVAL_MS = 5000; // safety-net interval save
 let draftUid = null;
 let draftId = null; // stable ID for dedup when APPENDUID unavailable
-let draftTimer;
+let draftTimer = null;
+let draftDebounceTimer = null;
 let lastDraftContent = "";
 let draftSaving = false; // prevent concurrent saves
+let draftSaveFailed = false; // surfaced in the compose status tag
+function showDraftStatus(text, isError) {
+    const status = document.getElementById("compose-status");
+    if (!status)
+        return;
+    status.textContent = text;
+    status.classList.toggle("compose-status-error", isError);
+}
 async function saveDraft() {
     if (draftSaving)
         return; // previous save still in flight
@@ -341,13 +334,76 @@ async function saveDraft() {
             draftUid = data.draftUid;
         if (data?.draftId)
             draftId = data.draftId;
+        if (draftSaveFailed) {
+            draftSaveFailed = false;
+            showDraftStatus("Draft saved", false);
+        }
+        else
+            showDraftStatus(`Draft saved ${new Date().toLocaleTimeString()}`, false);
+    }
+    catch (e) {
+        // Surface the error — silent failures are how drafts get lost on IMAP hiccups.
+        // The local editing/ checkpoint already exists server-side regardless.
+        console.error("[draft] save failed:", e);
+        draftSaveFailed = true;
+        showDraftStatus(`Draft save failed: ${e?.message || e}`, true);
+        // Clear lastDraftContent so the next tick retries the same content
+        lastDraftContent = "";
     }
-    catch { /* ignore draft save errors */ }
     finally {
         draftSaving = false;
     }
 }
-draftTimer = setInterval(saveDraft, 5000);
+/** Schedule a debounced save on user input — fires ~1.5s after the last keystroke. */
+function scheduleDraftSave() {
+    if (draftDebounceTimer)
+        clearTimeout(draftDebounceTimer);
+    draftDebounceTimer = setTimeout(() => { draftDebounceTimer = null; saveDraft(); }, DRAFT_INPUT_DEBOUNCE_MS);
+}
+// ── Initialize: always fetch real accounts from the API before applying init, then
+//    start the auto-save timer. Callers like message-viewer's Edit Draft pass
+//    init.accounts=[], so we can't trust what's in the init blob. ──
+(async () => {
+    let accounts = [];
+    try {
+        accounts = await getAccounts();
+    }
+    catch (e) {
+        console.error("Failed to load accounts:", e);
+    }
+    const stored = sessionStorage.getItem("composeInit");
+    if (stored) {
+        sessionStorage.removeItem("composeInit");
+        const init = JSON.parse(stored);
+        if (!init.accounts || init.accounts.length === 0)
+            init.accounts = accounts;
+        applyInit(init);
+    }
+    else {
+        populateFromSelect(accounts);
+        toInput.focus();
+    }
+    // Wire debounced saves to input events — checkpoint ~1.5s after the last
+    // keystroke instead of waiting up to 5s for the interval tick.
+    toInput.addEventListener("input", scheduleDraftSave);
+    ccInput.addEventListener("input", scheduleDraftSave);
+    bccInput.addEventListener("input", scheduleDraftSave);
+    subjectInput.addEventListener("input", scheduleDraftSave);
+    editor.onContentChange(scheduleDraftSave);
+    // Safety-net interval: even with no user input, catch any edge cases.
+    draftTimer = setInterval(saveDraft, DRAFT_INTERVAL_MS);
+    // Flush the draft on window close so the last-typed content lands in
+    // editing/ even if the interval tick hasn't fired yet. navigator.sendBeacon
+    // is synchronous enough to survive unload; callNode IPC would be dropped.
+    window.addEventListener("beforeunload", () => {
+        if (draftDebounceTimer) {
+            clearTimeout(draftDebounceTimer);
+            draftDebounceTimer = null;
+        }
+        // fire-and-forget — can't await during unload
+        saveDraft();
+    });
+})();
 // ── Send ──
 document.getElementById("btn-send")?.addEventListener("click", async () => {
     const btn = document.getElementById("btn-send");
@@ -365,10 +421,15 @@ document.getElementById("btn-send")?.addEventListener("click", async () => {
     };
     try {
         await sendMessage(body);
-        // Delete draft after successful send
-        clearInterval(draftTimer);
-        if (draftUid) {
-            deleteDraft(getFromAccountId(), draftUid).catch(() => { });
+        // Delete draft after successful send — stop auto-save first so it can't
+        // append a fresh copy after we delete. Use the stored draftId as a fallback
+        // so any orphaned drafts with the same stable ID are cleaned up too.
+        if (draftTimer) {
+            clearInterval(draftTimer);
+            draftTimer = null;
+        }
+        if (draftUid || draftId) {
+            deleteDraft(getFromAccountId(), draftUid || 0, draftId || "").catch(() => { });
         }
         closeCompose();
     }

package/client/compose/editor.js

@@ -3,6 +3,79 @@
  * The compose window loads this module and calls createEditor() based on the user's setting.
  */
 function createQuillEditor(container) {
+    // Extra keybindings for formatting that Quill doesn't wire up by default.
+    // Ctrl+K (insert link) is the one most users expect; we also add shortcuts
+    // for strikethrough, lists, indent, color, and clear-formatting.
+    const extraBindings = {
+        insertLink: {
+            key: "K", shortKey: true,
+            handler: function (range) {
+                if (!range)
+                    return true;
+                const current = this.quill.getFormat(range).link || "";
+                const url = prompt("URL (leave blank to remove link):", current);
+                if (url === null)
+                    return;
+                if (url === "")
+                    this.quill.format("link", false);
+                else
+                    this.quill.format("link", url);
+            },
+        },
+        removeLink: {
+            key: "K", shortKey: true, shiftKey: true,
+            handler: function () { this.quill.format("link", false); },
+        },
+        strike: {
+            key: "X", shortKey: true, shiftKey: true,
+            handler: function (range) {
+                if (!range)
+                    return true;
+                const cur = this.quill.getFormat(range).strike;
+                this.quill.format("strike", !cur);
+            },
+        },
+        orderedList: {
+            key: "7", shortKey: true, shiftKey: true,
+            handler: function () { this.quill.format("list", "ordered"); },
+        },
+        bulletList: {
+            key: "8", shortKey: true, shiftKey: true,
+            handler: function () { this.quill.format("list", "bullet"); },
+        },
+        indent: {
+            key: "]", shortKey: true,
+            handler: function (range, context) {
+                this.quill.format("indent", (context.format.indent || 0) + 1);
+            },
+        },
+        outdent: {
+            key: "[", shortKey: true,
+            handler: function (range, context) {
+                this.quill.format("indent", Math.max(0, (context.format.indent || 0) - 1));
+            },
+        },
+        color: {
+            key: "C", shortKey: true, shiftKey: true,
+            handler: function (range) {
+                if (!range)
+                    return true;
+                const current = this.quill.getFormat(range).color || "";
+                const color = prompt("Text color (name or #hex, blank to clear):", current);
+                if (color === null)
+                    return;
+                this.quill.format("color", color || false);
+            },
+        },
+        clearFormat: {
+            key: "\\", shortKey: true,
+            handler: function (range) {
+                if (!range)
+                    return true;
+                this.quill.removeFormat(range.index, range.length || 0);
+            },
+        },
+    };
     const q = new Quill(container, {
         theme: "snow",
         placeholder: "Write your message...",
@@ -16,7 +89,8 @@ function createQuillEditor(container) {
                 [{ align: [] }],
                 ["blockquote", "link", "image"],
                 ["clean"]
-            ]
+            ],
+            keyboard: { bindings: extraBindings },
         }
     });
     // Make toolbar buttons non-tabbable so Tab goes straight to editor body

package/client/lib/api-client.js

@@ -143,8 +143,8 @@ export function saveSettings(settings) {
 export function repairAccounts() {
     return ipc().repairAccounts?.();
 }
-export function deleteDraft(accountId, draftUid) {
-    return ipc().deleteDraft?.(accountId, draftUid);
+export function deleteDraft(accountId, draftUid, draftId) {
+    return ipc().deleteDraft?.(accountId, draftUid, draftId);
 }
 export function setupAccount(name, email, password) {
     return ipc().setupAccount?.(name, email, password);

package/client/lib/mailxapi.js

@@ -89,8 +89,8 @@
         // Compose
         sendMessage: function(msg) { return callNode("sendMessage", msg); },
         saveDraft: function(params) { return callNode("saveDraft", params); },
-        deleteDraft: function(accountId, draftUid) {
-            return callNode("deleteDraft", { accountId: accountId, draftUid: draftUid });
+        deleteDraft: function(accountId, draftUid, draftId) {
+            return callNode("deleteDraft", { accountId: accountId, draftUid: draftUid, draftId: draftId });
         },
 
         // Search

package/client/styles/components.css

@@ -385,6 +385,20 @@ button.tb-menu-item { background: none; border: none; color: inherit; width: 100
 }
 .ml-account-tag[title="gmail"] { background: #d93025; }
 .ml-account-tag[title="bobma"] { background: #1a73e8; }
+.ml-folder-tag {
+    display: inline-block;
+    padding: 0 6px;
+    font-size: 0.72rem;
+    font-weight: 500;
+    border-radius: 3px;
+    margin-right: 4px;
+    color: var(--color-text);
+    background: color-mix(in oklch, var(--color-accent) 18%, transparent);
+    vertical-align: baseline;
+    max-width: 10em;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
 .ml-subject {
     overflow: hidden;
     text-overflow: ellipsis;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.216",
+  "version": "1.0.218",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -24,7 +24,7 @@
     "@bobfrankston/iflow-node": "^0.1.2",
     "@bobfrankston/miscinfo": "^1.0.8",
     "@bobfrankston/oauthsupport": "^1.0.22",
-    "@bobfrankston/msger": "^0.1.278",
+    "@bobfrankston/msger": "^0.1.280",
     "@capacitor/android": "^8.3.0",
     "@capacitor/cli": "^8.3.0",
     "@capacitor/core": "^8.3.0",
@@ -78,7 +78,7 @@
       "@bobfrankston/iflow-node": "^0.1.2",
       "@bobfrankston/miscinfo": "^1.0.8",
       "@bobfrankston/oauthsupport": "^1.0.22",
-      "@bobfrankston/msger": "^0.1.278",
+      "@bobfrankston/msger": "^0.1.280",
       "@capacitor/android": "^8.3.0",
       "@capacitor/cli": "^8.3.0",
       "@capacitor/core": "^8.3.0",

package/packages/mailx-api/index.js

@@ -274,7 +274,7 @@ export function createApiRouter(db, imapManager) {
         try {
             const { accountId, subject, bodyHtml, bodyText, to, cc, previousDraftUid, draftId } = req.body;
             const result = await svc.saveDraft(accountId, subject, bodyHtml, bodyText, to, cc, previousDraftUid, draftId);
-            res.json({ ok: true, draftUid: result.uid, draftId: result.draftId });
+            res.json({ ok: true, draftUid: result.draftUid, draftId: result.draftId });
         }
         catch (e) {
             res.status(500).json({ error: e.message });
@@ -282,8 +282,8 @@ export function createApiRouter(db, imapManager) {
     });
     router.delete("/draft", async (req, res) => {
         try {
-            if (req.body.accountId && req.body.draftUid)
-                await svc.deleteDraft(req.body.accountId, req.body.draftUid);
+            if (req.body.accountId && (req.body.draftUid || req.body.draftId))
+                await svc.deleteDraft(req.body.accountId, req.body.draftUid || 0, req.body.draftId);
             res.json({ ok: true });
         }
         catch (e) {

package/packages/mailx-core/index.d.ts

@@ -51,6 +51,7 @@ export declare function getMessage(params: {
     id: number;
     accountId: string;
     folderId: number;
+    folderName?: string;
     uid: number;
     messageId: string;
     inReplyTo: string;

package/packages/mailx-imap/index.d.ts

@@ -169,8 +169,10 @@ export declare class ImapManager extends EventEmitter {
     /** Save a draft to the Drafts folder via IMAP APPEND.
      *  Returns the UID of the saved draft (for replacing on next save). */
     saveDraft(accountId: string, rawMessage: string | Buffer, previousDraftUid?: number, draftId?: string): Promise<number | null>;
-    /** Delete a draft after successful send */
-    deleteDraft(accountId: string, draftUid: number): Promise<void>;
+    /** Delete a draft (or all drafts with a stable X-Mailx-Draft-ID) after successful send.
+     *  Tries the specific UID first, then falls back to searchByHeader so orphaned copies
+     *  from earlier failed autosaves are cleaned up at the same time. */
+    deleteDraft(accountId: string, draftUid: number, draftId?: string): Promise<void>;
     /** Queue outgoing message locally — never fails, worker handles IMAP+SMTP */
     queueOutgoingLocal(accountId: string, rawMessage: string): void;
     /** Guard against concurrent processSendActions for the same account */
@@ -186,7 +188,9 @@ export declare class ImapManager extends EventEmitter {
     private saveSendingCopy;
     /** Queue a message for sending. Tries IMAP Outbox, falls back to local file. */
     queueOutgoing(accountId: string, rawMessage: string | Buffer): Promise<void>;
-    /** Process local file queue — send from outbox/ and sending/queued/ */
+    /** Process local file queue — send from outbox/ only (IMAP-unreachable fallback).
+     *  Do NOT scan sending/<acct>/queued/ — that was causing every sent message to be
+     *  re-APPENDed to the IMAP Outbox on the next tick and delivered twice. */
     private processLocalQueue;
     /** Send a raw RFC 2822 message via SMTP for a given account */
     private sendRawViaSMTP;

package/packages/mailx-imap/index.js

@@ -1558,24 +1558,32 @@ export class ImapManager extends EventEmitter {
         }
         const client = this.createClient(accountId);
         try {
-            // Delete previous draft — by UID if we have it, otherwise by X-Mailx-Draft-ID header
+            // Delete previous draft — try UID first (fast path), and ALWAYS also try
+            // searchByHeader(X-Mailx-Draft-ID) as a safety net. Running both catches
+            // orphans from a crash-mid-save or a UID delete that failed silently.
             if (previousDraftUid) {
                 try {
                     await client.deleteMessageByUid(drafts.path, previousDraftUid);
                 }
-                catch { /* previous draft may already be gone */ }
+                catch (e) {
+                    console.error(`  [drafts] Delete prev UID ${previousDraftUid} failed: ${e.message}`);
+                }
             }
-            else if (draftId) {
-                // Search Drafts for our draft ID and delete it
+            if (draftId) {
                 try {
                     const uids = await client.searchByHeader(drafts.path, "X-Mailx-Draft-ID", draftId);
                     for (const uid of uids) {
-                        await client.deleteMessageByUid(drafts.path, uid);
+                        try {
+                            await client.deleteMessageByUid(drafts.path, uid);
+                        }
+                        catch { /* next */ }
                     }
                     if (uids.length > 0)
-                        console.log(`  [drafts] Deleted ${uids.length} previous draft(s) by ID ${draftId}`);
+                        console.log(`  [drafts] Deleted ${uids.length} stale draft(s) by ID ${draftId}`);
+                }
+                catch (e) {
+                    console.error(`  [drafts] searchByHeader for ${draftId} failed: ${e.message}`);
                 }
-                catch { /* search not supported or failed — tolerate duplicate */ }
             }
             // Append new draft
             const result = await client.appendMessage(drafts.path, rawMessage, ["\\Draft", "\\Seen"]);
@@ -1590,18 +1598,42 @@ export class ImapManager extends EventEmitter {
             catch { /* ignore */ }
         }
     }
-    /** Delete a draft after successful send */
-    async deleteDraft(accountId, draftUid) {
+    /** Delete a draft (or all drafts with a stable X-Mailx-Draft-ID) after successful send.
+     *  Tries the specific UID first, then falls back to searchByHeader so orphaned copies
+     *  from earlier failed autosaves are cleaned up at the same time. */
+    async deleteDraft(accountId, draftUid, draftId) {
         const drafts = this.findFolder(accountId, "drafts");
-        if (!drafts || !draftUid)
+        if (!drafts)
+            return;
+        if (!draftUid && !draftId)
             return;
         const client = this.createClient(accountId);
         try {
-            await client.deleteMessageByUid(drafts.path, draftUid);
-            console.log(`  [drafts] Deleted draft UID ${draftUid}`);
-        }
-        catch (e) {
-            console.error(`  [drafts] Delete error: ${e.message}`);
+            if (draftUid) {
+                try {
+                    await client.deleteMessageByUid(drafts.path, draftUid);
+                    console.log(`  [drafts] Deleted draft UID ${draftUid}`);
+                }
+                catch (e) {
+                    console.error(`  [drafts] Delete by UID ${draftUid} failed: ${e.message}`);
+                }
+            }
+            if (draftId) {
+                try {
+                    const uids = await client.searchByHeader(drafts.path, "X-Mailx-Draft-ID", draftId);
+                    for (const uid of uids) {
+                        try {
+                            await client.deleteMessageByUid(drafts.path, uid);
+                        }
+                        catch { /* next */ }
+                    }
+                    if (uids.length > 0)
+                        console.log(`  [drafts] Deleted ${uids.length} draft(s) by ID ${draftId}`);
+                }
+                catch (e) {
+                    console.error(`  [drafts] searchByHeader for ${draftId} failed: ${e.message}`);
+                }
+            }
         }
         finally {
             try {
@@ -1709,8 +1741,13 @@ export class ImapManager extends EventEmitter {
     }
     /** Queue a message for sending. Tries IMAP Outbox, falls back to local file. */
     async queueOutgoing(accountId, rawMessage) {
-        // Always save a debug copy
-        this.saveSendingCopy(accountId, rawMessage, "queued");
+        // IMPORTANT: do NOT save a "debug copy" to sending/<acct>/queued/ here.
+        // processLocalQueue also scans sending/<acct>/queued/, so writing there
+        // on every send caused the same message to be re-APPENDed to the IMAP
+        // Outbox on the next outbox tick — resulting in a duplicate send.
+        // The only two legitimate queue locations are:
+        //   - IMAP Outbox (primary, populated by APPEND below)
+        //   - ~/.mailx/outbox/<acct>/*.ltr (fallback when IMAP is unreachable)
         try {
             const outboxPath = await this.ensureOutbox(accountId);
             const client = this.createClient(accountId);
@@ -1734,7 +1771,7 @@ export class ImapManager extends EventEmitter {
         catch (e) {
             console.error(`  [outbox] IMAP queue failed: ${e.message} — saving locally`);
         }
-        // Fallback: save to local file queue
+        // Fallback: save to local file queue (processLocalQueue picks these up)
         const localQueue = path.join(getConfigDir(), "outbox", accountId);
         fs.mkdirSync(localQueue, { recursive: true });
         const now = new Date();
@@ -1743,17 +1780,15 @@ export class ImapManager extends EventEmitter {
         fs.writeFileSync(path.join(localQueue, filename), rawMessage);
         console.log(`  [outbox] Saved locally: ${filename}`);
     }
-    /** Process local file queue — send from outbox/ and sending/queued/ */
+    /** Process local file queue — send from outbox/ only (IMAP-unreachable fallback).
+     *  Do NOT scan sending/<acct>/queued/ — that was causing every sent message to be
+     *  re-APPENDed to the IMAP Outbox on the next tick and delivered twice. */
     async processLocalQueue(accountId) {
-        // Collect files from both outbox/ (legacy .ltr) and sending/queued/ (drop-in)
         const outboxDir = path.join(getConfigDir(), "outbox", accountId);
-        const queuedDir = path.join(getConfigDir(), "sending", accountId, "queued");
         const filesToSend = [];
-        for (const dir of [outboxDir, queuedDir]) {
-            if (!fs.existsSync(dir))
-                continue;
-            for (const file of fs.readdirSync(dir).filter(f => f.endsWith(".ltr") || f.endsWith(".eml"))) {
-                filesToSend.push({ dir, file });
+        if (fs.existsSync(outboxDir)) {
+            for (const file of fs.readdirSync(outboxDir).filter(f => f.endsWith(".ltr") || f.endsWith(".eml"))) {
+                filesToSend.push({ dir: outboxDir, file });
             }
         }
         if (filesToSend.length === 0)

package/packages/mailx-service/index.d.ts

@@ -48,10 +48,10 @@ export declare class MailxService {
         filename: string;
     }>;
     saveDraft(accountId: string, subject: string, bodyHtml: string, bodyText: string, to?: string, cc?: string, previousDraftUid?: number, draftId?: string): Promise<{
-        uid: number | null;
+        draftUid: number | null;
         draftId: string;
     }>;
-    deleteDraft(accountId: string, draftUid: number): Promise<void>;
+    deleteDraft(accountId: string, draftUid: number, draftId?: string): Promise<void>;
     searchContacts(query: string): any[];
     syncGoogleContacts(): Promise<void>;
     seedContacts(): number;

package/packages/mailx-service/index.js

@@ -572,11 +572,11 @@ export class MailxService {
             }
         }
         catch { /* ignore */ }
-        const uid = await this.imapManager.saveDraft(accountId, raw, previousDraftUid, id);
-        return { uid, draftId: id };
+        const draftUid = await this.imapManager.saveDraft(accountId, raw, previousDraftUid, id);
+        return { draftUid, draftId: id };
     }
-    async deleteDraft(accountId, draftUid) {
-        await this.imapManager.deleteDraft(accountId, draftUid);
+    async deleteDraft(accountId, draftUid, draftId) {
+        await this.imapManager.deleteDraft(accountId, draftUid, draftId);
     }
     // ── Contacts ──
     searchContacts(query) {

package/packages/mailx-service/jsonrpc.js

@@ -76,7 +76,7 @@ async function dispatchAction(svc, action, p) {
         case "saveDraft":
             return svc.saveDraft(p.accountId, p.subject, p.bodyHtml, p.bodyText, p.to, p.cc, p.previousDraftUid, p.draftId);
         case "deleteDraft":
-            await svc.deleteDraft(p.accountId, p.draftUid);
+            await svc.deleteDraft(p.accountId, p.draftUid, p.draftId);
             return { ok: true };
         // Sync
         case "syncAll":

package/packages/mailx-store/db.js

@@ -448,8 +448,9 @@ export class MailxDB {
             }
             const countRow = this.db.prepare(`SELECT COUNT(*) as cnt FROM messages m JOIN messages_fts fts ON m.id = fts.rowid WHERE messages_fts MATCH ?${scopeWhere}`).get(ftsQuery, ...scopeParams);
             const total = countRow?.cnt || 0;
-            const rows = this.db.prepare(`SELECT m.* FROM messages m
+            const rows = this.db.prepare(`SELECT m.*, f.name AS folder_name FROM messages m
                  JOIN messages_fts fts ON m.id = fts.rowid
+                 LEFT JOIN folders f ON f.id = m.folder_id AND f.account_id = m.account_id
                  WHERE messages_fts MATCH ?${scopeWhere}
                  ORDER BY m.date DESC
                  LIMIT ? OFFSET ?`).all(ftsQuery, ...scopeParams, pageSize, offset);
@@ -457,6 +458,7 @@ export class MailxDB {
                 id: r.id,
                 accountId: r.account_id,
                 folderId: r.folder_id,
+                folderName: r.folder_name || "",
                 uid: r.uid,
                 messageId: r.message_id || "",
                 inReplyTo: r.in_reply_to || "",

package/packages/mailx-types/index.d.ts

@@ -59,6 +59,7 @@ export interface MessageEnvelope {
     id: number; /** Local store ID */
     accountId: string;
     folderId: number;
+    folderName?: string; /** Leaf folder name; populated by cross-folder search so the UI can tag each hit */
     uid: number; /** IMAP UID */
     messageId: string; /** RFC Message-ID header */
     inReplyTo: string; /** For threading */