@remit/mailbox-service 0.0.111 → 0.0.113

package/dist/test-helpers/mime-tree-generator.js

@@ -0,0 +1,329 @@
+/**
+ * Deterministic random MIME tree generator for the body-part mapper
+ * property test (issue #395 PR C).
+ *
+ * Three pieces:
+ *
+ *   1. `createRng(seed)` — small xorshift32 PRNG. Same seed → same sequence
+ *      so failing CI runs reproduce locally via `MAPPER_PROPERTY_SEED`.
+ *
+ *   2. `generateMimeTree(rng, opts)` — synthesise a random tree:
+ *        - root is either a leaf or a `multipart/<mixed|alternative|related>`
+ *        - multiparts have N ∈ [1, 5] children
+ *        - each child is leaf or multipart, depth capped at `maxDepth` (4)
+ *        - leaves draw uniformly from a fixed set of media types
+ *        - some leaves get a `dispositionFilename`, some a `contentId`,
+ *          some both, most neither
+ *        - leaves are mostly non-empty; a small fraction get zero bytes to
+ *          exercise the empty-leaf short-circuit in the mapper
+ *
+ *   3. `renderEml(tree)` + `treeToBodyParts(tree)` — produce a paired
+ *      `.eml` string and the `MapperInput[]` rows the mime-walker would
+ *      emit for that tree. Both walk the same tree, so partPath, content
+ *      type, filename and contentId stay aligned by construction.
+ *
+ * No external deps. Built on Node primitives only (`node:buffer`,
+ * `node:string_decoder` via `Buffer.from(..., 'base64')`).
+ */
+import { Buffer } from "node:buffer";
+export const createRng = (seed) => {
+    // xorshift32 needs a non-zero 32-bit state.
+    let state = (seed | 0) === 0 ? 0xc0dec0de | 0 : seed | 0;
+    const next = () => {
+        state ^= state << 13;
+        state ^= state >>> 17;
+        state ^= state << 5;
+        // Map signed-int range to [0, 1).
+        return ((state >>> 0) % 0xffffffff) / 0xffffffff;
+    };
+    return {
+        next,
+        int: (maxExclusive) => Math.floor(next() * maxExclusive),
+        pick: (items) => items[Math.floor(next() * items.length)],
+        bool: (probability) => next() < probability,
+    };
+};
+const LEAF_CONTENT_TYPES = [
+    "text/plain",
+    "text/html",
+    "application/pdf",
+    "image/png",
+    "application/octet-stream",
+];
+const MULTIPART_SUBTYPES = [
+    "mixed",
+    "alternative",
+    "related",
+];
+const DEFAULT_OPTS = {
+    maxDepth: 4,
+    rootMultipartProb: 0.85,
+    emptyLeafProb: 0.05,
+};
+const extensionFor = (contentType) => {
+    switch (contentType) {
+        case "text/plain":
+            return "txt";
+        case "text/html":
+            return "html";
+        case "application/pdf":
+            return "pdf";
+        case "image/png":
+            return "png";
+        case "application/octet-stream":
+            return "bin";
+    }
+};
+const randomBasename = (rng) => {
+    // Short ASCII basename — keeps the EML readable.
+    const letters = "abcdefghijklmnopqrstuvwxyz";
+    const len = 3 + rng.int(5);
+    let s = "";
+    for (let i = 0; i < len; i++)
+        s += letters[rng.int(letters.length)];
+    return s;
+};
+const generateLeafBytes = (rng, partPath, contentType, emptyLeafProb) => {
+    if (rng.bool(emptyLeafProb))
+        return Buffer.alloc(0);
+    return Buffer.from(`leaf-${partPath}-${contentType}`, "utf8");
+};
+const buildLeaf = (rng, partPath, emptyLeafProb) => {
+    const contentType = rng.pick(LEAF_CONTENT_TYPES);
+    const bytes = generateLeafBytes(rng, partPath, contentType, emptyLeafProb);
+    const leaf = { kind: "leaf", contentType, bytes };
+    const ext = extensionFor(contentType);
+    const isTextStar = contentType.startsWith("text/");
+    // Random attachment metadata:
+    //   - ~25% get a filename (more common on non-text leaves)
+    //   - ~10% get a contentId (image/inline-style)
+    //   - text/plain and text/html mostly stay bare (they route via parsed.text/html)
+    const wantsFilename = isTextStar ? rng.bool(0.05) : rng.bool(0.45);
+    const wantsContentId = rng.bool(0.15);
+    if (wantsFilename) {
+        leaf.filename = `${randomBasename(rng)}.${ext}`;
+        leaf.disposition = rng.bool(0.5) ? "attachment" : "inline";
+    }
+    if (wantsContentId) {
+        leaf.contentId = `${randomBasename(rng)}@example.org`;
+        // inline content-id attachments are conventionally inline.
+        if (!leaf.disposition)
+            leaf.disposition = "inline";
+    }
+    return leaf;
+};
+/**
+ * Decay child probability with depth: at depth 4 (max), all children are
+ * leaves to guarantee termination.
+ */
+const childMultipartProb = (depth, maxDepth) => {
+    if (depth >= maxDepth - 1)
+        return 0;
+    // 0.6 → 0.4 → 0.2 → 0 from depth 0 outward.
+    const slots = maxDepth - 1;
+    const remaining = slots - depth;
+    return Math.max(0, (remaining / slots) * 0.6);
+};
+const buildMultipart = (rng, depth, maxDepth, emptyLeafProb, partPath) => {
+    const subtype = rng.pick(MULTIPART_SUBTYPES);
+    const childCount = 1 + rng.int(5); // [1, 5]
+    const childMpProb = childMultipartProb(depth, maxDepth);
+    const children = [];
+    for (let i = 0; i < childCount; i++) {
+        const childPath = partPath === "0" ? String(i + 1) : `${partPath}.${i + 1}`;
+        const childIsMultipart = rng.bool(childMpProb);
+        if (childIsMultipart) {
+            children.push(buildMultipart(rng, depth + 1, maxDepth, emptyLeafProb, childPath));
+        }
+        else {
+            children.push(buildLeaf(rng, childPath, emptyLeafProb));
+        }
+    }
+    return { kind: "multipart", subtype, children };
+};
+export const generateMimeTree = (rng, opts = {}) => {
+    const o = { ...DEFAULT_OPTS, ...opts };
+    const rootIsMultipart = rng.bool(o.rootMultipartProb);
+    if (!rootIsMultipart) {
+        return buildLeaf(rng, "0", o.emptyLeafProb);
+    }
+    return buildMultipart(rng, 0, o.maxDepth, o.emptyLeafProb, "0");
+};
+/* -------------------------------------------------------------------- */
+/* BodyPart projection                                                  */
+/* -------------------------------------------------------------------- */
+const splitContentType = (contentType) => {
+    const [top, sub] = contentType.split("/");
+    const map = {
+        text: "TEXT",
+        image: "IMAGE",
+        application: "APPLICATION",
+        multipart: "MULTIPART",
+    };
+    const mediaType = map[top];
+    if (!mediaType) {
+        throw new Error(`mime-tree-generator: unknown top-level type "${top}"`);
+    }
+    return { mediaType, mediaSubtype: sub };
+};
+/**
+ * Walk the tree the same way `mime-walker.ts` would and emit
+ * `MapperInput[]` in declaration order. Root path is "0"; subsequent
+ * leaves are "1", "2", "1.1", "1.2", ... — matches `walkMimeStructure`.
+ */
+export const treeToBodyParts = (tree) => {
+    const out = [];
+    const visit = (node, partPath) => {
+        if (node.kind === "leaf") {
+            const { mediaType, mediaSubtype } = splitContentType(node.contentType);
+            const row = {
+                partPath,
+                isMultipart: false,
+                mediaType,
+                mediaSubtype,
+                sizeOctets: node.bytes.length,
+                ...(node.filename ? { dispositionFilename: node.filename } : {}),
+                ...(node.contentId ? { contentId: node.contentId } : {}),
+                ...(node.disposition ? { disposition: node.disposition } : {}),
+            };
+            out.push(row);
+            return;
+        }
+        out.push({
+            partPath,
+            isMultipart: true,
+            mediaType: "MULTIPART",
+            mediaSubtype: node.subtype,
+        });
+        for (let i = 0; i < node.children.length; i++) {
+            const childPath = partPath === "0" ? String(i + 1) : `${partPath}.${i + 1}`;
+            visit(node.children[i], childPath);
+        }
+    };
+    visit(tree, "0");
+    return out;
+};
+/* -------------------------------------------------------------------- */
+/* EML renderer                                                         */
+/* -------------------------------------------------------------------- */
+/**
+ * Render a buffer as quoted-printable in a very conservative dialect:
+ * ASCII printable stays raw, anything else hex-encoded. Line length
+ * limit ignored — fixtures are short enough that no fold is needed for
+ * our property test. (mailparser tolerates long QP lines.)
+ */
+const encodeQuotedPrintable = (buf) => {
+    let out = "";
+    for (const b of buf) {
+        if (b === 0x09 || b === 0x20 || (b >= 0x21 && b <= 0x7e && b !== 0x3d)) {
+            out += String.fromCharCode(b);
+        }
+        else if (b === 0x0a) {
+            out += "\r\n";
+        }
+        else {
+            out += `=${b.toString(16).toUpperCase().padStart(2, "0")}`;
+        }
+    }
+    return out;
+};
+const encodeBase64 = (buf) => {
+    const b64 = buf.toString("base64");
+    // Wrap at 76 columns per RFC 2045.
+    const lines = [];
+    for (let i = 0; i < b64.length; i += 76)
+        lines.push(b64.slice(i, i + 76));
+    return lines.join("\r\n");
+};
+const transferEncodingFor = (contentType) => {
+    if (contentType === "text/plain")
+        return "quoted-printable";
+    if (contentType === "text/html")
+        return "7bit";
+    return "base64";
+};
+const renderLeaf = (leaf) => {
+    const lines = [];
+    const params = [];
+    if (leaf.contentType.startsWith("text/"))
+        params.push("charset=us-ascii");
+    if (leaf.filename)
+        params.push(`name="${leaf.filename}"`);
+    const ctypeLine = params.length > 0
+        ? `Content-Type: ${leaf.contentType}; ${params.join("; ")}`
+        : `Content-Type: ${leaf.contentType}`;
+    lines.push(ctypeLine);
+    const cte = transferEncodingFor(leaf.contentType);
+    lines.push(`Content-Transfer-Encoding: ${cte}`);
+    if (leaf.disposition) {
+        const dispLine = leaf.filename
+            ? `Content-Disposition: ${leaf.disposition}; filename="${leaf.filename}"`
+            : `Content-Disposition: ${leaf.disposition}`;
+        lines.push(dispLine);
+    }
+    if (leaf.contentId) {
+        lines.push(`Content-ID: <${leaf.contentId}>`);
+    }
+    let body = "";
+    if (leaf.bytes.length > 0) {
+        if (cte === "base64")
+            body = encodeBase64(leaf.bytes);
+        else if (cte === "quoted-printable")
+            body = encodeQuotedPrintable(leaf.bytes);
+        else
+            body = leaf.bytes.toString("utf8");
+    }
+    lines.push("");
+    lines.push(body);
+    return lines.join("\r\n");
+};
+/**
+ * Deterministic boundary derived from the seed + node path. Each
+ * multipart node gets its own unique boundary so nested rendering is
+ * unambiguous.
+ */
+const boundaryFor = (seed, partPath) => `=_b_${seed.toString(16)}_${partPath.replace(/\./g, "_")}_=`;
+const renderNode = (node, partPath, seed) => {
+    if (node.kind === "leaf")
+        return renderLeaf(node);
+    const boundary = boundaryFor(seed, partPath);
+    const out = [];
+    out.push(`Content-Type: multipart/${node.subtype}; boundary="${boundary}"`);
+    out.push("");
+    for (let i = 0; i < node.children.length; i++) {
+        const childPath = partPath === "0" ? String(i + 1) : `${partPath}.${i + 1}`;
+        out.push(`--${boundary}`);
+        out.push(renderNode(node.children[i], childPath, seed));
+    }
+    out.push(`--${boundary}--`);
+    out.push("");
+    return out.join("\r\n");
+};
+export const renderEml = (tree, opts) => {
+    const headers = [];
+    headers.push(`From: ${opts.from ?? "alice@example.org"}`);
+    headers.push(`To: ${opts.to ?? "bob@example.org"}`);
+    headers.push(`Subject: ${opts.subject ?? `property-${opts.seed}`}`);
+    headers.push("Date: Thu, 28 May 2026 09:00:00 +0000");
+    headers.push(`Message-Id: <${opts.messageId ?? `property-${opts.seed}@example.org`}>`);
+    headers.push("MIME-Version: 1.0");
+    if (tree.kind === "leaf") {
+        // Flat single-leaf message: leaf headers merge with the envelope.
+        const leafRendered = renderLeaf(tree);
+        // Drop the duplicate trailing newlines and merge.
+        return `${headers.join("\r\n")}\r\n${leafRendered}\r\n`;
+    }
+    const boundary = boundaryFor(opts.seed, "0");
+    const out = [];
+    out.push(...headers);
+    out.push(`Content-Type: multipart/${tree.subtype}; boundary="${boundary}"`);
+    out.push("");
+    for (let i = 0; i < tree.children.length; i++) {
+        const childPath = String(i + 1);
+        out.push(`--${boundary}`);
+        out.push(renderNode(tree.children[i], childPath, opts.seed));
+    }
+    out.push(`--${boundary}--`);
+    out.push("");
+    return out.join("\r\n");
+};

