Meridian Mail — почта, календарь, контакты, задачи

PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON; PRAGMA application_id = 0x4D4D5831; -- 'MMX1'

CREATE TABLE accounts (
  id INTEGER PRIMARY KEY, name TEXT NOT NULL, email TEXT NOT NULL, kind TEXT NOT NULL CHECK(kind IN ('imap','pop3','ews','graph','gmail-api','jmap','local')),
  color TEXT, ord INTEGER, enabled INTEGER DEFAULT 1,
  incoming_host TEXT, incoming_port INTEGER, incoming_tls TEXT CHECK(incoming_tls IN ('tls','starttls','none')),
  outgoing_host TEXT, outgoing_port INTEGER, outgoing_tls TEXT, auth TEXT CHECK(auth IN ('password','oauth2','ntlm','none')),
  credential_ref TEXT,                       -- ключ в хранилище ОС / key in OS keystore (никогда сам секрет)
  oauth_provider TEXT, sync_days INTEGER DEFAULT 0, sync_bodies INTEGER DEFAULT 1,
  capabilities TEXT,                         -- JSON: CONDSTORE, QRESYNC, MOVE, IDLE, ...
  delimiter TEXT, namespaces TEXT, quota_used INTEGER, quota_total INTEGER, last_sync INTEGER, last_error TEXT
);
CREATE TABLE identities (
  id INTEGER PRIMARY KEY, account_id INTEGER REFERENCES accounts(id) ON DELETE CASCADE,
  name TEXT, email TEXT NOT NULL, reply_to TEXT, signature_html TEXT, signature_text TEXT,
  is_default INTEGER DEFAULT 0, smime_cert_ref TEXT, pgp_key_fpr TEXT, prefer_encrypt INTEGER DEFAULT 0
);
CREATE TABLE folders (
  id INTEGER PRIMARY KEY, account_id INTEGER REFERENCES accounts(id) ON DELETE CASCADE,
  parent_id INTEGER REFERENCES folders(id), name TEXT NOT NULL, full_name TEXT NOT NULL,   -- IMAP mailbox name (UTF-7 → UTF-8)
  role TEXT CHECK(role IN ('inbox','sent','drafts','trash','junk','archive','all','outbox','custom')),
  uidvalidity INTEGER, uidnext INTEGER, highestmodseq INTEGER, exists_count INTEGER, unseen_count INTEGER,
  subscribed INTEGER DEFAULT 1, favorite INTEGER DEFAULT 0, ord INTEGER, sync_enabled INTEGER DEFAULT 1,
  last_sync INTEGER, local_only INTEGER DEFAULT 0, color TEXT,
  UNIQUE(account_id, full_name)
);
CREATE TABLE messages (
  id INTEGER PRIMARY KEY, folder_id INTEGER NOT NULL REFERENCES folders(id) ON DELETE CASCADE,
  uid INTEGER,                               -- IMAP UID (NULL для локальных/POP) / NULL for local/POP
  modseq INTEGER, message_id TEXT, in_reply_to TEXT, refs TEXT,          -- References (JSON array)
  thread_id INTEGER REFERENCES threads(id),
  subject TEXT, subject_norm TEXT,           -- без Re:/Fwd: / normalized subject
  from_name TEXT, from_addr TEXT, to_json TEXT, cc_json TEXT, bcc_json TEXT, reply_to_json TEXT,
  date INTEGER, received INTEGER, size INTEGER, snippet TEXT,
  flags INTEGER NOT NULL DEFAULT 0,          -- bit: 1 seen, 2 answered, 4 flagged, 8 deleted, 16 draft, 32 forwarded, 64 junk, 128 phishing
  keywords TEXT,                             -- JSON: IMAP keywords ($label1, custom)
  has_attachments INTEGER DEFAULT 0, priority INTEGER DEFAULT 3, encryption TEXT, signature_state TEXT,
  body_state TEXT CHECK(body_state IN ('none','headers','partial','full')) DEFAULT 'headers',
  body_path TEXT, pop_uidl TEXT, list_id TEXT, list_unsubscribe TEXT,
  spam_score REAL, auth_results TEXT, pinned INTEGER DEFAULT 0, snooze_until INTEGER,
  UNIQUE(folder_id, uid)
);
CREATE INDEX messages_folder_date ON messages(folder_id, date DESC);
CREATE INDEX messages_msgid ON messages(message_id);
CREATE INDEX messages_thread ON messages(thread_id);
CREATE INDEX messages_flags ON messages(folder_id, flags);
CREATE TABLE parts (
  id INTEGER PRIMARY KEY, message_id INTEGER REFERENCES messages(id) ON DELETE CASCADE,
  section TEXT NOT NULL,                     -- IMAP section: "1", "1.2", "2"
  mime_type TEXT, filename TEXT, content_id TEXT, disposition TEXT, size INTEGER, charset TEXT, encoding TEXT,
  sha256 TEXT, store_path TEXT, fetched INTEGER DEFAULT 0, is_attachment INTEGER DEFAULT 0, text_extracted INTEGER DEFAULT 0
);
CREATE INDEX parts_msg ON parts(message_id);
CREATE TABLE threads (
  id INTEGER PRIMARY KEY, account_id INTEGER, root_message_id TEXT, subject_norm TEXT,
  last_date INTEGER, count INTEGER, unseen INTEGER, flagged INTEGER, participants TEXT
);
CREATE INDEX threads_last ON threads(account_id, last_date DESC);
CREATE TABLE labels (id INTEGER PRIMARY KEY, account_id INTEGER, name TEXT, color TEXT, keyword TEXT, remote_id TEXT, ord INTEGER);
CREATE TABLE message_labels (message_id INTEGER REFERENCES messages(id) ON DELETE CASCADE, label_id INTEGER REFERENCES labels(id) ON DELETE CASCADE, PRIMARY KEY(message_id, label_id));
CREATE TABLE rules (
  id INTEGER PRIMARY KEY, account_id INTEGER, name TEXT, enabled INTEGER DEFAULT 1, ord INTEGER,
  match_all INTEGER DEFAULT 1, conditions TEXT NOT NULL, actions TEXT NOT NULL,        -- JSON
  run_on TEXT DEFAULT 'incoming', server_side TEXT, hits INTEGER DEFAULT 0, last_hit INTEGER
);
CREATE TABLE outbox (
  id INTEGER PRIMARY KEY, identity_id INTEGER REFERENCES identities(id), draft_message_id INTEGER REFERENCES messages(id),
  eml_path TEXT NOT NULL, recipients TEXT NOT NULL, send_after INTEGER, attempts INTEGER DEFAULT 0, next_attempt INTEGER,
  state TEXT CHECK(state IN ('scheduled','queued','sending','sent','failed','cancelled')) DEFAULT 'queued',
  last_error TEXT, created INTEGER, undo_until INTEGER
);
CREATE TABLE pending_ops (                   -- очередь действий для сервера / offline action queue
  id INTEGER PRIMARY KEY, account_id INTEGER, kind TEXT NOT NULL,   -- flags|move|copy|delete|append|expunge|label|create_folder|...
  payload TEXT NOT NULL, created INTEGER, attempts INTEGER DEFAULT 0, last_error TEXT
);
CREATE TABLE sync_state (folder_id INTEGER PRIMARY KEY REFERENCES folders(id) ON DELETE CASCADE,
  mode TEXT CHECK(mode IN ('qresync','condstore','plain')), last_uid INTEGER, last_modseq INTEGER, last_full_check INTEGER, in_progress INTEGER DEFAULT 0);

