@wirecat/cli-core 0.487.0 → 0.489.0

package/dist/store/sqlite/calendar.js

@@ -1,5 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
-import { calendarText, entryMetadata, joinKeyOf, joinUrlWithoutQuery, } from "../../meetings/index.js";
+import { calendarText, entryInWindow, entryMetadata, joinKeyOf, joinUrlWithoutQuery, } from "../../meetings/index.js";
+import { listEvents } from "./calendar-events.js";
 import { bool, eventOf, fromJson, int, str, toJson } from "./events.js";
 import { driveDocumentOf, driveFileTarget, logFileLink } from "./files.js";
 import { identityOf } from "./identities.js";
@@ -51,6 +52,8 @@ const entryOf = (row) => ({
     etag: str(row.etag),
     seenAt: int(row.seen_at),
     deletedAt: int(row.deleted_at),
+    createdAt: Number(row.created_at),
+    transparency: str(row.transparency),
 });
 const participantOf = (row) => ({
     entryId: Number(row.entry_id),
@@ -79,6 +82,7 @@ const reviewOf = (row) => ({
     id: Number(row.id),
     linkableType: String(row.linkable_type),
     linkableId: Number(row.linkable_id),
+    calendarId: int(row.calendar_id),
     entityType: String(row.entity_type),
     candidates: fromJson(row.candidates),
     reason: String(row.reason),
@@ -94,6 +98,8 @@ const attachmentOf = (row) => ({
     title: str(fromJson(row.metadata)?.title),
     documentId: int(row.to_id),
 });
+const REVIEWS = "SELECT r.*, CASE WHEN r.linkable_type = 'calendar_entry' THEN " +
+    "(SELECT calendar_id FROM calendar_entries WHERE id = r.linkable_id) END AS calendar_id FROM link_reviews r";
 const TRACKED = ["title", "starts_at", "ends_at", "location", "status", "recurrence", "recurrence_ends_at"];
 const flag = (value) => (value ? 1 : 0);
 const cursorKey = (calendarId) => `calendar:${calendarId}`;
@@ -448,6 +454,56 @@ export const eventStoreOver = (context) => {
                 refreshEvent(Number(row.event_id), now);
         }
     };
+    const saveAll = (calendarId, entries, now) => {
+        calendarRow(calendarId);
+        // A series first, so an occurrence in the same page finds it.
+        const ordered = [...entries].sort((a, b) => Number(b.kind === "series") - Number(a.kind === "series"));
+        const ids = new Map();
+        const saved = ordered.map((input) => {
+            const entry = saveEntry(calendarId, input, now);
+            ids.set(input, entry.id);
+            return entry;
+        });
+        for (const entry of saved)
+            if (entry.kind === "series" && entry.status === "cancelled")
+                cancelOccurrences(entry.id, now);
+        const current = saved.map(({ id }) => entryOf(entryRow(id)));
+        for (const entry of current)
+            link(entry, now);
+        refreshAround(current.map(({ id }) => id), now);
+        return entries.map((input) => entryOf(entryRow(ids.get(input))));
+    };
+    const removeAll = (calendarId, externalIds, now) => {
+        calendarRow(calendarId);
+        const removed = database
+            .prepare(`SELECT * FROM calendar_entries WHERE calendar_id = ? AND external_id IN (SELECT value FROM json_each(?))
+           AND status <> 'cancelled' AND deleted_at IS NULL`)
+            .all(calendarId, JSON.stringify(externalIds));
+        for (const row of removed) {
+            cancel(row, now);
+            database.prepare("UPDATE calendar_entries SET seen_at = ? WHERE id = ?").run(now, Number(row.id));
+            if (row.kind === "series")
+                cancelOccurrences(Number(row.id), now);
+        }
+        refreshAround(removed.map((row) => Number(row.id)), now);
+        return removed.length;
+    };
+    const putCursor = (calendarId, value, now) => {
+        const accountId = Number(calendarRow(calendarId).account_id);
+        if (value === null)
+            database
+                .prepare("DELETE FROM sync_cursors WHERE account_id = ? AND key = ?")
+                .run(accountId, cursorKey(calendarId));
+        else
+            database
+                .prepare(`INSERT INTO sync_cursors (account_id, key, value, created_at, updated_at) VALUES (?, ?, ?, ?, ?)
+           ON CONFLICT (account_id, key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`)
+                .run(accountId, cursorKey(calendarId), value, now, now);
+    };
+    const slotRows = (calendarId, series, window) => database
+        .prepare(`SELECT * FROM calendar_entries WHERE calendar_id = ? AND kind = 'occurrence' AND series_external_id = ?
+           AND original_starts_at >= ? AND original_starts_at < ? AND deleted_at IS NULL ORDER BY original_starts_at`)
+        .all(calendarId, series, window.from, window.to);
     return {
         saveCalendars: async (accountId, calendars, now) => write(database, () => {
             const upsert = database.prepare(`INSERT INTO calendars (account_id, external_id, title, timezone, access_role, primary_calendar, synced, seen_at,
@@ -468,115 +524,72 @@ export const eventStoreOver = (context) => {
                 .prepare("UPDATE calendars SET synced = ?, updated_at = ? WHERE id = ?")
                 .run(flag(synced), now, calendarId);
         }),
-        saveEntries: async (calendarId, entries, now) => write(database, () => {
-            calendarRow(calendarId);
-            // A series first, so an occurrence in the same page finds it.
-            const ordered = [...entries].sort((a, b) => Number(b.kind === "series") - Number(a.kind === "series"));
-            const ids = new Map();
-            const saved = ordered.map((input) => {
-                const entry = saveEntry(calendarId, input, now);
-                ids.set(input, entry.id);
-                return entry;
-            });
-            for (const entry of saved)
-                if (entry.kind === "series" && entry.status === "cancelled")
-                    cancelOccurrences(entry.id, now);
-            const current = saved.map(({ id }) => entryOf(entryRow(id)));
-            for (const entry of current)
-                link(entry, now);
-            refreshAround(current.map(({ id }) => id), now);
-            return entries.map((input) => entryOf(entryRow(ids.get(input))));
-        }),
-        removeEntries: async (calendarId, externalIds, now) => write(database, () => {
-            calendarRow(calendarId);
-            const removed = database
-                .prepare(`SELECT * FROM calendar_entries WHERE calendar_id = ? AND external_id IN (SELECT value FROM json_each(?))
-               AND status <> 'cancelled' AND deleted_at IS NULL`)
-                .all(calendarId, JSON.stringify(externalIds));
-            for (const row of removed) {
-                cancel(row, now);
-                database.prepare("UPDATE calendar_entries SET seen_at = ? WHERE id = ?").run(now, Number(row.id));
-                if (row.kind === "series")
-                    cancelOccurrences(Number(row.id), now);
-            }
-            refreshAround(removed.map((row) => Number(row.id)), now);
-            return removed.length;
-        }),
+        saveEntries: async (calendarId, entries, now) => write(database, () => saveAll(calendarId, entries, now)),
+        removeEntries: async (calendarId, externalIds, now) => write(database, () => removeAll(calendarId, externalIds, now)),
         markUnseen: async (calendarId, seenBefore, window, now) => write(database, () => {
             const marked = database
-                .prepare(`UPDATE calendar_entries SET deleted_at = ?, updated_at = ? WHERE calendar_id = ? AND deleted_at IS NULL
-               AND (seen_at IS NULL OR seen_at < ?)
-               AND (kind <> 'occurrence' OR exception = 1 OR (original_starts_at >= ? AND original_starts_at < ?))
-             RETURNING event_id`)
-                .all(now, now, calendarId, seenBefore, window.from, window.to);
+                .prepare(`SELECT * FROM calendar_entries WHERE calendar_id = ? AND deleted_at IS NULL AND (seen_at IS NULL OR seen_at < ?)
+               AND min(coalesce(starts_at, original_starts_at), coalesce(original_starts_at, starts_at)) < ? AND (kind = 'series'
+                 OR max(coalesce(ends_at, 0), coalesce(starts_at, 0) + 1, coalesce(original_starts_at, 0)) >= ?)`)
+                .all(calendarId, seenBefore, window.to, window.from)
+                .filter((row) => entryInWindow(entryOf(row), window));
+            const mark = database.prepare("UPDATE calendar_entries SET deleted_at = ?, updated_at = ? WHERE id = ?");
+            for (const row of marked)
+                mark.run(now, now, Number(row.id));
             for (const eventId of new Set(marked.map((row) => int(row.event_id))))
                 if (eventId !== null)
                     refreshEvent(eventId, now);
             return marked.length;
         }),
+        restoreUnseen: async (calendarId, windowAt, now) => write(database, () => {
+            const restored = database
+                .prepare("SELECT * FROM calendar_entries WHERE calendar_id = ? AND deleted_at IS NOT NULL")
+                .all(calendarId)
+                .map(entryOf)
+                .filter((entry) => !entryInWindow(entry, windowAt(entry.deletedAt)));
+            const restore = database.prepare("UPDATE calendar_entries SET deleted_at = NULL, updated_at = ? WHERE id = ?");
+            for (const { id } of restored)
+                restore.run(now, id);
+            refreshAround(restored.map(({ id }) => id), now);
+            return restored.length;
+        }),
         entry: async (calendarId, externalId) => read(database, () => {
             const row = database
                 .prepare("SELECT * FROM calendar_entries WHERE calendar_id = ? AND external_id = ?")
                 .get(calendarId, externalId);
             return row ? entryOf(row) : null;
         }),
+        slotsOf: async (calendarId, seriesExternalId, window) => read(database, () => slotRows(calendarId, seriesExternalId, window).map(entryOf)),
+        saveSlots: async (calendarId, groups, window, cursor, now) => write(database, () => {
+            let [saved, removed] = [0, 0];
+            const seen = database.prepare("UPDATE calendar_entries SET seen_at = ? WHERE id = ?");
+            for (const { series, slots } of groups) {
+                const held = slotRows(calendarId, series, window);
+                if (slots === null) {
+                    for (const row of held)
+                        seen.run(now, Number(row.id));
+                    continue;
+                }
+                if (slots.length)
+                    saved += saveAll(calendarId, slots, now).length;
+                const given = new Set(slots.map(({ externalId }) => externalId));
+                const stale = held
+                    .filter((row) => Number(row.exception) !== 1 && row.status !== "cancelled" && !given.has(String(row.external_id)))
+                    .map((row) => String(row.external_id));
+                if (stale.length)
+                    removed += removeAll(calendarId, stale, now);
+            }
+            putCursor(calendarId, cursor, now);
+            return { saved, removed };
+        }),
         cursor: async (calendarId) => read(database, () => {
             const { account_id } = calendarRow(calendarId);
             return str(database
                 .prepare("SELECT value FROM sync_cursors WHERE account_id = ? AND key = ?")
                 .get(Number(account_id), cursorKey(calendarId))?.value);
         }),
-        setCursor: async (calendarId, value, now) => write(database, () => {
-            const accountId = Number(calendarRow(calendarId).account_id);
-            if (value === null)
-                database
-                    .prepare("DELETE FROM sync_cursors WHERE account_id = ? AND key = ?")
-                    .run(accountId, cursorKey(calendarId));
-            else
-                database
-                    .prepare(`INSERT INTO sync_cursors (account_id, key, value, created_at, updated_at) VALUES (?, ?, ?, ?, ?)
-               ON CONFLICT (account_id, key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`)
-                    .run(accountId, cursorKey(calendarId), value, now, now);
-        }),
-        events: async (filter = {}) => {
-            const clauses = ["e.deleted_at IS NULL"];
-            const params = [];
-            const entries = (extra) => `EXISTS (SELECT 1 FROM calendar_entries ce JOIN calendars c ON c.id = ce.calendar_id WHERE ce.event_id = e.id AND ${extra})`;
-            const dated = (column, date, instant, at) => {
-                if (at === undefined)
-                    return;
-                if (date === undefined) {
-                    clauses.push(instant);
-                    params.push(at);
-                    return;
-                }
-                clauses.push(`(CASE WHEN e.all_day = 1 THEN EXISTS (SELECT 1 FROM calendar_entries ce WHERE ce.event_id = e.id AND ce.${column}) ELSE ${instant} END)`);
-                params.push(date, at);
-            };
-            dated("end_date > ?", filter.fromDate, "coalesce(e.ends_at, e.starts_at + 1) > ?", filter.from);
-            dated("start_date < ?", filter.toDate, "e.starts_at < ?", filter.to);
-            if (filter.calendarId !== undefined) {
-                clauses.push(entries("ce.calendar_id = ?"));
-                params.push(filter.calendarId);
-            }
-            if (filter.accountId !== undefined) {
-                clauses.push(entries("c.account_id = ?"));
-                params.push(filter.accountId);
-            }
-            if (filter.personId !== undefined) {
-                clauses.push(entries("EXISTS (SELECT 1 FROM calendar_entry_participants p JOIN identity_links il ON il.identity_id = p.identity_id " +
-                    "WHERE p.entry_id = ce.id AND il.person_id = ?)"));
-                params.push(filter.personId);
-            }
-            const limit = filter.limit ?? 100;
-            const offset = filter.offset ?? 0;
-            if (!Number.isInteger(limit) || limit < 1 || limit > 1000 || !Number.isInteger(offset) || offset < 0)
-                throw new CliError("validation_error", "limit takes 1–1000 and offset 0 or more");
-            return database
-                .prepare(`SELECT e.* FROM events e WHERE ${clauses.join(" AND ")} ORDER BY ${filter.newest ? "e.starts_at DESC, e.id DESC" : "e.starts_at, e.id"} LIMIT ? OFFSET ?`)
-                .all(...params, limit, offset)
-                .map(eventOf);
-        },
+        setCursor: async (calendarId, value, now) => write(database, () => putCursor(calendarId, value, now)),
+        events: async (filter = {}) => listEvents(database, filter),
         event: async (id) => read(database, () => {
             const row = database.prepare("SELECT * FROM events WHERE id = ?").get(id);
             if (!row)
@@ -605,6 +618,25 @@ export const eventStoreOver = (context) => {
                     .map(attachmentOf),
             };
         }),
+        historyOf: async (eventIds, calendarIds, since) => read(database, () => {
+            const entries = database
+                .prepare(`SELECT * FROM calendar_entries WHERE event_id IN (SELECT value FROM json_each(?))
+               AND calendar_id IN (SELECT value FROM json_each(?)) ORDER BY id`)
+                .all(JSON.stringify(eventIds), JSON.stringify(calendarIds))
+                .map(entryOf);
+            const revisions = database
+                .prepare(`SELECT * FROM calendar_entry_revisions WHERE entry_id IN (SELECT value FROM json_each(?)) AND created_at >= ?
+              ORDER BY created_at, id`)
+                .all(JSON.stringify(entries.map(({ id }) => id)), since)
+                .map(revisionOf);
+            return { entries, revisions };
+        }),
+        participantsOf: async (eventIds, calendarIds) => read(database, () => database
+            .prepare(`SELECT p.*, ce.event_id FROM calendar_entry_participants p JOIN calendar_entries ce ON ce.id = p.entry_id
+              WHERE ce.event_id IN (SELECT value FROM json_each(?)) AND ce.calendar_id IN (SELECT value FROM json_each(?))
+              ORDER BY ce.event_id, p.entry_id, p.email`)
+            .all(JSON.stringify(eventIds), JSON.stringify(calendarIds))
+            .map((row) => ({ ...participantOf(row), eventId: Number(row.event_id) }))),
         linkEntry: async (entryId, eventId, now) => write(database, () => {
             const row = database.prepare("SELECT * FROM calendar_entries WHERE id = ?").get(entryId);
             if (!row)
@@ -636,11 +668,11 @@ export const eventStoreOver = (context) => {
             });
         }),
         reviews: async (filter = {}) => database
-            .prepare(`SELECT * FROM link_reviews${filter.status ? " WHERE status = ?" : ""} ORDER BY created_at, id`)
+            .prepare(`${REVIEWS}${filter.status ? " WHERE r.status = ?" : ""} ORDER BY r.created_at, r.id`)
             .all(...(filter.status ? [filter.status] : []))
             .map(reviewOf),
         resolveReview: async (id, decision, now) => write(database, () => {
-            const row = database.prepare("SELECT * FROM link_reviews WHERE id = ?").get(id);
+            const row = database.prepare(`${REVIEWS} WHERE r.id = ?`).get(id);
             if (!row)
                 throw new CliError("not_found", `no review ${id} in the local store`);
             const review = reviewOf(row);
@@ -710,7 +742,7 @@ export const eventStoreOver = (context) => {
             database
                 .prepare("UPDATE link_reviews SET status = ?, chosen_id = ?, decided_by = 'owner', decided_at = ?, updated_at = ? WHERE id = ?")
                 .run(chosen === null ? "apart" : "linked", chosen, now, now, id);
-            return reviewOf(database.prepare("SELECT * FROM link_reviews WHERE id = ?").get(id));
+            return reviewOf(database.prepare(`${REVIEWS} WHERE r.id = ?`).get(id));
         }),
     };
 };

package/dist/store/sqlite/email-locations.d.ts

@@ -0,0 +1,24 @@
+import type { CacheDatabase } from "../driver.js";
+/** Where an IMAP server holds an email: `folder` is the mailbox's external id. */
+export interface EmailLocationInput {
+    folder: string;
+    uidvalidity: string;
+    uid: number;
+}
+/** One email of a folder as a sync sees it there. */
+export interface FolderEmail {
+    uid: number;
+    externalId: string;
+    receivedAt: number | null;
+    read: boolean | null;
+    flagged: boolean | null;
+    /** Its locations in every folder, and the folders it is a member of: an email is gone only when all are lost. */
+    locations: number;
+    folders: number;
+}
+export declare const locate: (database: CacheDatabase, accountId: number, emailId: number, where: EmailLocationInput) => {
+    changes: number;
+};
+export declare const folderEmails: (database: CacheDatabase, accountId: number, folder: string, uidvalidity: string) => FolderEmail[];
+export declare const setLocations: (database: CacheDatabase, accountId: number, folder: string, uidvalidity: string, found: ReadonlyMap<string, number[]>) => number;
+export declare const forgetLocations: (database: CacheDatabase, accountId: number, folder: string, uidvalidity: string, uids: number[]) => void;

package/dist/store/sqlite/email-locations.js

@@ -0,0 +1,56 @@
+export const locate = (database, accountId, emailId, where) => database
+    .prepare(`INSERT OR REPLACE INTO email_locations (mailbox_id, uidvalidity, uid, email_id)
+         SELECT id, ?, ?, ? FROM mailboxes WHERE account_id = ? AND external_id = ?`)
+    .run(where.uidvalidity, where.uid, emailId, accountId, where.folder);
+export const folderEmails = (database, accountId, folder, uidvalidity) => database
+    .prepare(`SELECT l.uid, e.external_id, coalesce(e.received_at, e.sent_at) AS at, e.read, e.flagged,
+         (SELECT count(*) FROM email_locations x WHERE x.email_id = e.id) AS locations,
+         (SELECT count(*) FROM email_mailboxes m JOIN mailboxes b ON b.id = m.mailbox_id
+           WHERE m.email_id = e.id AND b.kind IS NULL) AS folders
+       FROM email_locations l JOIN emails e ON e.id = l.email_id
+       WHERE l.mailbox_id = (SELECT id FROM mailboxes WHERE account_id = ? AND external_id = ?)
+         AND l.uidvalidity = ? AND e.deleted_at IS NULL
+       ORDER BY l.uid`)
+    .all(accountId, folder, uidvalidity)
+    .map((row) => ({
+    uid: Number(row.uid),
+    externalId: String(row.external_id),
+    receivedAt: row.at === null ? null : Number(row.at),
+    read: row.read === null ? null : Boolean(row.read),
+    flagged: row.flagged === null ? null : Boolean(row.flagged),
+    locations: Number(row.locations),
+    folders: Number(row.folders),
+}));
+export const setLocations = (database, accountId, folder, uidvalidity, found) => {
+    database
+        .prepare(`DELETE FROM email_locations WHERE uidvalidity <> ?
+         AND mailbox_id = (SELECT id FROM mailboxes WHERE account_id = ? AND external_id = ?)`)
+        .run(uidvalidity, accountId, folder);
+    const lookup = database.prepare("SELECT id FROM emails WHERE account_id = ? AND external_id = ?");
+    let count = 0;
+    for (const [externalId, uids] of found) {
+        const row = lookup.get(accountId, externalId);
+        if (!row)
+            continue;
+        for (const uid of uids)
+            locate(database, accountId, Number(row.id), { folder, uidvalidity, uid });
+        count++;
+    }
+    return count;
+};
+export const forgetLocations = (database, accountId, folder, uidvalidity, uids) => {
+    const box = database
+        .prepare("SELECT id FROM mailboxes WHERE account_id = ? AND external_id = ?")
+        .get(accountId, folder);
+    if (!box)
+        return;
+    const emails = database
+        .prepare(`DELETE FROM email_locations WHERE mailbox_id = ? AND uidvalidity = ?
+         AND uid IN (SELECT value FROM json_each(?)) RETURNING email_id`)
+        .all(Number(box.id), uidvalidity, JSON.stringify(uids))
+        .map((row) => Number(row.email_id));
+    const leave = database.prepare(`DELETE FROM email_mailboxes WHERE email_id = ? AND mailbox_id = ?
+       AND NOT EXISTS (SELECT 1 FROM email_locations WHERE email_id = ? AND mailbox_id = ?)`);
+    for (const emailId of new Set(emails))
+        leave.run(emailId, Number(box.id), emailId, Number(box.id));
+};

package/dist/store/sqlite/email-state.d.ts

@@ -6,3 +6,5 @@ export declare const setEmailFlags: (database: CacheDatabase, accountId: number,
     read?: boolean;
     flagged?: boolean;
 }>, now: number) => number;
+export declare const markEmailsDeleted: (database: CacheDatabase, accountId: number, externalIds: string[], now: number) => number;
+export declare const markEmailsRestored: (database: CacheDatabase, accountId: number, externalIds: string[], now: number) => number;

package/dist/store/sqlite/email-state.js

@@ -1,4 +1,6 @@
+import { dropAttachmentChunks } from "./email-index.js";
 import { flag } from "./events.js";
+import { dropUnusedVectors } from "./vector-index.js";
 export const recountEmailThread = (database, threadId, now) => database
     .prepare(`UPDATE email_threads SET
          emails_count = (SELECT count(*) FROM emails WHERE email_thread_id = ? AND deleted_at IS NULL),
@@ -23,3 +25,29 @@ export const setEmailFlags = (database, accountId, flags, now) => {
     }
     return changed;
 };
+export const markEmailsDeleted = (database, accountId, externalIds, now) => {
+    const mark = database.prepare(`UPDATE emails SET deleted_at = ?, body_text = NULL, body_html = NULL, snippet = NULL, updated_at = ?
+       WHERE account_id = ? AND external_id = ? AND deleted_at IS NULL
+       RETURNING id, email_thread_id`);
+    const forget = database.prepare("UPDATE attachments SET text = NULL, normalized_text = NULL WHERE attachable_type = 'email' AND attachable_id = ?");
+    const unlocate = database.prepare("DELETE FROM email_locations WHERE email_id = ?");
+    const threads = externalIds.flatMap((id) => mark.all(now, now, accountId, id).map((r) => {
+        const pieces = dropAttachmentChunks(database, Number(r.id));
+        forget.run(Number(r.id));
+        unlocate.run(Number(r.id));
+        dropUnusedVectors(database, pieces);
+        return Number(r.email_thread_id);
+    }));
+    for (const id of new Set(threads))
+        recountEmailThread(database, id, now);
+    return threads.length;
+};
+export const markEmailsRestored = (database, accountId, externalIds, now) => {
+    const unmark = database.prepare(`UPDATE emails SET deleted_at = NULL, updated_at = ?
+       WHERE account_id = ? AND external_id = ? AND deleted_at IS NOT NULL
+       RETURNING email_thread_id`);
+    const threads = externalIds.flatMap((id) => unmark.all(now, accountId, id).map((r) => Number(r.email_thread_id)));
+    for (const id of new Set(threads))
+        recountEmailThread(database, id, now);
+    return threads.length;
+};

package/dist/store/sqlite/emails.d.ts

@@ -3,9 +3,11 @@ import type { Attachment, Metadata } from "../../meetings/index.js";
 import type { Stemmer, Stemmers } from "../../search/stem.js";
 import type { CacheDatabase } from "../driver.js";
 import type { ConversationSummary, StoredHit } from "../types.js";
+import { type EmailLocationInput, type FolderEmail } from "./email-locations.js";
 import { type MailRulesStore } from "./mail-rules.js";
 import { type AttachmentInput } from "./meetings.js";
 import type { StoreContext } from "./open.js";
+export type { EmailLocationInput, FolderEmail };
 export interface EmailAddress {
     address: string;
     name: string | null;
@@ -43,6 +45,8 @@ export interface EmailInput {
     mailRuleId?: number | null;
     /** Added to the mailboxes the email is already in; one scan sees one folder, so none is taken away. */
     mailboxes?: MailboxInput[];
+    /** Added to the locations the email has; a UID already known in that folder now points here. */
+    locations?: EmailLocationInput[];
     /** Replaced when given; the text is word-indexed. */
     attachments?: AttachmentInput[];
 }
@@ -228,6 +232,15 @@ export interface MailStore {
         read?: boolean;
         flagged?: boolean;
     }>, now: number): Promise<number>;
+    /** The live emails whose location in `folder` has this UIDVALIDITY, oldest UID first. */
+    folderEmails(accountId: number, folder: string, uidvalidity: string): Promise<FolderEmail[]>;
+    /**
+     * Records where emails the store holds are in `folder`, by Message-ID; one it does not hold is left out. Locations
+     * of the folder under another UIDVALIDITY are dropped: its UIDs mean nothing now.
+     */
+    setLocations(accountId: number, folder: string, uidvalidity: string, found: ReadonlyMap<string, number[]>): Promise<number>;
+    /** Forgets that these UIDs of `folder` hold anything; an email left with no location there leaves the folder too. */
+    forgetLocations(accountId: number, folder: string, uidvalidity: string, uids: number[]): Promise<void>;
     /** Marks emails gone at the source and drops their text; saving one again brings it back. Answers how many changed. */
     markDeleted(accountId: number, externalIds: string[], now: number): Promise<number>;
     /**

package/dist/store/sqlite/emails.js

@@ -2,7 +2,8 @@ import { formatLocator } from "../../domain/locator.js";
 import { formatReference } from "../../domain/references.js";
 import { fold, normalize } from "../normalize.js";
 import { chunkAttachments, drainEmailIndex, dropAttachmentChunks, MAIL_PIECES, queueThreads, threadPieces, titleOf, } from "./email-index.js";
-import { recountEmailThread as recount, setEmailFlags } from "./email-state.js";
+import { folderEmails, forgetLocations, locate, setLocations, } from "./email-locations.js";
+import { markEmailsDeleted, markEmailsRestored, recountEmailThread as recount, setEmailFlags } from "./email-state.js";
 import { bool, flag, fromJson, int, page, str, toJson } from "./events.js";
 import { folded } from "./folded.js";
 import { ensurePerson } from "./identities.js";
@@ -228,6 +229,8 @@ const saveEmail = (database, orm, accountId, threadId, mail, now) => {
     }
     for (const box of mail.mailboxes ?? [])
         join(database, emailId, mailboxPk(database, accountId, box, now), now);
+    for (const where of mail.locations ?? [])
+        locate(database, accountId, emailId, where);
     if (mail.attachments !== undefined) {
         const before = dropAttachmentChunks(database, emailId);
         const positions = mail.attachments.map(({ position }) => position);
@@ -545,34 +548,11 @@ export const mailStoreOver = ({ database, orm }, stemmerFor = stemmerCache()) =>
             return setEmailFlags(database, accountId, flags, now);
         });
     },
-    async markDeleted(accountId, externalIds, now) {
-        return write(database, () => {
-            const mark = database.prepare(`UPDATE emails SET deleted_at = ?, body_text = NULL, body_html = NULL, snippet = NULL, updated_at = ?
-           WHERE account_id = ? AND external_id = ? AND deleted_at IS NULL
-           RETURNING id, email_thread_id`);
-            const forget = database.prepare("UPDATE attachments SET text = NULL, normalized_text = NULL WHERE attachable_type = 'email' AND attachable_id = ?");
-            const threads = externalIds.flatMap((id) => mark.all(now, now, accountId, id).map((r) => {
-                const pieces = dropAttachmentChunks(database, Number(r.id));
-                forget.run(Number(r.id));
-                dropUnusedVectors(database, pieces);
-                return Number(r.email_thread_id);
-            }));
-            for (const id of new Set(threads))
-                recount(database, id, now);
-            return threads.length;
-        });
-    },
-    async markRestored(accountId, externalIds, now) {
-        return write(database, () => {
-            const unmark = database.prepare(`UPDATE emails SET deleted_at = NULL, updated_at = ?
-           WHERE account_id = ? AND external_id = ? AND deleted_at IS NOT NULL
-           RETURNING email_thread_id`);
-            const threads = externalIds.flatMap((id) => unmark.all(now, accountId, id).map((r) => Number(r.email_thread_id)));
-            for (const id of new Set(threads))
-                recount(database, id, now);
-            return threads.length;
-        });
-    },
+    folderEmails: async (accountId, folder, uidvalidity) => folderEmails(database, accountId, folder, uidvalidity),
+    setLocations: async (accountId, folder, uidvalidity, found) => write(database, () => setLocations(database, accountId, folder, uidvalidity, found)),
+    forgetLocations: async (accountId, folder, uidvalidity, uids) => write(database, () => forgetLocations(database, accountId, folder, uidvalidity, uids)),
+    markDeleted: async (accountId, externalIds, now) => write(database, () => markEmailsDeleted(database, accountId, externalIds, now)),
+    markRestored: async (accountId, externalIds, now) => write(database, () => markEmailsRestored(database, accountId, externalIds, now)),
     async chunksToEmbed(model, { after, limit }) {
         drainEmailIndex(database, stemmerFor);
         const file = database.prepare("SELECT text FROM attachments WHERE id = ?");

package/dist/store/sqlite/manifest.js

@@ -52,6 +52,7 @@ export const MANIFEST = [
     { name: "20261029181000_version-37-contact-mention-triggers", version: 37, minCompatible: 34 },
     { name: "20261029224106_version-38-folded-names", version: 38, minCompatible: 34 },
     { name: "20261029224107_version-38-folded-triggers", version: 38, minCompatible: 34 },
+    { name: "20261030114008_version-39-email-locations", version: 39, minCompatible: 34 },
 ];
 export const generatedMigrations = (manifest = MANIFEST, generated = GENERATED) => {
     const migrations = [];

package/dist/store/sqlite/migrations.generated.js

@@ -830,5 +830,12 @@ export const GENERATED = [
             "CREATE TRIGGER email_threads_subject_folded_au AFTER UPDATE OF subject ON email_threads\n  WHEN new.subject IS NOT old.subject AND new.subject_folded IS old.subject_folded BEGIN\n  UPDATE email_threads SET subject_folded = NULL WHERE id = new.id;\nEND;",
             "CREATE TRIGGER mailboxes_name_folded_au AFTER UPDATE OF name ON mailboxes\n  WHEN new.name IS NOT old.name AND new.name_folded IS old.name_folded BEGIN\n  UPDATE mailboxes SET name_folded = NULL WHERE id = new.id;\nEND;"
         ]
+    },
+    {
+        "name": "20261030114008_version-39-email-locations",
+        "statements": [
+            "CREATE TABLE `email_locations` (\n\t`mailbox_id` integer NOT NULL,\n\t`uidvalidity` text NOT NULL,\n\t`uid` integer NOT NULL,\n\t`email_id` integer NOT NULL,\n\tCONSTRAINT `email_locations_pk` PRIMARY KEY(`mailbox_id`, `uidvalidity`, `uid`),\n\tCONSTRAINT `fk_email_locations_mailbox_id_mailboxes_id_fk` FOREIGN KEY (`mailbox_id`) REFERENCES `mailboxes`(`id`),\n\tCONSTRAINT `fk_email_locations_email_id_emails_id_fk` FOREIGN KEY (`email_id`) REFERENCES `emails`(`id`)\n);",
+            "CREATE INDEX `email_locations_by_email_id` ON `email_locations` (`email_id`);"
+        ]
     }
 ];

package/dist/store/sqlite/schema.d.ts

@@ -6172,6 +6172,78 @@ export declare const emailMailboxes: import("drizzle-orm/sqlite-core").SQLiteTab
     dialect: 'sqlite';
     isAlias: false;
 }>;
+export declare const emailLocations: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "email_locations";
+    schema: undefined;
+    columns: {
+        mailboxId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "email_locations";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        uidvalidity: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "email_locations";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        uid: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "email_locations";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        emailId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "email_locations";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: 'sqlite';
+    isAlias: false;
+}>;
 export declare const emailIndexPending: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
     name: "email_index_pending";
     schema: undefined;

package/dist/store/sqlite/schema.js

@@ -695,6 +695,19 @@ export const emailMailboxes = sqliteTable("email_mailboxes", {
     primaryKey({ columns: [table.emailId, table.mailboxId] }),
     index("email_mailboxes_by_mailbox_id").on(table.mailboxId),
 ]);
+export const emailLocations = sqliteTable("email_locations", {
+    mailboxId: integer("mailbox_id")
+        .notNull()
+        .references(() => mailboxes.id),
+    uidvalidity: text("uidvalidity").notNull(),
+    uid: integer("uid").notNull(),
+    emailId: integer("email_id")
+        .notNull()
+        .references(() => emails.id),
+}, (table) => [
+    primaryKey({ columns: [table.mailboxId, table.uidvalidity, table.uid] }),
+    index("email_locations_by_email_id").on(table.emailId),
+]);
 export const emailIndexPending = sqliteTable("email_index_pending", {
     id: integer("id").notNull(),
     indexableType: text("indexable_type").notNull(),