@bobfrankston/mailx-imap 0.1.24 → 0.1.25

package/index.d.ts

@@ -5,7 +5,7 @@
  */
 import type { TransportFactory } from "@bobfrankston/tcp-transport";
 import { MailxDB, FileMessageStore } from "@bobfrankston/mailx-store";
-import type { AccountConfig, MessageEnvelope, EmailAddress, Folder } from "@bobfrankston/mailx-types";
+import type { AccountConfig, MessageEnvelope, Folder } from "@bobfrankston/mailx-types";
 import { EventEmitter } from "node:events";
 /** Events emitted by the IMAP manager */
 export interface ImapManagerEvents {
@@ -336,31 +336,6 @@ export declare class ImapManager extends EventEmitter {
     processSyncActions(accountId: string): Promise<void>;
     /** Find a folder by specialUse, case-insensitive */
     private findFolder;
-    /** Optimistic local-first Sent insert: write a row into the local DB's
-     *  Sent folder the moment the user hits Send, so the list reflects it
-     *  immediately instead of waiting for SMTP + IMAP-APPEND + syncFolder
-     *  (five server round-trips against a Dovecot that caps at 20 conns).
-     *
-     *  Uses a synthetic negative UID so it can't collide with a real APPENDUID
-     *  (which is always positive). When the real sync eventually picks the
-     *  message up in Sent with the server's UID, `db.upsertMessage` spots
-     *  the Message-ID match and rebinds the existing row's UID — no duplicate.
-     *  Negative UID also makes the row render pink (getMessages flags uid<0
-     *  as pending) so the user sees it's not-yet-reconciled.
-     *
-     *  Best-effort — any failure path (no Sent folder yet, parse error, store
-     *  write error) is logged and swallowed; the send itself is unaffected. */
-    insertOptimisticSentRow(accountId: string, envelope: {
-        messageId: string;
-        inReplyTo: string;
-        references: string[];
-        subject: string;
-        from: EmailAddress;
-        to: EmailAddress[];
-        cc: EmailAddress[];
-        bcc: EmailAddress[];
-        date: number;
-    }, rawMessage: string): Promise<void>;
     /** Copy sent message to the Sent folder via IMAP APPEND */
     copyToSent(accountId: string, rawMessage: string | Buffer): Promise<void>;
     /** Save a draft to the Drafts folder via IMAP APPEND.

package/index.js

@@ -874,7 +874,9 @@ export class ImapManager extends EventEmitter {
         if (!folder)
             throw new Error(`Folder ${folderId} not found`);
         this.emit("syncProgress", accountId, `sync:${folder.path}`, 0);
-        // Get the highest UID we already have for this folder
+        // Get the highest UID we already have for this folder. IMAP UIDs are
+        // monotonically increasing within a UIDVALIDITY (RFC 3501); a
+        // high-water mark is the right anchor for incremental fetch.
         const highestUid = this.db.getHighestUid(accountId, folderId);
         console.log(`  [sync] ${accountId}/${folder.path}: highestUid=${highestUid}, fetching...`);
         let messages;
@@ -2616,67 +2618,10 @@ export class ImapManager extends EventEmitter {
         return folders.find(f => f.specialUse === specialUse ||
             f.path.toLowerCase() === specialUse.toLowerCase()) || null;
     }
-    /** Optimistic local-first Sent insert: write a row into the local DB's
-     *  Sent folder the moment the user hits Send, so the list reflects it
-     *  immediately instead of waiting for SMTP + IMAP-APPEND + syncFolder
-     *  (five server round-trips against a Dovecot that caps at 20 conns).
-     *
-     *  Uses a synthetic negative UID so it can't collide with a real APPENDUID
-     *  (which is always positive). When the real sync eventually picks the
-     *  message up in Sent with the server's UID, `db.upsertMessage` spots
-     *  the Message-ID match and rebinds the existing row's UID — no duplicate.
-     *  Negative UID also makes the row render pink (getMessages flags uid<0
-     *  as pending) so the user sees it's not-yet-reconciled.
-     *
-     *  Best-effort — any failure path (no Sent folder yet, parse error, store
-     *  write error) is logged and swallowed; the send itself is unaffected. */
-    async insertOptimisticSentRow(accountId, envelope, rawMessage) {
-        try {
-            const sent = this.findFolder(accountId, "sent");
-            if (!sent) {
-                console.log(`  [sent-local] no Sent folder for ${accountId}; skipping optimistic row`);
-                return;
-            }
-            // Synthetic UID — negative ms timestamp is monotonic + won't
-            // collide with server UIDs. When the real APPENDUID returns via
-            // sync, upsertMessage's Message-ID rebind swaps this for the
-            // real positive value.
-            const synthUid = -Date.now();
-            const bodyPath = await this.bodyStore.putMessage(accountId, sent.id, synthUid, Buffer.from(rawMessage, "utf-8"));
-            const parsed = await extractPreview(rawMessage);
-            this.db.upsertMessage({
-                accountId,
-                folderId: sent.id,
-                uid: synthUid,
-                messageId: envelope.messageId,
-                inReplyTo: envelope.inReplyTo,
-                references: envelope.references,
-                date: envelope.date,
-                subject: envelope.subject,
-                from: envelope.from,
-                to: envelope.to,
-                cc: envelope.cc,
-                flags: ["\\Seen"],
-                size: rawMessage.length,
-                hasAttachments: parsed.hasAttachments,
-                preview: parsed.preview,
-                bodyPath,
-            });
-            // Folder-tree badge refresh + message-list reload if the user
-            // is currently on Sent — same event shape the sync path emits.
-            // (Was sending {accountId,folderId} as a single arg, which the
-            // IPC forwarder + UI handler decoded as garbage — the optimistic
-            // row landed in the DB but never appeared in the list.)
-            this.db.recalcFolderCounts(sent.id);
-            this.emit("folderCountsChanged", accountId, {});
-            console.log(`  [sent-local] wrote optimistic row in Sent (uid=${synthUid}) for ${accountId}: ${envelope.subject}`);
-        }
-        catch (e) {
-            // Non-fatal — send continues, Sent folder just won't show the
-            // row until the real APPEND-then-sync cycle completes.
-            console.error(`  [sent-local] optimistic insert failed: ${e?.message || e}`);
-        }
-    }
+    // insertOptimisticSentRow removed — the synthetic-negative-UID hack
+    // wedged Sent's high-water-mark sync (a synthetic value polluted MAX(uid)
+    // and made every Sent fetch take a stale code path). Sent is now what
+    // the server has, period. Pending sends live in the Outbox view.
     /** Copy sent message to the Sent folder via IMAP APPEND */
     async copyToSent(accountId, rawMessage) {
         const sent = this.findFolder(accountId, "sent");

package/package.json

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