@bobfrankston/rmfmail 1.0.467

package/client/lib/mailxapi.js

@@ -0,0 +1,304 @@
+/**
+ * mailxapi — IPC bridge injected into WebView by the Rust launcher.
+ * Follows the msgapi pattern: callNode → Promise → _msgapiServiceResolve/Reject.
+ *
+ * When running in a browser (no IPC), this file is not loaded.
+ * api-client.ts auto-detects and falls back to HTTP fetch.
+ */
+
+(function() {
+    "use strict";
+
+    var _callbacks = {};
+    var _callbackId = 0;
+    var _eventHandlers = [];
+    function callNode(action, params) {
+        var id = String(++_callbackId);
+        return new Promise(function(resolve, reject) {
+            var timer = setTimeout(function() {
+                delete _callbacks[id];
+                reject(new Error("mailxapi timeout: " + action));
+            }, 120000);
+            _callbacks[id] = { resolve: resolve, reject: reject, timer: timer };
+            var msg = Object.assign({ _action: action, _cbid: id }, params || {});
+            if (window.ipc && window.ipc.postMessage) {
+                window.ipc.postMessage(JSON.stringify(msg));
+            } else {
+                clearTimeout(timer);
+                delete _callbacks[id];
+                reject(new Error("No IPC channel available"));
+            }
+        });
+    }
+
+    // Called by host (msger Rust / msgview preload) to resolve service-channel promises
+    window._msgapiServiceResolve = function(id, value) {
+        var cb = _callbacks[id];
+        if (!cb) return;
+        delete _callbacks[id];
+        clearTimeout(cb.timer);
+        cb.resolve(value);
+    };
+
+    // Called by host to reject service-channel promises
+    window._msgapiServiceReject = function(id, error) {
+        var cb = _callbacks[id];
+        if (!cb) return;
+        delete _callbacks[id];
+        clearTimeout(cb.timer);
+        cb.reject(new Error(error));
+    };
+
+    // Called by host to push events (new mail, sync progress, etc.)
+    window._msgapiServiceEvent = function(event) {
+        for (var i = 0; i < _eventHandlers.length; i++) {
+            try { _eventHandlers[i](event); } catch(e) { /* ignore */ }
+        }
+    };
+
+    window.mailxapi = {
+        isApp: true,
+        platform: "webview2",
+
+        // Accounts
+        getAccounts: function() { return callNode("getAccounts"); },
+        getFolders: function(accountId) { return callNode("getFolders", { accountId: accountId }); },
+
+        // Messages
+        getMessages: function(accountId, folderId, page, pageSize, sort, sortDir, search, flaggedOnly) {
+            return callNode("getMessages", { accountId: accountId, folderId: folderId, page: page, pageSize: pageSize, sort: sort, sortDir: sortDir, search: search, flaggedOnly: flaggedOnly });
+        },
+        getUnifiedInbox: function(page, pageSize) {
+            return callNode("getUnifiedInbox", { page: page, pageSize: pageSize });
+        },
+        getMessage: function(accountId, uid, allowRemote, folderId) {
+            return callNode("getMessage", { accountId: accountId, uid: uid, allowRemote: allowRemote, folderId: folderId });
+        },
+
+        // Actions
+        updateFlags: function(accountId, uid, flags) {
+            return callNode("updateFlags", { accountId: accountId, uid: uid, flags: flags });
+        },
+        deleteMessage: function(accountId, uid) {
+            return callNode("deleteMessage", { accountId: accountId, uid: uid });
+        },
+        undeleteMessage: function(accountId, uid, folderId) {
+            return callNode("undeleteMessage", { accountId: accountId, uid: uid, folderId: folderId });
+        },
+
+        // Diagnostic tracing — callers (compose iframe, app, components) can
+        // ship arbitrary named events to the Node log. Surfaces as
+        // `[client] <tag> <data>` so a failing pipeline can be traced end
+        // to end in a single log file.
+        logClientEvent: function(tag, data) { return callNode("logClientEvent", { tag: tag, data: data }); },
+
+        // Compose
+        sendMessage: function(msg) { return callNode("sendMessage", msg); },
+        saveDraft: function(params) { return callNode("saveDraft", params); },
+        deleteDraft: function(accountId, draftUid, draftId) {
+            return callNode("deleteDraft", { accountId: accountId, draftUid: draftUid, draftId: draftId });
+        },
+
+        // Search
+        searchMessages: function(query, page, pageSize) {
+            return callNode("searchMessages", { query: query, page: page, pageSize: pageSize });
+        },
+        addContact: function(name, email) {
+            return callNode("addContact", { name: name, email: email });
+        },
+        getThreadMessages: function(accountId, threadId) {
+            return callNode("getThreadMessages", { accountId: accountId, threadId: threadId });
+        },
+        // Calendar / Tasks two-way cache. Reads return local DB immediately;
+        // writes commit locally and queue a push-to-Google action.
+        getCalendarEvents: function(fromMs, toMs) {
+            return callNode("getCalendarEvents", { fromMs: fromMs, toMs: toMs });
+        },
+        createCalendarEvent: function(ev) { return callNode("createCalendarEvent", ev); },
+        updateCalendarEvent: function(uuid, patch) { return callNode("updateCalendarEvent", { uuid: uuid, patch: patch }); },
+        deleteCalendarEvent: function(uuid) { return callNode("deleteCalendarEvent", { uuid: uuid }); },
+        getTasks: function(includeCompleted) { return callNode("getTasks", { includeCompleted: !!includeCompleted }); },
+        createTask: function(t) { return callNode("createTask", t); },
+        updateTask: function(uuid, patch) { return callNode("updateTask", { uuid: uuid, patch: patch }); },
+        deleteTask: function(uuid) { return callNode("deleteTask", { uuid: uuid }); },
+        drainStoreSync: function() { return callNode("drainStoreSync"); },
+        recordSpamReport: function(accountId, uid, folderId) {
+            return callNode("recordSpamReport", { accountId: accountId, uid: uid, folderId: folderId });
+        },
+        readJsoncFile: function(name) {
+            return callNode("readJsoncFile", { name: name });
+        },
+        writeJsoncFile: function(name, content) {
+            return callNode("writeJsoncFile", { name: name, content: content });
+        },
+        formatJsonc: function(content) {
+            return callNode("formatJsonc", { content: content });
+        },
+        readConfigHelp: function(name) {
+            return callNode("readConfigHelp", { name: name });
+        },
+        unsubscribeOneClick: function(url) {
+            return callNode("unsubscribeOneClick", { url: url });
+        },
+        openInWord: function(editId, html) {
+            return callNode("openInWord", { editId: editId, html: html });
+        },
+        closeWordEdit: function(editId) {
+            return callNode("closeWordEdit", { editId: editId });
+        },
+        aiTransform: function(req) {
+            return callNode("aiTransform", req);
+        },
+        // Restart the background service so edits to accounts.jsonc /
+        // allowlist.jsonc / other live config take effect without the user
+        // having to type `mailx -kill`. The service spawns a fresh detached
+        // daemon and then exits; the new daemon takes over.
+        restartDaemon: function() {
+            return new Promise(function(resolve) {
+                var id = String(++_callbackId);
+                _callbacks[id] = { resolve: resolve, reject: resolve, timer: setTimeout(function() {
+                    delete _callbacks[id];
+                    resolve({ ok: true, status: "service-gone" });
+                }, 5000) };
+                try { window.ipc.postMessage(JSON.stringify({ _action: "restartDaemon", _cbid: id })); } catch(e) { resolve({ ok: false }); }
+            });
+        },
+        searchContacts: function(query) {
+            return callNode("searchContacts", { query: query });
+        },
+        listContacts: function(query, page, pageSize) {
+            return callNode("listContacts", { query: query || "", page: page || 1, pageSize: pageSize || 100 });
+        },
+        upsertContact: function(name, email) {
+            return callNode("upsertContact", { name: name, email: email });
+        },
+        deleteContact: function(email) {
+            return callNode("deleteContact", { email: email });
+        },
+        addPreferredContact: function(name, email, source, organization) {
+            return callNode("addPreferredContact", {
+                name: name || "", email: email,
+                source: source || "", organization: organization || "",
+            });
+        },
+        addToDenylist: function(email) {
+            return callNode("addToDenylist", { email: email });
+        },
+        openLocalPath: function(which) {
+            return callNode("openLocalPath", { which: which });
+        },
+
+        // Item 17: platform-aware external openers. On Android (MAUI shell)
+        // these fire native Intents so Contacts/Calendar links jump to the
+        // OS apps instead of the browser. On desktop the MAUI shell isn't
+        // in play; we fall through to a URL open via the navigation path
+        // that msger / external launcher handles the same as any http link.
+        openContact: function(email) {
+            try {
+                // MAUI intercepts this scheme in OnNavigating and fires a
+                // native ACTION_VIEW intent on the mailto: URI — system
+                // Contacts registers for it on stock Android.
+                if (/Android/i.test(navigator.userAgent)) {
+                    window.location.href = "mailxapi-intent://contact/" + encodeURIComponent(email);
+                    return;
+                }
+            } catch (e) { /* navigation blocked — fall through */ }
+            // Desktop / browser fallback: open mailto: — msger forwards
+            // mailto URLs to the system default handler, which on a mailx
+            // install is mailx itself (our own compose window takes over).
+            window.location.href = "mailto:" + email;
+        },
+        openCalendarEvent: function(htmlLink) {
+            if (!htmlLink) return;
+            try {
+                if (/Android/i.test(navigator.userAgent)) {
+                    // MAUI dispatches this to the native Calendar app via
+                    // ACTION_VIEW on the Google Calendar event URL.
+                    window.location.href = "mailxapi-intent://calendar/" + encodeURIComponent(htmlLink);
+                    return;
+                }
+            } catch (e) { /* */ }
+            // Desktop: existing openExternal path (browser, new tab).
+            window.open(htmlLink, "_blank");
+        },
+
+        // Sync
+        syncAll: function() { return callNode("syncAll"); },
+        syncAccount: function(accountId) { return callNode("syncAccount", { accountId: accountId }); },
+        getSyncPending: function() { return callNode("getSyncPending"); },
+        getOutboxStatus: function() { return callNode("getOutboxStatus"); },
+        getDiagnostics: function() { return callNode("getDiagnostics"); },
+        getPrimaryAccount: function(feature) { return callNode("getPrimaryAccount", { feature: feature }); },
+        listQueuedOutgoing: function() { return callNode("listQueuedOutgoing"); },
+        cancelQueuedOutgoing: function(p) { return callNode("cancelQueuedOutgoing", { path: p }); },
+        reauthenticate: function(accountId) { return callNode("reauthenticate", { accountId: accountId }); },
+        reauthGoogleScopes: function() { return callNode("reauthGoogleScopes"); },
+        hasCcHistoryTo: function(email) { return callNode("hasCcHistoryTo", { email: email }); },
+
+        // Bulk operations
+        deleteMessages: function(accountId, uids) {
+            return callNode("deleteMessages", { accountId: accountId, uids: uids });
+        },
+        moveMessage: function(accountId, uid, targetFolderId, targetAccountId) {
+            return callNode("moveMessage", { accountId: accountId, uid: uid, targetFolderId: targetFolderId, targetAccountId: targetAccountId });
+        },
+        moveMessages: function(accountId, uids, targetFolderId) {
+            return callNode("moveMessages", { accountId: accountId, uids: uids, targetFolderId: targetFolderId });
+        },
+        markAsSpamMessages: function(accountId, uids) {
+            return callNode("markAsSpamMessages", { accountId: accountId, uids: uids });
+        },
+        performUpdate: function() {
+            return callNode("performUpdate", {});
+        },
+        markFolderRead: function(accountId, folderId) {
+            return callNode("markFolderRead", { folderId: folderId });
+        },
+        createFolder: function(accountId, parentPath, name) {
+            return callNode("createFolder", { accountId: accountId, parentPath: parentPath, name: name });
+        },
+        renameFolder: function(accountId, folderId, newName) {
+            return callNode("renameFolder", { accountId: accountId, folderId: folderId, newName: newName });
+        },
+        deleteFolder: function(accountId, folderId) {
+            return callNode("deleteFolder", { accountId: accountId, folderId: folderId });
+        },
+        emptyFolder: function(accountId, folderId) {
+            return callNode("emptyFolder", { accountId: accountId, folderId: folderId });
+        },
+
+        // Settings
+        allowRemoteContent: function(type, value) {
+            return callNode("allowRemoteContent", { type: type, value: value });
+        },
+        flagSenderOrDomain: function(type, value) {
+            return callNode("flagSenderOrDomain", { type: type, value: value });
+        },
+        getSettings: function() { return callNode("getSettings"); },
+        saveSettingsData: function(data) { return callNode("saveSettingsData", data); },
+        getVersion: function() { return callNode("getVersion"); },
+        getAutocompleteSettings: function() { return callNode("getAutocompleteSettings"); },
+        saveAutocompleteSettings: function(settings) { return callNode("saveAutocompleteSettings", settings); },
+
+        // Attachments
+        getAttachment: function(accountId, uid, attachmentId, folderId) {
+            return callNode("getAttachment", { accountId: accountId, uid: uid, attachmentId: attachmentId, folderId: folderId });
+        },
+
+        // Setup & Repair
+        setupAccount: function(name, email, password) {
+            return callNode("setupAccount", { name: name, email: email, password: password });
+        },
+        repairAccounts: function() { return callNode("repairAccounts"); },
+
+        // Window geometry
+        saveWindowGeometry: function(geom) {
+            return callNode("saveWindowGeometry", geom);
+        },
+
+        // Events
+        onEvent: function(handler) { _eventHandlers.push(handler); },
+    };
+
+    window.dispatchEvent(new CustomEvent("mailxapiready"));
+})();