package/dist/test-helpers/test-store.d.ts

@@ -0,0 +1,69 @@
+import type { AccountItem, CreateMessageInput, CreateThreadMessageInput, MailboxItem, MailboxSpecialUseValue, MessageItem, ThreadMessageItem } from "@remit/data-ports";
+import type { StorageService } from "@remit/storage-service";
+import type { FakeImapServer } from "./fake-imap.js";
+export { failingQueue, type RecordedMessage, type RecordingQueue, recordingQueue, } from "@remit/data-ports/recording-queue";
+export declare const openStore: () => Promise<{
+    storage: () => StorageService;
+    brokenStorage: () => StorageService;
+    close: () => Promise<void>;
+    accountConfig: import("@remit/drizzle-service").AccountConfigRepo;
+    account: import("@remit/drizzle-service").AccountRepo;
+    accountSetting: import("@remit/drizzle-service").AccountSettingRepo;
+    address: import("@remit/drizzle-service").AddressRepo;
+    mailbox: import("@remit/drizzle-service").MailboxRepo;
+    mailboxSpecialUse: import("@remit/drizzle-service").MailboxSpecialUseRepo;
+    mailboxLock: import("@remit/drizzle-service").MailboxLockRepo;
+    message: import("@remit/drizzle-service").DrizzleMessageRepository;
+    messageFlag: import("@remit/drizzle-service").DrizzleMessageFlagRepository;
+    outboxMessage: import("@remit/drizzle-service").OutboxMessageRepo;
+    outboxAttachment: import("@remit/drizzle-service").OutboxAttachmentRepo;
+    threadMessage: import("@remit/drizzle-service").DrizzleThreadMessageRepository;
+    envelope: import("@remit/drizzle-service").DrizzleEnvelopeRepository;
+    accountExportRequest: import("@remit/drizzle-service").AccountExportRequestRepo;
+    configImport: import("@remit/drizzle-service").ConfigImportRepo;
+    quarantine: import("@remit/drizzle-service").QuarantineRepo;
+    syncWarning: import("@remit/drizzle-service").SyncWarningRepo;
+    organizeJobRequest: import("@remit/drizzle-service").OrganizeJobRequestRepo;
+    placementMove: import("@remit/drizzle-service").MessagePlacementMoveRepo;
+    flagPush: import("@remit/drizzle-service").MessageFlagPushRepo;
+    filter: import("@remit/drizzle-service").FilterRepo;
+    label: import("@remit/drizzle-service").LabelRepo;
+    messageLabel: import("@remit/drizzle-service").MessageLabelRepo;
+    senderSignerStanding: import("@remit/drizzle-service").SenderSignerStandingRepo;
+    calendarCollection: import("@remit/drizzle-service").CalendarCollectionRepo;
+    calendarObject: import("@remit/drizzle-service").CalendarObjectRepo;
+    calendarEventIndex: import("@remit/drizzle-service").CalendarEventIndexRepo;
+    calendarFeedToken: import("@remit/drizzle-service").CalendarFeedTokenRepo;
+    calendarSuggestion: import("@remit/drizzle-service").CalendarSuggestionRepo;
+    calendarStore: import("@remit/drizzle-service").DrizzleCalendarStore;
+}>;
+export type Store = Awaited<ReturnType<typeof openStore>>;
+export declare const seedAccount: (store: Store, overrides?: Partial<AccountItem>) => Promise<AccountItem>;
+export declare const seedMailbox: (store: Store, account: Pick<AccountItem, "accountId">, fullPath: string, options?: {
+    specialUse?: MailboxSpecialUseValue;
+    overrides?: Partial<MailboxItem>;
+}) => Promise<MailboxItem>;
+export interface SeededMessage {
+    message: MessageItem;
+    threadMessage: ThreadMessageItem;
+}
+export declare const seedMessage: (store: Store, account: Pick<AccountItem, "accountConfigId">, mailbox: Pick<MailboxItem, "mailboxId">, uid: number, overrides?: {
+    message?: Partial<CreateMessageInput>;
+    threadMessage?: Partial<CreateThreadMessageInput>;
+}) => Promise<SeededMessage>;
+export declare const silentLog: {
+    info: () => void;
+    warn: () => void;
+    error: () => void;
+    debug: () => void;
+};
+export declare const syncFolder: (store: Store, account: Pick<AccountItem, "accountId" | "accountConfigId">, mailbox: Pick<MailboxItem, "mailboxId">, imap: FakeImapServer) => Promise<string[]>;
+export declare const messageAtUid: (store: Store, mailbox: Pick<MailboxItem, "mailboxId">, uid: number) => Promise<MessageItem>;
+export declare const arriveAt: (store: Store, imap: FakeImapServer, account: Pick<AccountItem, "accountId" | "accountConfigId">, mailbox: Pick<MailboxItem, "mailboxId" | "fullPath">, raw: Buffer) => Promise<string>;
+export declare const storeBody: (store: Store, storage: StorageService, account: Pick<AccountItem, "accountId" | "accountConfigId">, messageId: string, raw: Buffer) => Promise<void>;
+/**
+ * Another writer landing between a service's read and its write: `action` runs,
+ * for real, the next time `method` is called on `target`, and the call then
+ * proceeds as normal.
+ */
+export declare const beforeNext: <T extends object, K extends keyof T>(target: T, method: K, action: () => Promise<unknown>) => void;

