@wirecat/cli-core 0.471.0 → 0.473.0

package/dist/mail/score.js

@@ -0,0 +1,174 @@
+import { isDisposableEmailDomain } from "disposable-email-domains-js";
+import { getDomain } from "tldts";
+/**
+ * How much each sign of spam, a scam or a robot adds to a sender's score. Gmail filters spam before it reaches
+ * All Mail, so these mostly find what got through: spoofed senders, scams and robots no rule covers yet.
+ */
+export const WEIGHTS = {
+    spam_folder: 4,
+    dmarc_fail: 3,
+    brand_spoof: 3,
+    young_domain: 5,
+    reply_to_elsewhere: 1,
+    never_opened: 2,
+    dkim_not_passed: 2,
+    disposable_domain: 2,
+    bulk_never_replied: 1,
+    replied: -5,
+};
+/**
+ * The signs of a forged or fraudulent sender, as opposed to how the owner treats ordinary bulk mail. A failed DMARC
+ * check is one only beside another: alone it marks real senders with a broken setup or a forwarding path.
+ */
+export const FRAUD_SIGNALS = ["dmarc_fail", "brand_spoof", "young_domain", "disposable_domain"];
+export const SCORE_RULE = "score adds: in Gmail's Spam +4, Gmail's DMARC check failed +3 (only beside another sign of fraud), a brand in the display name sent from another " +
+    "domain +3, the domain under 180 days old when the mail came +5 (only with looked-up ages), Reply-To on another " +
+    "domain +1, none of its mail ever opened +2, Gmail's DKIM check not passed +2, a throwaway-mail domain +2, bulk mail " +
+    "never replied to +1, replied to by the owner -5";
+/**
+ * DMARC failures before this date are not counted: senders then often published a policy their own mail did not yet
+ * meet.
+ */
+export const DMARC_SINCE = "2022-01-01T00:00:00.000Z";
+/** A domain registered too recently to trust: under this many days old when the mail arrived. */
+export const YOUNG_DAYS = 180;
+/** The part of a host a person registers: `mail.news.example.co.uk` is `example.co.uk`. */
+export const registrableOf = (address) => {
+    const host = address.slice(address.lastIndexOf("@") + 1).toLowerCase();
+    return getDomain(host) ?? host;
+};
+/**
+ * The big mailbox providers. Their domains are years old and say nothing about the sender, so they are never
+ * looked up; a brand display name sent from one of them is the classic scam.
+ */
+export const FREE_MAIL = new Set([
+    "gmail.com",
+    "googlemail.com",
+    "yahoo.com",
+    "outlook.com",
+    "hotmail.com",
+    "live.com",
+    "msn.com",
+    "icloud.com",
+    "me.com",
+    "aol.com",
+    "proton.me",
+    "protonmail.com",
+    "gmx.com",
+    "gmx.de",
+    "mail.com",
+    "yandex.ru",
+    "ya.ru",
+    "mail.ru",
+    "bk.ru",
+    "inbox.ru",
+    "list.ru",
+    "rambler.ru",
+    "zoho.com",
+]);
+/** A brand and the first labels of the domains it really sends from. */
+const BRANDS = {
+    paypal: ["paypal"],
+    apple: ["apple", "icloud"],
+    microsoft: [
+        "microsoft",
+        "outlook",
+        "office",
+        "office365",
+        "live",
+        "hotmail",
+        "azure",
+        "onedrive",
+        "microsoftadvertising",
+    ],
+    google: ["google", "gmail", "youtube", "googlemail"],
+    amazon: ["amazon", "amazonaws", "aws"],
+    netflix: ["netflix"],
+    facebook: ["facebook", "facebookmail", "meta", "fb"],
+    instagram: ["instagram", "facebookmail"],
+    whatsapp: ["whatsapp"],
+    linkedin: ["linkedin"],
+    dhl: ["dhl"],
+    fedex: ["fedex"],
+    docusign: ["docusign"],
+    dropbox: ["dropbox", "dropboxmail", "hellosign"],
+    binance: ["binance"],
+    coinbase: ["coinbase"],
+    revolut: ["revolut"],
+};
+/** Platforms that name courses, spaces and pages after other companies: "Google Cloud" from Coursera is a course. */
+const NAMES_OTHERS = new Set(["coursera", "quora"]);
+const named = (brand, text) => new RegExp(`\\b${brand}\\b`, "i").test(text);
+/**
+ * The brand a display name claims while the address belongs to someone else, if any. "Google via LinkedIn" from
+ * LinkedIn's own domain is LinkedIn passing a page on; "PayPal via Desk" from anywhere else is still judged whole.
+ */
+export const spoofedBrand = (name, address) => {
+    if (name === undefined || address === undefined)
+        return undefined;
+    const label = registrableOf(address).split(".")[0] ?? "";
+    if (NAMES_OTHERS.has(label))
+        return undefined;
+    const relay = /\s+via\s+(.+)$/i.exec(name)?.[1];
+    if (relay !== undefined &&
+        Object.entries(BRANDS).some(([brand, owned]) => named(brand, relay) && owned.includes(label)))
+        return undefined;
+    return Object.entries(BRANDS).find(([brand, owned]) => named(brand, name) && !owned.includes(label))?.[0];
+};
+const DAY_MS = 24 * 60 * 60 * 1000;
+/**
+ * Under YOUNG_DAYS old at `at`; false when the age is not known, and when the registration came after `at`: the
+ * domain lapsed and someone registered it again later, which says nothing about the mail that came before.
+ */
+export const youngAt = (age, at) => {
+    if (age?.created === undefined)
+        return false;
+    const old = Date.parse(at) - Date.parse(age.created);
+    return old >= 0 && old < YOUNG_DAYS * DAY_MS;
+};
+const most = (items, test) => items.filter((item) => test(item)).length * 2 >= items.length;
+/**
+ * A sender group's score from the facts its emails carry. A sign counts when it holds for at least half the group's
+ * emails, so one odd email does not mark a sender; a spoofed brand counts on any one.
+ */
+export const scoreGroup = (items, context) => {
+    const signals = [];
+    const judged = items.filter((item) => item.headers?.auth?.dmarc !== undefined && item.receivedAt >= DMARC_SINCE);
+    if (most(items, (item) => item.labels?.includes("Spam")))
+        signals.push("spam_folder");
+    // A failure with a valid DKIM signature is a sender signing for another domain, common before 2021, not a forgery;
+    // one that passes DMARC on any of its mail is real, and its failures came by a path that breaks it.
+    const forged = (item) => item.headers?.auth?.dmarc === "fail" && item.headers.auth.dkim !== "pass";
+    if (judged.length && most(judged, forged) && !judged.some((item) => item.headers?.auth?.dmarc === "pass"))
+        signals.push("dmarc_fail");
+    if (items.some((item) => spoofedBrand(item.headers?.fromName, item.headers?.from) !== undefined))
+        signals.push("brand_spoof");
+    const sender = items.find((item) => item.headers?.from !== undefined)?.headers?.from;
+    const domain = sender === undefined ? undefined : registrableOf(sender);
+    const first = items.reduce((a, b) => (a.receivedAt < b.receivedAt ? a : b));
+    if (domain !== undefined && youngAt(context.ages.get(domain), first.receivedAt))
+        signals.push("young_domain");
+    if (most(items, (item) => {
+        const { from, replyTo } = item.headers ?? {};
+        return from !== undefined && replyTo !== undefined && registrableOf(replyTo) !== registrableOf(from);
+    }))
+        signals.push("reply_to_elsewhere");
+    const known = items.filter((item) => item.seen !== undefined);
+    if (known.length && known.every((item) => !item.seen))
+        signals.push("never_opened");
+    // Gmail's stamp without a dkim= verdict means the mail carried no signature: that counts as not passed.
+    const stamped = items.filter((item) => item.headers?.auth !== undefined);
+    if (stamped.length && most(stamped, (item) => item.headers?.auth?.dkim !== "pass"))
+        signals.push("dkim_not_passed");
+    if (domain !== undefined && isDisposableEmailDomain(domain))
+        signals.push("disposable_domain");
+    if (context.bulk >= 0.8 && !context.replied)
+        signals.push("bulk_never_replied");
+    if (context.replied)
+        signals.push("replied");
+    const kept = signals.includes("dmarc_fail") &&
+        !signals.some((signal) => signal !== "dmarc_fail" && FRAUD_SIGNALS.includes(signal))
+        ? signals.filter((signal) => signal !== "dmarc_fail")
+        : signals;
+    return { score: kept.reduce((sum, signal) => sum + WEIGHTS[signal], 0), signals: kept };
+};