-- Календарь / Calendar
CREATE TABLE calendars (
  id INTEGER PRIMARY KEY, account_id INTEGER REFERENCES accounts(id) ON DELETE CASCADE, name TEXT NOT NULL, color TEXT,
  kind TEXT CHECK(kind IN ('local','caldav','google','graph','ews','subscription')), url TEXT, ctag TEXT, sync_token TEXT,
  visible INTEGER DEFAULT 1, read_only INTEGER DEFAULT 0, is_default INTEGER DEFAULT 0, default_alarms TEXT, tz TEXT, ord INTEGER, last_sync INTEGER
);
CREATE TABLE events (
  id INTEGER PRIMARY KEY, calendar_id INTEGER NOT NULL REFERENCES calendars(id) ON DELETE CASCADE,
  uid TEXT NOT NULL, recurrence_id TEXT,     -- NULL для мастера серии / NULL for the master
  etag TEXT, href TEXT, sequence INTEGER DEFAULT 0,
  summary TEXT, location TEXT, description TEXT, description_html TEXT, url TEXT, categories TEXT, color TEXT,
  dtstart INTEGER NOT NULL, dtstart_tz TEXT, dtend INTEGER, dtend_tz TEXT, all_day INTEGER DEFAULT 0, floating INTEGER DEFAULT 0,
  rrule TEXT, rdates TEXT, exdates TEXT, status TEXT, transp TEXT, class TEXT, priority INTEGER,
  organizer TEXT, is_organizer INTEGER, my_partstat TEXT, created INTEGER, last_modified INTEGER, dtstamp INTEGER,
  ical BLOB,                                 -- исходный VEVENT для round-trip / original VEVENT
  UNIQUE(calendar_id, uid, recurrence_id)
);
CREATE INDEX events_range ON events(calendar_id, dtstart, dtend);
CREATE TABLE event_instances (               -- развёрнутые экземпляры (кэш) / expanded occurrences cache
  event_id INTEGER REFERENCES events(id) ON DELETE CASCADE, start INTEGER NOT NULL, end INTEGER NOT NULL,
  is_override INTEGER DEFAULT 0, cancelled INTEGER DEFAULT 0, PRIMARY KEY(event_id, start)
);
CREATE INDEX instances_range ON event_instances(start, end);
CREATE TABLE attendees (event_id INTEGER REFERENCES events(id) ON DELETE CASCADE, email TEXT, name TEXT, role TEXT, partstat TEXT, rsvp INTEGER, cutype TEXT, delegated_to TEXT, PRIMARY KEY(event_id, email));
CREATE TABLE alarms (id INTEGER PRIMARY KEY, event_id INTEGER REFERENCES events(id) ON DELETE CASCADE, task_id INTEGER, action TEXT, trigger_rel INTEGER, trigger_abs INTEGER, related TEXT, description TEXT, acknowledged INTEGER, snoozed_until INTEGER);
CREATE TABLE freebusy_cache (email TEXT, start INTEGER, end INTEGER, kind TEXT, fetched INTEGER, PRIMARY KEY(email, start, end));

