@wirecat/cli-core 0.486.0 → 0.487.0

package/CHANGELOG.md

@@ -7,6 +7,21 @@ shape of this file.
 
 ## Unreleased
 
+## 0.487.0 — 30.10.2026
+
+### Added
+
+- **A messenger can say what `reactions list` covers.** The new `reactionsListScope` option on the messenger (for
+  WhatsApp, "reactions received while this computer was syncing") adds `missing: [{ field: "reactions", why }]` to the
+  JSON answer and one line on stderr for a person: "shows only …". A messenger that sets none answers as before.
+- **Mail from a server with no cheap message id (Yandex) syncs from a listing of UID, flags, date and size.** A header
+  FETCH of 200 messages took 5 to 40 s there and often failed, so six months took hours. A `MailSource` can now answer
+  `quick: true` from `search` and give `quick` and `identify`; `syncMail` then lists only the UIDs not done, reads the
+  raw bytes of the new ones and takes the id from the Message-ID, so stored mail keeps its id and nothing stored is read
+  again. Rules and the bulk class run on the downloaded headers. A new UIDVALIDITY, other rules or `rescan` list the
+  folder with headers as before; a quick run proves no deletion and refreshes no flags of the mail it skips.
+  `mailSourceContract` checks that `quick` and `identify` agree with `list`; `fakeMailSource` takes `quick: true`.
+
 ## 0.486.0 — 30.10.2026
 
 ### Fixed

package/dist/cli/messenger/context.d.ts

@@ -84,6 +84,8 @@ export interface Messenger extends ServiceMessenger {
     pollCloseSeconds?: readonly [min: number, max: number];
     /** Whether `reactions list` shows who reacted to a message; no when unset. */
     reactionsList?: boolean;
+    /** What `reactions list` covers when it is less than everyone who reacted, as the end of "shows only …", such as "reactions received while this computer was syncing"; none when unset. */
+    reactionsListScope?: string;
     /** Whether `polls voters` lists who voted for what; no when unset. */
     pollVoters?: boolean;
     /** Whether a poll can be closed — `polls close`; yes when unset. WhatsApp's stay open. */

package/dist/cli/messenger/reactions-command.js

@@ -33,6 +33,7 @@ export const reactionsCommand = (messenger) => {
                     ...(cursor === undefined ? {} : { cursor }),
                 });
             });