package/dist/mail/sender-scores.d.ts

@@ -0,0 +1,30 @@
+import type { MessageStore } from "../store/index.js";
+import { type MailRule } from "./rules.js";
+import { type DomainAge } from "./score.js";
+export interface LookupResult {
+    looked: number;
+    failed: number;
+}
+/** Registration dates of sender domains: the ones already known, and a lookup for the rest. */
+export interface DomainAges {
+    known: () => ReadonlyMap<string, DomainAge>;
+    lookUp: (domains: readonly string[]) => Promise<LookupResult>;
+}
+/** Raised when the weights or the signals change, so every sender is scored again on the next sync. */
+export declare const SCORE_VERSION = 4;
+/** Signs of fraud adding up to this rank a sender's mail lower in search. */
+export declare const DEMOTE_AT = 3;
+/**
+ * Scores every sender of the account from the mail the store holds, as `memo mail inspect` scores a listing, and
+ * keeps the scores in the store, where search shows them. At most once a day, or at once after SCORE_VERSION
+ * changes. A sender in several groups (its own mail and a list) keeps the highest score. Domains not yet aged are
+ * looked up first, for senders heard from in the last two years.
+ */
+export declare const scoreSenders: (store: MessageStore, address: string, ages: DomainAges, now?: number, rules?: readonly MailRule[]) => Promise<{
+    scored: number;
+    looked: number;
+    failed: number;
+    demoted: number;
+} | undefined>;
+/** Every mail account's senders whose mail search ranks lower, as the last scoring left them. */
+export declare const demotedSenders: (store: MessageStore) => Promise<Set<string>>;

