@bobfrankston/rmfmail 1.0.664 → 1.0.666

package/client/compose/compose.bundle.js

@@ -0,0 +1,2872 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// client/lib/api-client.js
+var api_client_exports = {};
+__export(api_client_exports, {
+  abortMessageListRequests: () => abortMessageListRequests,
+  addContact: () => addContact,
+  addPreferredContact: () => addPreferredContact,
+  addToDenylist: () => addToDenylist,
+  aiTransform: () => aiTransform,
+  allowRemoteContent: () => allowRemoteContent,
+  autocomplete: () => autocomplete,
+  cancelQueuedOutgoing: () => cancelQueuedOutgoing,
+  closeWordEdit: () => closeWordEdit,
+  connectEvents: () => connectEvents,
+  connectWebSocket: () => connectWebSocket,
+  consumePendingMailto: () => consumePendingMailto,
+  createCalendarEvent: () => createCalendarEvent,
+  createFolder: () => createFolder,
+  createTask: () => createTask,
+  deleteCalendarEvent: () => deleteCalendarEvent,
+  deleteContact: () => deleteContact,
+  deleteDraft: () => deleteDraft,
+  deleteFolder: () => deleteFolder,
+  deleteMessage: () => deleteMessage,
+  deleteMessages: () => deleteMessages,
+  deleteTask: () => deleteTask,
+  drainStoreSync: () => drainStoreSync,
+  emptyFolder: () => emptyFolder,
+  flagSenderOrDomain: () => flagSenderOrDomain,
+  formatJsonc: () => formatJsonc,
+  getAccounts: () => getAccounts,
+  getAttachment: () => getAttachment,
+  getAutocompleteSettings: () => getAutocompleteSettings,
+  getCalendarEvents: () => getCalendarEvents,
+  getDeviceAccounts: () => getDeviceAccounts,
+  getDiagnostics: () => getDiagnostics,
+  getFolders: () => getFolders,
+  getMessage: () => getMessage,
+  getMessages: () => getMessages,
+  getOutboxStatus: () => getOutboxStatus,
+  getPrimaryAccount: () => getPrimaryAccount,
+  getPriorityLists: () => getPriorityLists,
+  getSettings: () => getSettings,
+  getSyncPending: () => getSyncPending,
+  getTasks: () => getTasks,
+  getThreadMessages: () => getThreadMessages,
+  getUnifiedInbox: () => getUnifiedInbox,
+  getVersion: () => getVersion,
+  hasBccHistoryTo: () => hasBccHistoryTo,
+  hasCcHistoryTo: () => hasCcHistoryTo,
+  listContacts: () => listContacts,
+  listQueuedOutgoing: () => listQueuedOutgoing,
+  logClientEvent: () => logClientEvent,
+  markAsSpamMessages: () => markAsSpamMessages,
+  markFolderRead: () => markFolderRead,
+  moveMessage: () => moveMessage,
+  moveMessages: () => moveMessages,
+  onEvent: () => onEvent,
+  onWsEvent: () => onWsEvent,
+  openInWord: () => openInWord,
+  openLocalPath: () => openLocalPath,
+  readConfigHelp: () => readConfigHelp,
+  readJsoncFile: () => readJsoncFile,
+  reauthGoogleScopes: () => reauthGoogleScopes,
+  reauthenticate: () => reauthenticate,
+  recordSpamReport: () => recordSpamReport,
+  renameFolder: () => renameFolder,
+  repairAccounts: () => repairAccounts,
+  restartServer: () => restartServer,
+  saveAutocompleteSettings: () => saveAutocompleteSettings,
+  saveDraft: () => saveDraft,
+  saveSettings: () => saveSettings,
+  searchContacts: () => searchContacts,
+  searchMessages: () => searchMessages,
+  sendMessage: () => sendMessage,
+  setPriorityDomain: () => setPriorityDomain,
+  setPrioritySender: () => setPrioritySender,
+  setupAccount: () => setupAccount,
+  showReminderPopup: () => showReminderPopup,
+  syncAccount: () => syncAccount,
+  triggerSync: () => triggerSync,
+  undeleteMessage: () => undeleteMessage,
+  unsubscribeOneClick: () => unsubscribeOneClick,
+  updateCalendarEvent: () => updateCalendarEvent,
+  updateFlags: () => updateFlags,
+  updateTask: () => updateTask,
+  upsertContact: () => upsertContact,
+  writeJsoncFile: () => writeJsoncFile
+});
+function getIpc() {
+  if (typeof mailxapi !== "undefined" && mailxapi?.isApp)
+    return mailxapi;
+  if (window.opener?.mailxapi?.isApp)
+    return window.opener.mailxapi;
+  if (window.parent?.mailxapi?.isApp)
+    return window.parent.mailxapi;
+  return null;
+}
+function buildRelayBridge() {
+  const pending = /* @__PURE__ */ new Map();
+  window.addEventListener("message", (ev) => {
+    if (!ev.data || ev.data.type !== "mailx-ipc-result" || !ev.data.id)
+      return;
+    const entry = pending.get(ev.data.id);
+    if (!entry)
+      return;
+    pending.delete(ev.data.id);
+    clearTimeout(entry.timer);
+    if (ev.data.ok)
+      entry.resolve(ev.data.result);
+    else
+      entry.reject(new Error(ev.data.error || "parent-relay ipc error"));
+  });
+  const call = (method, args) => {
+    const id = `ipc-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        pending.delete(id);
+        reject(new Error(`parent-relay timeout: ${method}`));
+      }, 12e4);
+      pending.set(id, { resolve, reject, timer });
+      try {
+        window.parent.postMessage({ type: "mailx-ipc", id, method, args }, "*");
+      } catch (e) {
+        clearTimeout(timer);
+        pending.delete(id);
+        reject(e);
+      }
+    });
+  };
+  return new Proxy({}, {
+    get(_t, prop) {
+      if (prop === "isApp")
+        return true;
+      if (prop === "platform")
+        return window.parent?.mailxapi?.platform || "webview2";
+      if (prop === "onEvent") {
+        return (handler) => window.parent?.mailxapi?.onEvent?.(handler);
+      }
+      return (...args) => call(prop, args);
+    }
+  });
+}
+function ipc() {
+  const inIframe = window.parent && window.parent !== window;
+  if (inIframe && window.parent?.mailxapi?.isApp) {
+    if (!cachedRelayBridge)
+      cachedRelayBridge = buildRelayBridge();
+    return cachedRelayBridge;
+  }
+  const bridge = getIpc();
+  if (!bridge)
+    throw new Error("IPC bridge not available");
+  return bridge;
+}
+function abortMessageListRequests() {
+  if (messageListAbort) {
+    messageListAbort.abort();
+    messageListAbort = null;
+  }
+}
+function getAccounts() {
+  return ipc().getAccounts();
+}
+function getFolders(accountId) {
+  return ipc().getFolders(accountId);
+}
+function getMessages(accountId, folderId, page = 1, pageSize = 50, flaggedOnly = false, sort, sortDir) {
+  abortMessageListRequests();
+  return ipc().getMessages(accountId, folderId, page, pageSize, sort, sortDir, void 0, flaggedOnly);
+}
+function getUnifiedInbox(page = 1, pageSize = 50) {
+  abortMessageListRequests();
+  return ipc().getUnifiedInbox(page, pageSize);
+}
+function searchMessages(query, page = 1, pageSize = 50, scope = "all", accountId = "", folderId = 0, includeTrashSpam = false) {
+  return ipc().searchMessages(query, page, pageSize, scope, accountId, folderId, includeTrashSpam);
+}
+function getMessage(accountId, uid, allowRemote = false, folderId) {
+  return ipc().getMessage(accountId, uid, allowRemote, folderId);
+}
+function updateFlags(accountId, uid, flags) {
+  return ipc().updateFlags(accountId, uid, flags);
+}
+function triggerSync() {
+  return ipc().syncAll();
+}
+function syncAccount(accountId) {
+  return ipc().syncAccount(accountId);
+}
+function reauthenticate(accountId) {
+  return ipc().reauthenticate(accountId);
+}
+function reauthGoogleScopes() {
+  return ipc().reauthGoogleScopes();
+}
+function getSyncPending() {
+  return ipc().getSyncPending();
+}
+function getDiagnostics() {
+  return ipc().getDiagnostics?.() ?? Promise.resolve([]);
+}
+function getPrimaryAccount(feature) {
+  return ipc().getPrimaryAccount?.(feature) ?? Promise.resolve(null);
+}
+function getCalendarEvents(fromMs, toMs) {
+  return ipc().getCalendarEvents?.(fromMs, toMs) ?? Promise.resolve([]);
+}
+function createCalendarEvent(ev) {
+  return ipc().createCalendarEvent?.(ev);
+}
+function updateCalendarEvent(uuid, patch) {
+  return ipc().updateCalendarEvent?.(uuid, patch);
+}
+function deleteCalendarEvent(uuid) {
+  return ipc().deleteCalendarEvent?.(uuid);
+}
+function getTasks(includeCompleted = false) {
+  return ipc().getTasks?.(includeCompleted) ?? Promise.resolve([]);
+}
+function createTask(t) {
+  return ipc().createTask?.(t);
+}
+function updateTask(uuid, patch) {
+  return ipc().updateTask?.(uuid, patch);
+}
+function deleteTask(uuid) {
+  return ipc().deleteTask?.(uuid);
+}
+function drainStoreSync() {
+  return ipc().drainStoreSync?.();
+}
+function recordSpamReport(accountId, uid, folderId) {
+  return ipc().recordSpamReport?.(accountId, uid, folderId);
+}
+function getOutboxStatus() {
+  return ipc().getOutboxStatus();
+}
+function listQueuedOutgoing() {
+  return ipc().listQueuedOutgoing();
+}
+function cancelQueuedOutgoing(p) {
+  return ipc().cancelQueuedOutgoing(p);
+}
+function searchContacts(query) {
+  return ipc().searchContacts(query);
+}
+function hasCcHistoryTo(email) {
+  return ipc().hasCcHistoryTo(email);
+}
+function hasBccHistoryTo(email) {
+  return ipc().hasBccHistoryTo(email);
+}
+function listContacts(query, page = 1, pageSize = 100) {
+  return ipc().listContacts(query, page, pageSize);
+}
+function upsertContact(name, email) {
+  return ipc().upsertContact(name, email);
+}
+function deleteContact(email) {
+  return ipc().deleteContact(email);
+}
+function addPreferredContact(entry) {
+  return ipc().addPreferredContact(entry.name, entry.email, entry.source, entry.organization);
+}
+function getPriorityLists() {
+  return ipc().getPriorityLists();
+}
+function setPrioritySender(email, value, name) {
+  return ipc().setPrioritySender(email, value, name);
+}
+function setPriorityDomain(domain, value) {
+  return ipc().setPriorityDomain(domain, value);
+}
+function addToDenylist(email) {
+  return ipc().addToDenylist(email);
+}
+function openLocalPath(which) {
+  return ipc().openLocalPath(which);
+}
+function allowRemoteContent(type, value) {
+  return ipc().allowRemoteContent(type, value);
+}
+function flagSenderOrDomain(type, value) {
+  return ipc().flagSenderOrDomain?.(type, value) ?? Promise.resolve({ flagged: false });
+}
+function deleteMessage(accountId, uid) {
+  return ipc().deleteMessage?.(accountId, uid);
+}
+function deleteMessages(accountId, uids) {
+  if (uids.length === 1)
+    return deleteMessage(accountId, uids[0]);
+  return ipc().deleteMessages?.(accountId, uids);
+}
+function moveMessages(accountId, uids, targetFolderId, targetAccountId) {
+  if (uids.length === 1)
+    return moveMessage(accountId, uids[0], targetFolderId, targetAccountId);
+  return ipc().moveMessages?.(accountId, uids, targetFolderId, targetAccountId);
+}
+function markAsSpamMessages(accountId, uids) {
+  return ipc().markAsSpamMessages?.(accountId, uids);
+}
+function undeleteMessage(accountId, uid, folderId) {
+  return ipc().undeleteMessage?.(accountId, uid, folderId);
+}
+function moveMessage(accountId, uid, targetFolderId, targetAccountId) {
+  return ipc().moveMessage?.(accountId, uid, targetFolderId, targetAccountId);
+}
+function restartServer() {
+  return ipc().restart?.();
+}
+function markFolderRead(accountId, folderId) {
+  return ipc().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 deleteFolder(accountId, folderId) {
+  return ipc().deleteFolder?.(accountId, folderId);
+}
+function emptyFolder(accountId, folderId) {
+  return ipc().emptyFolder?.(accountId, folderId);
+}
+function logClientEvent(tag, data) {
+  let delivered = false;
+  try {
+    const bridge = typeof globalThis.mailxapi !== "undefined" && globalThis.mailxapi?.isApp ? globalThis.mailxapi : window.opener?.mailxapi?.isApp ? window.opener.mailxapi : window.parent?.mailxapi?.isApp ? window.parent.mailxapi : null;
+    if (bridge?.logClientEvent) {
+      bridge.logClientEvent(tag, data);
+      delivered = true;
+    }
+  } catch {
+  }
+  try {
+    if (window.parent && window.parent !== window) {
+      window.parent.postMessage({ type: "mailx-trace", tag, data, bridged: delivered }, "*");
+    }
+  } catch {
+  }
+}
+function sendMessage(body) {
+  return ipc().sendMessage?.(body);
+}
+function saveDraft(body) {
+  return ipc().saveDraft?.(body);
+}
+function onEvent(handler) {
+  eventHandlers.push(handler);
+  return () => {
+    const i = eventHandlers.indexOf(handler);
+    if (i >= 0)
+      eventHandlers.splice(i, 1);
+  };
+}
+function connectEvents() {
+  ipc().onEvent((event) => {
+    for (const h of eventHandlers)
+      h(event);
+  });
+}
+function autocomplete(body, signal) {
+  return ipc().autocomplete?.(body);
+}
+function getAutocompleteSettings() {
+  return ipc().getAutocompleteSettings?.();
+}
+function saveAutocompleteSettings(settings) {
+  return ipc().saveAutocompleteSettings?.(settings);
+}
+function getVersion() {
+  return ipc().getVersion();
+}
+function getSettings() {
+  return ipc().getSettings();
+}
+function saveSettings(settings) {
+  return ipc().saveSettingsData?.(settings);
+}
+function repairAccounts() {
+  return ipc().repairAccounts?.();
+}
+function deleteDraft(accountId, draftUid2, draftId2) {
+  return ipc().deleteDraft?.(accountId, draftUid2, draftId2);
+}
+function addContact(name, email) {
+  return ipc().addContact?.(name, email);
+}
+function getThreadMessages(accountId, threadId) {
+  return ipc().getThreadMessages?.(accountId, threadId);
+}
+function readJsoncFile(name) {
+  return ipc().readJsoncFile?.(name);
+}
+function writeJsoncFile(name, content) {
+  return ipc().writeJsoncFile?.(name, content);
+}
+function formatJsonc(content) {
+  return ipc().formatJsonc?.(content);
+}
+function readConfigHelp(name) {
+  return ipc().readConfigHelp?.(name) ?? Promise.resolve({ content: "" });
+}
+function unsubscribeOneClick(url) {
+  return ipc().unsubscribeOneClick?.(url);
+}
+function openInWord(editId, html) {
+  return ipc().openInWord?.(editId, html) ?? Promise.resolve({ ok: false, path: "", opener: "none" });
+}
+function closeWordEdit(editId) {
+  return ipc().closeWordEdit?.(editId) ?? Promise.resolve();
+}
+function showReminderPopup(opts) {
+  return ipc().showReminderPopup?.(opts) ?? Promise.resolve({ button: "", reason: "no host" });
+}
+function consumePendingMailto() {
+  return ipc().consumePendingMailto?.() ?? Promise.resolve(null);
+}
+function aiTransform(req) {
+  return ipc().aiTransform?.(req) ?? Promise.resolve({ text: "", reason: "AI not available in this host" });
+}
+function setupAccount(name, email, password) {
+  return ipc().setupAccount?.(name, email, password);
+}
+async function getAttachment(accountId, uid, attachmentId, folderId) {
+  return ipc().getAttachment(accountId, uid, attachmentId, folderId);
+}
+async function getDeviceAccounts() {
+  return ipc().getDeviceAccounts?.() ?? [];
+}
+var cachedRelayBridge, messageListAbort, eventHandlers, connectWebSocket, onWsEvent;
+var init_api_client = __esm({
+  "client/lib/api-client.js"() {
+    "use strict";
+    cachedRelayBridge = null;
+    messageListAbort = null;
+    eventHandlers = [];
+    connectWebSocket = connectEvents;
+    onWsEvent = onEvent;
+  }
+});
+
+// client/lib/rmf-tiny.js
+var rmf_tiny_exports = {};
+__export(rmf_tiny_exports, {
+  createTinyMceEditor: () => createTinyMceEditor
+});
+async function loadTinymce(opts) {
+  try {
+    const mod = await import(
+      /* @vite-ignore */
+      "tinymce"
+    );
+    const tinymce = mod.default || mod;
+    await Promise.all([
+      import("tinymce/themes/silver").catch(() => {
+      }),
+      import("tinymce/icons/default").catch(() => {
+      }),
+      import("tinymce/models/dom").catch(() => {
+      }),
+      import("tinymce/plugins/paste").catch(() => {
+      }),
+      import("tinymce/plugins/lists").catch(() => {
+      }),
+      import("tinymce/plugins/link").catch(() => {
+      }),
+      import("tinymce/plugins/table").catch(() => {
+      }),
+      import("tinymce/plugins/code").catch(() => {
+      }),
+      import("tinymce/plugins/image").catch(() => {
+      })
+    ]);
+    return tinymce;
+  } catch {
+  }
+  const w = window;
+  if (w.tinymce)
+    return w.tinymce;
+  if (!opts.cdnUrl) {
+    throw new Error("rmf-tiny: tinymce not installed (npm install tinymce) and no cdnUrl supplied. See README for Android setup.");
+  }
+  const url = opts.apiKey && !opts.cdnUrl.includes("api-key") ? `${opts.cdnUrl}${opts.cdnUrl.includes("?") ? "&" : "?"}apiKey=${encodeURIComponent(opts.apiKey)}` : opts.cdnUrl;
+  await new Promise((resolve, reject) => {
+    const s = document.createElement("script");
+    s.src = url;
+    s.referrerPolicy = "origin";
+    s.onload = () => resolve();
+    s.onerror = () => reject(new Error(`rmf-tiny: failed to load TinyMCE from ${url}`));
+    document.head.appendChild(s);
+  });
+  if (!w.tinymce)
+    throw new Error("rmf-tiny: TinyMCE script loaded but window.tinymce is missing");
+  return w.tinymce;
+}
+async function createTinyMceEditor(container2, opts = {}) {
+  const tinymce = await loadTinymce(opts);
+  const target = document.createElement("div");
+  target.id = `rmf-tiny-${Math.random().toString(36).slice(2, 10)}`;
+  target.style.cssText = "width:100%;height:100%;";
+  container2.appendChild(target);
+  const editor2 = await new Promise((resolve) => {
+    tinymce.init({
+      target,
+      // Word-paste fidelity is the entire point of using TinyMCE here.
+      // `paste_as_text: false` keeps formatting; powerpaste isn't in
+      // OSS but the standard paste plugin handles Word reasonably well.
+      // All free / OSS plugins bundled in the jsDelivr tinymce@6 script.
+      // No premium plugins listed — listing one without an API key
+      // triggers TinyMCE's upsell dialog on every load.
+      plugins: "paste lists link table code image searchreplace autolink wordcount emoticons charmap insertdatetime quickbars nonbreaking directionality",
+      toolbar: [
+        "undo redo | bold italic underline strikethrough | forecolor backcolor",
+        "bullist numlist outdent indent | link table image code | emoticons charmap"
+      ].join(" | "),
+      // Include "tools" so wordcount and searchreplace are reachable.
+      menubar: "file edit view insert format tools",
+      // View menu — append zoom commands. fullscreen omitted: this editor
+      // lives inside a compose iframe overlay that already fills its host
+      // window; TinyMCE's fullscreen plugin re-positions the container in
+      // ways that produce a blank body, so it's not in the plugin list.
+      menu: {
+        view: { title: "View", items: "code | visualaid visualchars visualblocks | preview | zoomIn zoomOut zoomReset" }
+      },
+      // Disable the "Get all features" upsell badge that TinyMCE 6+
+      // injects automatically when no premium plugins are listed.
+      promotion: false,
+      // Floating toolbar that appears on text selection — keeps the
+      // main toolbar uncluttered while exposing common formatters
+      // where the cursor already is. quickbars_insert_toolbar:false
+      // suppresses the second (insert-on-blank-line) popup which
+      // clutters more than it helps in an email composer.
+      quickbars_selection_toolbar: "bold italic underline | forecolor | quicklink blockquote",
+      quickbars_insert_toolbar: false,
+      quickbars_image_toolbar: "alignleft aligncenter alignright",
+      // WebView's native spell-check (red underlines, right-click
+      // "Add to dictionary"). Free; same UX as Quill's spellcheck=true.
+      // Premium tinymcespellchecker plugin would replace this with a
+      // custom backend via spellchecker_rpc_url, but requires a
+      // Tiny Cloud subscription.
+      browser_spellcheck: true,
+      // Right-click context menu DISABLED so WebView2's native menu
+      // fires instead. We need the native menu because that's where
+      // the browser shows spelling suggestions (TinyMCE's contextmenu
+      // intercepts the right-click and replaces the menu — red
+      // underlines appear but suggestions are unreachable). Trade-off:
+      // lose TinyMCE's link / image / table quick actions. Standard
+      // text formatting is still on the toolbar.
+      contextmenu: false,
+      statusbar: false,
+      branding: false,
+      license_key: "gpl",
+      paste_data_images: true,
+      // Permissive valid_elements — preserve as much of the source
+      // formatting as possible. The default is more aggressive about
+      // stripping. Empty string for `valid_elements` means accept
+      // everything that the schema allows.
+      paste_word_valid_elements: "@[style|class],-strong/b,-em/i,-u,-s,-sub,-sup,-strike,-p,-ol,-ul,-li,-h1,-h2,-h3,-h4,-h5,-h6,-blockquote,-table[border|cellpadding|cellspacing|width|height|class|style],-tr,-td[colspan|rowspan|width|height|class|style|valign|align|background|bgcolor],-th,-thead,-tbody,-tfoot,-pre,-br,-a[href|target|title],-img[src|alt|width|height|style|class]",
+      paste_retain_style_properties: "color background background-color font-family font-size font-weight font-style text-decoration text-align padding padding-top padding-bottom padding-left padding-right margin margin-top margin-bottom margin-left margin-right border border-top border-bottom border-left border-right",
+      content_style: "body { font-family: system-ui, sans-serif; font-size: 14px; }",
+      init_instance_callback: (ed) => resolve(ed),
+      setup: (ed) => {
+        if (opts.initialHtml)
+          ed.on("init", () => ed.setContent(opts.initialHtml));
+        const ZOOM_DEFAULT = 14;
+        const ZOOM_STEP = 2;
+        const ZOOM_MIN = 8;
+        const ZOOM_MAX = 32;
+        let zoomPx = ZOOM_DEFAULT;
+        const applyZoom = () => {
+          try {
+            const body = ed.getBody();
+            if (body)
+              body.style.fontSize = `${zoomPx}px`;
+          } catch {
+          }
+        };
+        const bumpZoom = (delta) => {
+          zoomPx = Math.max(ZOOM_MIN, Math.min(ZOOM_MAX, zoomPx + delta));
+          applyZoom();
+        };
+        ed.ui.registry.addMenuItem("zoomIn", {
+          text: "Zoom in",
+          shortcut: "Ctrl+=",
+          onAction: () => bumpZoom(ZOOM_STEP)
+        });
+        ed.ui.registry.addMenuItem("zoomOut", {
+          text: "Zoom out",
+          shortcut: "Ctrl+-",
+          onAction: () => bumpZoom(-ZOOM_STEP)
+        });
+        ed.ui.registry.addMenuItem("zoomReset", {
+          text: "Reset zoom",
+          shortcut: "Ctrl+0",
+          onAction: () => {
+            zoomPx = ZOOM_DEFAULT;
+            applyZoom();
+          }
+        });
+        ed.on("init", () => {
+          try {
+            const body = ed.getBody();
+            if (body) {
+              body.setAttribute("spellcheck", "true");
+              body.setAttribute("lang", "en");
+            }
+            const doc = ed.getDoc();
+            if (doc?.documentElement)
+              doc.documentElement.setAttribute("lang", "en");
+          } catch {
+          }
+          try {
+            const doc = ed.getDoc();
+            doc.addEventListener("wheel", (e) => {
+              if (!e.ctrlKey)
+                return;
+              e.preventDefault();
+              bumpZoom(e.deltaY < 0 ? ZOOM_STEP : -ZOOM_STEP);
+            }, { passive: false });
+            doc.addEventListener("keydown", (e) => {
+              if (!(e.ctrlKey || e.metaKey))
+                return;
+              if (e.key === "=" || e.key === "+") {
+                e.preventDefault();
+                e.stopPropagation();
+                bumpZoom(ZOOM_STEP);
+              } else if (e.key === "-") {
+                e.preventDefault();
+                e.stopPropagation();
+                bumpZoom(-ZOOM_STEP);
+              } else if (e.key === "0") {
+                e.preventDefault();
+                e.stopPropagation();
+                zoomPx = ZOOM_DEFAULT;
+                applyZoom();
+              }
+            }, true);
+          } catch {
+          }
+        });
+      }
+    });
+  });
+  return {
+    setHtml(html) {
+      editor2.setContent(html);
+    },
+    getHtml() {
+      return editor2.getContent();
+    },
+    getText() {
+      return editor2.getContent({ format: "text" });
+    },
+    focus() {
+      editor2.focus();
+    },
+    setCursor(_pos) {
+      try {
+        editor2.selection.select(editor2.getBody(), true);
+        editor2.selection.collapse(false);
+      } catch {
+      }
+    },
+    get root() {
+      return editor2.getContainer();
+    },
+    on(event, handler) {
+      editor2.on(event, handler);
+    },
+    off(event, handler) {
+      editor2.off(event, handler);
+    }
+  };
+}
+var init_rmf_tiny = __esm({
+  "client/lib/rmf-tiny.js"() {
+    "use strict";
+  }
+});
+
+// client/compose/ghost-text.js
+var ghost_text_exports = {};
+__export(ghost_text_exports, {
+  destroyGhostText: () => destroyGhostText,
+  initGhostText: () => initGhostText
+});
+function dismiss() {
+  currentSuggestion = null;
+  if (ghostEl) {
+    ghostEl.remove();
+    ghostEl = null;
+  }
+}
+function positionGhost(editor2, text) {
+  dismiss();
+  const sel = window.getSelection();
+  if (!sel || sel.rangeCount === 0 || !sel.isCollapsed)
+    return;
+  const range = sel.getRangeAt(0);
+  let rect = range.getBoundingClientRect();
+  if (rect.width === 0 && rect.height === 0) {
+    const span = document.createElement("span");
+    span.textContent = "\u200B";
+    range.insertNode(span);
+    rect = span.getBoundingClientRect();
+    span.remove();
+    sel.removeAllRanges();
+    sel.addRange(range);
+  }
+  const container2 = editor2.getScrollContainer();
+  const containerRect = container2.getBoundingClientRect();
+  ghostEl = document.createElement("span");
+  ghostEl.className = "ghost-text";
+  ghostEl.textContent = text;
+  ghostEl.style.top = `${rect.top - containerRect.top + container2.scrollTop}px`;
+  ghostEl.style.left = `${rect.left - containerRect.left + container2.scrollLeft}px`;
+  container2.appendChild(ghostEl);
+  currentSuggestion = text;
+}
+function requestSuggestion(editor2, context) {
+  if (abortController) {
+    abortController.abort();
+    abortController = null;
+  }
+  const bodyText = editor2.getText();
+  if (!bodyText || bodyText.trim().length < 3)
+    return;
+  abortController = new AbortController();
+  const signal = abortController.signal;
+  autocomplete({
+    subject: context.getSubject(),
+    to: context.getTo(),
+    bodyText,
+    cursorOffset: bodyText.length
+  }, signal).then((result) => {
+    if (signal.aborted)
+      return;
+    if (result.suggestion) {
+      positionGhost(editor2, result.suggestion);
+    }
+  }).catch((e) => {
+    if (e.name === "AbortError")
+      return;
+  });
+}
+function initGhostText(editor2, context, options) {
+  activeEditor = editor2;
+  if (options?.debounceMs)
+    debounceMs = options.debounceMs;
+  editor2.onContentChange(() => {
+    dismiss();
+    if (debounceTimer)
+      clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => {
+      requestSuggestion(editor2, context);
+    }, debounceMs);
+  });
+  editor2.onKeyDown((e) => {
+    if (!currentSuggestion)
+      return;
+    if (e.key === "Tab") {
+      e.preventDefault();
+      e.stopPropagation();
+      const text = currentSuggestion;
+      dismiss();
+      editor2.insertTextAtCursor(text);
+      return;
+    }
+    if (e.key === "Escape") {
+      e.preventDefault();
+      e.stopPropagation();
+      dismiss();
+      return;
+    }
+    dismiss();
+  });
+  editor2.root.addEventListener("blur", dismiss);
+  editor2.getScrollContainer().addEventListener("scroll", dismiss);
+}
+function destroyGhostText() {
+  dismiss();
+  if (debounceTimer)
+    clearTimeout(debounceTimer);
+  if (abortController)
+    abortController.abort();
+  activeEditor = null;
+}
+var ghostEl, currentSuggestion, debounceTimer, abortController, activeEditor, debounceMs;
+var init_ghost_text = __esm({
+  "client/compose/ghost-text.js"() {
+    "use strict";
+    init_api_client();
+    ghostEl = null;
+    currentSuggestion = null;
+    debounceTimer = null;
+    abortController = null;
+    activeEditor = null;
+    debounceMs = 600;
+  }
+});
+
+// client/compose/editor-help.js
+var editor_help_exports = {};
+__export(editor_help_exports, {
+  EDITOR_HELP_MD: () => EDITOR_HELP_MD
+});
+var EDITOR_HELP_MD;
+var init_editor_help = __esm({
+  "client/compose/editor-help.js"() {
+    "use strict";
+    EDITOR_HELP_MD = `# Compose editor \u2014 formatting and shortcuts
+
+mailx ships with two rich-text editors: **Quill** (default) and **tiptap**.
+Most things work the same in both. Differences are called out below.
+
+Switch editors via **Settings \u2192 Editor \u2192 Quill | tiptap**.
+
+## Universal \u2014 works in both editors
+
+| Action | Shortcut | Where |
+|---|---|---|
+| **Send** | Ctrl+Enter | toolbar Send button |
+| Bold / Italic / Underline | Ctrl+B / Ctrl+I / Ctrl+U | toolbar B / I / U |
+| Strikethrough | Ctrl+Shift+X | toolbar S |
+| Bulleted list | Ctrl+Shift+8 | toolbar \u2022 |
+| Ordered list | Ctrl+Shift+7 | toolbar 1. |
+| Insert / edit link | Ctrl+K | toolbar \u{1F517} |
+| Remove link | Ctrl+Shift+K | (no toolbar button \u2014 use Ctrl+Shift+K) |
+| Blockquote | (Quill: Ctrl+Shift+Q; tiptap: toolbar) | toolbar " |
+| Clear formatting | Ctrl+\\\\ | toolbar \u2716 |
+| Heading (H1 / H2 / H3) | (Quill: format dropdown; tiptap: select dropdown) | "Normal / Heading 1 / 2 / 3" |
+| Undo / Redo | Ctrl+Z / Ctrl+Y | (no toolbar button) |
+| Spell-check | (browser native \u2014 red underlines) | right-click word |
+| Paste plain text | Ctrl+Shift+V | (browser native) |
+
+## Quill-only
+
+| Action | Shortcut |
+|---|---|
+| Indent / outdent | Ctrl+] / Ctrl+[ |
+| Color text | Ctrl+Shift+C |
+| Format dropdown | toolbar (left side) |
+| Inline code | toolbar \`<>\` |
+| Code block | toolbar |
+| Image inserter | (no built-in; use drag-and-drop or paste) |
+
+Quill has a more elaborate toolbar with format-specific dropdowns (font, size,
+color). Internally Quill uses its own *Delta* document model \u2014 copy/paste
+from Word/Outlook sometimes leaves extra empty paragraphs that you'll see
+in the sent message body.
+
+## tiptap-only
+
+| Action | Where |
+|---|---|
+| Heading select | left of toolbar |
+| Toggle bold / italic / underline / strike | toolbar B / I / U / S |
+| Blockquote | toolbar " |
+| Image (drag-and-drop) | drop a file into the body |
+
+tiptap is built on ProseMirror. Output HTML is cleaner than Quill on
+Word/Outlook paste roundtrips. Bundle is smaller. Some Quill toolbar
+features (inline code, indent shortcuts, color picker) aren't wired \u2014
+use the heading select / format menu instead.
+
+## Common features (across both)
+
+- **Drag-and-drop attachments** \u2014 drop files anywhere on the compose
+  window to attach. Overlay highlights the drop target while dragging.
+- **Edit in Word / LibreOffice** \u2014 toolbar **Edit in Word** button opens
+  the body in your default external editor. Save in the external editor
+  and the body reloads here. mailx writes a temporary \`.docx\` file (see
+  \`~/.rmfmail/external-edit/\`) and watches it for changes.
+- **Auto-save drafts** \u2014 every 5 seconds (and on input debounce / on
+  blur). Drafts land in the Drafts folder via IMAP append.
+- **Address auto-completion** \u2014 type a partial name in To/Cc/Bcc; matches
+  rank by recency \xD7 use-count. Group names from \`contacts.jsonc \u2192 groups\`
+  also surface here.
+- **Address-field expansion** \u2014 recipient fields are auto-growing
+  textareas; long lists wrap to multiple lines.
+- **Group expansion on send** \u2014 type a group name (e.g. \`family\`) in
+  To/Cc/Bcc and it expands to the address list at send time.
+- **Ghost-text autocomplete** (off by default) \u2014 Settings \u2192
+  AI autocomplete \u2192 on. Predicts the next words while you type.
+
+## When the toolbar doesn't appear
+
+The editor loads from a CDN (jsdelivr). If your network can't reach it, the
+toolbar disappears and a plain \`contenteditable\` fallback takes over. Status
+bar shows the failure. mailx tries the *other* editor before falling all the
+way back; if both fail you get a plain textarea with no shortcuts and no
+toolbar \u2014 sending still works.
+
+## See also
+
+- \`accounts.md\`, \`contacts.md\`, \`allowlist.md\`, \`clients.md\`, \`config.md\`,
+  \`preferences.md\` \u2014 config-file references (these live in your GDrive
+  \`.rmfmail/\` folder).
+- This document is **app-internal** \u2014 it ships with each release and
+  documents the editor as it currently exists in the version you're
+  running. It is not deployed to your user folder.
+`;
+  }
+});
+
+// client/compose/editor.js
+function looksLikeUrl(s) {
+  const t = s.trim();
+  if (!t)
+    return false;
+  if (/^(https?|mailto|tel):/i.test(t))
+    return true;
+  return /^[\w-]+(\.[\w-]+)+(\/\S*)?$/.test(t);
+}
+function normalizeUrl(s) {
+  const t = s.trim();
+  if (!t)
+    return t;
+  if (/^(https?|mailto|tel):/i.test(t))
+    return t;
+  if (/^[\w.+-]+@[\w-]+(\.[\w-]+)+$/.test(t))
+    return `mailto:${t}`;
+  return `https://${t}`;
+}
+function openLinkDialog(initialText, initialUrl) {
+  return new Promise((resolve) => {
+    const backdrop = document.createElement("div");
+    backdrop.className = "mailx-modal-backdrop";
+    const panel = document.createElement("div");
+    panel.className = "mailx-modal";
+    panel.innerHTML = `
+            <div class="mailx-modal-title">Edit link</div>
+            <label class="mailx-modal-label">Text
+                <input type="text" class="mailx-modal-input" id="mailx-link-text">
+            </label>
+            <label class="mailx-modal-label">URL
+                <input type="text" class="mailx-modal-input" id="mailx-link-url" spellcheck="false" autocomplete="off">
+            </label>
+            <div class="mailx-modal-buttons">
+                <button type="button" class="mailx-modal-btn" data-action="remove">Remove link</button>
+                <span class="mailx-modal-spacer"></span>
+                <button type="button" class="mailx-modal-btn" data-action="cancel">Cancel</button>
+                <button type="button" class="mailx-modal-btn mailx-modal-btn-primary" data-action="ok">OK</button>
+            </div>`;
+    backdrop.appendChild(panel);
+    document.body.appendChild(backdrop);
+    const textInput = panel.querySelector("#mailx-link-text");
+    const urlInput = panel.querySelector("#mailx-link-url");
+    textInput.value = initialText;
+    urlInput.value = initialUrl;
+    const close = (result) => {
+      backdrop.remove();
+      document.removeEventListener("keydown", onKey, true);
+      resolve(result);
+    };
+    const commit = () => close({ text: textInput.value, url: normalizeUrl(urlInput.value) });
+    const onKey = (e) => {
+      if (e.key === "Escape") {
+        e.stopPropagation();
+        e.preventDefault();
+        close(null);
+      } else if (e.key === "Enter") {
+        e.stopPropagation();
+        e.preventDefault();
+        commit();
+      }
+    };
+    document.addEventListener("keydown", onKey, true);
+    panel.querySelectorAll(".mailx-modal-btn").forEach((btn) => {
+      btn.addEventListener("click", () => {
+        const action = btn.dataset.action;
+        if (action === "cancel")
+          close(null);
+        else if (action === "remove")
+          close({ text: textInput.value, url: "", remove: true });
+        else
+          commit();
+      });
+    });
+    backdrop.addEventListener("mousedown", (e) => {
+      if (e.target === backdrop)
+        close(null);
+    });
+    (initialText ? urlInput : textInput).focus();
+    (initialText ? urlInput : textInput).select();
+  });
+}
+function createQuillEditor(container2) {
+  const openLinkForRange = async (quill, range) => {
+    if (!range)
+      return;
+    let linkRange = range;
+    const format = quill.getFormat(range);
+    if (range.length === 0 && format.link) {
+      const [leaf, offset] = quill.getLeaf(range.index);
+      if (leaf) {
+        const text = quill.getText();
+        let start = range.index, end = range.index;
+        while (start > 0 && quill.getFormat(start - 1, 1).link === format.link)
+          start--;
+        while (end < text.length - 1 && quill.getFormat(end, 1).link === format.link)
+          end++;
+        linkRange = { index: start, length: end - start };
+      }
+    }
+    const currentText = linkRange.length ? quill.getText(linkRange.index, linkRange.length).replace(/\n$/, "") : "";
+    const currentUrl = format.link || "";
+    const result = await openLinkDialog(currentText, currentUrl);
+    if (!result)
+      return;
+    if (result.remove) {
+      if (linkRange.length)
+        quill.formatText(linkRange.index, linkRange.length, "link", false);
+      return;
+    }
+    if (!result.url)
+      return;
+    const newText = result.text || result.url;
+    if (linkRange.length) {
+      quill.deleteText(linkRange.index, linkRange.length);
+      quill.insertText(linkRange.index, newText, { link: result.url });
+      quill.setSelection(linkRange.index + newText.length, 0);
+    } else {
+      quill.insertText(linkRange.index, newText, { link: result.url });
+      quill.setSelection(linkRange.index + newText.length, 0);
+    }
+  };
+  const extraBindings = {
+    insertLink: {
+      key: "K",
+      shortKey: true,
+      handler: function(range) {
+        openLinkForRange(this.quill, range);
+      }
+    },
+    removeLink: {
+      key: "K",
+      shortKey: true,
+      shiftKey: true,
+      handler: function() {
+        this.quill.format("link", false);
+      }
+    },
+    strike: {
+      key: "X",
+      shortKey: true,
+      shiftKey: true,
+      handler: function(range) {
+        if (!range)
+          return true;
+        const cur = this.quill.getFormat(range).strike;
+        this.quill.format("strike", !cur);
+      }
+    },
+    orderedList: {
+      key: "7",
+      shortKey: true,
+      shiftKey: true,
+      handler: function() {
+        this.quill.format("list", "ordered");
+      }
+    },
+    bulletList: {
+      key: "8",
+      shortKey: true,
+      shiftKey: true,
+      handler: function() {
+        this.quill.format("list", "bullet");
+      }
+    },
+    indent: {
+      key: "]",
+      shortKey: true,
+      handler: function(range, context) {
+        this.quill.format("indent", (context.format.indent || 0) + 1);
+      }
+    },
+    outdent: {
+      key: "[",
+      shortKey: true,
+      handler: function(range, context) {
+        this.quill.format("indent", Math.max(0, (context.format.indent || 0) - 1));
+      }
+    },
+    color: {
+      key: "C",
+      shortKey: true,
+      shiftKey: true,
+      handler: function(range) {
+        if (!range)
+          return true;
+        const current = this.quill.getFormat(range).color || "";
+        const color = prompt("Text color (name or #hex, blank to clear):", current);
+        if (color === null)
+          return;
+        this.quill.format("color", color || false);
+      }
+    },
+    clearFormat: {
+      key: "\\",
+      shortKey: true,
+      handler: function(range) {
+        if (!range)
+          return true;
+        this.quill.removeFormat(range.index, range.length || 0);
+      }
+    }
+  };
+  const q = new Quill(container2, {
+    theme: "snow",
+    placeholder: "Write your message...",
+    modules: {
+      toolbar: [
+        [{ font: [] }, { size: ["small", false, "large", "huge"] }],
+        [{ header: [1, 2, 3, false] }],
+        ["bold", "italic", "underline", "strike"],
+        [{ color: [] }, { background: [] }],
+        [{ list: "ordered" }, { list: "bullet" }],
+        [{ align: [] }],
+        ["blockquote", "link", "image"],
+        ["clean"]
+      ],
+      keyboard: { bindings: extraBindings }
+    }
+  });
+  document.querySelectorAll(".ql-toolbar button, .ql-toolbar select, .ql-toolbar .ql-picker-label").forEach((el) => el.setAttribute("tabindex", "-1"));
+  const applySpellcheck = () => {
+    if (q.root.getAttribute("spellcheck") !== "true")
+      q.root.setAttribute("spellcheck", "true");
+    if (q.root.getAttribute("autocorrect") !== "on")
+      q.root.setAttribute("autocorrect", "on");
+    if (q.root.getAttribute("autocapitalize") !== "on")
+      q.root.setAttribute("autocapitalize", "on");
+  };
+  applySpellcheck();
+  requestAnimationFrame(applySpellcheck);
+  setTimeout(applySpellcheck, 100);
+  const spellObs = new MutationObserver(() => applySpellcheck());
+  spellObs.observe(q.root, { attributes: true, attributeFilter: ["spellcheck", "autocorrect", "autocapitalize"] });
+  const toolbar = q.getModule("toolbar");
+  toolbar?.addHandler("link", function() {
+    openLinkForRange(q, q.getSelection() || { index: q.getLength() - 1, length: 0 });
+  });
+  q.root.addEventListener("contextmenu", async (e) => {
+    try {
+      const sel = q.getSelection();
+      if (!sel || sel.length === 0)
+        return;
+      const settingsRaw = localStorage.getItem("mailx-ai-proofread-enabled");
+      if (settingsRaw !== "true")
+        return;
+      const text = q.getText(sel.index, sel.length);
+      if (!text.trim())
+        return;
+      e.preventDefault();
+      const menu = document.createElement("div");
+      menu.style.cssText = `position:fixed;z-index:2500;background:var(--color-bg);color:var(--color-text);border:1px solid var(--color-border);border-radius:6px;box-shadow:0 4px 16px rgba(0,0,0,0.2);padding:4px 0;font-size:13px;min-width:160px;`;
+      menu.style.left = `${e.clientX}px`;
+      menu.style.top = `${e.clientY}px`;
+      const item = document.createElement("div");
+      item.textContent = "Proofread selection";
+      item.style.cssText = `padding:6px 12px;cursor:pointer;`;
+      item.addEventListener("mouseenter", () => item.style.background = "var(--color-bg-hover)");
+      item.addEventListener("mouseleave", () => item.style.background = "");
+      item.addEventListener("click", async () => {
+        menu.remove();
+        try {
+          const { aiTransform: aiTransform2 } = await Promise.resolve().then(() => (init_api_client(), api_client_exports));
+          const r = await aiTransform2({ action: "proofread", text });
+          if (r?.text && r.text !== text) {
+            q.deleteText(sel.index, sel.length);
+            q.insertText(sel.index, r.text);
+            q.setSelection(sel.index, r.text.length);
+          } else if (r?.reason) {
+            alert(`Proofread: ${r.reason}`);
+          }
+        } catch (err) {
+          alert(`Proofread failed: ${err?.message || err}`);
+        }
+      });
+      menu.appendChild(item);
+      document.body.appendChild(menu);
+      const dismiss2 = () => {
+        menu.remove();
+        document.removeEventListener("mousedown", dismiss2);
+      };
+      setTimeout(() => document.addEventListener("mousedown", dismiss2), 0);
+    } catch {
+    }
+  });
+  q.root.addEventListener("paste", (e) => {
+    const cb = e.clipboardData;
+    if (!cb)
+      return;
+    const consume = () => {
+      e.preventDefault();
+      e.stopImmediatePropagation();
+    };
+    for (const item of Array.from(cb.items)) {
+      if (item.kind === "file" && item.type.startsWith("image/")) {
+        const file = item.getAsFile();
+        if (!file)
+          continue;
+        consume();
+        const reader = new FileReader();
+        reader.onload = () => {
+          const dataUrl = String(reader.result || "");
+          const range = q.getSelection(true) || { index: q.getLength(), length: 0 };
+          q.insertEmbed(range.index, "image", dataUrl);
+          q.setSelection(range.index + 1, 0);
+        };
+        reader.readAsDataURL(file);
+        return;
+      }
+    }
+    const html = cb.getData("text/html");
+    const plain = cb.getData("text/plain");
+    if (html) {
+      try {
+        const tmp = document.createElement("div");
+        tmp.innerHTML = html;
+        const root = tmp.querySelector("body") || tmp;
+        const meaningful = Array.from(root.childNodes).filter((n) => {
+          if (n.nodeType === Node.TEXT_NODE)
+            return (n.textContent || "").trim().length > 0;
+          if (n.nodeType === Node.ELEMENT_NODE) {
+            const tag = n.tagName.toLowerCase();
+            return tag !== "meta" && tag !== "style" && tag !== "script";
+          }
+          return false;
+        });
+        if (meaningful.length === 1 && meaningful[0].tagName?.toLowerCase() === "a") {
+          const a = meaningful[0];
+          const href = a.getAttribute("href") || "";
+          const text = (a.textContent || "").trim();
+          if (href && text) {
+            consume();
+            const range = q.getSelection(true);
+            if (!range)
+              return;
+            if (range.length > 0) {
+              q.deleteText(range.index, range.length);
+            }
+            q.insertText(range.index, text, { link: href });
+            q.setSelection(range.index + text.length, 0);
+            return;
+          }
+        }
+        const textOnly = (root.textContent || "").trim();
+        if (textOnly && looksLikeUrl(textOnly) && !root.querySelector("a")) {
+          consume();
+          const range = q.getSelection(true);
+          if (!range)
+            return;
+          const url = normalizeUrl(textOnly);
+          if (range.length > 0) {
+            q.formatText(range.index, range.length, "link", url);
+            q.setSelection(range.index + range.length, 0);
+          } else {
+            q.insertText(range.index, textOnly, { link: url });
+            q.setSelection(range.index + textOnly.length, 0);
+          }
+          return;
+        }
+      } catch {
+      }
+      return;
+    }
+    if (plain && looksLikeUrl(plain)) {
+      consume();
+      const range = q.getSelection(true);
+      if (!range)
+        return;
+      const url = normalizeUrl(plain);
+      if (range.length > 0) {
+        q.formatText(range.index, range.length, "link", url);
+        q.setSelection(range.index + range.length, 0);
+      } else {
+        q.insertText(range.index, plain.trim(), { link: url });
+        q.setSelection(range.index + plain.trim().length, 0);
+      }
+    }
+  }, true);
+  let hoverTip = null;
+  q.root.addEventListener("mouseover", (e) => {
+    const a = e.target.closest("a[href]");
+    if (!a)
+      return;
+    if (hoverTip)
+      hoverTip.remove();
+    hoverTip = document.createElement("div");
+    hoverTip.className = "mailx-link-hover";
+    hoverTip.textContent = a.getAttribute("href") || "";
+    document.body.appendChild(hoverTip);
+    const rect = a.getBoundingClientRect();
+    hoverTip.style.left = `${Math.max(8, rect.left)}px`;
+    hoverTip.style.top = `${rect.bottom + 4}px`;
+  });
+  q.root.addEventListener("mouseout", (e) => {
+    const to = e.relatedTarget;
+    if (to && to.closest("a[href]"))
+      return;
+    if (hoverTip) {
+      hoverTip.remove();
+      hoverTip = null;
+    }
+  });
+  return {
+    setHtml(html) {
+      q.clipboard.dangerouslyPasteHTML(html);
+    },
+    getHtml() {
+      return q.root.innerHTML;
+    },
+    getText() {
+      return q.getText();
+    },
+    focus() {
+      q.focus();
+    },
+    setCursor(pos) {
+      q.setSelection(pos, 0);
+    },
+    root: q.root,
+    getScrollContainer() {
+      return q.root;
+    },
+    onContentChange(handler) {
+      q.on("text-change", handler);
+    },
+    onKeyDown(handler) {
+      q.root.addEventListener("keydown", handler);
+    },
+    insertTextAtCursor(text) {
+      const sel = q.getSelection();
+      if (sel)
+        q.insertText(sel.index, text);
+    }
+  };
+}
+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 toolbar = document.createElement("div");
+  toolbar.className = "tt-toolbar";
+  toolbar.innerHTML = `
+        <select class="tt-heading" tabindex="-1">
+            <option value="p">Normal</option>
+            <option value="1">Heading 1</option>
+            <option value="2">Heading 2</option>
+            <option value="3">Heading 3</option>
+        </select>
+        <button class="tt-btn" data-cmd="bold" title="Bold" tabindex="-1"><b>B</b></button>
+        <button class="tt-btn" data-cmd="italic" title="Italic" tabindex="-1"><i>I</i></button>
+        <button class="tt-btn" data-cmd="underline" title="Underline" tabindex="-1"><u>U</u></button>
+        <button class="tt-btn" data-cmd="strike" title="Strikethrough" tabindex="-1"><s>S</s></button>
+        <button class="tt-btn" data-cmd="bulletList" title="Bullet list" tabindex="-1">&#8226;</button>
+        <button class="tt-btn" data-cmd="orderedList" title="Ordered list" tabindex="-1">1.</button>
+        <button class="tt-btn" data-cmd="blockquote" title="Blockquote" tabindex="-1">&ldquo;</button>
+        <button class="tt-btn" data-cmd="link" title="Link" tabindex="-1">&#128279;</button>
+        <button class="tt-btn" data-cmd="clearFormat" title="Clear formatting" tabindex="-1">&#8999;</button>
+    `;
+  const content = document.createElement("div");
+  content.className = "tt-content";
+  container2.appendChild(toolbar);
+  container2.appendChild(content);
+  const ed = new Editor({
+    element: content,
+    extensions: [
+      StarterKit,
+      Link.configure({ openOnClick: false }),
+      Image,
+      Underline,
+      Placeholder.configure({ placeholder: "Write your message..." })
+    ],
+    content: ""
+  });
+  toolbar.querySelectorAll(".tt-btn").forEach((btn) => {
+    btn.addEventListener("mousedown", (e) => {
+      e.preventDefault();
+      const cmd = btn.dataset.cmd;
+      switch (cmd) {
+        case "bold":
+          ed.chain().focus().toggleBold().run();
+          break;
+        case "italic":
+          ed.chain().focus().toggleItalic().run();
+          break;
+        case "underline":
+          ed.chain().focus().toggleUnderline().run();
+          break;
+        case "strike":
+          ed.chain().focus().toggleStrike().run();
+          break;
+        case "bulletList":
+          ed.chain().focus().toggleBulletList().run();
+          break;
+        case "orderedList":
+          ed.chain().focus().toggleOrderedList().run();
+          break;
+        case "blockquote":
+          ed.chain().focus().toggleBlockquote().run();
+          break;
+        case "link": {
+          const url = prompt("URL:");
+          if (url)
+            ed.chain().focus().setLink({ href: url }).run();
+          break;
+        }
+        case "clearFormat":
+          ed.chain().focus().clearNodes().unsetAllMarks().run();
+          break;
+      }
+    });
+  });
+  const headingSelect = toolbar.querySelector(".tt-heading");
+  headingSelect?.addEventListener("change", () => {
+    const val = headingSelect.value;
+    if (val === "p")
+      ed.chain().focus().setParagraph().run();
+    else
+      ed.chain().focus().toggleHeading({ level: parseInt(val) }).run();
+  });
+  content.addEventListener("keydown", (e) => {
+    const mod = e.ctrlKey || e.metaKey;
+    if (!mod)
+      return;
+    const k = e.key.toLowerCase();
+    if (e.shiftKey && k === "7") {
+      e.preventDefault();
+      ed.chain().focus().toggleOrderedList().run();
+      return;
+    }
+    if (e.shiftKey && k === "8") {
+      e.preventDefault();
+      ed.chain().focus().toggleBulletList().run();
+      return;
+    }
+    if (e.shiftKey && k === "x") {
+      e.preventDefault();
+      ed.chain().focus().toggleStrike().run();
+      return;
+    }
+    if (e.shiftKey && k === "k") {
+      e.preventDefault();
+      ed.chain().focus().unsetLink().run();
+      return;
+    }
+    if (!e.shiftKey && k === "k") {
+      e.preventDefault();
+      const url = prompt("URL:");
+      if (url)
+        ed.chain().focus().setLink({ href: url }).run();
+      return;
+    }
+    if (k === "\\") {
+      e.preventDefault();
+      ed.chain().focus().clearNodes().unsetAllMarks().run();
+      return;
+    }
+  });
+  const editorEl = content.querySelector(".tiptap") || content;
+  return {
+    setHtml(html) {
+      ed.commands.setContent(html);
+    },
+    getHtml() {
+      return ed.getHTML();
+    },
+    getText() {
+      return ed.getText();
+    },
+    focus() {
+      ed.commands.focus("start");
+    },
+    setCursor(pos) {
+      ed.commands.focus("start");
+    },
+    root: editorEl,
+    getScrollContainer() {
+      return editorEl;
+    },
+    onContentChange(handler) {
+      ed.on("update", handler);
+    },
+    onKeyDown(handler) {
+      editorEl.addEventListener("keydown", handler);
+    },
+    insertTextAtCursor(text) {
+      ed.commands.insertContent(text);
+    }
+  };
+}
+async function createEditor(container2, type) {
+  if (type === "tiptap") {
+    return createTiptapEditor(container2);
+  }
+  if (type === "tinymce") {
+    return createTinyMceEditor2(container2);
+  }
+  return createQuillEditor(container2);
+}
+var DEFAULT_TINYMCE_CDN = "../lib/tinymce/tinymce.min.js";
+async function createTinyMceEditor2(container2) {
+  let cdnUrl = DEFAULT_TINYMCE_CDN;
+  let apiKey;
+  try {
+    cdnUrl = localStorage.getItem("mailx-tinymce-cdn") || DEFAULT_TINYMCE_CDN;
+    apiKey = localStorage.getItem("mailx-tinymce-apikey") || void 0;
+  } catch {
+  }
+  const m = await Promise.resolve().then(() => (init_rmf_tiny(), rmf_tiny_exports));
+  const ed = await m.createTinyMceEditor(container2, { cdnUrl, apiKey });
+  return ed;
+}
+
+// client/compose/compose.ts
+init_api_client();
+
+// client/components/context-menu.js
+var activeMenu = null;
+var dismissListener = null;
+var escapeListener = null;
+function closeContextMenu() {
+  if (activeMenu) {
+    activeMenu.remove();
+    activeMenu = null;
+  }
+  if (dismissListener) {
+    document.removeEventListener("pointerdown", dismissListener, true);
+    dismissListener = null;
+  }
+  if (escapeListener) {
+    document.removeEventListener("keydown", escapeListener, true);
+    escapeListener = null;
+  }
+}
+function showContextMenu(x, y, items) {
+  closeContextMenu();
+  const menu = document.createElement("div");
+  menu.className = "ctx-menu";
+  for (const item of items) {
+    if (item.separator) {
+      const sep = document.createElement("div");
+      sep.className = "ctx-sep";
+      menu.appendChild(sep);
+      continue;
+    }
+    const el = document.createElement("div");
+    el.className = "ctx-item" + (item.disabled ? " ctx-disabled" : "");
+    el.textContent = item.label;
+    if (!item.disabled) {
+      el.addEventListener("click", () => {
+        closeContextMenu();
+        item.action();
+      });
+    }
+    menu.appendChild(el);
+  }
+  menu.style.left = `${x}px`;
+  menu.style.top = `${y}px`;
+  document.body.appendChild(menu);
+  const rect = menu.getBoundingClientRect();
+  if (rect.right > window.innerWidth)
+    menu.style.left = `${x - rect.width}px`;
+  if (rect.bottom > window.innerHeight)
+    menu.style.top = `${y - rect.height}px`;
+  activeMenu = menu;
+  requestAnimationFrame(() => {
+    dismissListener = (e) => {
+      if (activeMenu && !activeMenu.contains(e.target)) {
+        closeContextMenu();
+      }
+    };
+    document.addEventListener("pointerdown", dismissListener, true);
+    escapeListener = (e) => {
+      if (e.key === "Escape") {
+        e.preventDefault();
+        e.stopPropagation();
+        closeContextMenu();
+      }
+    };
+    document.addEventListener("keydown", escapeListener, true);
+  });
+}
+document.addEventListener("scroll", closeContextMenu, true);
+document.addEventListener("contextmenu", () => {
+});
+
+// client/compose/compose.ts
+logClientEvent("compose-module-loaded", { href: location.href, version: window.mailxVersion || "?" });
+function closeCompose() {
+  logClientEvent("compose-close");
+  try {
+    parent.postMessage({ type: "mailx-compose-close" }, "*");
+  } catch {
+  }
+  try {
+    window.close();
+  } catch {
+  }
+}
+function loadScript(src) {
+  return new Promise((resolve, reject) => {
+    const s = document.createElement("script");
+    s.src = src;
+    s.onload = () => resolve();
+    s.onerror = () => reject(new Error(`Failed to load ${src}`));
+    document.head.appendChild(s);
+  });
+}
+function loadCSS(href) {
+  const link = document.createElement("link");
+  link.rel = "stylesheet";
+  link.href = href;
+  document.head.appendChild(link);
+}
+async function loadEditorAssets(type) {
+  if (type === "tiptap") {
+    const cdn = "https://cdn.jsdelivr.net/npm";
+    await loadScript(`${cdn}/@tiptap/core@2/dist/index.umd.js`);
+    await Promise.all([
+      loadScript(`${cdn}/@tiptap/starter-kit@2/dist/index.umd.js`),
+      loadScript(`${cdn}/@tiptap/extension-link@2/dist/index.umd.js`),
+      loadScript(`${cdn}/@tiptap/extension-image@2/dist/index.umd.js`),
+      loadScript(`${cdn}/@tiptap/extension-underline@2/dist/index.umd.js`),
+      loadScript(`${cdn}/@tiptap/extension-placeholder@2/dist/index.umd.js`)
+    ]);
+  } else {
+    loadCSS("https://cdn.jsdelivr.net/npm/quill@2/dist/quill.snow.css");
+    await loadScript("https://cdn.jsdelivr.net/npm/quill@2/dist/quill.js");
+  }
+}
+var editorType = "quill";
+var appSettings = null;
+try {
+  const cached = localStorage.getItem("mailx-editor-type");
+  if (cached === "tiptap" || cached === "quill" || cached === "tinymce") editorType = cached;
+} catch {
+}
+(async () => {
+  try {
+    appSettings = await getSettings();
+    const settingValue = appSettings?.ui?.editor;
+    const next = settingValue === "tiptap" ? "tiptap" : settingValue === "tinymce" ? "tinymce" : "quill";
+    try {
+      localStorage.setItem("mailx-editor-type", next);
+    } catch {
+    }
+  } catch {
+  }
+})();
+var editor;
+var container = document.getElementById("compose-editor");
+function setActiveEditorBadge(type) {
+  const el = document.getElementById("compose-editor-badge");
+  if (!el) return;
+  const labels = {
+    quill: "Quill",
+    tiptap: "tiptap",
+    tinymce: "TinyMCE",
+    fallback: "plain (fallback)"
+  };
+  const docs = {
+    quill: "https://quilljs.com/docs/quickstart",
+    tiptap: "https://tiptap.dev/docs/editor/introduction",
+    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;
+  el.dataset.editor = type;
+  const url = docs[type];
+  if (url) {
+    el.style.cursor = "pointer";
+    el.title = `Open ${labels[type]} documentation`;
+    el.onclick = () => {
+      const api = window.mailxapi;
+      if (api?.openExternal) api.openExternal(url);
+      else window.open(url, "_blank", "noopener,noreferrer");
+    };
+  } else {
+    el.style.cursor = "";
+    el.title = "";
+    el.onclick = null;
+  }
+}
+async function tryEditor(type) {
+  try {
+    if (type !== "tinymce") await loadEditorAssets(type);
+  } catch (e) {
+    logClientEvent("compose-editor-assets-failed", { type, error: String(e?.message || e) });
+    return null;
+  }
+  container.classList.remove("editor-tiptap", "editor-quill", "editor-tinymce");
+  container.classList.add(`editor-${type}`);
+  try {
+    return await createEditor(container, type);
+  } catch (e) {
+    logClientEvent("compose-editor-create-failed", { type, error: String(e?.message || e) });
+    return null;
+  }
+}
+var activeEditorType = editorType;
+editor = await tryEditor(editorType);
+if (!editor) {
+  const fallbackType = editorType === "quill" ? "tiptap" : "quill";
+  logClientEvent("compose-editor-fallback-other", { from: editorType, to: fallbackType });
+  container.innerHTML = "";
+  editor = await tryEditor(fallbackType);
+  if (editor) {
+    activeEditorType = fallbackType;
+    setTimeout(() => showDraftStatus(`${editorType} editor unavailable \u2014 using ${fallbackType} instead.`, false), 0);
+  }
+}
+if (!editor) {
+  logClientEvent("compose-editor-create-failed-both", {});
+  container.innerHTML = `<div class="compose-fallback-editor" contenteditable="true" style="border:1px solid #c00;padding:8px;min-height:200px;background:#fff" data-fallback="true"></div>`;
+  const fallback = container.querySelector(".compose-fallback-editor");
+  editor = {
+    root: fallback,
+    setHtml: (html) => {
+      fallback.innerHTML = html;
+    },
+    getHtml: () => fallback.innerHTML,
+    getText: () => fallback.innerText,
+    focus: () => fallback.focus(),
+    setCursor: () => {
+    },
+    getScrollContainer: () => fallback,
+    onContentChange: (handler) => {
+      fallback.addEventListener("input", handler);
+    },
+    onKeyDown: (handler) => {
+      fallback.addEventListener("keydown", handler);
+    },
+    insertTextAtCursor: (text) => {
+      const sel = window.getSelection();
+      if (sel && sel.rangeCount > 0) {
+        const range = sel.getRangeAt(0);
+        range.deleteContents();
+        range.insertNode(document.createTextNode(text));
+      } else {
+        fallback.append(document.createTextNode(text));
+      }
+    }
+  };
+  activeEditorType = "fallback";
+  setTimeout(() => showDraftStatus(`Both editors failed to load. Plain-text fallback in use. Check the log; CDN may be unreachable.`, true), 0);
+}
+setActiveEditorBadge(activeEditorType);
+(() => {
+  const STORAGE_KEY = "mailx.compose.zoom";
+  const MIN = 0.5, MAX = 3, STEP = 0.1;
+  let zoom = parseFloat(localStorage.getItem(STORAGE_KEY) || "1") || 1;
+  const applyZoom = () => {
+    container.style.fontSize = `${zoom}em`;
+    localStorage.setItem(STORAGE_KEY, String(zoom));
+  };
+  applyZoom();
+  container.addEventListener("wheel", (e) => {
+    if (!e.ctrlKey) return;
+    e.preventDefault();
+    const delta = e.deltaY < 0 ? STEP : -STEP;
+    zoom = Math.min(MAX, Math.max(MIN, Math.round((zoom + delta) * 10) / 10));
+    applyZoom();
+  }, { passive: false });
+  document.addEventListener("keydown", (e) => {
+    if (!(e.ctrlKey || e.metaKey)) return;
+    if (e.key === "=" || e.key === "+") {
+      zoom = Math.min(MAX, zoom + STEP);
+      applyZoom();
+      e.preventDefault();
+    } else if (e.key === "-") {
+      zoom = Math.max(MIN, zoom - STEP);
+      applyZoom();
+      e.preventDefault();
+    } else if (e.key === "0") {
+      zoom = 1;
+      applyZoom();
+      e.preventDefault();
+    }
+  });
+})();
+var fromInput = document.getElementById("compose-from-input");
+var fromOptions = document.getElementById("compose-from-options");
+var toInput = document.getElementById("compose-to");
+var ccInput = document.getElementById("compose-cc");
+var bccInput = document.getElementById("compose-bcc");
+var subjectInput = document.getElementById("compose-subject");
+function autoGrowAddrInput(el) {
+  if (!el) return;
+  el.style.height = "auto";
+  const max = 8 * 22;
+  el.style.height = Math.min(el.scrollHeight, max) + "px";
+  if (el.scrollHeight > max) el.style.overflowY = "auto";
+  else el.style.overflowY = "hidden";
+}
+for (const el of [toInput, ccInput, bccInput]) {
+  el?.addEventListener("input", () => autoGrowAddrInput(el));
+  el?.addEventListener("keydown", (e) => {
+    if (e.key === "Enter" && !e.shiftKey && !e.ctrlKey && !e.metaKey) {
+      e.preventDefault();
+      const start = el.selectionStart || 0;
+      const v = el.value;
+      el.value = v.slice(0, start).replace(/[,\s]+$/, "") + ", " + v.slice(start).replace(/^[,\s]+/, "");
+      el.selectionStart = el.selectionEnd = start + 2;
+      autoGrowAddrInput(el);
+    }
+  });
+}
+var knownAccounts = [];
+if (appSettings?.autocomplete?.enabled && appSettings.autocomplete.provider !== "off") {
+  Promise.resolve().then(() => (init_ghost_text(), ghost_text_exports)).then(({ initGhostText: initGhostText2 }) => {
+    initGhostText2(editor, {
+      getSubject: () => subjectInput.value,
+      getTo: () => toInput.value
+    }, { debounceMs: appSettings.autocomplete.debounceMs || 600 });
+  }).catch(() => {
+  });
+}
+function formatAccountFrom(acct) {
+  return `${acct.name} <${acct.email}>`;
+}
+var FROM_HISTORY_KEY = "mailx-from-history";
+var 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 {
+  }
+}
+function populateFromOptions(accounts, selectedId) {
+  knownAccounts = accounts;
+  fromOptions.innerHTML = "";
+  const seenValues = /* @__PURE__ */ new Set();
+  for (const acct of accounts) {
+    const opt = document.createElement("option");
+    opt.value = formatAccountFrom(acct);
+    const tag = acct.label || acct.name;
+    opt.label = tag;
+    fromOptions.appendChild(opt);
+    seenValues.add(opt.value);
+  }
+  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) || accounts.find((a) => a.defaultSend) || accounts[0];
+    if (selected) fromInput.value = formatAccountFrom(selected);
+  }
+}
+function parseFromInput() {
+  const raw = fromInput.value.trim();
+  const match = raw.match(/^(.+?)\s*<(.+?)>$/);
+  if (match) return { name: match[1].trim(), address: match[2].trim() };
+  return { name: "", address: raw };
+}
+function getFromAccountId() {
+  const { address } = parseFromInput();
+  const lower = address.toLowerCase();
+  const exact = knownAccounts.find((a) => a.email.toLowerCase() === lower);
+  if (exact) return exact.id;
+  const domain = lower.split("@")[1] || "";
+  if (domain) {
+    const sameDomain = knownAccounts.find((a) => a.email.toLowerCase().endsWith("@" + domain));
+    if (sameDomain) return sameDomain.id;
+  }
+  const def = knownAccounts.find((a) => a.defaultSend) || knownAccounts[0];
+  return def?.id || "";
+}
+function getFromAddress() {
+  return fromInput.value.trim();
+}
+function showAutocompleteContextMenu(e, row) {
+  showContextMenu(e.clientX, e.clientY, [
+    {
+      label: "Add to preferred\u2026",
+      action: () => openAddToPreferredModal(row)
+    },
+    {
+      label: "Never suggest this address",
+      action: async () => {
+        try {
+          await addToDenylist(row.email);
+        } catch (err) {
+          alert(`Failed to add to denylist: ${err?.message || err}`);
+        }
+      }
+    }
+  ]);
+}
+function openAddToPreferredModal(prefill) {
+  const overlay = document.createElement("div");
+  overlay.className = "modal-overlay";
+  overlay.innerHTML = `
+        <div class="modal" role="dialog" aria-label="Add to preferred contacts">
+            <h3>Add to preferred</h3>
+            <p class="muted">Saved to <code>contacts.jsonc</code> on your shared drive.</p>
+            <label>Name <input type="text" id="pf-name" /></label>
+            <label>Email <input type="email" id="pf-email" /></label>
+            <label>Source tag <input type="text" id="pf-source" placeholder="(optional \u2014 e.g. work, family)" /></label>
+            <label>Organization <input type="text" id="pf-org" placeholder="(optional)" /></label>
+            <div class="modal-actions">
+                <button id="pf-cancel">Cancel</button>
+                <button id="pf-save" class="primary">Save</button>
+            </div>
+        </div>
+    `;
+  document.body.appendChild(overlay);
+  overlay.querySelector("#pf-name").value = prefill.name || "";
+  overlay.querySelector("#pf-email").value = prefill.email || "";
+  const sysSources = /* @__PURE__ */ new Set(["google", "discovered", "preferred", ""]);
+  const initSource = sysSources.has(prefill.source || "") ? "" : prefill.source;
+  overlay.querySelector("#pf-source").value = initSource;
+  const close = () => overlay.remove();
+  overlay.querySelector("#pf-cancel").addEventListener("click", close);
+  overlay.addEventListener("click", (ev) => {
+    if (ev.target === overlay) close();
+  });
+  overlay.querySelector("#pf-save").addEventListener("click", async () => {
+    const name = overlay.querySelector("#pf-name").value.trim();
+    const email = overlay.querySelector("#pf-email").value.trim();
+    const source = overlay.querySelector("#pf-source").value.trim();
+    const org = overlay.querySelector("#pf-org").value.trim();
+    if (!email) {
+      alert("Email is required.");
+      return;
+    }
+    try {
+      await addPreferredContact({ name, email, source, organization: org });
+      close();
+    } catch (err) {
+      alert(`Failed to save: ${err?.message || err}`);
+    }
+  });
+  overlay.querySelector("#pf-name").focus();
+}
+function setupAutocomplete(input) {
+  let dropdown = null;
+  let activeIndex = -1;
+  let debounce;
+  function closeDropdown() {
+    if (dropdown) {
+      dropdown.remove();
+      dropdown = null;
+    }
+    activeIndex = -1;
+  }
+  function getLastToken() {
+    const val = input.value;
+    const lastComma = val.lastIndexOf(",");
+    return val.substring(lastComma + 1).trim();
+  }
+  function replaceLastToken(replacement) {
+    const val = input.value;
+    const lastComma = val.lastIndexOf(",");
+    const prefix = lastComma >= 0 ? val.substring(0, lastComma + 1) + " " : "";
+    input.value = prefix + replacement + ", ";
+    closeDropdown();
+    input.focus();
+  }
+  input.addEventListener("input", () => {
+    clearTimeout(debounce);
+    const token = getLastToken();
+    if (token.length < 1) {
+      closeDropdown();
+      return;
+    }
+    debounce = setTimeout(() => {
+      requestAnimationFrame(async () => {
+        try {
+          const results = await searchContacts(token);
+          if (results.length === 0) {
+            closeDropdown();
+            return;
+          }
+          closeDropdown();
+          dropdown = document.createElement("div");
+          dropdown.className = "ac-dropdown";
+          activeIndex = 0;
+          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;
+            const sourceEl = document.createElement("span");
+            sourceEl.className = "ac-item-source";
+            sourceEl.textContent = results[i].source || "";
+            item.appendChild(nameEl);
+            if (results[i].name) item.appendChild(emailEl);
+            if (results[i].source) item.appendChild(sourceEl);
+            item.addEventListener("mousedown", (e) => {
+              e.preventDefault();
+              const display = results[i].name ? `${results[i].name} <${results[i].email}>` : results[i].email;
+              replaceLastToken(display);
+            });
+            item.addEventListener("contextmenu", (e) => {
+              e.preventDefault();
+              e.stopPropagation();
+              showAutocompleteContextMenu(e, results[i]);
+            });
+            dropdown.appendChild(item);
+          }
+          input.parentElement.appendChild(dropdown);
+          requestAnimationFrame(() => {
+            if (!dropdown) return;
+            const rect = dropdown.getBoundingClientRect();
+            const inputRect = input.getBoundingClientRect();
+            const spaceBelow = window.innerHeight - inputRect.bottom;
+            const spaceAbove = inputRect.top;
+            if (rect.bottom > window.innerHeight && spaceAbove > spaceBelow) {
+              dropdown.style.top = "auto";
+              dropdown.style.bottom = "100%";
+            }
+          });
+        } catch {
+        }
+      });
+    }, 200);
+  });
+  input.addEventListener("keydown", (e) => {
+    if (!dropdown) return;
+    const items = dropdown.querySelectorAll(".ac-item");
+    const ke = e;
+    if (ke.key === "ArrowDown") {
+      e.preventDefault();
+      activeIndex = Math.min(activeIndex + 1, items.length - 1);
+      items.forEach((el, i) => el.classList.toggle("ac-active", i === activeIndex));
+    } else if (ke.key === "ArrowUp") {
+      e.preventDefault();
+      activeIndex = Math.max(activeIndex - 1, 0);
+      items.forEach((el, i) => el.classList.toggle("ac-active", i === activeIndex));
+    } else if (ke.key === "Tab" || ke.key === "Enter") {
+      if (items.length > 0) {
+        e.preventDefault();
+        const idx = activeIndex >= 0 ? activeIndex : 0;
+        items[idx].dispatchEvent(new MouseEvent("mousedown"));
+        return;
+      }
+    } else if (ke.key === "Escape") {
+      closeDropdown();
+    }
+  });
+  input.addEventListener("blur", () => {
+    setTimeout(closeDropdown, 150);
+  });
+}
+setupAutocomplete(toInput);
+setupAutocomplete(ccInput);
+setupAutocomplete(bccInput);
+function formatAddrs(addrs) {
+  return addrs.map((a) => a.name ? `${a.name} <${a.address}>` : a.address).join(", ");
+}
+function parseAddrs(s) {
+  if (!s.trim()) return [];
+  return s.split(",").map((p) => p.trim()).filter((p) => p.length > 0).map((part) => {
+    const match = part.match(/^(.+?)\s*<(.+?)>$/);
+    if (match) return { name: match[1].trim(), address: match[2].trim() };
+    return { name: "", address: part };
+  });
+}
+var GROUPS_LS_KEY = "mailx-groups-cache-v1";
+var _groupsCache = readGroupsFromLocalStorage();
+function readGroupsFromLocalStorage() {
+  try {
+    const raw = localStorage.getItem(GROUPS_LS_KEY);
+    if (raw) return JSON.parse(raw) || {};
+  } catch {
+  }
+  return {};
+}
+function writeGroupsToLocalStorage(groups) {
+  try {
+    localStorage.setItem(GROUPS_LS_KEY, JSON.stringify(groups));
+  } catch {
+  }
+}
+function refreshGroupsMapInBackground() {
+  (async () => {
+    try {
+      const { readJsoncFile: readJsoncFile2 } = await Promise.resolve().then(() => (init_api_client(), api_client_exports));
+      const r = await readJsoncFile2("contacts.jsonc");
+      if (!r?.content) return;
+      const stripped = r.content.replace(/^\s*\/\/.*$/gm, "").replace(/,(\s*[}\]])/g, "$1");
+      const cfg = JSON.parse(stripped);
+      const groups = cfg && typeof cfg.groups === "object" && cfg.groups ? cfg.groups : {};
+      _groupsCache = groups;
+      writeGroupsToLocalStorage(groups);
+    } catch {
+    }
+  })();
+}
+refreshGroupsMapInBackground();
+function expandGroups(raw) {
+  if (!raw.trim()) return raw;
+  if (Object.keys(_groupsCache).length === 0) return raw;
+  const groupsLc = {};
+  for (const k of Object.keys(_groupsCache)) groupsLc[k.toLowerCase()] = _groupsCache[k];
+  const tokens = raw.split(",").map((s) => s.trim()).filter(Boolean);
+  const out = [];
+  for (const tok of tokens) {
+    const members = groupsLc[tok.toLowerCase()];
+    if (members && Array.isArray(members)) out.push(...members);
+    else out.push(tok);
+  }
+  return out.join(", ");
+}
+function applyInit(init) {
+  populateFromOptions(init.accounts, init.accountId);
+  if (init.fromAddress) {
+    const account = init.accounts.find((a) => a.id === init.accountId);
+    const displayName = account?.name || "";
+    fromInput.value = displayName ? `${displayName} <${init.fromAddress}>` : init.fromAddress;
+  }
+  toInput.value = formatAddrs(init.to);
+  ccInput.value = formatAddrs(init.cc);
+  subjectInput.value = init.subject;
+  autoGrowAddrInput(toInput);
+  autoGrowAddrInput(ccInput);
+  autoGrowAddrInput(bccInput);
+  if (ccInput.value.trim()) {
+    const ccRowEl = document.getElementById("compose-cc-row");
+    const ccBtn = document.getElementById("btn-toggle-cc");
+    if (ccRowEl) ccRowEl.hidden = false;
+    if (ccBtn) ccBtn.classList.add("active");
+  } else if (init.to && init.to.length === 1) {
+    const firstEmail = init.to[0]?.address || "";
+    if (firstEmail) {
+      Promise.resolve().then(() => (init_api_client(), api_client_exports)).then(({ hasCcHistoryTo: hasCcHistoryTo2, hasBccHistoryTo: hasBccHistoryTo2 }) => {
+        hasCcHistoryTo2(firstEmail).then((res) => {
+          if (!res?.hasCc) return;
+          const ccRowEl = document.getElementById("compose-cc-row");
+          const ccBtn = document.getElementById("btn-toggle-cc");
+          if (ccRowEl?.hidden && !ccInput.value) {
+            ccRowEl.hidden = false;
+            ccBtn?.classList.add("active");
+          }
+        }).catch(() => {
+        });
+        hasBccHistoryTo2(firstEmail).then((res) => {
+          if (!res?.hasBcc) return;
+          const bccRowEl = document.getElementById("compose-bcc-row");
+          const bccBtn = document.getElementById("btn-toggle-bcc");
+          if (bccRowEl?.hidden && !bccInput.value) {
+            bccRowEl.hidden = false;
+            bccBtn?.classList.add("active");
+          }
+        }).catch(() => {
+        });
+      });
+    }
+  }
+  let bodyToRender = init.bodyHtml || "";
+  const acct = init.accounts.find((a) => a.id === init.accountId);
+  const isNew = init.mode !== "reply" && init.mode !== "replyAll" && init.mode !== "forward" && init.mode !== "draft" && !init.draftUid;
+  const isReplyForward = init.mode === "reply" || init.mode === "replyAll" || init.mode === "forward";
+  if (isNew && acct?.sig?.text) {
+    const sigText = acct.sig.html ? acct.sig.text : escapeHtml(acct.sig.text).replace(/\n/g, "<br>");
+    bodyToRender = `${bodyToRender}<br><br>-- <br>${sigText}`;
+  } else if (acct?.signature && init.mode !== "draft" && !init.draftUid) {
+    const sigBlock = `<br><br>--<br>${acct.signature}`;
+    bodyToRender = isReplyForward ? `<br>${sigBlock}<br>${bodyToRender}` : `${bodyToRender}${sigBlock}`;
+  }
+  if (bodyToRender) {
+    editor.setHtml(bodyToRender);
+    editor.setCursor(0);
+  }
+  if (init.draftUid) {
+    draftUid = init.draftUid;
+  }
+  setComposeTitle(init.subject || "");
+  if (!toInput.value) toInput.focus();
+  else if (!subjectInput.value) subjectInput.focus();
+  else editor.focus();
+  recordContentBaseline();
+}
+var composeDirty = false;
+function setComposeTitle(subject) {
+  const base = subject ? `${subject} - Compose` : "Compose - mailx";
+  document.title = composeDirty ? `\u2022 ${base}` : base;
+}
+function markComposeDirty() {
+  if (composeDirty) return;
+  composeDirty = true;
+  setComposeTitle(subjectInput?.value || "");
+}
+function markComposeClean() {
+  if (!composeDirty) return;
+  composeDirty = false;
+  setComposeTitle(subjectInput?.value || "");
+}
+var DRAFT_INPUT_DEBOUNCE_MS = 800;
+var DRAFT_INTERVAL_MS = 2e3;
+var draftUid = null;
+var draftId = null;
+var draftTimer = null;
+var draftDebounceTimer = null;
+var lastDraftContent = "";
+var baselineSnapshot = "";
+function getContentSnapshot() {
+  return JSON.stringify({
+    body: editor?.getHtml() || "",
+    to: toInput?.value || "",
+    cc: ccInput?.value || "",
+    bcc: bccInput?.value || "",
+    subject: subjectInput?.value || ""
+  });
+}
+function recordContentBaseline() {
+  baselineSnapshot = getContentSnapshot();
+  lastDraftContent = baselineSnapshot;
+}
+function composeHasUserChanges() {
+  return getContentSnapshot() !== baselineSnapshot;
+}
+var draftSaving = false;
+var draftSaveFailed = false;
+var attachments = [];
+function showDraftStatus(text, isError) {
+  const status = document.getElementById("compose-status");
+  if (!status) return;
+  status.textContent = text;
+  status.classList.toggle("compose-status-error", isError);
+}
+async function saveDraft2() {
+  if (draftSaving) return;
+  if (!draftUid && !draftId && !composeHasUserChanges()) return;
+  const content = getContentSnapshot();
+  if (content === lastDraftContent) return;
+  window.__mailxSaveDraft = saveDraft2;
+  lastDraftContent = content;
+  draftSaving = true;
+  try {
+    const data = await saveDraft({
+      accountId: getFromAccountId(),
+      subject: subjectInput.value,
+      bodyHtml: editor.getHtml(),
+      bodyText: editor.getText(),
+      to: toInput.value,
+      cc: ccInput.value,
+      previousDraftUid: draftUid,
+      draftId
+    });
+    if (data?.draftUid) draftUid = data.draftUid;
+    if (data?.draftId) draftId = data.draftId;
+    if (draftSaveFailed) {
+      draftSaveFailed = false;
+      showDraftStatus("Draft saved", false);
+    } else showDraftStatus(`Draft saved ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}`, false);
+    markComposeClean();
+  } catch (e) {
+    console.error("[draft] save failed:", e);
+    draftSaveFailed = true;
+    showDraftStatus(`Draft save failed: ${e?.message || e}`, true);
+    lastDraftContent = "";
+  } finally {
+    draftSaving = false;
+  }
+}
+function scheduleDraftSave() {
+  markComposeDirty();
+  if (draftDebounceTimer) clearTimeout(draftDebounceTimer);
+  draftDebounceTimer = setTimeout(() => {
+    draftDebounceTimer = null;
+    requestAnimationFrame(() => {
+      saveDraft2();
+    });
+  }, DRAFT_INPUT_DEBOUNCE_MS);
+}
+(async () => {
+  const stored = sessionStorage.getItem("composeInit");
+  if (stored) {
+    sessionStorage.removeItem("composeInit");
+    const init = JSON.parse(stored);
+    if (init.accounts && init.accounts.length > 0) {
+      applyInit(init);
+      getAccounts().then((fresh) => {
+        if (Array.isArray(fresh) && fresh.length > 0) {
+          init.accounts = fresh;
+          try {
+            populateFromOptions(fresh);
+          } catch {
+          }
+        }
+      }).catch(() => {
+      });
+    } else {
+      let fresh = [];
+      try {
+        fresh = await getAccounts();
+      } catch (e) {
+        console.error("Failed to load accounts:", e);
+      }
+      init.accounts = fresh;
+      applyInit(init);
+    }
+  } else {
+    let accounts = [];
+    try {
+      accounts = await getAccounts();
+    } catch (e) {
+      console.error("Failed to load accounts:", e);
+    }
+    populateFromOptions(accounts);
+    toInput.focus();
+  }
+  toInput.addEventListener("input", scheduleDraftSave);
+  ccInput.addEventListener("input", scheduleDraftSave);
+  bccInput.addEventListener("input", scheduleDraftSave);
+  subjectInput.addEventListener("input", scheduleDraftSave);
+  editor.onContentChange(scheduleDraftSave);
+  draftTimer = setInterval(saveDraft2, DRAFT_INTERVAL_MS);
+  window.addEventListener("beforeunload", () => {
+    if (draftDebounceTimer) {
+      clearTimeout(draftDebounceTimer);
+      draftDebounceTimer = null;
+    }
+    saveDraft2();
+  });
+})();
+document.addEventListener("keydown", (e) => {
+  if ((e.ctrlKey || e.metaKey) && e.key === "Enter") {
+    e.preventDefault();
+    document.getElementById("btn-send")?.click();
+  }
+});
+window.addEventListener("blur", () => {
+  try {
+    window.__mailxSaveDraft?.();
+  } catch {
+  }
+});
+document.getElementById("btn-send")?.addEventListener("click", async () => {
+  logClientEvent("compose-send-click");
+  const toExpanded = expandGroups(toInput.value);
+  const ccExpanded = expandGroups(ccInput.value);
+  const bccExpanded = expandGroups(bccInput.value);
+  const body = {
+    from: getFromAccountId(),
+    fromAddress: getFromAddress(),
+    to: parseAddrs(toExpanded),
+    cc: parseAddrs(ccExpanded),
+    bcc: parseAddrs(bccExpanded),
+    subject: subjectInput.value,
+    bodyHtml: editor.getHtml(),
+    bodyText: editor.getText(),
+    attachments: attachments.map((a) => ({ filename: a.filename, mimeType: a.mimeType, dataBase64: a.dataBase64 })),
+    // Hand draft identifiers to the daemon so it owns post-send cleanup.
+    // Previously the client fired deleteDraft() as a separate IPC after
+    // send, fire-and-forget with a silent catch — when the IMAP path
+    // hiccuped the draft survived ("draft droppings"). Daemon-side
+    // cleanup queues a sync_action on failure for reliable retry.
+    draftUid: draftUid ?? void 0,
+    draftId: draftId ?? void 0
+  };
+  logClientEvent("compose-send-body-built", { from: body.from, toCount: body.to.length, subjectLen: (body.subject || "").length, bodyHtmlLen: (body.bodyHtml || "").length, atts: body.attachments.length });
+  if (!body.to.length) {
+    logClientEvent("compose-send-rejected-no-to");
+    alert("Please add at least one To recipient.");
+    return;
+  }
+  const emailRe = /^[^\s<>@]+@[^\s<>@]+\.[^\s<>@]+$/;
+  const badAddress = (list) => {
+    if (!list) return null;
+    for (const a of list) {
+      const addr = (a?.address || "").trim();
+      if (!addr) continue;
+      if (!emailRe.test(addr)) return addr;
+    }
+    return null;
+  };
+  const bad = badAddress(body.to) || badAddress(body.cc) || badAddress(body.bcc);
+  if (bad) {
+    logClientEvent("compose-send-rejected-bad-addr", { addr: bad });
+    const statusEl = document.getElementById("compose-status");
+    if (statusEl) statusEl.textContent = `Invalid address: "${bad}"`;
+    else alert(`Invalid address: "${bad}"`);
+    return;
+  }
+  console.log(`[compose] Send clicked: from=${body.from} to=${JSON.stringify(body.to)} subject="${body.subject}" attachments=${body.attachments.length}`);
+  if (draftTimer) {
+    clearInterval(draftTimer);
+    draftTimer = null;
+  }
+  try {
+    const raw = fromInput.value.trim();
+    const known = knownAccounts.some((a) => formatAccountFrom(a) === raw);
+    if (raw && !known && /@.+\./.test(raw)) recordFromHistory(raw);
+  } catch {
+  }
+  const sendStart = Date.now();
+  logClientEvent("compose-send-pre-ipc");
+  try {
+    const reqId = `send-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const onMsg = (ev) => {
+      if (!ev.data || ev.data.type !== "mailx-compose-send-result" || ev.data.id !== reqId) return;
+      window.removeEventListener("message", onMsg);
+      if (ev.data.ok) {
+        logClientEvent("compose-send-ipc-resolved", { ms: Date.now() - sendStart });
+      } else {
+        const msg = ev.data.error || "unknown";
+        logClientEvent("compose-send-ipc-rejected", { error: msg, ms: Date.now() - sendStart });
+        try {
+          parent.postMessage({ type: "mailx-send-error", message: msg, accountId: body.from }, "*");
+        } catch {
+        }
+      }
+    };
+    window.addEventListener("message", onMsg);
+    setTimeout(() => window.removeEventListener("message", onMsg), 12e4);
+    parent.postMessage({ type: "mailx-compose-send", id: reqId, body }, "*");
+    logClientEvent("compose-send-ipc-invoked", { via: "parent-relay", reqId });
+  } catch (e) {
+    const msg = e?.message || String(e);
+    logClientEvent("compose-send-ipc-throw", { error: msg });
+    const sendBtn = document.getElementById("btn-send");
+    if (sendBtn) {
+      sendBtn.disabled = false;
+      sendBtn.textContent = "Send";
+    }
+    const statusEl = document.getElementById("compose-status");
+    if (statusEl) statusEl.textContent = `Bridge error: ${msg}`;
+    return;
+  }
+  closeCompose();
+});
+function composeHasContent() {
+  return composeHasUserChanges();
+}
+function promptSaveOrDiscard() {
+  return new Promise((resolve) => {
+    const overlay = document.createElement("div");
+    overlay.className = "compose-modal-overlay";
+    const box = document.createElement("div");
+    box.className = "compose-modal";
+    const msg = document.createElement("div");
+    msg.className = "compose-modal-msg";
+    msg.textContent = "Save this message as a draft?";
+    const btnRow = document.createElement("div");
+    btnRow.className = "compose-modal-buttons";
+    const mkBtn = (label, choice, primary) => {
+      const b = document.createElement("button");
+      b.type = "button";
+      b.textContent = label;
+      b.className = primary ? "compose-modal-btn primary" : "compose-modal-btn";
+      b.addEventListener("click", () => {
+        cleanup();
+        resolve(choice);
+      });
+      return b;
+    };
+    const cleanup = () => {
+      document.removeEventListener("keydown", onKey);
+      overlay.remove();
+    };
+    const onKey = (e) => {
+      if (e.key === "Escape") {
+        e.preventDefault();
+        cleanup();
+        resolve("cancel");
+      } else if (e.key === "Enter") {
+        e.preventDefault();
+        cleanup();
+        resolve("save");
+      }
+    };
+    document.addEventListener("keydown", onKey);
+    btnRow.appendChild(mkBtn("Save draft", "save", true));
+    btnRow.appendChild(mkBtn("Discard", "discard", false));
+    btnRow.appendChild(mkBtn("Cancel", "cancel", false));
+    box.appendChild(msg);
+    box.appendChild(btnRow);
+    overlay.appendChild(box);
+    document.body.appendChild(overlay);
+    btnRow.firstChild.focus();
+  });
+}
+async function handleCloseRequest() {
+  if (!composeHasContent()) {
+    closeCompose();
+    return true;
+  }
+  const choice = await promptSaveOrDiscard();
+  if (choice === "cancel") return false;
+  if (draftDebounceTimer) {
+    clearTimeout(draftDebounceTimer);
+    draftDebounceTimer = null;
+  }
+  if (draftTimer) {
+    clearInterval(draftTimer);
+    draftTimer = null;
+  }
+  if (choice === "save") {
+    try {
+      await saveDraft2();
+    } catch {
+    }
+  } else {
+    if (draftUid || draftId) {
+      try {
+        await deleteDraft(getFromAccountId(), draftUid || 0, draftId || "");
+      } catch {
+      }
+    }
+  }
+  closeCompose();
+  return true;
+}
+document.getElementById("btn-discard")?.addEventListener("click", async () => {
+  if (composeHasContent() && !confirm("Discard this draft? Any unsaved content will be lost.")) return;
+  if (draftDebounceTimer) {
+    clearTimeout(draftDebounceTimer);
+    draftDebounceTimer = null;
+  }
+  if (draftTimer) {
+    clearInterval(draftTimer);
+    draftTimer = null;
+  }
+  if (draftUid || draftId) {
+    try {
+      await deleteDraft(getFromAccountId(), draftUid || 0, draftId || "");
+    } catch {
+    }
+  }
+  closeCompose();
+});
+var ccRow = document.getElementById("compose-cc-row");
+var bccRow = document.getElementById("compose-bcc-row");
+var toggleCcBtn = document.getElementById("btn-toggle-cc");
+var toggleBccBtn = document.getElementById("btn-toggle-bcc");
+function setCcVisible(visible) {
+  ccRow.hidden = !visible;
+  toggleCcBtn.classList.toggle("active", visible);
+  if (visible) ccInput.focus();
+  else ccInput.value = "";
+}
+function setBccVisible(visible) {
+  bccRow.hidden = !visible;
+  toggleBccBtn.classList.toggle("active", visible);
+  if (visible) bccInput.focus();
+  else bccInput.value = "";
+}
+toggleCcBtn?.addEventListener("click", () => setCcVisible(ccRow.hidden));
+toggleBccBtn?.addEventListener("click", () => setBccVisible(bccRow.hidden));
+var fileInput = document.getElementById("compose-file");
+var attEl = document.getElementById("compose-attachments");
+function renderAttachmentChips() {
+  attEl.innerHTML = "";
+  if (attachments.length === 0) {
+    attEl.hidden = true;
+    return;
+  }
+  attEl.hidden = false;
+  for (let i = 0; i < attachments.length; i++) {
+    const a = attachments[i];
+    const chip = document.createElement("span");
+    chip.className = "compose-att-chip";
+    chip.innerHTML = `\u{1F4CE} ${escapeHtml(a.filename)} (${formatSize(a.size)}) `;
+    const rm = document.createElement("button");
+    rm.type = "button";
+    rm.title = "Remove attachment";
+    rm.textContent = "\u2715";
+    rm.addEventListener("click", () => {
+      attachments.splice(i, 1);
+      renderAttachmentChips();
+    });
+    chip.appendChild(rm);
+    attEl.appendChild(chip);
+  }
+}
+function escapeHtml(s) {
+  return s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
+}
+function formatSize(n) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+}
+var attachJustClicked = 0;
+document.getElementById("btn-attach")?.addEventListener("click", () => {
+  attachJustClicked = Date.now();
+  fileInput?.click();
+});
+var wordEditId = null;
+{
+  const isAndroid = window.mailxapi?.platform === "android" || window.parent?.mailxapi?.platform === "android";
+  if (isAndroid) {
+    const btn = document.getElementById("btn-edit-in-word");
+    if (btn) btn.hidden = true;
+  }
+}
+document.getElementById("btn-edit-in-word")?.addEventListener("click", async () => {
+  if (!wordEditId) wordEditId = `compose-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  showDraftStatus("Opening in Word\u2026", false);
+  try {
+    const result = await openInWord(wordEditId, editor.getHtml());
+    if (!result.ok || result.opener === "none") {
+      showDraftStatus("Couldn't launch an editor. Install Word, LibreOffice, or set a default for .html.", true);
+      return;
+    }
+    const label = result.opener === "word" ? "Word" : result.opener === "libreoffice" ? "LibreOffice" : "your default editor";
+    showDraftStatus(`Editing in ${label} \u2014 saves there will reload here.`, false);
+    showExternalEditHint(label);
+  } catch (e) {
+    showDraftStatus(`Edit-in-Word failed: ${e?.message || e}`, true);
+  }
+});
+document.getElementById("btn-compose-help")?.addEventListener("click", async () => {
+  try {
+    const { EDITOR_HELP_MD: EDITOR_HELP_MD2 } = await Promise.resolve().then(() => (init_editor_help(), editor_help_exports));
+    showEditorHelpModal(EDITOR_HELP_MD2);
+  } catch (e) {
+    showDraftStatus(`Couldn't open help: ${e?.message || e}`, true);
+  }
+});
+function showEditorHelpModal(md) {
+  if (document.getElementById("mailx-editor-help-modal")) return;
+  const backdrop = document.createElement("div");
+  backdrop.id = "mailx-editor-help-modal";
+  backdrop.style.cssText = "position:fixed;inset:0;background:rgba(0,0,0,0.5);z-index:10001;display:flex;align-items:center;justify-content:center;padding:24px;";
+  const panel = document.createElement("div");
+  panel.style.cssText = "background:var(--color-bg, #fff);color:var(--color-text, #000);border-radius:8px;max-width:780px;max-height:88vh;width:100%;display:flex;flex-direction:column;box-shadow:0 8px 32px rgba(0,0,0,0.4);";
+  const header = document.createElement("div");
+  header.style.cssText = "display:flex;justify-content:space-between;align-items:center;padding:12px 18px;border-bottom:1px solid var(--color-border, #ddd);";
+  header.innerHTML = `<span style="font-weight:600;">Editor help</span><button id="mailx-editor-help-close" style="background:none;border:0;font-size:18px;cursor:pointer;color:var(--color-text);padding:2px 8px;" aria-label="Close">&times;</button>`;
+  const body = document.createElement("div");
+  body.style.cssText = "flex:1;overflow:auto;padding:18px 22px;font:14px/1.55 system-ui;";
+  body.innerHTML = renderMarkdownLite(md);
+  panel.appendChild(header);
+  panel.appendChild(body);
+  backdrop.appendChild(panel);
+  document.body.appendChild(backdrop);
+  const close = () => {
+    backdrop.remove();
+    document.removeEventListener("keydown", onKey, true);
+  };
+  const onKey = (e) => {
+    if (e.key === "Escape") {
+      e.stopPropagation();
+      e.preventDefault();
+      close();
+    }
+  };
+  document.addEventListener("keydown", onKey, true);
+  header.querySelector("#mailx-editor-help-close")?.addEventListener("click", close);
+  backdrop.addEventListener("mousedown", (e) => {
+    if (e.target === backdrop) close();
+  });
+}
+function renderMarkdownLite(md) {
+  const esc = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
+  const inline = (s) => esc(s).replace(/`([^`]+)`/g, '<code style="background:var(--color-bg-surface,#f3f3f3);padding:1px 4px;border-radius:3px;">$1</code>').replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>").replace(/(?<![*\w])\*([^*\n]+)\*(?!\w)/g, "<em>$1</em>").replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2" target="_blank" rel="noopener">$1</a>');
+  const lines = md.split(/\r?\n/);
+  const out = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const h = /^(#{1,6})\s+(.*)$/.exec(line);
+    if (h) {
+      out.push(`<h${h[1].length} style="margin:18px 0 8px 0;">${inline(h[2])}</h${h[1].length}>`);
+      i++;
+      continue;
+    }
+    if (/^\s*$/.test(line)) {
+      i++;
+      continue;
+    }
+    if (line.includes("|") && /^\s*\|/.test(line)) {
+      const rows = [];
+      while (i < lines.length && /^\s*\|/.test(lines[i])) {
+        rows.push(lines[i].trim().split("|").slice(1, -1).map((s) => s.trim()));
+        i++;
+      }
+      if (rows.length >= 2 && /^[\s\-:]+$/.test(rows[1].join(""))) {
+        const head = rows[0];
+        const data = rows.slice(2);
+        out.push(`<table style="border-collapse:collapse;margin:8px 0;">`);
+        out.push(`<thead><tr>${head.map((h2) => `<th style="border-bottom:2px solid var(--color-border,#ccc);padding:4px 10px;text-align:left;">${inline(h2)}</th>`).join("")}</tr></thead>`);
+        out.push(`<tbody>${data.map((r) => `<tr>${r.map((c) => `<td style="border-bottom:1px solid var(--color-border,#eee);padding:4px 10px;">${inline(c)}</td>`).join("")}</tr>`).join("")}</tbody>`);
+        out.push(`</table>`);
+        continue;
+      }
+    }
+    if (/^\s*[-*]\s+/.test(line)) {
+      const items = [];
+      while (i < lines.length && /^\s*[-*]\s+/.test(lines[i])) {
+        items.push(lines[i].replace(/^\s*[-*]\s+/, ""));
+        i++;
+      }
+      out.push(`<ul style="margin:6px 0 6px 22px;">${items.map((it) => `<li style="margin:3px 0;">${inline(it)}</li>`).join("")}</ul>`);
+      continue;
+    }
+    out.push(`<p style="margin:6px 0;">${inline(line)}</p>`);
+    i++;
+  }
+  return out.join("\n");
+}
+function showExternalEditHint(editorLabel) {
+  if (document.getElementById("mailx-extedit-hint")) return;
+  const backdrop = document.createElement("div");
+  backdrop.id = "mailx-extedit-hint";
+  backdrop.style.cssText = "position:fixed;inset:0;background:rgba(0,0,0,0.45);z-index:10001;display:flex;align-items:center;justify-content:center;";
+  const panel = document.createElement("div");
+  panel.style.cssText = "background:var(--color-bg, #fff);color:var(--color-text, #000);border:1px solid var(--color-border, #ccc);border-radius:8px;padding:18px 22px;max-width:480px;box-shadow:0 8px 32px rgba(0,0,0,0.4);font:14px/1.5 system-ui;";
+  panel.innerHTML = `
+        <div style="font-weight:600;font-size:16px;margin-bottom:10px;">Editing in ${escapeHtml(editorLabel)}</div>
+        <ol style="margin:0 0 12px 18px;padding:0;">
+            <li>Edit your message in <b>${escapeHtml(editorLabel)}</b>.</li>
+            <li>Save (<b>Ctrl+S</b>). Today, choose <b>"Web Page, Filtered (.htm)"</b> if Word asks for a format \u2014 keep the same filename.</li>
+            <li>Switch back to this window (<b>Alt+Tab</b>). The body will reload here.</li>
+            <li>Click <b>Send</b> in this window when ready.</li>
+        </ol>
+        <div style="text-align:right;margin-top:8px;">
+            <button type="button" id="mailx-extedit-hint-ok" style="padding:6px 16px;border:1px solid var(--color-border, #ccc);background:var(--color-bg-surface, #f6f6f6);border-radius:4px;cursor:pointer;font:inherit;">Got it</button>
+        </div>
+    `;
+  backdrop.appendChild(panel);
+  document.body.appendChild(backdrop);
+  const close = () => {
+    backdrop.remove();
+    document.removeEventListener("keydown", onKey, true);
+  };
+  const onKey = (e) => {
+    if (e.key === "Escape") {
+      e.stopPropagation();
+      e.preventDefault();
+      close();
+    }
+  };
+  document.addEventListener("keydown", onKey, true);
+  panel.querySelector("#mailx-extedit-hint-ok")?.addEventListener("click", close);
+  backdrop.addEventListener("mousedown", (e) => {
+    if (e.target === backdrop) close();
+  });
+}
+onEvent((ev) => {
+  if (ev?.type !== "wordEditUpdated") return;
+  if (!wordEditId || ev.editId !== wordEditId) return;
+  try {
+    editor.setHtml(ev.html || "");
+    showDraftStatus("Reloaded edits from external editor.", false);
+    scheduleDraftSave();
+  } catch (e) {
+    showDraftStatus(`Reload failed: ${e?.message || e}`, true);
+  }
+});
+window.addEventListener("beforeunload", () => {
+  if (wordEditId) closeWordEdit(wordEditId).catch(() => {
+  });
+});
+async function ingestFiles(files) {
+  for (const file of Array.from(files)) {
+    const buf = await file.arrayBuffer();
+    let binary = "";
+    const bytes = new Uint8Array(buf);
+    for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+    const dataBase64 = btoa(binary);
+    attachments.push({
+      filename: file.name,
+      mimeType: file.type || "application/octet-stream",
+      size: file.size,
+      dataBase64
+    });
+  }
+  renderAttachmentChips();
+  scheduleDraftSave();
+}
+fileInput?.addEventListener("change", async () => {
+  if (!fileInput.files) return;
+  await ingestFiles(fileInput.files);
+  fileInput.value = "";
+});
+(() => {
+  let dragDepth = 0;
+  const root = document.body;
+  const overlay = document.createElement("div");
+  overlay.id = "compose-drop-overlay";
+  const baseStyle = "position:fixed;inset:0;background:oklch(0.6 0.18 250 / 0.15);border:3px dashed oklch(0.55 0.2 250);z-index:9999;pointer-events:none;align-items:center;justify-content:center;font-size:1.5rem;font-weight:500;color:oklch(0.35 0.2 250)";
+  overlay.style.cssText = baseStyle + ";display:none";
+  overlay.textContent = "Drop files to attach";
+  root.appendChild(overlay);
+  const show = () => {
+    overlay.style.display = "flex";
+  };
+  const hide = () => {
+    overlay.style.display = "none";
+  };
+  const hasFiles = (e) => Array.from(e.dataTransfer?.types || []).includes("Files");
+  root.addEventListener("dragenter", (e) => {
+    if (!hasFiles(e)) return;
+    dragDepth++;
+    show();
+  });
+  root.addEventListener("dragleave", (e) => {
+    if (!hasFiles(e)) return;
+    dragDepth = Math.max(0, dragDepth - 1);
+    if (dragDepth === 0) hide();
+  });
+  root.addEventListener("dragover", (e) => {
+    if (!hasFiles(e)) return;
+    e.preventDefault();
+    if (e.dataTransfer) e.dataTransfer.dropEffect = "copy";
+  });
+  root.addEventListener("drop", async (e) => {
+    if (!hasFiles(e)) return;
+    e.preventDefault();
+    dragDepth = 0;
+    hide();
+    const files = e.dataTransfer?.files;
+    if (files && files.length > 0) await ingestFiles(files);
+  });
+})();
+window.addEventListener("compose-save-and-close", () => {
+  handleCloseRequest();
+});
+window.addEventListener("compose-discard", () => {
+  document.getElementById("btn-discard")?.click();
+});
+document.addEventListener("keydown", (e) => {
+  if (e.ctrlKey && e.key === "Enter") {
+    document.getElementById("btn-send")?.click();
+  }
+  if (e.key === "Escape") {
+    if (Date.now() - attachJustClicked < 1500) return;
+    e.preventDefault();
+    handleCloseRequest();
+  }
+  if (e.ctrlKey && (e.key === "k" || e.key === "K")) {
+    const active = document.activeElement;
+    const addressFields = [toInput, ccInput, bccInput];
+    if (addressFields.includes(active)) {
+      e.preventDefault();
+      active.dispatchEvent(new Event("input"));
+    }
+  }
+});
+//# sourceMappingURL=compose.bundle.js.map