@bobfrankston/mailx-imap 0.1.94 → 0.1.95

package/index.js

@@ -3386,24 +3386,56 @@ export class ImapManager extends EventEmitter {
                                             const raw = Buffer.from(source, "utf-8");
                                             const bodyPath = await this.bodyStore.putMessage(accountId, folderId, uid, raw);
                                             const parsed = await extractPreview(source);
-                                            this.db.updateBodyMeta(accountId, folderId, uid, bodyPath, parsed.hasAttachments, parsed.preview);
-                                            this.emit("bodyCached", accountId, uid);
-                                            this.clearPrefetchEmpty(accountId, folderId, uid); // healed — drop stale backoff
-                                            counters.totalFetched++;
-                                            madeProgress = true;
+                                            // The body_path DB write races the main thread's
+                                            // writer (two-writer WAL contention since sync
+                                            // moved to its own thread). That's TRANSIENT —
+                                            // the .eml is already on disk; only this UPDATE
+                                            // is losing the lock. Retry with backoff instead
+                                            // of treating it as a poison body. Backing a
+                                            // momentary lock off for 5m→12h was exactly why
+                                            // prefetched bodies "weren't happening" (Bob
+                                            // 2026-06-14): the .eml sat on disk but body_path
+                                            // never landed, so the row looked un-downloaded
+                                            // AND was suppressed from re-fetch.
+                                            let wrote = false;
+                                            for (let attempt = 0; attempt < 4 && !wrote; attempt++) {
+                                                try {
+                                                    this.db.updateBodyMeta(accountId, folderId, uid, bodyPath, parsed.hasAttachments, parsed.preview);
+                                                    wrote = true;
+                                                }
+                                                catch (we) {
+                                                    const locked = /database is locked|sqlite_busy|busy/i.test(String(we?.message || we));
+                                                    if (locked && attempt < 3) {
+                                                        await new Promise(r => setTimeout(r, 300 * (attempt + 1)));
+                                                        continue;
+                                                    }
+                                                    if (locked) {
+                                                        // Still locked — leave the UID
+                                                        // un-backed-off so the next tick heals it.
+                                                        console.error(`  [prefetch] ${accountId}/${uid}: body_path write still locked after retries — retry next tick`);
+                                                    }
+                                                    else {
+                                                        // Genuine write failure (corrupt body etc.) — back off.
+                                                        console.error(`  [prefetch] ${accountId}/${uid}: store write failed: ${we?.message || we}`);
+                                                        this.markPrefetchEmpty(accountId, folderId, uid);
+                                                    }
+                                                    break;
+                                                }
+                                            }
+                                            if (wrote) {
+                                                this.emit("bodyCached", accountId, uid);
+                                                this.clearPrefetchEmpty(accountId, folderId, uid); // healed — drop stale backoff
+                                                counters.totalFetched++;
+                                                madeProgress = true;
+                                            }
                                         }
                                         catch (e) {
                                             console.error(`  [prefetch] ${accountId}/${uid}: store write failed: ${e.message}`);
-                                            // Back off this UID. A corrupt body (the
-                                            // putMessage guard rejecting an IMAP command
-                                            // leaked into the FETCH response — iflow
-                                            // protocol desync) was NOT marked, so the
-                                            // same poisoned UID got re-fetched every
-                                            // prefetch cycle forever, spamming the log
-                                            // and wasting fetch turns (Bob 2026-05-28
-                                            // "why is prefetching still broken" — UID
-                                            // 59686 failing on a loop). markPrefetchEmpty
-                                            // applies the 5m→30m→2h→12h backoff.
+                                            // putMessage / extractPreview failure (e.g. a
+                                            // corrupt body — an IMAP command leaked into the
+                                            // FETCH response). Genuine poison: back off
+                                            // 5m→30m→2h→12h so it isn't re-fetched on a loop
+                                            // (Bob 2026-05-28, UID 59686).
                                             this.markPrefetchEmpty(accountId, folderId, uid);
                                         }
                                     })());

package/package.json

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