package/dist/mail/sender-scores.js

@@ -0,0 +1,96 @@
+import { domainsToAge, groupKey, probeMail } from "./probe.js";
+import { decide } from "./rules.js";
+import { FRAUD_SIGNALS, FREE_MAIL, registrableOf, WEIGHTS } from "./score.js";
+import { listedOf } from "./stored.js";
+const SCORED = "mail_sender_scores";
+/** Raised when the weights or the signals change, so every sender is scored again on the next sync. */
+export const SCORE_VERSION = 4;
+/** Signs of fraud adding up to this rank a sender's mail lower in search. */
+export const DEMOTE_AT = 3;
+const DAY = 86_400_000;
+/** Only senders heard from this recently are looked up: an older sender's domain may have lapsed or changed hands. */
+const RECENT = 2 * 365 * DAY;
+/**
+ * Scores every sender of the account from the mail the store holds, as `memo mail inspect` scores a listing, and
+ * keeps the scores in the store, where search shows them. At most once a day, or at once after SCORE_VERSION
+ * changes. A sender in several groups (its own mail and a list) keeps the highest score. Domains not yet aged are
+ * looked up first, for senders heard from in the last two years.
+ */
+export const scoreSenders = async (store, address, ages, now = Date.now(), rules = []) => {
+    const key = { provider: "email", account: address.toLowerCase() };
+    const last = (await store.sync.syncState(key, SCORED))?.value;
+    const done = last === undefined ? undefined : JSON.parse(last);
+    if (done !== undefined && done.version === SCORE_VERSION && now - done.at < DAY)
+        return undefined;
+    const stored = await store.accounts.storedAccount(key).catch(() => null);
+    if (stored === null)
+        return undefined;
+    const items = (await store.mail.emailFacts({ accountId: stored.id })).map((email) => {
+        const item = listedOf(email);
+        return email.outgoing && !item.labels?.includes("Sent")
+            ? { ...item, labels: [...(item.labels ?? []), "Sent"] }
+            : item;
+    });
+    // Each registry learns only its own domains' names; big mailbox providers and senders the owner wrote to are never asked.
+    const latest = new Map();
+    for (const item of items) {
+        if (item.headers === undefined)
+            continue;
+        const key = groupKey(item.headers);
+        if ((latest.get(key) ?? "") < item.receivedAt)
+            latest.set(key, item.receivedAt);
+    }
+    const since = new Date(now - RECENT).toISOString();
+    const recent = probeMail(items, Number.MAX_SAFE_INTEGER).items.filter((group) => (latest.get(groupKey({
+        ...(group.from === null ? {} : { from: group.from }),
+        ...(group.listId === null ? {} : { listId: group.listId }),
+    })) ?? "") >= since);
+    const lookups = await ages.lookUp(domainsToAge(recent, FREE_MAIL)).catch(() => ({ looked: 0, failed: 1 }));
+    const groups = new Map(probeMail(items, Number.MAX_SAFE_INTEGER, ages.known()).items.map((group) => [
+        groupKey({
+            ...(group.from === null ? {} : { from: group.from }),
+            ...(group.listId === null ? {} : { listId: group.listId }),
+        }),
+        group,
+    ]));
+    // The owner's own: a domain they wrote to anyone at, their own mailbox's domain, or a sender a protect rule keeps.
+    const trusted = new Set([address, ...items.filter((item) => item.labels?.includes("Sent")).flatMap((item) => item.headers?.to ?? [])]
+        .map((to) => registrableOf(to))
+        .filter((domain) => !FREE_MAIL.has(domain)));
+    const protectedSenders = new Set(items.filter((item) => decide(rules, item)?.protected).flatMap((item) => item.headers?.from?.toLowerCase() ?? []));
+    const fraud = (signals) => signals.reduce((sum, signal) => sum + (FRAUD_SIGNALS.includes(signal) ? WEIGHTS[signal] : 0), 0);
+    const scores = new Map();
+    for (const item of items) {
+        const from = item.headers?.from?.toLowerCase();
+        const group = item.headers === undefined ? undefined : groups.get(groupKey(item.headers));
+        if (from === undefined || group === undefined)
+            continue;
+        const held = scores.get(from);
+        if (held === undefined || group.score > held.score)
+            scores.set(from, {
+                address: from,
+                score: group.score,
+                signals: group.signals,
+                demoted: fraud(group.signals) >= DEMOTE_AT &&
+                    !group.signals.includes("replied") &&
+                    !trusted.has(registrableOf(from)) &&
+                    !protectedSenders.has(from),
+            });
+    }
+    const demoted = [...scores.values()].filter((score) => score.demoted).map(({ address }) => address);
+    const written = await store.mail.setSenderScores(stored.id, [...scores.values()], now);
+    await store.sync.setSyncState(key, SCORED, JSON.stringify({ version: SCORE_VERSION, at: now, demoted }));
+    return { scored: written, ...lookups, demoted: demoted.length };
+};
+/** Every mail account's senders whose mail search ranks lower, as the last scoring left them. */
+export const demotedSenders = async (store) => {
+    const senders = new Set();
+    for (const account of await store.accounts.accounts()) {
+        if (account.provider !== "email")
+            continue;
+        const value = (await store.sync.syncState(account, SCORED))?.value;
+        for (const sender of value === undefined ? [] : (JSON.parse(value).demoted ?? []))
+            senders.add(sender);
+    }
+    return senders;
+};