-- Контакты / Contacts
CREATE TABLE addressbooks (id INTEGER PRIMARY KEY, account_id INTEGER, name TEXT, kind TEXT CHECK(kind IN ('local','carddav','google','graph','ews','ldap','collected')), url TEXT, ctag TEXT, sync_token TEXT, read_only INTEGER DEFAULT 0, ord INTEGER);
CREATE TABLE contacts (
  id INTEGER PRIMARY KEY, addressbook_id INTEGER REFERENCES addressbooks(id) ON DELETE CASCADE, uid TEXT, etag TEXT, href TEXT,
  kind TEXT DEFAULT 'individual', fn TEXT, family TEXT, given TEXT, additional TEXT, prefix TEXT, suffix TEXT, nickname TEXT,
  sort_key TEXT, org TEXT, title TEXT, bday TEXT, anniversary TEXT, note TEXT, photo_path TEXT, categories TEXT,
  vcard BLOB, vcard_version TEXT, created INTEGER, modified INTEGER, UNIQUE(addressbook_id, uid)
);
CREATE INDEX contacts_sort ON contacts(sort_key);
CREATE TABLE contact_emails (contact_id INTEGER REFERENCES contacts(id) ON DELETE CASCADE, email TEXT NOT NULL, email_norm TEXT NOT NULL, type TEXT, pref INTEGER DEFAULT 0);
CREATE INDEX contact_emails_norm ON contact_emails(email_norm);
CREATE TABLE contact_phones (contact_id INTEGER REFERENCES contacts(id) ON DELETE CASCADE, phone TEXT, phone_e164 TEXT, type TEXT, pref INTEGER DEFAULT 0);
CREATE INDEX contact_phones_e164 ON contact_phones(phone_e164);
CREATE TABLE contact_addresses (contact_id INTEGER REFERENCES contacts(id) ON DELETE CASCADE, type TEXT, street TEXT, city TEXT, region TEXT, postal TEXT, country TEXT);
CREATE TABLE contact_groups (id INTEGER PRIMARY KEY, addressbook_id INTEGER, uid TEXT, name TEXT, filter TEXT);
CREATE TABLE contact_group_members (group_id INTEGER REFERENCES contact_groups(id) ON DELETE CASCADE, contact_id INTEGER REFERENCES contacts(id) ON DELETE CASCADE, PRIMARY KEY(group_id, contact_id));
CREATE TABLE not_duplicates (a INTEGER, b INTEGER, PRIMARY KEY(a, b));

