@remit/mailbox-service 0.0.111 → 0.0.113

package/dist/mailbox-sync.js

@@ -0,0 +1,490 @@
+/**
+ * Mailbox synchronization service
+ *
+ * Orchestrates syncing mailbox data from IMAP server to the data backend.
+ */
+import { ROLE_SPECIAL_USE, roleForFolderName, } from "@remit/data-ports/folder-role";
+import { MailboxCursorState, MailboxSyncStatus, NamespaceType, } from "@remit/domain-enums";
+import pMap from "p-map";
+import { isNoSelect, parseImapAttributes } from "./attribute-mapper.js";
+import { isCursorRebuildNeeded } from "./mailbox-cursor.js";
+import { isFolderMutationInFlight, isMailboxMutationInFlight, } from "./mailbox-presence.js";
+/**
+ * Compare two unordered special-use lists/sets for equality. Treats `undefined`
+ * and an empty array as equivalent (a mailbox with no flags).
+ */
+const areSpecialUseSetsEqual = (a, b) => {
+    const aArr = a ?? [];
+    const bArr = b ?? [];
+    if (aArr.length !== bArr.length)
+        return false;
+    const aSet = new Set(aArr);
+    for (const value of bArr) {
+        if (!aSet.has(value))
+            return false;
+    }
+    return true;
+};
+/**
+ * Service for synchronizing mailbox metadata between IMAP and the data backend.
+ */
+export class MailboxSyncService {
+    mailboxService;
+    specialUseService;
+    log;
+    // Required, with no no-op default: the lines below are the only record that a
+    // mailbox was created or destroyed, and a default would let the next call site
+    // lose them with no error and no failing test.
+    constructor(mailboxService, specialUseService, logger) {
+        this.mailboxService = mailboxService;
+        this.specialUseService = specialUseService;
+        this.log = logger;
+    }
+    /**
+     * Sync all mailboxes for an account from IMAP server
+     *
+     * @param account - Account info including accountId
+     * @param connection - Active IMAP connection
+     */
+    syncMailboxes = async (account, connection) => {
+        const result = {
+            created: 0,
+            updated: 0,
+            deleted: 0,
+        };
+        // Get existing mailboxes from database
+        const existingMailboxes = await this.getAllMailboxes(account.accountId);
+        const existingByPath = new Map(existingMailboxes.map((m) => [m.fullPath, m]));
+        // The paths a rename is on its way to (D14). Under D2 `fullPath` stays the
+        // path the server held when the intent was recorded, so between the server
+        // executing RENAME and the settle, LIST returns a path no row is keyed to
+        // — and the insert branch below has no state guard at all. Without this it
+        // inserts a second row under a fresh mailboxId and initial-syncs the
+        // folder's mail into it, leaving the original as a permanent phantom still
+        // holding that folder's messages, filters and role appointments. No unique
+        // index on (accountId, fullPath) exists to catch it; #386 adds one.
+        //
+        // `pending` only. A failed rename keeps its target so the UI can name what
+        // it was aiming at (T6), and nothing clears it until the user retries or
+        // dismisses — so honouring a `failed` row's claim would let one stuck
+        // folder block the sweep from ever discovering a real folder another
+        // client later creates at that path.
+        const claimedByPendingRename = new Set(existingMailboxes.flatMap((m) => m.syncStatus === MailboxSyncStatus.pending &&
+            m.pendingPath !== undefined
+            ? [m.pendingPath]
+            : []));
+        // Get namespaces and mailboxes from IMAP
+        const namespaces = await connection.getNamespaces();
+        const remoteMailboxes = await this.fetchAllMailboxes(connection, namespaces);
+        // Build a map of special-use designations claimed by mailboxes with IMAP attributes.
+        // Used to:
+        //  1. Skip duplicate folders (e.g., "Trash" vs "[Gmail]/Trash") at sync time.
+        //  2. Skip duplicate localized folders (e.g., "Sent" vs "Verzonden items") when one
+        //     of them carries the IMAP \Sent flag — issue #194.
+        const claimedSpecialUse = this.buildSpecialUseMap(remoteMailboxes);
+        // Track which paths we've seen from remote
+        const seenPaths = new Set();
+        // Process each remote mailbox (concurrency 3 for IMAP pipelining)
+        await pMap(remoteMailboxes, async (mailboxInfo) => {
+            // Skip non-selectable mailboxes (container folders that can't hold messages)
+            if (isNoSelect(mailboxInfo.attributes)) {
+                // Mark as seen so we don't try to delete again in cleanup loop
+                seenPaths.add(mailboxInfo.fullPath);
+                // If this mailbox exists in DB, delete it
+                const existing = existingByPath.get(mailboxInfo.fullPath);
+                // A folder mid-create can transiently LIST as `\Noselect`, and
+                // deleting the row then races the create exactly as #290
+                // documented. The state check goes before the delete, through the
+                // same predicate the rest of the sweep asks.
+                if (existing && !isFolderMutationInFlight(existing)) {
+                    // The duplicate-special-use branch below clears the special-use
+                    // entries too; this one skipped them, orphaning a row per
+                    // deleted mailbox.
+                    await this.specialUseService.deleteByMailboxId(existing.mailboxId);
+                    await this.mailboxService.delete(account.accountId, existing.mailboxId);
+                    this.log.info({
+                        mailboxId: existing.mailboxId,
+                        fullPath: existing.fullPath,
+                        reason: "non-selectable",
+                    }, "Deleted mailbox");
+                    result.deleted++;
+                }
+                return;
+            }
+            // Skip duplicate special-use folders (e.g., "Trash" when "[Gmail]/Trash" exists)
+            if (this.isDuplicateSpecialUse(mailboxInfo, claimedSpecialUse)) {
+                seenPaths.add(mailboxInfo.fullPath);
+                const existing = existingByPath.get(mailboxInfo.fullPath);
+                if (existing && !isFolderMutationInFlight(existing)) {
+                    await this.specialUseService.deleteByMailboxId(existing.mailboxId);
+                    await this.mailboxService.delete(account.accountId, existing.mailboxId);
+                    this.log.info({
+                        mailboxId: existing.mailboxId,
+                        fullPath: existing.fullPath,
+                        reason: "duplicate-special-use",
+                    }, "Deleted mailbox");
+                    result.deleted++;
+                }
+                return;
+            }
+            seenPaths.add(mailboxInfo.fullPath);
+            const existing = existingByPath.get(mailboxInfo.fullPath);
+            if (existing) {
+                // A folder at either end of its lifecycle is left alone: the worker
+                // that establishes or removes it writes its own identity back, and
+                // reading its status meanwhile is work whose only possible outcome is
+                // a failure that fails this whole account's fan-out with it.
+                if (isFolderMutationInFlight(existing)) {
+                    return;
+                }
+                // The folder set can change under this sweep. A delete that lands
+                // between the LIST above and this mailbox's STATUS fails on the
+                // server or on the row, and that would abort the enumeration of every
+                // other folder and the SYNC_MESSAGES fan-out behind it — on a
+                // per-account FIFO queue, for the whole visibility window (issue
+                // #339). One folder leaving is not a failed account sync. Anything
+                // else still propagates.
+                const updated = await this.updateMailbox(account.accountId, existing, mailboxInfo, connection).catch(async (error) => {
+                    // The read only classifies the failure in hand; one that cannot
+                    // answer must not replace it.
+                    const gone = await isMailboxMutationInFlight(this.mailboxService, account.accountId, existing.mailboxId).catch(() => false);
+                    if (gone)
+                        return null;
+                    throw error;
+                });
+                if (updated) {
+                    result.updated++;
+                }
+            }
+            else if (!claimedByPendingRename.has(mailboxInfo.fullPath)) {
+                const created = await this.createMailbox(account.accountId, mailboxInfo, namespaces, connection);
+                if (created)
+                    result.created++;
+            }
+        }, { concurrency: 3 });
+        // Handle deleted mailboxes (exist in DB but not on server)
+        for (const existing of existingMailboxes) {
+            if (seenPaths.has(existing.fullPath))
+                continue;
+            // A row with a mutation in flight is a folder whose absence from the
+            // LIST is expected, not a server-side deletion. Deleting it races the
+            // worker: the row vanishes, then MAILBOX_CREATE fails with NotFoundError
+            // trying to mark it synced, and — sharing this account's mailboxes FIFO
+            // group — that un-acked failure stalls every later mailbox sync for the
+            // queue's whole visibility window (#290).
+            //
+            // `deleting` is here for a second reason. That window is exactly when a
+            // delete has landed on the server and the worker has not written back,
+            // so hard-deleting the row removes it under the client holding its id —
+            // the "Mailbox not found: <old id>" of #333 — and removes it without the
+            // folder's mail, which is the worker's job (D8). Leave both to the flow
+            // that owns them.
+            if (isFolderMutationInFlight(existing))
+                continue;
+            await this.mailboxService.delete(account.accountId, existing.mailboxId);
+            this.log.info({
+                mailboxId: existing.mailboxId,
+                fullPath: existing.fullPath,
+                reason: "not-on-server",
+            }, "Deleted mailbox");
+            result.deleted++;
+        }
+        return result;
+    };
+    /**
+     * Sync metadata for a specific mailbox
+     *
+     * Opens the mailbox to get current UID validity, counts, etc.
+     */
+    syncMailboxMetadata = async (accountId, mailboxId, connection) => {
+        const mailbox = await this.mailboxService.get(accountId, mailboxId);
+        const boxStatus = await connection.openBox(mailbox.fullPath, true);
+        // See `updateMailbox` above for why this trips (not skips) on a
+        // UIDVALIDITY change instead of silently overwriting the stored value.
+        const uidValidityChanged = mailbox.uidValidity !== boxStatus.uidvalidity;
+        const cursorTrip = uidValidityChanged && !isCursorRebuildNeeded(mailbox.cursorState)
+            ? { cursorState: MailboxCursorState.cursor_invalid }
+            : {};
+        return this.mailboxService
+            .update(accountId, mailboxId, {
+            uidValidity: boxStatus.uidvalidity,
+            uidNext: boxStatus.uidnext,
+            messageCount: boxStatus.messages.total,
+            ...cursorTrip,
+        })
+            .finally(() => connection.closeBox(false));
+    };
+    /**
+     * Get all mailboxes for an account, handling pagination
+     */
+    getAllMailboxes = async (accountId) => {
+        const allMailboxes = [];
+        let continuationToken;
+        do {
+            const result = await this.mailboxService.listByAccount(accountId, {
+                continuationToken,
+            });
+            allMailboxes.push(...result.items);
+            continuationToken = result.continuationToken;
+        } while (continuationToken);
+        return allMailboxes;
+    };
+    /**
+     * Fetch all mailboxes from IMAP server across all namespaces.
+     * Uses listMailboxes() to preserve original paths from the server.
+     */
+    fetchAllMailboxes = async (connection, namespaces) => {
+        // Flatten all namespaces with their types
+        const allNamespaces = [
+            ...namespaces.personal.map((ns) => ({
+                type: NamespaceType.Personal,
+                prefix: ns.prefix || "",
+            })),
+            ...namespaces.other.map((ns) => ({
+                type: NamespaceType.OtherUsers,
+                prefix: ns.prefix || "",
+            })),
+            ...namespaces.shared.map((ns) => ({
+                type: NamespaceType.Shared,
+                prefix: ns.prefix || "",
+            })),
+        ];
+        // Fetch mailboxes for each namespace and flatten
+        const nestedResults = await Promise.all(allNamespaces.map(async ({ type, prefix }) => {
+            const mailboxes = await connection.listMailboxes(prefix);
+            return mailboxes.map((mailbox) => ({
+                ...mailbox,
+                namespaceType: type,
+                namespacePrefix: prefix,
+            }));
+        }));
+        const results = nestedResults.flat();
+        // INBOX is implicit in IMAP and may not be returned by LIST commands
+        const hasInbox = results.some((m) => m.fullPath.toUpperCase() === "INBOX");
+        if (!hasInbox) {
+            const nsDelimiter = namespaces.personal[0]?.delimiter;
+            const delimiter = typeof nsDelimiter === "string" ? nsDelimiter : "/";
+            results.unshift({
+                fullPath: "INBOX",
+                name: "INBOX",
+                delimiter,
+                attributes: [],
+                parentPath: null,
+                namespaceType: NamespaceType.Personal,
+                namespacePrefix: "",
+            });
+        }
+        return results;
+    };
+    /**
+     * Create a new mailbox in the database
+     */
+    createMailbox = async (accountId, mailboxInfo, _namespaces, connection) => {
+        // Fetch mailbox status using STATUS command (doesn't require SELECT/EXAMINE)
+        // This gets us message counts including unseen without opening the mailbox
+        const status = await connection.getMailboxStatus(mailboxInfo.fullPath);
+        // Parse special-use attributes (RFC 6154) up front so the row stores a
+        // denormalized copy. Frontends list mailboxes by account; threading a join
+        // through MailboxSpecialUseEntry per row would be O(N) extra round-trips.
+        const parsed = parseImapAttributes(mailboxInfo.attributes);
+        const input = {
+            accountId,
+            namespaceType: mailboxInfo.namespaceType,
+            namespacePrefix: mailboxInfo.namespacePrefix,
+            hierarchyDelimiter: mailboxInfo.delimiter,
+            fullPath: mailboxInfo.fullPath,
+            uidValidity: status.uidValidity,
+            uidNext: status.uidNext,
+            // The message-sync cursor, not a status projection: it records how
+            // far THIS mailbox's messages have been applied, and nothing has
+            // been. Seeding it from the server's current HIGHESTMODSEQ would
+            // declare an unsynced folder already caught up and skip every
+            // message in it. Message sync seeds it once it has enumerated the
+            // folder.
+            highestModseq: "0",
+            messageCount: status.messages,
+            unseenCount: status.unseen,
+            deletedCount: status.deletedCount,
+            totalSize: 0,
+            lastSyncUid: 0,
+            highWaterMarkUid: 0,
+            lastMessageSyncAt: 0,
+            specialUse: parsed.specialUse.length > 0 ? parsed.specialUse : undefined,
+            // A folder the server just told us about is confirmed. The column
+            // defaults to this, so the row is right either way; the field is total
+            // now (D1) and the insert says what it means.
+            syncStatus: MailboxSyncStatus.synced,
+            // parentMailboxId would need to be resolved from parentPath
+        };
+        const created = await this.mailboxService.create(input);
+        if (created.outcome === "PathTaken") {
+            this.log.error({ accountId, fullPath: mailboxInfo.fullPath }, "Sweep found no row for a folder path the account already holds");
+            return null;
+        }
+        const { mailbox } = created;
+        // Keep the MailboxSpecialUseEntry table in sync — every backend and worker
+        // special-folder lookup reads it through MailboxSpecialUseRepo. Denormalized
+        // copy on Mailbox is the read-side optimization, the entries remain the
+        // authoritative join source for cross-mailbox lookups.
+        if (parsed.specialUse.length > 0) {
+            await this.specialUseService.createMany(mailbox.mailboxId, parsed.specialUse);
+            this.log.info({
+                mailboxId: mailbox.mailboxId,
+                fullPath: mailboxInfo.fullPath,
+                specialUse: parsed.specialUse,
+            }, "Created mailbox");
+        }
+        else {
+            this.log.info({ mailboxId: mailbox.mailboxId, fullPath: mailboxInfo.fullPath }, "Created mailbox");
+        }
+        return mailbox;
+    };
+    /**
+     * Update an existing mailbox with fresh data.
+     * Skips DB write if nothing has changed.
+     *
+     * @returns The updated mailbox, or null if skipped due to no changes
+     */
+    updateMailbox = async (accountId, existing, mailboxInfo, connection) => {
+        // Fetch mailbox status using STATUS command (doesn't require SELECT/EXAMINE)
+        const status = await connection.getMailboxStatus(mailboxInfo.fullPath);
+        const parsed = parseImapAttributes(mailboxInfo.attributes);
+        const specialUseChanged = !areSpecialUseSetsEqual(existing.specialUse, parsed.specialUse);
+        // UIDVALIDITY detection (#1272): this STATUS-based sweep persists a fresh
+        // uidValidity below regardless (harmless — it never touches a stored UID),
+        // but if the server's value disagrees with what's stored and the mailbox
+        // was still `normal`, the axis just changed. Trip the cursor here so the
+        // message-sync/flag-push/move/body-fetch paths pause outbound IMAP until
+        // the rebuild resolves it, instead of silently overwriting the old value
+        // and erasing the only evidence a bump happened.
+        const uidValidityChanged = existing.uidValidity !== status.uidValidity;
+        const cursorTrip = uidValidityChanged && !isCursorRebuildNeeded(existing.cursorState)
+            ? { cursorState: MailboxCursorState.cursor_invalid }
+            : {};
+        // Check if anything actually changed
+        const hasChanges = existing.uidNext !== status.uidNext ||
+            existing.uidValidity !== status.uidValidity ||
+            existing.messageCount !== status.messages ||
+            existing.unseenCount !== status.unseen ||
+            existing.deletedCount !== status.deletedCount ||
+            specialUseChanged;
+        // Sync special-use attributes (handles migration of existing mailboxes)
+        await this.syncSpecialUseAttributes(existing.mailboxId, mailboxInfo);
+        if (!hasChanges) {
+            return null;
+        }
+        // Debug: log what changed
+        const changes = [];
+        if (existing.uidNext !== status.uidNext)
+            changes.push(`uidNext: ${existing.uidNext} -> ${status.uidNext}`);
+        if (existing.uidValidity !== status.uidValidity)
+            changes.push(`uidValidity: ${existing.uidValidity} -> ${status.uidValidity}`);
+        if (existing.messageCount !== status.messages)
+            changes.push(`messageCount: ${existing.messageCount} -> ${status.messages}`);
+        if (existing.unseenCount !== status.unseen)
+            changes.push(`unseenCount: ${existing.unseenCount} -> ${status.unseen}`);
+        if (existing.deletedCount !== status.deletedCount)
+            changes.push(`deletedCount: ${existing.deletedCount} -> ${status.deletedCount}`);
+        if (specialUseChanged)
+            changes.push(`specialUse: [${(existing.specialUse ?? []).join(",")}] -> [${parsed.specialUse.join(",")}]`);
+        this.log.info({
+            mailboxId: existing.mailboxId,
+            fullPath: mailboxInfo.fullPath,
+            changes,
+        }, "Updating mailbox");
+        // Update mailbox with fresh status. ElectroDB rejects empty sets, so we
+        // pass undefined when no flags are present rather than [].
+        return this.mailboxService.update(accountId, existing.mailboxId, {
+            hierarchyDelimiter: mailboxInfo.delimiter,
+            uidValidity: status.uidValidity,
+            uidNext: status.uidNext,
+            // `highestModseq` is deliberately absent: it is message sync's
+            // cursor over this mailbox's own applied changes, and overwriting it
+            // with the server's current value here would step it over every
+            // change message sync had not yet applied.
+            messageCount: status.messages,
+            unseenCount: status.unseen,
+            deletedCount: status.deletedCount,
+            specialUse: parsed.specialUse.length > 0 ? parsed.specialUse : undefined,
+            ...cursorTrip,
+        });
+    };
+    /**
+     * Sync special-use attributes for a mailbox.
+     * Creates entries if they don't exist, updates if changed.
+     */
+    syncSpecialUseAttributes = async (mailboxId, mailboxInfo) => {
+        const parsed = parseImapAttributes(mailboxInfo.attributes);
+        const existingEntries = await this.specialUseService.listByMailboxId(mailboxId);
+        const existingSpecialUses = new Set(existingEntries.map((e) => e.specialUse));
+        const newSpecialUses = new Set(parsed.specialUse);
+        // Check if sets are equal
+        const areEqual = existingSpecialUses.size === newSpecialUses.size &&
+            [...existingSpecialUses].every((use) => newSpecialUses.has(use));
+        if (areEqual)
+            return;
+        // Delete and recreate (simpler than diff)
+        if (existingEntries.length > 0) {
+            await this.specialUseService.deleteByMailboxId(mailboxId);
+        }
+        if (parsed.specialUse.length > 0) {
+            await this.specialUseService.createMany(mailboxId, parsed.specialUse);
+            this.log.debug({ fullPath: mailboxInfo.fullPath, specialUse: parsed.specialUse }, "Synced special-use");
+        }
+    };
+    /**
+     * Build a map of special-use designations to mailbox paths.
+     * Only includes mailboxes that have the IMAP special-use attribute.
+     */
+    buildSpecialUseMap = (mailboxes) => {
+        const map = new Map();
+        for (const mailbox of mailboxes) {
+            const parsed = parseImapAttributes(mailbox.attributes);
+            for (const specialUse of parsed.specialUse) {
+                // First mailbox with this special-use wins (usually the canonical one)
+                if (!map.has(specialUse)) {
+                    map.set(specialUse, mailbox.fullPath);
+                }
+            }
+        }
+        return map;
+    };
+    /**
+     * Check if a mailbox is a duplicate special-use folder.
+     * A folder is considered duplicate if:
+     * 1. Its name matches a common special-use folder name (e.g., "Trash")
+     * 2. It does NOT have the IMAP special-use attribute
+     * 3. Another folder already claimed that special-use designation
+     */
+    isDuplicateSpecialUse = (mailbox, claimedSpecialUse) => {
+        // Get the folder name (last segment of path)
+        const folderName = mailbox.fullPath.split(mailbox.delimiter).pop() ?? "";
+        const normalizedName = folderName.toLowerCase();
+        // Check if this folder name is a conventional name for a role
+        const role = roleForFolderName(normalizedName);
+        if (!role) {
+            return false; // Not a special-use folder name
+        }
+        const expectedSpecialUse = ROLE_SPECIAL_USE[role];
+        if (!expectedSpecialUse) {
+            return false; // The role has no SPECIAL-USE flag to be a duplicate of
+        }
+        // Check if this mailbox has the special-use attribute
+        const parsed = parseImapAttributes(mailbox.attributes);
+        if (parsed.specialUse.some((use) => use === expectedSpecialUse)) {
+            return false; // This IS the canonical folder
+        }
+        // Check if another folder already claimed this special-use
+        const claimed = [...claimedSpecialUse].find(([specialUse]) => specialUse === expectedSpecialUse);
+        if (!claimed) {
+            return false; // No other folder has this special-use
+        }
+        // This is a duplicate - another folder has the attribute
+        this.log.debug({
+            fullPath: mailbox.fullPath,
+            claimedPath: claimed[1],
+            specialUse: expectedSpecialUse,
+        }, "Skipping duplicate folder");
+        return true;
+    };
+}

