@bobfrankston/rmfmail 1.0.708 → 1.1.3

package/packages/mailx-imap/index.ts

@@ -7,7 +7,7 @@
 import { createAutoImapConfig, CompatImapClient } from "@bobfrankston/iflow-direct";
 import type { TransportFactory } from "@bobfrankston/tcp-transport";
 import { authenticateOAuth } from "@bobfrankston/oauthsupport";
-import { MailxDB, FileMessageStore, parseSerial } from "@bobfrankston/mailx-store";
+import { MailxDB, FileMessageStore, parseSerial, storeBus } from "@bobfrankston/mailx-store";
 import { loadSettings, getStorePath, getConfigDir, getHistoryDays, getPrefetch } from "@bobfrankston/mailx-settings";
 import type { AccountConfig, MessageEnvelope, EmailAddress, Folder } from "@bobfrankston/mailx-types";
 import { EventEmitter } from "node:events";
@@ -283,6 +283,22 @@ export class ImapManager extends EventEmitter {
                 console.log(`  [reconcile-cancel] ${info.accountId} ${info.fromFolderId}/${info.fromUid}: deferred delete cancelled (move-detect rebound to ${info.toFolderId}/${info.toUid})`);
             }
         });
+        // Bridge legacy EventEmitter "folderCountsChanged" to the Store bus
+        // so subscribers can listen on a single mechanism. Done in-class
+        // rather than at every call site (~20 emit points in this file) to
+        // keep the diff small and avoid a per-call regression risk during
+        // the refactor. The Store bus is the long-term home; once every
+        // consumer subscribes via the bus, the legacy listeners in
+        // bin/mailx.ts get retired and the `this.emit("folderCountsChanged"...)`
+        // calls can convert in bulk.
+        this.on("folderCountsChanged", (accountId: string, payload: any) => {
+            storeBus.publish({
+                topic: `account:${accountId}`,
+                kind: "folderCountsChanged",
+                accountId,
+                folderId: payload?.folderId,
+            });
+        });
     }
 
     /** Get OAuth access token for an account (for SMTP auth) */
@@ -2945,135 +2961,6 @@ export class ImapManager extends EventEmitter {
         return this.bodyStore;
     }
 
