@bobfrankston/mailx 1.0.382 → 1.0.383

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.382",
+  "version": "1.0.383",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -39,7 +39,7 @@
     "@bobfrankston/tcp-transport": "^0.1.4",
     "@bobfrankston/node-tcp-transport": "^0.1.4",
     "@bobfrankston/smtp-direct": "^0.1.4",
-    "@bobfrankston/mailx-sync": "^0.1.8"
+    "@bobfrankston/mailx-sync": "^0.1.9"
   },
   "devDependencies": {
     "@types/mailparser": "^3.4.6"
@@ -103,7 +103,7 @@
       "@bobfrankston/tcp-transport": "^0.1.4",
       "@bobfrankston/node-tcp-transport": "^0.1.4",
       "@bobfrankston/smtp-direct": "^0.1.4",
-      "@bobfrankston/mailx-sync": "^0.1.8"
+      "@bobfrankston/mailx-sync": "^0.1.9"
     }
   }
 }

package/packages/mailx-imap/index.d.ts

@@ -227,6 +227,20 @@ export declare class ImapManager extends EventEmitter {
      *  prefetch session alongside any still in flight, blowing through Gmail's
      *  per-minute quota and racing on disk writes. One prefetch per account. */
     private prefetchingAccounts;
+    /** Per-folder error cooldowns — `accountId:folderPath` → [timestamps].
+     *  Used to skip folders that repeatedly time out (Dovecot on slow shared
+     *  hosting SELECTs big `_Spam` / archive folders at 300s+ latency; the
+     *  prefetch error budget was burning out on a handful of bad folders
+     *  before the INBOX could finish). A folder with 2+ errors in the last
+     *  15 minutes is skipped until the cooldown passes. User-reported via
+     *  log analysis 2026-04-23: bobma prefetch timing out on Added2.organizations,
+     *  Added2.technews, _Spam, "Prefirst.Jerry's Retreat", Added2.zines. */
+    private folderErrorCooldown;
+    private readonly FOLDER_ERROR_WINDOW_MS;
+    private readonly FOLDER_ERROR_THRESHOLD;
+    private shouldSkipFolder;
+    private recordFolderError;
+    private clearFolderErrors;
     private prefetchBodies;
     private _prefetchBodies;
     /** Get the body store for direct access */

package/packages/mailx-imap/index.js

@@ -1925,6 +1925,34 @@ export class ImapManager extends EventEmitter {
      *  prefetch session alongside any still in flight, blowing through Gmail's
      *  per-minute quota and racing on disk writes. One prefetch per account. */
     prefetchingAccounts = new Set();
+    /** Per-folder error cooldowns — `accountId:folderPath` → [timestamps].
+     *  Used to skip folders that repeatedly time out (Dovecot on slow shared
+     *  hosting SELECTs big `_Spam` / archive folders at 300s+ latency; the
+     *  prefetch error budget was burning out on a handful of bad folders
+     *  before the INBOX could finish). A folder with 2+ errors in the last
+     *  15 minutes is skipped until the cooldown passes. User-reported via
+     *  log analysis 2026-04-23: bobma prefetch timing out on Added2.organizations,
+     *  Added2.technews, _Spam, "Prefirst.Jerry's Retreat", Added2.zines. */
+    folderErrorCooldown = new Map();
+    FOLDER_ERROR_WINDOW_MS = 15 * 60_000;
+    FOLDER_ERROR_THRESHOLD = 2;
+    shouldSkipFolder(accountId, folderPath) {
+        const key = `${accountId}:${folderPath}`;
+        const now = Date.now();
+        const errors = (this.folderErrorCooldown.get(key) || [])
+            .filter(t => now - t < this.FOLDER_ERROR_WINDOW_MS);
+        this.folderErrorCooldown.set(key, errors);
+        return errors.length >= this.FOLDER_ERROR_THRESHOLD;
+    }
+    recordFolderError(accountId, folderPath) {
+        const key = `${accountId}:${folderPath}`;
+        const arr = this.folderErrorCooldown.get(key) || [];
+        arr.push(Date.now());
+        this.folderErrorCooldown.set(key, arr);
+    }
+    clearFolderErrors(accountId, folderPath) {
+        this.folderErrorCooldown.delete(`${accountId}:${folderPath}`);
+    }
     async prefetchBodies(accountId) {
         if (this.prefetchingAccounts.has(accountId))
             return;
@@ -2061,10 +2089,26 @@ export class ImapManager extends EventEmitter {
                 let client = null;
                 try {
                     client = await this.createClientWithLimit(accountId);
-                    for (const [folderId, uids] of byFolder) {
+                    // INBOX-first ordering so the folder the user actually looks at
+                    // gets its bodies even if a later folder eats the error budget.
+                    const orderedFolders = Array.from(byFolder.entries()).sort(([aid], [bid]) => {
+                        const af = folders.find(f => f.id === aid);
+                        const bf = folders.find(f => f.id === bid);
+                        const ai = af?.specialUse === "inbox" ? 0 : 1;
+                        const bi = bf?.specialUse === "inbox" ? 0 : 1;
+                        return ai - bi;
+                    });
+                    for (const [folderId, uids] of orderedFolders) {
                         const folder = folders.find(f => f.id === folderId);
                         if (!folder)
                             continue;
+                        // Skip folders that have repeatedly timed out — keeps one
+                        // slow folder from burning the whole error budget and
+                        // starving the folder the user is actually looking at.
+                        if (this.shouldSkipFolder(accountId, folder.path)) {
+                            console.log(`  [prefetch] ${accountId}: skipping ${folder.path} (recent timeouts — cooling down)`);
+                            continue;
+                        }
                         const received = new Set();
                         // onBody fires synchronously as each message streams in from the server.
                         // Disk/DB writes are kicked off fire-and-forget; we await them after the
@@ -2091,10 +2135,13 @@ export class ImapManager extends EventEmitter {
                                 })());
                             });
                             batchSucceeded = true;
+                            // Folder responded — clear its error history.
+                            this.clearFolderErrors(accountId, folder.path);
                         }
                         catch (e) {
                             console.error(`  [prefetch] ${accountId} folder ${folder.path}: batch fetch failed: ${e.message}`);
                             counters.errors++;
+                            this.recordFolderError(accountId, folder.path);
                             if (counters.errors >= ERROR_BUDGET)
                                 break;
                         }