-- Задачи / Tasks
CREATE TABLE task_lists (id INTEGER PRIMARY KEY, account_id INTEGER, name TEXT, color TEXT, kind TEXT CHECK(kind IN ('local','caldav','google','graph','ews','flagged')), url TEXT, ctag TEXT, sync_token TEXT, ord INTEGER);
CREATE TABLE tasks (
  id INTEGER PRIMARY KEY, list_id INTEGER REFERENCES task_lists(id) ON DELETE CASCADE, uid TEXT, etag TEXT, href TEXT,
  parent_id INTEGER REFERENCES tasks(id) ON DELETE CASCADE, summary TEXT NOT NULL, description TEXT,
  dtstart INTEGER, due INTEGER, completed INTEGER, status TEXT, percent INTEGER DEFAULT 0, priority INTEGER DEFAULT 0,
  categories TEXT, rrule TEXT, rrule_after_completion INTEGER DEFAULT 0, ord INTEGER,
  linked_message_id INTEGER REFERENCES messages(id) ON DELETE SET NULL, linked_event_id INTEGER, ical BLOB, created INTEGER, modified INTEGER
);
CREATE INDEX tasks_due ON tasks(due);

-- Вложения (общие) / Attachments registry
CREATE TABLE attachments (sha256 TEXT PRIMARY KEY, size INTEGER, mime_type TEXT, refcount INTEGER DEFAULT 0, text_path TEXT, thumb_path TEXT);

-- Индекс / Index bookkeeping
CREATE TABLE fts_state (message_id INTEGER PRIMARY KEY, indexed_hash BLOB, indexed_at INTEGER);
CREATE TABLE settings (key TEXT PRIMARY KEY, value TEXT);

// kernel/crates/meridian-mail/src/model.rs
pub struct Envelope {
    pub message_id: Option<String>, pub in_reply_to: Option<String>, pub references: Vec<String>,
    pub subject: String, pub from: Vec<Mailbox>, pub to: Vec<Mailbox>, pub cc: Vec<Mailbox>,
    pub date: Option<DateTime<FixedOffset>>, pub size: u64,
}
pub struct Mailbox { pub name: Option<String>, pub addr: String }

bitflags! { pub struct Flags: u32 { const SEEN=1; const ANSWERED=2; const FLAGGED=4; const DELETED=8; const DRAFT=16;
            const FORWARDED=32; const JUNK=64; const PHISHING=128; } }

pub struct MimePart {
    pub section: String, pub ctype: Mime, pub params: BTreeMap<String,String>,
    pub disposition: Option<Disposition>, pub filename: Option<String>, pub content_id: Option<String>,
    pub encoding: Transfer, pub charset: Option<String>, pub size: u64,
    pub body: PartBody,                      // Inline(Bytes) | Stored(sha256) | NotFetched
    pub children: Vec<MimePart>,             // для multipart / for multipart
}

pub struct Event {
    pub uid: String, pub recurrence_id: Option<DateTimeOrDate>, pub sequence: u32,
    pub summary: String, pub dtstart: DateTimeOrDate, pub dtend: Option<DateTimeOrDate>, pub duration: Option<Duration>,
    pub rrule: Option<RRule>, pub rdate: Vec<DateTimeOrDate>, pub exdate: Vec<DateTimeOrDate>,
    pub attendees: Vec<Attendee>, pub organizer: Option<Attendee>, pub alarms: Vec<Alarm>,
    pub status: EventStatus, pub transp: Transp, pub class: Class, pub extra: Vec<IcalProperty>,   // round-trip
}

