@bobfrankston/rmfmail 1.2.77 → 1.2.79

package/packages/mailx-store-web/android-bootstrap.ts

@@ -96,6 +96,11 @@ class AndroidSyncManager implements WebSyncManager {
     // advanced to fetching new mail, so the list stayed stale despite "Synced"
     // (Bob 2026-06-27). Coalesce concurrent calls to one in-flight run.
     private syncAllInflight: Promise<void> | null = null;
+    // Separate guard for the Phase-2/3 background pass (other folders + body
+    // prefetch). It runs DETACHED from the inbox guard so a long folder sweep
+    // can't make the 60s poll skip the inbox refresh (new mail must keep
+    // flowing). One background pass at a time — overlapping triggers no-op.
+    private bgSyncInflight: Promise<void> | null = null;
 
     constructor(
         private db: WebMailxDB,
@@ -164,50 +169,65 @@ class AndroidSyncManager implements WebSyncManager {
     }
 
     async syncAll(): Promise<void> {
-        // Single-flight: coalesce overlapping triggers (boot / 60s interval /
-        // resume) into one run so they can't stack and thrash the main thread.
+        // The inbox guard covers ONLY Phase 1 (inbox sync). Overlapping triggers
+        // coalesce so they can't thrash the single main thread.
         if (this.syncAllInflight) {
-            console.log("[sync] syncAll already in flight — coalescing this trigger");
+            console.log("[sync] inbox sync already in flight — coalescing this trigger");
             return this.syncAllInflight;
         }
         const t0 = Date.now();
-        console.log("[sync] syncAll START");
-        this.syncAllInflight = this._syncAllImpl()
-            .catch((e: any) => { console.error(`[sync] syncAll error: ${e?.message || e}`); })
+        console.log("[sync] syncAll START (inbox phase)");
+        this.syncAllInflight = this._syncInboxes()
+            .catch((e: any) => { console.error(`[sync] inbox sync error: ${e?.message || e}`); })
             .finally(() => {
-                console.log(`[sync] syncAll DONE in ${Date.now() - t0}ms`);
+                console.log(`[sync] inbox phase DONE in ${Date.now() - t0}ms`);
                 this.syncAllInflight = null;
             });
+        // Phase 2/3 (other folders + body prefetch) run DETACHED, under their own
+        // guard — they must not hold the inbox guard, or a slow folder sweep would
+        // make the next 60s poll skip new inbox mail.
+        this._kickBackgroundSync();
         return this.syncAllInflight;
     }
 
-    private async _syncAllImpl(): Promise<void> {
-        const accounts = this.db.getAccounts();
-        vlog(`syncAll: ${accounts.length} accounts in DB: ${accounts.map(a => a.id).join(",")}`);
+    /** Phase 1: sync every account's INBOX IN PARALLEL so a slow account (e.g.
+     *  Gmail's metadata fetch, or an auth-failing IMAP account) can't delay new
+     *  mail for the others. Each account is time-boxed; network fetches overlap
+     *  even though JS is single-threaded (the awaits yield). */
+    private async _syncInboxes(): Promise<void> {
+        const accounts = this.db.getAccounts().filter(a => this.providers.has(a.id));
+        vlog(`syncInboxes: ${accounts.length} accounts: ${accounts.map(a => a.id).join(",")}`);
+        await Promise.all(accounts.map(account =>
+            withTimeout(`${account.id} inbox`, 60000, async () => {
+                const folders = await this.syncFolders(account.id);
+                const inbox = folders.find(f => f.specialUse === "inbox");
+                if (inbox) {
+                    console.log(`[sync] ${account.id}: fetching INBOX (folderId=${inbox.id})`);
+                    await this.syncFolder(account.id, inbox.id);
+                    console.log(`[sync] ${account.id}: INBOX fetch done`);
+                    emitEvent({ type: "syncComplete", accountId: account.id });
+                }
+            }).catch((e: any) => console.error(`[sync] ${account.id} inbox: ${e?.message || e}`)),
+        ));
+    }
 
-        // Phase 1: Sync INBOX for every account first — user sees new mail fast.
-        // Each account is time-boxed so one hung account can't starve the rest.
-        for (const account of accounts) {
-            if (!this.providers.has(account.id)) continue;
-            try {
-                await withTimeout(`${account.id} inbox`, 60000, async () => {
-                    const folders = await this.syncFolders(account.id);
-                    const inbox = folders.find(f => f.specialUse === "inbox");
-                    if (inbox) {
-                        console.log(`[sync] ${account.id}: fetching INBOX (folderId=${inbox.id})`);
-                        await this.syncFolder(account.id, inbox.id);
-                        console.log(`[sync] ${account.id}: INBOX fetch done`);
-                        emitEvent({ type: "syncComplete", accountId: account.id });
-                    }
-                });
-            } catch (e: any) {
-                console.error(`[sync] ${account.id} inbox: ${e.message}`);
-            }
-        }
+    /** Phase 2 + 3: remaining folders, then body prefetch. Runs in the
+     *  background under its own single-flight guard. */
+    private _kickBackgroundSync(): void {
+        if (this.bgSyncInflight) return;
+        const t0 = Date.now();
+        this.bgSyncInflight = this._syncRemainingAndPrefetch()
+            .catch((e: any) => console.error(`[sync] background sweep error: ${e?.message || e}`))
+            .finally(() => {
+                console.log(`[sync] background sweep DONE in ${Date.now() - t0}ms`);
+                this.bgSyncInflight = null;
+            });
+    }
 
-        // Phase 2: Remaining folders (sent, drafts, trash, then everything else).
+    private async _syncRemainingAndPrefetch(): Promise<void> {
+        const accounts = this.db.getAccounts().filter(a => this.providers.has(a.id));
+        // Phase 2: remaining folders (per account, per folder time-boxed).
         for (const account of accounts) {
-            if (!this.providers.has(account.id)) continue;
             try {
                 const folders = this.db.getFolders(account.id);
                 const remaining = folders.filter(f => f.specialUse !== "inbox");
@@ -219,16 +239,11 @@ class AndroidSyncManager implements WebSyncManager {
                 emitEvent({ type: "syncComplete", accountId: account.id });
             } catch (e: any) {
                 console.error(`[sync] ${account.id}: ${e.message}`);
-                vlog(`syncAll: ${account.id} ERROR: ${e.message}`);
                 emitEvent({ type: "syncError", accountId: account.id, error: e.message });
             }
         }
-
-        // Phase 3: background body prefetch. Fire-and-forget — sync itself is
-        // already done and the UI doesn't wait on this. Per-account guard means
-        // a slow account can't block a fast one.
+        // Phase 3: body prefetch (fire-and-forget per account).
         for (const account of accounts) {
-            if (!this.providers.has(account.id)) continue;
             this.prefetchBodies(account.id).catch(e =>
                 console.error(`[prefetch] ${account.id}: ${e.message}`));
         }
@@ -394,11 +409,27 @@ class AndroidSyncManager implements WebSyncManager {
         emitEvent({ type: "syncProgress", accountId, phase: `sync:${folder.path}`, progress: 0 });
         const highestUid = this.db.getHighestUid(accountId, folderId);
         const startDate = new Date(Date.now() - 30 * 86400000);
+        const account = this.db.getAccounts().find(a => a.id === accountId);
+        const isGoogle = !!account && isGoogleAccount(account);
 
         let messages: ProviderMessage[];
         if (highestUid > 0) {
-            messages = await provider.fetchSince(folder.path, highestUid, { source: false });
-            messages = messages.filter(m => m.uid > highestUid);
+            const opts: { source: boolean; knownUids?: Set<number> } = { source: false };
+            if (isGoogle) {
+                // Gmail re-lists a recent page (IDs aren't monotonic). Give it
+                // the set of UIDs we already have so it fetches only new ones
+                // instead of re-pulling ~200 every sync (Bob 2026-06-27).
+                opts.knownUids = new Set(this.db.getUidsForFolder(accountId, folderId));
+            }
+            messages = await provider.fetchSince(folder.path, highestUid, opts);
+            // IMAP UIDs are monotonic — keep the high-water guard. For Gmail the
+            // knownUids skip already returned only NEW messages; applying
+            // `uid > highestUid` to Gmail's HASH uids is a lottery that wrongly
+            // drops new mail whose hash falls below the mark (the long-standing
+            // "Gmail new messages missing" bug).
+            if (!isGoogle) {
+                messages = messages.filter(m => m.uid > highestUid);
+            }
         } else {
             const tomorrow = new Date(Date.now() + 86400000);
             messages = await provider.fetchByDate(folder.path, startDate, tomorrow, { source: false });

package/packages/mailx-store-web/package.json

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