imsg-mcp 1.2.0 → 1.3.1

package/dist/{imessage-db-BYU5mxM-.js → imessage-db-vDZF7E8B.js}

@@ -1,11 +1,378 @@
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { join, dirname } from "node:path";
 import Database from "better-sqlite3";
 import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 import { existsSync, readdirSync, mkdirSync } from "node:fs";
-import { O as OBJECT_REPLACEMENT_CHAR, p as perf, J as isGroupGuid, K as isGroupChatIdentifier, L as generateThreadSlug, T as Tables, M as AssociatedMessageType, N as macAutoTimestampToDate, P as isReactionType, Q as MAC_EPOCH_OFFSET, R as NANOS_PER_SECOND, S as macTimestampToDate$1, U as parseAssociatedMessageGuid$1 } from "./shutdown-BJifUGdo.js";
+import { O as OBJECT_REPLACEMENT_CHAR, p as perf, J as isGroupGuid, K as isGroupChatIdentifier, L as generateThreadSlug, T as Tables, M as AssociatedMessageType, N as macAutoTimestampToDate, P as isReactionType, Q as MAC_EPOCH_OFFSET, R as NANOS_PER_SECOND, S as parseAssociatedMessageGuid$1, U as macTimestampToDate$1 } from "./shutdown-CikCSZru.js";
 import { parseBuffer } from "bplist-parser";