-    /** Bulk trash messages — local-first, single IMAP connection for all */
-    async trashMessages(accountId: string, messages: { uid: number; folderId: number }[]): Promise<void> {
-        if (messages.length === 0) return;
-        const trash = this.findFolder(accountId, "trash");
-
-        // Tombstone each Message-ID so sync won't re-import the source-folder
-        // row before the server-side MOVE completes. Cleared on permanent
-        // failure (clearTombstoneForUid in processSyncActions).
-        for (const msg of messages) {
-            const env = this.db.getMessageByUid(accountId, msg.uid, msg.folderId);
-            if (env?.messageId) this.db.addTombstone(accountId, env.messageId, env.subject || "");
-        }
-
-        // Local first — move to trash folder locally so the row stays
-        // visible in Trash and Ctrl+Z can restore it. Body file stays in
-        // its original folder dir; the next sync rebinds path on
-        // membership uid change. Old behavior was `db.deleteMessage` +
-        // `unlinkBodyFile` which made undelete impossible (no row to
-        // restore, no body to read). For folders that ARE the trash
-        // already, fall through to hard delete (the action will EXPUNGE
-        // and reconciliation cleans up).
-        for (const msg of messages) {
-            if (trash && trash.id !== msg.folderId) {
-                this.db.moveMessageLocal(accountId, msg.uid, msg.folderId, trash.id);
-            } else {
-                this.unlinkBodyFile(accountId, msg.uid, msg.folderId).catch(() => {});
-                this.db.deleteMessage(accountId, msg.uid, "user-initiated trash (already in trash → expunge)", "mailx-imap trashMessages");
-            }
-        }
-        console.log(`  Trashed ${messages.length} messages locally (moved to trash folder, body files retained)`);
-
-        // Queue IMAP actions
-        for (const msg of messages) {
-            if (trash && trash.id !== msg.folderId) {
-                this.db.queueSyncAction(accountId, "move", msg.uid, msg.folderId, { targetFolderId: trash.id });
-            } else {
-                this.db.queueSyncAction(accountId, "delete", msg.uid, msg.folderId);
-            }
-        }
-
-        // Recalc folder counts so the tree badge updates immediately instead
-        // of showing stale numbers until the next full sync.
-        const sourceFolderIds = new Set(messages.map(m => m.folderId));
-        for (const fid of sourceFolderIds) this.db.recalcFolderCounts(fid);
-        if (trash) this.db.recalcFolderCounts(trash.id);
-        this.emit("folderCountsChanged", accountId, {});
-
-        // Process all queued actions in one IMAP session
-        this.debounceSyncActions(accountId);
-    }
-
-    /** Bulk move messages — queues the IMAP action only. The service layer
-     *  (MailxService.moveMessages) owns the local DB mutation via
-     *  updateMessageFolder; this method used to ALSO deleteMessage here,
-     *  which wiped the row the service just updated — the message vanished
-     *  on the next reconcile and "spam folder empty" was the symptom. */
-    async moveMessages(accountId: string, messages: { uid: number; folderId: number }[], targetFolderId: number): Promise<void> {
-        if (messages.length === 0) return;
-        for (const msg of messages) {
-            this.db.queueSyncAction(accountId, "move", msg.uid, msg.folderId, { targetFolderId });
-        }
-        console.log(`  [move] ${accountId}: queued IMAP MOVE for ${messages.length} message(s) → folder ${targetFolderId}`);
-        this.debounceSyncActions(accountId);
-    }
-
-    /** Debounced sync actions — batches rapid local changes into one IMAP operation */
-    private syncActionTimers = new Map<string, ReturnType<typeof setTimeout>>();
-
-    private debounceSyncActions(accountId: string): void {
-        const existing = this.syncActionTimers.get(accountId);
-        if (existing) clearTimeout(existing);
-        this.syncActionTimers.set(accountId, setTimeout(() => {
-            this.syncActionTimers.delete(accountId);
-            this.processSyncActions(accountId).catch(() => {});
-        }, 1000));
-    }
-
-    /** Move a message to Trash (delete) — local-first, queues IMAP sync */
-    async trashMessage(accountId: string, folderId: number, uid: number): Promise<void> {
-        const trash = this.findFolder(accountId, "trash");
-
-        // Tombstone the Message-ID so sync won't re-import the row in the
-        // source folder before the server-side move completes. Cleared on
-        // permanent failure of the queued sync_action (see processSyncActions
-        // catch block, where clearTombstoneForUid runs after attempts >= 5)
-        // so the user sees the row reappear when their action didn't take.
-        const env = this.db.getMessageByUid(accountId, uid, folderId);
-        if (env?.messageId) this.db.addTombstone(accountId, env.messageId, env.subject || "");
-
-        // Local first — move to trash folder so the row stays visible in
-        // Trash and Ctrl+Z can restore. Body file retained for undelete.
-        // If we're already in trash (or no trash configured), fall through
-        // to hard delete + EXPUNGE.
-        if (trash && trash.id !== folderId) {
-            this.db.moveMessageLocal(accountId, uid, folderId, trash.id);
-        } else {
-            this.unlinkBodyFile(accountId, uid, folderId).catch(() => {});
-            this.db.deleteMessage(accountId, uid, "user-initiated trash (already in trash → expunge)", "mailx-imap trashMessage");
-        }
-
-        // Queue IMAP action + log the resolution so "I deleted a message and
-        // now it's in neither trash nor deleted" is diagnosable from the log.
-        if (trash && trash.id !== folderId) {
-            const trashFolder = this.db.getFolders(accountId).find(f => f.id === trash.id);
-            this.db.queueSyncAction(accountId, "move", uid, folderId, { targetFolderId: trash.id });
-            console.log(`  [trash] ${accountId} UID ${uid}: queued MOVE to "${trashFolder?.path || trash.path}" (id=${trash.id}, specialUse=trash)`);
-        } else {
-            this.db.queueSyncAction(accountId, "delete", uid, folderId);
-            console.log(`  [trash] ${accountId} UID ${uid}: queued EXPUNGE in folder ${folderId} (already in trash or no trash configured)`);
-        }
-
-        // Folder counts moved — refresh both source and trash so the
-        // tree badges update immediately, not at the next sync.
-        this.db.recalcFolderCounts(folderId);
-        if (trash && trash.id !== folderId) this.db.recalcFolderCounts(trash.id);
-        this.emit("folderCountsChanged", accountId, {});
-
-        // Debounced sync — batches multiple deletes into one IMAP session
-        this.debounceSyncActions(accountId);
-    }
-
-    /** Move a message between folders — queues IMAP sync only. Service
-     *  layer owns the local DB update (see MailxService.moveMessage). */
-    async moveMessage(accountId: string, uid: number, fromFolderId: number, toFolderId: number): Promise<void> {
-        this.db.queueSyncAction(accountId, "move", uid, fromFolderId, { targetFolderId: toFolderId });
-        console.log(`  [move] ${accountId}: queued IMAP MOVE UID ${uid} folder ${fromFolderId} → ${toFolderId}`);
-        this.debounceSyncActions(accountId);
-    }
-
     /** Move message across accounts using iflow's moveMessageToServer */
     async moveMessageCrossAccount(
         fromAccountId: string, uid: number, fromFolderId: number,
@@ -3102,55 +2989,6 @@ export class ImapManager extends EventEmitter {
         });
     }
 