+            const why = messenger.reactionsListScope === undefined ? undefined : `shows only ${messenger.reactionsListScope}`;
             renderAnswer(this, context, listOf("reactions list", {
                 items: found.items.map(reactorAnswer),
                 limit,
@@ -40,7 +41,10 @@ export const reactionsCommand = (messenger) => {
                 paging: "cursor",
                 ...(found.cursor === undefined ? {} : { cursor: found.cursor }),
                 args: { chat, message, ...(words.length > 0 ? { query: words.join(" ") } : {}) },
+                ...(why === undefined ? {} : { missing: [{ field: "reactions", why }] }),
             }), lines(({ reacted_at, person, reaction: name }) => [reacted_at, person.name ?? person.id, name].join("  ")));
+            if (why !== undefined && context.format !== "json")
+                context.renderer.note(why);
         }));
     annotate(reactions.command("add"), {
         effects: REMOTE_WRITE,

package/dist/cli/messenger/serve-relay.d.ts

@@ -45,6 +45,7 @@ export declare const serveRelay: (command: Command, messenger: Messenger) => {
         pollQuiz?: boolean;
         pollCloseSeconds?: readonly [min: number, max: number];
         reactionsList?: boolean;
+        reactionsListScope?: string;
         pollVoters?: boolean;
         pollClose?: boolean;
         pollRevote?: boolean;

package/dist/mail/headers.d.ts

@@ -36,6 +36,8 @@ export declare const authOf: (unfolded: string) => AuthVerdicts | undefined;
 export declare const addressesOf: (value: string | undefined) => string[];
 /** The header fields of one email, from its header text. */
 export declare const headersOf: (text: string) => MailHeaders;
+/** The header fields of a whole email, as `headersOf` reads them from a listing. */
+export declare const headersOfRaw: (raw: Uint8Array) => MailHeaders;
 /**
  * List-Id, the bulk-mail fields, Reply-To and Gmail's SPF, DKIM and DMARC verdicts of a whole email, kept on mail
  * stored in full so a rule or a sender score can be worked out from the store later. Names are lower case.

package/dist/mail/headers.js

@@ -66,15 +66,19 @@ export const headersOf = (text) => {
         ...(/^\s*multipart\/mixed\b/i.test(field(unfolded, "Content-Type") ?? "") ? { attachments: true } : {}),
     };
 };
+const headTextOf = (raw) => {
+    const bytes = Buffer.from(raw.buffer, raw.byteOffset, raw.byteLength);
+    const end = [bytes.indexOf("\r\n\r\n"), bytes.indexOf("\n\n")].filter((at) => at !== -1);
+    return bytes.subarray(0, end.length ? Math.min(...end) : Math.min(bytes.length, 256 * 1024)).toString("utf8");
+};
+/** The header fields of a whole email, as `headersOf` reads them from a listing. */
+export const headersOfRaw = (raw) => headersOf(headTextOf(raw));
 /**
  * List-Id, the bulk-mail fields, Reply-To and Gmail's SPF, DKIM and DMARC verdicts of a whole email, kept on mail
  * stored in full so a rule or a sender score can be worked out from the store later. Names are lower case.
  */
 export const mailHeadersOf = (raw) => {
-    const bytes = Buffer.from(raw.buffer, raw.byteOffset, raw.byteLength);
-    const end = [bytes.indexOf("\r\n\r\n"), bytes.indexOf("\n\n")].filter((at) => at !== -1);
-    const head = bytes.subarray(0, end.length ? Math.min(...end) : Math.min(bytes.length, 256 * 1024));
-    const unfolded = unfold(head.toString("utf8"));
+    const unfolded = unfold(headTextOf(raw));
     const listId = listIdOf(field(unfolded, "List-Id"));
     const precedence = field(unfolded, "Precedence")?.trim().toLowerCase();
     const [replyTo] = addressesOf(field(unfolded, "Reply-To"));

package/dist/mail/index.d.ts

@@ -12,6 +12,6 @@ export { mapProposedTags, ruleTagger, settleRuleTags, type TagOutcome } from "./
 export { conditionKeys, decide, describeMatch, ENVELOPE, envelopeBox, envelopeBoxOf, type MailAction, type MailFacts, type MailRule, type MailRuleMatch, matches, sameMatch, tagsOf, } from "./rules.js";
 export { type DomainAge, FRAUD_SIGNALS, FREE_MAIL, registrableOf, SCORE_RULE, type Scored, type Signal, scoreGroup, WEIGHTS, } from "./score.js";
 export { DEMOTE_AT, type DomainAges, demotedSenders, type LookupResult, SCORE_VERSION, scoreSenders, } from "./sender-scores.js";
-export type { Listed, MailSource, Searched } from "./source.js";
+export type { Listed, MailSource, Quick, Searched } from "./source.js";
 export { listedOf, type StoredMail } from "./stored.js";
 export { MAX_ATTACHMENT_CHARS, type MailAccount, type MailIndexed, type MailSyncOptions, type MailSyncResult, RETRYABLE_ATTACHMENTS, syncMail, } from "./sync.js";

package/dist/mail/quick.d.ts

@@ -0,0 +1,39 @@
+import type { BudgetStop, RunBudget } from "../background/budget.js";
+import { type Ranges } from "./resume.js";
+import type { Listed, MailSource, Quick, Searched } from "./source.js";
+export declare const FETCH_SLICE = 50;
+export declare const keyOf: (folder: string, uid: string) => string;
+/** What a budgeted run carries from round to round that a quick folder also reads and writes. */
+export interface QuickPlan {
+    budget: RunBudget;
+    /** UIDs a round already asked for, `folder\0uid`. */
+    tried: Set<string>;
+    /** Messages the source could not give; asked for once more when the pass is over. */
+    failed: Set<string>;
+    unlisted: Set<string>;
+    /** Only these are asked for: the retry pass. */
+    only?: Set<string>;
+    /** Each quick folder's listing of what was not done, made once; a round takes the next newest of it. */
+    quick: Map<string, Quick[]>;
+    stopped: BudgetStop | null;
+    remaining: number;
+    asked: number;
+}
+export interface QuickRead {
+    /** Messages read and identified, with their raw bytes so the save does not read them again. */
+    read: {
+        item: Listed;
+        raw: Uint8Array;
+    }[];
+    unreadable: {
+        message: string;
+        reason: string;
+    }[];
+    /** Mail of the folder is left for a later round or run. */
+    capped: boolean;
+}
+/**
+ * One round of a folder whose server gives no cheap message id: UID, flags, date and size of what is not done, then
+ * the raw bytes of the newest of it, whose Message-ID gives the id the full listing would have given.
+ */
+export declare const readQuick: (source: MailSource & Required<Pick<MailSource, "quick" | "identify">>, since: Date, folder: string, searched: Searched, done: Ranges, max: number, plan: QuickPlan | undefined) => Promise<QuickRead>;

package/dist/mail/quick.js

@@ -0,0 +1,73 @@
+import { headersOfRaw } from "./headers.js";
+import { within } from "./resume.js";
+export const FETCH_SLICE = 50;
+export const keyOf = (folder, uid) => `${folder}\0${uid}`;
+/**
+ * One round of a folder whose server gives no cheap message id: UID, flags, date and size of what is not done, then
+ * the raw bytes of the newest of it, whose Message-ID gives the id the full listing would have given.
+ */
+export const readQuick = async (source, since, folder, searched, done, max, plan) => {
+    const answer = { read: [], unreadable: [], capped: false };
+    let items = plan?.quick.get(folder);
+    if (items === undefined) {
+        const asked = searched.uids.filter((uid) => !within(done, Number(uid)) && (plan?.only === undefined || plan.only.has(keyOf(folder, uid))));
+        if (asked.length > 0 && plan) {
+            const stop = plan.budget.take();
+            if (stop) {
+                plan.stopped = stop;
+                plan.remaining += asked.length;
+                return { ...answer, capped: true };
+            }
+        }
+        items = asked.length === 0 ? [] : await source.quick(since, folder, { searched: { ...searched, uids: asked } });
+        if (plan !== undefined) {
+            plan.quick.set(folder, items);
+            const got = new Set(items.map(({ uid }) => uid));
+            for (const uid of asked)
+                if (!got.has(uid)) {
+                    plan.failed.add(keyOf(folder, uid));
+                    plan.unlisted.add(keyOf(folder, uid));
+                }
+        }
+    }
+    const open = items
+        .filter(({ uid }) => !within(done, Number(uid)) && !plan?.tried.has(keyOf(folder, uid)))
+        .sort((a, b) => Number(b.uid) - Number(a.uid));
+    const slice = open.slice(0, plan === undefined ? max : (source.fetchBatch ?? FETCH_SLICE));
+    if (plan !== undefined)
+        plan.remaining += open.length - slice.length;
+    answer.capped = open.length > slice.length;
+    if (slice.length === 0)
+        return answer;
+    if (plan !== undefined) {
+        const stop = plan.budget.take();
+        if (stop) {
+            plan.stopped = stop;
+            plan.remaining += slice.length;
+            return { ...answer, capped: true };
+        }
+        for (const { uid } of slice)
+            plan.tried.add(keyOf(folder, uid));
+        plan.asked += slice.length;
+    }
+    const raws = await source.fetchRaw(slice);
+    // Every email failing is the connection or the login, not the mail: stop instead of trying the rest.
+    if (slice.length > 1 && raws.every((raw) => raw instanceof Error))
+        throw raws[0];
+    for (const [index, item] of slice.entries()) {
+        const raw = raws[index];
+        const key = keyOf(folder, item.uid);
+        if (raw === undefined || raw instanceof Error) {
+            if (plan === undefined)
+                answer.unreadable.push({ message: `uid:${folder}:${item.uid}`, reason: raw?.message ?? "not read" });
+            else {
+                plan.failed.add(key);
+                plan.unlisted.add(key);
+            }
+            continue;
+        }
+        plan?.unlisted.delete(key);
+        answer.read.push({ item: { ...item, ...source.identify(raw, item), headers: headersOfRaw(raw) }, raw });
+    }
+    return answer;
+};

package/dist/mail/source.d.ts

@@ -16,10 +16,17 @@ export interface Listed {
     /** Read only when asked for; absent when not asked or unreadable, so no rule applies to it. */
     headers?: MailHeaders;
 }
+/** A message as `quick` lists it: everything but the ids, which a source without a cheap one reads from the raw bytes. */
+export type Quick = Omit<Listed, "messageId" | "threadId">;
 export interface Searched {
     /** Absent when the server does not say; then no UID is trusted across runs. */
     validity?: string;
     uids: string[];
+    /**
+     * The server gives no message id without reading the message, so `list` is slow. The sync then lists with `quick`
+     * and takes the id from the raw bytes with `identify`.
+     */
+    quick?: boolean;
 }
 /** Everything the import asks of a mail client, so a transport can be replaced without touching the sync. */
 export interface MailSource {
@@ -43,6 +50,18 @@ export interface MailSource {
      * those. Absent for a file, which has no UIDs.
      */
     search?(since: Date, folder: string): Promise<Searched>;
+    /**
+     * For a folder whose `search` said `quick`: UID, flags, date and size of the given UIDs, with no envelope and no
+     * header. A UID the server does not return is left out.
+     */
+    quick?(since: Date, folder: string, options: {
+        searched: Searched;
+    }): Promise<Quick[]>;
+    /** The ids of a message read by `fetchRaw`, worked out as `list` works them out; needed wherever `quick` is. */
+    identify?(raw: Uint8Array, item: Quick): {
+        messageId: string;
+        threadId: string;
+    };
     /** A file's size and modification time, so an unchanged file read to the end is not read again. */
     stamp?(): Promise<FileStamp>;
     /**
@@ -70,5 +89,5 @@ export interface MailSource {
     /** Puts labels back on messages in `folder`, by Gmail id. */
     label?(messageIds: readonly string[], folder: string, labels: readonly string[]): Promise<void>;
     /** Each item's raw RFC 5322 bytes, in order; one that could not be read is an Error, not a failed call. */
-    fetchRaw(items: Listed[]): Promise<(Uint8Array | Error)[]>;
+    fetchRaw(items: Quick[]): Promise<(Uint8Array | Error)[]>;
 }

package/dist/mail/sync.js

@@ -6,6 +6,7 @@ import { GMAIL_ALL_MAIL, mailFolders } from "./folders.js";
 import { dropMissing, tooManyGone } from "./gone.js";
 import { mailHeadersOf } from "./headers.js";
 import { MAX_BODY_CHARS, parseMail } from "./parse.js";
+import { FETCH_SLICE, keyOf, readQuick } from "./quick.js";
 import { FULL_PASS_MS, MBOX_RESUME, mergeRanges, parsePoint, rangesOf, resumeKey, rulesKey, within, } from "./resume.js";
 import { ruleTagger, settleRuleTags } from "./rule-tags.js";
 import { decide, ENVELOPE, envelopeBox, envelopeBoxOf, tagsOf } from "./rules.js";
@@ -54,8 +55,6 @@ const readAttachments = async (mail, messageId, { loadEngine, maxAttachmentChars
     return files;
 };
 const LIST_SLICE = 200;
-const FETCH_SLICE = 50;
-const keyOf = (folder, uid) => `${folder}\0${uid}`;
 export const syncMail = async (source, store, options) => {
     const { budget, index } = options;
     if (budget === undefined || options.retryAttachments || options.account.mode === "mbox")
@@ -68,6 +67,8 @@ export const syncMail = async (source, store, options) => {
         modes: new Map(),
         unreadable: new Map(),
         unlisted: new Set(),
+        quick: new Map(),
+        quickFolders: new Set(),
         stopped: null,
         remaining: 0,
         asked: 0,
@@ -100,6 +101,7 @@ export const syncMail = async (source, store, options) => {
     // A message the server failed on once is often fine a minute later; only one more try, then the next run.
     if (plan.stopped === null && plan.failed.size > 0) {
         plan.only = new Set(plan.failed);
+        plan.quick.clear();
         plan.failed.clear();
         plan.tried.clear();
         await goOn();
@@ -188,6 +190,17 @@ const syncRound = async (source, store, { account, since, max = 200, maxBodyChar
             mboxPoint = point;
     }
     let capped = false;
+    const unreadable = [];
+    /** Raw mail read to learn its id, kept for the save so it is not read twice. */
+    const rawOf = new Map();
+    const quickRan = new Set();
+    let holding;
+    const holdsMail = async (folder) => {
+        holding ??= new Set((await store.mail.emailRefs({ accountId })).flatMap(({ mailboxes }) => mailboxes
+            .filter(({ kind }) => kind !== "label" && kind !== ENVELOPE && kind !== BULK)
+            .map((box) => box.externalId)));
+        return holding.has(folder);
+    };
     for (const folder of folders) {
         if (mboxPoint !== undefined)
             break;
@@ -212,6 +225,38 @@ const syncRound = async (source, store, { account, since, max = 200, maxBodyChar
             if (kept !== undefined)
                 storedPoints.set(folder, kept);
             const point = fresh ? undefined : kept;
+            const sameRules = point !== undefined && point.validity === searched.validity && point.rules === ruleSet;
+            // Without a cheap id the mail's identity is in its bytes, so a folder is listed quickly only when no stored mail
+            // can be read twice: its done UIDs are known, or the store holds nothing from it. Otherwise (a new UIDVALIDITY,
+            // other rules, --rescan) the full header listing recognises what is stored without downloading it.
+            const quickable = !snapshot &&
+                searched.quick === true &&
+                searched.validity !== undefined &&
+                source.quick !== undefined &&
+                source.identify !== undefined;
+            const inQuick = quickable &&
+                (plan === undefined
+                    ? sameRules || !(await holdsMail(folder))
+                    : plan.quickFolders.has(folder) || (!plan.modes.has(folder) && (sameRules || !(await holdsMail(folder)))));
+            if (inQuick) {
+                plan?.quickFolders.add(folder);
+                plan?.modes.set(folder, "resumed");
+                resumed.add(folder);
+                quickRan.add(folder);
+                const done = point !== undefined && sameRules ? point.done : [];
+                if (point !== undefined && sameRules)
+                    earlier.set(folder, point);
+                const round = await readQuick(source, since, folder, searched, done, max, plan);
+                if (round.capped)
+                    capped = true;
+                for (const { item, raw } of round.read) {
+                    collected.push(item);
+                    rawOf.set(item, raw);
+                }
+                for (const bad of round.unreadable)
+                    unreadable.push(bad);
+                continue;
+            }
             if (point !== undefined && point.validity === searched.validity && point.rules === ruleSet) {
                 earlier.set(folder, point);
                 const mode = plan?.modes.get(folder);
@@ -301,6 +346,8 @@ const syncRound = async (source, store, { account, since, max = 200, maxBodyChar
         skipped = "an mbox file is a snapshot; mail missing from it is not proven deleted";
     else if (plan !== undefined && (capped || plan.tried.size > plan.asked || plan.only !== undefined))
         skipped = "this run read the window in parts; a run that lists all of it at once checks deletions";
+    else if (quickRan.size > 0)
+        skipped = "this run listed only mail not read before, by UID; --rescan lists every message and checks deletions";
     else if (resumed.size > 0)
         skipped =
             "this run listed only mail not read before; a full listing, at least daily or with --rescan, checks deletions";
@@ -339,7 +386,6 @@ const syncRound = async (source, store, { account, since, max = 200, maxBodyChar
         await store.mail.setMailboxes(accountId, [...scanned.values()], new Map([...labelsOf].map(([id, { labels }]) => [id, (labels ?? []).map((name) => label(name).externalId)])), startedAt);
     }
     const attachments = [];
-    const unreadable = [];
     let saved = 0;
     let alreadyStored = 0;
     let ruledOut = 0;
@@ -509,7 +555,9 @@ const syncRound = async (source, store, { account, since, max = 200, maxBodyChar
     for (let start = 0; start < pending.length; start += fetchChunk) {
         await stopIfAborted();
         const chunk = pending.slice(start, start + fetchChunk);
-        if (plan !== undefined) {
+        // Mail read to learn its id is already in hand: a chunk of it costs no request.
+        const unread = chunk.filter((item) => !rawOf.has(item));
+        if (plan !== undefined && unread.length > 0) {
             const stop = plan.budget.take();
             if (stop) {
                 plan.stopped = stop;
@@ -519,7 +567,8 @@ const syncRound = async (source, store, { account, since, max = 200, maxBodyChar
         }
         let raws;
         try {
-            raws = await source.fetchRaw(chunk);
+            const got = unread.length > 0 ? await source.fetchRaw(unread) : [];
+            raws = chunk.map((item) => rawOf.get(item) ?? got[unread.indexOf(item)]);
         }
         catch (error) {
             // What this run saved stays saved: the next one goes on from it.
@@ -601,7 +650,7 @@ const syncRound = async (source, store, { account, since, max = 200, maxBodyChar
         await store.mail.setFlags(accountId, new Map([...labelsOf].flatMap(([id, { seen, flagged }]) => seen === undefined && flagged === undefined
             ? []
             : [[id, { ...(seen === undefined ? {} : { read: seen }), ...(flagged === undefined ? {} : { flagged }) }]])), startedAt);
-    const incomplete = plan !== undefined && (capped || plan.stopped !== null || plan.failed.size > 0);
+    const incomplete = capped || (plan !== undefined && (plan.stopped !== null || plan.failed.size > 0));
     const complete = !full && !incomplete && unreadable.length === 0 && (plan?.unreadable.size ?? 0) === 0;
     const bulk = new Map(listed.filter((item) => item.headers?.bulk).map((item) => [item.messageId, [bulkBox.externalId]]));
     if (bulk.size)

package/dist/mail/testing/contract.js

@@ -53,6 +53,28 @@ export const mailSourceContract = (make) => {
             });
             assert.deepEqual(listed.map(({ uid }) => uid), first === undefined ? [] : [first]);
         }),
+        test("lists quickly the same UIDs, flags and sizes, and gives from the bytes the ids `list` gives", async (source) => {
+            if (source.search === undefined || source.quick === undefined || source.identify === undefined)
+                return;
+            const searched = await source.search(SINCE, folder);
+            if (!searched.quick)
+                return;
+            const quick = await source.quick(SINCE, folder, { searched });
+            const full = await source.list(SINCE, folder);
+            assert.deepEqual(quick.map(({ uid }) => uid).sort(), full.map(({ uid }) => uid).sort());
+            const raws = await source.fetchRaw(quick);
+            for (const [index, item] of quick.entries()) {
+                const raw = raws[index];
+                assert.ok(raw instanceof Uint8Array, "bytes");
+                const same = full.find(({ uid }) => uid === item.uid);
+                assert.deepEqual(source.identify(raw, item), {
+                    messageId: same?.messageId,
+                    threadId: same?.threadId,
+                });
+                assert.equal(item.seen, same?.seen);
+                assert.equal(item.receivedAt, same?.receivedAt);
+            }
+        }),
         test("returns each message's bytes in order, and one that cannot be read as an Error, not a failed call", async (source) => {
             const listed = await source.list(SINCE, folder);
             const raws = await source.fetchRaw(listed);

package/dist/mail/testing/fake.d.ts

@@ -48,7 +48,12 @@ export interface FakeMailbox {
         search: number;
         list: number;
         fetchRaw: number;
+        quick?: number;
     };
+    /** Answers as a server with no cheap message id does: `search` says `quick`, and `quick` and `identify` work. */
+    quick?: boolean;
+    /** The UIDs `fetchRaw` was asked for, in order, so a test proves nothing is read twice. */
+    read?: string[];
     /** What the source tells a budgeted sync about its batch sizes. */
     listBatch?: number;
     fetchBatch?: number;

package/dist/mail/testing/fake.js

@@ -29,18 +29,21 @@ export const rawOf = (m) => {
 };
 const failure = (message) => new CliError("provider_error", message, { reason: "mail.source-failed" });
 const labelsOf = (m) => [...new Set([...(m.labels ?? []), ...(m.flagged ? ["Starred"] : [])])].sort();
-const listingOf = (m, headers, folder) => ({
+const quickOf = (m, folder) => ({
     uid: m.uid,
-    messageId: m.messageId,
-    threadId: m.threadId,
     receivedAt: new Date(m.receivedAt).toISOString(),
     size: rawOf(m).length,
     labels: labelsOf(m),
     seen: m.seen ?? false,
     flagged: m.flagged ?? false,
-    ...(headers ? { headers: headersOf(Buffer.from(rawOf(m)).toString().split("\r\n\r\n")[0] ?? "") } : {}),
     folder,
 });
+const listingOf = (m, headers, folder) => ({
+    ...quickOf(m, folder),
+    messageId: m.messageId,
+    threadId: m.threadId,
+    ...(headers ? { headers: headersOf(Buffer.from(rawOf(m)).toString().split("\r\n\r\n")[0] ?? "") } : {}),
+});
 /**
  * An in-memory mail source with Gmail's shape: ids and threads that outlive a folder, labels and flags, UIDVALIDITY,
  * a trash a move reaches, and All Mail under the account's language. The sync tests and the adapter contract run on it.
@@ -59,6 +62,7 @@ export const fakeMailSource = (mailbox) => {
         const from = Date.UTC(since.getUTCFullYear(), since.getUTCMonth(), since.getUTCDate());
         return {
             validity: String(mailbox.validity ?? 12),
+            ...(mailbox.quick ? { quick: true } : {}),
             uids: inFolder(folder)
                 .filter((m) => Date.parse(m.receivedAt) >= from)
                 .map((m) => m.uid),
@@ -73,7 +77,7 @@ export const fakeMailSource = (mailbox) => {
     };
     const count = (kind) => {
         if (mailbox.calls)
-            mailbox.calls[kind] += 1;
+            mailbox.calls[kind] = (mailbox.calls[kind] ?? 0) + 1;
     };
     return {
         ...(mailbox.listBatch === undefined ? {} : { listBatch: mailbox.listBatch }),
@@ -94,6 +98,24 @@ export const fakeMailSource = (mailbox) => {
                 .filter((m) => wanted.has(m.uid) && !failsNow(m.uid))
                 .map((m) => listingOf(m, options?.headers ?? false, folder));
         },
+        ...(mailbox.quick
+            ? {
+                quick: async (_since, folder, options) => {
+                    count("quick");
+                    if (mailbox.searchFails)
+                        throw failure(mailbox.searchFails);
+                    const wanted = new Set(options.searched.uids);
+                    return inFolder(folder)
+                        .filter((m) => wanted.has(m.uid) && !failsNow(m.uid))
+                        .map((m) => quickOf(m, folder));
+                },
+                identify: (raw) => {
+                    const id = /^Message-ID:\s*<(.+?)@example\.test>/im.exec(Buffer.from(raw).toString())?.[1];
+                    const m = mailbox.messages.find((each) => each.messageId === id);
+                    return { messageId: m.messageId, threadId: m.threadId };
+                },
+            }
+            : {}),
         find: async (messageIds, folder, options) => {
             for (const id of messageIds)
                 mailbox.asked?.push(`msgid:${id}`);
@@ -131,6 +153,7 @@ export const fakeMailSource = (mailbox) => {
         },
         fetchRaw: async (items) => {
             count("fetchRaw");
+            mailbox.read?.push(...items.map(({ uid }) => uid));
             return items.map((item) => {
                 const m = mailbox.messages.find((each) => each.uid === item.uid);
                 if (m === undefined || mailbox.unreadable?.includes(item.uid) || failsNow(item.uid))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.486.0",
+  "version": "0.487.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",