pub enum DateTimeOrDate { Date(NaiveDate), Floating(NaiveDateTime), Utc(DateTime<Utc>), Zoned { local: NaiveDateTime, tzid: TzId } }

/// Инкрементальная синхронизация папки / Incremental folder sync
pub async fn sync_folder(cx: &mut ImapSession, db: &Db, f: &Folder) -> Result<()> {
    // 1. Воспроизвести локальные операции (флаги, перемещения) до чтения состояния сервера
    //    / Replay local pending ops before reading server state
    replay_pending_ops(cx, db, f).await?;

    // 2. SELECT с QRESYNC, если можем / SELECT with QRESYNC when possible
    let st = db.sync_state(f.id)?;
    let sel = if cx.caps.qresync && st.mode == Qresync && st.last_modseq > 0 {
        cx.select_qresync(&f.full_name, f.uidvalidity, st.last_modseq).await?
    } else { cx.select(&f.full_name).await? };

    // 3. UIDVALIDITY изменился → кэш недействителен / UIDVALIDITY changed → drop cache
    if sel.uidvalidity != f.uidvalidity {
        db.invalidate_folder(f.id)?;                      // тела остаются по message_id для повторного связывания
        return Box::pin(full_sync(cx, db, f, sel)).await;
    }

    match st.mode {
        Qresync => {
            // Сервер уже прислал VANISHED (EARLIER) и FETCH FLAGS для изменённых / server pushed VANISHED + FLAGS
            db.apply_vanished(f.id, &sel.vanished)?;
            db.apply_flag_updates(f.id, &sel.flag_updates)?;
        }
        Condstore => {
            // Изменённые флаги / changed flags since last MODSEQ
            let changed = cx.uid_fetch("1:*", "(FLAGS)", Some(st.last_modseq)).await?;   // CHANGEDSINCE
            db.apply_flag_updates(f.id, &changed)?;
            // Удаления — сравнением множеств UID (дёшево: UID SEARCH ALL / ESEARCH) / deletions by UID set diff
            let server_uids = cx.uid_search_all().await?;
            db.delete_missing(f.id, &server_uids)?;
        }
        Plain => {
            let server = cx.uid_fetch("1:*", "(FLAGS)", None).await?;
            db.delete_missing(f.id, &server.uids())?;
            db.apply_flag_updates(f.id, &server)?;
        }
    }

    // 4. Новые письма: UID > last_uid → заголовки пачками по 500 / new messages: headers in batches of 500
    let new_range = format!("{}:*", st.last_uid + 1);
    let envs = cx.uid_fetch(&new_range, "(UID FLAGS MODSEQ RFC822.SIZE BODYSTRUCTURE ENVELOPE BODY.PEEK[HEADER.FIELDS (MESSAGE-ID IN-REPLY-TO REFERENCES LIST-ID LIST-UNSUBSCRIBE AUTHENTICATION-RESULTS X-PRIORITY)])", None).await?;
    for env in envs.iter().filter(|e| e.uid > st.last_uid) {
        let msg_id = db.upsert_message(f.id, env)?;
        thread_insert(db, msg_id)?;                         // JWZ, инкрементально / incremental threading
        rules_enqueue(db, msg_id)?;                         // правила на новые письма / rules for new mail
        if f.policy.fetch_bodies(env) { body_queue.push(f.id, env.uid, Priority::Background); }
    }

    // 5. Сохранить курсор / persist cursor
    db.set_sync_state(f.id, SyncState { last_uid: sel.uidnext - 1, last_modseq: sel.highestmodseq, .. })?;
    Ok(())
}