-    /** Undelete — move from Trash back to original folder. Local-first:
-     *  the row was moved (not deleted) on trash, so we just move it back
-     *  in the local DB and reconcile the IMAP queue. Two cases:
-     *    (a) the to-trash MOVE is still pending — cancel it; the server
-     *        never saw the delete, so no counter-action is needed.
-     *    (b) the to-trash MOVE drained — the message is now in Trash on
-     *        the server with a new uid. Queue a counter-move from
-     *        trash → original. The IMAP processor's fetchByUid in trash
-     *        will use the local membership uid (which the reconciler
-     *        rebound to the server's new trash uid via Message-ID match).
-     *        If reconcile hasn't run yet (unlikely race), action retries
-     *        until it does. */
-    async undeleteMessage(accountId: string, uid: number, originalFolderId: number): Promise<void> {
-        const trash = this.findFolder(accountId, "trash");
-        if (!trash) throw new Error("No Trash folder found");
-
-        // Move locally back to the original folder.
-        const moved = this.db.moveMessageLocal(accountId, uid, trash.id, originalFolderId);
-        if (!moved) {
-            console.log(`  [undelete] ${accountId} UID ${uid}: no row in trash — nothing to restore locally (sync may have already pruned)`);
-        }
-
-        // (a) cancel still-pending to-trash action.
-        const pending = this.db.findPendingSyncAction(accountId, "move", uid, originalFolderId, trash.id);
-        if (pending) {
-            this.db.completeSyncAction(pending.id);
-            console.log(`  [undelete] ${accountId} UID ${uid}: cancelled pending MOVE to trash (server never saw delete)`);
-            this.emit("folderCountsChanged", accountId, {});
-            return;
-        }
-
-        // (b) queue counter-move from trash → original.
-        this.db.queueSyncAction(accountId, "move", uid, trash.id, { targetFolderId: originalFolderId });
-        console.log(`  [undelete] ${accountId} UID ${uid}: queued counter-MOVE trash → folder ${originalFolderId}`);
-        this.debounceSyncActions(accountId);
-        this.emit("folderCountsChanged", accountId, {});
-    }
-
-    /** Update flags — local-first, queues IMAP sync */
-    async updateFlagsLocal(accountId: string, uid: number, folderId: number, flags: string[]): Promise<void> {
-        this.db.updateMessageFlags(accountId, uid, flags);
-        this.db.queueSyncAction(accountId, "flags", uid, folderId, { flags });
-        // User-visible pink-dot pending state stays until the action drains.
-        // The 30-second periodic tick was too slow — opening one message to
-        // auto-mark-as-read left it pink for half a minute. Same 1-second
-        // debounce as moves/deletes batches rapid flag churn without the
-        // visual lag.
-        this.debounceSyncActions(accountId);
-    }
 
     /** Process pending sync actions for an account */
     async processSyncActions(accountId: string): Promise<void> {

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

@@ -1,12 +1,12 @@
 {
   "name": "@bobfrankston/mailx-imap",
-  "version": "0.1.44",
+  "version": "0.1.45",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bobfrankston/mailx-imap",
-      "version": "0.1.44",
+      "version": "0.1.45",
       "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.44",
+  "version": "0.1.45",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",

package/packages/mailx-service/db-worker-client.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Main-thread client for the DB factor worker.
+ *
+ * Spawns `db-worker.js` in a Node `worker_thread`, performs the init
+ * handshake (passes dbPath + storePath), and returns a `WorkerBus` the
+ * caller can use to send read requests and subscribe to DB events.
+ *
+ * The init handshake is a single `{kind:"init"}` postMessage followed by an
+ * `{kind:"init-ok"}` or `{kind:"init-error"}` reply. This is done OUTSIDE
+ * the WorkerBus message protocol so a bus method can't accidentally race
+ * the construction of LocalStore inside the worker.
+ *
+ * Failure mode: if the worker can't load (the file is missing in a packaged
+ * build, the DB can't be opened, etc.), `spawnDbWorker()` rejects. The
+ * caller can fall back to in-process LocalStore — same code, same answers,
+ * just shares the event loop with whatever else is running on main. That's
+ * the legacy path; the worker is the new default but we don't paint
+ * ourselves into a corner.
+ */
+import { Worker } from "node:worker_threads";
+import { WorkerBus } from "@bobfrankston/mailx-bus";
+export interface SpawnedDbWorker {
+    bus: WorkerBus;
+    worker: Worker;
+    /** Stop the worker. After this, requests over the bus reject. */
+    close(): Promise<void>;
+}
+export declare function spawnDbWorker(opts: {
+    dbPath: string;
+    storePath: string;
+}): Promise<SpawnedDbWorker>;
+//# sourceMappingURL=db-worker-client.d.ts.map

package/packages/mailx-service/db-worker-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db-worker-client.d.ts","sourceRoot":"","sources":["db-worker-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAG7C,OAAO,EAAE,SAAS,EAAwB,MAAM,yBAAyB,CAAC;AAE1E,MAAM,WAAW,eAAe;IAC5B,GAAG,EAAE,SAAS,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,iEAAiE;IACjE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED,wBAAsB,aAAa,CAAC,IAAI,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,eAAe,CAAC,CA0CzG"}

package/packages/mailx-service/db-worker-client.js

@@ -0,0 +1,66 @@
+/**
+ * Main-thread client for the DB factor worker.
+ *
+ * Spawns `db-worker.js` in a Node `worker_thread`, performs the init
+ * handshake (passes dbPath + storePath), and returns a `WorkerBus` the
+ * caller can use to send read requests and subscribe to DB events.
+ *
+ * The init handshake is a single `{kind:"init"}` postMessage followed by an
+ * `{kind:"init-ok"}` or `{kind:"init-error"}` reply. This is done OUTSIDE
+ * the WorkerBus message protocol so a bus method can't accidentally race
+ * the construction of LocalStore inside the worker.
+ *
+ * Failure mode: if the worker can't load (the file is missing in a packaged
+ * build, the DB can't be opened, etc.), `spawnDbWorker()` rejects. The
+ * caller can fall back to in-process LocalStore — same code, same answers,
+ * just shares the event loop with whatever else is running on main. That's
+ * the legacy path; the worker is the new default but we don't paint
+ * ourselves into a corner.
+ */
+import { Worker } from "node:worker_threads";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { WorkerBus } from "@bobfrankston/mailx-bus";
+export async function spawnDbWorker(opts) {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const workerPath = join(here, "db-worker.js");
+    const worker = new Worker(workerPath);
+    // Don't let the worker prevent process exit. Phase 1 design choice — the
+    // service shuts down cleanly via its own gracefulShutdown which closes
+    // the worker explicitly; without unref, a stuck worker could block exit.
+    worker.unref();
+    // Init handshake — promise resolves on init-ok, rejects on init-error.
+    await new Promise((resolve, reject) => {
+        const onMessage = (msg) => {
+            if (!msg || typeof msg !== "object")
+                return;
+            if (msg.kind === "init-ok") {
+                worker.off("message", onMessage);
+                resolve();
+            }
+            else if (msg.kind === "init-error") {
+                worker.off("message", onMessage);
+                reject(new Error(`db-worker init: ${msg.error}`));
+            }
+            // Ignore other messages (bus traffic) — the bus is built AFTER
+            // we resolve, so any bus message arriving here is stale.
+        };
+        worker.on("message", onMessage);
+        worker.on("error", (e) => {
+            worker.off("message", onMessage);
+            reject(e);
+        });
+        worker.postMessage({ kind: "init", dbPath: opts.dbPath, storePath: opts.storePath });
+    });
+    // Wrap the post-init port in a WorkerBus on this side. The worker has
+    // already wrapped its parentPort in a WorkerBus inside its init handler.
+    const bus = new WorkerBus(worker);
+    return {
+        bus,
+        worker,
+        async close() {
+            await worker.terminate();
+        },
+    };
+}
+//# sourceMappingURL=db-worker-client.js.map

package/packages/mailx-service/db-worker-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"db-worker-client.js","sourceRoot":"","sources":["db-worker-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,SAAS,EAAwB,MAAM,yBAAyB,CAAC;AAS1E,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,IAA2C;IAC3E,MAAM,IAAI,GAAG,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IACrD,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;IAC9C,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,UAAU,CAAC,CAAC;IACtC,yEAAyE;IACzE,uEAAuE;IACvE,yEAAyE;IACzE,MAAM,CAAC,KAAK,EAAE,CAAC;IAEf,uEAAuE;IACvE,MAAM,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACxC,MAAM,SAAS,GAAG,CAAC,GAAQ,EAAQ,EAAE;YACjC,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ;gBAAE,OAAO;YAC5C,IAAI,GAAG,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;gBACzB,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;gBACjC,OAAO,EAAE,CAAC;YACd,CAAC;iBAAM,IAAI,GAAG,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;gBACnC,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;gBACjC,MAAM,CAAC,IAAI,KAAK,CAAC,mBAAmB,GAAG,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YACtD,CAAC;YACD,+DAA+D;YAC/D,yDAAyD;QAC7D,CAAC,CAAC;QACF,MAAM,CAAC,EAAE,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QAChC,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,CAAQ,EAAE,EAAE;YAC5B,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;YACjC,MAAM,CAAC,CAAC,CAAC,CAAC;QACd,CAAC,CAAC,CAAC;QACH,MAAM,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;IACzF,CAAC,CAAC,CAAC;IAEH,sEAAsE;IACtE,yEAAyE;IACzE,MAAM,GAAG,GAAG,IAAI,SAAS,CAAC,MAAoC,CAAC,CAAC;IAEhE,OAAO;QACH,GAAG;QACH,MAAM;QACN,KAAK,CAAC,KAAK;YACP,MAAM,MAAM,CAAC,SAAS,EAAE,CAAC;QAC7B,CAAC;KACJ,CAAC;AACN,CAAC"}

package/packages/mailx-service/db-worker-client.ts

@@ -0,0 +1,75 @@
+/**
+ * Main-thread client for the DB factor worker.
+ *
+ * Spawns `db-worker.js` in a Node `worker_thread`, performs the init
+ * handshake (passes dbPath + storePath), and returns a `WorkerBus` the
+ * caller can use to send read requests and subscribe to DB events.
+ *
+ * The init handshake is a single `{kind:"init"}` postMessage followed by an
+ * `{kind:"init-ok"}` or `{kind:"init-error"}` reply. This is done OUTSIDE
+ * the WorkerBus message protocol so a bus method can't accidentally race
+ * the construction of LocalStore inside the worker.
+ *
+ * Failure mode: if the worker can't load (the file is missing in a packaged
+ * build, the DB can't be opened, etc.), `spawnDbWorker()` rejects. The
+ * caller can fall back to in-process LocalStore — same code, same answers,
+ * just shares the event loop with whatever else is running on main. That's
+ * the legacy path; the worker is the new default but we don't paint
+ * ourselves into a corner.
+ */
+
+import { Worker } from "node:worker_threads";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { WorkerBus, type MessagePortLike } from "@bobfrankston/mailx-bus";
+
+export interface SpawnedDbWorker {
+    bus: WorkerBus;
+    worker: Worker;
+    /** Stop the worker. After this, requests over the bus reject. */
+    close(): Promise<void>;
+}
+
+export async function spawnDbWorker(opts: { dbPath: string; storePath: string }): Promise<SpawnedDbWorker> {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const workerPath = join(here, "db-worker.js");
+    const worker = new Worker(workerPath);
+    // Don't let the worker prevent process exit. Phase 1 design choice — the
+    // service shuts down cleanly via its own gracefulShutdown which closes
+    // the worker explicitly; without unref, a stuck worker could block exit.
+    worker.unref();
+
+    // Init handshake — promise resolves on init-ok, rejects on init-error.
+    await new Promise<void>((resolve, reject) => {
+        const onMessage = (msg: any): void => {
+            if (!msg || typeof msg !== "object") return;
+            if (msg.kind === "init-ok") {
+                worker.off("message", onMessage);
+                resolve();
+            } else if (msg.kind === "init-error") {
+                worker.off("message", onMessage);
+                reject(new Error(`db-worker init: ${msg.error}`));
+            }
+            // Ignore other messages (bus traffic) — the bus is built AFTER
+            // we resolve, so any bus message arriving here is stale.
+        };
+        worker.on("message", onMessage);
+        worker.on("error", (e: Error) => {
+            worker.off("message", onMessage);
+            reject(e);
+        });
+        worker.postMessage({ kind: "init", dbPath: opts.dbPath, storePath: opts.storePath });
+    });
+
+    // Wrap the post-init port in a WorkerBus on this side. The worker has
+    // already wrapped its parentPort in a WorkerBus inside its init handler.
+    const bus = new WorkerBus(worker as unknown as MessagePortLike);
+
+    return {
+        bus,
+        worker,
+        async close(): Promise<void> {
+            await worker.terminate();
+        },
+    };
+}

package/packages/mailx-service/db-worker.d.ts

@@ -0,0 +1,39 @@
+/**
+ * DB factor — Node worker thread.
+ *
+ * Owns the SQLite handle and FileMessageStore. Serves the UI-read surface
+ * (getFolders, getMessages, getUnifiedInbox, getMessage, searchMessages,
+ * searchContacts, getThreadMessages) over `mailx-bus`. Subscribes to write
+ * events from the sync factor (Phase 2) and emits `db:messageAdded` /
+ * `db:messageRemoved` / `db:flagChanged` so the UI can update incrementally
+ * without re-asking.
+ *
+ * **Why a worker.** Until now every UI click had to traverse the same Node
+ * event loop the sync code runs on. A 14-minute synchronous freeze in the
+ * sync path (Dovecot SELECT hang, Prefirst.OIA backfill loop) starved every
+ * UI read. The IPC pipe handler couldn't even be scheduled. From the user's
+ * perspective: Sent shows empty, message bodies never load, autocomplete
+ * dies, drafts can't save. All of those have one cause: the read path
+ * shares an event loop with the write/sync path.
+ *
+ * In this worker, the read path is on its own thread. Sync can freeze for
+ * an hour and the user's click still gets a 5 ms answer from local SQLite.
+ *
+ * **Topology**. Main thread spawns this worker once, holds a `WorkerBus` over
+ * the `parentPort`. The worker also holds a `WorkerBus` over `parentPort` and
+ * registers its handlers. Two ends of the same channel, mirror APIs.
+ *
+ * **DB connection**. `better-sqlite3` is in-process synchronous, so the
+ * worker opens its OWN connection to the same `.db` file. WAL mode (set in
+ * `MailxDB`) makes concurrent readers safe; writes still happen on the main
+ * thread for Phase 1 and the worker sees committed rows immediately.
+ * Phase 2 moves writes to the sync worker, which routes through this worker
+ * for any UI-visible mutation so the LRU/cache here can update in lock-step.
+ *
+ * **No mailparser here.** Body parsing is the parse-worker's job. This
+ * worker reads the .eml bytes off disk and delegates parsing via
+ * `parseSerial` (which already postMessages to its own worker). Two workers
+ * either side of this thread; the read coordinator is purely an indexer.
+ */
+export {};
+//# sourceMappingURL=db-worker.d.ts.map

package/packages/mailx-service/db-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db-worker.d.ts","sourceRoot":"","sources":["db-worker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG"}

package/packages/mailx-service/db-worker.js

@@ -0,0 +1,104 @@
+/**
+ * DB factor — Node worker thread.
+ *
+ * Owns the SQLite handle and FileMessageStore. Serves the UI-read surface
+ * (getFolders, getMessages, getUnifiedInbox, getMessage, searchMessages,
+ * searchContacts, getThreadMessages) over `mailx-bus`. Subscribes to write
+ * events from the sync factor (Phase 2) and emits `db:messageAdded` /
+ * `db:messageRemoved` / `db:flagChanged` so the UI can update incrementally
+ * without re-asking.
+ *
+ * **Why a worker.** Until now every UI click had to traverse the same Node
+ * event loop the sync code runs on. A 14-minute synchronous freeze in the
+ * sync path (Dovecot SELECT hang, Prefirst.OIA backfill loop) starved every
+ * UI read. The IPC pipe handler couldn't even be scheduled. From the user's
+ * perspective: Sent shows empty, message bodies never load, autocomplete
+ * dies, drafts can't save. All of those have one cause: the read path
+ * shares an event loop with the write/sync path.
+ *
+ * In this worker, the read path is on its own thread. Sync can freeze for
+ * an hour and the user's click still gets a 5 ms answer from local SQLite.
+ *
+ * **Topology**. Main thread spawns this worker once, holds a `WorkerBus` over
+ * the `parentPort`. The worker also holds a `WorkerBus` over `parentPort` and
+ * registers its handlers. Two ends of the same channel, mirror APIs.
+ *
+ * **DB connection**. `better-sqlite3` is in-process synchronous, so the
+ * worker opens its OWN connection to the same `.db` file. WAL mode (set in
+ * `MailxDB`) makes concurrent readers safe; writes still happen on the main
+ * thread for Phase 1 and the worker sees committed rows immediately.
+ * Phase 2 moves writes to the sync worker, which routes through this worker
+ * for any UI-visible mutation so the LRU/cache here can update in lock-step.
+ *
+ * **No mailparser here.** Body parsing is the parse-worker's job. This
+ * worker reads the .eml bytes off disk and delegates parsing via
+ * `parseSerial` (which already postMessages to its own worker). Two workers
+ * either side of this thread; the read coordinator is purely an indexer.
+ */
+import { parentPort } from "node:worker_threads";
+import { WorkerBus } from "@bobfrankston/mailx-bus";
+import { MailxDB, FileMessageStore } from "@bobfrankston/mailx-store";
+import { LocalStore } from "./local-store.js";
+if (!parentPort) {
+    throw new Error("db-worker: must be spawned as a worker, parentPort is null");
+}
+// Wait for the init message before constructing the DB — the main thread
+// owns the resolved paths and passes them in.
+let store = null;
+let initialized = false;
+parentPort.once("message", async (msg) => {
+    if (msg?.kind !== "init") {
+        parentPort.postMessage({ kind: "init-error", error: `expected "init" message, got ${JSON.stringify(msg)}` });
+        return;
+    }
+    try {
+        const db = new MailxDB(msg.dbPath);
+        const bodyStore = new FileMessageStore(msg.storePath);
+        store = new LocalStore(db, bodyStore);
+        initialized = true;
+        // Now that the store is up, register handlers and ack init.
+        registerHandlers(store);
+        parentPort.postMessage({ kind: "init-ok" });
+    }
+    catch (e) {
+        parentPort.postMessage({ kind: "init-error", error: e?.message || String(e) });
+    }
+});
+function registerHandlers(s) {
+    // The bus speaks over `parentPort`. `WorkerBus` reads the same channel
+    // we just consumed `init` from — that's fine, `once()` removes the
+    // single-shot listener and the bus's own `on("message")` takes over.
+    const bus = new WorkerBus(parentPort);
+    // ── Folders ─────────────────────────────────────────────────────
+    bus.register("db:getFolders", ({ accountId }) => s.getFolders(accountId));
+    // ── Message list ────────────────────────────────────────────────
+    bus.register("db:getMessages", (q) => s.getMessages(q));
+    bus.register("db:getUnifiedInbox", ({ page = 1, pageSize = 50 }) => s.getUnifiedInbox(page, pageSize));
+    bus.register("db:searchMessages", ({ query, page = 1, pageSize = 50, accountId, folderId, includeTrashSpam = false }) => s.searchMessages(query, page, pageSize, accountId, folderId, includeTrashSpam));
+    // ── Single message (envelope + body) ────────────────────────────
+    bus.register("db:getMessage", ({ accountId, uid, allowRemote = false, folderId }) => s.getMessage(accountId, uid, allowRemote, folderId));
+    bus.register("db:getThreadMessages", ({ accountId, threadId }) => s.getThreadMessages?.(accountId, threadId) ?? []);
+    // ── Contacts read (lookups) ─────────────────────────────────────
+    bus.register("db:searchContacts", ({ query, limit }) => s.searchContacts?.(query, limit) ?? []);
+    // ── Accounts (read-only DB shape) ───────────────────────────────
+    bus.register("db:getAccounts", () => s.getAccounts());
+    // ── Config-cache invalidation ──────────────────────────────────
+    // Main thread receives `configChanged` events (allowlist.jsonc etc.)
+    // and publishes them; the worker invalidates its in-LocalStore caches
+    // so the next read sees the fresh JSONC.
+    bus.subscribe("config:changed", () => {
+        s.invalidateConfigCaches();
+    });
+}
+// Defensive: if the bus is ever asked something before init completes, the
+// caller gets a clear error rather than a hang. Mirrors the init-error path.
+parentPort.on("message", (msg) => {
+    if (!initialized && msg && typeof msg === "object" && msg.kind === "request") {
+        parentPort.postMessage({
+            kind: "reply",
+            id: msg.id,
+            error: "db-worker: not initialized — main thread must send {kind:'init'} first",
+        });
+    }
+});
+//# sourceMappingURL=db-worker.js.map

package/packages/mailx-service/db-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"db-worker.js","sourceRoot":"","sources":["db-worker.ts"],"names":[],"mappings":"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"}