package/dist/mailbox-upstream.d.ts

@@ -0,0 +1,38 @@
+/** The folder is not on the server: a delete has nothing left to do. */
+export declare const isMailboxAbsentUpstream: (error: unknown) => boolean;
+/** The folder is already on the server: a create has nothing left to do. */
+export declare const isMailboxPresentUpstream: (error: unknown) => boolean;
+export declare const isMailboxRefusedUpstream: (error: unknown) => boolean;
+export declare const upstreamFailureReason: (error: unknown) => string;
+/**
+ * Something after the server RENAME failed — the local settle, not the
+ * mutation. The rename landed, so this is never a refused rename: marking the
+ * rows `failed` would offer a retry of work the server has already done, and
+ * `fullPath` would go on naming a path the server no longer holds.
+ *
+ * It is rethrown rather than swallowed. The rows are still `pending` with their
+ * targets recorded, so the redelivery's guard passes and the settle runs again;
+ * swallowing it would ack the message and leave the subtree `pending` forever,
+ * skipped by message sync with no route out.
+ */
+/**
+ * The folder a rename was to move is confirmed gone: the server refused the
+ * RENAME as non-existent, and its own listing holds neither the path being left
+ * nor the path being aimed at.
+ *
+ * It is a distinct kind because it is the only answer that may remove a folder
+ * and its mail. Re-reading the server's response code at the call site would
+ * make every unclassifiable `NONEXISTENT` — a listing that could not be read, a
+ * path the comparison normalized wrongly — destroy the user's mail; here the
+ * decision is made once, where the evidence is.
+ */
+export declare class FolderGoneUpstreamError extends Error {
+    name: string;
+    readonly cause: unknown;
+    constructor(mailboxId: string, oldPath: string, cause: unknown);
+}
+export declare class FolderRenameSettleError extends Error {
+    name: string;
+    readonly cause: unknown;
+    constructor(mailboxId: string, confirmedPath: string, cause: unknown);
+}

