@bobfrankston/mailx-store 0.1.26 → 0.1.28

package/db.d.ts

@@ -347,6 +347,14 @@ export declare class MailxDB {
     beginTransaction(): void;
     commitTransaction(): void;
     rollbackTransaction(): void;
+    /** Run `fn` inside a transaction — nesting-safe. `node:sqlite` throws on
+     *  a nested BEGIN, and the async chunked walkers (seedContactsFromMessages,
+     *  applyContactsConfig) can interleave with the sync backfill's own
+     *  transactions across their `setImmediate` yields. If a transaction is
+     *  already open this just runs `fn` (its writes join the open txn);
+     *  otherwise it owns a fresh BEGIN/COMMIT. `fn` MUST be synchronous so it
+     *  can't span an await and leave a transaction open across a yield. */
+    runInTxn<T>(fn: () => T): T;
     /** Record an address used in sent mail */
     recordSentAddress(name: string, email: string): void;
     /** True if `email` (lowercased) appears in the active denylist. Cached
@@ -399,7 +407,16 @@ export declare class MailxDB {
      *  Discovered is a single tier; sub-distinctions like sent-vs-received
      *  collapse here because the user-facing UI shows them as one "discovered"
      *  source. Recency-weighted use_count differentiates within the tier. */
-    seedContactsFromMessages(): number;
+    /** ASYNC + chunked. This walks every cached message's address fields —
+     *  on a large account that is hundreds of thousands of rows. The old
+     *  synchronous version did `.all()` on the whole messages table in one
+     *  call, materialising every row and blocking the event loop for tens
+     *  of seconds to minutes (profiled 2026-05-15: 99% of daemon ticks were
+     *  in native SQLite while this ran — every getMessage IPC, every preview
+     *  click, queued behind it; that IS the "loading body takes forever"
+     *  bug). Now keyset-paginated by `m.id` with a `setImmediate` yield
+     *  between pages, so user IPC lands in the gaps. */
+    seedContactsFromMessages(): Promise<number>;
     /** Apply the contents of contacts.jsonc — replaces all preferred-tier rows
      *  with the entries in `preferred[]`, merges `discovered[]` into the local
      *  cache, sets the in-memory denylist, and purges any discovered rows
@@ -428,12 +445,12 @@ export declare class MailxDB {
             useCount?: number;
             lastUsed?: number;
         }[];
-    }): {
+    }): Promise<{
         preferred: number;
         discovered: number;
         purged: number;
         conflicts: string[];
-    };
+    }>;
     /** Build the contacts.jsonc shape from current DB state — for round-trip
      *  to GDrive. Preferred-tier rows come from anything not in the reserved
      *  system sources; discovered comes from `source='discovered'` rows;

package/db.js

@@ -1901,6 +1901,30 @@ export class MailxDB {
     beginTransaction() { this.db.exec("BEGIN"); }
     commitTransaction() { this.db.exec("COMMIT"); }
     rollbackTransaction() { this.db.exec("ROLLBACK"); }
+    /** Run `fn` inside a transaction — nesting-safe. `node:sqlite` throws on
+     *  a nested BEGIN, and the async chunked walkers (seedContactsFromMessages,
+     *  applyContactsConfig) can interleave with the sync backfill's own
+     *  transactions across their `setImmediate` yields. If a transaction is
+     *  already open this just runs `fn` (its writes join the open txn);
+     *  otherwise it owns a fresh BEGIN/COMMIT. `fn` MUST be synchronous so it
+     *  can't span an await and leave a transaction open across a yield. */
+    runInTxn(fn) {
+        if (this.db.isTransaction)
+            return fn();
+        this.db.exec("BEGIN");
+        try {
+            const r = fn();
+            this.db.exec("COMMIT");
+            return r;
+        }
+        catch (e) {
+            try {
+                this.db.exec("ROLLBACK");
+            }
+            catch { /* already rolled back */ }
+            throw e;
+        }
+    }
     // ── Contacts ──
     /** Record an address used in sent mail */
     recordSentAddress(name, email) {
@@ -1992,7 +2016,16 @@ export class MailxDB {
      *  Discovered is a single tier; sub-distinctions like sent-vs-received
      *  collapse here because the user-facing UI shows them as one "discovered"
      *  source. Recency-weighted use_count differentiates within the tier. */
-    seedContactsFromMessages() {
+    /** ASYNC + chunked. This walks every cached message's address fields —
+     *  on a large account that is hundreds of thousands of rows. The old
+     *  synchronous version did `.all()` on the whole messages table in one
+     *  call, materialising every row and blocking the event loop for tens
+     *  of seconds to minutes (profiled 2026-05-15: 99% of daemon ticks were
+     *  in native SQLite while this ran — every getMessage IPC, every preview
+     *  click, queued behind it; that IS the "loading body takes forever"
+     *  bug). Now keyset-paginated by `m.id` with a `setImmediate` yield
+     *  between pages, so user IPC lands in the gaps. */
+    async seedContactsFromMessages() {
         const VALID = /^[^\s<>@]+@[^\s<>@]+\.[^\s<>@]+$/;
         const now = Date.now();
         const agg = new Map();
@@ -2016,57 +2049,75 @@ export class MailxDB {
                 agg.set(email, { name: name || "", cnt: 1, last: date || 0 });
             }
         };
-        // Sent folder: recipients only (skip the user's own From address).
-        const sentRows = this.db.prepare(`SELECT m.to_json, m.cc_json, m.bcc_json, m.date
-             FROM messages m
-             JOIN folders f ON m.folder_id = f.id
-             WHERE f.special_use = 'sent'`).all();
-        for (const r of sentRows) {
-            const date = r.date || 0;
-            for (const field of [r.to_json, r.cc_json, r.bcc_json]) {
-                if (!field)
-                    continue;
-                let parsed;
-                try {
-                    parsed = JSON.parse(field);
-                }
-                catch {
-                    continue;
-                }
-                if (!Array.isArray(parsed))
+        const eatRecipients = (field, date) => {
+            if (!field)
+                return;
+            let parsed;
+            try {
+                parsed = JSON.parse(field);
+            }
+            catch {
+                return;
+            }
+            if (!Array.isArray(parsed))
+                return;
+            for (const a of parsed) {
+                if (!a)
                     continue;
-                for (const a of parsed) {
-                    if (!a)
-                        continue;
-                    bump(a.name || "", a.address || a.email || "", date);
+                bump(a.name || "", a.address || a.email || "", date);
+            }
+        };
+        const yieldLoop = () => new Promise(r => setImmediate(r));
+        const PAGE = 2000;
+        // Sent folder: recipients only (skip the user's own From address).
+        // Keyset pagination by m.id — each page is a bounded `.all()`, and
+        // the event loop is handed back between pages.
+        {
+            const stmt = this.db.prepare(`SELECT m.id AS id, m.to_json, m.cc_json, m.bcc_json, m.date
+                 FROM messages m
+                 JOIN folders f ON m.folder_id = f.id
+                 WHERE f.special_use = 'sent' AND m.id > ?
+                 ORDER BY m.id LIMIT ?`);
+            let lastId = 0;
+            for (;;) {
+                const rows = stmt.all(lastId, PAGE);
+                if (rows.length === 0)
+                    break;
+                for (const r of rows) {
+                    const date = r.date || 0;
+                    eatRecipients(r.to_json, date);
+                    eatRecipients(r.cc_json, date);
+                    eatRecipients(r.bcc_json, date);
                 }
+                lastId = rows[rows.length - 1].id;
+                if (rows.length < PAGE)
+                    break;
+                await yieldLoop();
             }
         }
         // Other folders: From + recipients.
-        const recvRows = this.db.prepare(`SELECT m.from_name, m.from_address, m.to_json, m.cc_json, m.bcc_json, m.date
-             FROM messages m
-             LEFT JOIN folders f ON m.folder_id = f.id
-             WHERE f.special_use IS NULL OR f.special_use != 'sent'`).all();
-        for (const r of recvRows) {
-            const date = r.date || 0;
-            bump(r.from_name, r.from_address, date);
-            for (const field of [r.to_json, r.cc_json, r.bcc_json]) {
-                if (!field)
-                    continue;
-                let parsed;
-                try {
-                    parsed = JSON.parse(field);
-                }
-                catch {
-                    continue;
-                }
-                if (!Array.isArray(parsed))
-                    continue;
-                for (const a of parsed) {
-                    if (!a)
-                        continue;
-                    bump(a.name || "", a.address || a.email || "", date);
+        {
+            const stmt = this.db.prepare(`SELECT m.id AS id, m.from_name, m.from_address, m.to_json, m.cc_json, m.bcc_json, m.date
+                 FROM messages m
+                 LEFT JOIN folders f ON m.folder_id = f.id
+                 WHERE (f.special_use IS NULL OR f.special_use != 'sent') AND m.id > ?
+                 ORDER BY m.id LIMIT ?`);
+            let lastId = 0;
+            for (;;) {
+                const rows = stmt.all(lastId, PAGE);
+                if (rows.length === 0)
+                    break;
+                for (const r of rows) {
+                    const date = r.date || 0;
+                    bump(r.from_name, r.from_address, date);
+                    eatRecipients(r.to_json, date);
+                    eatRecipients(r.cc_json, date);
+                    eatRecipients(r.bcc_json, date);
                 }
+                lastId = rows[rows.length - 1].id;
+                if (rows.length < PAGE)
+                    break;
+                await yieldLoop();
             }
         }
         let added = 0;
@@ -2077,16 +2128,30 @@ export class MailxDB {
                                  name = CASE WHEN name = '' AND ? != '' THEN ? ELSE name END,
                                  updated_at = ?
              WHERE id = ?`);
-        for (const [email, info] of agg) {
-            const existing = this.db.prepare("SELECT id FROM contacts WHERE source = 'discovered' AND lower(email) = ?").get(email);
-            if (!existing) {
-                insStmt.run(info.name, email, info.last, info.cnt, now);
-                added++;
-            }
-            else {
-                updStmt.run(info.cnt, info.last, info.name, info.name, now, existing.id);
-                bumped++;
-            }
+        const findStmt = this.db.prepare("SELECT id FROM contacts WHERE source = 'discovered' AND lower(email) = ?");
+        // Write phase — chunked. Each chunk runs via `db.transaction()`
+        // (one synchronous turn, one commit) rather than raw BEGIN/COMMIT
+        // straddling an `await` — the wrapper is nesting-safe (savepoints)
+        // so it can't collide with the sync backfill's own transactions
+        // when the two interleave across the yield below.
+        const WRITE_CHUNK = 500;
+        const entries = [...agg.entries()];
+        for (let i = 0; i < entries.length; i += WRITE_CHUNK) {
+            const slice = entries.slice(i, i + WRITE_CHUNK);
+            this.runInTxn(() => {
+                for (const [email, info] of slice) {
+                    const existing = findStmt.get(email);
+                    if (!existing) {
+                        insStmt.run(info.name, email, info.last, info.cnt, now);
+                        added++;
+                    }
+                    else {
+                        updStmt.run(info.cnt, info.last, info.name, info.name, now, existing.id);
+                        bumped++;
+                    }
+                }
+            });
+            await yieldLoop();
         }
         if (added > 0 || bumped > 0) {
             console.log(`  [contacts] seed: ${added} new + ${bumped} refreshed (discovered)`);
@@ -2104,7 +2169,7 @@ export class MailxDB {
      *  Discovered rows from the file are MERGED with whatever the local
      *  message-corpus seeder has produced. Each device contributes its
      *  observed addresses; over time GDrive accumulates the union. */
-    applyContactsConfig(cfg) {
+    async applyContactsConfig(cfg) {
         const preferred = Array.isArray(cfg.preferred) ? cfg.preferred : [];
         const denylist = Array.isArray(cfg.denylist) ? cfg.denylist : [];
         const denylistPatterns = Array.isArray(cfg.denylistPatterns) ? cfg.denylistPatterns : [];
@@ -2119,41 +2184,65 @@ export class MailxDB {
             .filter(e => e && e.priority === true && e.email)
             .map(e => e.email);
         this.setPriorityIndex(prioritySenders, priorityDomains);
+        const VALID = /^[^\s<>@]+@[^\s<>@]+\.[^\s<>@]+$/;
+        const now = Date.now();
+        const denySet = new Set(denylist.map(e => (e || "").trim().toLowerCase()).filter(Boolean));
+        const conflicts = [];
+        const yieldLoop = () => new Promise(r => setImmediate(r));
+        const CHUNK = 500;
         // Wipe and rewrite preferred-tier rows owned by contacts.jsonc.
         // The address-book UI's legacy `upsertContact` still writes
         // source='manual' rows; those are owned by the address-book code
         // path, not contacts.jsonc, so we leave them alone here.
-        this.db.exec("DELETE FROM contacts WHERE source NOT IN ('google', 'discovered', 'manual')");
-        const VALID = /^[^\s<>@]+@[^\s<>@]+\.[^\s<>@]+$/;
-        const now = Date.now();
+        // ALL writes below run inside transactions and yield the event
+        // loop between chunks. The prior version did one autocommitting
+        // INSERT/UPDATE per row with NO transaction — on a contacts.jsonc
+        // that has accumulated thousands of `discovered` entries across
+        // devices, that was thousands of fsyncs back-to-back, blocking the
+        // daemon for 25-30 s (profiled 2026-05-15: applyContactsConfig was
+        // ~97% of the wedge). It also re-`prepare()`d a `lower(email)`
+        // full-scan SELECT every iteration. Now: one statement prep, one
+        // up-front map of existing discovered rows (kills the N×N scan),
+        // chunked transactions, yields between chunks.
         const ins = this.db.prepare(`INSERT OR IGNORE INTO contacts (source, name, email, organization, last_used, use_count, updated_at)
              VALUES (?, ?, ?, ?, 0, 0, ?)`);
-        const denySet = new Set(denylist.map(e => (e || "").trim().toLowerCase()).filter(Boolean));
-        const conflicts = [];
         let inserted = 0;
-        for (const entry of preferred) {
-            if (!entry)
-                continue;
-            const email = (entry.email || "").trim();
-            if (!email || !VALID.test(email))
-                continue;
-            if (denySet.has(email.toLowerCase())) {
-                conflicts.push(email);
-                continue;
-            }
-            const source = (entry.source || "preferred").trim() || "preferred";
-            const name = (entry.name || "").trim();
-            const org = (entry.organization || entry.org || "").trim();
-            try {
-                const r = ins.run(source, name, email, org, now);
-                if (r.changes)
-                    inserted++;
+        // runInTxn: nesting-safe and atomic within one synchronous turn, so
+        // these writes can't collide with the sync backfill's transactions
+        // when the two interleave across the yields below.
+        this.runInTxn(() => {
+            this.db.exec("DELETE FROM contacts WHERE source NOT IN ('google', 'discovered', 'manual')");
+            for (const entry of preferred) {
+                if (!entry)
+                    continue;
+                const email = (entry.email || "").trim();
+                if (!email || !VALID.test(email))
+                    continue;
+                if (denySet.has(email.toLowerCase())) {
+                    conflicts.push(email);
+                    continue;
+                }
+                const source = (entry.source || "preferred").trim() || "preferred";
+                const name = (entry.name || "").trim();
+                const org = (entry.organization || entry.org || "").trim();
+                try {
+                    const r = ins.run(source, name, email, org, now);
+                    if (r.changes)
+                        inserted++;
+                }
+                catch { /* dup row, skip */ }
             }
-            catch { /* dup row, skip */ }
-        }
+        });
+        await yieldLoop();
         // Merge discovered[] from cloud into local cache. For each entry:
         // existing row wins on use_count (max), name fills if empty, lastUsed
         // is max. Missing rows are inserted. Denylisted entries skipped.
+        // Existing discovered rows are mapped ONCE up front so the merge is
+        // O(N) hash lookups, not O(N) `lower(email)` table scans.
+        const existingDiscovered = new Map();
+        for (const row of this.db.prepare("SELECT id, lower(email) AS le FROM contacts WHERE source = 'discovered'").all()) {
+            existingDiscovered.set(row.le, row.id);
+        }
         const insDiscovered = this.db.prepare("INSERT INTO contacts (source, name, email, last_used, use_count, updated_at) VALUES ('discovered', ?, ?, ?, ?, ?)");
         const updDiscovered = this.db.prepare(`UPDATE contacts SET use_count = max(use_count, ?),
                                  last_used = max(last_used, ?),
@@ -2161,36 +2250,44 @@ export class MailxDB {
                                  updated_at = ?
              WHERE id = ?`);
         let discoveredAdded = 0;
-        for (const entry of discovered) {
-            if (!entry)
-                continue;
-            const email = (entry.email || "").trim();
-            if (!email || !VALID.test(email))
-                continue;
-            const lower = email.toLowerCase();
-            if (denySet.has(lower))
-                continue;
-            if (isJunkContact(lower, entry.name || ""))
-                continue;
-            const name = (entry.name || "").trim();
-            const useCount = Math.max(0, entry.useCount || 0);
-            const lastUsed = Math.max(0, entry.lastUsed || 0);
-            const existing = this.db.prepare("SELECT id FROM contacts WHERE source = 'discovered' AND lower(email) = ?").get(lower);
-            if (!existing) {
-                insDiscovered.run(name, email, lastUsed, useCount, now);
-                discoveredAdded++;
-            }
-            else {
-                updDiscovered.run(useCount, lastUsed, name, name, now, existing.id);
-            }
+        for (let i = 0; i < discovered.length; i += CHUNK) {
+            const slice = discovered.slice(i, i + CHUNK);
+            this.runInTxn(() => {
+                for (const entry of slice) {
+                    if (!entry)
+                        continue;
+                    const email = (entry.email || "").trim();
+                    if (!email || !VALID.test(email))
+                        continue;
+                    const lower = email.toLowerCase();
+                    if (denySet.has(lower))
+                        continue;
+                    if (isJunkContact(lower, entry.name || ""))
+                        continue;
+                    const name = (entry.name || "").trim();
+                    const useCount = Math.max(0, entry.useCount || 0);
+                    const lastUsed = Math.max(0, entry.lastUsed || 0);
+                    const existingId = existingDiscovered.get(lower);
+                    if (existingId === undefined) {
+                        insDiscovered.run(name, email, lastUsed, useCount, now);
+                        discoveredAdded++;
+                    }
+                    else {
+                        updDiscovered.run(useCount, lastUsed, name, name, now, existingId);
+                    }
+                }
+            });
+            await yieldLoop();
         }
         // Purge discovered rows for any denylisted email.
         const purge = this.db.prepare("DELETE FROM contacts WHERE source = 'discovered' AND lower(email) = ?");
         let purged = 0;
-        for (const e of denySet) {
-            const r = purge.run(e);
-            purged += Number(r.changes || 0);
-        }
+        this.runInTxn(() => {
+            for (const e of denySet) {
+                const r = purge.run(e);
+                purged += Number(r.changes || 0);
+            }
+        });
         if (conflicts.length > 0) {
             console.warn(`  [contacts] config: ${conflicts.length} preferred entries also appear in denylist — denylist wins, entries skipped: ${conflicts.join(", ")}`);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-store",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",
@@ -9,7 +9,7 @@
   },
   "license": "ISC",
   "dependencies": {
-    "@bobfrankston/mailx-types": "^0.1.13",
+    "@bobfrankston/mailx-types": "^0.1.14",
     "@bobfrankston/mailx-settings": "^0.1.17",
     "@bobfrankston/mailx-bus": "^0.1.2",
     "mailparser": "^3.7.2"
@@ -29,7 +29,7 @@
   },
   ".transformedSnapshot": {
     "dependencies": {
-      "@bobfrankston/mailx-types": "^0.1.13",
+      "@bobfrankston/mailx-types": "^0.1.14",
       "@bobfrankston/mailx-settings": "^0.1.17",
       "@bobfrankston/mailx-bus": "^0.1.2",
       "mailparser": "^3.7.2"

package/parse-serial.js

@@ -73,7 +73,10 @@ function getWorker() {
     });
     w.on("error", (e) => {
         // Fatal worker crash — fail every in-flight parse, then null the
-        // singleton so the next call respawns.
+        // singleton so the next call respawns. Logged loudly: a silent
+        // respawn loop forces every Nth parse to eat a fresh cold-start,
+        // which reads as a random multi-second "loading body" stall.
+        console.error(`  [parse-worker] CRASHED (${e.message}) — ${_inflight.size} in-flight parse(s) failed, will respawn`);
         for (const entry of _inflight.values())
             entry.reject(e);
         _inflight.clear();
@@ -81,6 +84,9 @@ function getWorker() {
         signalCompletion();
     });
     w.on("exit", (code) => {
+        // code 0 = clean exit (shouldn't happen — parentPort keeps it alive);
+        // non-zero = crash. Either way the next parse respawns + re-warms.
+        console.warn(`  [parse-worker] exited (code=${code}), ${_inflight.size} in-flight — next parse respawns`);
         if (_inflight.size > 0) {
             const err = new Error(`parse-worker exited (code=${code}) with ${_inflight.size} in-flight`);
             for (const entry of _inflight.values())

package/parse-worker.js

@@ -21,18 +21,43 @@ import { simpleParser } from "mailparser";
 if (!parentPort) {
     throw new Error("parse-worker: must be spawned as a worker, parentPort is null");
 }
-// Self-warmup: parse a synthetic RFC 5322 message at worker startup so V8
-// JIT, libmime / iconv-lite module loading, and mailparser's lazy
-// initialisation all complete *before* the worker accepts its first real
-// request. Sub-50 ms parses become the norm even on the first user click,
-// instead of the 14-25 s cold-start observed when this work happened
-// on-demand. Buffered messages received during warmup queue behind it.
+// Self-warmup: parse a synthetic message at worker startup so V8 JIT,
+// libmime / iconv-lite loading, and mailparser's lazy init all complete
+// *before* the worker accepts its first real request.
+//
+// CRITICAL (Bob 2026-05-15): the warmup message MUST exercise every heavy
+// code path a real email hits, or the cold-start cost just moves to the
+// first real parse. The previous warmup was a trivial text/plain message
+// — it JIT'd the basic path but NOT the HTML pipeline, quoted-printable
+// decode, multipart boundary handling, or attachment extraction. Result:
+// the first real parse (a 96 KB multipart/alternative) took 33 SECONDS
+// in the log — the cold start was never actually absorbed. This warmup
+// message is multipart/mixed → multipart/alternative(text + QP-encoded
+// HTML) + a base64 attachment, with HTML entities and a non-ASCII char,
+// so the first real parse rides warm JIT for all of them.
 const _warmupT0 = Date.now();
-const _warmupPromise = simpleParser(Buffer.from("From: warmup@mailx.local\r\nTo: warmup@mailx.local\r\n"
-    + "Subject: warmup\r\nMIME-Version: 1.0\r\n"
+const _warmupMessage = "From: warmup@mailx.local\r\nTo: warmup@mailx.local\r\n"
+    + "Subject: =?UTF-8?Q?warm=E2=80=91up?=\r\nMIME-Version: 1.0\r\n"
+    + "Content-Type: multipart/mixed; boundary=\"MIX\"\r\n\r\n"
+    + "--MIX\r\n"
+    + "Content-Type: multipart/alternative; boundary=\"ALT\"\r\n\r\n"
+    + "--ALT\r\n"
     + "Content-Type: text/plain; charset=UTF-8\r\n\r\n"
-    + "parse-worker cold-start absorber. Discard.\r\n", "utf8")).then(() => {
-    // Optional: emit a heartbeat so the main thread can log the cost.
+    + "parse-worker cold-start absorber — discard.\r\n"
+    + "--ALT\r\n"
+    + "Content-Type: text/html; charset=UTF-8\r\n"
+    + "Content-Transfer-Encoding: quoted-printable\r\n\r\n"
+    + "<html><body><p>warm=E2=80=91up &amp; discard</p>"
+    + "<blockquote>quoted</blockquote><a href=3D\"http://x\">link</a></body></html>\r\n"
+    + "--ALT--\r\n"
+    + "--MIX\r\n"
+    + "Content-Type: application/octet-stream; name=\"w.bin\"\r\n"
+    + "Content-Transfer-Encoding: base64\r\n"
+    + "Content-Disposition: attachment; filename=\"w.bin\"\r\n\r\n"
+    + "d2FybXVw\r\n"
+    + "--MIX--\r\n";
+const _warmupPromise = simpleParser(Buffer.from(_warmupMessage, "utf8")).then(() => {
+    // Heartbeat so the main thread can log the absorbed cost.
     parentPort.postMessage({ warmupMs: Date.now() - _warmupT0 });
 }).catch(() => { });
 parentPort.on("message", async (msg) => {
@@ -58,7 +83,17 @@ parentPort.on("message", async (msg) => {
             const u = source;
             normalized = Buffer.from(u.buffer, u.byteOffset, u.byteLength);
         }
+        const _t0 = Date.now();
         const result = await simpleParser(normalized);
+        const _ms = Date.now() - _t0;
+        // Worker-side parse time. If THIS is slow, the bug is in simpleParser
+        // on a given input; if this is fast but the main thread still saw a
+        // multi-second `[parse]` figure, the cost is queue wait / respawn —
+        // splitting the two was the open question of the 2026-05-15 hunt.
+        if (_ms > 1000) {
+            const size = Buffer.isBuffer(normalized) ? normalized.byteLength : String(normalized).length;
+            console.warn(`  [parse-worker] simpleParser took ${_ms}ms for ${(size / 1024).toFixed(0)} KB (worker-side, not queue wait)`);
+        }
         parentPort.postMessage({ id, ok: true, result });
     }
     catch (e) {

package/store.d.ts

@@ -41,6 +41,15 @@ export interface StoreMessage extends MessageEnvelope {
         contentId: string;
     }>;
     cached: boolean;
+    /** Disambiguates `cached: false`:
+     *   - bodyOnDisk false → the .eml is NOT on disk; caller should queue
+     *     an IMAP/Gmail fetch.
+     *   - bodyOnDisk true  → the .eml IS on disk; a parse is in flight.
+     *     Caller MUST NOT queue a fetch — just wait for the `bodyAvailable`
+     *     bus event. Queuing a fetch here caused the 10-Hz "Loading body…"
+     *     loop (Bob 2026-05-15): cached:false → MailxService fetched →
+     *     reconciler re-published bodyAvailable → viewer re-called → repeat. */
+    bodyOnDisk: boolean;
     deliveredTo: string;
     returnPath: string;
     listUnsubscribe: string;
@@ -69,6 +78,7 @@ export declare class Store {
     private parsedLru;
     private parsedLruGet;
     private parsedLruPut;
+    private parseInflight;
     private _allowlistCache;
     private _settingsCache;
     private getCachedAllowlist;

package/store.js

@@ -95,6 +95,15 @@ export class Store {
             this.parsedLru.delete(oldest);
         }
     }
+    // In-flight parse coalescing. Concurrent getMessage calls for the same
+    // body (same path|mtime cacheKey) must share ONE parse — otherwise a
+    // viewer that re-requests while the first parse is still queued enqueues
+    // a duplicate, and N retries become N parses stacked in the parse-worker
+    // queue. Observed 2026-05-15: the same .eml parsed 3-4× in a burst, and
+    // a genuine click then waited 25 s behind the pile-up. The map entry is
+    // removed when the parse settles (success OR failure — a failed parse
+    // must not poison the key).
+    parseInflight = new Map();
     // Allowlist + settings caches. Both files live on the GDrive-mounted
     // shared dir; their sync `readFileSync` calls in `loadAllowlist()` and
     // `loadSettings()` can stall for seconds per call. getMessage runs on
@@ -222,11 +231,13 @@ export class Store {
             hasRemoteContent: false, remoteAllowed: allowRemote,
             attachments: [],
             cached: false,
+            bodyOnDisk: false, // overridden to true on the parse-pending return
             deliveredTo: "", returnPath: "",
             listUnsubscribe: "", listUnsubscribeMail: "", listUnsubscribeHttp: "", listUnsubscribeOneClick: false,
             emlPath: "",
             isFlagged,
         };
+        // No body file → caller should queue a fetch (bodyOnDisk stays false).
         if (!storedPath)
             return empty;
         if (!await this.bodyStore.hasByPath(storedPath))
@@ -246,30 +257,46 @@ export class Store {
             // body cached; recompute the volatile fields and overlay.
             return { ...cached, remoteAllowed: allowRemote, isFlagged };
         }
-        let raw;
-        try {
-            raw = await this.bodyStore.readByPath(storedPath);
-        }
-        catch {
-            // File path is in DB but the file is missing — the prefetch
-            // dot is lying. Caller (UI) should mark the row as broken and
-            // the reconciler should re-fetch. Don't crash; return as if
-            // not cached.
-            return empty;
+        // Synchronous parse. The .eml is on disk; read + parse it inline
+        // and return the fully-rendered message. The parse runs on the
+        // parse-worker thread (off the main event loop) — the IPC promise
+        // just awaits the worker's reply, ~50-200 ms on a warm worker.
+        //
+        // 2026-05-15: this REPLACED an async "return envelope now, parse
+        // later, emit bodyAvailable" split. That split overloaded
+        // `cached:false` (was it "no body file" or "parse pending"?),
+        // which made MailxService queue redundant fetches, which churned
+        // the .eml mtime, which invalidated the cache key, which spawned
+        // duplicate parses — a 10 Hz "Loading body…" loop and 30-second
+        // queue-contention parses. Synchronous parse makes the whole
+        // class structurally impossible: getMessage either returns the
+        // body or returns `cached:false` meaning exactly "fetch it."
+        // Coalesce: if another getMessage is already reading+parsing this
+        // exact body, await its parse instead of starting a duplicate.
+        let parsed;
+        const existingParse = this.parseInflight.get(cacheKey);
+        if (existingParse) {
+            parsed = await existingParse;
         }
-        // Parse + sanitize. Same logic as today's MailxService.getMessage,
-        // but executed only when the body is local — never on a fresh
-        // server fetch.
-        const adjusted = sniffAndFixCharset(raw);
-        // simpleParser blocks the event loop while it parses — visible cost
-        // on >100 KB messages. Time it so the log makes the cost concrete:
-        // when this number is high, that's why other IPC calls (the next
-        // message click, the folder-count update tick) stall.
-        const _parseT0 = Date.now();
-        const parsed = await parseSerial(adjusted);
-        const _parseMs = Date.now() - _parseT0;
-        if (_parseMs > 50) {
-            console.log(`  [parse] simpleParser ${_parseMs}ms for ${(raw.length / 1024).toFixed(0)} KB (${storedPath})`);
+        else {
+            const _parseT0 = Date.now();
+            const fresh = (async () => {
+                const raw = await this.bodyStore.readByPath(storedPath);
+                const adjusted = sniffAndFixCharset(raw);
+                const result = await parseSerial(adjusted);
+                const _parseMs = Date.now() - _parseT0;
+                if (_parseMs > 50) {
+                    console.log(`  [parse] simpleParser ${_parseMs}ms for ${(raw.length / 1024).toFixed(0)} KB (${storedPath})`);
+                }
+                return result;
+            })();
+            this.parseInflight.set(cacheKey, fresh);
+            try {
+                parsed = await fresh;
+            }
+            finally {
+                this.parseInflight.delete(cacheKey);
+            }
         }
         let bodyHtml = parsed.html || "";
         const bodyText = parsed.text || "";
@@ -367,19 +394,10 @@ export class Store {
             emlPath: this.bodyStore.absolutePath(storedPath),
             isFlagged,
         };
-        // Memoize the parsed result for subsequent views of the same UID.
-        // `remoteAllowed` and `isFlagged` get re-overlaid on read so a flag
-        // toggle or allowlist edit doesn't require a re-parse to take
-        // effect (see the parsedLruGet path above).
-        //
-        // BUT don't poison the cache with an empty parse — a malformed .eml
-        // or a fetch that left a stub file gives bodyHtml === "" AND
-        // bodyText === ""; caching that means future views serve emptiness
-        // until the daemon restarts. Let the next view try again; the
-        // parse cost on a 9 kB .eml is ~20 ms, so re-parsing an oddity
-        // is cheap.
-        const hasContent = (bodyHtml && bodyHtml.length > 0) || (bodyText && bodyText.length > 0);
-        if (mtimeMs > 0 && hasContent)
+        // Memoize for instant re-view of the same message. cacheKey is
+        // path+mtime so a re-fetch (mtime changes) invalidates naturally.
+        // The LRU is a perf tier only — correctness never depends on it.
+        if (mtimeMs > 0)
             this.parsedLruPut(cacheKey, result);
         return result;
     }