+function normalizePhoneNumber(phone) {
+  const digits = phone.replace(/\D/g, "");
+  if (digits.length === 11 && digits.startsWith("1")) {
+    return digits.slice(1);
+  }
+  return digits;
+}
+function normalizedPhoneVariants(phone) {
+  const normalized = normalizePhoneNumber(phone);
+  const variants = /* @__PURE__ */ new Set([normalized]);
+  if (normalized.length === 11 && normalized.startsWith("61")) {
+    const localMobile = normalized.slice(2);
+    variants.add(localMobile);
+    if (localMobile.length === 9 && localMobile.startsWith("4")) {
+      variants.add(`0${localMobile}`);
+    }
+  }
+  if (normalized.length === 10 && normalized.startsWith("04")) {
+    const mobileDigits = normalized.slice(1);
+    variants.add(mobileDigits);
+    variants.add(`61${mobileDigits}`);
+  }
+  if (normalized.length === 10) {
+    variants.add(`1${normalized}`);
+  }
+  if (normalized.length === 9 && normalized.startsWith("4")) {
+    variants.add(`61${normalized}`);
+    variants.add(`0${normalized}`);
+  }
+  return [...variants];
+}
+function normalizeEmail(email) {
+  return email.toLowerCase().trim();
+}
+function normalizeNameForMatch(name) {
+  if (!name) return "";
+  return name.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/\s+/g, " ").trim();
+}
+function nameCandidates(fields) {
+  const out = /* @__PURE__ */ new Set();
+  const add = (n) => {
+    const norm = normalizeNameForMatch(n);
+    if (norm) out.add(norm);
+  };
+  add(fields.nickname);
+  const full = [fields.firstName, fields.lastName].filter(Boolean).join(" ");
+  add(full);
+  add(fields.organization);
+  return out;
+}
+const ADDRESS_BOOK_DIR = join(homedir(), "Library", "Application Support", "AddressBook");
+const MAIN_DB_NAME = "AddressBook-v22.abcddb";
+function discoverContactDbPaths(customPaths) {
+  if (customPaths) {
+    const list = Array.isArray(customPaths) ? customPaths : [customPaths];
+    return list.filter((p) => existsSync(p));
+  }
+  const paths = [];
+  const mainDb = join(ADDRESS_BOOK_DIR, MAIN_DB_NAME);
+  if (existsSync(mainDb)) paths.push(mainDb);
+  const sourcesDir = join(ADDRESS_BOOK_DIR, "Sources");
+  if (existsSync(sourcesDir)) {
+    try {
+      const subdirs = readdirSync(sourcesDir, { withFileTypes: true });
+      for (const d of subdirs) {
+        if (!d.isDirectory()) continue;
+        const sourceDb = join(sourcesDir, d.name, MAIN_DB_NAME);
+        if (existsSync(sourceDb)) paths.push(sourceDb);
+      }
+    } catch {
+    }
+  }
+  return paths;
+}
+class ContactsDB {
+  dbPaths = [];
+  databases = [];
+  phoneMap = /* @__PURE__ */ new Map();
+  emailMap = /* @__PURE__ */ new Map();
+  contactCache = /* @__PURE__ */ new Map();
+  initialized = false;
+  /** Next id when loading from multiple DBs (avoids Z_PK collisions across sources). */
+  nextContactId = 1;
+  constructor(dbPaths) {
+    this.dbPaths = discoverContactDbPaths(dbPaths);
+  }
+  /**
+   * Initialize the contact lookup maps from all discovered DBs (local + iCloud/sources).
+   */
+  initialize() {
+    if (this.initialized) return;
+    for (const path of this.dbPaths) {
+      try {
+        const db = new Database(path, { readonly: true });
+        this.databases.push(db);
+        this.loadContactsFromDb(db);
+      } catch (err) {
+        console.warn(`ContactsDB: could not load ${path}:`, err);
+      }
+    }
+    this.initialized = true;
+  }
+  /**
+   * Load contacts from a single Address Book SQLite DB into the shared maps.
+   */
+  loadContactsFromDb(db) {
+    const contacts = db.prepare(`
+      SELECT 
+        Z_PK as localId,
+        ZFIRSTNAME as firstName,
+        ZLASTNAME as lastName,
+        ZMIDDLENAME as middleName,
+        ZNICKNAME as nickname,
+        ZORGANIZATION as organization
+      FROM ZABCDRECORD
+      WHERE ZFIRSTNAME IS NOT NULL OR ZLASTNAME IS NOT NULL OR ZORGANIZATION IS NOT NULL
+    `).all();
+    for (const row of contacts) {
+      const localId = row.localId;
+      const phones = db.prepare(`
+        SELECT ZFULLNUMBER as number, ZLABEL as label
+        FROM ZABCDPHONENUMBER
+        WHERE ZOWNER = ? OR Z22_OWNER = ?
+      `).all(localId, localId).filter((p) => p.number);
+      const emails = db.prepare(`
+        SELECT ZADDRESS as email, ZLABEL as label
+        FROM ZABCDEMAILADDRESS
+        WHERE ZOWNER = ? OR Z22_OWNER = ?
+      `).all(localId, localId).filter((e) => e.email);
+      const existingIds = this.findExistingContactIds(
+        phones.map((p) => p.number),
+        emails.map((e) => e.email)
+      );
+      const cardNames = nameCandidates(row);
+      const sameEntityIds = existingIds.filter((id) => {
+        const existing = this.contactCache.get(id);
+        if (!existing) return false;
+        const existingNames = nameCandidates(existing);
+        if (cardNames.size === 0 || existingNames.size === 0) return true;
+        for (const n of cardNames) if (existingNames.has(n)) return true;
+        return false;
+      });
+      let contact;
+      if (sameEntityIds.length === 0) {
+        contact = {
+          id: this.nextContactId++,
+          firstName: row.firstName,
+          lastName: row.lastName,
+          middleName: row.middleName,
+          nickname: row.nickname,
+          organization: row.organization,
+          displayName: this.buildDisplayName(row),
+          phoneNumbers: [],
+          emails: []
+        };
+      } else {
+        const survivorId = sameEntityIds[0];
+        for (let i = 1; i < sameEntityIds.length; i++) {
+          this.mergeContacts(survivorId, sameEntityIds[i]);
+        }
+        contact = this.contactCache.get(survivorId);
+      }
+      const handleName = this.buildDisplayName(row);
+      for (const phone of phones) {
+        if (!contact.phoneNumbers.includes(phone.number)) contact.phoneNumbers.push(phone.number);
+        for (const variant of normalizedPhoneVariants(phone.number)) {
+          if (!this.phoneMap.has(variant)) {
+            this.phoneMap.set(variant, {
+              contactId: contact.id,
+              displayName: handleName,
+              label: phone.label
+            });
+          }
+        }
+      }
+      for (const email of emails) {
+        if (!contact.emails.includes(email.email)) contact.emails.push(email.email);
+        const key = normalizeEmail(email.email);
+        if (!this.emailMap.has(key)) {
+          this.emailMap.set(key, {
+            contactId: contact.id,
+            displayName: handleName,
+            label: email.label
+          });
+        }
+      }
+      this.contactCache.set(contact.id, contact);
+    }
+  }
+  /**
+   * Probe the already-loaded lookup maps for every existing contactId that
+   * shares any of these handles (loaded from earlier source DBs). Returns the
+   * distinct ids in first-seen order; the caller treats the first as the
+   * survivor and unions the rest. Empty when none match.
+   */
+  findExistingContactIds(phones, emails) {
+    const ids = [];
+    const seen = /* @__PURE__ */ new Set();
+    const add = (id) => {
+      if (!seen.has(id)) {
+        seen.add(id);
+        ids.push(id);
+      }
+    };
+    for (const number of phones) {
+      for (const variant of normalizedPhoneVariants(number)) {
+        const hit = this.phoneMap.get(variant);
+        if (hit) add(hit.contactId);
+      }
+    }
+    for (const email of emails) {
+      const hit = this.emailMap.get(normalizeEmail(email));
+      if (hit) add(hit.contactId);
+    }
+    return ids;
+  }
+  /**
+   * Fold contact `dropId` into `keepId`: union their phone/email lists and
+   * re-point every lookup-map entry (preserving labels) from the dropped id to
+   * the survivor, then forget the dropped id. Used when one card bridges two
+   * previously-separate identities.
+   */
+  mergeContacts(keepId, dropId) {
+    if (keepId === dropId) return;
+    const keep = this.contactCache.get(keepId);
+    const drop = this.contactCache.get(dropId);
+    if (!keep || !drop) return;
+    for (const p of drop.phoneNumbers)
+      if (!keep.phoneNumbers.includes(p)) keep.phoneNumbers.push(p);
+    for (const e of drop.emails) if (!keep.emails.includes(e)) keep.emails.push(e);
+    for (const [key, lookup] of this.phoneMap) {
+      if (lookup.contactId === dropId) {
+        this.phoneMap.set(key, { ...lookup, contactId: keepId });
+      }
+    }
+    for (const [key, lookup] of this.emailMap) {
+      if (lookup.contactId === dropId) {
+        this.emailMap.set(key, { ...lookup, contactId: keepId });
+      }
+    }
+    this.contactCache.delete(dropId);
+  }
+  /**
+   * Look up a contact by phone number or email.
+   */
+  lookupContact(handle) {
+    if (!this.initialized) {
+      this.initialize();
+    }
+    if (/[\d+\-()\s]/.test(handle)) {
+      for (const variant of normalizedPhoneVariants(handle)) {
+        const contact = this.phoneMap.get(variant);
+        if (contact) {
+          return contact;
+        }
+      }
+    }
+    if (handle.includes("@")) {
+      const normalized = normalizeEmail(handle);
+      const contact = this.emailMap.get(normalized);
+      if (contact) {
+        return contact;
+      }
+    }
+    return null;
+  }
+  /**
+   * Look up a contact by phone number or email
+   * Returns display name if found, or the original handle if not
+   */
+  lookupHandle(handle) {
+    return this.lookupContact(handle)?.displayName ?? handle;
+  }
+  /**
+   * Get full contact details by ID
+   */
+  getContact(id) {
+    if (!this.initialized) {
+      this.initialize();
+    }
+    return this.contactCache.get(id) || null;
+  }
+  /**
+   * A load-order-independent identity anchor for a contact: the
+   * lexicographically smallest normalized handle. Contact ids are assigned in
+   * Address Book load order, so they renumber whenever any card is added or
+   * removed — anything persisted across sessions (thread-slug hashes) must key
+   * off this anchor instead, which only changes if the contact's own handles
+   * change.
+   */
+  stableAnchor(contactId) {
+    const contact = this.getContact(contactId);
+    if (!contact) return null;
+    const handles = [
+      ...contact.phoneNumbers.map((p) => normalizePhoneNumber(p)),
+      ...contact.emails.map((e) => normalizeEmail(e))
+    ].filter((h) => h.length > 0);
+    if (handles.length === 0) return null;
+    handles.sort();
+    return handles[0];
+  }
+  /**
+   * Search contacts by name
+   */
+  searchContacts(query) {
+    if (!this.initialized) {
+      this.initialize();
+    }
+    const lowerQuery = query.toLowerCase();
+    return Array.from(this.contactCache.values()).filter(
+      (c) => c.displayName.toLowerCase().includes(lowerQuery) || c.phoneNumbers.some((p) => p.includes(query)) || c.emails.some((e) => e.toLowerCase().includes(lowerQuery))
+    );
+  }
+  /**
+   * Build display name from contact fields
+   */
+  buildDisplayName(row) {
+    if (row.nickname) return row.nickname;
+    const parts = [];
+    if (row.firstName) parts.push(row.firstName);
+    if (row.lastName) parts.push(row.lastName);
+    if (parts.length > 0) {
+      return parts.join(" ");
+    }
+    if (row.organization) return row.organization;
+    return "Unknown Contact";
+  }
+  /**
+   * Close all database connections
+   */
+  close() {
+    for (const db of this.databases) {
+      try {
+        db.close();
+      } catch {
+      }
+    }
+    this.databases = [];
+  }
+  /**
+   * Paginated list of all loaded contacts, sorted by displayName.
+   * Used by the MCP `list_contacts` tool.
+   */
+  listContacts(offset = 0, limit = 20) {
+    if (!this.initialized) {
+      this.initialize();
+    }
+    const all = Array.from(this.contactCache.values()).sort(
+      (a, b) => a.displayName.localeCompare(b.displayName)
+    );
+    const slice = limit === 0 ? all.slice(offset) : all.slice(offset, offset + limit);
+    return { contacts: slice, total: all.length };
+  }
+  /**
+   * Get statistics about loaded contacts
+   */
+  getStats() {
+    if (!this.initialized) {
+      this.initialize();
+    }
+    return {
+      totalContacts: this.contactCache.size,
+      phoneNumbers: this.phoneMap.size,
+      emails: this.emailMap.size
+    };
+  }
+}
 const __dirname$1 = dirname(fileURLToPath(import.meta.url));
 let _native;
 function tryLoadNative() {
@@ -307,317 +674,59 @@ function normalizeCandidate(text) {
 function scoreCandidate(text) {
   let score = 0;
   if (/[A-Za-z]/.test(text)) score += 50;
-  if (/\d/.test(text)) score += 10;
-  if (/\s/.test(text)) score += 30;
-  if (/[.!?]/.test(text)) score += 15;
-  if (/[\u{1F300}-\u{1FAFF}]/u.test(text)) score += 100;
-  if (/^[A-Za-z0-9]{1,3}$/.test(text)) score -= 100;
-  score += Math.min(text.length, 200);
-  return score;
-}
-const STRUCTURED_BOOST = 500;
-function extractAttributedBodyText(blob) {
-  if (!blob) return void 0;
-  const native = getNativeParser();
-  if (native) {
-    try {
-      const result = native(blob);
-      if (result && result.length > 1 && nativeResultLooksTrustworthy(result)) {
-        return result;
-      }
-    } catch {
-    }
-  }
-  const parser = new TypedStreamParser(blob);
-  const candidates = /* @__PURE__ */ new Map();
-  const deadline = Date.now() + PARSE_TIMEOUT_MS;
-  const remember = (values, boost = 0) => {
-    for (const value of values) {
-      const normalized = normalizeCandidate(value);
-      if (!normalized) continue;
-      const score = scoreCandidate(normalized) + boost;
-      const prev = candidates.get(normalized) ?? -Infinity;
-      if (score > prev) candidates.set(normalized, score);
-    }
-  };
-  try {
-    if (Date.now() < deadline) {
-      remember(
-        parser.parseAllNSStrings().map((entry) => entry.content),
-        STRUCTURED_BOOST
-      );
-    }
-  } catch {
-  }
-  try {
-    if (Date.now() < deadline) {
-      remember(parser.extractReadableText());
-    }
-  } catch {
-  }
-  if (Date.now() < deadline) {
-    remember(blob.toString("utf8").split(CONTROL_SPLIT_RE));
-  }
-  const best = [...candidates.entries()].sort((a, b) => b[1] - a[1])[0];
-  return best?.[0];
-}
-function normalizePhoneNumber(phone) {
-  const digits = phone.replace(/\D/g, "");
-  if (digits.length === 11 && digits.startsWith("1")) {
-    return digits.slice(1);
-  }
-  return digits;
-}
-function normalizedPhoneVariants(phone) {
-  const normalized = normalizePhoneNumber(phone);
-  const variants = /* @__PURE__ */ new Set([normalized]);
-  if (normalized.length === 11 && normalized.startsWith("61")) {
-    const localMobile = normalized.slice(2);
-    variants.add(localMobile);
-    if (localMobile.length === 9 && localMobile.startsWith("4")) {
-      variants.add(`0${localMobile}`);
-    }
-  }
-  if (normalized.length === 10 && normalized.startsWith("04")) {
-    const mobileDigits = normalized.slice(1);
-    variants.add(mobileDigits);
-    variants.add(`61${mobileDigits}`);
-  }
-  if (normalized.length === 10) {
-    variants.add(`1${normalized}`);
-  }
-  if (normalized.length === 9 && normalized.startsWith("4")) {
-    variants.add(`61${normalized}`);
-    variants.add(`0${normalized}`);
-  }
-  return [...variants];
-}
-function normalizeEmail(email) {
-  return email.toLowerCase().trim();
-}
-const ADDRESS_BOOK_DIR = join(homedir(), "Library", "Application Support", "AddressBook");
-const MAIN_DB_NAME = "AddressBook-v22.abcddb";
-function discoverContactDbPaths(customPaths) {
-  if (customPaths) {
-    const list = Array.isArray(customPaths) ? customPaths : [customPaths];
-    return list.filter((p) => existsSync(p));
-  }
-  const paths = [];
-  const mainDb = join(ADDRESS_BOOK_DIR, MAIN_DB_NAME);
-  if (existsSync(mainDb)) paths.push(mainDb);
-  const sourcesDir = join(ADDRESS_BOOK_DIR, "Sources");
-  if (existsSync(sourcesDir)) {
-    try {
-      const subdirs = readdirSync(sourcesDir, { withFileTypes: true });
-      for (const d of subdirs) {
-        if (!d.isDirectory()) continue;
-        const sourceDb = join(sourcesDir, d.name, MAIN_DB_NAME);
-        if (existsSync(sourceDb)) paths.push(sourceDb);
-      }
-    } catch {
-    }
-  }
-  return paths;
-}
-class ContactsDB {
-  dbPaths = [];
-  databases = [];
-  phoneMap = /* @__PURE__ */ new Map();
-  emailMap = /* @__PURE__ */ new Map();
-  contactCache = /* @__PURE__ */ new Map();
-  initialized = false;
-  /** Next id when loading from multiple DBs (avoids Z_PK collisions across sources). */
-  nextContactId = 1;
-  constructor(dbPaths) {
-    this.dbPaths = discoverContactDbPaths(dbPaths);
-  }
-  /**
-   * Initialize the contact lookup maps from all discovered DBs (local + iCloud/sources).
-   */
-  initialize() {
-    if (this.initialized) return;
-    for (const path of this.dbPaths) {
-      try {
-        const db = new Database(path, { readonly: true });
-        this.databases.push(db);
-        this.loadContactsFromDb(db);
-      } catch (err) {
-        console.warn(`ContactsDB: could not load ${path}:`, err);
-      }
-    }
-    this.initialized = true;
-  }
-  /**
-   * Load contacts from a single Address Book SQLite DB into the shared maps.
-   */
-  loadContactsFromDb(db) {
-    const contacts = db.prepare(`
-      SELECT 
-        Z_PK as localId,
-        ZFIRSTNAME as firstName,
-        ZLASTNAME as lastName,
-        ZMIDDLENAME as middleName,
-        ZNICKNAME as nickname,
-        ZORGANIZATION as organization
-      FROM ZABCDRECORD
-      WHERE ZFIRSTNAME IS NOT NULL OR ZLASTNAME IS NOT NULL OR ZORGANIZATION IS NOT NULL
-    `).all();
-    for (const row of contacts) {
-      const globalId = this.nextContactId++;
-      const contact = {
-        id: globalId,
-        firstName: row.firstName,
-        lastName: row.lastName,
-        middleName: row.middleName,
-        nickname: row.nickname,
-        organization: row.organization,
-        displayName: this.buildDisplayName(row),
-        phoneNumbers: [],
-        emails: []
-      };
-      const localId = row.localId;
-      const phones = db.prepare(`
-        SELECT ZFULLNUMBER as number, ZLABEL as label
-        FROM ZABCDPHONENUMBER
-        WHERE ZOWNER = ? OR Z22_OWNER = ?
-      `).all(localId, localId);
-      for (const phone of phones) {
-        if (phone.number) {
-          contact.phoneNumbers.push(phone.number);
-          const lookup = {
-            contactId: contact.id,
-            displayName: contact.displayName,
-            label: phone.label
-          };
-          for (const variant of normalizedPhoneVariants(phone.number)) {
-            this.phoneMap.set(variant, lookup);
-          }
-        }
-      }
-      const emails = db.prepare(`
-        SELECT ZADDRESS as email, ZLABEL as label
-        FROM ZABCDEMAILADDRESS
-        WHERE ZOWNER = ? OR Z22_OWNER = ?
-      `).all(localId, localId);
-      for (const email of emails) {
-        if (email.email) {
-          contact.emails.push(email.email);
-          const normalized = normalizeEmail(email.email);
-          this.emailMap.set(normalized, {
-            contactId: contact.id,
-            displayName: contact.displayName,
-            label: email.label
-          });
-        }
-      }
-      this.contactCache.set(contact.id, contact);
-    }
-  }
-  /**
-   * Look up a contact by phone number or email.
-   */
-  lookupContact(handle) {
-    if (!this.initialized) {
-      this.initialize();
-    }
-    if (/[\d+\-()\s]/.test(handle)) {
-      for (const variant of normalizedPhoneVariants(handle)) {
-        const contact = this.phoneMap.get(variant);
-        if (contact) {
-          return contact;
-        }
-      }
-    }
-    if (handle.includes("@")) {
-      const normalized = normalizeEmail(handle);
-      const contact = this.emailMap.get(normalized);
-      if (contact) {
-        return contact;
+  if (/\d/.test(text)) score += 10;
+  if (/\s/.test(text)) score += 30;
+  if (/[.!?]/.test(text)) score += 15;
+  if (/[\u{1F300}-\u{1FAFF}]/u.test(text)) score += 100;
+  if (/^[A-Za-z0-9]{1,3}$/.test(text)) score -= 100;
+  score += Math.min(text.length, 200);
+  return score;
+}
+const STRUCTURED_BOOST = 500;
+function extractAttributedBodyText(blob) {
+  if (!blob) return void 0;
+  const native = getNativeParser();
+  if (native) {
+    try {
+      const result = native(blob);
+      if (result && result.length > 1 && nativeResultLooksTrustworthy(result)) {
+        return result;
       }
+    } catch {
     }
-    return null;
-  }
-  /**
-   * Look up a contact by phone number or email
-   * Returns display name if found, or the original handle if not
-   */
-  lookupHandle(handle) {
-    return this.lookupContact(handle)?.displayName ?? handle;
-  }
-  /**
-   * Get full contact details by ID
-   */
-  getContact(id) {
-    if (!this.initialized) {
-      this.initialize();
-    }
-    return this.contactCache.get(id) || null;
-  }
-  /**
-   * Search contacts by name
-   */
-  searchContacts(query) {
-    if (!this.initialized) {
-      this.initialize();
-    }
-    const lowerQuery = query.toLowerCase();
-    return Array.from(this.contactCache.values()).filter(
-      (c) => c.displayName.toLowerCase().includes(lowerQuery) || c.phoneNumbers.some((p) => p.includes(query)) || c.emails.some((e) => e.toLowerCase().includes(lowerQuery))
-    );
   }
-  /**
-   * Build display name from contact fields
-   */
-  buildDisplayName(row) {
-    if (row.nickname) return row.nickname;
-    const parts = [];
-    if (row.firstName) parts.push(row.firstName);
-    if (row.lastName) parts.push(row.lastName);
-    if (parts.length > 0) {
-      return parts.join(" ");
+  const parser = new TypedStreamParser(blob);
+  const candidates = /* @__PURE__ */ new Map();
+  const deadline = Date.now() + PARSE_TIMEOUT_MS;
+  const remember = (values, boost = 0) => {
+    for (const value of values) {
+      const normalized = normalizeCandidate(value);
+      if (!normalized) continue;
+      const score = scoreCandidate(normalized) + boost;
+      const prev = candidates.get(normalized) ?? -Infinity;
+      if (score > prev) candidates.set(normalized, score);
     }
-    if (row.organization) return row.organization;
-    return "Unknown Contact";
-  }
-  /**
-   * Close all database connections
-   */
-  close() {
-    for (const db of this.databases) {
-      try {
-        db.close();
-      } catch {
-      }
+  };
+  try {
+    if (Date.now() < deadline) {
+      remember(
+        parser.parseAllNSStrings().map((entry) => entry.content),
+        STRUCTURED_BOOST
+      );
     }
-    this.databases = [];
+  } catch {
   }
-  /**
-   * Paginated list of all loaded contacts, sorted by displayName.
-   * Used by the MCP `list_contacts` tool.
-   */
-  listContacts(offset = 0, limit = 20) {
-    if (!this.initialized) {
-      this.initialize();
+  try {
+    if (Date.now() < deadline) {
+      remember(parser.extractReadableText());
     }
-    const all = Array.from(this.contactCache.values()).sort(
-      (a, b) => a.displayName.localeCompare(b.displayName)
-    );
-    const slice = limit === 0 ? all.slice(offset) : all.slice(offset, offset + limit);
-    return { contacts: slice, total: all.length };
+  } catch {
   }
-  /**
-   * Get statistics about loaded contacts
-   */
-  getStats() {
-    if (!this.initialized) {
-      this.initialize();
-    }
-    return {
-      totalContacts: this.contactCache.size,
-      phoneNumbers: this.phoneMap.size,
-      emails: this.emailMap.size
-    };
+  if (Date.now() < deadline) {
+    remember(blob.toString("utf8").split(CONTROL_SPLIT_RE));
   }
+  const best = [...candidates.entries()].sort((a, b) => b[1] - a[1])[0];
+  return best?.[0];
 }
 function normalizeSnippetText(text) {
   if (!text) return null;
@@ -723,20 +832,42 @@ class SlugStore {
     this.db.pragma("journal_mode = WAL");
     this.migrate();
   }
+  /**
+   * Schema. v2 splits identity-level slug rows from a many-to-one guid map so a
+   * single canonical slug can cover every chat leg of one contact (phone + email,
+   * SMS + iMessage). v1 keyed a slug to exactly one guid, so a merged identity
+   * produced multiple slugs whose surfaced one flipped with recency.
+   */
   migrate() {
+    const version = this.db.pragma("user_version", { simple: true }) ?? 0;
+    if (version < 2) {
+      this.db.exec("DROP TABLE IF EXISTS thread_slugs");
+      this.db.exec("DROP TABLE IF EXISTS slug_chat_guids");
+    }
     this.db.exec(`
       CREATE TABLE IF NOT EXISTS thread_slugs (
         slug            TEXT PRIMARY KEY,
-        chat_guid       TEXT UNIQUE NOT NULL,
         chat_identifier TEXT NOT NULL,
         display_name    TEXT,
         service         TEXT NOT NULL DEFAULT 'iMessage',
         is_group        INTEGER NOT NULL DEFAULT 0,
         participants    TEXT NOT NULL DEFAULT '',
         updated_at      INTEGER NOT NULL DEFAULT 0
-      )
+      );
+      CREATE TABLE IF NOT EXISTS slug_chat_guids (
+        chat_guid TEXT PRIMARY KEY,
+        slug      TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_slug_chat_guids_slug ON slug_chat_guids(slug);
     `);
+    this.db.pragma("user_version = 2");
   }
+  /**
+   * Upsert one chat leg under its identity slug. The identity row is keyed by
+   * slug (idempotent across legs); the leg's guid is mapped to that slug. When
+   * an identity already has a phone `chat_identifier`, a later email leg does
+   * NOT overwrite it — phone is preferred as the canonical handle for stability.
+   */
   upsert(record) {
     const params = {
       slug: record.slug,
@@ -748,33 +879,28 @@ class SlugStore {
       participants: record.participants,
       updatedAt: record.updatedAt
     };
-    const updateByGuid = this.db.prepare(`
-      UPDATE thread_slugs
-      SET
-        slug = @slug,
-        chat_identifier = @chatIdentifier,
-        display_name = @displayName,
-        service = @service,
-        is_group = @isGroup,
-        participants = @participants,
-        updated_at = @updatedAt
-      WHERE chat_guid = @chatGuid
-    `);
-    const updateResult = updateByGuid.run(params);
-    if (updateResult.changes > 0) return;
-    const insertOrUpdateBySlug = this.db.prepare(`
-      INSERT INTO thread_slugs (slug, chat_guid, chat_identifier, display_name, service, is_group, participants, updated_at)
-      VALUES (@slug, @chatGuid, @chatIdentifier, @displayName, @service, @isGroup, @participants, @updatedAt)
-      ON CONFLICT(slug) DO UPDATE SET
-        chat_guid = excluded.chat_guid,
-        chat_identifier = excluded.chat_identifier,
-        display_name = excluded.display_name,
-        service = excluded.service,
-        is_group = excluded.is_group,
-        participants = excluded.participants,
-        updated_at = excluded.updated_at
-    `);
-    insertOrUpdateBySlug.run(params);
+    const tx = this.db.transaction(() => {
+      this.db.prepare(`
+          INSERT INTO thread_slugs (slug, chat_identifier, display_name, service, is_group, participants, updated_at)
+          VALUES (@slug, @chatIdentifier, @displayName, @service, @isGroup, @participants, @updatedAt)
+          ON CONFLICT(slug) DO UPDATE SET
+            chat_identifier = CASE
+              WHEN instr(thread_slugs.chat_identifier, '@') = 0 AND instr(excluded.chat_identifier, '@') > 0
+                THEN thread_slugs.chat_identifier
+              ELSE excluded.chat_identifier
+            END,
+            display_name = excluded.display_name,
+            service = excluded.service,
+            is_group = excluded.is_group,
+            participants = excluded.participants,
+            updated_at = excluded.updated_at
+        `).run(params);
+      this.db.prepare(`
+          INSERT INTO slug_chat_guids (chat_guid, slug) VALUES (@chatGuid, @slug)
+          ON CONFLICT(chat_guid) DO UPDATE SET slug = excluded.slug
+        `).run(params);
+    });
+    tx();
   }
   upsertMany(records) {
     const tx = this.db.transaction((recs) => {
@@ -784,39 +910,56 @@ class SlugStore {
   }
   lookupBySlug(slug) {
     const row = this.db.prepare("SELECT * FROM thread_slugs WHERE slug = ?").get(slug);
-    return row ? this.rowToRecord(row) : null;
+    return row ? this.rowToRecord(row, this.representativeGuid(slug)) : null;
   }
   lookupByGuid(chatGuid) {
-    const row = this.db.prepare("SELECT * FROM thread_slugs WHERE chat_guid = ?").get(chatGuid);
-    return row ? this.rowToRecord(row) : null;
+    const link = this.db.prepare("SELECT slug FROM slug_chat_guids WHERE chat_guid = ?").get(chatGuid);
+    if (!link) return null;
+    const row = this.db.prepare("SELECT * FROM thread_slugs WHERE slug = ?").get(link.slug);
+    return row ? this.rowToRecord(row, chatGuid) : null;
   }
   lookupByChatIdentifier(chatIdentifier) {
     const row = this.db.prepare("SELECT * FROM thread_slugs WHERE chat_identifier = ?").get(chatIdentifier);
-    return row ? this.rowToRecord(row) : null;
+    return row ? this.rowToRecord(row, this.representativeGuid(row.slug)) : null;
   }
   all() {
     const rows = this.db.prepare("SELECT * FROM thread_slugs ORDER BY updated_at DESC").all();
-    return rows.map((r) => this.rowToRecord(r));
+    return rows.map((r) => this.rowToRecord(r, this.representativeGuid(r.slug)));
+  }
+  /** Every guid→slug link (used to rebuild the in-memory guid map on startup). */
+  guidLinks() {
+    const rows = this.db.prepare("SELECT chat_guid, slug FROM slug_chat_guids").all();
+    return rows.map((r) => ({ chatGuid: r.chat_guid, slug: r.slug }));
   }
-  /** Remove slugs whose chat_guid is not in the given set of valid guids. */
+  /** A stable representative guid for a slug (lowest guid, or "" if none). */
+  representativeGuid(slug) {
+    const row = this.db.prepare("SELECT MIN(chat_guid) as guid FROM slug_chat_guids WHERE slug = ?").get(slug);
+    return row?.guid ?? "";
+  }
+  /**
+   * Drop guid links whose chat_guid is not in the valid set, then any identity
+   * slug left with no guids. Returns the number of guid links removed.
+   */
   prune(validGuids) {
-    const all = this.db.prepare("SELECT slug, chat_guid FROM thread_slugs").all();
-    const toDelete = all.filter((r) => !validGuids.has(r.chat_guid));
-    if (toDelete.length === 0) return 0;
-    const del = this.db.prepare("DELETE FROM thread_slugs WHERE slug = ?");
-    const tx = this.db.transaction((slugs) => {
-      for (const s of slugs) del.run(s);
+    const links = this.db.prepare("SELECT chat_guid FROM slug_chat_guids").all();
+    const toDelete = links.filter((r) => !validGuids.has(r.chat_guid)).map((r) => r.chat_guid);
+    const tx = this.db.transaction(() => {
+      const delLink = this.db.prepare("DELETE FROM slug_chat_guids WHERE chat_guid = ?");
+      for (const guid of toDelete) delLink.run(guid);
+      this.db.exec(
+        "DELETE FROM thread_slugs WHERE slug NOT IN (SELECT DISTINCT slug FROM slug_chat_guids)"
+      );
     });
-    tx(toDelete.map((r) => r.slug));
+    tx();
     return toDelete.length;
   }
   close() {
     this.db.close();
   }
-  rowToRecord(row) {
+  rowToRecord(row, chatGuid) {
     return {
       slug: row.slug,
-      chatGuid: row.chat_guid,
+      chatGuid,
       chatIdentifier: row.chat_identifier,
       displayName: row.display_name,
       service: row.service,
@@ -880,6 +1023,9 @@ function getRichContentType(balloonBundleId) {
   return "unknown";
 }
 const macTimestampToDate = macTimestampToDate$1;
+function dateToMacTimestamp(date) {
+  return Math.floor((date.getTime() / 1e3 - MAC_EPOCH_OFFSET) * NANOS_PER_SECOND);
+}
 class IMessageDB {
   raw;
   dbPath;
@@ -890,6 +1036,8 @@ class IMessageDB {
   slugMap = /* @__PURE__ */ new Map();
   /** In-memory chat guid -> slug for stable per-chat slug lookups. */
   guidToSlug = /* @__PURE__ */ new Map();
+  /** Per-sync canonical service per identity key (prefer iMessage) for slugs. */
+  identityServiceMap = null;
   // ── TTL caches ───────────────────────────────────────────────────────
   static CACHE_TTL_MS = 3e4;
   cachedAllChats = null;
@@ -898,8 +1046,22 @@ class IMessageDB {
   cachedParticipants = /* @__PURE__ */ new Map();
   cachedMergeKeys = /* @__PURE__ */ new Map();
   cachedSnippets = /* @__PURE__ */ new Map();
+  /**
+   * Per-chat reaction map (guid → reactions), TTL-cached. A large export pages
+   * the same merged chats dozens of times; without this, every page re-scanned
+   * each chat's full reaction set — O(pages × chats) — which dominated big
+   * exports and spiked event-loop lag.
+   *
+   * Invalidation contract: entries expire via their per-entry TTL on read, and
+   * the whole map is cleared only in scheduleBackgroundRefresh() — every read
+   * path that can observe new messages schedules that refresh, so there is no
+   * other clear site. Add one if you introduce a read path that bypasses it.
+   */
+  cachedReactionsByChat = /* @__PURE__ */ new Map();
   backgroundSyncNeeded = true;
   backgroundRefreshScheduled = false;
+  /** Set on close() so background chunked work stops touching a closed DB. */
+  closed = false;
   constructor(dbPath, contactsDbPaths, slugStorePath) {
     const span = perf("IMessageDB.constructor");
     this.dbPath = dbPath || join(homedir(), "Library", "Messages", "chat.db");
@@ -923,9 +1085,11 @@ class IMessageDB {
    */
   loadCachedSlugs() {
     const span = perf("loadCachedSlugs");
+    for (const link of this.slugStore.guidLinks()) {
+      this.guidToSlug.set(link.chatGuid, link.slug);
+    }
     const records = this.slugStore.all();
     for (const r of records) {
-      this.guidToSlug.set(r.chatGuid, r.slug);
       this.slugMap.set(r.slug, {
         ROWID: 0,
         // placeholder -- will be filled on full sync
@@ -938,24 +1102,53 @@ class IMessageDB {
     }
     span.end({ loaded: records.length });
   }
-  /** Generate and cache a slug for a single chat. */
-  syncSlugForChat(chat) {
+  /**
+   * Compute the canonical slug for a chat without persisting anything.
+   *
+   * Identity key: every chat leg of one contact (phone + email, SMS +
+   * iMessage) shares this, so they collapse to ONE stable slug. Groups stay
+   * per-guid. Mirrors getConversationMergeKey so the slug tracks the merge.
+   * The service segment is identity-wide (prefer iMessage) — otherwise the
+   * SMS leg and iMessage leg of one contact would produce `…~sms~h` and
+   * `…~imsg~h`, i.e. two slugs.
+   */
+  computeSlugForChat(chat) {
     const isGroup = isGroupGuid(chat.guid) || isGroupChatIdentifier(chat.chat_identifier);
-    const resolvedName = !isGroup && chat.chat_identifier ? this.contacts.lookupHandle(chat.chat_identifier) : null;
+    const mergeKey = isGroup ? `group:${chat.guid}` : this.getConversationMergeKey(chat.chat_identifier, chat.guid, false);
+    const canonicalService = isGroup ? this.detectServiceForChat(chat) : this.identityServiceMap?.get(mergeKey) ?? this.detectServiceForChat(chat);
+    let identityKey = mergeKey;
+    let resolvedName = null;
+    if (!isGroup && chat.chat_identifier) {
+      const lookup = this.contacts.lookupContact(chat.chat_identifier);
+      if (lookup) {
+        const anchor = this.contacts.stableAnchor(lookup.contactId);
+        if (anchor) identityKey = `contact:${anchor}`;
+        resolvedName = this.contacts.getContact(lookup.contactId)?.displayName ?? lookup.displayName;
+      } else {
+        const fallback = this.contacts.lookupHandle(chat.chat_identifier);
+        resolvedName = fallback !== chat.chat_identifier ? fallback : null;
+      }
+    }
     const slug = generateThreadSlug({
       chatIdentifier: chat.chat_identifier,
       guid: chat.guid,
       displayName: chat.display_name,
-      serviceName: chat.service_name ?? null,
-      resolvedContactName: resolvedName !== chat.chat_identifier ? resolvedName : null
+      serviceName: canonicalService,
+      resolvedContactName: resolvedName,
+      identityKey
     });
+    return { slug, isGroup, resolvedName, canonicalService };
+  }
+  /** Generate and cache a slug for a single chat. */
+  syncSlugForChat(chat) {
+    const { slug, isGroup, resolvedName, canonicalService } = this.computeSlugForChat(chat);
     const participants = isGroup ? this.fetchChatParticipants(chat.ROWID) : [chat.chat_identifier];
     this.slugStore.upsert({
       slug,
       chatGuid: chat.guid,
       chatIdentifier: chat.chat_identifier,
-      displayName: resolvedName !== chat.chat_identifier ? resolvedName : chat.display_name || null,
-      service: this.detectServiceForChat(chat),
+      displayName: resolvedName ?? chat.display_name ?? null,
+      service: canonicalService,
       isGroup,
       participants: participants.join(","),
       updatedAt: Date.now()
@@ -973,21 +1166,30 @@ class IMessageDB {
     this.backgroundSyncNeeded = false;
     const span = perf("backgroundSlugSync");
     const chats = this.getAllChatsWithLastDate();
+    const identityService = /* @__PURE__ */ new Map();
+    for (const c of chats) {
+      if (isGroupGuid(c.guid) || isGroupChatIdentifier(c.chat_identifier)) continue;
+      const key = this.getConversationMergeKey(c.chat_identifier, c.guid, false);
+      const svc = this.detectServiceForChat(c);
+      if (svc === "iMessage" || !identityService.has(key)) identityService.set(key, svc);
+    }
+    this.identityServiceMap = identityService;
     const validGuids = /* @__PURE__ */ new Set();
     let index = 0;
     let synced = 0;
     const CHUNK = 100;
     const processChunk = () => {
+      if (this.closed) return;
       const end = Math.min(index + CHUNK, chats.length);
       for (; index < end; index++) {
         const chat = chats[index];
         validGuids.add(chat.guid);
-        if (!this.guidToSlug.has(chat.guid)) {
+        const expected = this.computeSlugForChat(chat).slug;
+        if (this.guidToSlug.get(chat.guid) !== expected) {
           this.syncSlugForChat(chat);
           synced++;
         } else {
-          const existingSlug = this.guidToSlug.get(chat.guid);
-          this.slugMap.set(existingSlug, chat);
+          this.slugMap.set(expected, chat);
         }
       }
       if (index < chats.length) {
@@ -1102,13 +1304,17 @@ class IMessageDB {
       return [];
     }
     const perChatLimit = Math.max(limit * 2, 50);
+    const beforeDate = beforeMessageId != null ? this.dateOfMessage(beforeMessageId) : void 0;
+    const afterDate = afterMessageId != null ? this.dateOfMessage(afterMessageId) : void 0;
     const result = /* @__PURE__ */ new Map();
     for (const chat of chats) {
       const rows = this.fetchMessagesForChatRowId(
         chat.ROWID,
         perChatLimit,
         beforeMessageId,
-        afterMessageId
+        afterMessageId,
+        beforeDate,
+        afterDate
       );
       const extBatch = this.fetchExtendedMessageDataBatch(rows.map((r) => r.ROWID));
       const reactionsByGuid = includeReactionDetails ? this.fetchReactionsForChat(chat.ROWID) : void 0;
@@ -1139,6 +1345,140 @@ class IMessageDB {
     span.end({ limit, chats: chats.length, returned: sorted.length });
     return sorted;
   }
+  /**
+   * Get one chronological export page for a conversation.
+   *
+   * This deliberately does not use getMessagesForChat's ROWID-only
+   * beforeMessageId contract. Exports need to walk the whole conversation in
+   * display order across every chat row that resolves to the same visible
+   * thread, dedupe messages linked to multiple chats before applying LIMIT,
+   * and avoid letting reaction/system rows consume page slots.
+   */
+  async getMessagesForChatExportPage(chatIdentifier, limit = 1e3, options = {}) {
+    const span = perf("getMessagesForChatExportPage");
+    const {
+      includeReactions = false,
+      includeReactionDetails = false,
+      afterCursor,
+      since,
+      until
+    } = options;
+    const pageLimit = Math.max(1, limit);
+    const chats = this.resolveChatsForConversation(chatIdentifier);
+    if (chats.length === 0) {
+      span.end({ limit: pageLimit, returned: 0 });
+      return { messages: [], nextCursor: null, rawCount: 0 };
+    }
+    const chatIds = chats.map((chat) => chat.ROWID);
+    const chatPlaceholders = chatIds.map(() => "?").join(",");
+    const conditions = [
+      `cmj.chat_id IN (${chatPlaceholders})`,
+      "COALESCE(m.item_type, 0) = 0"
+    ];
+    const params = [...chatIds];
+    if (!includeReactions) {
+      conditions.push(`COALESCE(m.associated_message_type, 0) = ${AssociatedMessageType.NORMAL}`);
+    }
+    if (afterCursor) {
+      conditions.push("(m.date > ? OR (m.date = ? AND m.ROWID > ?))");
+      params.push(afterCursor.date, afterCursor.date, afterCursor.rowid);
+    }
+    if (since) {
+      conditions.push("m.date >= ?");
+      params.push(dateToMacTimestamp(since));
+    }
+    if (until) {
+      conditions.push("m.date <= ?");
+      params.push(dateToMacTimestamp(until));
+    }
+    params.push(pageLimit);
+    const stmt = this.raw.prepare(`
+      WITH target_messages AS (
+        SELECT
+          m.ROWID,
+          m.date,
+          MIN(c.chat_identifier) as chat_identifier
+        FROM ${Tables.MESSAGE} m
+        JOIN ${Tables.CHAT_MESSAGE_JOIN} cmj ON m.ROWID = cmj.message_id
+        JOIN ${Tables.CHAT} c ON c.ROWID = cmj.chat_id
+        WHERE ${conditions.join("\n          AND ")}
+        GROUP BY m.ROWID, m.date
+        ORDER BY m.date ASC, m.ROWID ASC
+        LIMIT ?
+      )
+      SELECT
+        m.ROWID,
+        m.guid,
+        m.text,
+        m.attributedBody,
+        m.date,
+        m.is_from_me,
+        h.id as handle_id,
+        h.service as handle_service,
+        m.cache_has_attachments,
+        tm.chat_identifier,
+        m.is_read,
+        m.date_read,
+        m.is_delivered,
+        m.date_delivered,
+        m.associated_message_type,
+        m.associated_message_guid,
+        m.associated_message_emoji,
+        m.thread_originator_guid,
+        m.thread_originator_part,
+        m.balloon_bundle_id,
+        m.item_type,
+        m.date_edited,
+        m.date_retracted,
+        m.message_summary_info,
+        m.payload_data
+      FROM target_messages tm
+      JOIN ${Tables.MESSAGE} m ON m.ROWID = tm.ROWID
+      LEFT JOIN ${Tables.HANDLE} h ON m.handle_id = h.ROWID
+      ORDER BY tm.date ASC, tm.ROWID ASC
+    `);
+    const rows = stmt.all(...params);
+    const reactionsByGuid = /* @__PURE__ */ new Map();
+    if (includeReactionDetails) {
+      for (const chat of chats) {
+        for (const [guid, reactions] of this.fetchReactionsForChat(chat.ROWID)) {
+          const existing = reactionsByGuid.get(guid);
+          if (existing) existing.push(...reactions);
+          else reactionsByGuid.set(guid, [...reactions]);
+        }
+      }
+    }
+    const messages = [];
+    for (const row of rows) {
+      const text = this.parseMessageText(row);
+      if (isHiddenSystemItem(row.item_type)) continue;
+      const converted = this.convertMessage(
+        row,
+        text,
+        row.chat_identifier ?? chatIdentifier,
+        row,
+        false
+      );
+      if (!includeReactions && converted.isReaction) continue;
+      if (includeReactionDetails && !converted.isReaction) {
+        const reactions = reactionsByGuid.get(row.guid);
+        if (reactions && reactions.length > 0) {
+          converted.reactions = this.consolidateReactions(reactions);
+          if (converted.reactions.length === 0) converted.reactions = void 0;
+        }
+      }
+      messages.push(converted);
+    }
+    const lastRow = rows[rows.length - 1];
+    const nextCursor = lastRow ? { date: lastRow.date, rowid: lastRow.ROWID } : null;
+    span.end({
+      limit: pageLimit,
+      chats: chats.length,
+      rows: rows.length,
+      returned: messages.length
+    });
+    return { messages, nextCursor, rawCount: rows.length };
+  }
   /**
    * Get unread messages across all conversations, sorted by date descending (newest first).
    * Excludes reactions for cleaner output.
@@ -1195,7 +1535,7 @@ class IMessageDB {
    */
   async getMessagesAfter(chatIdentifier, afterMessageId) {
     const messages = await this.getMessagesForChat(chatIdentifier, 1e3, { afterMessageId });
-    const filtered = messages.filter((m) => m.id > afterMessageId && !m.isFromMe);
+    const filtered = messages.filter((m) => m.id !== afterMessageId && !m.isFromMe);
     filtered.sort((a, b) => a.date.getTime() - b.date.getTime());
     return filtered;
   }
@@ -1215,8 +1555,7 @@ class IMessageDB {
       last: lastByChat[chat.ROWID]
     }));
     sortEntries.sort((a, b) => b.lastDate - a.lastDate);
-    const candidates = sortEntries.slice(0, limit * 3);
-    const prepared = candidates.map(({ chat, isGroup, last }) => {
+    const enrich = ({ chat, isGroup, last }) => {
       const lastDate = last ? macTimestampToDate(last.lastDate) : null;
       const rawIdentifier = chat.chat_identifier;
       let displayName = chat.display_name;
@@ -1246,8 +1585,17 @@ class IMessageDB {
           serviceType
         }
       };
-    });
-    const deduped = this.mergeDuplicateConversations(prepared);
+    };
+    const CHUNK = Math.max(limit, 200);
+    const prepared = [];
+    let cursor = 0;
+    let deduped = this.mergeDuplicateConversations(prepared);
+    while (deduped.length < limit && cursor < sortEntries.length) {
+      const chunk = sortEntries.slice(cursor, cursor + CHUNK);
+      cursor += chunk.length;
+      for (const entry of chunk) prepared.push(enrich(entry));
+      deduped = this.mergeDuplicateConversations(prepared);
+    }
     const selected = deduped.slice(0, limit);
     const result = selected.map(({ conversation, last }) => ({
       ...conversation,
@@ -1255,7 +1603,7 @@ class IMessageDB {
     }));
     span.end({
       chats: chats.length,
-      candidates: candidates.length,
+      enriched: cursor,
       deduped: deduped.length,
       returned: result.length
     });
@@ -1532,6 +1880,76 @@ class IMessageDB {
       (chat) => !(isGroupGuid(chat.guid) || isGroupChatIdentifier(chat.chat_identifier)) && this.getConversationMergeKey(chat.chat_identifier, chat.guid, false) === mergeKey
     ).map((chat) => toChatRow(chat));
   }
+  /**
+   * Completeness diagnostic for exports. Finds non-group chats that belong to
+   * the same identity as the exported conversation but that the merge-key logic
+   * did NOT fold in — e.g. a contact whose phone and email landed on separate
+   * Address Book cards, or chats Apple linked via `person_centric_id`.
+   *
+   * Two independent signals, unioned and deduped by chat ROWID:
+   *  1. **contactId invariant** (primary): any non-group chat whose handle
+   *     resolves (via the loaded Address Books, incl. iCloud sources) to the
+   *     same contactId as the merged set but wasn't merged. Catches merge
+   *     regressions and normalization gaps.
+   *  2. **person_centric_id** (fallback): Apple's own cross-handle link. Still
+   *     fires when the contact isn't in any Address Book — but note this column
+   *     is NULL on many real chat.dbs, so signal (1) is the dependable one.
+   *
+   * Inherent limit: a contact in NO Address Book *and* with a NULL
+   * person_centric_id cannot be linked from data alone — that case is guarded
+   * by the cross-source merge tests, not this diagnostic. Read-only.
+   */
+  findUnmergedSiblingChats(chatIdentifier) {
+    const merged = this.resolveChatsForConversation(chatIdentifier);
+    if (merged.length === 0) return [];
+    const mergedIds = new Set(merged.map((c) => c.ROWID));
+    const siblings = /* @__PURE__ */ new Map();
+    const isGroupChat = (guid, ident) => isGroupGuid(guid) || isGroupChatIdentifier(ident ?? "");
+    const mergedContactIds = /* @__PURE__ */ new Set();
+    for (const chat of merged) {
+      const contact = this.contacts.lookupContact(chat.chat_identifier);
+      if (contact) mergedContactIds.add(contact.contactId);
+    }
+    if (mergedContactIds.size > 0) {
+      for (const chat of this.getAllChatsWithLastDate()) {
+        if (mergedIds.has(chat.ROWID)) continue;
+        if (isGroupChat(chat.guid, chat.chat_identifier)) continue;
+        const contact = this.contacts.lookupContact(chat.chat_identifier);
+        if (contact && mergedContactIds.has(contact.contactId)) {
+          siblings.set(chat.ROWID, {
+            chatIdentifier: chat.chat_identifier,
+            reason: "resolves to the same contact but was not merged"
+          });
+        }
+      }
+    }
+    const mergedIdList = [...mergedIds];
+    const placeholders = mergedIdList.map(() => "?").join(",");
+    const rows = this.raw.prepare(`
+        SELECT DISTINCT c.ROWID as rowid, c.guid, c.chat_identifier
+        FROM ${Tables.CHAT} c
+        JOIN ${Tables.CHAT_HANDLE_JOIN} chj ON chj.chat_id = c.ROWID
+        JOIN ${Tables.HANDLE} h ON h.ROWID = chj.handle_id
+        WHERE c.ROWID NOT IN (${placeholders})
+          AND h.person_centric_id IN (
+            SELECT DISTINCT h2.person_centric_id
+            FROM ${Tables.CHAT_HANDLE_JOIN} chj2
+            JOIN ${Tables.HANDLE} h2 ON h2.ROWID = chj2.handle_id
+            WHERE chj2.chat_id IN (${placeholders})
+              AND h2.person_centric_id IS NOT NULL
+              AND h2.person_centric_id != ''
+          )
+      `).all(...mergedIdList, ...mergedIdList);
+    for (const row of rows) {
+      if (isGroupChat(row.guid, row.chat_identifier)) continue;
+      if (siblings.has(row.rowid)) continue;
+      siblings.set(row.rowid, {
+        chatIdentifier: row.chat_identifier ?? row.guid,
+        reason: "shares this contact's identity (person_centric_id) but was not merged"
+      });
+    }
+    return [...siblings.values()];
+  }
   /**
    * Get all chats with their last message date in one join query.
    * Used to resolve the correct chat for a contact when multiple chats exist (e.g. same number).
@@ -1642,53 +2060,45 @@ class IMessageDB {
     ).all();
     return rows;
   }
+  /** Resolve a message ROWID to its date (for composite pagination cursors). */
+  dateOfMessage(rowid) {
+    const row = this.raw.prepare(`SELECT date FROM ${Tables.MESSAGE} WHERE ROWID = ?`).get(rowid);
+    return row?.date;
+  }
   /**
    * Fetch message rows for a chat ROWID, ordered by date DESC.
-   * Replaces the upstream IMessageDatabase.getMessagesFromChat().
+   *
+   * Pagination boundaries are composite `(date, ROWID)` cursors, NOT bare
+   * ROWID comparisons: results are ordered by date, and in restored/merged
+   * threads ROWID order diverges from date order — a ROWID-only bound both
+   * skips older-date/higher-ROWID messages and re-shows newer-date/lower-ROWID
+   * ones (paginating a real thread that way reached only ~47% of it; the same
+   * defect made wait_for_reply able to miss replies entirely). ROWID-only is
+   * kept solely as a fallback when the boundary message's date is unknown
+   * (e.g. the boundary row was deleted).
    */
-  fetchMessagesForChatRowId(chatRowId, limit, beforeMessageId, afterMessageId) {
-    if (beforeMessageId != null && afterMessageId != null) {
-      const stmt2 = this.raw.prepare(`
-        SELECT
-          m.ROWID, m.guid, m.text, m.attributedBody, m.date,
-          m.is_from_me, h.id as handle_id, m.cache_has_attachments
-        FROM ${Tables.MESSAGE} m
-        LEFT JOIN ${Tables.HANDLE} h ON m.handle_id = h.ROWID
-        LEFT JOIN ${Tables.CHAT_MESSAGE_JOIN} cmj ON m.ROWID = cmj.message_id
-        WHERE cmj.chat_id = ? AND m.ROWID > ? AND m.ROWID < ?
-        ORDER BY m.date DESC, m.ROWID DESC
-        LIMIT ?
-      `);
-      return stmt2.all(chatRowId, afterMessageId, beforeMessageId, limit);
-    }
+  fetchMessagesForChatRowId(chatRowId, limit, beforeMessageId, afterMessageId, beforeDate, afterDate) {
+    const conditions = ["cmj.chat_id = ?"];
+    const params = [chatRowId];
     if (beforeMessageId != null) {
-      const stmt2 = this.raw.prepare(`
-        SELECT
-          m.ROWID, m.guid, m.text, m.attributedBody, m.date,
-          m.is_from_me, h.id as handle_id, m.cache_has_attachments
-        FROM ${Tables.MESSAGE} m
-        LEFT JOIN ${Tables.HANDLE} h ON m.handle_id = h.ROWID
-        LEFT JOIN ${Tables.CHAT_MESSAGE_JOIN} cmj ON m.ROWID = cmj.message_id
-        WHERE cmj.chat_id = ? AND m.ROWID < ?
-        ORDER BY m.date DESC, m.ROWID DESC
-        LIMIT ?
-      `);
-      return stmt2.all(chatRowId, beforeMessageId, limit);
+      if (beforeDate != null) {
+        conditions.push("(m.date < ? OR (m.date = ? AND m.ROWID < ?))");
+        params.push(beforeDate, beforeDate, beforeMessageId);
+      } else {
+        conditions.push("m.ROWID < ?");
+        params.push(beforeMessageId);
+      }
     }
     if (afterMessageId != null) {
-      const stmt2 = this.raw.prepare(`
-        SELECT
-          m.ROWID, m.guid, m.text, m.attributedBody, m.date,
-          m.is_from_me, h.id as handle_id, m.cache_has_attachments
-        FROM ${Tables.MESSAGE} m
-        LEFT JOIN ${Tables.HANDLE} h ON m.handle_id = h.ROWID
-        LEFT JOIN ${Tables.CHAT_MESSAGE_JOIN} cmj ON m.ROWID = cmj.message_id
-        WHERE cmj.chat_id = ? AND m.ROWID > ?
-        ORDER BY m.date DESC, m.ROWID DESC
-        LIMIT ?
-      `);
-      return stmt2.all(chatRowId, afterMessageId, limit);
+      if (afterDate != null) {
+        conditions.push("(m.date > ? OR (m.date = ? AND m.ROWID > ?))");
+        params.push(afterDate, afterDate, afterMessageId);
+      } else {
+        conditions.push("m.ROWID > ?");
+        params.push(afterMessageId);
+      }
     }
+    params.push(limit);
     const stmt = this.raw.prepare(`
       SELECT
         m.ROWID, m.guid, m.text, m.attributedBody, m.date,
@@ -1696,11 +2106,11 @@ class IMessageDB {
       FROM ${Tables.MESSAGE} m
       LEFT JOIN ${Tables.HANDLE} h ON m.handle_id = h.ROWID
       LEFT JOIN ${Tables.CHAT_MESSAGE_JOIN} cmj ON m.ROWID = cmj.message_id
-      WHERE cmj.chat_id = ?
+      WHERE ${conditions.join(" AND ")}
       ORDER BY m.date DESC, m.ROWID DESC
       LIMIT ?
     `);
-    return stmt.all(chatRowId, limit);
+    return stmt.all(...params);
   }
   /**
    * Extract readable text from a message row.
@@ -1872,6 +2282,7 @@ class IMessageDB {
         this.cachedAllChats = null;
         this.cachedLastByChat = null;
         this.cachedUnreadByChat = null;
+        this.cachedReactionsByChat.clear();
         this.getAllChatsWithLastDate();
         this.scheduleBackgroundSlugSync();
       } catch {
@@ -1886,6 +2297,7 @@ class IMessageDB {
    * Close database connections
    */
   async close() {
+    this.closed = true;
     this.raw.close();
     this.contacts.close();
     this.slugStore.close();
@@ -2126,6 +2538,10 @@ class IMessageDB {
    * One query replaces N individual LIKE queries (the main perf bottleneck).
    */
   fetchReactionsForChat(chatRowId) {
+    const cached = this.cachedReactionsByChat.get(chatRowId);
+    if (cached && Date.now() - cached.ts < IMessageDB.CACHE_TTL_MS) {
+      return cached.data;
+    }
     const stmt = this.raw.prepare(`
       SELECT
         m.associated_message_type,
@@ -2161,6 +2577,7 @@ class IMessageDB {
       if (existing) existing.push(reaction);
       else result.set(targetGuid, [reaction]);
     }
+    this.cachedReactionsByChat.set(chatRowId, { data: result, ts: Date.now() });
     return result;
   }
   /**
@@ -2242,6 +2659,7 @@ const imessageDb = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
 export {
   IMessageDB as I,
   hasNativeModule as h,
-  imessageDb as i
+  imessageDb as i,
+  normalizedPhoneVariants as n
 };
-//# sourceMappingURL=imessage-db-BYU5mxM-.js.map
+//# sourceMappingURL=imessage-db-vDZF7E8B.js.map