package/dist/mail/source.d.ts

@@ -0,0 +1,74 @@
+import type { MailHeaders } from "./headers.js";
+import type { FileStamp } from "./resume.js";
+export interface Listed {
+    uid: string;
+    /** Gmail's own ids: the same in every folder, and they survive a UID reset. */
+    messageId: string;
+    threadId: string;
+    receivedAt: string;
+    folder?: string;
+    /** Gmail labels, plain names; absent when the answer could not be read, so nothing is changed. */
+    labels?: string[];
+    seen?: boolean;
+    flagged?: boolean;
+    /** RFC822.SIZE in bytes, to size fetch batches. */
+    size?: number;
+    /** Read only when asked for; absent when not asked or unreadable, so no rule applies to it. */
+    headers?: MailHeaders;
+}
+export interface Searched {
+    /** Absent when the server does not say; then no UID is trusted across runs. */
+    validity?: string;
+    uids: string[];
+}
+/** Everything the import asks of a mail client, so a transport can be replaced without touching the sync. */
+export interface MailSource {
+    /**
+     * How many messages one `list` call reads in about one request's time, parallel connections included; a budgeted
+     * sync lists that many at a time, so a request of the budget is one call. Absent: 200.
+     */
+    listBatch?: number;
+    /** The same for `fetchRaw`. Absent: 50. */
+    fetchBatch?: number;
+    /**
+     * Every message in `folder` received since `since`; all or nothing, since deletions are proved from it.
+     * `headers` also reads From, To, Cc and the list fields, for the probe and the owner's rules.
+     */
+    list(since: Date, folder: string, options?: {
+        headers?: boolean;
+        searched?: Searched;
+    }): Promise<Listed[]>;
+    /**
+     * The folder's UIDs in the window and its UIDVALIDITY, without reading a message; `list` given them reads only
+     * those. Absent for a file, which has no UIDs.
+     */
+    search?(since: Date, folder: string): Promise<Searched>;
+    /** A file's size and modification time, so an unchanged file read to the end is not read again. */
+    stamp?(): Promise<FileStamp>;
+    /**
+     * The messages of `folder` with these Gmail ids, listed as `list` lists them; a message no longer there is left
+     * out. Absent where messages have no Gmail id: a file, or plain IMAP.
+     */
+    find?(messageIds: readonly string[], folder: string, options?: {
+        headers?: boolean;
+    }): Promise<Listed[]>;
+    /**
+     * Moves messages by Gmail id between folders on the server; ids `from` does not hold come back as missing.
+     * `known` gives each id's UID in `from`, already read, so none is looked up again.
+     */
+    move?(messageIds: readonly string[], from: string, to: string, known?: ReadonlyMap<string, string>): Promise<{
+        moved: string[];
+        missing: string[];
+    }>;
+    /** All Mail and Trash under the names this account's language gives them. */
+    folders?(): Promise<{
+        all: string;
+        trash: string;
+    }>;
+    /** Which of these UIDs `folder` still holds. */
+    present?(uids: readonly string[], folder: string): Promise<string[]>;
+    /** 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)[]>;
+}

package/dist/mail/source.js

@@ -0,0 +1 @@
+export {};

package/dist/mail/stored.d.ts

@@ -0,0 +1,7 @@
+import type { EmailFacts } from "../store/index.js";
+import type { Listed } from "./source.js";
+export type StoredMail = Listed & {
+    envelope: boolean;
+};
+/** A stored email in the shape a Gmail listing has; it has no UID until Gmail is asked. */
+export declare const listedOf: (email: EmailFacts) => StoredMail;

package/dist/mail/stored.js

@@ -0,0 +1,36 @@
+import { BULK } from "./bulk.js";
+import { ENVELOPE } from "./rules.js";
+/** A stored email in the shape a Gmail listing has; it has no UID until Gmail is asked. */
+export const listedOf = (email) => {
+    const labels = email.mailboxes.filter(({ kind }) => kind === "label").map(({ name }) => name);
+    if (email.flagged && !labels.includes("Starred"))
+        labels.push("Starred");
+    return {
+        uid: "",
+        messageId: email.externalId,
+        threadId: "",
+        receivedAt: new Date(email.receivedAt ?? 0).toISOString(),
+        labels: labels.sort(),
+        seen: email.read,
+        flagged: email.flagged,
+        ...(email.size === null ? {} : { size: email.size }),
+        headers: {
+            ...(email.fromAddress === null ? {} : { from: email.fromAddress }),
+            ...(email.fromName === null ? {} : { fromName: email.fromName }),
+            ...(email.subject === null ? {} : { subject: email.subject }),
+            ...(email.listId === null ? {} : { listId: email.listId }),
+            to: email.recipients,
+            bulk: email.mailboxes.some(({ kind }) => kind === BULK),
+            ...(email.replyTo === null ? {} : { replyTo: email.replyTo }),
+            ...(email.dkim === null && email.dmarc === null
+                ? {}
+                : {
+                    auth: {
+                        ...(email.dkim === null ? {} : { dkim: email.dkim }),
+                        ...(email.dmarc === null ? {} : { dmarc: email.dmarc }),
+                    },
+                }),
+        },
+        envelope: email.mailboxes.some(({ kind }) => kind === ENVELOPE),
+    };
+};

package/dist/mail/sync.d.ts

@@ -0,0 +1,106 @@
+import type { BudgetStop, RunBudget } from "../background/budget.js";
+import type { LoadEngine } from "../readers/types.js";
+import type { AccountKey, MessageStore } from "../store/index.js";
+import { type TagOutcome } from "./rule-tags.js";
+import { type MailRule } from "./rules.js";
+import type { DomainAge } from "./score.js";
+import type { MailSource } from "./source.js";
+export interface MailAccount {
+    /** The mailbox address: the store's account id. */
+    address: string;
+    mode?: "gmail" | "imap" | "mbox";
+    folders?: string[];
+    rules?: MailRule[];
+}
+/** What an index step reports, as memo's embedding does; the sync only passes it on. */
+export interface MailIndexed {
+    chats: number;
+    chunks: number;
+    left: boolean;
+    notEmbedded?: unknown;
+}
+export interface MailSyncResult {
+    account: string;
+    since: string;
+    listed: number;
+    saved: number;
+    alreadyStored: number;
+    /** New emails a skip rule kept out: never read, never stored. */
+    skipped: number;
+    /** New emails an envelope rule recorded: sender, date, size and labels, never their text. */
+    envelopes: number;
+    deleted: number;
+    /** False when `max` stopped the run before every new message was read; the next run continues. */
+    complete: boolean;
+    /** `partial`: a budgeted run stopped before the whole window was read; the next run goes on. */
+    state?: "partial" | "complete";
+    /** Why a budgeted run stopped early: its request budget, its deadline, or a cancel. */
+    stopped?: BudgetStop;
+    /** Messages of the window this run did not get to read; a budgeted run only. */
+    remaining?: number;
+    /** Requests a budgeted run spent. */
+    requests?: number;
+    /** Emails that could not be read or parsed; they are tried again next run. */
+    unreadable?: {
+        message: string;
+        reason: string;
+    }[];
+    /** Why stored messages missing at the source were left alone, when they were. */
+    deletionsSkipped?: string;
+    /** "resumed": only mail not done before was listed; "full": every message in the window was. */
+    pass?: "full" | "resumed";
+    indexed?: MailIndexed;
+    coverage?: {
+        folders: string[];
+        since: string;
+        until: string;
+        state: "window" | "partial";
+        identity: string;
+    };
+    attachments?: {
+        message: string;
+        part: number;
+        status: string;
+    }[];
+    /** Rule tags put on mail as an existing label the store pointed to. */
+    tagsReused?: TagOutcome["reused"];
+    /** Rule tags the store refused with nothing to reuse; that mail is stored untagged. */
+    tagsSkipped?: TagOutcome["skipped"];
+    /** `--retry-attachments`: emails read again for attachments a missing reader left unread. */
+    retried?: {
+        emails: number;
+        extracted: number;
+        stillFailed: number;
+        missing: number;
+    };
+}
+export declare const MAX_ATTACHMENT_CHARS = 200000;
+export interface MailSyncOptions {
+    account: MailAccount;
+    since: Date;
+    max?: number;
+    maxBodyChars?: number;
+    maxAttachmentChars?: number;
+    now?: () => number;
+    /** Domain registration dates already known, for the sender score a rule asks for. */
+    ages?: ReadonlyMap<string, DomainAge>;
+    loadEngine?: LoadEngine;
+    retryAttachments?: boolean;
+    /** List every message in the window, not only those an earlier run left: proves deletions, refreshes labels. */
+    rescan?: boolean;
+    /** A window smaller than this is listed whole every run: it costs seconds and keeps flags and deletions current. */
+    resumeFrom?: number;
+    /** Runs after the mail is saved, so chats and mail still waiting for vectors are indexed; its answer is `indexed`. */
+    index?: (store: MessageStore, key: AccountKey) => Promise<MailIndexed>;
+    /** Stops between batches of emails, after saving the resume point. */
+    signal?: AbortSignal;
+    /**
+     * Makes the run budgeted: it reads the window in rounds, one request of the budget per call to the source, saves
+     * after each, stops when the budget says so and answers `state: "partial"`. A message the source could not give
+     * is tried once more at the end of the run and, if it still fails, left for the next one. `max` defaults to no limit.
+     */
+    budget?: RunBudget;
+}
+export declare const syncMail: (source: MailSource, store: MessageStore, options: MailSyncOptions) => Promise<MailSyncResult>;
+/** Failures a newer install mends: the reader was missing, not the file at fault, so reading again can succeed. */
+export declare const RETRYABLE_ATTACHMENTS: string[];