package/{src/mailbox-upstream.ts → dist/mailbox-upstream.js}

@@ -1,9 +1,9 @@
-const stringField = (value: unknown, key: string): string => {
-	if (!(value instanceof Object)) return "";
-	const field = Reflect.get(value, key);
-	return typeof field === "string" ? field : "";
+const stringField = (value, key) => {
+    if (!(value instanceof Object))
+        return "";
+    const field = Reflect.get(value, key);
+    return typeof field === "string" ? field : "";
 };
-
 /**
  * Read a tagged-NO outcome out of an IMAP failure.
  *
@@ -19,35 +19,32 @@ const stringField = (value: unknown, key: string): string => {
  * with the code on the error, which is why matching the message alone never
  * caught a real Dovecot answer.
  */
-const saidByServer = (error: Error): string =>
-	`${error.message} ${stringField(error, "responseText")}`;
-
+const saidByServer = (error) => `${error.message} ${stringField(error, "responseText")}`;
 /** The folder is not on the server: a delete has nothing left to do. */
-export const isMailboxAbsentUpstream = (error: unknown): boolean => {
-	if (!(error instanceof Error)) return false;
-	if (stringField(error, "serverResponseCode") === "NONEXISTENT") return true;
-	return /not found|does ?n.?t exist/i.test(saidByServer(error));
+export const isMailboxAbsentUpstream = (error) => {
+    if (!(error instanceof Error))
+        return false;
+    if (stringField(error, "serverResponseCode") === "NONEXISTENT")
+        return true;
+    return /not found|does ?n.?t exist/i.test(saidByServer(error));
 };
-
 /** The folder is already on the server: a create has nothing left to do. */
-export const isMailboxPresentUpstream = (error: unknown): boolean => {
-	if (!(error instanceof Error)) return false;
-	if (stringField(error, "serverResponseCode") === "ALREADYEXISTS") return true;
-	return /already exists/i.test(saidByServer(error));
+export const isMailboxPresentUpstream = (error) => {
+    if (!(error instanceof Error))
+        return false;
+    if (stringField(error, "serverResponseCode") === "ALREADYEXISTS")
+        return true;
+    return /already exists/i.test(saidByServer(error));
 };
-
 const PERMANENT_REFUSALS = new Set(["NOPERM", "CANNOT"]);
-
-export const isMailboxRefusedUpstream = (error: unknown): boolean =>
-	error instanceof Error &&
-	PERMANENT_REFUSALS.has(stringField(error, "serverResponseCode"));
-
-export const upstreamFailureReason = (error: unknown): string => {
-	const serverText = stringField(error, "responseText").trim();
-	if (serverText.length > 0) return serverText;
-	return error instanceof Error ? error.message : String(error);
+export const isMailboxRefusedUpstream = (error) => error instanceof Error &&
+    PERMANENT_REFUSALS.has(stringField(error, "serverResponseCode"));
+export const upstreamFailureReason = (error) => {
+    const serverText = stringField(error, "responseText").trim();
+    if (serverText.length > 0)
+        return serverText;
+    return error instanceof Error ? error.message : String(error);
 };
-
 /**
  * Something after the server RENAME failed — the local settle, not the
  * mutation. The rename landed, so this is never a refused rename: marking the
@@ -71,25 +68,18 @@ export const upstreamFailureReason = (error: unknown): string => {
  * decision is made once, where the evidence is.
  */
 export class FolderGoneUpstreamError extends Error {
-	name = "FolderGoneUpstreamError";
-	readonly cause: unknown;
-
-	constructor(mailboxId: string, oldPath: string, cause: unknown) {
-		super(
-			`Folder ${mailboxId} is gone from the mail server: neither "${oldPath}" nor its rename target is listed`,
-		);
-		this.cause = cause;
-	}
+    name = "FolderGoneUpstreamError";
+    cause;
+    constructor(mailboxId, oldPath, cause) {
+        super(`Folder ${mailboxId} is gone from the mail server: neither "${oldPath}" nor its rename target is listed`);
+        this.cause = cause;
+    }
 }
-
 export class FolderRenameSettleError extends Error {
-	name = "FolderRenameSettleError";
-	readonly cause: unknown;
-
-	constructor(mailboxId: string, confirmedPath: string, cause: unknown) {
-		super(
-			`Folder ${mailboxId} was renamed to "${confirmedPath}" but the local settle did not finish`,
-		);
-		this.cause = cause;
-	}
+    name = "FolderRenameSettleError";
+    cause;
+    constructor(mailboxId, confirmedPath, cause) {
+        super(`Folder ${mailboxId} was renamed to "${confirmedPath}" but the local settle did not finish`);
+        this.cause = cause;
+    }
 }