@bobfrankston/rmfmail 1.2.241 → 1.2.242

package/client/components/message-viewer.ts

@@ -236,6 +236,60 @@ export function showPreviewBodyMenu(absX: number, absY: number, selectedText: st
     showContextMenu(absX, absY, items);
 }
 
+/** How long the viewer waits for a body before it stops counting and
+ *  explains itself. Long enough that a slow Dovecot read or a cold Gmail
+ *  batch still lands inside it; short enough that nobody watches a counter
+ *  tick past a minute wondering whether the app is alive. */
+const WAIT_GIVE_UP_SECS = 45;
+
+/**
+ * Replace the elapsed-time counter with something that tells the user what
+ * happened and what they can still do.
+ *
+ * The counter existed to distinguish "slow" from "wedged" (v1.0.x, Bob
+ * 2026-05-24) and it does — but only for the first half-minute. Past that it
+ * is a progress bar for a process that is not running: nothing retries, no
+ * error was reported, and the number just grows. This says so.
+ */
+function renderBodyFetchGaveUp(
+    bodyEl: HTMLElement,
+    accountId: string,
+    uid: number,
+    folderId: number | undefined,
+    secs: number,
+    previewText: string,
+    specialUse?: string,
+    envelope?: any,
+): void {
+    // A Gmail account addresses bodies by a uid derived from the Gmail
+    // message id — a ~10^14 number. A small sequential uid on such an
+    // account means this row came from the IMAP side (server search, an
+    // older sync), and the Gmail API fetcher has no way to name it. That is
+    // not a slow network and retrying will not help, so say which it is
+    // instead of offering false hope.
+    const looksImapUidOnApiAccount = uid > 0 && uid < 1_000_000_000;
+    const why = looksImapUidOnApiAccount
+        ? `This message was indexed over IMAP, but its account fetches bodies through the Gmail API, which addresses messages by a different id. The body can't be requested for this row.`
+        : `The server accepted the request but never returned the body.`;
+    const snippet = previewText
+        ? `<div class="mv-preview-placeholder">${escapeHtml(previewText)}<div class="mv-tear-line"><span>✂ snippet — this is all that arrived ✂</span></div></div>`
+        : "";
+    bodyEl.innerHTML = `${snippet}<div class="mv-system-message mv-system-error">
+        <div class="mv-system-tag">rmfmail</div>
+        <div class="mv-system-title">Body didn't arrive after ${secs}s — not still loading</div>
+        <div class="mv-system-body">${escapeHtml(why)}
+        <div style="margin-top:8px;display:flex;gap:8px;flex-wrap:wrap">
+            <button id="mv-body-retry" class="tb-btn">Try again</button>
+        </div></div></div>`;
+    bodyEl.querySelector("#mv-body-retry")?.addEventListener("click", () => {
+        invalidateParsedCache(accountId, folderId, uid);
+        showMessage(accountId, uid, folderId, specialUse, true, envelope).catch(() => { /* reported by the next render */ });
+    });
+    // No "View source" button here — the viewer toolbar already has Source,
+    // and a second control that dispatches an event nothing listens for is
+    // the silent-no-op pattern this session spent the day removing.
+}
+
 /** Toggle preview-fullscreen mode. CSS rule on body.fullscreen-preview hides
  *  toolbar / rail / folder tree / list / statusbar and expands the viewer to
  *  the full viewport. Exits via second toggle, Esc, or the floating ✕. */
@@ -777,12 +831,30 @@ export async function showMessage(accountId: string, uid: number, folderId?: num
                 // After 30 s a still-counting timer is suspicious — surface
                 // a hint so the user knows the daemon should be looked at.
                 if (secs === 30) span.classList.add("mv-wait-slow");
+                // …and at 45 s, stop counting and SAY something. A counter
+                // that runs forever is not information: the fetch is not
+                // "still working", it has failed in a way nothing reports —
+                // e.g. a Gmail row indexed over IMAP (small sequential uid)
+                // whose body the Gmail API path cannot address at all,
+                // because it only knows uids derived from Gmail message ids
+                // (Bob 2026-08-09: "definitely need an appropriate message
+                // rather than an infinitely counting timer"). Whatever the
+                // cause, at this point the honest thing is to say the body
+                // did not arrive, keep the snippet visible, and offer the
+                // paths that DO work.
+                if (secs >= WAIT_GIVE_UP_SECS) {
+                    clearInterval(tick);
+                    off?.();
+                    renderBodyFetchGaveUp(bodyEl, accountId, uid, folderId, secs, previewText, specialUse, envelope || cached || undefined);
+                }
             }, 1000);
             // Subscribe via Store bus (the post-refactor surface). The
             // reconciler publishes `bodyAvailable` on `message:<uuid>` (or
             // `folder:<id>` when uuid isn't available); the wildcard catches
             // both. Match by account+uid because the viewer keys off those.
-            const off = subscribeStore("*", (ev: any) => {
+            // eslint-disable-next-line prefer-const — assigned below, referenced by the tick above
+            let off: (() => void) | undefined;
+            off = subscribeStore("*", (ev: any) => {
                 if (ev.kind !== "bodyAvailable") return;
                 if (ev.accountId !== accountId || ev.uid !== uid) return;
                 if (captureGen !== showMessageGeneration) { off(); clearInterval(tick); return; }

package/client/compose/compose.bundle.js

@@ -2645,6 +2645,20 @@ async function createTinyMceEditor(container2, opts = {}) {
         // 2026-07-28: pasted/inserted text needs a one-click quote.
         "blockquote bullist numlist outdent indent | link table image code rmfcode | emoticons charmap | help"
       ].join(" | "),
+      // Wrap the toolbar onto as many rows as it needs instead of hiding
+      // the overflow behind a "…" that opens a FLOATING popover over the
+      // message body (TinyMCE default is toolbar_mode:"floating").
+      //
+      // Two things were wrong with the popover: it covers the text you
+      // are writing, and it does not dismiss on its own (Bob 2026-08-08:
+      // "you temporarily extend the menu as a popover but that does not
+      // go away on its own. It makes more sense to just wrap the buttons
+      // onto a separate line. That works because the width is stable so
+      // there is not any fibrillation"). Wrapping grows the header, which
+      // is the honest use of the space — the compose window width does
+      // not change while you type, so the row count is stable and there
+      // is no reflow churn.
+      toolbar_mode: "wrap",
       // Include "tools" so wordcount and searchreplace are reachable.
       menubar: "file edit view insert format tools",
       // View menu — append zoom commands. fullscreen omitted: this editor