@bobfrankston/mailx 1.0.399 → 1.0.405

package/client/android.html

@@ -145,6 +145,7 @@
                 <input type="search" id="search-input" placeholder="Search..." autocomplete="off" title="Search messages">
             </search>
             <div class="ml-header">
+                <span class="ml-col ml-col-avatar"></span>
                 <span class="ml-col ml-col-flag"></span>
                 <span class="ml-col ml-col-from" data-sort="from">From</span>
                 <span class="ml-col ml-col-date" data-sort="date">Date</span>

package/client/app.js

@@ -1266,6 +1266,21 @@ window.addEventListener("message", (e) => {
     // with no failures), so we do the IPC from here and post the result back
     // to the iframe via its source. `e.source` is the iframe's window; use it
     // so targeting works even if the iframe moves in the DOM.
+    // S61 2026-04-24: parent-relay compose close. On Android the
+    // window.close() override applied in `frame.onload` doesn't always fire
+    // (WebView2 / MAUI WebView dispatches close to the shell in some cases),
+    // leaving the compose overlay stuck after Send. postMessage is reliable;
+    // compose.ts's closeCompose() posts this, and we find-and-remove the
+    // overlay whose iframe window matches e.source.
+    if (e.data?.type === "mailx-compose-close") {
+        const src = e.source;
+        document.querySelectorAll(".compose-overlay").forEach(el => {
+            const iframe = el.querySelector("iframe");
+            if (!src || iframe?.contentWindow === src)
+                el.remove();
+        });
+        return;
+    }
     if (e.data?.type === "mailx-compose-send" && e.data.id && e.data.body) {
         const src = e.source;
         const id = e.data.id;

package/client/components/message-list.js

@@ -100,6 +100,17 @@ function clearSelection() {
     // would break if we kept a stale pointer.
     currentFocusedRow = null;
 }
+/** Deterministic sender-avatar color from a seed string (typically the
+ *  email address). Hash → hue at 12 evenly-spaced positions on the wheel.
+ *  Saturation + lightness fixed so all colors carry the same visual weight
+ *  regardless of hue, and so light/dark themes don't have to override. */
+function senderColor(seed) {
+    let h = 0;
+    for (let i = 0; i < seed.length; i++)
+        h = (h * 31 + seed.charCodeAt(i)) | 0;
+    const hue = ((Math.abs(h) % 12) * 30) + 15; // 15, 45, 75, …, 345
+    return `oklch(0.62 0.14 ${hue})`;
+}
 /** Exit multi-select mode (entered via touch long-press). Clears selection
  *  and the sticky body flag so subsequent taps open messages again. */
 function exitMultiSelect() {
@@ -723,6 +734,41 @@ function appendMessages(body, accountId, items) {
         row.dataset.folderId = String(msg.folderId);
         if (msg.threadId)
             row.dataset.threadId = msg.threadId;
+        // Sender avatar \u2014 Thunderbird-style colored circle with the first
+        // initial of the sender's display name. Doubles as the multi-select
+        // affordance: in `multi-select-on` mode, the avatar swaps to a
+        // checkmark via CSS. Color is derived deterministically from the
+        // address so the same sender keeps the same color across rows.
+        const fromName = (showToInsteadOfFrom && msg.to?.length)
+            ? (msg.to[0].name || msg.to[0].address || "?")
+            : (msg.from?.name || msg.from?.address || "?");
+        const seedAddr = (msg.from?.address || msg.from?.name || "?").toLowerCase();
+        const initial = (fromName.replace(/^[\W_]+/, "") || "?").charAt(0).toUpperCase();
+        const avatar = document.createElement("span");
+        avatar.className = "ml-avatar";
+        avatar.textContent = initial;
+        avatar.style.background = senderColor(seedAddr);
+        avatar.title = msg.from?.address || "";
+        // Tapping the avatar enters multi-select mode (or toggles in it,
+        // mirroring Thunderbird/Gmail). Click bubbles to the row otherwise,
+        // which would open the message — stopPropagation here keeps the
+        // avatar a dedicated selection affordance.
+        avatar.addEventListener("click", (e) => {
+            e.stopPropagation();
+            const body = document.getElementById("ml-body");
+            if (!body)
+                return;
+            if (body.classList.contains("multi-select-on")) {
+                row.classList.toggle("selected");
+            }
+            else {
+                clearSelection();
+                row.classList.add("selected");
+                body.classList.add("multi-select-on");
+            }
+            lastClickedRow = row;
+            updateBulkBar();
+        });
         const flag = document.createElement("span");
         flag.className = "ml-flag";
         flag.textContent = msg.flags.includes("\\Flagged") ? "\u2605" : "\u2606";
@@ -751,6 +797,15 @@ function appendMessages(body, accountId, items) {
             folderTag.title = `In folder: ${msg.folderName}`;
             from.prepend(folderTag);
         }
+        // Unified inbox: same Message-ID exists under >=2 accounts → ⇆ badge.
+        // Tooltip names the count so the user knows "this appears on N".
+        if (msg.dupeCount >= 2) {
+            const dupe = document.createElement("span");
+            dupe.className = "ml-dupe-tag";
+            dupe.textContent = "⇆";
+            dupe.title = `Same message on ${msg.dupeCount} accounts`;
+            from.prepend(dupe);
+        }
         const subject = document.createElement("span");
         subject.className = "ml-subject";
         subject.innerHTML = escapeHtml(msg.subject);
@@ -795,6 +850,7 @@ function appendMessages(body, accountId, items) {
             }
             catch { /* ignore */ }
         });
+        row.appendChild(avatar);
         row.appendChild(flag);
         row.appendChild(from);
         row.appendChild(date);

package/client/components/message-viewer.js

@@ -191,6 +191,17 @@ function installPreviewControls(iframe) {
             const pct = Math.round(previewZoom * 100);
             const sel = doc.defaultView?.getSelection();
             const selectedText = sel?.toString().trim() || "";
+            const runSearch = (query) => {
+                const input = document.getElementById("search-input");
+                if (!input)
+                    return;
+                input.value = query;
+                // Trigger the existing search path — Enter keydown hits the
+                // immediate branch in app.ts's handler.
+                input.dispatchEvent(new Event("input"));
+                input.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
+                input.focus();
+            };
             const items = [
                 { label: "Copy", action: () => doc.execCommand("copy") },
                 { label: "Select all", action: () => {
@@ -202,14 +213,35 @@ function installPreviewControls(iframe) {
                         s.removeAllRanges();
                         s.addRange(range);
                     } },
-                { label: "", action: () => { }, separator: true },
-                { label: selectedText ? "Translate selection" : "Translate message",
-                    action: () => translateAndShow(selectedText || (doc.body?.innerText || "")) },
-                { label: "", action: () => { }, separator: true },
-                { label: "Zoom in", action: () => setZoom(previewZoom + ZOOM_STEP, doc) },
-                { label: "Zoom out", action: () => setZoom(previewZoom - ZOOM_STEP, doc) },
-                { label: `Reset zoom (${pct}%)`, action: () => setZoom(1, doc) },
             ];
+            if (selectedText) {
+                items.push({ label: "", action: () => { }, separator: true }, 
+                // Truncate long selections in the label so the menu doesn't
+                // blow out; full string is what we search for.
+                { label: `Search messages for "${selectedText.length > 40 ? selectedText.slice(0, 40) + "…" : selectedText}"`,
+                    action: () => runSearch(selectedText) }, {
+                    label: "Copy as quoted (> prefix)",
+                    action: async () => {
+                        // Prefix each line with "> " (RFC 3676 reply-quote).
+                        // Useful when pasting a snippet into a compose window
+                        // without the usual full-message blockquote wrapping.
+                        const quoted = selectedText.split(/\r?\n/).map(l => "> " + l).join("\n");
+                        try {
+                            await navigator.clipboard.writeText(quoted);
+                        }
+                        catch { /* */ }
+                    },
+                });
+            }
+            const senderAddr = currentMessage?.from?.address || "";
+            if (senderAddr) {
+                items.push({
+                    label: `Search messages from ${senderAddr}`,
+                    action: () => runSearch(`from:${senderAddr}`),
+                });
+            }
+            items.push({ label: "", action: () => { }, separator: true }, { label: selectedText ? "Translate selection" : "Translate message",
+                action: () => translateAndShow(selectedText || (doc.body?.innerText || "")) }, { label: "", action: () => { }, separator: true }, { label: "Zoom in", action: () => setZoom(previewZoom + ZOOM_STEP, doc) }, { label: "Zoom out", action: () => setZoom(previewZoom - ZOOM_STEP, doc) }, { label: `Reset zoom (${pct}%)`, action: () => setZoom(1, doc) });
             showContextMenu(x, y, items);
         });
     };
@@ -239,8 +271,24 @@ export async function showMessage(accountId, uid, folderId, specialUse, isRetry
     const headerEl = document.getElementById("mv-header");
     const bodyEl = document.getElementById("mv-body");
     const attEl = document.getElementById("mv-attachments");
-    bodyEl.innerHTML = `<div class="mv-empty">Fetching message body...</div>`;
-    headerEl.hidden = true;
+    // Envelope-first render: the row the user just clicked already has the
+    // subject / from / to / cc / date / preview in the message-state. Use
+    // that to populate the header + a snippet placeholder IMMEDIATELY so
+    // tapping a message never shows just "Fetching message body..." with
+    // nothing actionable. The full getMessage() call (which might block on
+    // a slow IMAP body fetch) only fills in the body and attachments.
+    const cached = state.getSelected();
+    if (cached && cached.uid === uid && (cached.accountId || accountId) === accountId) {
+        try {
+            renderHeaderFromEnvelope(headerEl, cached);
+        }
+        catch { /* */ }
+        bodyEl.innerHTML = `<div class="mv-empty">Fetching message body…<br><br><span style="color:var(--color-text-muted);font-size:0.9em">${escapeHtml(cached.preview || "")}</span></div>`;
+    }
+    else {
+        bodyEl.innerHTML = `<div class="mv-empty">Fetching message body...</div>`;
+        headerEl.hidden = true;
+    }
     attEl.hidden = true;
     try {
         const msg = await getMessage(accountId, uid, false, folderId);
@@ -697,6 +745,29 @@ export async function showMessage(accountId, uid, folderId, specialUse, isRetry
                         console.error(`Attachment download failed: ${err.message}`);
                     }
                 });
+                // Drag the chip to an external target (Explorer / Finder / Files app)
+                // to drop the file there. Uses the Chromium `DownloadURL` dataTransfer
+                // format: "mime:filename:blob-url". We fetch the attachment first so
+                // the blob URL is valid by the time the drop lands.
+                chip.draggable = true;
+                chip.addEventListener("dragstart", async (e) => {
+                    if (!e.dataTransfer)
+                        return;
+                    try {
+                        const data = await getAttachment(accountId, uid, i, msg.folderId);
+                        const bytes = Uint8Array.from(atob(data.content), c => c.charCodeAt(0));
+                        const blob = new Blob([bytes], { type: data.contentType || "application/octet-stream" });
+                        const url = URL.createObjectURL(blob);
+                        // Sanitize filename: no path separators, no newlines.
+                        const safeName = (att.filename || "attachment").replace(/[\r\n"\/\\]/g, "_");
+                        const downloadUrl = `${data.contentType || "application/octet-stream"}:${safeName}:${url}`;
+                        e.dataTransfer.setData("DownloadURL", downloadUrl);
+                        e.dataTransfer.effectAllowed = "copy";
+                    }
+                    catch (err) {
+                        console.error(`Attachment drag-out failed: ${err.message || err}`);
+                    }
+                });
                 attEl.appendChild(chip);
             }
         }
@@ -731,6 +802,40 @@ function formatAddr(addr) {
         return `${addr.name} <${addr.address}>`;
     return addr.address;
 }
+/** Render the viewer header from a list-row envelope (instant — no body
+ *  fetch awaited). Used to populate the header pane the moment a message
+ *  is clicked so the user always sees something actionable; getMessage()
+ *  later overwrites the same fields with the authoritative values from the
+ *  body parse (which can add Cc, Delivered-To, etc. that the list row
+ *  doesn't track). */
+function renderHeaderFromEnvelope(headerEl, env) {
+    headerEl.hidden = false;
+    const fromEl = headerEl.querySelector(".mv-from");
+    const toEl = headerEl.querySelector(".mv-to");
+    const subjEl = headerEl.querySelector(".mv-subject");
+    const dateEl = headerEl.querySelector(".mv-date");
+    if (fromEl)
+        fromEl.textContent = formatAddr(env.from);
+    if (toEl) {
+        let toLine = `To: ${(env.to || []).map(formatAddr).join(", ")}`;
+        if (env.cc?.length)
+            toLine += `  Cc: ${env.cc.map(formatAddr).join(", ")}`;
+        toEl.textContent = toLine;
+    }
+    if (subjEl)
+        subjEl.textContent = env.subject || "";
+    if (dateEl) {
+        try {
+            dateEl.textContent = new Date(env.date).toLocaleString();
+        }
+        catch {
+            dateEl.textContent = "";
+        }
+    }
+}
+function escapeHtml(s) {
+    return (s || "").replace(/[&<>"']/g, c => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", "\"": "&quot;", "'": "&#39;" }[c]));
+}
 /** Convert plain text URLs into clickable links, escaping HTML */
 function linkifyText(text) {
     // Escape HTML first
@@ -922,15 +1027,12 @@ ${csp}
     document.addEventListener("touchcancel", function () {
         lastTouchTarget = null; touchMoved = false;
     }, { passive: true, capture: true });
-    document.addEventListener("mouseover", function (e) {
-        var a = e.target && e.target.closest ? e.target.closest("a[href]") : null;
-        if (a) {
-            var r = a.getBoundingClientRect();
-            window.parent.postMessage({ type: "linkHover", url: a.href, rect: { left: r.left, top: r.top, right: r.right, bottom: r.bottom } }, "*");
-        } else {
-            window.parent.postMessage({ type: "linkHover", url: "" }, "*");
-        }
-    });
+    // Link hover popover removed 2026-04-24 — user feedback: it persisted
+    // over the message body when the dismissers (mousedown/scroll/blur)
+    // didn't fire from inside the iframe, leaving a multi-line URL hanging
+    // in the middle of the reading pane. Right-click (desktop) and long-
+    // press (touch) on a link still open the existing C29 menu with Open /
+    // Save-as / Copy URL / Copy link-text.
     // C29: right-click on a link → ask parent for the Open/Save/Copy menu.
     document.addEventListener("contextmenu", function (e) {
         var a = e.target && e.target.closest ? e.target.closest("a[href]") : null;

package/client/compose/compose.js

@@ -11,7 +11,18 @@ logClientEvent("compose-module-loaded", { href: location.href, version: window.m
 /** Close compose window */
 function closeCompose() {
     logClientEvent("compose-close");
-    window.close();
+    // S61: Android WebView's window.close() override is unreliable inside
+    // iframes — compose overlay sometimes stays visible after Send. Primary
+    // path is a parent postMessage; window.close() is a fallback that also
+    // works on desktop/msger where the override DOES fire reliably.
+    try {
+        parent.postMessage({ type: "mailx-compose-close" }, "*");
+    }
+    catch { /* */ }
+    try {
+        window.close();
+    }
+    catch { /* */ }
 }
 // ── Load editor scripts dynamically ──
 function loadScript(src) {
@@ -147,20 +158,54 @@ if (appSettings?.autocomplete?.enabled && appSettings.autocomplete.provider !==
 function formatAccountFrom(acct) {
     return `${acct.name} <${acct.email}>`;
 }
-/** Populate the From <datalist> with one entry per known account and set
- *  the input's current value to the selected account (or the first/default
- *  account when no selection is given). */
+const FROM_HISTORY_KEY = "mailx-from-history"; // up to 20 recent manual From entries
+const FROM_HISTORY_MAX = 20;
+function loadFromHistory() {
+    try {
+        return JSON.parse(localStorage.getItem(FROM_HISTORY_KEY) || "[]");
+    }
+    catch {
+        return [];
+    }
+}
+function recordFromHistory(value) {
+    const v = (value || "").trim();
+    if (!v)
+        return;
+    try {
+        const list = loadFromHistory().filter(x => x !== v);
+        list.unshift(v);
+        localStorage.setItem(FROM_HISTORY_KEY, JSON.stringify(list.slice(0, FROM_HISTORY_MAX)));
+    }
+    catch { /* private mode */ }
+}
+/** Populate the From <datalist> with one entry per known account plus any
+ *  manually-typed addresses from localStorage history. Account entries rank
+ *  first; history entries get an "(used before)" label so the user can tell
+ *  which ones are real accounts vs free-form aliases. */
 function populateFromOptions(accounts, selectedId) {
     knownAccounts = accounts;
     fromOptions.innerHTML = "";
+    const seenValues = new Set();
     for (const acct of accounts) {
         const opt = document.createElement("option");
         opt.value = formatAccountFrom(acct);
-        // datalist options can carry a label so the dropdown row shows the
-        // friendly account tag ("gmail", "bob.ma") next to the address.
         const tag = acct.label || acct.name;
         opt.label = tag;
         fromOptions.appendChild(opt);
+        seenValues.add(opt.value);
+    }
+    // Custom From history — addresses the user has typed before that don't
+    // match any known account (aliases, +tag addresses, one-off identities).
+    // Stored in localStorage because they're inherently per-device preferences;
+    // moving them to an account profile would be a different feature.
+    for (const value of loadFromHistory()) {
+        if (seenValues.has(value))
+            continue;
+        const opt = document.createElement("option");
+        opt.value = value;
+        opt.label = "(used before)";
+        fromOptions.appendChild(opt);
     }
     if (!fromInput.value) {
         const selected = (selectedId && accounts.find(a => a.id === selectedId)) ||
@@ -249,41 +294,46 @@ function setupAutocomplete(input) {
             closeDropdown();
             return;
         }
-        debounce = setTimeout(async () => {
-            try {
-                const results = await searchContacts(token);
-                if (results.length === 0) {
+        debounce = setTimeout(() => {
+            // rAF yield before hitting the DB — S60 mitigation, same reason
+            // as the draft-save path. The 200 ms timer already deferred past
+            // the input burst; this extra frame lets the last keystroke paint.
+            requestAnimationFrame(async () => {
+                try {
+                    const results = await searchContacts(token);
+                    if (results.length === 0) {
+                        closeDropdown();
+                        return;
+                    }
                     closeDropdown();
-                    return;
-                }
-                closeDropdown();
-                dropdown = document.createElement("div");
-                dropdown.className = "ac-dropdown";
-                activeIndex = 0; // first item highlighted by default
-                for (let i = 0; i < results.length; i++) {
-                    const item = document.createElement("div");
-                    item.className = `ac-item${i === 0 ? " ac-active" : ""}`;
-                    const nameEl = document.createElement("span");
-                    nameEl.className = "ac-item-name";
-                    nameEl.textContent = results[i].name || results[i].email;
-                    const emailEl = document.createElement("span");
-                    emailEl.className = "ac-item-email";
-                    emailEl.textContent = results[i].email;
-                    item.appendChild(nameEl);
-                    if (results[i].name)
-                        item.appendChild(emailEl);
-                    item.addEventListener("mousedown", (e) => {
-                        e.preventDefault();
-                        const display = results[i].name
-                            ? `${results[i].name} <${results[i].email}>`
-                            : results[i].email;
-                        replaceLastToken(display);
-                    });
-                    dropdown.appendChild(item);
+                    dropdown = document.createElement("div");
+                    dropdown.className = "ac-dropdown";
+                    activeIndex = 0; // first item highlighted by default
+                    for (let i = 0; i < results.length; i++) {
+                        const item = document.createElement("div");
+                        item.className = `ac-item${i === 0 ? " ac-active" : ""}`;
+                        const nameEl = document.createElement("span");
+                        nameEl.className = "ac-item-name";
+                        nameEl.textContent = results[i].name || results[i].email;
+                        const emailEl = document.createElement("span");
+                        emailEl.className = "ac-item-email";
+                        emailEl.textContent = results[i].email;
+                        item.appendChild(nameEl);
+                        if (results[i].name)
+                            item.appendChild(emailEl);
+                        item.addEventListener("mousedown", (e) => {
+                            e.preventDefault();
+                            const display = results[i].name
+                                ? `${results[i].name} <${results[i].email}>`
+                                : results[i].email;
+                            replaceLastToken(display);
+                        });
+                        dropdown.appendChild(item);
+                    }
+                    input.parentElement.appendChild(dropdown);
                 }
-                input.parentElement.appendChild(dropdown);
-            }
-            catch { /* ignore */ }
+                catch { /* ignore */ }
+            });
         }, 200);
     });
     input.addEventListener("keydown", (e) => {
@@ -499,12 +549,23 @@ async function saveDraft() {
         draftSaving = false;
     }
 }
-/** Schedule a debounced save on user input — fires ~1.5s after the last keystroke. */
+/** Schedule a debounced save on user input — fires ~1.5s after the last
+ *  keystroke, then yields one animation frame before actually writing so
+ *  the browser can paint any keystroke in the mean time. S60 mitigation:
+ *  wa-sqlite writes are synchronous on Android; this keeps the typing
+ *  experience responsive by never running the write in the same task as
+ *  an input event. */
 function scheduleDraftSave() {
     markComposeDirty();
     if (draftDebounceTimer)
         clearTimeout(draftDebounceTimer);
-    draftDebounceTimer = setTimeout(() => { draftDebounceTimer = null; saveDraft(); }, DRAFT_INPUT_DEBOUNCE_MS);
+    draftDebounceTimer = setTimeout(() => {
+        draftDebounceTimer = null;
+        // rAF yield — lets any pending keystroke render before we block on
+        // the DB write. A no-op when the tab is hidden (rAF is throttled),
+        // which is fine because the user isn't typing then either.
+        requestAnimationFrame(() => { saveDraft(); });
+    }, DRAFT_INPUT_DEBOUNCE_MS);
 }
 // ── Initialize: local-first population.
 //
@@ -689,6 +750,17 @@ document.getElementById("btn-send")?.addEventListener("click", () => {
         .then(() => {
         logClientEvent("compose-send-ipc-resolved", { ms: Date.now() - sendStart });
         console.log(`[compose] Send IPC returned OK in ${Date.now() - sendStart}ms`);
+        // Record From-address history on successful send. Only manual
+        // values worth keeping — skip anything that exactly matches a
+        // known account (already in the dropdown), and skip obviously
+        // invalid inputs. Populated dropdown surfaces this next time.
+        try {
+            const raw = fromInput.value.trim();
+            const known = knownAccounts.some(a => formatAccountFrom(a) === raw);
+            if (raw && !known && /@.+\./.test(raw))
+                recordFromHistory(raw);
+        }
+        catch { /* */ }
         // Stop autosave only after ACK — if send threw we want the draft
         // autosave to keep the message safe.
         if (draftTimer) {

package/client/index.html

@@ -118,6 +118,7 @@
             </search>
             <div class="ml-folder-title" id="ml-folder-title"></div>
             <div class="ml-header" id="ml-header">
+                <span class="ml-col ml-col-avatar"></span>
                 <span class="ml-col ml-col-flag"></span>
                 <span class="ml-col ml-col-from ml-col-sortable" data-sort="from">From</span>
                 <span class="ml-col ml-col-date ml-col-sortable" data-sort="date">Date</span>

package/client/styles/components.css

@@ -299,7 +299,8 @@ button.tb-menu-item { background: none; border: none; color: inherit; width: 100
 
 .message-list {
     display: grid;
-    grid-template-columns: 1.2em minmax(120px, 200px) auto 1fr;
+    /* avatar | flag | from | date | subject */
+    grid-template-columns: 28px 1.2em minmax(120px, 200px) auto 1fr;
     grid-template-rows: auto auto 1fr;
     column-gap: var(--gap-sm);
     overflow: hidden;
@@ -308,7 +309,7 @@ button.tb-menu-item { background: none; border: none; color: inherit; width: 100
 
 /* Two-line view */
 .message-list.two-line {
-    grid-template-columns: 1.2em 1fr auto;
+    grid-template-columns: 28px 1.2em 1fr auto;
 }
 
 .message-list.two-line .ml-row {
@@ -316,11 +317,12 @@ button.tb-menu-item { background: none; border: none; color: inherit; width: 100
     grid-template-rows: auto auto;
 }
 
-.message-list.two-line .ml-flag { grid-row: 1 / 3; align-self: center; }
-.message-list.two-line .ml-from { grid-column: 2; }
-.message-list.two-line .ml-date { grid-column: 3; grid-row: 1; padding-right: var(--gap-md); }
+.message-list.two-line .ml-avatar { grid-row: 1 / 3; align-self: center; grid-column: 1; }
+.message-list.two-line .ml-flag { grid-row: 1 / 3; align-self: center; grid-column: 2; }
+.message-list.two-line .ml-from { grid-column: 3; }
+.message-list.two-line .ml-date { grid-column: 4; grid-row: 1; padding-right: var(--gap-md); }
 .message-list.two-line .ml-subject {
-    grid-column: 2 / 4;
+    grid-column: 3 / 5;
     grid-row: 2;
     color: oklch(0.55 0.10 250) !important;
     font-size: var(--font-size-sm);
@@ -900,6 +902,66 @@ button.tb-menu-item { background: none; border: none; color: inherit; width: 100
    list empty when the selection is a singleton thread. */
 .ml-row.thread-filter-hidden { display: none; }
 
+/* Sender avatar — Thunderbird-style 24-px circle with the sender's first
+   initial. Background color is hashed from the sender's address so the
+   same person keeps the same color across rows. In multi-select mode
+   (#ml-body.multi-select-on) the avatar swaps to a checkmark per row,
+   filled when selected, hollow when not — matches the Thunderbird /
+   Gmail / Apple Mail pattern. */
+.ml-avatar {
+    width: 24px;
+    height: 24px;
+    border-radius: 50%;
+    background: oklch(0.62 0.14 250);
+    color: #fff;
+    font-size: 0.78rem;
+    font-weight: 600;
+    line-height: 24px;
+    text-align: center;
+    user-select: none;
+    flex-shrink: 0;
+    align-self: center;
+    cursor: pointer;
+}
+#ml-body.multi-select-on .ml-avatar {
+    background: transparent !important;
+    color: var(--color-text-muted);
+    border: 2px solid currentColor;
+    line-height: 20px;
+}
+#ml-body.multi-select-on .ml-avatar::before { content: ""; }
+#ml-body.multi-select-on .ml-row.selected .ml-avatar {
+    background: var(--color-brand, oklch(0.55 0.18 250)) !important;
+    color: #fff;
+    border-color: var(--color-brand, oklch(0.55 0.18 250));
+}
+/* Replace the initial with a check when selected in multi-mode. The
+   `font-size: 0` trick blanks the text node we set in JS without having
+   to clear it; the ::after glyph then fills the space. */
+#ml-body.multi-select-on .ml-avatar { font-size: 0; }
+#ml-body.multi-select-on .ml-avatar::after { content: ""; }
+#ml-body.multi-select-on .ml-row.selected .ml-avatar::after {
+    content: "✓";
+    font-size: 0.95rem;
+    line-height: 20px;
+    font-weight: 700;
+}
+
+/* Add an avatar slot to the header so columns line up. Header is a sibling
+   subgrid; first cell is empty (avatar column). */
+.ml-header { grid-template-columns: subgrid; }
+
+/* Duplicate-message-id tag in unified inbox — shown when the same
+   Message-ID appears across 2+ accounts (same letter delivered to both,
+   mailing-list Bcc, etc.). Subtle teal badge; tooltip explains. */
+.ml-dupe-tag {
+    display: inline-block;
+    color: oklch(0.55 0.14 195);
+    font-weight: 600;
+    margin-right: 0.3em;
+    user-select: none;
+}
+
 /* Per-row ⋮ touch-menu button removed 2026-04-24 — user feedback: "nice
    idea but better when we have a second-stage plan strategy". Touch users
    still reach the menu via long-press → multi-select → bulk-bar, or by

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.399",
+  "version": "1.0.405",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",

package/packages/mailx-imap/index.js

@@ -2402,14 +2402,19 @@ export class ImapManager extends EventEmitter {
     async updateFlagsLocal(accountId, uid, folderId, flags) {
         this.db.updateMessageFlags(accountId, uid, flags);
         this.db.queueSyncAction(accountId, "flags", uid, folderId, { flags });
-        // Don't process immediately — let the 30s timer batch actions
-        // (immediate processing during sync causes connection churn)
+        // User-visible pink-dot pending state stays until the action drains.
+        // The 30-second periodic tick was too slow — opening one message to
+        // auto-mark-as-read left it pink for half a minute. Same 1-second
+        // debounce as moves/deletes batches rapid flag churn without the
+        // visual lag.
+        this.debounceSyncActions(accountId);
     }
     /** Process pending sync actions for an account */
     async processSyncActions(accountId) {
         const actions = this.db.getPendingSyncActions(accountId);
         if (actions.length === 0)
             return;
+        const startCount = actions.length;
         const folders = this.db.getFolders(accountId);
         // Gmail path: push flag/label changes through the REST provider so
         // they actually reach the server. Earlier this method always went
@@ -2475,6 +2480,11 @@ export class ImapManager extends EventEmitter {
                 }
                 catch { /* */ }
             }
+            // Nudge the UI so rows that were pending-reconcile re-query their
+            // pending state (pink dot was sticky until this event fired).
+            const remaining = this.db.getPendingSyncActions(accountId).length;
+            if (remaining < startCount)
+                this.emit("folderCountsChanged", accountId, {});
             return;
         }
         await this.withConnection(accountId, async (client) => {
@@ -2546,6 +2556,12 @@ export class ImapManager extends EventEmitter {
                 }
             }
         });
+        // IMAP path: same nudge as the Gmail branch above. Any action that
+        // drained (successful or gave-up-after-5) decrements the pending
+        // count, which flips the pink dot off on the next re-query.
+        const remaining = this.db.getPendingSyncActions(accountId).length;
+        if (remaining < startCount)
+            this.emit("folderCountsChanged", accountId, {});
     }
     /** Find a folder by specialUse, case-insensitive */
     findFolder(accountId, specialUse) {

package/packages/mailx-server/index.js

@@ -66,6 +66,35 @@ const imapManager = new ImapManager(db, () => new NodeTransport());
 // ── Express App ──
 const app = express();
 app.use(express.json({ limit: "Infinity" }));
+// Optional token gate — required whenever the server binds to anything other
+// than a loopback address. Set via `MAILX_SERVER_TOKEN=<secret>` (or the
+// shorter `MAILX_TOKEN`). When the server is loopback-only (the default), the
+// gate is a no-op since nothing outside the machine can reach it. When bound
+// externally (`MAILX_SERVER_HOST=0.0.0.0` or `--external`), connections must
+// present the token in either `?t=<token>` or the `x-mailx-token` header. No
+// token configured + external bind → server refuses to start (safer than
+// serving open).
+const SERVER_TOKEN = process.env.MAILX_SERVER_TOKEN || process.env.MAILX_TOKEN || "";
+const SERVER_HOST = process.env.MAILX_SERVER_HOST || "";
+const IS_EXTERNAL_BIND = SERVER_HOST && SERVER_HOST !== "127.0.0.1" && SERVER_HOST !== "localhost" && SERVER_HOST !== "::1";
+if (IS_EXTERNAL_BIND && !SERVER_TOKEN) {
+    console.error("[server] Refusing to bind externally without MAILX_SERVER_TOKEN. Set the env var or drop the external host.");
+    process.exit(2);
+}
+app.use((req, res, next) => {
+    if (!IS_EXTERNAL_BIND)
+        return next();
+    // Allow the bare static file fetch so the login page can render; every
+    // /api/* path requires the token.
+    if (!req.path.startsWith("/api/"))
+        return next();
+    const provided = req.query.t || req.header("x-mailx-token") || "";
+    if (provided !== SERVER_TOKEN) {
+        res.status(401).json({ error: "missing or invalid token" });
+        return;
+    }
+    next();
+});
 // Request logging
 app.use((req, res, next) => {
     const start = Date.now();

package/packages/mailx-store/db.js

@@ -879,7 +879,9 @@ export class MailxDB {
         const rows = this.db.prepare(`SELECT m.*, EXISTS(
                 SELECT 1 FROM sync_actions sa
                 WHERE sa.account_id = m.account_id AND sa.uid = m.uid
-            ) AS pending
+            ) AS pending,
+            (SELECT COUNT(DISTINCT account_id) FROM messages m2
+             WHERE m2.message_id = m.message_id AND m.message_id != '') AS dupeCount
             FROM messages m WHERE m.folder_id IN (${placeholders})
             ORDER BY m.date DESC LIMIT ? OFFSET ?`).all(...folderIds, pageSize, offset);
         const items = rows.map(r => ({
@@ -902,6 +904,11 @@ export class MailxDB {
             preview: r.preview,
             bodyPath: r.body_path || "",
             pending: !!r.pending,
+            // >=2 means the same message-id exists under another account in
+            // the local DB (delivered to both accounts, or a mailing-list
+            // Bcc). The unified-inbox UI shows a small ⇆ badge on these
+            // rows so the user knows "this is a copy of the same message".
+            dupeCount: r.dupeCount | 0,
         }));
         return { items, total, page, pageSize };
     }

package/packages/mailx-store-web/android-bootstrap.js

@@ -174,9 +174,19 @@ class AndroidSyncManager {
             const THROTTLE_MS = 150;
             const RATE_LIMIT_PAUSE_MS = 30000;
             const ERROR_BUDGET = 10;
+            const CONCURRENCY = 2; // S62: 2 in-flight per account
             let totalFetched = 0;
             let errors = 0;
             let announced = false;
+            // S62: INBOX always first. Within each folder the DB returns rows
+            // most-recent-first (PRIMARY KEY order), so newest unfetched INBOX
+            // mail wins the queue. A slow label (`[Gmail]/Jerrry`, etc.) can't
+            // starve INBOX any more.
+            const folderPriority = (folderId) => {
+                const f = this.db.getFolders(accountId).find((x) => x.id === folderId);
+                return f?.specialUse === "inbox" ? 0 : 1;
+            };
+            let rateLimitCooldownUntil = 0;
             while (true) {
                 const missing = this.db.getMessagesWithoutBody(accountId, BATCH_SIZE);
                 if (missing.length === 0)
@@ -186,46 +196,70 @@ class AndroidSyncManager {
                     vlog(`prefetch ${accountId} start: ${missing.length}+ pending`);
                     announced = true;
                 }
+                // Sort this batch INBOX-first. getMessagesWithoutBody doesn't
+                // know the priority, and re-querying per folder would multiply
+                // the SELECTs. One in-memory sort is cheap.
+                missing.sort((a, b) => folderPriority(a.folderId) - folderPriority(b.folderId));
                 let progressedThisBatch = false;
-                for (const m of missing) {
-                    // Sync the DB path if the body is already in IndexedDB — common
-                    // when upgrading from a build that didn't set body_path on cache.
-                    if (await this.bodyStore.hasMessage(accountId, m.folderId, m.uid)) {
-                        this.db.updateBodyPath(accountId, m.uid, `idb:${accountId}/${m.folderId}/${m.uid}`);
-                        progressedThisBatch = true;
-                        continue;
-                    }
-                    try {
-                        const result = await this.fetchMessageBody(accountId, m.folderId, m.uid);
-                        if (result) {
-                            totalFetched++;
-                            progressedThisBatch = true;
-                            emitEvent({ type: "bodyCached", accountId, uid: m.uid, folderId: m.folderId });
+                let batchAborted = false;
+                // Bounded-concurrency worker pool. Each worker pulls the next
+                // unclaimed item from `missing`. Shared flags (errors,
+                // rateLimitCooldownUntil, progressedThisBatch) are updated
+                // inside the loop — sql.js is single-threaded so there's no
+                // actual race on reads/writes.
+                let cursor = 0;
+                const worker = async () => {
+                    while (cursor < missing.length) {
+                        if (batchAborted)
+                            return;
+                        if (errors >= ERROR_BUDGET)
+                            return;
+                        const idx = cursor++;
+                        const m = missing[idx];
+                        // Honor rate-limit cooldown across workers.
+                        const now = Date.now();
+                        if (rateLimitCooldownUntil > now) {
+                            await new Promise(r => setTimeout(r, rateLimitCooldownUntil - now));
                         }
-                        else {
-                            errors++;
+                        if (await this.bodyStore.hasMessage(accountId, m.folderId, m.uid)) {
+                            this.db.updateBodyPath(accountId, m.uid, `idb:${accountId}/${m.folderId}/${m.uid}`);
+                            progressedThisBatch = true;
+                            continue;
                         }
-                    }
-                    catch (e) {
-                        errors++;
-                        const msg = String(e?.message || "");
-                        if (/429|rate|too many/i.test(msg)) {
-                            console.log(`[prefetch] ${accountId}: rate-limited — pausing ${RATE_LIMIT_PAUSE_MS / 1000}s`);
-                            await new Promise(r => setTimeout(r, RATE_LIMIT_PAUSE_MS));
+                        try {
+                            const result = await this.fetchMessageBody(accountId, m.folderId, m.uid);
+                            if (result) {
+                                totalFetched++;
+                                progressedThisBatch = true;
+                                emitEvent({ type: "bodyCached", accountId, uid: m.uid, folderId: m.folderId });
+                            }
+                            else {
+                                errors++;
+                            }
                         }
-                        else {
-                            console.error(`[prefetch] ${accountId}/${m.uid}: ${msg}`);
+                        catch (e) {
+                            errors++;
+                            const msg = String(e?.message || "");
+                            if (/429|rate|too many/i.test(msg)) {
+                                console.log(`[prefetch] ${accountId}: rate-limited — pausing ${RATE_LIMIT_PAUSE_MS / 1000}s`);
+                                rateLimitCooldownUntil = Date.now() + RATE_LIMIT_PAUSE_MS;
+                            }
+                            else {
+                                console.error(`[prefetch] ${accountId}/${m.uid}: ${msg}`);
+                            }
                         }
+                        // Throttle kept per-request to spread load on flaky
+                        // phone networks; concurrency-2 means effective request
+                        // rate is ~1 per THROTTLE_MS/2.
+                        await new Promise(r => setTimeout(r, THROTTLE_MS));
                     }
-                    if (errors >= ERROR_BUDGET) {
-                        console.error(`[prefetch] ${accountId}: stopping after ${errors} errors (${totalFetched} cached)`);
-                        vlog(`prefetch ${accountId} aborted: ${errors} errors, ${totalFetched} cached`);
-                        return;
-                    }
-                    await new Promise(r => setTimeout(r, THROTTLE_MS));
+                };
+                await Promise.all(Array.from({ length: Math.min(CONCURRENCY, missing.length) }, () => worker()));
+                if (errors >= ERROR_BUDGET) {
+                    console.error(`[prefetch] ${accountId}: stopping after ${errors} errors (${totalFetched} cached)`);
+                    vlog(`prefetch ${accountId} aborted: ${errors} errors, ${totalFetched} cached`);
+                    return;
                 }
-                // If a full batch made no progress, bail out to avoid an infinite
-                // loop on messages the server can't deliver.
                 if (!progressedThisBatch) {
                     console.warn(`[prefetch] ${accountId}: batch made no progress, stopping`);
                     break;
@@ -910,70 +944,12 @@ export async function initAndroid() {
         }
         await syncManager.addAccount(account);
     }
-    // Connect to GDrive using the Gmail token — read shared accounts.jsonc
-    if (gmailTokenProvider) {
-        setGDriveTokenProvider(gmailTokenProvider);
-        try {
-            console.log("[android] Looking up GDrive mailx folder...");
-            const folderId = await findGDriveMailxFolder(gmailTokenProvider);
-            if (!folderId) {
-                console.warn("[android] GDrive mailx folder not found");
-            }
-            else {
-                setGDriveFolderId(folderId);
-                console.log(`[android] GDrive mailx folder: ${folderId}`);
-                // DEBUG: list all files in the folder
-                try {
-                    const tk = await gmailTokenProvider();
-                    const lr = await fetch(`https://www.googleapis.com/drive/v3/files?q='${folderId}'+in+parents+and+trashed%3Dfalse&fields=files(id,name,mimeType,owners(emailAddress))`, { headers: { "Authorization": `Bearer ${tk}` } });
-                    if (lr.ok) {
-                        const ld = await lr.json();
-                        const names = (ld.files || []).map((f) => `${f.name}(${f.owners?.[0]?.emailAddress || "?"})`).join(",");
-                        console.log(`[android] Folder contents: ${ld.files?.length || 0} files [${names}]`);
-                    }
-                    else {
-                        console.warn(`[android] List folder failed: ${lr.status}`);
-                    }
-                }
-                catch (e) {
-                    console.warn(`[android] List debug: ${e.message}`);
-                }
-                // Read accounts directly from GDrive (bypass IndexedDB cache)
-                console.log("[android] Reading accounts.jsonc from GDrive...");
-                const gdriveAccounts = await loadAccountsFromCloud();
-                console.log(`[android] GDrive returned ${gdriveAccounts.length} accounts: ${gdriveAccounts.map(a => a.id).join(",")}`);
-                if (gdriveAccounts.length > 0) {
-                    // Use canonical GDrive accounts (upsert handles overwrites)
-                    accounts = gdriveAccounts;
-                    for (const account of accounts) {
-                        vlog(`init: registering ${account.id} email=${account.email} enabled=${account.enabled} imap=${JSON.stringify(account.imap)}`);
-                        if (!account.enabled) {
-                            vlog(`init: ${account.id} disabled, skipping`);
-                            continue;
-                        }
-                        const domain = account.email?.split("@")[1]?.toLowerCase() || "";
-                        if (domain === "gmail.com" || domain === "googlemail.com") {
-                            syncManager.setTokenProvider(account.id, createNativeTokenProvider(account.email));
-                        }
-                        await syncManager.addAccount(account);
-                    }
-                    console.log(`[android] Loaded ${accounts.length} accounts from GDrive`);
-                }
-                // Register this Android device in clients.jsonc
-                await registerDeviceInGDrive(gmailTokenProvider, folderId, accounts.map(a => a.id));
-            }
-        }
-        catch (e) {
-            console.warn(`[android] GDrive access failed: ${e.message}`);
-        }
-    }
+    // Install the mailxapi bridge + drain pending queues IMMEDIATELY using
+    // the local-cache account list. UI shouldn't wait on GDrive (which can
+    // be slow on cold network) before becoming actionable. GDrive
+    // reconciliation (below) runs in the background and re-registers fresh
+    // accounts when it returns.
     installBridge();
-    // Drain any stranded send-queue entries BEFORE first sync. A message
-    // queued in a prior session (offline, crashed mid-send, process killed)
-    // gets a retry as soon as we have accounts registered. Desktop parity.
-    // Q112 (2026-04-24): also drain move/flag/trash actions here — Android
-    // is standalone, not desktop-dependent, so it pushes state changes
-    // directly to the server the same way desktop does.
     for (const account of accounts) {
         if (!account.enabled)
             continue;
@@ -982,9 +958,73 @@ export async function initAndroid() {
         syncManager.processSyncActions(account.id)
             .catch(e => console.error(`[android] processSyncActions ${account.id}: ${e.message}`));
     }
+    // First sync from local accounts on a tiny delay so the UI gets to paint.
     setTimeout(() => {
         syncManager.syncAll().catch(e => console.error(`[android] Sync error: ${e.message}`));
     }, 1000);
+    // GDrive reconciliation runs in the background — accounts.jsonc on the
+    // shared cloud may have been edited from another device, so we re-pull
+    // and re-register if it differs from the cached copy. The user can
+    // already see and use mail by the time this resolves.
+    if (gmailTokenProvider) {
+        const tp = gmailTokenProvider;
+        (async () => {
+            setGDriveTokenProvider(tp);
+            try {
+                console.log("[android] Looking up GDrive mailx folder…");
+                const folderId = await findGDriveMailxFolder(tp);
+                if (!folderId) {
+                    console.warn("[android] GDrive mailx folder not found");
+                }
+                else {
+                    setGDriveFolderId(folderId);
+                    console.log(`[android] GDrive mailx folder: ${folderId}`);
+                    // DEBUG: list all files in the folder
+                    try {
+                        const tk = await tp();
+                        const lr = await fetch(`https://www.googleapis.com/drive/v3/files?q='${folderId}'+in+parents+and+trashed%3Dfalse&fields=files(id,name,mimeType,owners(emailAddress))`, { headers: { "Authorization": `Bearer ${tk}` } });
+                        if (lr.ok) {
+                            const ld = await lr.json();
+                            const names = (ld.files || []).map((f) => `${f.name}(${f.owners?.[0]?.emailAddress || "?"})`).join(",");
+                            console.log(`[android] Folder contents: ${ld.files?.length || 0} files [${names}]`);
+                        }
+                        else {
+                            console.warn(`[android] List folder failed: ${lr.status}`);
+                        }
+                    }
+                    catch (e) {
+                        console.warn(`[android] List debug: ${e.message}`);
+                    }
+                    // Read accounts directly from GDrive (bypass IndexedDB cache)
+                    console.log("[android] Reading accounts.jsonc from GDrive...");
+                    const gdriveAccounts = await loadAccountsFromCloud();
+                    console.log(`[android] GDrive returned ${gdriveAccounts.length} accounts: ${gdriveAccounts.map(a => a.id).join(",")}`);
+                    if (gdriveAccounts.length > 0) {
+                        // Use canonical GDrive accounts (upsert handles overwrites)
+                        accounts = gdriveAccounts;
+                        for (const account of accounts) {
+                            vlog(`init: registering ${account.id} email=${account.email} enabled=${account.enabled} imap=${JSON.stringify(account.imap)}`);
+                            if (!account.enabled) {
+                                vlog(`init: ${account.id} disabled, skipping`);
+                                continue;
+                            }
+                            const domain = account.email?.split("@")[1]?.toLowerCase() || "";
+                            if (domain === "gmail.com" || domain === "googlemail.com") {
+                                syncManager.setTokenProvider(account.id, createNativeTokenProvider(account.email));
+                            }
+                            await syncManager.addAccount(account);
+                        }
+                        console.log(`[android] Loaded ${accounts.length} accounts from GDrive`);
+                    }
+                    // Register this Android device in clients.jsonc
+                    await registerDeviceInGDrive(tp, folderId, accounts.map(a => a.id));
+                }
+            }
+            catch (e) {
+                console.warn(`[android] GDrive access failed: ${e.message}`);
+            }
+        })();
+    }
     // Periodic re-sync every 2 minutes (no IDLE on Android, so poll)
     const SYNC_INTERVAL_MS = 2 * 60 * 1000;
     setInterval(() => {

package/unwedge.cmd

@@ -0,0 +1 @@
+rmdir C:\Users\Bob\.claude\session-env\5a053d1d-7856-4e74-9b2b-23a4e3262aed /s /q