@bobfrankston/mailx-store 0.1.22 → 0.1.24

package/db.d.ts

@@ -53,15 +53,46 @@ export declare class MailxDB {
      *  user's own Sent copy, so it's still a reliable signal that this user
      *  habitually Bccs when writing to this recipient. */
     hasBccHistoryTo(recipientEmail: string): boolean;
-    /** Mark a Message-ID as locally-deleted for an account. No-op if messageId
-     *  is empty (e.g. provider stripped the header) — without a stable id we
-     *  can't check against future sync results anyway. */
+    /** Mark a local row as "delete pending server confirmation". The row
+     *  stays visible (UI greys / strikes it through) until the server
+     *  confirms via QRESYNC VANISHED or its UID drops out of the set-diff. */
+    setMessagePendingDelete(accountId: string, uid: number, folderId: number): void;
+    /** Clear the pending-delete flag — used when the IMAP MOVE/EXPUNGE is
+     *  refused by the server and the row should revert to a normal visible
+     *  state, and by Ctrl-Z undelete. */
+    clearMessagePendingDelete(accountId: string, uid: number, folderId: number): void;
+    /** Query: is this (folder, uid) pending server-side delete? */
+    isMessagePendingDelete(accountId: string, uid: number, folderId: number): boolean;
+    /** @deprecated — superseded by setMessagePendingDelete. Retained as a
+     *  no-op so legacy delete paths still compile; the table is preserved
+     *  but never read by the sync path anymore. */
     addTombstone(accountId: string, messageId: string, subject?: string): void;
-    /** Is this Message-ID tombstoned for this account? */
+    /** Is this Message-ID tombstoned for this account? Tombstones suppress
+     *  re-import of a row the user just deleted/moved while the server-side
+     *  IMAP action is still in flight; without this, the moved-out source
+     *  folder would re-insert the message on the next sync (server still
+     *  sees the UID; mailx has no other way to know "I just moved this").
+     *
+     *  Lifetime: created at the local-delete/move moment, removed on
+     *  successful IMAP action complete OR on PERMANENT IMAP action failure.
+     *  The failure-clear is the 2026-05-13 fix for the "tombstones outlive
+     *  failed deletes" bug — `failSyncAction` calls `clearTombstoneForUid`
+     *  after the final retry attempt so the user sees the row reappear on
+     *  the next sync (server still has it, mailx now agrees). QRESYNC
+     *  servers don't need this fallback because VANISHED is authoritative;
+     *  tombstones are no-ops on the QRESYNC fast path. */
     hasTombstone(accountId: string, messageId: string): boolean;
-    /** Remove a tombstone — used by "undelete" (Ctrl-Z) so a subsequent sync
-     *  re-imports the message as normal. Also lets the user recover from a
-     *  mistaken local delete. */
+    /** Clear the tombstone for the message currently at (accountId, uid,
+     *  folderId). Used by the sync-action failure path: when an IMAP MOVE
+     *  or EXPUNGE fails terminally, the row is still on the server and the
+     *  user should see it again — so the suppression must lift. The lookup
+     *  is by (accountId, uid, folderId) → message_id, since the action
+     *  table stores UID not Message-ID. No-op if the row no longer exists
+     *  (concurrent server-side EXPUNGE etc.). */
+    clearTombstoneForUid(accountId: string, uid: number, folderId: number): void;
+    /** @deprecated — use clearMessagePendingDelete instead. Retained as a
+     *  no-op for legacy callers (Ctrl-Z undelete paths still work because
+     *  their sibling clearMessagePendingDelete is called). */
     removeTombstone(accountId: string, messageId: string): void;
     /** Age-out tombstones older than the given cutoff. Keeps the table from
      *  growing unboundedly. Default retention is 30 days; caller passes the

package/db.js

@@ -357,6 +357,14 @@ const SCHEMA = `
         folder_id INTEGER NOT NULL,
         uid INTEGER NOT NULL,
         last_seen_at INTEGER NOT NULL,
+        -- 0 = normal, 1 = user initiated delete, server-sync in flight.
+        -- Replaces the old tombstones table: rather than hide a row server
+        -- still has, we keep it visible with this flag and let the UI render
+        -- it as a struck-through "in flight" row. On server-confirmed
+        -- deletion (QRESYNC VANISHED, or absence from a set-diff with the
+        -- 50% safety guard) the row is dropped. On server-refused deletion
+        -- the flag is cleared and the row reverts to normal.
+        pending_delete INTEGER DEFAULT 0,
         UNIQUE(folder_id, uid)
     );
     CREATE INDEX IF NOT EXISTS idx_message_folders_msg ON message_folders(message_row_id);
@@ -420,6 +428,9 @@ export class MailxDB {
         // calendar's defaultReminders pre-resolved server-side and pulled
         // through here too.
         this.addColumnIfMissing("calendar_events", "reminder_minutes_json", "TEXT DEFAULT '[]'");
+        // pending_delete on message_folders replaces the old tombstones table.
+        // See the table comment for semantics — visible in-flight delete state.
+        this.addColumnIfMissing("message_folders", "pending_delete", "INTEGER DEFAULT 0");
         // Backfill UUIDs for any pre-existing rows that were inserted before
         // this column landed. One UPDATE + an id roundtrip per row — cheap
         // at our row counts, runs once per DB upgrade.
@@ -692,10 +703,61 @@ export class MailxDB {
             return false;
         }
     }
-    // ── Tombstones (local-delete record so server echo can't resurrect) ──
-    /** Mark a Message-ID as locally-deleted for an account. No-op if messageId
-     *  is empty (e.g. provider stripped the header) — without a stable id we
-     *  can't check against future sync results anyway. */
+    // ── Pending-delete state (replaces tombstones) ──
+    //
+    // Tombstones were a client-side invention that hid messages the server
+    // still considered present. With QRESYNC (RFC 7162) the server is
+    // authoritative — VANISHED tells us definitively what's deleted, so the
+    // tombstone hack is obsolete. For the non-QRESYNC case, the natural
+    // upsert-by-(folder, uid) behaviour of the sync path is already correct:
+    // a row pending deletion just has `pending_delete = 1`; the sync upserts
+    // refresh `last_seen_at` but don't reset the flag.
+    //
+    // The old tombstone API stubs below remain temporarily so legacy callers
+    // compile; they delegate to pending_delete by (folder, uid) when possible
+    // and no-op otherwise. Plan is to remove the stubs once every caller has
+    // been migrated to the (uid, folderId) form.
+    /** Mark a local row as "delete pending server confirmation". The row
+     *  stays visible (UI greys / strikes it through) until the server
+     *  confirms via QRESYNC VANISHED or its UID drops out of the set-diff. */
+    setMessagePendingDelete(accountId, uid, folderId) {
+        try {
+            this.db.prepare(`UPDATE message_folders SET pending_delete = 1
+                 WHERE folder_id = ? AND uid = ?
+                   AND message_row_id IN (SELECT id FROM messages WHERE account_id = ?)`).run(folderId, uid, accountId);
+        }
+        catch (e) {
+            console.error(`  [pending-delete] failed to mark ${accountId}/${folderId}/${uid}: ${e.message}`);
+        }
+    }
+    /** Clear the pending-delete flag — used when the IMAP MOVE/EXPUNGE is
+     *  refused by the server and the row should revert to a normal visible
+     *  state, and by Ctrl-Z undelete. */
+    clearMessagePendingDelete(accountId, uid, folderId) {
+        try {
+            this.db.prepare(`UPDATE message_folders SET pending_delete = 0
+                 WHERE folder_id = ? AND uid = ?
+                   AND message_row_id IN (SELECT id FROM messages WHERE account_id = ?)`).run(folderId, uid, accountId);
+        }
+        catch (e) {
+            console.error(`  [pending-delete] failed to clear ${accountId}/${folderId}/${uid}: ${e.message}`);
+        }
+    }
+    /** Query: is this (folder, uid) pending server-side delete? */
+    isMessagePendingDelete(accountId, uid, folderId) {
+        const row = this.db.prepare(`SELECT mf.pending_delete
+             FROM message_folders mf
+             JOIN messages m ON m.id = mf.message_row_id
+             WHERE mf.folder_id = ? AND mf.uid = ? AND m.account_id = ?
+             LIMIT 1`).get(folderId, uid, accountId);
+        return !!row && row.pending_delete === 1;
+    }
+    // ── Legacy tombstone API — stubs for backwards compatibility ────────────
+    // TODO(tombstone-removal): once all call sites use the (uid, folderId)
+    // pending_delete API, delete these stubs and drop the tombstones table.
+    /** @deprecated — superseded by setMessagePendingDelete. Retained as a
+     *  no-op so legacy delete paths still compile; the table is preserved
+     *  but never read by the sync path anymore. */
     addTombstone(accountId, messageId, subject = "") {
         if (!messageId)
             return;
@@ -706,16 +768,42 @@ export class MailxDB {
             console.error(`  [tombstones] failed to record ${messageId}: ${e.message}`);
         }
     }
-    /** Is this Message-ID tombstoned for this account? */
+    /** Is this Message-ID tombstoned for this account? Tombstones suppress
+     *  re-import of a row the user just deleted/moved while the server-side
+     *  IMAP action is still in flight; without this, the moved-out source
+     *  folder would re-insert the message on the next sync (server still
+     *  sees the UID; mailx has no other way to know "I just moved this").
+     *
+     *  Lifetime: created at the local-delete/move moment, removed on
+     *  successful IMAP action complete OR on PERMANENT IMAP action failure.
+     *  The failure-clear is the 2026-05-13 fix for the "tombstones outlive
+     *  failed deletes" bug — `failSyncAction` calls `clearTombstoneForUid`
+     *  after the final retry attempt so the user sees the row reappear on
+     *  the next sync (server still has it, mailx now agrees). QRESYNC
+     *  servers don't need this fallback because VANISHED is authoritative;
+     *  tombstones are no-ops on the QRESYNC fast path. */
     hasTombstone(accountId, messageId) {
         if (!messageId)
             return false;
         const row = this.db.prepare("SELECT 1 FROM tombstones WHERE account_id = ? AND message_id = ? LIMIT 1").get(accountId, messageId);
         return !!row;
     }
-    /** Remove a tombstone — used by "undelete" (Ctrl-Z) so a subsequent sync
-     *  re-imports the message as normal. Also lets the user recover from a
-     *  mistaken local delete. */
+    /** Clear the tombstone for the message currently at (accountId, uid,
+     *  folderId). Used by the sync-action failure path: when an IMAP MOVE
+     *  or EXPUNGE fails terminally, the row is still on the server and the
+     *  user should see it again — so the suppression must lift. The lookup
+     *  is by (accountId, uid, folderId) → message_id, since the action
+     *  table stores UID not Message-ID. No-op if the row no longer exists
+     *  (concurrent server-side EXPUNGE etc.). */
+    clearTombstoneForUid(accountId, uid, folderId) {
+        const env = this.getMessageByUid(accountId, uid, folderId);
+        if (!env?.messageId)
+            return;
+        this.removeTombstone(accountId, env.messageId);
+    }
+    /** @deprecated — use clearMessagePendingDelete instead. Retained as a
+     *  no-op for legacy callers (Ctrl-Z undelete paths still work because
+     *  their sibling clearMessagePendingDelete is called). */
     removeTombstone(accountId, messageId) {
         if (!messageId)
             return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-store",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",

package/parse-serial.d.ts

@@ -27,7 +27,8 @@
  * pool is built.
  */
 import { type ParsedMail, type Source } from "mailparser";
-/** Serialized wrapper around `mailparser.simpleParser`. Drop-in replacement —
- *  same signature, same return value. */
-export declare function parseSerial(source: Source): Promise<ParsedMail>;
+/** Serialized wrapper around `mailparser.simpleParser`. `priority` defaults
+ *  to "foreground" — only sync/background callers should pass "background"
+ *  so user clicks aren't stuck behind a back-fill. */
+export declare function parseSerial(source: Source, priority?: "foreground" | "background"): Promise<ParsedMail>;
 //# sourceMappingURL=parse-serial.d.ts.map

package/parse-serial.js

@@ -27,12 +27,42 @@
  * pool is built.
  */
 import { simpleParser } from "mailparser";
-let _chain = Promise.resolve();
-/** Serialized wrapper around `mailparser.simpleParser`. Drop-in replacement —
- *  same signature, same return value. */
-export async function parseSerial(source) {
-    const queued = _chain.then(() => simpleParser(source));
-    _chain = queued.catch(() => undefined);
-    return queued;
+const _head = []; // UI / foreground — drained first
+const _tail = []; // sync / background
+let _pumping = false;
+async function pump() {
+    if (_pumping)
+        return;
+    _pumping = true;
+    try {
+        for (;;) {
+            const next = _head.shift() ?? _tail.shift();
+            if (!next)
+                break;
+            try {
+                const parsed = await simpleParser(next.source);
+                next.resolve(parsed);
+            }
+            catch (e) {
+                next.reject(e);
+            }
+        }
+    }
+    finally {
+        _pumping = false;
+    }
+}
+/** Serialized wrapper around `mailparser.simpleParser`. `priority` defaults
+ *  to "foreground" — only sync/background callers should pass "background"
+ *  so user clicks aren't stuck behind a back-fill. */
+export async function parseSerial(source, priority = "foreground") {
+    return new Promise((resolve, reject) => {
+        const entry = { source, resolve, reject };
+        if (priority === "foreground")
+            _head.push(entry);
+        else
+            _tail.push(entry);
+        pump();
+    });
 }
 //# sourceMappingURL=parse-serial.js.map