@bobfrankston/mailx-store 0.1.58 → 0.1.61

package/db.d.ts

@@ -439,6 +439,36 @@ export declare class MailxDB {
      *  per DB: drop, recreate standalone, reindex subject/from + derived to/cc.
      *  body_text backfills as bodies parse. */
     private migrateFtsSchema;
+    /** True while the trigram migration's shadow table exists — the FTS write
+     *  paths (upsert / updateFtsBody) mirror into it so the copy loop never
+     *  chases a moving target. TTL-cached: upserts run hundreds/sec during
+     *  sync and the answer only changes twice in the DB's lifetime. Checked
+     *  via sqlite_master (not an in-memory flag) because the migration runs on
+     *  the main writer while upserts run on the sync worker's connection. */
+    private triShadowCache;
+    private ftsTriShadowExists;
+    /** Does messages_fts still use the old unicode61 word tokenizer? Checked
+     *  per-call (not cached): the answer flips mid-session when the background
+     *  migration swaps tables, and searchMessages must switch query dialects
+     *  the moment it does — including on the read-worker's own connection. */
+    private ftsIsTrigram;
+    ftsNeedsTrigramMigration(): boolean;
+    /** One-time background conversion of messages_fts from the unicode61 word
+     *  tokenizer to trigram (substring search — "sprinkler" now finds
+     *  "OpenSprinkler", Bob 2026-07-19). Word tokens only match by prefix, so
+     *  any mid-word search silently found nothing.
+     *
+     *  Runs chunked on the main writer (~3-4 min for 190k rows, measured) so
+     *  boot isn't blocked and sync writes stay responsive between chunks. The
+     *  existing index keeps serving searches the whole time; concurrent FTS
+     *  writes land in BOTH tables via ftsTriShadowExists() mirroring. The
+     *  final swap (DROP + RENAME) is a single transaction, so a crash at any
+     *  point leaves either the old table (migration restarts next boot) or
+     *  the finished trigram table — never neither. Stored body_text survives
+     *  because the copy reads it straight out of the old standalone table.
+     *  Call ONLY from the long-lived daemon: a one-shot CLI command would sit
+     *  alive for minutes finishing the copy. */
+    startFtsTrigramMigration(): void;
     /** Record a prefetch failure (0-body fetch / store-write fail) for a UID,
      *  incrementing its backoff count. Persisted so it survives restarts. */
     recordPrefetchFailure(accountId: string, folderId: number, uid: number): void;

package/db.js

@@ -219,8 +219,14 @@ const SCHEMA = `
     -- the index stores its own text (we INSERT it explicitly on upsert), so
     -- there's nothing to dereference and DELETE/INSERT/reindex all work. The
     -- migrateFtsSchema() pass below rebuilds an existing external-content table.
+    -- Tokenizer is TRIGRAM (not unicode61): unicode61 indexes whole words, so
+    -- "opens" prefix-matched "opensprinkler" but "sprinkler" found nothing
+    -- (Bob 2026-07-19). Trigram matches any >=3-char substring; searchMessages
+    -- falls back to LIKE for 1-2 char terms. Existing DBs with the old
+    -- tokenizer are converted in the background by startFtsTrigramMigration().
     CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
-        subject, from_name, from_address, to_text, cc_text, body_text
+        subject, from_name, from_address, to_text, cc_text, body_text,
+        tokenize='trigram remove_diacritics 1'
     );
 
     CREATE TABLE IF NOT EXISTS sync_actions (
@@ -540,6 +546,20 @@ export class MailxDB {
             this.db.exec("CREATE INDEX IF NOT EXISTS idx_messages_acct_msgid ON messages(account_id, message_id)");
         }
         catch { /* already exists */ }
+        // GLOBAL date-order indexes for the unified-inbox streaming walk.
+        // Every folder-scoped index leads with account_id or folder_id, so a
+        // cross-folder `ORDER BY sent_date DESC` had NO usable index and
+        // SQLite sorted all ~139k inbox rows into a temp B-tree on EVERY
+        // unified page fetch — a fixed ~750ms per call (profiled 2026-07-14;
+        // user-visible as "scroll pauses at the bottom then continues", the
+        // load-more gap outrunning its 1000px lead). With these, the walk
+        // streams straight off the index: ~1ms for a 100-row page. One per
+        // date basis (sent_date default, date for the Received toggle).
+        try {
+            this.db.exec("CREATE INDEX IF NOT EXISTS idx_messages_sentdate_global ON messages(sent_date DESC)");
+            this.db.exec("CREATE INDEX IF NOT EXISTS idx_messages_date_global ON messages(date DESC)");
+        }
+        catch { /* already exists */ }
         // is_replied: set when ANY other message in this account has in_reply_to
         // pointing at this row's message_id. Primary source of truth for the ↩
         // marker — \Answered is plan B (some servers strip it, Gmail labels
@@ -1801,8 +1821,21 @@ export class MailxDB {
                 // + from/to. Standalone FTS5 → delete + insert. body_text
                 // backfills when the body parses.
                 try {
+                    const vals = [
+                        existing.id, msg.subject || "", msg.from?.name || "", msg.from?.address || "",
+                        (msg.to || []).map(a => `${a.name || ""} ${a.address || ""}`).join(" "),
+                        (msg.cc || []).map(a => `${a.name || ""} ${a.address || ""}`).join(" "),
+                    ];
                     this.db.prepare("DELETE FROM messages_fts WHERE rowid = ?").run(existing.id);
-                    this.db.prepare("INSERT INTO messages_fts (rowid, subject, from_name, from_address, to_text, cc_text, body_text) VALUES (?, ?, ?, ?, ?, ?, '')").run(existing.id, msg.subject || "", msg.from?.name || "", msg.from?.address || "", (msg.to || []).map(a => `${a.name || ""} ${a.address || ""}`).join(" "), (msg.cc || []).map(a => `${a.name || ""} ${a.address || ""}`).join(" "));
+                    this.db.prepare("INSERT INTO messages_fts (rowid, subject, from_name, from_address, to_text, cc_text, body_text) VALUES (?, ?, ?, ?, ?, ?, '')").run(...vals);
+                    // Mirror into the trigram-migration shadow so the swap
+                    // doesn't lose this re-index (see startFtsTrigramMigration).
+                    if (this.ftsTriShadowExists()) {
+                        try {
+                            this.db.prepare("INSERT OR REPLACE INTO messages_fts_tri (rowid, subject, from_name, from_address, to_text, cc_text, body_text) VALUES (?, ?, ?, ?, ?, ?, '')").run(...vals);
+                        }
+                        catch { /* shadow may have just been swapped away */ }
+                    }
                 }
                 catch { /* best-effort */ }
             }
@@ -1836,10 +1869,39 @@ export class MailxDB {
             // fresh insert instead — both copies get their own row, matching
             // what the server (and every other client) actually shows, and the
             // set-diff converges.
-            if (moved && moved.folder_id === msg.folderId && moved.uid !== msg.uid
-                && msg.liveServerUids?.has(moved.uid)) {
+            const sameFolderDup = !!moved && moved.folder_id === msg.folderId && moved.uid !== msg.uid
+                && !!msg.liveServerUids?.has(moved.uid);
+            // Cross-folder copy, NOT a move (2026-07-16). Self-addressed mail
+            // legitimately carries ONE Message-ID in both INBOX and Sent — a
+            // Sent backfill "moving" the INBOX row to Sent stole thousands of
+            // INBOX rows, and the next INBOX sync saw 877 "server-only" UIDs,
+            // refetched them, rebound them back … an infinite cross-folder
+            // flap that hammered Dovecot, flip-flopped read/unread flags, and
+            // starved the interactive body-fetch lane ("Fetching body from
+            // server…" for minutes). Evidence available at this call site:
+            // the source folder's membership row — its last_seen_at refreshes
+            // every time that folder's sync confirms the UID is still on the
+            // server. A recently-confirmed source instance means the message
+            // exists in BOTH folders → insert a second row (matches server
+            // truth). Reconcile converges either way: a real move's source
+            // membership is dropped by the source folder's next sync and the
+            // orphaned row is deleted. The window covers hot folders (INBOX
+            // confirms every ~30 s); a stale or missing membership falls
+            // through to the rebind, preserving UUID continuity for genuine
+            // server-side moves.
+            let crossFolderCopy = false;
+            if (moved && !sameFolderDup && moved.folder_id !== msg.folderId) {
+                const SOURCE_CONFIRM_WINDOW_MS = 10 * 60_000;
+                const src = this.db.prepare("SELECT message_row_id, last_seen_at FROM message_folders WHERE folder_id = ? AND uid = ?").get(moved.folder_id, moved.uid);
+                crossFolderCopy = !!src && src.message_row_id === moved.id
+                    && (Date.now() - src.last_seen_at) < SOURCE_CONFIRM_WINDOW_MS;
+            }
+            if (sameFolderDup && moved) {
                 console.log(`  [move-detect] ${msg.accountId} ${msg.messageId}: uid ${moved.uid} still on server — duplicate copy at uid ${msg.uid}, inserting second row`);
             }
+            else if (crossFolderCopy && moved) {
+                console.log(`  [move-detect] ${msg.accountId} ${msg.messageId}: source folder ${moved.folder_id}/uid ${moved.uid} recently confirmed on server — cross-folder copy at folder ${msg.folderId}/uid ${msg.uid}, inserting second row`);
+            }
             else if (moved) {
                 console.log(`  [move-detect] ${msg.accountId} ${msg.messageId}: rebinding row ${moved.id} (folder ${moved.folder_id}/uid ${moved.uid} → folder ${msg.folderId}/uid ${msg.uid})`);
                 this.db.prepare("UPDATE messages SET folder_id = ?, uid = ?, cached_at = ? WHERE id = ?").run(msg.folderId, msg.uid, Date.now(), moved.id);
@@ -1907,6 +1969,13 @@ export class MailxDB {
         // which is in <...>.eml but it was not found") never match.
         try {
             this.db.prepare("INSERT INTO messages_fts (rowid, subject, from_name, from_address, to_text, cc_text, body_text) VALUES (?, ?, ?, ?, ?, ?, ?)").run(rowId, msg.subject, msg.from.name, msg.from.address, toText, ccText, msg.preview);
+            // Mirror into the trigram-migration shadow (see startFtsTrigramMigration).
+            if (this.ftsTriShadowExists()) {
+                try {
+                    this.db.prepare("INSERT OR REPLACE INTO messages_fts_tri (rowid, subject, from_name, from_address, to_text, cc_text, body_text) VALUES (?, ?, ?, ?, ?, ?, ?)").run(rowId, msg.subject, msg.from.name, msg.from.address, toText, ccText, msg.preview);
+                }
+                catch { /* shadow may have just been swapped away */ }
+            }
         }
         catch { /* FTS insert may fail on rebuild, non-fatal */ }
         return rowId;
@@ -1928,6 +1997,15 @@ export class MailxDB {
         try {
             const capped = bodyText.length > 64_000 ? bodyText.slice(0, 64_000) : bodyText;
             this.db.prepare("UPDATE messages_fts SET body_text = ? WHERE rowid = ?").run(capped, rowId);
+            // Mirror into the trigram-migration shadow (see startFtsTrigramMigration).
+            // No-op if the copy loop hasn't reached this rowid yet — the chunk
+            // will carry the (also-updated) old-table value across later.
+            if (this.ftsTriShadowExists()) {
+                try {
+                    this.db.prepare("UPDATE messages_fts_tri SET body_text = ? WHERE rowid = ?").run(capped, rowId);
+                }
+                catch { /* shadow may have just been swapped away */ }
+            }
         }
         catch { /* FTS update is best-effort */ }
     }
@@ -2073,7 +2151,11 @@ export class MailxDB {
         const totalKey = `${flaggedOnly}:${folderIds.join(",")}`;
         const cachedTotal = this._unifiedTotalCache.get(totalKey);
         let total;
-        if (cachedTotal && (Date.now() - cachedTotal.at) < 4000) {
+        // 15s TTL (was 4s): the COUNT is a ~450ms GROUP BY scan of every inbox
+        // row, and background refreshes land often enough that a 4s TTL
+        // recomputed it nearly every fetch. Staleness only affects the
+        // page-count indicator / load-more end detection, never row data.
+        if (cachedTotal && (Date.now() - cachedTotal.at) < 15_000) {
             total = cachedTotal.total;
         }
         else {
@@ -2097,9 +2179,17 @@ export class MailxDB {
         // idx_messages_folder_date supplies the date order. Deep pages walk more
         // (bounded by offset+pageSize survivors) but remain far cheaper than a
         // full window sort, and are rare in the unified inbox.
+        // CROSS JOIN forces messages as the OUTER table so the plan drives off
+        // idx_messages_sentdate_global / idx_messages_date_global (global
+        // date-DESC order, no temp B-tree — the `, m.id` tiebreak only sorts
+        // within equal-date runs) and probes message_folders per row. The
+        // planner can't see our early `break`, so with a plain JOIN it
+        // "optimizes" for full output: drives from mf's folder index and
+        // sorts ALL ~139k inbox rows before yielding row 1 (~750ms/page,
+        // profiled 2026-07-14). Forced order: ~1ms.
         const baseStmt = this.db.prepare(`SELECT m.*, mf.uid AS uid, mf.folder_id AS folder_id
              FROM messages m
-             JOIN message_folders mf ON mf.message_row_id = m.id
+             CROSS JOIN message_folders mf ON mf.message_row_id = m.id
              WHERE mf.folder_id IN (${placeholders})${flagFilter}
              ORDER BY ${dateCol} DESC, m.id DESC`);
         // Per-survivor enrichment (runs only for the ≤pageSize kept rows, not the
@@ -2448,7 +2538,7 @@ export class MailxDB {
                 return; // already standalone
             console.log("  [db] messages_fts had broken external-content schema — rebuilding standalone + reindexing");
             this.db.exec("DROP TABLE IF EXISTS messages_fts");
-            this.db.exec("CREATE VIRTUAL TABLE messages_fts USING fts5(subject, from_name, from_address, to_text, cc_text, body_text)");
+            this.db.exec("CREATE VIRTUAL TABLE messages_fts USING fts5(subject, from_name, from_address, to_text, cc_text, body_text, tokenize='trigram remove_diacritics 1')");
             const addrText = (j) => {
                 try {
                     return JSON.parse(j || "[]").map(a => `${a.name || ""} ${a.address || ""}`).join(" ");
@@ -2478,6 +2568,149 @@ export class MailxDB {
             console.error(`  [db] migrateFtsSchema failed: ${e?.message || e}`);
         }
     }
+    /** True while the trigram migration's shadow table exists — the FTS write
+     *  paths (upsert / updateFtsBody) mirror into it so the copy loop never
+     *  chases a moving target. TTL-cached: upserts run hundreds/sec during
+     *  sync and the answer only changes twice in the DB's lifetime. Checked
+     *  via sqlite_master (not an in-memory flag) because the migration runs on
+     *  the main writer while upserts run on the sync worker's connection. */
+    triShadowCache = null;
+    ftsTriShadowExists() {
+        const now = Date.now();
+        if (this.triShadowCache && now - this.triShadowCache.at < 2000)
+            return this.triShadowCache.exists;
+        let exists = false;
+        try {
+            exists = !!this.db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='messages_fts_tri'").get();
+        }
+        catch { /* treat as absent */ }
+        this.triShadowCache = { at: now, exists };
+        return exists;
+    }
+    /** Does messages_fts still use the old unicode61 word tokenizer? Checked
+     *  per-call (not cached): the answer flips mid-session when the background
+     *  migration swaps tables, and searchMessages must switch query dialects
+     *  the moment it does — including on the read-worker's own connection. */
+    ftsIsTrigram() {
+        try {
+            const row = this.db.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='messages_fts'").get();
+            return !!row && /trigram/i.test(row.sql || "");
+        }
+        catch {
+            return false;
+        }
+    }
+    ftsNeedsTrigramMigration() {
+        if (this.readOnly)
+            return false;
+        try {
+            const row = this.db.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='messages_fts'").get();
+            return !!row && !/trigram/i.test(row.sql || "");
+        }
+        catch {
+            return false;
+        }
+    }
+    /** One-time background conversion of messages_fts from the unicode61 word
+     *  tokenizer to trigram (substring search — "sprinkler" now finds
+     *  "OpenSprinkler", Bob 2026-07-19). Word tokens only match by prefix, so
+     *  any mid-word search silently found nothing.
+     *
+     *  Runs chunked on the main writer (~3-4 min for 190k rows, measured) so
+     *  boot isn't blocked and sync writes stay responsive between chunks. The
+     *  existing index keeps serving searches the whole time; concurrent FTS
+     *  writes land in BOTH tables via ftsTriShadowExists() mirroring. The
+     *  final swap (DROP + RENAME) is a single transaction, so a crash at any
+     *  point leaves either the old table (migration restarts next boot) or
+     *  the finished trigram table — never neither. Stored body_text survives
+     *  because the copy reads it straight out of the old standalone table.
+     *  Call ONLY from the long-lived daemon: a one-shot CLI command would sit
+     *  alive for minutes finishing the copy. */
+    startFtsTrigramMigration() {
+        if (!this.ftsNeedsTrigramMigration())
+            return;
+        const COLS = "rowid, subject, from_name, from_address, to_text, cc_text, body_text";
+        try {
+            // A leftover shadow from an interrupted run may be stale (writes
+            // that happened while no daemon mirrored them) — start clean.
+            this.db.exec("DROP TABLE IF EXISTS messages_fts_tri");
+            this.db.exec("CREATE VIRTUAL TABLE messages_fts_tri USING fts5(subject, from_name, from_address, to_text, cc_text, body_text, tokenize='trigram remove_diacritics 1')");
+        }
+        catch (e) {
+            console.error(`  [db] FTS trigram migration setup failed: ${e?.message || e}`);
+            return;
+        }
+        let total = 0;
+        try {
+            total = this.db.prepare("SELECT COUNT(*) AS c FROM messages_fts").get()?.c || 0;
+        }
+        catch { /* */ }
+        console.log(`  [db] FTS trigram migration started: ${total} rows in background (substring search when done)`);
+        const CHUNK = 500; // ~0.35s of tokenization per chunk (measured on Bob's DB)
+        let last = 0, copied = 0, chunkN = 0;
+        const step = () => {
+            try {
+                const rows = this.db.prepare("SELECT rowid FROM messages_fts WHERE rowid > ? ORDER BY rowid LIMIT ?").all(last, CHUNK);
+                if (rows.length === 0) {
+                    finish();
+                    return;
+                }
+                const hi = rows[rows.length - 1].rowid;
+                // Single INSERT..SELECT — atomic against the sync worker's
+                // mirrored writes (WAL serializes writers), so old and shadow
+                // can't diverge inside a chunk. OR REPLACE because mirrored
+                // writes may have already landed rows past the frontier.
+                this.db.prepare(`INSERT OR REPLACE INTO messages_fts_tri (${COLS}) SELECT ${COLS} FROM messages_fts WHERE rowid > ? AND rowid <= ?`).run(last, hi);
+                last = hi;
+                copied += rows.length;
+                chunkN++;
+                if (chunkN % 40 === 0) {
+                    console.log(`  [db] FTS trigram migration: ${copied}/${total}`);
+                    // The copy writes ~1 GB through the WAL in total — keep it drained.
+                    try {
+                        this.db.exec("PRAGMA wal_checkpoint(PASSIVE)");
+                    }
+                    catch { /* */ }
+                }
+                setTimeout(step, 100); // yield the writer between chunks
+            }
+            catch (e) {
+                console.error(`  [db] FTS trigram migration chunk failed (${e?.message || e}) — retrying in 5s`);
+                setTimeout(step, 5000);
+            }
+        };
+        const finish = () => {
+            try {
+                this.db.exec("BEGIN IMMEDIATE");
+                // Rows past the frontier that landed after the last chunk are
+                // already mirrored into the shadow, but belt-and-braces: if any
+                // exist, loop once more instead of trusting the mirror.
+                const strag = this.db.prepare("SELECT COUNT(*) AS c FROM messages_fts WHERE rowid > ?").get(last)?.c || 0;
+                if (strag > 0) {
+                    this.db.exec("ROLLBACK");
+                    setTimeout(step, 100);
+                    return;
+                }
+                this.db.exec("DROP TABLE messages_fts");
+                this.db.exec("ALTER TABLE messages_fts_tri RENAME TO messages_fts");
+                this.db.exec("COMMIT");
+                console.log(`  [db] FTS trigram migration complete: ${copied} rows — substring search active`);
+                try {
+                    this.db.exec("PRAGMA wal_checkpoint(PASSIVE)");
+                }
+                catch { /* */ }
+            }
+            catch (e) {
+                try {
+                    this.db.exec("ROLLBACK");
+                }
+                catch { /* */ }
+                console.error(`  [db] FTS trigram migration swap failed (${e?.message || e}) — retrying in 5s`);
+                setTimeout(finish, 5000);
+            }
+        };
+        setTimeout(step, 3000); // let boot (folder loads, first sync) settle first
+    }
     /** Record a prefetch failure (0-body fetch / store-write fail) for a UID,
      *  incrementing its backoff count. Persisted so it survives restarts. */
     recordPrefetchFailure(accountId, folderId, uid) {
@@ -3377,9 +3610,56 @@ export class MailxDB {
         // Strip FTS5 metacharacters from a user term. A stray `;` `(` `:` `"`
         // etc. is a hard `fts5: syntax error` (Bob 2026-05-21 log). FTS5's
         // tokenizer splits on non-word chars anyway, so removing them loses no
-        // real matching ability.
+        // real matching ability. (unicode61 dialect only — see isTri below.)
         const ftsClean = (t) => t.replace(/["';:(){}\[\]^~\\/]/g, "").trim();
-        for (const part of parts) {
+        // ── Tokenizer dialects ──
+        // The index is migrating from unicode61 (word tokens, prefix-only
+        // matching — "sprinkler" could never find "opensprinkler") to trigram
+        // (substring matching, Bob 2026-07-19). Which dialect to emit depends
+        // on which table is live RIGHT NOW: the background migration swaps it
+        // mid-session, and this runs on the read-worker's own connection, so
+        // ask sqlite_master rather than trusting boot-time state.
+        //
+        // Trigram dialect rules:
+        //  • every term is emitted as a QUOTED string — FTS5 then matches it
+        //    as a case-folded substring anywhere in the text, punctuation and
+        //    all ("192.55.226" matches literally; no dot-splitting, no `*`).
+        //    Only embedded double-quotes need stripping.
+        //  • terms under 3 chars can't form a trigram and MATCH nothing, so
+        //    they fall back to a LIKE over the header columns. Headers only:
+        //    scanning preview/to/cc for a 1-2 char pattern measured ~5s on
+        //    190k rows vs ~0.3s worst-case for headers, and short terms are
+        //    transient search-as-you-type states anyway.
+        const isTri = this.ftsIsTrigram();
+        const triClean = (t) => t.replace(/"/g, "").trim();
+        const triQuote = (t) => `"${t}"`;
+        const likeEsc = (t) => t.replace(/[~%_]/g, m => `~${m}`);
+        // One OR-group per call: multiple terms land in the SAME group so an
+        // all-short alternation ("ab|cd") stays an OR, not an AND of groups.
+        const pushLike = (cols, terms) => {
+            const list = Array.isArray(terms) ? terms : [terms];
+            const clauses = [];
+            for (const t of list) {
+                for (const c of cols) {
+                    clauses.push(`${c} LIKE ? ESCAPE '~'`);
+                    extraParams.push(`%${likeEsc(t)}%`);
+                }
+            }
+            if (clauses.length)
+                extraWhere.push("(" + clauses.join(" OR ") + ")");
+        };
+        const LIKE_FROM = ["m.from_name", "m.from_address"];
+        const LIKE_TO = ["m.to_json", "m.cc_json"];
+        const LIKE_CC = ["m.cc_json"];
+        const LIKE_SUBJ = ["m.subject"];
+        const LIKE_ANY = ["m.subject", "m.from_name", "m.from_address"];
+        for (let pi = 0; pi < parts.length; pi++) {
+            const part = parts[pi];
+            // A 1-2 char term next to a user-typed OR must be DROPPED, not
+            // LIKE'd: LIKE clauses AND against the MATCH, so "ab OR sprinkler"
+            // would intersect down to zero. Over-matching (just "sprinkler")
+            // beats returning nothing. (Trigram dialect only.)
+            const orAdjacent = parts[pi - 1] === "OR" || parts[pi + 1] === "OR";
             const fromMatch = part.match(/^from:(.+)$/i);
             const toMatch = part.match(/^to:(.+)$/i);
             const ccMatch = part.match(/^cc:(.+)$/i);
@@ -3393,28 +3673,64 @@ export class MailxDB {
             if (fromMatch) {
                 // FTS5 column-group `{c1 c2}:term` matches term in either
                 // column without the parens that break a trailing implicit-AND.
-                const term = ftsClean(fromMatch[1]);
-                if (term)
-                    frags.push({ s: `{from_name from_address}:${term}*`, op: false });
+                if (isTri) {
+                    const term = triClean(fromMatch[1]);
+                    if (term.length >= 3)
+                        frags.push({ s: `{from_name from_address}:${triQuote(term)}`, op: false });
+                    else if (term && !orAdjacent)
+                        pushLike(LIKE_FROM, term);
+                }
+                else {
+                    const term = ftsClean(fromMatch[1]);
+                    if (term)
+                        frags.push({ s: `{from_name from_address}:${term}*`, op: false });
+                }
             }
             else if (toMatch) {
                 // `to:` deliberately spans To AND Cc — when someone searches
                 // "to:bob" they mean "addressed to bob", and being Cc'd counts.
                 // Use `cc:` for a Cc-only match. (Bcc isn't indexed: it's absent
                 // on received mail by design, and only meaningful in Sent.)
-                const term = ftsClean(toMatch[1]);
-                if (term)
-                    frags.push({ s: `{to_text cc_text}:${term}*`, op: false });
+                if (isTri) {
+                    const term = triClean(toMatch[1]);
+                    if (term.length >= 3)
+                        frags.push({ s: `{to_text cc_text}:${triQuote(term)}`, op: false });
+                    else if (term && !orAdjacent)
+                        pushLike(LIKE_TO, term);
+                }
+                else {
+                    const term = ftsClean(toMatch[1]);
+                    if (term)
+                        frags.push({ s: `{to_text cc_text}:${term}*`, op: false });
+                }
             }
             else if (ccMatch) {
-                const term = ftsClean(ccMatch[1]);
-                if (term)
-                    frags.push({ s: `cc_text:${term}*`, op: false });
+                if (isTri) {
+                    const term = triClean(ccMatch[1]);
+                    if (term.length >= 3)
+                        frags.push({ s: `cc_text:${triQuote(term)}`, op: false });
+                    else if (term && !orAdjacent)
+                        pushLike(LIKE_CC, term);
+                }
+                else {
+                    const term = ftsClean(ccMatch[1]);
+                    if (term)
+                        frags.push({ s: `cc_text:${term}*`, op: false });
+                }
             }
             else if (subjectMatch) {
-                const term = ftsClean(subjectMatch[1]);
-                if (term)
-                    frags.push({ s: `subject:${term}*`, op: false });
+                if (isTri) {
+                    const term = triClean(subjectMatch[1]);
+                    if (term.length >= 3)
+                        frags.push({ s: `subject:${triQuote(term)}`, op: false });
+                    else if (term && !orAdjacent)
+                        pushLike(LIKE_SUBJ, term);
+                }
+                else {
+                    const term = ftsClean(subjectMatch[1]);
+                    if (term)
+                        frags.push({ s: `subject:${term}*`, op: false });
+                }
             }
             else if (dateMatch || afterMatch || beforeMatch) {
                 const op = dateMatch ? (dateMatch[1] || "=") : (afterMatch ? ">" : "<");
@@ -3467,6 +3783,36 @@ export class MailxDB {
                 // match like "Peter Hoddie" + "github" returned zero hits.
                 frags.push({ s: part, op: true });
             }
+            else if (isTri) {
+                // Unqualified, trigram dialect — quoted substring match. A
+                // user-quoted "foo bar" phrase survives as one literal
+                // substring including the space (real phrase search, which
+                // the unicode61 dialect approximated with AND'd words).
+                const term = part.replace(/^\/|\/$/g, "");
+                if (term.includes("|")) {
+                    const alts = term.split("|").map(t => triClean(t)).filter(Boolean);
+                    const long = alts.filter(t => t.length >= 3);
+                    const short = alts.filter(t => t.length < 3);
+                    if (long.length) {
+                        // Mixed `abc|xy`: drop the short alternates. An OR
+                        // can't span MATCH and LIKE (LIKE would AND against
+                        // the MATCH and turn the union into an intersection
+                        // that returns nothing).
+                        frags.push({ s: `(${long.map(triQuote).join(" OR ")})`, op: false });
+                    }
+                    else if (short.length && !orAdjacent) {
+                        // All-short: one OR'd LIKE group keeps `ab|cd` a union.
+                        pushLike(LIKE_ANY, short);
+                    }
+                }
+                else {
+                    const t = triClean(term);
+                    if (t.length >= 3)
+                        frags.push({ s: triQuote(t), op: false });
+                    else if (t && !orAdjacent)
+                        pushLike(LIKE_ANY, t);
+                }
+            }
             else {
                 // Unqualified — search everything. Strip /regex-literal/
                 // slashes and FTS5 metacharacters before wildcarding.
@@ -3497,6 +3843,14 @@ export class MailxDB {
                 }
             }
         }
+        // A term diverted to the LIKE fallback can strand a user-typed
+        // operator at the edge of the MATCH string ("ab OR sprinkler" → the
+        // "ab" became a LIKE, leaving "OR sprinkler" — an FTS5 syntax error
+        // that would silently empty the whole search). Trim dangling operators.
+        while (frags.length && frags[0].op)
+            frags.shift();
+        while (frags.length && frags[frags.length - 1].op)
+            frags.pop();
         // Join fragments. Two adjacent value fragments need an explicit `AND`
         // (implicit-AND after a `(...)` / `{...}:` group is an FTS5 syntax
         // error); a user operator fragment glues itself, so no insert around it.
@@ -3613,8 +3967,12 @@ export class MailxDB {
             this.db.exec("DROP TABLE IF EXISTS messages_fts");
         }
         catch { /* ignore */ }
+        // Trigram tokenization is ~10x slower to build than unicode61, so a
+        // full -reindex on a 190k-row DB takes minutes. Explicit user command,
+        // runs once — substring search is worth it.
         this.db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
-            subject, from_name, from_address, to_text, cc_text, body_text
+            subject, from_name, from_address, to_text, cc_text, body_text,
+            tokenize='trigram remove_diacritics 1'
         )`);
         // Use a single transaction + prepared statement for speed (~50x faster than individual inserts)
         const insert = this.db.prepare("INSERT INTO messages_fts (rowid, subject, from_name, from_address, to_text, cc_text, body_text) VALUES (?, ?, ?, ?, ?, ?, ?)");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-store",
-  "version": "0.1.58",
+  "version": "0.1.61",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",
@@ -9,8 +9,8 @@
   },
   "license": "ISC",
   "dependencies": {
-    "@bobfrankston/mailx-types": "^0.1.22",
-    "@bobfrankston/mailx-settings": "^0.1.33",
+    "@bobfrankston/mailx-types": "^0.1.24",
+    "@bobfrankston/mailx-settings": "^0.1.35",
     "@bobfrankston/mailx-bus": "^0.1.2",
     "mailparser": "^3.7.2"
   },
@@ -29,8 +29,8 @@
   },
   ".transformedSnapshot": {
     "dependencies": {
-      "@bobfrankston/mailx-types": "^0.1.22",
-      "@bobfrankston/mailx-settings": "^0.1.33",
+      "@bobfrankston/mailx-types": "^0.1.24",
+      "@bobfrankston/mailx-settings": "^0.1.35",
       "@bobfrankston/mailx-bus": "^0.1.2",
       "mailparser": "^3.7.2"
     }