@bobfrankston/rmfmail 1.1.97 → 1.1.99

package/packages/mailx-service/sync-queue.ts

@@ -33,6 +33,17 @@ interface BodyFetchKey { accountId: string; folderId: number; uid: number; lane:
 
 export class SyncQueue {
     private bodyFetches = new Map<string, BodyFetchKey>();
+    /** Per-draft serialization slot. Autosave fires every ~2 s but an IMAP
+     *  search-delete-append cycle takes longer; unserialized pushes
+     *  overlapped, each one's "find the stale copy" running before a
+     *  sibling's "append" — so neither saw the other's new copy and the
+     *  Drafts folder filled with dozens of duplicates (Bob 2026-05-19).
+     *  One push in flight per draft; while it runs, only the LATEST queued
+     *  raw message is kept (intermediate autosaves are superseded). */
+    private draftPushes = new Map<string, {
+        inFlight: boolean;
+        pending: { rawMessage: string; previousDraftUid?: number } | null;
+    }>();
     /** Per-account debounce timers. Multiple rapid enqueues (3 flag toggles,
      *  bulk move/delete) coalesce into one processSyncActions drain after
      *  DRAIN_DEBOUNCE_MS. Was previously in ImapManager.debounceSyncActions;
@@ -97,10 +108,34 @@ export class SyncQueue {
      *  bytes. The reconciler retries on transient IMAP failure via the
      *  existing sync_actions backoff after first failure. */
     enqueueDraftPush(accountId: string, rawMessage: string, previousDraftUid?: number, draftId?: string): void {
-        this.imapManager.saveDraft(accountId, rawMessage, previousDraftUid, draftId).catch((e: any) => {
-            console.error(`  [sync-queue] draft push deferred (${draftId}): ${e?.message || e}`);
-            this.imapManager.emit("draftSaveDeferred", { accountId, draftId, error: String(e?.message || e) });
-        });
+        const key = `${accountId}:${draftId || ""}`;
+        let slot = this.draftPushes.get(key);
+        if (slot && slot.inFlight) {
+            // A push is already running for this draft — supersede: keep only
+            // the newest content. The in-flight push finishes, then this runs.
+            slot.pending = { rawMessage, previousDraftUid };
+            return;
+        }
+        if (!slot) { slot = { inFlight: false, pending: null }; this.draftPushes.set(key, slot); }
+        slot.inFlight = true;
+        const run = (raw: string, prevUid?: number): void => {
+            this.imapManager.saveDraft(accountId, raw, prevUid, draftId)
+                .catch((e: any) => {
+                    console.error(`  [sync-queue] draft push deferred (${draftId}): ${e?.message || e}`);
+                    this.imapManager.emit("draftSaveDeferred", { accountId, draftId, error: String(e?.message || e) });
+                })
+                .finally(() => {
+                    const next = slot!.pending;
+                    slot!.pending = null;
+                    if (next) {
+                        run(next.rawMessage, next.previousDraftUid);   // drain the coalesced save
+                    } else {
+                        slot!.inFlight = false;
+                        this.draftPushes.delete(key);
+                    }
+                });
+        };
+        run(rawMessage, previousDraftUid);
     }
 
     /** Queue an outbox send. Today the outbox/<acct>/*.ltr directory IS