imsg-mcp 1.0.0

package/dist/imessage-db-BVDtx0Sn.js

@@ -0,0 +1,2263 @@
+import { homedir } from "node:os";
+import { dirname, join } 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, T as Tables, G as AssociatedMessageType, H as macTimestampToDate$1, I as isReactionType, M as MAC_EPOCH_OFFSET, N as NANOS_PER_SECOND, J as parseAssociatedMessageGuid$1 } from "./shutdown-B9ClCyco.js";
+import { parseBuffer } from "bplist-parser";
+import { createHash } from "node:crypto";
+const __dirname$1 = dirname(fileURLToPath(import.meta.url));
+let _native;
+function tryLoadNative() {
+  if (_native !== void 0) return _native;
+  if (process.env.IMSG_DISABLE_NATIVE === "1") {
+    _native = null;
+    return null;
+  }
+  try {
+    const require2 = createRequire(import.meta.url);
+    const nativePath = join(__dirname$1, "..", "native", "index.js");
+    _native = require2(nativePath);
+    return _native;
+  } catch {
+    _native = null;
+    return null;
+  }
+}
+function hasNativeModule() {
+  return tryLoadNative() !== null;
+}
+class BufferReader {
+  buffer;
+  offset;
+  constructor(buffer, initialOffset = 0) {
+    this.buffer = buffer;
+    this.offset = initialOffset;
+  }
+  get position() {
+    return this.offset;
+  }
+  get length() {
+    return this.buffer.length;
+  }
+  get remaining() {
+    return this.buffer.length - this.offset;
+  }
+  seek(position) {
+    if (position < 0 || position > this.buffer.length) {
+      throw new Error(`Invalid seek position: ${position}`);
+    }
+    this.offset = position;
+  }
+  skip(bytes) {
+    this.offset += bytes;
+  }
+  readUInt8() {
+    const value = this.buffer.readUInt8(this.offset);
+    this.offset += 1;
+    return value;
+  }
+  readUInt16LE() {
+    const value = this.buffer.readUInt16LE(this.offset);
+    this.offset += 2;
+    return value;
+  }
+  readBytes(length) {
+    if (this.offset + length > this.buffer.length) {
+      throw new Error("Attempt to read beyond buffer length");
+    }
+    const bytes = this.buffer.subarray(this.offset, this.offset + length);
+    this.offset += length;
+    return bytes;
+  }
+  readString(length, encoding = "utf8") {
+    const bytes = this.readBytes(length);
+    return bytes.toString(encoding);
+  }
+  findPattern(pattern) {
+    const searchBuffer = typeof pattern === "string" ? Buffer.from(pattern) : pattern;
+    const index = this.buffer.indexOf(searchBuffer, this.offset);
+    return index >= 0 ? index : -1;
+  }
+  peekByte() {
+    if (this.offset >= this.buffer.length) return null;
+    return this.buffer[this.offset];
+  }
+  peekBytes(length) {
+    if (this.offset + length > this.buffer.length) return null;
+    return this.buffer.subarray(this.offset, this.offset + length);
+  }
+}
+const PREAMBLE_BYTE_2_VARIANTS = /* @__PURE__ */ new Set([148, 149]);
+const PREAMBLE_LEN = 5;
+function matchesNSStringPreamble(bytes) {
+  if (!bytes || bytes.length < PREAMBLE_LEN) return false;
+  return bytes[0] === 1 && PREAMBLE_BYTE_2_VARIANTS.has(bytes[1]) && bytes[2] === 132 && bytes[3] === 1 && bytes[4] === 43;
+}
+const METADATA_KEYWORDS = [
+  "streamtyped",
+  "NSMutableAttributedString",
+  "NSAttributedString",
+  "NSObject",
+  "NSMutableString",
+  "NSString",
+  "NSDictionary",
+  "NSNumber",
+  "NSValue",
+  "NSFont",
+  "NSParagraphStyle",
+  "__kIM",
+  "NSData",
+  "bplist",
+  "NSKeyedArchiver",
+  "NS.rangeval",
+  "Z$classname",
+  "$class",
+  "$classname"
+];
+class TypedStreamParser {
+  reader;
+  headerParsed = false;
+  constructor(buffer) {
+    this.reader = new BufferReader(buffer);
+  }
+  /** Parse all NSString objects found in the buffer. */
+  parseAllNSStrings() {
+    const strings = [];
+    this.parseHeader();
+    const maxIter = this.reader.length;
+    let iter = 0;
+    while (this.reader.remaining > 0 && iter++ < maxIter) {
+      const posBefore = this.reader.position;
+      const found = this.parseNSString();
+      if (found) {
+        strings.push(found);
+      } else if (this.reader.remaining > 0) {
+        if (this.reader.position <= posBefore) {
+          this.reader.skip(1);
+        }
+      }
+      if (this.reader.position <= posBefore && this.reader.remaining > 0) {
+        this.reader.skip(1);
+      }
+    }
+    return strings;
+  }
+  /** Fallback: extract readable text segments by scanning for printable byte runs. */
+  extractReadableText() {
+    this.reader.seek(0);
+    const texts = [];
+    let current = "";
+    let inText = false;
+    const maxIter = this.reader.length;
+    let iter = 0;
+    while (this.reader.remaining > 0 && iter++ < maxIter) {
+      const posBefore = this.reader.position;
+      const byte = this.reader.readUInt8();
+      if (byte >= 32 && byte <= 126 || byte === 9 || byte === 10 || byte === 13) {
+        current += String.fromCharCode(byte);
+        inText = true;
+      } else if (byte >= 192 && byte <= 247) {
+        const extraBytes = byte < 224 ? 1 : byte < 240 ? 2 : 3;
+        if (this.reader.remaining >= extraBytes) {
+          const bytes = [byte];
+          let valid = true;
+          for (let i = 0; i < extraBytes; i++) {
+            const cont = this.reader.readUInt8();
+            if ((cont & 192) !== 128) {
+              valid = false;
+              break;
+            }
+            bytes.push(cont);
+          }
+          if (valid) {
+            try {
+              current += Buffer.from(bytes).toString("utf8");
+              inText = true;
+            } catch {
+              this.flushSegment(current, inText, texts);
+              current = "";
+              inText = false;
+            }
+          } else {
+            this.flushSegment(current, inText, texts);
+            current = "";
+            inText = false;
+          }
+        } else {
+          this.flushSegment(current, inText, texts);
+          current = "";
+          inText = false;
+        }
+      } else {
+        this.flushSegment(current, inText, texts);
+        current = "";
+        inText = false;
+      }
+      if (this.reader.position <= posBefore) {
+        if (this.reader.remaining > 0) this.reader.skip(1);
+        else break;
+      }
+    }
+    this.flushSegment(current, true, texts);
+    return texts;
+  }
+  // ── Private ──────────────────────────────────────────────────────────
+  parseHeader() {
+    if (this.headerParsed) return;
+    const magic = this.reader.peekBytes(11);
+    if (!magic || magic.toString("ascii") !== "streamtyped") return;
+    this.reader.skip(11);
+    const maxSkip = Math.min(this.reader.remaining, 256);
+    let skipped = 0;
+    while (this.reader.remaining > 0 && skipped++ < maxSkip) {
+      const next4 = this.reader.peekBytes(4);
+      if (next4 && /^[A-Z]/.test(next4.toString("ascii"))) break;
+      this.reader.skip(1);
+    }
+    this.headerParsed = true;
+  }
+  parseNSString() {
+    const pos = this.reader.findPattern("NSString");
+    if (pos === -1) {
+      this.reader.seek(this.reader.length);
+      return null;
+    }
+    this.reader.seek(pos + 8);
+    const preamble = this.reader.peekBytes(PREAMBLE_LEN);
+    if (matchesNSStringPreamble(preamble)) {
+      this.reader.skip(PREAMBLE_LEN);
+    }
+    if (this.reader.remaining < 1) return null;
+    const lengthByte = this.reader.readUInt8();
+    let length;
+    if (lengthByte === 129) {
+      if (this.reader.remaining < 2) return null;
+      length = this.reader.readUInt16LE();
+    } else {
+      length = lengthByte;
+    }
+    if (length === 0 || length > this.reader.remaining) return null;
+    return {
+      className: "NSString",
+      content: this.reader.readString(length, "utf8"),
+      encoding: "utf8"
+    };
+  }
+  flushSegment(text, inText, out) {
+    if (!inText || text.length <= 3) return;
+    const cleaned = this.cleanText(text);
+    if (cleaned.length > 3) out.push(cleaned);
+  }
+  cleanText(text) {
+    let cleaned = text;
+    for (const kw of METADATA_KEYWORDS) {
+      cleaned = cleaned.replaceAll(kw, "");
+    }
+    return cleaned.replace(/\{[^}]*\}/g, "").replace(/\[[^\]]*\]/g, "").replace(/[\x00-\x1f]/g, "").replace(/\s+/g, " ").trim();
+  }
+}
+let _nativeParseAttributedBody;
+function getNativeParser() {
+  if (_nativeParseAttributedBody !== void 0) return _nativeParseAttributedBody;
+  const native = tryLoadNative();
+  _nativeParseAttributedBody = native ? native.parseAttributedBody.bind(native) : null;
+  return _nativeParseAttributedBody;
+}
+function nativeResultLooksTrustworthy(text) {
+  if (/at_\d+_[0-9A-F-]{8,}/i.test(text)) return false;
+  if (/__kIM[A-Z]/.test(text)) return false;
+  if (/\$class|streamtyped|NSKeyedArchiver/.test(text)) return false;
+  if (/^NS[A-Z][a-z]+/.test(text)) return false;
+  if (/^([A-Z])\1[a-z]/.test(text)) return false;
+  return true;
+}
+const METADATA_PATTERNS = [
+  /^streamtyped$/i,
+  /^NS[A-Z]/,
+  /^[^A-Za-z0-9]*__kIM/,
+  /^MessagePartAttributeName$/i,
+  /^DataDetectedAttributeName$/i,
+  /^CalendarEventAttributeName$/i,
+  /^X\$version/,
+  /^WversionYdd-result/,
+  /^bplist/,
+  /^\$class/,
+  /^RMSV\$class/,
+  /^NSData$/,
+  /^NSDictionary$/,
+  /^NSNumber$/,
+  /^NSValue$/,
+  /^at_\d+_[0-9A-F-]+$/i,
+  /FileTransferGUIDAttributeName/i,
+  /BaseWritingDirectionAttributeName/i,
+  /^\d{2}.*��/
+];
+const CONTROL_OR_DEL_RE = /[\x00-\x1F\x7F]/g;
+const CONTROL_SPLIT_RE = /[\x00-\x1F\x7F]+/g;
+const PARSE_TIMEOUT_MS = 200;
+function normalizeCandidate(text) {
+  const normalized = text.replace(/^[+;:"'()&\s]+/, "").replace(/^[^A-Za-z\d\s](?=[A-Z])/, "").replace(/^[a-z\d](?=[A-Z])/, "").replace(/^[A-Z](?=[A-Z][a-z])/, "").replace(CONTROL_OR_DEL_RE, " ").replace(/\uFFFD+/g, "").replace(/\s+/g, " ").trim();
+  if (!normalized || normalized === "�" || normalized === "") return null;
+  if (normalized.length < 2 && !/[\u{1F300}-\u{1FAFF}]/u.test(normalized)) return null;
+  if (/^[A-Za-z0-9]{1,2}$/.test(normalized)) return null;
+  if (METADATA_PATTERNS.some((pattern) => pattern.test(normalized))) return null;
+  return normalized;
+}
+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;
+      }
+    }
+    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(" ");
+    }
+    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
+    };
+  }
+}
+function normalizeSnippetText(text) {
+  if (!text) return null;
+  const attachmentMarker = new RegExp(
+    `${OBJECT_REPLACEMENT_CHAR.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}+`,
+    "g"
+  );
+  const normalized = text.replace(/^[#$]/, "").replace(attachmentMarker, "📎 ").replace(/\uFFFD/g, "").replace(/\s+/g, " ").trim();
+  if (!normalized || normalized === "📎" || /^(📎\s*)+$/.test(normalized)) {
+    return normalized ? "(image/attachment)" : null;
+  }
+  return normalized;
+}
+function isMetadataOnlySnippet(text) {
+  if (!text) return false;
+  const normalized = text.trim();
+  return /^[$#]?https?:\/\//i.test(normalized) || /HttpURL\/?$/i.test(normalized) || /^[$#]https?:\/\/.*HttpURL\/?$/i.test(normalized);
+}
+function normalizeRichMetadataText(text) {
+  const normalized = normalizeSnippetText(text);
+  if (!normalized) return null;
+  if (/^https?:\/\/.*HttpURL\/?$/i.test(normalized)) {
+    return normalized.replace(/HttpURL\/?$/i, "");
+  }
+  return normalized;
+}
+function pickConversationSnippet(options) {
+  return normalizeSnippetText(options.rawText) ?? normalizeSnippetText(options.parsedText) ?? normalizeSnippetText(options.summaryText);
+}
+function normalizeText(value) {
+  const normalized = value?.replace(/\s+/g, " ").trim();
+  return normalized && normalized.length >= 4 ? normalized : void 0;
+}
+function extractNullPaddedAsciiText(blob) {
+  if (!blob) return void 0;
+  let best = "";
+  let current = "";
+  const flush = () => {
+    if (current.length > best.length) {
+      best = current;
+    }
+    current = "";
+  };
+  for (let index = 0; index < blob.length - 1; index += 1) {
+    const first = blob[index];
+    const second = blob[index + 1];
+    if (first === 0 && second >= 32 && second <= 126) {
+      current += String.fromCharCode(second);
+      index += 1;
+      continue;
+    }
+    flush();
+  }
+  flush();
+  return normalizeText(best);
+}
+function extractArchivedAttributedStringText(blob) {
+  if (!blob) return void 0;
+  try {
+    const [plist] = parseBuffer(blob);
+    const objects = plist?.$objects;
+    if (!Array.isArray(objects)) {
+      return extractNullPaddedAsciiText(blob);
+    }
+    const attributedString = objects.find(
+      (value) => typeof value === "object" && value !== null && "NSString" in value
+    );
+    const stringUid = attributedString?.NSString?.UID;
+    if (typeof stringUid === "number" && typeof objects[stringUid] === "string") {
+      return normalizeText(objects[stringUid]);
+    }
+    const firstString = objects.find(
+      (value) => typeof value === "string" && !value.startsWith("$") && !value.startsWith("NS")
+    );
+    return normalizeText(firstString) ?? extractNullPaddedAsciiText(blob);
+  } catch {
+    return extractNullPaddedAsciiText(blob);
+  }
+}
+function extractChatSummaryText(blob) {
+  if (!blob) return void 0;
+  try {
+    const [plist] = parseBuffer(blob);
+    const chatSummary = plist?.chatSummaryDictionary?.chatSummary;
+    if (chatSummary) {
+      return extractArchivedAttributedStringText(chatSummary);
+    }
+  } catch {
+  }
+  return extractNullPaddedAsciiText(blob);
+}
+const DEFAULT_DIR = join(homedir(), ".imsg-mcp");
+const DEFAULT_DB = join(DEFAULT_DIR, "slugs.db");
+class SlugStore {
+  db;
+  constructor(dbPath) {
+    const path = dbPath ?? DEFAULT_DB;
+    const dir = dirname(path);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    this.db = new Database(path);
+    this.db.pragma("journal_mode = WAL");
+    this.migrate();
+  }
+  migrate() {
+    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
+      )
+    `);
+  }
+  upsert(record) {
+    const params = {
+      slug: record.slug,
+      chatGuid: record.chatGuid,
+      chatIdentifier: record.chatIdentifier,
+      displayName: record.displayName,
+      service: record.service,
+      isGroup: record.isGroup ? 1 : 0,
+      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);
+  }
+  upsertMany(records) {
+    const tx = this.db.transaction((recs) => {
+      for (const r of recs) this.upsert(r);
+    });
+    tx(records);
+  }
+  lookupBySlug(slug) {
+    const row = this.db.prepare("SELECT * FROM thread_slugs WHERE slug = ?").get(slug);
+    return row ? this.rowToRecord(row) : null;
+  }
+  lookupByGuid(chatGuid) {
+    const row = this.db.prepare("SELECT * FROM thread_slugs WHERE chat_guid = ?").get(chatGuid);
+    return row ? this.rowToRecord(row) : null;
+  }
+  lookupByChatIdentifier(chatIdentifier) {
+    const row = this.db.prepare("SELECT * FROM thread_slugs WHERE chat_identifier = ?").get(chatIdentifier);
+    return row ? this.rowToRecord(row) : null;
+  }
+  all() {
+    const rows = this.db.prepare("SELECT * FROM thread_slugs ORDER BY updated_at DESC").all();
+    return rows.map((r) => this.rowToRecord(r));
+  }
+  /** Remove slugs whose chat_guid is not in the given set of valid guids. */
+  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);
+    });
+    tx(toDelete.map((r) => r.slug));
+    return toDelete.length;
+  }
+  close() {
+    this.db.close();
+  }
+  rowToRecord(row) {
+    return {
+      slug: row.slug,
+      chatGuid: row.chat_guid,
+      chatIdentifier: row.chat_identifier,
+      displayName: row.display_name,
+      service: row.service,
+      isGroup: Boolean(row.is_group),
+      participants: row.participants,
+      updatedAt: row.updated_at
+    };
+  }
+}
+function sanitizeSlugPart(name) {
+  return name.toLowerCase().replace(/['']/g, "").replace(/[\s_]+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-{2,}/g, "-").replace(/^-|-$/g, "");
+}
+function shortHash(input) {
+  return createHash("md5").update(input).digest("hex").slice(0, 4);
+}
+function serviceAbbrev(service) {
+  const lower = service.toLowerCase();
+  if (lower === "imessage") return "imsg";
+  if (lower === "sms") return "sms";
+  return sanitizeSlugPart(lower) || "msg";
+}
+function isGroupChatIdentifier(chatIdentifier) {
+  return chatIdentifier.startsWith("chat");
+}
+function isGroupGuid(guid) {
+  return guid.includes(";+;");
+}
+function generateThreadSlug(input) {
+  const svc = serviceAbbrev(input.serviceName || "iMessage");
+  const hash = shortHash(input.guid);
+  const isGroup = isGroupGuid(input.guid) || isGroupChatIdentifier(input.chatIdentifier);
+  let namePart;
+  if (isGroup) {
+    if (input.displayName && !input.displayName.startsWith("chat")) {
+      namePart = sanitizeSlugPart(input.displayName);
+    } else {
+      namePart = "group";
+    }
+  } else {
+    if (input.resolvedContactName) {
+      namePart = sanitizeSlugPart(input.resolvedContactName);
+    } else if (input.displayName && input.displayName !== input.chatIdentifier) {
+      namePart = sanitizeSlugPart(input.displayName);
+    } else {
+      namePart = sanitizeSlugPart(input.chatIdentifier.replace(/^\+/, ""));
+    }
+  }
+  if (!namePart) namePart = "unknown";
+  return `${namePart}~${svc}~${hash}`;
+}
+function toChatRow(c) {
+  return {
+    ROWID: c.ROWID,
+    guid: c.guid,
+    chat_identifier: c.chat_identifier,
+    display_name: c.display_name
+  };
+}
+const TAPBACK_TYPE_MAP = {
+  2e3: { type: "love", isRemoval: false },
+  2001: { type: "like", isRemoval: false },
+  2002: { type: "dislike", isRemoval: false },
+  2003: { type: "laugh", isRemoval: false },
+  2004: { type: "emphasize", isRemoval: false },
+  2005: { type: "question", isRemoval: false },
+  2006: { type: "emoji", isRemoval: false },
+  // iOS 18+ custom emoji
+  3e3: { type: "love", isRemoval: true },
+  3001: { type: "like", isRemoval: true },
+  3002: { type: "dislike", isRemoval: true },
+  3003: { type: "laugh", isRemoval: true },
+  3004: { type: "emphasize", isRemoval: true },
+  3005: { type: "question", isRemoval: true },
+  3006: { type: "emoji", isRemoval: true },
+  1e3: { type: "sticker", isRemoval: false }
+};
+const parseAssociatedMessageGuid = parseAssociatedMessageGuid$1;
+function isPlaceholderText(text) {
+  if (!text) return true;
+  return /^[\uFFFC\uFFFD\s]+$/u.test(text);
+}
+function isHiddenSystemItem(itemType) {
+  return (itemType ?? 0) !== 0;
+}
+function getRichContentType(balloonBundleId) {
+  if (!balloonBundleId) return void 0;
+  if (balloonBundleId === "com.apple.messages.URLBalloonProvider") {
+    return "link_preview";
+  }
+  if (balloonBundleId === "com.apple.DigitalTouchBalloonProvider") {
+    return "digital_touch";
+  }
+  if (balloonBundleId === "com.apple.Handwriting.HandwritingProvider") {
+    return "handwriting";
+  }
+  if (balloonBundleId.includes("findmy") || balloonBundleId.includes("Maps")) {
+    return "location";
+  }
+  if (balloonBundleId.includes("MSMessageExtensionBalloonPlugin")) {
+    return "app_message";
+  }
+  return "unknown";
+}
+const macTimestampToDate = macTimestampToDate$1;
+class IMessageDB {
+  raw;
+  dbPath;
+  /** Address-book reader. Public so MCP `*_contacts` tools can wrap it. */
+  contacts;
+  slugStore;
+  /** In-memory slug -> ChatWithLastDate for fast lookups during a session. */
+  slugMap = /* @__PURE__ */ new Map();
+  /** In-memory chat guid -> slug for stable per-chat slug lookups. */
+  guidToSlug = /* @__PURE__ */ new Map();
+  // ── TTL caches ───────────────────────────────────────────────────────
+  static CACHE_TTL_MS = 3e4;
+  cachedAllChats = null;
+  cachedLastByChat = null;
+  cachedUnreadByChat = null;
+  cachedParticipants = /* @__PURE__ */ new Map();
+  cachedMergeKeys = /* @__PURE__ */ new Map();
+  cachedSnippets = /* @__PURE__ */ new Map();
+  backgroundSyncNeeded = true;
+  backgroundRefreshScheduled = false;
+  constructor(dbPath, contactsDbPaths, slugStorePath) {
+    const span = perf("IMessageDB.constructor");
+    this.dbPath = dbPath || join(homedir(), "Library", "Messages", "chat.db");
+    this.raw = new Database(this.dbPath, { readonly: true });
+    this.contacts = new ContactsDB(contactsDbPaths);
+    this.slugStore = new SlugStore(slugStorePath);
+    const contactsSpan = perf("contacts.initialize");
+    try {
+      this.contacts.initialize();
+      contactsSpan.end();
+    } catch (err) {
+      contactsSpan.end({ error: String(err) });
+      console.warn("Failed to initialize contacts database:", err);
+    }
+    this.loadCachedSlugs();
+    span.end();
+  }
+  /**
+   * Fast startup: load persisted slugs from SlugStore into in-memory maps.
+   * No chat.db queries -- uses the SQLite slug store populated by previous runs.
+   */
+  loadCachedSlugs() {
+    const span = perf("loadCachedSlugs");
+    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
+        guid: r.chatGuid,
+        chat_identifier: r.chatIdentifier,
+        display_name: r.displayName,
+        service_name: r.service ?? null,
+        last_date: null
+      });
+    }
+    span.end({ loaded: records.length });
+  }
+  /** Generate and cache a slug for a single chat. */
+  syncSlugForChat(chat) {
+    const isGroup = isGroupGuid(chat.guid) || isGroupChatIdentifier(chat.chat_identifier);
+    const resolvedName = !isGroup && chat.chat_identifier ? this.contacts.lookupHandle(chat.chat_identifier) : 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
+    });
+    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),
+      isGroup,
+      participants: participants.join(","),
+      updatedAt: Date.now()
+    });
+    this.slugMap.set(slug, chat);
+    this.guidToSlug.set(chat.guid, slug);
+    return slug;
+  }
+  /**
+   * Schedule a full slug sync in the background using setImmediate chunks.
+   * Each chunk processes up to 100 chats then yields the event loop.
+   */
+  scheduleBackgroundSlugSync() {
+    if (!this.backgroundSyncNeeded) return;
+    this.backgroundSyncNeeded = false;
+    const span = perf("backgroundSlugSync");
+    const chats = this.getAllChatsWithLastDate();
+    const validGuids = /* @__PURE__ */ new Set();
+    let index = 0;
+    let synced = 0;
+    const CHUNK = 100;
+    const processChunk = () => {
+      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)) {
+          this.syncSlugForChat(chat);
+          synced++;
+        } else {
+          const existingSlug = this.guidToSlug.get(chat.guid);
+          this.slugMap.set(existingSlug, chat);
+        }
+      }
+      if (index < chats.length) {
+        setImmediate(processChunk);
+      } else {
+        this.slugStore.prune(validGuids);
+        span.end({ chats: chats.length, newSlugs: synced });
+      }
+    };
+    setImmediate(processChunk);
+  }
+  /** Look up a chat by thread slug. */
+  findChatBySlug(slug) {
+    const cached = this.slugMap.get(slug);
+    if (cached) return toChatRow(cached);
+    const record = this.slugStore.lookupBySlug(slug);
+    if (!record) return null;
+    return this.findChatByIdentifier(record.chatIdentifier);
+  }
+  /** Get the slug for a specific chat GUID. */
+  getSlugForChatGuid(chatGuid) {
+    const cached = this.guidToSlug.get(chatGuid);
+    if (cached) return cached;
+    const record = this.slugStore.lookupByGuid(chatGuid);
+    return record?.slug ?? null;
+  }
+  /** Get the slug record for a chat_identifier (for attaching to output). */
+  getSlugForChatIdentifier(chatIdentifier) {
+    const matches = [...this.slugMap.entries()].filter(
+      ([, chat]) => chat.chat_identifier === chatIdentifier
+    );
+    if (matches.length === 1) return matches[0][0];
+    if (matches.length > 1) return null;
+    const record = this.slugStore.lookupByChatIdentifier(chatIdentifier);
+    return record?.slug ?? null;
+  }
+  /** Get slug record by slug string. */
+  getSlugRecord(slug) {
+    return this.slugStore.lookupBySlug(slug);
+  }
+  /** Get all slug records. */
+  getAllSlugs() {
+    return this.slugStore.all();
+  }
+  /** Fetch group chat participants from chat_handle_join. */
+  fetchChatParticipants(chatRowId) {
+    const cached = this.cachedParticipants.get(chatRowId);
+    if (cached) return cached;
+    const stmt = this.raw.prepare(`
+      SELECT h.id
+      FROM ${Tables.CHAT_HANDLE_JOIN} chj
+      JOIN ${Tables.HANDLE} h ON chj.handle_id = h.ROWID
+      WHERE chj.chat_id = ?
+    `);
+    const rows = stmt.all(chatRowId);
+    const result = rows.map((r) => r.id);
+    this.cachedParticipants.set(chatRowId, result);
+    return result;
+  }
+  /** Detect service type from chat data. */
+  detectServiceForChat(chat) {
+    if (chat.service_name) {
+      return chat.service_name.toLowerCase().includes("sms") ? "SMS" : "iMessage";
+    }
+    if (chat.guid) {
+      return chat.guid.toLowerCase().startsWith("sms") ? "SMS" : "iMessage";
+    }
+    return "iMessage";
+  }
+  /**
+   * Get the N most recent messages across all conversations
+   * By default excludes reactions (tapbacks) for cleaner output
+   */
+  async getRecentMessages(limit = 20, includeReactions = false) {
+    const span = perf("getRecentMessages");
+    const chats = this.getAllChatsWithLastDate().sort((a, b) => (b.last_date ?? 0) - (a.last_date ?? 0)).slice(0, 10);
+    const allMessages = [];
+    for (const chat of chats) {
+      try {
+        const rows = this.fetchMessagesForChatRowId(chat.ROWID, Math.min(limit * 2, 40));
+        const extBatch = this.fetchExtendedMessageDataBatch(rows.map((r) => r.ROWID));
+        for (const msg of rows) {
+          const text = this.parseMessageText(msg);
+          const ext = extBatch.get(msg.ROWID) ?? {};
+          if (isHiddenSystemItem(ext.item_type)) continue;
+          const converted = this.convertMessage(msg, text, chat.chat_identifier, ext);
+          if (!includeReactions && converted.isReaction) continue;
+          allMessages.push(converted);
+        }
+      } catch {
+      }
+    }
+    const result = allMessages.sort((a, b) => b.date.getTime() - a.date.getTime()).slice(0, limit);
+    span.end({ limit, returned: result.length });
+    return result;
+  }
+  /**
+   * Get messages from a specific conversation, sorted by date ascending (chronological).
+   * By default excludes reactions (tapbacks) for cleaner output.
+   */
+  async getMessagesForChat(chatIdentifier, limit = 50, options = {}) {
+    const span = perf("getMessagesForChat");
+    const {
+      includeReactions = false,
+      includeReactionDetails = false,
+      beforeMessageId,
+      afterMessageId
+    } = options;
+    const chats = this.resolveChatsForConversation(chatIdentifier);
+    if (chats.length === 0) {
+      span.end({ limit, returned: 0 });
+      return [];
+    }
+    const perChatLimit = Math.max(limit * 2, 50);
+    const result = /* @__PURE__ */ new Map();
+    for (const chat of chats) {
+      const rows = this.fetchMessagesForChatRowId(
+        chat.ROWID,
+        perChatLimit,
+        beforeMessageId,
+        afterMessageId
+      );
+      const extBatch = this.fetchExtendedMessageDataBatch(rows.map((r) => r.ROWID));
+      const reactionsByGuid = includeReactionDetails ? this.fetchReactionsForChat(chat.ROWID) : void 0;
+      for (const msg of rows) {
+        const text = this.parseMessageText(msg);
+        const ext = extBatch.get(msg.ROWID) ?? {};
+        if (isHiddenSystemItem(ext.item_type)) continue;
+        const converted = this.convertMessage(
+          msg,
+          text,
+          chat.chat_identifier,
+          ext,
+          false
+          // don't let convertMessage fetch reactions individually
+        );
+        if (reactionsByGuid && !converted.isReaction) {
+          const rxns = reactionsByGuid.get(msg.guid);
+          if (rxns && rxns.length > 0) {
+            converted.reactions = this.consolidateReactions(rxns);
+            if (converted.reactions.length === 0) converted.reactions = void 0;
+          }
+        }
+        if (!includeReactions && converted.isReaction) continue;
+        result.set(converted.id, converted);
+      }
+    }
+    const sorted = [...result.values()].sort((a, b) => a.date.getTime() - b.date.getTime()).slice(-limit);
+    span.end({ limit, chats: chats.length, returned: sorted.length });
+    return sorted;
+  }
+  /**
+   * Get unread messages across all conversations, sorted by date descending (newest first).
+   * Excludes reactions for cleaner output.
+   * @param limit Max number of messages to return (default 100).
+   */
+  async getUnreadMessages(limit = 100) {
+    const span = perf("getUnreadMessages");
+    const stmt = 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,
+        c.chat_identifier
+      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
+      LEFT JOIN ${Tables.CHAT} c ON cmj.chat_id = c.ROWID
+      WHERE m.is_from_me = 0
+        AND m.is_read = 0
+        AND m.associated_message_type = ${AssociatedMessageType.NORMAL}
+        AND COALESCE(m.item_type, 0) = 0
+      ORDER BY m.date DESC
+      LIMIT ?
+    `);
+    const rows = stmt.all(limit);
+    const validRows = rows.filter((r) => r.chat_identifier != null);
+    const extBatch = this.fetchExtendedMessageDataBatch(validRows.map((r) => r.ROWID));
+    const result = [];
+    for (const row of validRows) {
+      const text = this.parseMessageText(row);
+      const ext = extBatch.get(row.ROWID) ?? {};
+      result.push(this.convertMessage(row, text, row.chat_identifier, ext));
+    }
+    result.sort((a, b) => b.date.getTime() - a.date.getTime());
+    const sliced = result.slice(0, limit);
+    span.end({ limit, rows: rows.length, returned: sliced.length });
+    return sliced;
+  }
+  /**
+   * Get the most recent message in a conversation
+   */
+  async getLastMessage(chatIdentifier) {
+    const messages = await this.getMessagesForChat(chatIdentifier, 1);
+    return messages.length > 0 ? messages[messages.length - 1] : null;
+  }
+  /**
+   * Get messages after a specific message ID (for polling new messages).
+   * Returns incoming messages only, sorted by date ascending (chronological).
+   */
+  async getMessagesAfter(chatIdentifier, afterMessageId) {
+    const messages = await this.getMessagesForChat(chatIdentifier, 1e3, { afterMessageId });
+    const filtered = messages.filter((m) => m.id > afterMessageId && !m.isFromMe);
+    filtered.sort((a, b) => a.date.getTime() - b.date.getTime());
+    return filtered;
+  }
+  /**
+   * List all conversations with metadata, sorted by last message date (newest first).
+   * Populates lastMessageDate, lastMessageSnippet, and unreadCount to match Messages.app left pane.
+   */
+  async listConversations(limit = 200) {
+    const span = perf("listConversations");
+    const chats = this.getAllChats();
+    const lastByChat = this.getLastMessageByChat();
+    const unreadByChat = this.getUnreadByChat();
+    const sortEntries = chats.map((chat) => ({
+      chat,
+      lastDate: lastByChat[chat.ROWID]?.lastDate ?? 0,
+      isGroup: isGroupGuid(chat.guid) || isGroupChatIdentifier(chat.chat_identifier),
+      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 lastDate = last ? macTimestampToDate(last.lastDate) : null;
+      const rawIdentifier = chat.chat_identifier;
+      let displayName = chat.display_name;
+      if (!displayName && rawIdentifier && !isGroup) {
+        const resolved = this.contacts.lookupHandle(rawIdentifier);
+        displayName = resolved !== rawIdentifier ? resolved : null;
+      }
+      const participants = isGroup ? this.fetchChatParticipants(chat.ROWID) : [rawIdentifier];
+      const mergeKey = this.getConversationMergeKey(rawIdentifier, chat.guid, isGroup);
+      const slug = this.getSlugForChatGuid(chat.guid) ?? rawIdentifier;
+      const chatData = this.slugMap.get(slug);
+      const serviceType = chatData ? this.detectServiceForChat(chatData) : "iMessage";
+      return {
+        last,
+        mergeKey,
+        conversation: {
+          chatId: chat.guid,
+          chatIdentifier: rawIdentifier,
+          displayName: displayName || null,
+          rawIdentifier,
+          participants,
+          lastMessageDate: lastDate,
+          lastMessageSnippet: null,
+          unreadCount: unreadByChat[chat.ROWID] ?? 0,
+          threadSlug: slug,
+          isGroupChat: isGroup,
+          serviceType
+        }
+      };
+    });
+    const deduped = this.mergeDuplicateConversations(prepared);
+    const selected = deduped.slice(0, limit);
+    const result = selected.map(({ conversation, last }) => ({
+      ...conversation,
+      lastMessageSnippet: this.resolveConversationSnippet(last)
+    }));
+    span.end({
+      chats: chats.length,
+      candidates: candidates.length,
+      deduped: deduped.length,
+      returned: result.length
+    });
+    return result;
+  }
+  /**
+   * Find a chat by phone number, email, or chat identifier.
+   * Uses a single join (chats + last message date), then filters and sorts by date.
+   * When multiple chats match (e.g. same number, different threads), returns the one with the most recent message.
+   */
+  async findChatByHandle(handle) {
+    const chats = this.getAllChatsWithLastDate();
+    const normalized = handle.replace(/[\s\-()]/g, "").toLowerCase();
+    const matches = chats.filter((chat) => {
+      const chatNorm = chat.chat_identifier?.replace(/[\s\-()]/g, "").toLowerCase() || "";
+      return chatNorm.includes(normalized) || normalized.includes(chatNorm);
+    });
+    if (matches.length === 0) return null;
+    const found = this.pickMostRecentChat(matches);
+    const rawIdentifier = found.chat_identifier;
+    const isGroup = isGroupGuid(found.guid) || isGroupChatIdentifier(rawIdentifier);
+    let displayName = found.display_name;
+    if (!displayName && rawIdentifier && !isGroup) {
+      const resolved = this.contacts.lookupHandle(rawIdentifier);
+      displayName = resolved !== rawIdentifier ? resolved : null;
+    }
+    const slug = this.getSlugForChatGuid(found.guid) ?? rawIdentifier;
+    const chatData = this.slugMap.get(slug);
+    const serviceType = chatData ? this.detectServiceForChat(chatData) : "iMessage";
+    return {
+      chatId: found.guid,
+      chatIdentifier: rawIdentifier,
+      displayName: displayName || null,
+      rawIdentifier,
+      participants: isGroup ? this.fetchChatParticipants(found.ROWID) : [rawIdentifier],
+      lastMessageDate: null,
+      lastMessageSnippet: null,
+      unreadCount: 0,
+      threadSlug: slug,
+      isGroupChat: isGroup,
+      serviceType
+    };
+  }
+  /**
+   * Search messages across all conversations.
+   *
+   * Strategy: search the `text` column via LIKE first (covers most messages).
+   * For messages where text is NULL but attributedBody exists, we fetch a larger
+   * window and post-filter after parsing the blob.  The upstream imessage-parser
+   * had a bug here: its SQL `WHERE text LIKE ? OR attributedBody IS NOT NULL`
+   * with a LIMIT meant the LIMIT was consumed by non-matching attributedBody rows,
+   * hiding older text matches entirely.
+   */
+  async searchMessages(query, limit = 20) {
+    const span = perf("searchMessages");
+    const textStmt = 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,
+        c.chat_identifier
+      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
+      LEFT JOIN ${Tables.CHAT} c ON cmj.chat_id = c.ROWID
+      WHERE m.text LIKE ?
+        AND m.associated_message_type = ${AssociatedMessageType.NORMAL}
+        AND COALESCE(m.item_type, 0) = 0
+      ORDER BY m.date DESC
+      LIMIT ?
+    `);
+    const textRows = textStmt.all(`%${query}%`, limit * 2);
+    const seenIds = /* @__PURE__ */ new Set();
+    const messages = [];
+    for (const row of textRows) {
+      if (!row.chat_identifier) continue;
+      seenIds.add(row.ROWID);
+      const text = this.parseMessageText(row);
+      const ext = this.fetchExtendedMessageData(row.ROWID);
+      if (isHiddenSystemItem(ext.item_type)) continue;
+      const converted = this.convertMessage(row, text, row.chat_identifier, ext);
+      if (converted.isReaction) continue;
+      messages.push(converted);
+      if (messages.length >= limit) return messages;
+    }
+    const blobStmt = 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,
+        c.chat_identifier
+      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
+      LEFT JOIN ${Tables.CHAT} c ON cmj.chat_id = c.ROWID
+      WHERE m.text IS NULL
+        AND m.attributedBody IS NOT NULL
+        AND m.associated_message_type = ${AssociatedMessageType.NORMAL}
+        AND COALESCE(m.item_type, 0) = 0
+      ORDER BY m.date DESC
+      LIMIT ?
+    `);
+    const blobRows = blobStmt.all(limit * 20);
+    const queryLower = query.toLowerCase();
+    for (const row of blobRows) {
+      if (!row.chat_identifier || seenIds.has(row.ROWID)) continue;
+      const text = this.parseMessageText(row);
+      if (!text || !text.toLowerCase().includes(queryLower)) continue;
+      const ext = this.fetchExtendedMessageData(row.ROWID);
+      if (isHiddenSystemItem(ext.item_type)) continue;
+      const converted = this.convertMessage(row, text, row.chat_identifier, ext);
+      if (converted.isReaction) continue;
+      messages.push(converted);
+      if (messages.length >= limit) break;
+    }
+    span.end({
+      query,
+      limit,
+      textHits: textRows.length,
+      blobScanned: blobRows.length,
+      returned: messages.length
+    });
+    return messages;
+  }
+  /**
+   * Get a deep link to open a specific conversation in Messages.app
+   */
+  getConversationLink(chatIdentifier) {
+    return `imessage://${encodeURIComponent(chatIdentifier)}`;
+  }
+  resolveConversationSnippet(last) {
+    if (!last) return null;
+    const cached = this.cachedSnippets.get(last.lastMessageId);
+    if (cached !== void 0) return cached;
+    let result = null;
+    const directSnippet = pickConversationSnippet({ rawText: last.snippet });
+    if (directSnippet && !this.shouldFallbackToPreviousSnippet(directSnippet, last)) {
+      result = directSnippet;
+    }
+    if (result == null) {
+      const parsedSnippet = pickConversationSnippet({
+        parsedText: this.getMessageTextByRowId(last.lastMessageId)
+      });
+      if (parsedSnippet && !this.shouldFallbackToPreviousSnippet(parsedSnippet, last)) {
+        result = parsedSnippet;
+      }
+    }
+    if (result == null) {
+      result = this.getPreviousConversationSnippet(last);
+    }
+    if (result == null) {
+      result = pickConversationSnippet({
+        summaryText: extractChatSummaryText(last.chatProperties) ?? null
+      });
+    }
+    this.cachedSnippets.set(last.lastMessageId, result);
+    return result;
+  }
+  shouldFallbackToPreviousSnippet(snippet, last) {
+    return Boolean(
+      last.balloonBundleId?.includes("URLBalloonProvider") && isMetadataOnlySnippet(snippet)
+    );
+  }
+  getPreviousConversationSnippet(last) {
+    const rows = this.raw.prepare(`
+      SELECT m.ROWID, m.text, m.attributedBody, m.date, m.is_from_me
+      FROM ${Tables.MESSAGE} m
+      JOIN ${Tables.CHAT_MESSAGE_JOIN} cmj ON cmj.message_id = m.ROWID
+      WHERE cmj.chat_id = ?
+        AND m.associated_message_type = ${AssociatedMessageType.NORMAL}
+        AND COALESCE(m.item_type, 0) = 0
+        AND (m.date < ? OR (m.date = ? AND m.ROWID < ?))
+      ORDER BY m.date DESC, m.ROWID DESC
+      LIMIT 5
+    `).all(last.chatId, last.lastDate, last.lastDate, last.lastMessageId);
+    for (const row of rows) {
+      if (Boolean(row.is_from_me) !== last.lastIsFromMe) break;
+      if (Math.abs(last.lastDate - row.date) > 6e10) break;
+      const snippet = pickConversationSnippet({
+        rawText: row.text,
+        parsedText: this.extractMessageText(row)
+      });
+      if (snippet && !isMetadataOnlySnippet(snippet)) {
+        return snippet;
+      }
+    }
+    return null;
+  }
+  mergeDuplicateConversations(prepared) {
+    const merged = [];
+    const indexByKey = /* @__PURE__ */ new Map();
+    for (const entry of prepared) {
+      const existingIndex = indexByKey.get(entry.mergeKey);
+      if (existingIndex === void 0) {
+        indexByKey.set(entry.mergeKey, merged.length);
+        merged.push(entry);
+        continue;
+      }
+      merged[existingIndex] = this.mergeConversationEntries(merged[existingIndex], entry);
+    }
+    return merged;
+  }
+  mergeConversationEntries(left, right) {
+    const preferred = this.pickPreferredConversationEntry(left, right);
+    const other = preferred === left ? right : left;
+    const sameIdentifier = preferred.conversation.chatIdentifier === other.conversation.chatIdentifier;
+    return {
+      mergeKey: preferred.mergeKey,
+      last: preferred.last ?? other.last,
+      conversation: {
+        ...preferred.conversation,
+        displayName: preferred.conversation.displayName ?? other.conversation.displayName,
+        participants: [
+          .../* @__PURE__ */ new Set([...preferred.conversation.participants, ...other.conversation.participants])
+        ],
+        unreadCount: sameIdentifier ? Math.max(preferred.conversation.unreadCount, other.conversation.unreadCount) : preferred.conversation.unreadCount + other.conversation.unreadCount
+      }
+    };
+  }
+  pickPreferredConversationEntry(left, right) {
+    const leftTime = left.conversation.lastMessageDate?.getTime() ?? 0;
+    const rightTime = right.conversation.lastMessageDate?.getTime() ?? 0;
+    if (leftTime !== rightTime) {
+      return leftTime > rightTime ? left : right;
+    }
+    const preferredService = left.last?.lastService ?? right.last?.lastService ?? null;
+    if (preferredService) {
+      const preferredType = preferredService.toLowerCase().includes("sms") ? "SMS" : "iMessage";
+      if (left.conversation.serviceType === preferredType && right.conversation.serviceType !== preferredType) {
+        return left;
+      }
+      if (right.conversation.serviceType === preferredType && left.conversation.serviceType !== preferredType) {
+        return right;
+      }
+    }
+    if (left.conversation.displayName && !right.conversation.displayName) return left;
+    if (right.conversation.displayName && !left.conversation.displayName) return right;
+    if (left.conversation.serviceType === "iMessage" && right.conversation.serviceType === "SMS") {
+      return left;
+    }
+    if (right.conversation.serviceType === "iMessage" && left.conversation.serviceType === "SMS") {
+      return right;
+    }
+    return left;
+  }
+  getConversationMergeKey(chatIdentifier, chatGuid, isGroup) {
+    const cacheKey = `${chatIdentifier}::${chatGuid}::${isGroup}`;
+    const cached = this.cachedMergeKeys.get(cacheKey);
+    if (cached) return cached;
+    let key;
+    if (isGroup) {
+      key = `group:${chatGuid}`;
+    } else {
+      const contact = this.contacts.lookupContact(chatIdentifier);
+      key = contact ? `contact:${contact.contactId}` : `identifier:${chatIdentifier.replace(/[\s\-()]/g, "").toLowerCase()}`;
+    }
+    this.cachedMergeKeys.set(cacheKey, key);
+    return key;
+  }
+  resolveChatsForConversation(identifier) {
+    const chats = this.getAllChatsWithLastDate();
+    const normalized = identifier.replace(/[\s\-()]/g, "").toLowerCase();
+    const directMatches = chats.filter(
+      (chat) => chat.chat_identifier === identifier || chat.guid === identifier || chat.chat_identifier != null && (chat.chat_identifier.replace(/[\s\-()]/g, "").toLowerCase().includes(normalized) || normalized.includes(chat.chat_identifier.replace(/[\s\-()]/g, "").toLowerCase()))
+    );
+    if (directMatches.length === 0) return [];
+    const representative = this.pickMostRecentChat(directMatches);
+    const isGroup = isGroupGuid(representative.guid) || isGroupChatIdentifier(representative.chat_identifier);
+    if (isGroup) return [representative];
+    const mergeKey = this.getConversationMergeKey(
+      representative.chat_identifier,
+      representative.guid,
+      false
+    );
+    return chats.filter(
+      (chat) => !(isGroupGuid(chat.guid) || isGroupChatIdentifier(chat.chat_identifier)) && this.getConversationMergeKey(chat.chat_identifier, chat.guid, false) === mergeKey
+    ).map((chat) => toChatRow(chat));
+  }
+  /**
+   * 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).
+   * Results are suitable for filtering by handle/identifier then sorting by last_date descending.
+   */
+  getAllChatsWithLastDate() {
+    const now = Date.now();
+    if (this.cachedAllChats && now - this.cachedAllChats.ts < IMessageDB.CACHE_TTL_MS) {
+      return this.cachedAllChats.data;
+    }
+    const stmt = this.raw.prepare(`
+      SELECT
+        c.ROWID as rowid,
+        c.guid,
+        c.chat_identifier,
+        c.display_name,
+        c.service_name,
+        (SELECT MAX(m.date)
+         FROM ${Tables.CHAT_MESSAGE_JOIN} cmj
+         JOIN ${Tables.MESSAGE} m ON cmj.message_id = m.ROWID
+         WHERE cmj.chat_id = c.ROWID
+           AND m.associated_message_type = ${AssociatedMessageType.NORMAL}
+           AND COALESCE(m.item_type, 0) = 0) as last_date
+       FROM ${Tables.CHAT} c
+     `);
+    const rows = stmt.all();
+    const data = rows.map((r) => ({
+      ROWID: r.rowid,
+      guid: r.guid,
+      chat_identifier: r.chat_identifier,
+      display_name: r.display_name,
+      service_name: r.service_name,
+      last_date: r.last_date
+    }));
+    this.cachedAllChats = { data, ts: now };
+    return data;
+  }
+  /** Last message metadata per chat (window function over message table). Cached with TTL. */
+  getLastMessageByChat() {
+    const now = Date.now();
+    if (this.cachedLastByChat && now - this.cachedLastByChat.ts < IMessageDB.CACHE_TTL_MS) {
+      return this.cachedLastByChat.data;
+    }
+    const stmt = this.raw.prepare(`
+      SELECT chat_id, last_date, last_message_id, last_service, last_is_from_me, balloon_bundle_id, snippet, chat_properties FROM (
+        SELECT cmj.chat_id, m.date as last_date, m.ROWID as last_message_id,
+          m.service as last_service,
+          m.is_from_me as last_is_from_me,
+          m.balloon_bundle_id as balloon_bundle_id,
+          COALESCE(TRIM(SUBSTR(m.text, 1, 200)), '') as snippet,
+          c.properties as chat_properties,
+          ROW_NUMBER() OVER (PARTITION BY cmj.chat_id ORDER BY m.date DESC) as rn
+        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 m.associated_message_type = ${AssociatedMessageType.NORMAL}
+          AND COALESCE(m.item_type, 0) = 0
+      ) WHERE rn = 1
+    `);
+    const data = stmt.all().reduce(
+      (acc, row) => {
+        acc[row.chat_id] = {
+          chatId: row.chat_id,
+          lastDate: row.last_date,
+          lastMessageId: row.last_message_id,
+          lastService: row.last_service,
+          lastIsFromMe: Boolean(row.last_is_from_me),
+          balloonBundleId: row.balloon_bundle_id,
+          snippet: row.snippet || null,
+          chatProperties: row.chat_properties
+        };
+        return acc;
+      },
+      {}
+    );
+    this.cachedLastByChat = { data, ts: now };
+    return data;
+  }
+  /** Unread count per chat. Cached with TTL. */
+  getUnreadByChat() {
+    const now = Date.now();
+    if (this.cachedUnreadByChat && now - this.cachedUnreadByChat.ts < IMessageDB.CACHE_TTL_MS) {
+      return this.cachedUnreadByChat.data;
+    }
+    const stmt = this.raw.prepare(`
+      SELECT cmj.chat_id, COUNT(*) as unread
+      FROM ${Tables.MESSAGE} m
+      JOIN ${Tables.CHAT_MESSAGE_JOIN} cmj ON m.ROWID = cmj.message_id
+      WHERE m.associated_message_type = ${AssociatedMessageType.NORMAL}
+        AND COALESCE(m.item_type, 0) = 0
+        AND m.is_from_me = 0 AND m.is_read = 0
+      GROUP BY cmj.chat_id
+    `);
+    const data = stmt.all().reduce(
+      (acc, row) => {
+        acc[row.chat_id] = row.unread;
+        return acc;
+      },
+      {}
+    );
+    this.cachedUnreadByChat = { data, ts: now };
+    return data;
+  }
+  /** Get all chats (without last_date subquery -- lighter for listing). */
+  getAllChats() {
+    const rows = this.raw.prepare(
+      `SELECT ROWID, guid, chat_identifier, display_name FROM ${Tables.CHAT} ORDER BY ROWID DESC`
+    ).all();
+    return rows;
+  }
+  /**
+   * Fetch message rows for a chat ROWID, ordered by date DESC.
+   * Replaces the upstream IMessageDatabase.getMessagesFromChat().
+   */
+  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);
+    }
+    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 (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);
+    }
+    const stmt = 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 = ?
+      ORDER BY m.date DESC, m.ROWID DESC
+      LIMIT ?
+    `);
+    return stmt.all(chatRowId, limit);
+  }
+  /**
+   * Extract readable text from a message row.
+   * Prefers the plain text column; falls back to parsing the attributedBody blob.
+   * Replaces the upstream IMessageDatabase.parseMessage().
+   */
+  parseMessageText(row) {
+    if (row.text && !isPlaceholderText(row.text)) return row.text;
+    return extractAttributedBodyText(row.attributedBody) || null;
+  }
+  /**
+   * From a list of chats with last_date, return the one with the most recent message (sort by last_date desc).
+   */
+  pickMostRecentChat(chats) {
+    if (chats.length === 0) throw new Error("pickMostRecentChat requires at least one chat");
+    if (chats.length === 1) return toChatRow(chats[0]);
+    const sorted = chats.slice().sort((a, b) => {
+      const aDate = a.last_date ?? 0;
+      const bDate = b.last_date ?? 0;
+      return bDate - aDate;
+    });
+    return toChatRow(sorted[0]);
+  }
+  /**
+   * Helper to find chat by identifier.
+   * When multiple chats match (e.g. same number in different services), returns the one with the most recent message.
+   */
+  findChatByIdentifier(identifier) {
+    const chats = this.getAllChatsWithLastDate();
+    const matches = chats.filter(
+      (c) => c.chat_identifier === identifier || c.guid === identifier || c.chat_identifier != null && (c.chat_identifier.includes(identifier) || identifier.includes(c.chat_identifier))
+    );
+    if (matches.length === 0) return null;
+    return this.pickMostRecentChat(matches);
+  }
+  /**
+   * Convert a raw message row to our Message type with full extended data
+   */
+  convertMessage(raw, text, chatId, extended, includeReactions = false) {
+    const ext = extended || this.fetchExtendedMessageData(raw.ROWID);
+    let cleanText = text || raw.text || null;
+    if (isPlaceholderText(cleanText)) {
+      const attributedText = extractAttributedBodyText(raw.attributedBody ?? null) || null;
+      if (attributedText) {
+        cleanText = attributedText;
+      }
+    }
+    if (cleanText) {
+      const re = new RegExp(
+        `${OBJECT_REPLACEMENT_CHAR.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}+`,
+        "g"
+      );
+      cleanText = cleanText.replace(re, "📎 ").replace(/\uFFFD/g, "").trim();
+      if (!cleanText || cleanText === "📎" || /^(📎\s*)+$/.test(cleanText)) {
+        cleanText = "(image/attachment)";
+      }
+      if (ext.balloon_bundle_id?.includes("URLBalloonProvider")) {
+        cleanText = normalizeRichMetadataText(cleanText) ?? cleanText;
+      }
+    }
+    const associatedType = ext.associated_message_type ?? AssociatedMessageType.NORMAL;
+    const isReaction = isReactionType(associatedType);
+    let reaction;
+    if (isReaction && ext.associated_message_guid) {
+      const typeInfo = TAPBACK_TYPE_MAP[associatedType] || {
+        type: "unknown",
+        isRemoval: false
+      };
+      const parsed = parseAssociatedMessageGuid(ext.associated_message_guid);
+      reaction = {
+        type: typeInfo.type,
+        emoji: ext.associated_message_emoji || void 0,
+        fromHandle: raw.is_from_me ? "me" : ext.handle_id || "unknown",
+        isRemoval: typeInfo.isRemoval,
+        targetMessageGuid: parsed?.targetGuid || "",
+        targetMessagePart: parsed?.partIndex || 0
+      };
+    }
+    const isReply = Boolean(ext.thread_originator_guid);
+    let replyTo;
+    if (isReply && ext.thread_originator_guid) {
+      const originalText = this.getMessageTextByGuid(ext.thread_originator_guid);
+      replyTo = {
+        replyToGuid: ext.thread_originator_guid,
+        replyToText: originalText
+      };
+    }
+    const richContentType = getRichContentType(ext.balloon_bundle_id || null);
+    const hasAttachments = Boolean(ext.cache_has_attachments);
+    let attachments;
+    if (hasAttachments) {
+      attachments = this.fetchAttachments(raw.ROWID);
+    }
+    let reactions;
+    if (includeReactions && !isReaction) {
+      reactions = this.fetchReactionsForMessage(raw.guid);
+      if (reactions.length > 0) {
+        reactions = this.consolidateReactions(reactions);
+      }
+      if (reactions.length === 0) reactions = void 0;
+    }
+    const rawHandle = raw.is_from_me ? "me" : ext.handle_id || "unknown";
+    const displayName = rawHandle === "me" ? void 0 : this.contacts.lookupHandle(rawHandle);
+    let richContentSummary;
+    if (ext.message_summary_info) {
+      richContentSummary = this.parseRichContentSummary(ext.message_summary_info);
+    }
+    return {
+      id: raw.ROWID,
+      guid: raw.guid,
+      text: cleanText,
+      handle: rawHandle,
+      displayName: displayName !== rawHandle ? displayName : void 0,
+      isFromMe: Boolean(raw.is_from_me),
+      date: macTimestampToDate(raw.date) || /* @__PURE__ */ new Date(0),
+      dateRead: macTimestampToDate(ext.date_read ?? null),
+      dateDelivered: macTimestampToDate(ext.date_delivered ?? null),
+      isRead: ext.is_read != null ? Boolean(ext.is_read) : true,
+      isDelivered: ext.is_delivered != null ? Boolean(ext.is_delivered) : true,
+      chatId,
+      service: this.detectServiceForMessage(ext),
+      isReaction,
+      reaction,
+      isReply,
+      replyTo,
+      reactions,
+      richContentType,
+      richContentSummary,
+      isEdited: Boolean(ext.date_edited && ext.date_edited > 0),
+      isRetracted: Boolean(ext.date_retracted && ext.date_retracted > 0),
+      hasAttachments,
+      attachments
+    };
+  }
+  /**
+   * Consolidate reactions by removing reactions that are canceled by removal messages
+   */
+  consolidateReactions(reactions) {
+    const reactionMap = /* @__PURE__ */ new Map();
+    for (const r of reactions) {
+      const key = `${r.fromHandle}-${r.type}-${r.targetMessagePart}`;
+      if (r.isRemoval) {
+        reactionMap.delete(key);
+      } else {
+        reactionMap.set(key, r);
+      }
+    }
+    return Array.from(reactionMap.values());
+  }
+  /**
+   * Detect service from extended message data (handle.service column).
+   */
+  detectServiceForMessage(ext) {
+    if (ext.handle_service) {
+      return ext.handle_service.toLowerCase().includes("sms") ? "SMS" : "iMessage";
+    }
+    return "iMessage";
+  }
+  /**
+   * Schedule a non-blocking background refresh of caches.
+   * Call after responding to an MCP tool call or TUI refresh.
+   */
+  scheduleBackgroundRefresh() {
+    if (this.backgroundRefreshScheduled) return;
+    this.backgroundRefreshScheduled = true;
+    setImmediate(() => {
+      this.backgroundRefreshScheduled = false;
+      try {
+        this.cachedAllChats = null;
+        this.cachedLastByChat = null;
+        this.cachedUnreadByChat = null;
+        this.getAllChatsWithLastDate();
+        this.scheduleBackgroundSlugSync();
+      } catch {
+      }
+    });
+  }
+  /** Resolve participant handles to display names via contacts DB. */
+  resolveParticipantNames(handles) {
+    return handles.map((h) => this.contacts.lookupHandle(h));
+  }
+  /**
+   * Close database connections
+   */
+  async close() {
+    this.raw.close();
+    this.contacts.close();
+    this.slugStore.close();
+  }
+  /**
+   * Fetch extended message data using raw DB
+   * Includes: is_read, date_read, handle_id, reaction data, reply data, edit status, attachments
+   */
+  fetchExtendedMessageData(rowid) {
+    const stmt = this.raw.prepare(`
+      SELECT 
+        m.is_read,
+        m.date_read,
+        m.is_delivered,
+        m.date_delivered,
+        h.id as handle_id,
+        h.service as handle_service,
+        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.cache_has_attachments,
+        m.message_summary_info,
+        m.payload_data
+      FROM ${Tables.MESSAGE} m
+      LEFT JOIN ${Tables.HANDLE} h ON m.handle_id = h.ROWID
+      WHERE m.ROWID = ?
+      LIMIT 1
+    `);
+    return stmt.get(rowid) || {};
+  }
+  /**
+   * Batch-fetch extended message data for multiple ROWIDs in a single query.
+   * Falls back to individual fetches for very large batches (SQLite bind param limit).
+   */
+  fetchExtendedMessageDataBatch(rowids) {
+    const result = /* @__PURE__ */ new Map();
+    if (rowids.length === 0) return result;
+    const CHUNK = 500;
+    for (let i = 0; i < rowids.length; i += CHUNK) {
+      const chunk = rowids.slice(i, i + CHUNK);
+      const placeholders = chunk.map(() => "?").join(",");
+      const stmt = this.raw.prepare(`
+        SELECT
+          m.ROWID as _rowid,
+          m.is_read, m.date_read, m.is_delivered, m.date_delivered,
+          h.id as handle_id, h.service as handle_service,
+          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.cache_has_attachments, m.message_summary_info, m.payload_data
+        FROM ${Tables.MESSAGE} m
+        LEFT JOIN ${Tables.HANDLE} h ON m.handle_id = h.ROWID
+        WHERE m.ROWID IN (${placeholders})
+      `);
+      const rows = stmt.all(...chunk);
+      for (const row of rows) {
+        result.set(row._rowid, row);
+      }
+    }
+    return result;
+  }
+  /** Max ROWID currently in the message table — used as a cache key. */
+  getMaxMessageRowId() {
+    const row = this.raw.prepare(`SELECT COALESCE(MAX(ROWID), 0) AS m FROM ${Tables.MESSAGE}`).get();
+    return Number(row.m) || 0;
+  }
+  /**
+   * Fetch every message newer than `cutoffMs` across all chats. Used by the
+   * chat_analytics tool — bounded by date, not by per-chat limit. Reactions
+   * are included (tapback analytics need them); hidden system items dropped.
+   */
+  async getMessagesInWindow(cutoffMs, capPerWindow = 2e5) {
+    const span = perf("getMessagesInWindow");
+    const cutoffNanos = Math.floor((cutoffMs / 1e3 - MAC_EPOCH_OFFSET) * NANOS_PER_SECOND);
+    const sql = `
+      SELECT m.ROWID, m.guid, m.text, m.date, m.date_read, m.date_delivered,
+             m.is_read, m.is_delivered, m.is_from_me, h.id as handle_id,
+             m.cache_has_attachments, m.associated_message_type,
+             m.associated_message_guid, m.associated_message_emoji,
+             m.item_type, c.chat_identifier
+      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
+      LEFT JOIN ${Tables.CHAT} c ON cmj.chat_id = c.ROWID
+      WHERE m.date >= ?
+      ORDER BY m.date ASC
+      LIMIT ?
+    `;
+    const rows = this.raw.prepare(sql).all(cutoffNanos, capPerWindow);
+    const out = [];
+    for (const r of rows) {
+      if (isHiddenSystemItem(r.item_type)) continue;
+      const text = this.parseMessageText(r);
+      const ext = { item_type: r.item_type };
+      const msg = this.convertMessage(r, text, r.chat_identifier || "", ext);
+      out.push(msg);
+    }
+    span.end({ cutoffMs, returned: out.length });
+    return out;
+  }
+  /**
+   * Search attachments by MIME prefix, date window, and/or chat identifier.
+   * Excludes stickers (is_sticker=1) and Apple plugin-payload UTIs which
+   * aren't meaningful as user-facing attachments.
+   *
+   * Returns metadata only — use getAttachmentByRowId for the file bytes.
+   */
+  searchAttachments(opts) {
+    const span = perf("searchAttachments");
+    const conds = [
+      "a.is_sticker = 0",
+      "(a.uti IS NULL OR a.uti NOT LIKE 'com.apple.messages.plugin%')"
+    ];
+    const params = [];
+    if (opts.mimePrefix) {
+      conds.push("a.mime_type LIKE ?");
+      params.push(`${opts.mimePrefix}%`);
+    }
+    if (opts.chatIdentifier) {
+      conds.push("c.chat_identifier = ?");
+      params.push(opts.chatIdentifier);
+    }
+    const toMacNanos = (ms) => Math.floor((ms / 1e3 - MAC_EPOCH_OFFSET) * NANOS_PER_SECOND);
+    if (opts.sinceMs !== void 0) {
+      conds.push("a.created_date >= ?");
+      params.push(toMacNanos(opts.sinceMs));
+    }
+    if (opts.untilMs !== void 0) {
+      conds.push("a.created_date <= ?");
+      params.push(toMacNanos(opts.untilMs));
+    }
+    const lim = opts.limit > 0 ? opts.limit : 1e3;
+    params.push(lim);
+    const sql = `
+      SELECT
+        a.ROWID as rowId,
+        a.filename,
+        a.mime_type,
+        a.transfer_name,
+        a.total_bytes,
+        a.created_date,
+        c.chat_identifier
+      FROM ${Tables.ATTACHMENT} a
+      JOIN ${Tables.MESSAGE_ATTACHMENT_JOIN} maj ON a.ROWID = maj.attachment_id
+      JOIN ${Tables.MESSAGE} m ON maj.message_id = m.ROWID
+      JOIN ${Tables.CHAT_MESSAGE_JOIN} cmj ON m.ROWID = cmj.message_id
+      JOIN ${Tables.CHAT} c ON cmj.chat_id = c.ROWID
+      WHERE ${conds.join(" AND ")}
+      ORDER BY a.created_date DESC
+      LIMIT ?
+    `;
+    const rows = this.raw.prepare(sql).all(...params);
+    const out = rows.map((r) => ({
+      rowId: Number(r.rowId),
+      filename: r.filename || "",
+      mimeType: r.mime_type ?? null,
+      transferName: r.transfer_name ?? null,
+      totalBytes: Number(r.total_bytes) || 0,
+      createdDate: macTimestampToDate$1(Number(r.created_date)) ?? /* @__PURE__ */ new Date(0),
+      chatId: r.chat_identifier || ""
+    }));
+    span.end({ count: out.length });
+    return out;
+  }
+  /** Fetch a single attachment record by ROWID. */
+  getAttachmentByRowId(rowId) {
+    const row = this.raw.prepare(
+      `SELECT ROWID as rowId, filename, mime_type, transfer_name, total_bytes
+         FROM ${Tables.ATTACHMENT}
+         WHERE ROWID = ?`
+    ).get(rowId);
+    if (!row) return null;
+    return {
+      rowId: Number(row.rowId),
+      filename: row.filename || "",
+      mimeType: row.mime_type ?? null,
+      transferName: row.transfer_name ?? null,
+      totalBytes: Number(row.total_bytes) || 0
+    };
+  }
+  /**
+   * Fetch attachments for a message
+   */
+  fetchAttachments(messageRowId) {
+    const stmt = this.raw.prepare(`
+      SELECT 
+        a.filename,
+        a.mime_type,
+        a.transfer_name,
+        a.total_bytes
+      FROM ${Tables.ATTACHMENT} a
+      JOIN ${Tables.MESSAGE_ATTACHMENT_JOIN} maj ON a.ROWID = maj.attachment_id
+      WHERE maj.message_id = ?
+    `);
+    const rows = stmt.all(messageRowId);
+    return rows.map((r) => ({
+      filename: r.filename || "",
+      mimeType: r.mime_type,
+      transferName: r.transfer_name,
+      totalBytes: r.total_bytes || 0
+    }));
+  }
+  /**
+   * Batch-fetch all reactions in a chat, grouped by target message GUID.
+   * One query replaces N individual LIKE queries (the main perf bottleneck).
+   */
+  fetchReactionsForChat(chatRowId) {
+    const stmt = this.raw.prepare(`
+      SELECT
+        m.associated_message_type,
+        m.associated_message_guid,
+        m.associated_message_emoji,
+        h.id as handle_id,
+        m.is_from_me
+      FROM ${Tables.MESSAGE} m
+      LEFT JOIN ${Tables.HANDLE} h ON m.handle_id = h.ROWID
+      JOIN ${Tables.CHAT_MESSAGE_JOIN} cmj ON m.ROWID = cmj.message_id
+      WHERE cmj.chat_id = ?
+        AND m.associated_message_type >= 2000
+    `);
+    const rows = stmt.all(chatRowId);
+    const result = /* @__PURE__ */ new Map();
+    for (const r of rows) {
+      const typeInfo = TAPBACK_TYPE_MAP[r.associated_message_type] || {
+        type: "unknown",
+        isRemoval: false
+      };
+      const parsed = parseAssociatedMessageGuid(r.associated_message_guid);
+      const targetGuid = parsed?.targetGuid;
+      if (!targetGuid) continue;
+      const reaction = {
+        type: typeInfo.type,
+        emoji: r.associated_message_emoji || void 0,
+        fromHandle: r.is_from_me ? "me" : r.handle_id || "unknown",
+        isRemoval: typeInfo.isRemoval,
+        targetMessageGuid: targetGuid,
+        targetMessagePart: parsed?.partIndex || 0
+      };
+      const existing = result.get(targetGuid);
+      if (existing) existing.push(reaction);
+      else result.set(targetGuid, [reaction]);
+    }
+    return result;
+  }
+  /**
+   * Fetch reactions for a specific message GUID
+   */
+  fetchReactionsForMessage(messageGuid) {
+    const stmt = this.raw.prepare(`
+      SELECT 
+        m.associated_message_type,
+        m.associated_message_guid,
+        m.associated_message_emoji,
+        h.id as handle_id,
+        m.is_from_me
+      FROM ${Tables.MESSAGE} m
+      LEFT JOIN ${Tables.HANDLE} h ON m.handle_id = h.ROWID
+      WHERE m.associated_message_guid LIKE ?
+        AND m.associated_message_type >= 2000
+    `);
+    const rows = stmt.all(`%/${messageGuid}`);
+    return rows.map((r) => {
+      const typeInfo = TAPBACK_TYPE_MAP[r.associated_message_type] || {
+        type: "unknown",
+        isRemoval: false
+      };
+      const parsed = parseAssociatedMessageGuid(r.associated_message_guid);
+      return {
+        type: typeInfo.type,
+        emoji: r.associated_message_emoji || void 0,
+        fromHandle: r.is_from_me ? "me" : r.handle_id || "unknown",
+        isRemoval: typeInfo.isRemoval,
+        targetMessageGuid: parsed?.targetGuid || messageGuid,
+        targetMessagePart: parsed?.partIndex || 0
+      };
+    });
+  }
+  /**
+   * Parse rich content summary from message_summary_info BLOB
+   * This contains metadata about link previews, rich messages, etc.
+   */
+  parseRichContentSummary(blob) {
+    if (!blob) return void 0;
+    try {
+      const str = blob.toString("utf8");
+      const urlMatch = str.match(/https?:\/\/\S+/);
+      if (urlMatch) {
+        return `Link: ${urlMatch[0]}`;
+      }
+      const titleMatch = str.match(/<string>([^<]+)<\/string>/);
+      if (titleMatch) {
+        return titleMatch[1];
+      }
+      return "[Rich Content]";
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Look up the text of a message by GUID (for reply context)
+   * Falls back to parsing attributedBody if text is null
+   */
+  getMessageTextByRowId(rowId) {
+    const row = this.raw.prepare(`SELECT ROWID, text, attributedBody FROM ${Tables.MESSAGE} WHERE ROWID = ? LIMIT 1`).get(rowId);
+    return this.extractMessageText(row);
+  }
+  getMessageTextByGuid(guid) {
+    const row = this.raw.prepare(`SELECT ROWID, text, attributedBody FROM ${Tables.MESSAGE} WHERE guid = ? LIMIT 1`).get(guid);
+    return this.extractMessageText(row);
+  }
+  extractMessageText(row) {
+    if (!row) return null;
+    if (row.text && !isPlaceholderText(row.text)) return row.text;
+    return extractAttributedBodyText(row.attributedBody) || null;
+  }
+}
+const imessageDb = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  IMessageDB
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  IMessageDB as I,
+  hasNativeModule as h,
+  imessageDb as i
+};
+//# sourceMappingURL=imessage-db-BVDtx0Sn.js.map