@bobfrankston/mailx-store 0.1.47 → 0.1.49

package/db.d.ts

@@ -9,7 +9,14 @@ import type { MessageEnvelope, Folder, EmailAddress, PagedResult, MessageQuery }
 export declare function setContactsDenyPatterns(patterns: string[]): void;
 export declare class MailxDB {
     private db;
-    constructor(dbDir: string);
+    /** True for the DB read-worker's connection. Read-only handles never run
+     *  DDL / migrations / backfills (the main writer already did, before this
+     *  handle opened) and reject any write at the SQLite level. */
+    readonly readOnly: boolean;
+    constructor(dbDir: string, opts?: {
+        readOnly?: boolean;
+        skipMigrations?: boolean;
+    });
     /** Fail loud + early if expected columns are missing. Cheap (PRAGMA only
      *  runs at startup). The user-facing message names the recovery command. */
     private verifySchema;

package/db.js

@@ -403,12 +403,56 @@ const SCHEMA = `
 `;
 export class MailxDB {
     db;
-    constructor(dbDir) {
+    /** True for the DB read-worker's connection. Read-only handles never run
+     *  DDL / migrations / backfills (the main writer already did, before this
+     *  handle opened) and reject any write at the SQLite level. */
+    readOnly;
+    constructor(dbDir, opts = {}) {
         fs.mkdirSync(dbDir, { recursive: true });
         const dbPath = path.join(dbDir, "mailx.db");
+        this.readOnly = !!opts.readOnly;
         this.db = new DatabaseSync(dbPath);
+        if (opts.skipMigrations && !opts.readOnly) {
+            // Write-capable connection that does NOT run schema/migrations —
+            // used by the sync worker, which opens its own writer AFTER the
+            // main thread has already built the schema. Two threads running the
+            // DDL/backfills concurrently would race on the WAL write lock.
+            this.db.exec("PRAGMA journal_mode = WAL");
+            this.db.exec("PRAGMA foreign_keys = ON");
+            this.db.exec("PRAGMA busy_timeout = 5000");
+            return;
+        }
+        if (this.readOnly) {
+            // Read-worker connection (Phase 0 read isolation). The main-thread
+            // MailxDB has ALREADY created the schema and run every migration /
+            // backfill before this worker is spawned, so we must NOT touch any
+            // of that here — two threads racing writes on one WAL file means
+            // SQLITE_BUSY and corruption risk. Strategy:
+            //   • Do NOT pass {readOnly:true} to DatabaseSync. An OS-read-only
+            //     handle on a WAL database can't maintain the -shm wal-index
+            //     and fails to read at all. We open read-WRITE at the OS level
+            //     so WAL reads work, then forbid writes LOGICALLY below.
+            //   • PRAGMA query_only = ON makes every statement on this handle
+            //     read-only — INSERT/UPDATE/DELETE/DDL all throw. That is the
+            //     guard that lets us reuse the full MailxDB read surface here
+            //     without any chance of a stray write.
+            // WAL mode is a persisted property of the file (the writer set it),
+            // so readers see committed snapshots with no journal_mode call.
+            this.db.exec("PRAGMA foreign_keys = ON");
+            this.db.exec("PRAGMA query_only = ON");
+            // A reader can briefly collide with a WAL checkpoint; wait, don't throw.
+            this.db.exec("PRAGMA busy_timeout = 5000");
+            return;
+        }
         this.db.exec("PRAGMA journal_mode = WAL");
         this.db.exec("PRAGMA foreign_keys = ON");
+        // Multi-writer foundation for the sync-worker migration: once sync runs
+        // on its own thread with its own write connection, it and the main
+        // thread are two writers on one WAL file. WAL serializes writers, so a
+        // collision returns SQLITE_BUSY *immediately* by default — busy_timeout
+        // makes the loser WAIT for the lock (up to 5s) instead of failing. Safe
+        // and inert today (single writer); required before the worker lands.
+        this.db.exec("PRAGMA busy_timeout = 5000");
         this.db.exec(SCHEMA);
         this.migrateFtsSchema();
         // Purge phantom uid=0 rows (invalid IMAP UID — empty stub letters, the
@@ -1180,6 +1224,7 @@ export class MailxDB {
             accountId: r.account_id,
             folderId: r.folder_id,
             uid: r.uid,
+            uuid: r.uuid || "", // stable identity for row data-uuid / selection restore
             messageId: r.message_id || "",
             inReplyTo: r.in_reply_to || "",
             references: JSON.parse(r.refs || "[]"),
@@ -1873,6 +1918,13 @@ export class MailxDB {
             // Bcc). The unified-inbox UI shows a small ⇆ badge on these
             // rows so the user knows "this is a copy of the same message".
             dupeCount: r.dupeCount | 0,
+            // uuid is the stable local identity each message-list row carries as
+            // data-uuid. Without it, restoreSelection() / rememberPosition() /
+            // the set-diff scroll anchor all match on empty string and fail, so
+            // the selected-row highlight vanishes on every reload (Bob
+            // 2026-06-13: "no highlighting in the summary"). getMessages already
+            // maps uuid; this unified-inbox map dropped it. SELECT m.* exposes it.
+            uuid: r.uuid || "",
         }));
         return { items, total, page, pageSize };
     }
@@ -3132,6 +3184,7 @@ export class MailxDB {
                 folderId: r.folder_id,
                 folderName: r.folder_name || "",
                 uid: r.uid,
+                uuid: r.uuid || "", // stable identity for row data-uuid / selection restore
                 messageId: r.message_id || "",
                 inReplyTo: r.in_reply_to || "",
                 references: JSON.parse(r.refs || "[]"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-store",
-  "version": "0.1.47",
+  "version": "0.1.49",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",