@bobfrankston/rmfmail 1.0.589 → 1.0.592

package/packages/mailx-imap/index.ts

@@ -1159,21 +1159,13 @@ export class ImapManager extends EventEmitter {
                 const missingUids = allServerUids.filter((uid: number) =>
                     !existingSet.has(uid) && !newSet.has(uid)
                 );
-                // Backfill chunk size: ops queue yields between chunks so
-                // a click-time body fetch can interleave. 100 UIDs per
-                // chunk balances throughput (one FETCH command per chunk)
-                // against latency (a chunk takes 1-3s on Dovecot, which
-                // is the worst-case wait an interactive click endures).
-                // The 500-chunk version held the ops queue for the
-                // entire backfill — Bob 2026-05-08 saw a click-to-render
-                // wait of 100+ minutes on a busy backfill of the IP
-                // folder.
+                // Backfill chunk size. Use the passed-in `client` directly
+                // (NOT a nested withConnection) — syncFolder is now wrapped
+                // in withConnection at the call site, so the slow lane is
+                // already locked for our duration. A nested withConnection
+                // would deadlock waiting for the slot we hold.
                 const BACKFILL_CHUNK_SIZE = 100;
                 if (missingUids.length > 0 && missingUids.length <= 5000) {
-                    // For the log line we report a count; computing
-                    // min/max via a spread (`Math.min(...arr)`) blows V8's
-                    // argument limit on folders with tens of thousands of
-                    // UIDs. Use a manual reduce.
                     let minU = existingUids[0] ?? 0;
                     for (let i = 1; i < existingUids.length; i++) if (existingUids[i] < minU) minU = existingUids[i];
                     console.log(`  ${folder.path}: ${missingUids.length} server-only UIDs (local lowest=${minU}, highest=${highestUid}) — fetching`);
@@ -1181,40 +1173,22 @@ export class ImapManager extends EventEmitter {
                     for (let i = 0; i < missingUids.length; i += BACKFILL_CHUNK_SIZE) {
                         const chunk = missingUids.slice(i, i + BACKFILL_CHUNK_SIZE);
                         const range = chunk.join(",");
-                        // Each chunk gets its own withConnection slow-lane
-                        // turn so any fast-lane click queued in the
-                        // meantime gets serviced between chunks. The
-                        // outer `client` param is bypassed here; the
-                        // queue-managed client is the same persistent
-                        // ops client (getOpsClient).
-                        const recovered = await this.withConnection(accountId, async (c) =>
-                            await (c as any).fetchMessages(folder.path, range, { source: false }),
-                            { slow: true },
-                        );
+                        const recovered = await (client as any).fetchMessages(folder.path, range, { source: false });
                         messages.push(...recovered);
                         recoveredTotal += recovered.length;
                         console.log(`  ${folder.path}: fetch ${recoveredTotal}/${missingUids.length}`);
                     }
                 } else if (missingUids.length > 5000) {
                     console.log(`  ${folder.path}: ${missingUids.length} server-only UIDs — capped; will resume next cycle`);
-                    // ASSUMPTION: vanilla IMAP under stable UIDVALIDITY,
-                    // higher UID = later assignment ≈ more recent message.
-                    // True for Dovecot / Cyrus / standard IMAP, which is the
-                    // only place this code path runs (Gmail-API mode goes
-                    // through syncAccountViaApi and doesn't reach here —
-                    // its synthesized hash-UIDs have no temporal meaning).
-                    // If we ever wire this for a non-monotonic UID source,
-                    // sort by date instead — but that means an extra
-                    // fetch-of-INTERNALDATE round-trip, which we avoid for
-                    // free here under the IMAP guarantee.
+                    // Vanilla IMAP under stable UIDVALIDITY: higher UID =
+                    // later assignment ≈ more recent message (Dovecot/
+                    // Cyrus). Gmail-API path is separate (no temporal
+                    // meaning to its hash-UIDs).
                     const cappedSlice = missingUids.sort((a: number, b: number) => b - a).slice(0, 5000);
                     let recoveredTotal = 0;
                     for (let i = 0; i < cappedSlice.length; i += BACKFILL_CHUNK_SIZE) {
                         const chunk = cappedSlice.slice(i, i + BACKFILL_CHUNK_SIZE);
-                        const recovered = await this.withConnection(accountId, async (c) =>
-                            await (c as any).fetchMessages(folder.path, chunk.join(","), { source: false }),
-                            { slow: true },
-                        );
+                        const recovered = await (client as any).fetchMessages(folder.path, chunk.join(","), { source: false });
                         messages.push(...recovered);
                         recoveredTotal += recovered.length;
                         console.log(`  ${folder.path}: fetch ${recoveredTotal}/5000 (capped)`);
@@ -1610,26 +1584,38 @@ export class ImapManager extends EventEmitter {
                 const isTrashChild = folder.path.includes("/") && folder.path.toLowerCase().startsWith("trash");
                 const highestUid = this.db.getHighestUid(accountId, folder.id);
                 if (isTrashChild && highestUid === 0) return;
-                let fresh: any = null;
+                let clientForDiag: any = null;
                 try {
-                    fresh = await this.getOpsClient(accountId);
-                    await Promise.race([
-                        this.syncFolder(accountId, folder.id, fresh),
-                        new Promise((_, reject) => setTimeout(() => {
-                            // C120: pull TCP transport diagnostics into the
-                            // per-folder timeout error so the [sync] log
-                            // distinguishes "server stopped responding"
-                            // (sinceLastRead high) from "we never finished
-                            // writing" (writes climbing without reads). Same
-                            // shape iflow-direct emits on its own timeouts.
-                            const d = (fresh as any)?.transport?.diagnostics;
-                            const diag = d
-                                ? ` [conn#${d.connId} r=${d.bytesRead}B w=${d.bytesWritten}B writes=${d.writeCount} sinceLastRead=${d.lastReadAt ? Date.now() - d.lastReadAt : -1}ms]`
-                                : "";
-                            reject(new Error(`per-folder timeout (${PER_FOLDER_TIMEOUT_MS / 1000}s): ${folder.path}${diag}`));
-                        }, PER_FOLDER_TIMEOUT_MS)),
-                    ]);
+                    // Route syncFolder through the slow-lane queue so prefetch
+                    // (also slow lane) and sync take strict turns on the slow
+                    // client. Previously syncOne grabbed `getOpsClient` and
+                    // ran syncFolder directly OUTSIDE the queue; prefetch
+                    // chunks via withConnection raced against it on the same
+                    // client. Symptom: prefetch sent `SELECT INBOX` then sync
+                    // sent `SELECT Sent/Drafts`, then prefetch's `UID FETCH
+                    // <inbox-uids>` ran against Drafts → 0 bodies returned →
+                    // prefetch logs "0/N — NOT pruning" but bodies never
+                    // download. With C123 the fast lane has its own
+                    // independent client, so wrapping sync in slow-lane
+                    // withConnection doesn't block click-time body fetches.
+                    await this.withConnection(accountId, async (client) => {
+                        clientForDiag = client;
+                        await this.syncFolder(accountId, folder.id, client);
+                    }, { slow: true, timeoutMs: PER_FOLDER_TIMEOUT_MS });
                 } catch (e: any) {
+                    // C120: per-folder timeout error appends transport
+                    // diagnostics so the [sync] log distinguishes "server
+                    // stopped responding" (sinceLastRead high) from "we
+                    // never finished writing" (writes climbing without
+                    // reads). The withConnection timeout already includes
+                    // its own message; we annotate further only for the
+                    // timeout path.
+                    if (/timeout/i.test(e?.message || "")) {
+                        const d = (clientForDiag as any)?.transport?.diagnostics;
+                        if (d) {
+                            e.message = `${e.message} [conn#${d.connId} r=${d.bytesRead}B w=${d.bytesWritten}B writes=${d.writeCount} sinceLastRead=${d.lastReadAt ? Date.now() - d.lastReadAt : -1}ms] folder=${folder.path}`;
+                        }
+                    }
                     if (e.responseText?.includes("doesn't exist")) {
                         this.db.deleteFolder(folder.id);
                     } else {

package/packages/mailx-imap/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bobfrankston/mailx-imap",
-  "version": "0.1.29",
+  "version": "0.1.30",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bobfrankston/mailx-imap",
-      "version": "0.1.29",
+      "version": "0.1.30",
       "license": "ISC",
       "dependencies": {
         "@bobfrankston/iflow-direct": "^0.1.27",

package/packages/mailx-imap/package.json

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