package/client/lib/message-state.js

@@ -0,0 +1,132 @@
+/**
+ * Shared message state — single source of truth for the message list and viewer.
+ *
+ * The message list and viewer both reference message objects from this store.
+ * Operations (move, delete, sync) mutate the store; UI components subscribe
+ * and update themselves. No manual DOM cleanup, no custom events.
+ */
+/** The currently loaded messages (what the list shows) */
+let messages = [];
+/** The currently selected/viewed message (same ref as an entry in messages[]) */
+let selected = null;
+const listeners = [];
+/** Subscribe to state changes. Returns unsubscribe function. */
+export function subscribe(fn) {
+    listeners.push(fn);
+    return () => {
+        const i = listeners.indexOf(fn);
+        if (i >= 0)
+            listeners.splice(i, 1);
+    };
+}
+function notify(change) {
+    for (const fn of listeners) {
+        try {
+            fn(change);
+        }
+        catch { /* don't let one subscriber break others */ }
+    }
+}
+/** Replace the entire message list (folder load, search, unified inbox).
+ *  Selection stays even when the previously-selected message isn't in
+ *  the new list — that case happens whenever a periodic sync re-fetches
+ *  page 1 of the unified inbox and a row the user opened earlier has
+ *  scrolled off, or when the same row's accountId/uid pair changes
+ *  shape after dedup. Yanking the viewer mid-read was a user-reported
+ *  surprise (2026-04-30: "I was reading a message but now it just
+ *  jumped to Select a message to read"). The viewer keeps the message
+ *  it has; it'll only clear when the user explicitly clicks elsewhere
+ *  or the message is removed via removeMessages (real delete/move). */
+export function setMessages(msgs) {
+    messages = msgs;
+    notify("messages");
+}
+/** Get current messages */
+export function getMessages() {
+    return messages;
+}
+/** Select a message (by reference or null to deselect) */
+export function select(msg) {
+    selected = msg;
+    notify("selected");
+}
+/** Get the selected message */
+export function getSelected() {
+    return selected;
+}
+/**
+ * Remove messages from the list (after move or delete).
+ * If the selected message is removed, auto-selects the next message or null.
+ * Decrements dupeCount on any remaining messages that shared a Message-ID
+ * with one of the removed rows — so the unified-inbox ⇆ marker disappears
+ * when one half of a duplicate pair is deleted, instead of pointing at a
+ * sibling that no longer exists.
+ */
+export function removeMessages(uids) {
+    const removeSet = new Set(uids.map(u => `${u.accountId}:${u.uid}`));
+    const wasSelectedRemoved = selected && removeSet.has(`${selected.accountId}:${selected.uid}`);
+    // Identity-based pre-capture of the row that should become selected
+    // after the batch. Walk forward from the last removed row to the first
+    // surviving row — that's the message the user would have navigated to
+    // next. Capturing by reference (not index) so the post-filter shift
+    // doesn't matter; if every deleted row had a survivor below it, the
+    // chosen survivor is the same regardless of how many got deleted.
+    // Falls back to walking backward if the deletion is at the bottom.
+    let nextAfterRemoval = null;
+    if (wasSelectedRemoved) {
+        let lastRemovedIdx = -1;
+        for (let i = 0; i < messages.length; i++) {
+            if (removeSet.has(`${messages[i].accountId}:${messages[i].uid}`))
+                lastRemovedIdx = i;
+        }
+        for (let i = lastRemovedIdx + 1; i < messages.length; i++) {
+            if (!removeSet.has(`${messages[i].accountId}:${messages[i].uid}`)) {
+                nextAfterRemoval = messages[i];
+                break;
+            }
+        }
+        if (!nextAfterRemoval) {
+            // No survivor below — fall back to the closest survivor above.
+            for (let i = lastRemovedIdx - 1; i >= 0; i--) {
+                if (!removeSet.has(`${messages[i].accountId}:${messages[i].uid}`)) {
+                    nextAfterRemoval = messages[i];
+                    break;
+                }
+            }
+        }
+    }
+    // Capture Message-IDs of the rows about to leave, so we can fix up the
+    // dupeCount on any remaining siblings. Only IDs that were in the list
+    // and had a non-empty messageId count — empty IDs would match every
+    // headerless row and falsely "merge" them.
+    const removedIds = new Set();
+    for (const m of messages) {
+        if (removeSet.has(`${m.accountId}:${m.uid}`) && m.messageId) {
+            removedIds.add(m.messageId);
+        }
+    }
+    messages = messages.filter(m => !removeSet.has(`${m.accountId}:${m.uid}`));
+    // Sibling dupeCount adjustment. dupeCount is server-recomputed on the
+    // next getUnifiedInbox fetch, but we don't want to wait for that —
+    // user just deleted, the marker should drop now. Decrement once per
+    // remaining message whose messageId matches a removed one.
+    if (removedIds.size > 0) {
+        for (const m of messages) {
+            if (m.messageId && removedIds.has(m.messageId) && typeof m.dupeCount === "number") {
+                m.dupeCount = Math.max(0, m.dupeCount - 1);
+            }
+        }
+    }
+    if (wasSelectedRemoved) {
+        selected = nextAfterRemoval;
+    }
+    notify("removed");
+}
+/** Update flags on a message in the list */
+export function updateMessageFlags(accountId, uid, flags) {
+    const msg = messages.find(m => m.uid === uid && m.accountId === accountId);
+    if (msg)
+        msg.flags = flags;
+    // No notify — flag changes are cosmetic, handled inline by the list
+}
+//# sourceMappingURL=message-state.js.map