/// Построение цепочек (Zawinski) / JWZ threading
pub fn build_threads(msgs: &[MsgRef]) -> Vec<ContainerId> {
    let mut table: HashMap<String, ContainerId> = HashMap::new();   // id_table
    let mut arena = Arena::new();                                    // контейнеры: msg: Option<MsgRef>, parent, children
    // 1. Для каждого письма / for each message
    for m in msgs {
        let mid = m.message_id.clone().unwrap_or_else(|| format!("<missing-{}>", m.db_id)); // синтетический id
        let c = *table.entry(mid.clone()).or_insert_with(|| arena.new_container(None));
        if arena[c].msg.is_some() { /* дубликат Message-ID → новый контейнер */ let d = arena.new_container(Some(m.clone())); arena.attach(c, d); continue; }
        arena[c].msg = Some(m.clone());
        // 1B. References по цепочке: каждый ссылается на следующий / link References chain
        let mut prev: Option<ContainerId> = None;
        for r in m.references.iter().chain(m.in_reply_to.iter()) {     // In-Reply-To добавляется как последний
            let rc = *table.entry(r.clone()).or_insert_with(|| arena.new_container(None));
            if let Some(p) = prev { if rc != p && !arena.reachable(rc, p) && arena[rc].parent.is_none() { arena.attach(p, rc); } }
            prev = Some(rc);
        }
        // 1C. Родитель текущего — последний из References; снять старого родителя / set parent = last reference
        if let Some(p) = prev { if p != c && !arena.reachable(c, p) { arena.detach(c); arena.attach(p, c); } }
    }
    // 2. Корни — контейнеры без родителя / roots = no parent
    let mut roots: Vec<_> = arena.ids().filter(|&c| arena[c].parent.is_none()).collect();
    // 4. Удалить пустые контейнеры / prune empty containers
    roots = roots.into_iter().flat_map(|r| prune_empty(&mut arena, r)).collect();
    // 5. Группировка по теме (без Re:/Fwd:/[list]) / group by normalized subject
    let mut by_subject: HashMap<String, ContainerId> = HashMap::new();
    for &r in &roots {
        let subj = normalized_subject(&arena, r);
        if subj.is_empty() { continue; }
        match by_subject.get(&subj) {
            None => { by_subject.insert(subj, r); }
            Some(&other) => {
                // предпочитаем контейнер без сообщения или с темой без Re: / prefer empty or non-reply root
                let (keep, merge) = choose_root(&arena, other, r);
                merge_roots(&mut arena, keep, merge); by_subject.insert(subj, keep);
            }
        }
    }
    roots.retain(|r| arena[*r].parent.is_none());
    // 6. Сортировка детей по дате / sort children by date
    for r in &roots { arena.sort_by_date(*r); }
    roots
}

interface MailApp {
  accounts: Account[]; defaultAccount: Account;
  folders: { inbox: Folder; sent: Folder; drafts: Folder; trash: Folder; byId(id: number): Folder; find(path: string): Folder | null };
  selection: Item[]; activeItem: Item | null;
  createItem(kind: 'mail'): MailItem; createItem(kind: 'appointment'): AppointmentItem;
  createItem(kind: 'contact'): ContactItem; createItem(kind: 'task'): TaskItem;
  search(query: string, opts?: { account?: Account; folder?: Folder; limit?: number }): Promise<MailItem[]>;
  calendars: Calendar[]; addressBooks: AddressBook[]; taskLists: TaskList[];
  on(event: 'newMail', h: (e: { item: MailItem }) => void): Disposable;
  on(event: 'beforeSend', h: (e: { item: MailItem; cancel: boolean; reason?: string }) => void | Promise<void>): Disposable;
  on(event: 'itemChanged' | 'itemMoved' | 'itemDeleted', h: (e: { item: Item; folder?: Folder }) => void): Disposable;
  on(event: 'reminder', h: (e: { item: AppointmentItem | TaskItem }) => void): Disposable;
  on(event: 'syncCompleted', h: (e: { account: Account }) => void): Disposable;
  ui: { message(text: string): Promise<void>; prompt(label: string): Promise<string | null>; notify(title: string, body: string): void };
}
interface Account { id: number; name: string; email: string; kind: string; folders: Folder[]; identities: Identity[]; sync(): Promise<void>; }
interface Folder { id: number; name: string; path: string; role: string; unread: number; total: number; parent: Folder | null; children: Folder[];
  items(opts?: { unreadOnly?: boolean; since?: Date; limit?: number }): Promise<MailItem[]>; }
interface Item { id: number; kind: 'mail'|'appointment'|'contact'|'task'; created: Date; modified: Date; categories: string[];
  save(): Promise<void>; delete(): Promise<void>; open(): void; }
