@bobfrankston/rmfmail 1.2.50 → 1.2.65

package/client/components/message-list.ts

@@ -58,6 +58,17 @@ function applyLiveFilter(body: HTMLElement): void {
 }
 
 let currentSearchQuery = "";
+
+/** Empty-list placeholder text. When a search is active, name the query so an
+ *  empty list reads as "nothing matched THIS search" rather than a bare,
+ *  alarming "No messages" (Bob 2026-06-25). Covers paths other than the
+ *  search loader itself — e.g. deleting the last surviving search hit. */
+function emptyListMessage(): string {
+    if (searchMode && currentSearchQuery) {
+        return `No messages found by "${escapeHtmlText(currentSearchQuery)}"`;
+    }
+    return "No messages";
+}
 // Remember the pre-search view mode so clearSearchMode() can restore it.
 // Without this, searching from "All Inboxes" loses the unified-mode flag
 // (loadSearchResults sets unifiedMode=false), and clearing the search
@@ -404,6 +415,156 @@ export function setRowSeen(accountId: string, uid: number, yes: boolean): void {
     if (row) row.setUnreadClass(!yes);
 }
 
+/** Resolve currently-selected rows to MessageRow objects (skips any not in
+ *  the loaded DOM). */
+function selectedRows(): MessageRow[] {
+    const out: MessageRow[] = [];
+    for (const s of getSelectedMessages()) {
+        const row = rowByKey.get(rowKey(s.accountId, s.uid));
+        if (row) out.push(row);
+    }
+    return out;
+}
+
+/** Every row currently shown (visible = matches search + view filters, and
+ *  loaded — the list lazy-loads). */
+function visibleRowObjs(): MessageRow[] {
+    const body = document.getElementById("ml-body");
+    if (!body) return [];
+    return Array.from(body.querySelectorAll<HTMLElement>(".ml-row:not(.filter-hidden)"))
+        .map(el => rowByKey.get(rowKey(el.dataset.accountId || "", Number(el.dataset.uid))))
+        .filter((r): r is MessageRow => !!r);
+}
+
+/** The set a bulk action targets: the SELECTED rows if any are marked,
+ *  otherwise ALL shown rows. This is the "act on selected, else all filtered"
+ *  rule Bob asked for (2026-06-24). */
+function bulkTargets(): MessageRow[] {
+    const sel = selectedRows();
+    return sel.length > 0 ? sel : visibleRowObjs();
+}
+
+/** Flag / unflag a set of rows. Captures the prior flagged state per row and
+ *  emits `mailx-flagged-batch` so app.ts can register ONE Ctrl+Z undo entry
+ *  for the whole batch (Bob 2026-06-24: bulk ops need undo for safety). */
+async function bulkSetFlagged(rows: MessageRow[], flagged: boolean): Promise<void> {
+    const undo: { accountId: string; uid: number; prevFlagged: boolean }[] = [];
+    await Promise.all(rows.map(async (row) => {
+        // Read current state from the VISIBLE class via row.isFlagged — NOT
+        // flaggedOf(row.msg). The two can drift, and a stale `msg.flags` made
+        // Unflag skip flagged rows as "already unflagged" (Bob 2026-06-24
+        // "unflag is not removing the flag"). The class is the source of truth
+        // the single-star toggle already trusts.
+        const prev = row.isFlagged;
+        if (prev === flagged) return;   // already in the target state
+        const prevFlags = [...(row.msg.flags || [])];
+        row.isFlagged = flagged;        // setter: updates class + msg.flags
+        try {
+            await updateFlags(row.accountId, row.msg.uid, row.msg.flags);
+            state.updateMessageFlags(row.accountId, row.msg.uid, row.msg.flags);
+            undo.push({ accountId: row.accountId, uid: row.msg.uid, prevFlagged: prev });
+        } catch {
+            row.msg.flags = prevFlags;  // revert on server failure
+            row.setFlaggedClass(prev);
+        }
+    }));
+    if (undo.length) document.dispatchEvent(new CustomEvent("mailx-flagged-batch", { detail: undo }));
+}
+
+/** Mark a set of rows read / unread. Low-risk + trivially reversible, so no
+ *  undo entry (unlike flag, move, delete). State read from the class too. */
+async function bulkSetSeen(rows: MessageRow[], seen: boolean): Promise<void> {
+    await Promise.all(rows.map(async (row) => {
+        const prev = row.isSeen;
+        if (prev === seen) return;
+        const prevFlags = [...(row.msg.flags || [])];
+        row.isSeen = seen;              // setter: updates class + msg.flags
+        try {
+            await updateFlags(row.accountId, row.msg.uid, row.msg.flags);
+            state.updateMessageFlags(row.accountId, row.msg.uid, row.msg.flags);
+        } catch {
+            row.msg.flags = prevFlags;
+            row.setUnreadClass(!prev);
+        }
+    }));
+}
+
+/** Move every selected message (of the first selected row's account) to a
+ *  picked folder. Local-first: optimistic remove + fire-and-forget IPC, same
+ *  as the row context menu's "Move to folder…". */
+async function bulkMoveSelection(): Promise<void> {
+    const targets = bulkTargets();
+    if (targets.length === 0) return;
+    const accountId = targets[0].accountId;
+    const same = targets.filter(r => r.accountId === accountId);
+    const pick = await pickFolder(accountId, { excludeFolderIds: [same[0].msg.folderId] });
+    if (!pick) return;
+    const uids = same.map(r => r.msg.uid);
+    removeMessagesAndReconcile(uids.map(u => ({ accountId, uid: u })));
+    const statusSync = document.getElementById("status-sync");
+    if (statusSync) statusSync.textContent = `Moving ${uids.length} message${uids.length !== 1 ? "s" : ""} to ${pick.folderName}…`;
+    apiMoveMessages(accountId, uids, pick.folderId)
+        .then(() => { if (statusSync) statusSync.textContent = `Moved ${uids.length} to ${pick.folderName}`; })
+        .catch((err: any) => { if (statusSync) statusSync.textContent = `Move sync issue: ${err?.message || err}`; });
+    exitMultiSelect();
+}
+
+/** Toolbar "Filtered" menu — home for bulk operations. Two concepts, kept
+ *  separate (Bob 2026-06-24): SHOWN = rows the current folder/search/filters
+ *  make visible (lazy-loaded, so it's what's loaded now); SELECTED = rows
+ *  you've clicked. Actions auto-target: if anything is SELECTED they act on
+ *  that, otherwise on ALL SHOWN — the header says which is in effect. Delete
+ *  and Mark-as-spam are omitted: the toolbar's own buttons already do those on
+ *  the selection. Flag/unflag and move are Ctrl+Z-undoable. */
+export async function showSelectionMenu(x: number, y: number): Promise<void> {
+    const { showContextMenu } = await import("./context-menu.js");
+    const body = document.getElementById("ml-body");
+    const visibleRows = body
+        ? Array.from(body.querySelectorAll<HTMLElement>(".ml-row:not(.filter-hidden)"))
+        : [];
+    const enterMulti = () => body?.classList.add("multi-select-on");
+    const shownCount = visibleRows.length;
+    const selCount = getSelectedMessages().length;
+    const hasShown = shownCount > 0;
+    // Auto-target: selected if any, else all shown. The action labels carry
+    // the effective target count so there's no ambiguity about what runs.
+    const targetN = selCount > 0 ? selCount : shownCount;
+    const onWhat = selCount > 0 ? `selected (${selCount})` : `all shown (${shownCount})`;
+    const canAct = targetN > 0;
+
+    const items: MenuItem[] = [
+        { label: `Acting on ${onWhat}`, action: () => {}, disabled: true },
+        { label: "", action: () => {}, separator: true },
+        {
+            label: `Select all shown (${shownCount})`,
+            action: () => { if (!body) return; enterMulti(); for (const r of visibleRows) r.classList.add("selected"); lastClickedRow = visibleRows[visibleRows.length - 1] || null; updateBulkBar(); },
+            disabled: !hasShown,
+        },
+        {
+            label: "Select flagged ★ among shown",
+            action: () => { if (!body) return; enterMulti(); for (const r of visibleRows) r.classList.toggle("selected", r.classList.contains("flagged")); lastClickedRow = null; updateBulkBar(); },
+            disabled: !hasShown,
+        },
+        {
+            label: "Invert selection among shown",
+            action: () => { if (!body) return; enterMulti(); for (const r of visibleRows) r.classList.toggle("selected"); updateBulkBar(); },
+            disabled: !hasShown,
+        },
+        { label: `Deselect all (${selCount})`, action: () => exitMultiSelect(), disabled: selCount === 0 },
+        { label: "", action: () => {}, separator: true },
+        // Actions — auto-targeted (selected else all shown). No count on the
+        // verb itself (a number on "Flag" reads as ambiguous, Bob 2026-06-24);
+        // the "Acting on …" header above carries the target count.
+        { label: "Flag", action: () => bulkSetFlagged(bulkTargets(), true), disabled: !canAct },
+        { label: "Unflag", action: () => bulkSetFlagged(bulkTargets(), false), disabled: !canAct },
+        { label: "Mark read", action: () => bulkSetSeen(bulkTargets(), true), disabled: !canAct },
+        { label: "Mark unread", action: () => bulkSetSeen(bulkTargets(), false), disabled: !canAct },
+        { label: "", action: () => {}, separator: true },
+        { label: "Move to folder…", action: () => bulkMoveSelection(), disabled: !canAct },
+    ];
+    showContextMenu(x, y, items);
+}
+
 /** Scroll the focused row into view. Wired to a keyboard shortcut so the
  *  user can recover after scrolling the list away from the preview.
  *
@@ -832,7 +993,7 @@ export function removeMessagesAndReconcile(
             }
         }
         if (state.getMessages().length === 0) {
-            body.innerHTML = `<div class="ml-empty">No messages</div>`;
+            body.innerHTML = `<div class="ml-empty">${emptyListMessage()}</div>`;
         }
     }
 
@@ -926,10 +1087,14 @@ export async function loadUnifiedInbox(autoSelect = true): Promise<void> {
     if (cached) {
         totalMessages = cached.total;
         state.setMessages(cached.items);
-        renderMessages(body, "", cached.items, { background: !autoSelect });
+        // See loadMessages: anchor the cache render on background reloads so a
+        // scrolled reader isn't yanked to the top when new mail arrives.
+        const renderCached = () => renderMessages(body, "", cached.items, { background: !autoSelect });
+        if (!autoSelect) withScrollAnchor(body, renderCached);
+        else renderCached();
         const targetUuid = remembered ? pickRestoreUid(cached.items, remembered) : null;
         if (targetUuid) {
-            body.scrollTop = savedScroll;
+            if (autoSelect) body.scrollTop = savedScroll;
             restoreSelection(body, targetUuid);
         } else if (autoSelect) {
             selectFirst(body);
@@ -1043,7 +1208,7 @@ export async function loadSearchResults(query: string, scope = "all", accountId
             );
             totalMessages = matches.length;
             state.setMessages(matches);
-            if (matches.length === 0) { body.innerHTML = `<div class="ml-empty">No regex matches</div>`; return; }
+            if (matches.length === 0) { body.innerHTML = `<div class="ml-empty">No messages found by "${escapeHtmlText(query)}"</div>`; return; }
             body.innerHTML = "";
             appendMessages(body, "", matches);
             selectFirst(body);
@@ -1069,7 +1234,7 @@ export async function loadSearchResults(query: string, scope = "all", accountId
         if (result.items.length === 0) {
             state.setMessages([]);
             body.innerHTML = partialNote +
-                `<div class="ml-empty">No results for "${query}"${partial ? " in the folders that responded" : ""}</div>`;
+                `<div class="ml-empty">No messages found by "${escapeHtmlText(query)}"${partial ? " in the folders that responded" : ""}</div>`;
             return;
         }
 
@@ -1084,7 +1249,16 @@ export async function loadSearchResults(query: string, scope = "all", accountId
     }
 }
 
-export async function loadMessages(accountId: string, folderId: number, page = 1, specialUse = "", autoSelect = true): Promise<void> {
+/** Search-as-find: leave search and reveal a specific message in its own
+ *  folder. Loads the folder list, selects the message, and scrolls it into
+ *  view. Used when the user closes search while a result is selected — they
+ *  "stay at" that message in its real folder instead of bouncing back to the
+ *  pre-search view (Bob 2026-06-25). */
+export function revealMessage(accountId: string, folderId: number, uid: number, specialUse = ""): void {
+    loadMessages(accountId, folderId, 1, specialUse, true, uid);
+}
+
+export async function loadMessages(accountId: string, folderId: number, page = 1, specialUse = "", autoSelect = true, focusUid?: number): Promise<void> {
     const myGen = ++loadGen;
     searchMode = false;
     unifiedMode = false;
@@ -1127,11 +1301,26 @@ export async function loadMessages(accountId: string, folderId: number, page = 1
     if (cached) {
         totalMessages = cached.total;
         state.setMessages(cached.items);
-        renderMessages(body, accountId, cached.items, { background: !autoSelect });
+        // Background reload (new mail / sync): a bare renderMessages rebuilds
+        // innerHTML and resets scrollTop to 0, which then makes the follow-up
+        // network anchor think the user is at the top and reveal new mail there
+        // — yanking a scrolled-down reader to the top (Bob 2026-06-24 "the list
+        // jumps when a new message is added ... must not move while I'm
+        // viewing it"). Anchor the cache render too so the visible rows stay put.
+        const renderCached = () => renderMessages(body, accountId, cached.items, { background: !autoSelect });
+        if (!autoSelect) withScrollAnchor(body, renderCached);
+        else renderCached();
         const targetUuid = remembered ? pickRestoreUid(cached.items, remembered) : null;
-        if (targetUuid) {
+        if (focusUid != null) {
+            // Search-as-find: jump to the specific message the user selected.
+            requestAnimationFrame(() => {
+                if (!focusByIdentity(accountId, focusUid, { scroll: true }) && autoSelect) selectFirst(body);
+            });
+        } else if (targetUuid) {
             requestAnimationFrame(() => {
-                body.scrollTop = savedScroll;
+                // Folder switch restores saved pixels; a background reload was
+                // already placed by the anchor — don't override it.
+                if (autoSelect) body.scrollTop = savedScroll;
                 restoreSelection(body, targetUuid);
             });
         } else if (autoSelect) {
@@ -1184,7 +1373,13 @@ export async function loadMessages(accountId: string, folderId: number, page = 1
 
         // Prefer saved position; otherwise default by autoSelect.
         const targetUuid = remembered ? pickRestoreUid(result.items, remembered) : null;
-        if (targetUuid) {
+        if (focusUid != null) {
+            // Search-as-find: select the message the user picked from results.
+            requestAnimationFrame(() => {
+                if (myGen !== loadGen) return;
+                if (!focusByIdentity(accountId, focusUid, { scroll: true }) && autoSelect) selectFirst(body);
+            });
+        } else if (targetUuid) {
             requestAnimationFrame(() => {
                 if (myGen !== loadGen) return;
                 // On a first paint (no cache), use the saved scrollTop.
@@ -1211,6 +1406,15 @@ async function loadMoreMessages(): Promise<void> {
     loading = true;
     currentPage++;
 
+    // Diagnostics for the "scroll near the bottom does nothing" report
+    // (Bob 2026-06-22: position-dependent, "go up a tad and it works"). The
+    // suspect is a loadMore that doesn't grow scrollHeight — duplicate/empty
+    // page, end-of-list overshoot — leaving the user pinned. Capture
+    // before/after geometry + how many rows the page actually added so the
+    // log shows whether the list grew, stalled, or the page came back empty.
+    const t0 = Date.now();
+    const heightBefore = body.scrollHeight;
+    const rowsBefore = body.querySelectorAll(".ml-row").length;
     try {
         const flaggedOnly = body.classList.contains("flagged-only");
         const result = searchMode
@@ -1222,6 +1426,11 @@ async function loadMoreMessages(): Promise<void> {
         const current = state.getMessages();
         state.setMessages([...current, ...result.items]);
         appendMessages(body, unifiedMode ? "" : currentAccountId, result.items);
+        const rowsAfter = body.querySelectorAll(".ml-row").length;
+        const heightAfter = body.scrollHeight;
+        const elapsed = Date.now() - t0;
+        const grew = heightAfter > heightBefore;
+        console.log(`  [ml-loadmore] page=${currentPage} got=${result.items?.length ?? 0} rows ${rowsBefore}->${rowsAfter} height ${heightBefore}->${heightAfter} grew=${grew} total=${totalMessages} ${elapsed}ms${grew ? "" : "  ⚠ NO GROWTH — scroll will appear stuck"}`);
     } catch (e: any) {
         console.error(`Load more error: ${e.message}`);
     } finally {
@@ -1231,11 +1440,29 @@ async function loadMoreMessages(): Promise<void> {
 
 /** Replace body contents with rendered rows */
 function renderMessages(body: HTMLElement, accountId: string, items: any[], opts: { background?: boolean } = {}): void {
+    // MULTI-SELECT SURVIVAL: replaceChildren below builds fresh rows with no
+    // `.selected`, so a sync/new-mail rebuild would collapse an active
+    // multi-selection down to the single focused row restoreSelection re-binds
+    // (Bob 2026-06-22: "selected multiple NMLS spam, suddenly seeing only one —
+    // a new message arrived and confused you"). The `multi-select-on` class
+    // lives on the body and survives the rebuild, so when it's set we snapshot
+    // the selected rows' stable uuids and re-apply `.selected` to whichever
+    // survive the new render. Keyed on uuid, so a folder switch (different
+    // uuids) matches nothing and correctly drops the stale highlight.
+    const preserveSel = body.classList.contains("multi-select-on")
+        ? new Set(Array.from(body.querySelectorAll<HTMLElement>(".ml-row.selected"))
+            .map(r => r.dataset.uuid || "").filter(Boolean))
+        : null;
     const fragment = document.createDocumentFragment();
     const tempDiv = document.createElement("div");
     appendMessages(tempDiv, accountId, items);
     while (tempDiv.firstChild) fragment.appendChild(tempDiv.firstChild);
     body.replaceChildren(fragment);
+    if (preserveSel && preserveSel.size > 0) {
+        for (const uuid of preserveSel) {
+            body.querySelector(`.ml-row[data-uuid="${CSS.escape(uuid)}"]`)?.classList.add("selected");
+        }
+    }
     // A filter (flagged-only / priority-only) that hides EVERY row makes the
     // list look broken — identical to an empty/failed load. Bob 2026-05-27
     // lost an afternoon to this: the flagged-only filter was stuck on (it
@@ -1671,6 +1898,19 @@ class MessageRow {
 
     private onFlagClick(e: MouseEvent): void {
         e.stopPropagation();
+        // Multi-select: clicking the ★ on one of several highlighted rows acts
+        // on the WHOLE selection, not just this row — same as the context-menu
+        // Flag/Unflag (Bob 2026-06-26: "clear the * only clears one not the
+        // selection"). Target state is the toggle of the clicked row, so a
+        // flagged row clears the lot and an unflagged row flags the lot.
+        const body = this.el.parentElement as HTMLElement | null;
+        if (body?.classList.contains("multi-select-on") && this.el.classList.contains("selected")) {
+            const sel = selectedRows();
+            if (sel.length > 1) {
+                void bulkSetFlagged(sel, !this.el.classList.contains("flagged"));
+                return;
+            }
+        }
         // Local-first: flip the visual class + in-memory flag array NOW so the
         // star toggles under the cursor with zero latency, then mirror to the
         // server in the background. The earlier `await updateFlags(...)`
@@ -1845,36 +2085,24 @@ class MessageRow {
         const msg = this.msg;
         const self = this;
 
+        // Count of selected rows — when >1, the read/flag actions apply to the
+        // whole selection and the label says so (e.g. "Unflag (5)"). The row
+        // menu's fallback (nothing selected) is the clicked row, NOT all shown.
+        const selCount = getSelectedMessages().length;
+        const countSfx = selCount > 1 ? ` (${selCount})` : "";
+        const rowTargets = (): MessageRow[] => { const s = selectedRows(); return s.length > 0 ? s : [self]; };
+
         const items: MenuItem[] = [
             {
-                label: isSeen ? "Mark unread" : "Mark read",
-                action: async () => {
-                    // Target state = inverse of what the menu showed,
-                    // matching what the user clicked. Visual-state-based
-                    // labels stay coherent with the auto-mark-as-read
-                    // debounce; the new flag array is computed via the
-                    // typed setter and sent to the server.
-                    const probe = { flags: [...(msg.flags || [])] };
-                    setSeen(probe, !isSeen);
-                    try {
-                        await updateFlags(accountId, msg.uid, probe.flags);
-                        msg.flags = probe.flags;
-                        state.updateMessageFlags(accountId, msg.uid, probe.flags);
-                        self.setUnreadClass(isSeen);
-                    } catch { /* ignore */ }
-                },
+                // Target state = inverse of what the menu showed, matching what
+                // the user clicked. Visual-state-based labels stay coherent with
+                // the auto-mark-as-read debounce. Applies to the whole selection.
+                label: (isSeen ? "Mark unread" : "Mark read") + countSfx,
+                action: () => bulkSetSeen(rowTargets(), !isSeen),
             },
             {
-                label: isFlagged ? "Unflag" : "Flag",
-                action: async () => {
-                    const probe = { flags: [...(msg.flags || [])] };
-                    setFlagged(probe, !isFlagged);
-                    try {
-                        await updateFlags(accountId, msg.uid, probe.flags);
-                        msg.flags = probe.flags;
-                        self.setFlaggedClass(!isFlagged);
-                    } catch { /* ignore */ }
-                },
+                label: (isFlagged ? "Unflag" : "Flag") + countSfx,
+                action: () => bulkSetFlagged(rowTargets(), !isFlagged),
             },
             { label: "", action: () => {}, separator: true },
             // Drafts get an explicit "Edit draft" entry as the primary action —

package/client/compose/compose.bundle.js

@@ -1367,8 +1367,8 @@ function markFolderRead(accountId, folderId) {
 function createFolder(accountId, parentPath, name) {
   return ipc().createFolder?.(accountId, parentPath, name);
 }
-function renameFolder(accountId, folderId, newName) {
-  return ipc().renameFolder?.(accountId, folderId, newName);
+function renameFolder(accountId, folderId, newName, newParentId) {
+  return ipc().renameFolder?.(accountId, folderId, newName, newParentId);
 }
 function deleteFolder(accountId, folderId) {
   return ipc().deleteFolder?.(accountId, folderId);
@@ -2301,20 +2301,35 @@ async function createTinyMceEditor(container2, opts = {}) {
             }
           }
         });
+        const QUOTE_SELECTOR = "blockquote, div.reply, .gmail_quote, .moz-cite-prefix, pre.moz-quote-pre, [type=cite]";
+        const markQuotedNoSpellcheck = (body) => {
+          if (!body?.querySelectorAll)
+            return;
+          body.querySelectorAll(QUOTE_SELECTOR).forEach((el) => {
+            el.setAttribute("spellcheck", "false");
+          });
+        };
+        ed.on("SetContent", () => {
+          try {
+            markQuotedNoSpellcheck(ed.getBody());
+          } catch {
+          }
+        });
         ed.on("init", () => {
           try {
             const body = ed.getBody();
             if (body) {
               body.setAttribute("spellcheck", "true");
               body.setAttribute("lang", "en");
+              markQuotedNoSpellcheck(body);
             }
             const doc = ed.getDoc();
             if (doc?.documentElement)
               doc.documentElement.setAttribute("lang", "en");
           } catch {
           }
-          if (zoomPx !== ZOOM_DEFAULT)
-            applyZoom();
+          const reflowRaf = (ed.getWin && ed.getWin() || window).requestAnimationFrame || ((f) => setTimeout(f, 16));
+          reflowRaf(() => applyZoom());
           try {
             const doc = ed.getDoc();
             doc.addEventListener("wheel", (e) => {
@@ -3345,12 +3360,22 @@ function createQuillEditor(container2) {
   };
 }
 async function createTiptapEditor(container2) {
-  const { Editor } = window.tiptapCore;
-  const { StarterKit } = window.tiptapStarterKit;
-  const { Link } = window.tiptapExtensionLink;
-  const { Image } = window.tiptapExtensionImage;
-  const { Underline } = window.tiptapExtensionUnderline;
-  const { Placeholder } = window.tiptapExtensionPlaceholder;
+  const w = window;
+  const core = w["@tiptap/core"];
+  const starter = w["@tiptap/starter-kit"];
+  const link = w["@tiptap/extension-link"];
+  const image = w["@tiptap/extension-image"];
+  const underline = w["@tiptap/extension-underline"];
+  const placeholder = w["@tiptap/extension-placeholder"];
+  const Editor = core?.Editor;
+  const StarterKit = starter?.StarterKit ?? starter?.default;
+  const Link = link?.Link ?? link?.default;
+  const Image = image?.Image ?? image?.default;
+  const Underline = underline?.Underline ?? underline?.default;
+  const Placeholder = placeholder?.Placeholder ?? placeholder?.default;
+  if (!Editor || !StarterKit) {
+    throw new Error("tiptap UMD globals not found (expected window['@tiptap/core'].Editor)");
+  }
   const toolbar = document.createElement("div");
   toolbar.className = "tt-toolbar";
   toolbar.innerHTML = `
@@ -3695,8 +3720,11 @@ function setActiveEditorBadge(type) {
     tinymce: "https://www.tiny.cloud/docs/tinymce/6/",
     fallback: "https://github.com/BobFrankston/mailx/blob/master/app/docs/editor.md"
   };
-  el.textContent = labels[type] || type;
+  const requested = editorType;
+  const fellBack = type !== "fallback" && type !== requested;
+  el.textContent = fellBack ? `${labels[type] || type} (${labels[requested] || requested} unavailable)` : labels[type] || type;
   el.dataset.editor = type;
+  el.dataset.fellBack = fellBack ? "true" : "false";
   const url = docs[type];
   if (url) {
     el.style.cursor = "pointer";
@@ -3824,6 +3852,18 @@ setActiveEditorBadge(activeEditorType);
 })();
 var fromInput = document.getElementById("compose-from-input");
 var fromOptions = document.getElementById("compose-from-options");
+if (fromInput) {
+  fromInput.addEventListener("focus", () => {
+    fromInput.dataset.prevFrom = fromInput.value;
+    fromInput.value = "";
+  });
+  fromInput.addEventListener("blur", () => {
+    if (fromInput.value.trim() === "" && fromInput.dataset.prevFrom) {
+      fromInput.value = fromInput.dataset.prevFrom;
+    }
+    delete fromInput.dataset.prevFrom;
+  });
+}
 var toInput = document.getElementById("compose-to");
 var ccInput = document.getElementById("compose-cc");
 var bccInput = document.getElementById("compose-bcc");
@@ -4248,18 +4288,24 @@ setupAutocomplete(toInput);
 setupAutocomplete(ccInput);
 setupAutocomplete(bccInput);
 function splitRecipients(s) {
-  const out = [];
+  const raw = [];
   let cur = "", inQuote = false;
   for (const c of s) {
     if (c === '"') {
       inQuote = !inQuote;
       cur += c;
     } else if (c === "," && !inQuote) {
-      out.push(cur);
+      raw.push(cur);
       cur = "";
     } else cur += c;
   }
-  out.push(cur);
+  raw.push(cur);
+  const out = [];
+  for (let i = 0; i < raw.length; i++) {
+    let seg = raw[i];
+    while (i < raw.length - 1 && !/[@<]/.test(seg)) seg += "," + raw[++i];
+    out.push(seg);
+  }
   return out;
 }
 function tokenSpanAtCaret(s, caret) {
@@ -4423,6 +4469,16 @@ function applyInit(init) {
   }
   replyInReplyTo = init.inReplyTo || "";
   replyReferences = init.references || [];
+  if (Array.isArray(init.attachments) && init.attachments.length && attachments.length === 0) {
+    for (const a of init.attachments) {
+      if (a && a.dataBase64) {
+        const b64 = a.dataBase64;
+        const size = Math.max(0, Math.floor(b64.length * 3 / 4) - (b64.endsWith("==") ? 2 : b64.endsWith("=") ? 1 : 0));
+        attachments.push({ filename: a.filename, mimeType: a.mimeType, size, dataBase64: b64 });
+      }
+    }
+    renderAttachmentChips();
+  }
   setComposeTitle(init.subject || "");
   if (!toInput.value) toInput.focus();
   else if (!subjectInput.value) subjectInput.focus();