package/client/lib/message-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-state.js","sourceRoot":"","sources":["message-state.ts"],"names":[],"mappings":"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"}

package/client/lib/message-state.ts

@@ -0,0 +1,160 @@
+/**
+ * Shared message state — single source of truth for the message list and viewer.
+ *
+ * The message list and viewer both reference message objects from this store.
+ * Operations (move, delete, sync) mutate the store; UI components subscribe
+ * and update themselves. No manual DOM cleanup, no custom events.
+ */
+
+export interface ListMessage {
+    accountId: string;
+    uid: number;
+    folderId: number;
+    subject: string;
+    from: { name: string; address: string };
+    to: { name: string; address: string }[];
+    cc: { name: string; address: string }[];
+    date: number;
+    flags: string[];
+    size: number;
+    preview: string;
+    hasAttachments: boolean;
+    [key: string]: any;
+}
+
+type ChangeType = "messages" | "selected" | "removed";
+type Listener = (change: ChangeType) => void;
+
+/** The currently loaded messages (what the list shows) */
+let messages: ListMessage[] = [];
+
+/** The currently selected/viewed message (same ref as an entry in messages[]) */
+let selected: ListMessage | null = null;
+
+const listeners: Listener[] = [];
+
+/** Subscribe to state changes. Returns unsubscribe function. */
+export function subscribe(fn: Listener): () => void {
+    listeners.push(fn);
+    return () => {
+        const i = listeners.indexOf(fn);
+        if (i >= 0) listeners.splice(i, 1);
+    };
+}
+
+function notify(change: ChangeType): void {
+    for (const fn of listeners) {
+        try { fn(change); } catch { /* don't let one subscriber break others */ }
+    }
+}
+
+/** Replace the entire message list (folder load, search, unified inbox).
+ *  Selection stays even when the previously-selected message isn't in
+ *  the new list — that case happens whenever a periodic sync re-fetches
+ *  page 1 of the unified inbox and a row the user opened earlier has
+ *  scrolled off, or when the same row's accountId/uid pair changes
+ *  shape after dedup. Yanking the viewer mid-read was a user-reported
+ *  surprise (2026-04-30: "I was reading a message but now it just
+ *  jumped to Select a message to read"). The viewer keeps the message
+ *  it has; it'll only clear when the user explicitly clicks elsewhere
+ *  or the message is removed via removeMessages (real delete/move). */
+export function setMessages(msgs: ListMessage[]): void {
+    messages = msgs;
+    notify("messages");
+}
+
+/** Get current messages */
+export function getMessages(): ListMessage[] {
+    return messages;
+}
+
+/** Select a message (by reference or null to deselect) */
+export function select(msg: ListMessage | null): void {
+    selected = msg;
+    notify("selected");
+}
+
+/** Get the selected message */
+export function getSelected(): ListMessage | null {
+    return selected;
+}
+
+/**
+ * Remove messages from the list (after move or delete).
+ * If the selected message is removed, auto-selects the next message or null.
+ * Decrements dupeCount on any remaining messages that shared a Message-ID
+ * with one of the removed rows — so the unified-inbox ⇆ marker disappears
+ * when one half of a duplicate pair is deleted, instead of pointing at a
+ * sibling that no longer exists.
+ */
+export function removeMessages(uids: { accountId: string; uid: number }[]): void {
+    const removeSet = new Set(uids.map(u => `${u.accountId}:${u.uid}`));
+    const wasSelectedRemoved = selected && removeSet.has(`${selected.accountId}:${selected.uid}`);
+
+    // Identity-based pre-capture of the row that should become selected
+    // after the batch. Walk forward from the last removed row to the first
+    // surviving row — that's the message the user would have navigated to
+    // next. Capturing by reference (not index) so the post-filter shift
+    // doesn't matter; if every deleted row had a survivor below it, the
+    // chosen survivor is the same regardless of how many got deleted.
+    // Falls back to walking backward if the deletion is at the bottom.
+    let nextAfterRemoval: ListMessage | null = null;
+    if (wasSelectedRemoved) {
+        let lastRemovedIdx = -1;
+        for (let i = 0; i < messages.length; i++) {
+            if (removeSet.has(`${messages[i].accountId}:${messages[i].uid}`)) lastRemovedIdx = i;
+        }
+        for (let i = lastRemovedIdx + 1; i < messages.length; i++) {
+            if (!removeSet.has(`${messages[i].accountId}:${messages[i].uid}`)) {
+                nextAfterRemoval = messages[i];
+                break;
+            }
+        }
+        if (!nextAfterRemoval) {
+            // No survivor below — fall back to the closest survivor above.
+            for (let i = lastRemovedIdx - 1; i >= 0; i--) {
+                if (!removeSet.has(`${messages[i].accountId}:${messages[i].uid}`)) {
+                    nextAfterRemoval = messages[i];
+                    break;
+                }
+            }
+        }
+    }
+
+    // Capture Message-IDs of the rows about to leave, so we can fix up the
+    // dupeCount on any remaining siblings. Only IDs that were in the list
+    // and had a non-empty messageId count — empty IDs would match every
+    // headerless row and falsely "merge" them.
+    const removedIds = new Set<string>();
+    for (const m of messages) {
+        if (removeSet.has(`${m.accountId}:${m.uid}`) && m.messageId) {
+            removedIds.add(m.messageId);
+        }
+    }
+
+    messages = messages.filter(m => !removeSet.has(`${m.accountId}:${m.uid}`));
+
+    // Sibling dupeCount adjustment. dupeCount is server-recomputed on the
+    // next getUnifiedInbox fetch, but we don't want to wait for that —
+    // user just deleted, the marker should drop now. Decrement once per
+    // remaining message whose messageId matches a removed one.
+    if (removedIds.size > 0) {
+        for (const m of messages) {
+            if (m.messageId && removedIds.has(m.messageId) && typeof (m as any).dupeCount === "number") {
+                (m as any).dupeCount = Math.max(0, (m as any).dupeCount - 1);
+            }
+        }
+    }
+
+    if (wasSelectedRemoved) {
+        selected = nextAfterRemoval;
+    }
+    notify("removed");
+}
+
+/** Update flags on a message in the list */
+export function updateMessageFlags(accountId: string, uid: number, flags: string[]): void {
+    const msg = messages.find(m => m.uid === uid && m.accountId === accountId);
+    if (msg) msg.flags = flags;
+    // No notify — flag changes are cosmetic, handled inline by the list
+}

package/client/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@bobfrankston/mailx-client",
+  "version": "1.0.16",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {
+    "quill": "^2.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BobFrankston/mailx-client.git"
+  }
+}