interface MailItem extends Item {
  subject: string; from: Address; to: Address[]; cc: Address[]; bcc: Address[]; replyTo: Address[];
  date: Date; body: string; htmlBody: string; snippet: string; attachments: Attachment[];
  unread: boolean; flagged: boolean; answered: boolean; importance: 'low'|'normal'|'high'; folder: Folder; thread: MailItem[];
  headers: Record<string, string>; messageId: string; encryption: 'none'|'smime'|'pgp'; signatureValid: boolean | null;
  reply(all?: boolean): MailItem; forward(): MailItem; send(opts?: { at?: Date }): Promise<void>;
  move(to: Folder): Promise<void>; copy(to: Folder): Promise<void>; markRead(v?: boolean): Promise<void>; flag(due?: Date): Promise<void>;
  addAttachment(path: string | Blob, name?: string): Promise<Attachment>; saveAs(path: string, format: 'eml'|'pdf'|'html'): Promise<void>;
}
interface AppointmentItem extends Item { subject: string; start: Date; end: Date; allDay: boolean; location: string; body: string; calendar: Calendar;
  recurrence: RecurrenceRule | null; attendees: Attendee[]; organizer: Address | null; reminders: Reminder[]; busyStatus: 'free'|'tentative'|'busy'|'oof';
  sendInvitations(): Promise<void>; respond(status: 'accepted'|'tentative'|'declined', opts?: { send?: boolean; comment?: string }): Promise<void>;
  occurrences(from: Date, to: Date): Promise<AppointmentItem[]>; }
interface ContactItem extends Item { fullName: string; firstName: string; lastName: string; company: string; jobTitle: string;
  emails: { type: string; address: string }[]; phones: { type: string; number: string }[]; addresses: PostalAddress[]; birthday: Date | null; notes: string; photo: Blob | null; groups: string[]; }
interface TaskItem extends Item { subject: string; body: string; due: Date | null; start: Date | null; status: 'needs-action'|'in-process'|'completed'|'cancelled';
  percent: number; priority: 1|5|9|0; list: TaskList; parent: TaskItem | null; subtasks: TaskItem[]; linkedMail: MailItem | null; complete(): Promise<void>; }

// 1. Автоматическое сохранение счетов из писем в папку и задача на оплату / Save invoices and create a task
App.on('newMail', async ({ item }) => {
  if (!/счёт|invoice/i.test(item.subject)) return;
  for (const a of item.attachments.filter(a => a.name.endsWith('.pdf'))) {
    await a.saveTo(`~/Документы/Счета/${item.date.toISOString().slice(0,7)}/${a.name}`);
  }
  const t = App.createItem('task');
  t.subject = `Оплатить: ${item.subject}`; t.due = new Date(Date.now() + 5 * 864e5); t.linkedMail = item;
  await t.save();
  await item.move(App.folders.find('Входящие/Счета')!);
});

// 2. Проверка перед отправкой: вложение упомянуто, но не приложено / Attachment reminder before send
App.on('beforeSend', e => {
  const mentions = /вложени|прилага|attached|attachment/i.test(e.item.body);
  if (mentions && e.item.attachments.length === 0) { e.cancel = true; e.reason = 'В письме упомянуто вложение, но файлов нет.'; }
});

// 3. Встреча из выделенного письма с участниками из To/Cc / Meeting from the selected message
const m = App.activeItem as MailItem;
const ap = App.createItem('appointment');
ap.subject = `Обсуждение: ${m.subject}`; ap.start = new Date(Date.now() + 864e5); ap.end = new Date(ap.start.getTime() + 36e5);
ap.attendees = [m.from, ...m.to, ...m.cc].map(a => ({ address: a, role: 'required' }));
ap.body = `Контекст: ${m.snippet}\n${m.messageId}`;
await ap.save(); await ap.sendInvitations();

// 4. Отчёт по непрочитанным за неделю в Sheets / Weekly unread report to Sheets
const items = await App.folders.inbox.items({ unreadOnly: true, since: new Date(Date.now() - 7 * 864e5) });
const rows = items.map(i => [i.date, i.from.address, i.subject, i.attachments.length]);
await Meridian.sheets.createWorkbook({ sheets: [{ name: 'Непрочитанные', rows: [['Дата','От','Тема','Вложений'], ...rows] }] });