package/dist/test-helpers/test-store.js

@@ -0,0 +1,193 @@
+import { randomUUID } from "node:crypto";
+import { copyFileSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { AccountAuthType, ConnectionState } from "@remit/domain-enums";
+import { createSqliteRepositories, openSqliteDatabases, } from "@remit/drizzle-service";
+import { applyShippedMigrations } from "@remit/drizzle-service/test-sqlite";
+import { createFilesystemStorageService } from "@remit/storage-service/filesystem";
+import Database from "better-sqlite3";
+import { MessageSyncService } from "../message-sync.js";
+import { SyncWarningService } from "../sync-warning.js";
+export { failingQueue, recordingQueue, } from "@remit/data-ports/recording-queue";
+const UPLOAD_URLS = {
+    origin: "https://reader.test",
+    signingSecret: "test-signing-secret",
+};
+/**
+ * The store the app opens: the committed migrations applied to a file, then
+ * that file opened the way the app opens it — as the app, mail and search
+ * database at once — with every repo the app composes.
+ * Storage made from it lives in the same directory and goes with it.
+ */
+let migrated;
+const migratedTemplate = () => {
+    if (migrated)
+        return migrated;
+    const dir = mkdtempSync(join(tmpdir(), "mbx-template-"));
+    const filename = join(dir, "template.sqlite");
+    const migrating = new Database(filename);
+    migrating.pragma("synchronous = OFF");
+    applyShippedMigrations(migrating);
+    migrating.close();
+    process.once("exit", () => rmSync(dir, { recursive: true, force: true }));
+    migrated = filename;
+    return filename;
+};
+export const openStore = async () => {
+    const dir = mkdtempSync(join(tmpdir(), "mbx-store-"));
+    const filename = join(dir, "store.sqlite");
+    copyFileSync(migratedTemplate(), filename);
+    const { close, ...databases } = await openSqliteDatabases({
+        app: filename,
+        mail: filename,
+        search: filename,
+    });
+    let storages = 0;
+    return {
+        ...createSqliteRepositories(databases),
+        storage: () => createFilesystemStorageService(join(dir, `storage-${++storages}`), UPLOAD_URLS),
+        brokenStorage: () => {
+            const root = join(dir, `broken-${++storages}`);
+            writeFileSync(root, "");
+            return createFilesystemStorageService(root);
+        },
+        close: async () => {
+            await close();
+            rmSync(dir, { recursive: true, force: true });
+        },
+    };
+};
+export const seedAccount = async (store, overrides = {}) => {
+    const config = await store.accountConfig.create({
+        accountConfigId: overrides.accountConfigId,
+        userId: "user-1",
+        name: "Me",
+    });
+    return store.account.create({
+        username: "me@example.com",
+        email: "me@example.com",
+        authType: AccountAuthType.Password,
+        passwordHash: '{"ciphertext":"x"}',
+        imapHost: "imap.example.com",
+        imapPort: 993,
+        imapTls: true,
+        imapStartTls: false,
+        isActive: true,
+        connectionState: ConnectionState.Authenticated,
+        ...overrides,
+        accountConfigId: config.accountConfigId,
+    });
+};
+export const seedMailbox = async (store, account, fullPath, options = {}) => {
+    const created = await store.mailbox.create({
+        accountId: account.accountId,
+        namespacePrefix: "",
+        hierarchyDelimiter: "/",
+        fullPath,
+        uidValidity: 7,
+        uidNext: 1,
+        highestModseq: "0",
+        messageCount: 0,
+        unseenCount: 0,
+        deletedCount: 0,
+        totalSize: 0,
+        lastSyncUid: 0,
+        highWaterMarkUid: 0,
+        lastMessageSyncAt: 0,
+        ...(options.specialUse ? { specialUse: [options.specialUse] } : {}),
+        ...options.overrides,
+    });
+    if (created.outcome !== "Created") {
+        throw new Error(`${fullPath} already exists`);
+    }
+    if (options.specialUse) {
+        await store.mailboxSpecialUse.create(created.mailbox.mailboxId, options.specialUse);
+    }
+    return created.mailbox;
+};
+export const seedMessage = async (store, account, mailbox, uid, overrides = {}) => {
+    const messageId = overrides.message?.messageId ?? randomUUID();
+    const message = await store.message.create({
+        messageId,
+        mailboxId: mailbox.mailboxId,
+        uid,
+        sequenceNumber: uid,
+        rfc822Size: 100,
+        internalDate: 1_700_000_000_000 + uid,
+        envelopeId: randomUUID(),
+        rootBodyPartId: randomUUID(),
+        status: "active",
+        syncStatus: "synced",
+        ...overrides.message,
+    });
+    const threadMessage = await store.threadMessage.create({
+        accountConfigId: account.accountConfigId,
+        threadId: messageId,
+        messageId,
+        mailboxId: message.mailboxId,
+        uid: message.uid,
+        referenceOrder: 0,
+        internalDate: message.internalDate,
+        sentDate: message.internalDate,
+        isRead: false,
+        isDeleted: false,
+        hasAttachment: false,
+        hasStars: false,
+        ...overrides.threadMessage,
+    });
+    return { message, threadMessage };
+};
+export const silentLog = {
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+    debug: () => { },
+};
+export const syncFolder = async (store, account, mailbox, imap) => {
+    const connection = imap.connection();
+    const service = new MessageSyncService({ getConnection: () => connection, close: async () => { } }, store.mailbox, store.mailboxSpecialUse, store.message, store.envelope, store.address, store.threadMessage, new SyncWarningService(store.syncWarning), silentLog, store.flagPush, store.messageFlag);
+    const synced = [];
+    for (;;) {
+        const result = await service.syncMessages(mailbox.mailboxId, account.accountId, account.accountConfigId);
+        synced.push(...result.syncedMessageIds);
+        if (!result.hasMore)
+            return synced;
+    }
+};
+export const messageAtUid = async (store, mailbox, uid) => {
+    const found = (await store.message.listAllByMailbox(mailbox.mailboxId)).find((message) => message.uid === uid);
+    if (!found)
+        throw new Error(`no message at uid ${uid}`);
+    return found;
+};
+export const arriveAt = async (store, imap, account, mailbox, raw) => {
+    const uid = imap.deliver(mailbox.fullPath, raw);
+    await syncFolder(store, account, mailbox, imap);
+    return (await messageAtUid(store, mailbox, uid)).messageId;
+};
+export const storeBody = async (store, storage, account, messageId, raw) => {
+    const ref = await storage.storeMessageBody({
+        accountConfigId: account.accountConfigId,
+        accountId: account.accountId,
+        messageId,
+        content: raw,
+    });
+    await store.message.update(messageId, { bodyStorageKey: ref.uri });
+};
+/**
+ * Another writer landing between a service's read and its write: `action` runs,
+ * for real, the next time `method` is called on `target`, and the call then
+ * proceeds as normal.
+ */
+export const beforeNext = (target, method, action) => {
+    const original = target[method];
+    let pending = true;
+    target[method] = (async (...args) => {
+        if (pending) {
+            pending = false;
+            await action();
+        }
+        return original.apply(target, args);
+    });
+};

package/dist/text/normalizer.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Multilingual text normalizer for email processing.
+ *
+ * Uses franc for language detection, natural for stemming,
+ * and stopword for stopword removal.
+ */
+export type SupportedLanguage = "en" | "de" | "fr" | "es" | "it" | "nl" | "pt";
+export interface NormalizeOptions {
+    language?: SupportedLanguage;
+    stem?: boolean;
+    removeStopwords?: boolean;
+}
+export interface TextNormalizer {
+    detectLanguage(text: string): SupportedLanguage;
+    normalize(text: string, options?: NormalizeOptions): string;
+    tokenize(text: string): string[];
+    stem(word: string, language?: SupportedLanguage): string;
+    removeStopwords(words: string[], language?: SupportedLanguage): string[];
+}
+export declare const createTextNormalizer: () => TextNormalizer;