@bobfrankston/mailx-store 0.1.27 → 0.1.29

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

@@ -1355,13 +1355,18 @@ export class MailxDB {
         // quoted-strings (RFC-strictly forbidden, common in the wild). Run
         // libmime over Subject and every address display name once; safe
         // to call on already-decoded text (no `=?...?=` markers → no-op).
+        // The `address` is decoded too: a legit address never carries an
+        // encoded-word, so it's a no-op there — but spam sometimes packs the
+        // whole `name <addr>` into the mailbox local-part as one encoded
+        // word (`=?utf-8?q?...=3C...=40...=3E?=@host`). Decoding it at least
+        // renders readable text instead of raw `=3C`/`=C3=A9` gibberish.
         msg.subject = decodeHeaderWords(msg.subject);
         if (msg.from)
-            msg.from = { name: decodeHeaderWords(msg.from.name || ""), address: msg.from.address || "" };
+            msg.from = { name: decodeHeaderWords(msg.from.name || ""), address: decodeHeaderWords(msg.from.address || "") };
         if (msg.to)
-            msg.to = msg.to.map(a => ({ name: decodeHeaderWords(a.name || ""), address: a.address || "" }));
+            msg.to = msg.to.map(a => ({ name: decodeHeaderWords(a.name || ""), address: decodeHeaderWords(a.address || "") }));
         if (msg.cc)
-            msg.cc = msg.cc.map(a => ({ name: decodeHeaderWords(a.name || ""), address: a.address || "" }));
+            msg.cc = msg.cc.map(a => ({ name: decodeHeaderWords(a.name || ""), address: decodeHeaderWords(a.address || "") }));
         const existing = this.db.prepare("SELECT id, provider_id FROM messages WHERE account_id = ? AND folder_id = ? AND uid = ?").get(msg.accountId, msg.folderId, msg.uid);
         if (existing) {
             // Backfill provider_id on existing rows that predate this column —
@@ -1901,6 +1906,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 +2021,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 +2054,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 +2133,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 +2174,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 +2189,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 +2255,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.27",
+  "version": "0.1.29",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",
@@ -9,8 +9,8 @@
   },
   "license": "ISC",
   "dependencies": {
-    "@bobfrankston/mailx-types": "^0.1.14",
-    "@bobfrankston/mailx-settings": "^0.1.17",
+    "@bobfrankston/mailx-types": "^0.1.15",
+    "@bobfrankston/mailx-settings": "^0.1.18",
     "@bobfrankston/mailx-bus": "^0.1.2",
     "mailparser": "^3.7.2"
   },
@@ -29,8 +29,8 @@
   },
   ".transformedSnapshot": {
     "dependencies": {
-      "@bobfrankston/mailx-types": "^0.1.14",
-      "@bobfrankston/mailx-settings": "^0.1.17",
+      "@bobfrankston/mailx-types": "^0.1.15",
+      "@bobfrankston/mailx-settings": "^0.1.18",
       "@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

@@ -83,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

@@ -78,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
@@ -262,13 +271,32 @@ export class Store {
         // queue-contention parses. Synchronous parse makes the whole
         // class structurally impossible: getMessage either returns the
         // body or returns `cached:false` meaning exactly "fetch it."
-        const raw = await this.bodyStore.readByPath(storedPath);
-        const adjusted = sniffAndFixCharset(raw);
-        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})`);
+        // 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;
+        }
+        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 || "";