@bobfrankston/rmfmail 1.2.224 → 1.2.225

package/client/app.ts

@@ -1857,8 +1857,8 @@ async function performUndo(): Promise<void> {
                     ? [flag] // simplest restore — full set is unknown here
                     : [];
                 await updateFlags(entry.accountId, entry.uid, flagsAfter, entry.folderId);
-                setRowFlagged(entry.accountId, entry.uid, entry.prevFlagged);
-                messageState.updateMessageFlags(entry.accountId, entry.uid, flagsAfter);
+                setRowFlagged(entry.accountId, entry.uid, entry.prevFlagged, entry.folderId);
+                messageState.updateMessageFlags(entry.accountId, entry.uid, flagsAfter, entry.folderId);
             }
             if (statusSync) statusSync.textContent = `Undid flag change on ${op.payload.length} message${op.payload.length !== 1 ? "s" : ""}${remaining}`;
         }
@@ -2075,8 +2075,8 @@ async function bulkFlagSelected(): Promise<void> {
     for (const r of rows) {
         if (flaggedOf(r) === targetFlagged) continue;
         setFlagged(r, targetFlagged);
-        setRowFlagged(r.accountId, r.uid, targetFlagged);
-        messageState.updateMessageFlags(r.accountId, r.uid, r.flags);
+        setRowFlagged(r.accountId, r.uid, targetFlagged, (r as any).folderId);
+        messageState.updateMessageFlags(r.accountId, r.uid, r.flags, (r as any).folderId);
         try { await updateFlags(r.accountId, r.uid, r.flags, (r as any).folderId); }
         catch (e: any) { console.error(`Bulk flag failed for ${r.accountId}/${r.uid}: ${e?.message || e}`); }
     }
@@ -2097,10 +2097,10 @@ document.getElementById("btn-flag")?.addEventListener("click", async () => {
     updateFlagButton();
     try {
         await updateFlags(sel.accountId, sel.uid, sel.flags, (sel as any).folderId);
-        messageState.updateMessageFlags(sel.accountId, sel.uid, sel.flags);
+        messageState.updateMessageFlags(sel.accountId, sel.uid, sel.flags, (sel as any).folderId);
         // Row owns its own DOM \u2014 go through the row object so class + star
         // update atomically and the list/preview stay in sync.
-        setRowFlagged(sel.accountId, sel.uid, !wasFlagged);
+        setRowFlagged(sel.accountId, sel.uid, !wasFlagged, (sel as any).folderId);
     } catch (e: unknown) {
         // Revert local state on failure so visual + data stay consistent.
         setFlagged(sel, wasFlagged);
@@ -2172,9 +2172,20 @@ async function spamSelectedMessages(): Promise<void> {
                 // messages' current folder instead of guessing by uid alone.
                 if (result?.targetFolderId) spamUndo.targetFolderId = result.targetFolderId;
             })
-            .catch(e => {
+            .catch(async e => {
                 console.error(`[spam] ${accountId} failed:`, e);
-                if (statusSync) statusSync.textContent = `Spam sync issue (${accountId}): ${e?.message || e}`;
+                // The optimistic remove above already took these rows off the
+                // list. If the move genuinely failed, leaving them gone is a
+                // LIE — the message is still in the inbox and reappears at the
+                // next sync looking like it "came back" (Bob 2026-08-07, where
+                // the Android markAsSpamMessages stub threw on every click and
+                // only a status-bar line said so). Put the list back and say it
+                // loudly enough to be seen on a phone.
+                if (statusSync) statusSync.textContent = `Spam FAILED (${accountId}): ${e?.message || e}`;
+                try { await reloadCurrentFolder(); } catch { /* list rebuilds on next sync */ }
+                window.dispatchEvent(new CustomEvent("mailx-alert", {
+                    detail: { message: `Couldn't move ${uids.length} message(s) to spam: ${e?.message || e}`, key: "spam-move" },
+                }));
             });
     }
 }
@@ -2236,7 +2247,7 @@ document.getElementById("btn-mark-unread")?.addEventListener("click", () => {
     const wasSeen = seenOf(sel);
     setSeen(sel, !wasSeen);
     updateFlags(sel.accountId, sel.uid, sel.flags, (sel as any).folderId).then(() => {
-        messageState.updateMessageFlags(sel.accountId, sel.uid, sel.flags);
+        messageState.updateMessageFlags(sel.accountId, sel.uid, sel.flags, (sel as any).folderId);
         const row = document.querySelector(`.ml-row[data-uid="${sel.uid}"][data-account-id="${sel.accountId}"]`) as HTMLElement;
         if (row) row.classList.toggle("unread", wasSeen);
     }).catch(() => { setSeen(sel, wasSeen); });
@@ -5995,7 +6006,7 @@ document.addEventListener("mailx-popout-action", ((e: any) => {
         setFlagged(msg, !wasFlagged);
         updateFlags(accountId, msg.uid, msg.flags, msg.folderId).catch((err: any) =>
             console.error(`[popout] flag failed: ${err?.message || err}`));
-        setRowFlagged(accountId, msg.uid, !wasFlagged);
+        setRowFlagged(accountId, msg.uid, !wasFlagged, msg.folderId);
     }
 }) as EventListener);
 

package/client/components/message-list.js

@@ -382,8 +382,40 @@ export async function refreshPriorityIndex() {
     }
     catch { /* service may not be ready yet */ }
 }
-function rowKey(accountId, uid) {
-    return `${accountId}:${uid}`;
+/** Row lookup key. MUST include the folder: an IMAP UID is unique only WITHIN
+ *  a folder, so in a unified view ("All Inboxes", search results) two entirely
+ *  different messages routinely share one (account, uid) pair. Keyed on
+ *  (account, uid) alone, the second row's attach() OVERWROTE the first in
+ *  rowByKey — after which setRowFlagged / setRowSeen / focusByIdentity for
+ *  either message resolved to whichever row registered last, and the loser's
+ *  detach() deleted the winner's entry. That is why an accidental star
+ *  "refused to go away" and why a second message from the same sender came up
+ *  starred too (Bob 2026-08-07, All Inboxes). Same invariant the DB has had
+ *  since the uid-is-not-identity corruption. */
+function rowKey(accountId, uid, folderId) {
+    return `${accountId}:${folderId ?? ""}:${uid}`;
+}
+/** Resolve a row when the caller may not know the folder. With a folderId it
+ *  is an exact hit; without one it scans, and a UID that matches more than one
+ *  folder returns nothing rather than guessing — silently acting on the wrong
+ *  message is the failure mode this whole key change exists to stop. */
+function findRow(accountId, uid, folderId) {
+    if (folderId !== undefined && folderId !== null) {
+        const exact = rowByKey.get(rowKey(accountId, uid, folderId));
+        if (exact)
+            return exact;
+    }
+    const hits = [];
+    for (const row of rowByKey.values()) {
+        if (row.accountId === accountId && row.msg.uid === uid)
+            hits.push(row);
+    }
+    if (hits.length === 1)
+        return hits[0];
+    if (hits.length > 1) {
+        console.warn(`[message-list] ambiguous row lookup ${accountId}/uid=${uid} — ${hits.length} folders match; caller must pass folderId`);
+    }
+    return undefined;
 }
 function focusRow(row, opts = {}) {
     // Single-select invariant: this row is the ONLY highlight, and it is the
@@ -458,7 +490,7 @@ export function getCurrentFocused() {
  *  keyboard nav, post-delete handoff. Returns true if a row was found
  *  and focused. */
 function focusByIdentity(accountId, uid, opts = {}) {
-    const row = rowByKey.get(rowKey(accountId, uid));
+    const row = findRow(accountId, uid, opts.folderId);
     if (!row)
         return false;
     focusRow(row, opts);
@@ -468,8 +500,8 @@ function focusByIdentity(accountId, uid, opts = {}) {
  *  the toolbar Flag button so the visible star tracks the data instead of
  *  drifting until the next list rebuild. Calls into the row object's own
  *  setFlaggedClass — atomic class+text update, can't desync. */
-export function setRowFlagged(accountId, uid, yes) {
-    const row = rowByKey.get(rowKey(accountId, uid));
+export function setRowFlagged(accountId, uid, yes, folderId) {
+    const row = findRow(accountId, uid, folderId);
     if (row)
         row.setFlaggedClass(yes);
 }
@@ -480,8 +512,8 @@ export function setRowFlagged(accountId, uid, yes) {
  *  a right-click during the 2-s dwell window read the row as "read"
  *  and offered "Mark unread" on a message that wasn't actually marked
  *  yet. */
-export function setRowSeen(accountId, uid, yes) {
-    const row = rowByKey.get(rowKey(accountId, uid));
+export function setRowSeen(accountId, uid, yes, folderId) {
+    const row = findRow(accountId, uid, folderId);
     if (row)
         row.setUnreadClass(!yes);
 }
@@ -490,7 +522,7 @@ export function setRowSeen(accountId, uid, yes) {
 function selectedRows() {
     const out = [];
     for (const s of getSelectedMessages()) {
-        const row = rowByKey.get(rowKey(s.accountId, s.uid));
+        const row = findRow(s.accountId, s.uid, s.folderId);
         if (row)
             out.push(row);
     }
@@ -503,7 +535,7 @@ function visibleRowObjs() {
     if (!body)
         return [];
     return Array.from(body.querySelectorAll(".ml-row:not(.filter-hidden)"))
-        .map(el => rowByKey.get(rowKey(el.dataset.accountId || "", Number(el.dataset.uid))))
+        .map(el => rowByKey.get(rowKey(el.dataset.accountId || "", Number(el.dataset.uid), el.dataset.folderId)))
         .filter((r) => !!r);
 }
 /** The set a bulk action targets: the SELECTED rows if any are marked,
@@ -695,6 +727,15 @@ export function releaseFocus() {
     const body = document.getElementById("ml-body");
     body?.querySelectorAll(".ml-row.selected").forEach(r => r.classList.remove("selected"));
     viewerClear();
+    // On a narrow screen the viewer is the ONLY visible pane (the list carries
+    // narrow-hidden), so clearing it leaves a white screen reading "Select a
+    // message to read" with no list to select from — and in viewer-fullscreen
+    // not even a back button. That is a dead end: the user had to fold/unfold
+    // the phone to escape (Bob 2026-08-07, after sending spam from the viewer).
+    // No message ⟹ nothing to view ⟹ go back to the list.
+    document.body.classList.remove("viewer-fullscreen");
+    document.getElementById("message-viewer")?.classList.remove("narrow-active");
+    document.getElementById("message-list")?.classList.remove("narrow-hidden");
     document.dispatchEvent(new CustomEvent("mailx-focus-changed", { detail: null }));
 }
 /** Flip the "not-downloaded" indicator off for rows whose bodies just cached.
@@ -1071,7 +1112,7 @@ export function removeMessagesAndReconcile(uids) {
                 // scheme, but only detach via the row object if it actually
                 // owns THIS element (a cross-folder uid collision could point
                 // it at a different row). Otherwise remove the DOM node directly.
-                const dead = rowByKey.get(rowKey(el.dataset.accountId || "", Number(el.dataset.uid)));
+                const dead = rowByKey.get(rowKey(el.dataset.accountId || "", Number(el.dataset.uid), el.dataset.folderId));
                 if (dead && dead.el === el)
                     dead.detach();
                 else
@@ -1084,7 +1125,7 @@ export function removeMessagesAndReconcile(uids) {
     }
     if (outcome.focusedWasRemoved) {
         const survivor = outcome.nextSurvivor;
-        if (survivor && focusByIdentity(survivor.accountId, survivor.uid)) {
+        if (survivor && focusByIdentity(survivor.accountId, survivor.uid, { folderId: survivor.folderId })) {
             // focusByIdentity handled the transition (DOM class + viewer).
             return;
         }
@@ -1096,7 +1137,7 @@ export function removeMessagesAndReconcile(uids) {
         // order; the first row that has a live DOM/rowByKey entry wins.
         const remaining = state.getMessages();
         for (const m of remaining) {
-            if (focusByIdentity(m.accountId, m.uid))
+            if (focusByIdentity(m.accountId, m.uid, { folderId: m.folderId }))
                 return;
         }
         // Truly empty folder (state.length === 0). Now releasing focus is
@@ -2011,7 +2052,7 @@ class MessageRow {
     /** Insert this row into a list body and register it in the lookup map. */
     attach(body) {
         body.appendChild(this.el);
-        rowByKey.set(rowKey(this.accountId, this.msg.uid), this);
+        rowByKey.set(rowKey(this.accountId, this.msg.uid, this.msg.folderId), this);
     }
     /** Remove this row from the DOM and the lookup map. If it was the
      *  focused row, the controller is responsible for releasing focus
@@ -2019,7 +2060,7 @@ class MessageRow {
      *  may want to hand focus to a sibling instead). */
     detach() {
         this.el.remove();
-        rowByKey.delete(rowKey(this.accountId, this.msg.uid));
+        rowByKey.delete(rowKey(this.accountId, this.msg.uid, this.msg.folderId));
     }
     setSelected(yes) { this.el.classList.toggle("selected", yes); }
     get isSelected() { return this.el.classList.contains("selected"); }
@@ -2560,7 +2601,7 @@ onEvent((ev) => {
         return;
     if (!ev.accountId || ev.previousDraftUid == null)
         return;
-    const row = rowByKey.get(rowKey(ev.accountId, ev.previousDraftUid));
+    const row = findRow(ev.accountId, Number(ev.previousDraftUid), ev.folderId);
     if (row)
         row.setDate(typeof ev.savedAt === "number" ? ev.savedAt : Date.now());
 });