imapflow 2.0.6 → 2.0.8

package/dist/cjs/jp-decoder.js

@@ -37,7 +37,7 @@ class JPDecoder extends node_stream_1.Transform {
             chunk = Buffer.from(chunk, encoding);
         }
         if (this.chunklen + chunk.length > this.maxBytes) {
-            chunk = chunk.slice(0, Math.max(0, this.maxBytes - this.chunklen));
+            chunk = chunk.subarray(0, Math.max(0, this.maxBytes - this.chunklen));
         }
         if (chunk.length) {
             this.chunks.push(chunk);

package/dist/cjs/package-info.d.ts

@@ -1,3 +1,3 @@
 export declare const name = "imapflow";
-export declare const version = "2.0.6";
+export declare const version = "2.0.8";
 export declare const homepage = "https://imapflow.com/";

package/dist/cjs/package-info.js

@@ -2,6 +2,6 @@
 // Generated by scripts/build.js from package.json. Do not edit by hand.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.homepage = exports.version = exports.name = void 0;
-exports.name = 'imapflow';
-exports.version = '2.0.6';
-exports.homepage = 'https://imapflow.com/';
+exports.name = "imapflow";
+exports.version = "2.0.8";
+exports.homepage = "https://imapflow.com/";

package/dist/cjs/search-compiler.js

@@ -406,21 +406,14 @@ const searchCompiler = (connection, query) => {
                          * @returns Binary tree structure
                          */
                         let genOrTree = (list) => {
-                            let group = false;
                             let groups = [];
                             // Group items in pairs
-                            list.forEach((entry, i) => {
-                                if (i % 2 === 0) {
-                                    group = [entry];
-                                }
-                                else {
-                                    group.push(entry);
-                                    groups.push(group);
-                                    group = false;
-                                }
-                            });
+                            for (let i = 0; i + 1 < list.length; i += 2) {
+                                groups.push([list[i], list[i + 1]]);
+                            }
                             // Handle odd number of items
-                            if (group && group.length) {
+                            if (list.length % 2) {
+                                let group = [list[list.length - 1]];
                                 while (group.length === 1 && Array.isArray(group[0])) {
                                     group = group[0];
                                 }

package/dist/cjs/tools.d.ts

@@ -2,7 +2,7 @@ import type { Transform } from 'node:stream';
 import type { ImapFlow } from './imap-flow.js';
 import type { ConnectionErrorSite, ImapFlowError } from './errors.js';
 import type { ImapAttributeList, ImapAttributeNode, ImapResponse } from './handler/types.js';
-import type { FetchMessageObject, ListResponse, ListTreeResponse, MailboxObject, MessageEnvelopeObject, MessageStructureObject, StatusQuery } from './types.js';
+import type { FetchMessageObject, ListResponse, ListTreeResponse, MailboxObject, MessageEnvelopeObject, MessageStructureObject, ImapFlowEvents, StatusQuery } from './types.js';
 export { AuthenticationFailure } from './errors.js';
 export declare const EXPANDED_RANGE_LIMIT = 16777216;
 export declare const MAX_UINT32_DIGITS = 10;
@@ -80,6 +80,13 @@ export declare function guardedPromise<T>(executor: (resolve: (value: T | Promis
  * @returns Rejected promise, with its rejection already observed
  */
 export declare function guardedReject(error: Error): Promise<never>;
+/**
+ * Clears a timer that may already have been dropped. `clearTimeout()` accepts undefined but not
+ * null, and the connection nulls its timer fields once cleared, so every site clears through here.
+ *
+ * @param timer - Timer handle returned by setTimeout, or null/undefined when none is armed
+ */
+export declare function clearTimer(timer: NodeJS.Timeout | null | undefined): void;
 /**
  * Detaches a background timer from the event loop, so it cannot keep the process alive on its
  * own. Applied to every background timer (auto-IDLE, IDLE restart, fallback polling, throttle
@@ -89,13 +96,6 @@ export declare function guardedReject(error: Error): Promise<never>;
  * @param timer - Timer handle returned by setTimeout
  * @returns The same timer handle
  */
-/**
- * Clears a timer that may already have been dropped. `clearTimeout()` accepts undefined but not
- * null, and the connection nulls its timer fields once cleared, so every site clears through here.
- *
- * @param timer - Timer handle returned by setTimeout, or null/undefined when none is armed
- */
-export declare function clearTimer(timer: NodeJS.Timeout | null | undefined): void;
 export declare function unrefTimer<T extends NodeJS.Timeout | null | undefined>(timer: T): T;
 /**
  * Logs a failure from background connection work at the level its cause deserves.
@@ -200,6 +200,25 @@ export declare function updateCapabilities(list: ImapAttributeList | null | unde
  * @returns Uppercase status code string, or false if not found
  */
 export declare function getStatusCode(response: ImapResponse | string | false | undefined): string | false;
+/**
+ * Emits a state-change event from inside the command pipeline. A listener that throws must not
+ * abort the code that emitted it: select() emits before it releases the response, so the throw
+ * would leave the reader loop waiting forever, and close() would never get to emit 'close'. The
+ * error is logged instead, the same contract untagged handlers and the 'response' event get.
+ *
+ * @param connection - IMAP connection instance
+ * @param event - Event name
+ * @param args - Event arguments
+ */
+export declare function emitSafe<K extends keyof ImapFlowEvents>(connection: ImapFlow, event: K, ...args: ImapFlowEvents[K]): void;
+/**
+ * Collects the values of the TEXT tokens of a parsed response (the human-readable
+ * part of a status response, a greeting or a BYE).
+ *
+ * @param attributes - Attributes of a parsed IMAP response
+ * @returns Values of the TEXT tokens, in order
+ */
+export declare function getTextValues(attributes: ImapAttributeList | undefined): string[];
 /**
  * Compiles an IMAP response object back into a human-readable string.
  *
@@ -214,6 +233,28 @@ export declare function getErrorText(response: ImapResponse | string | false | u
  * @returns The enhanced error with `serverResponseCode` and string `response`
  */
 export declare function enhanceCommandError(err: ImapFlowError): Promise<ImapFlowError>;
+/**
+ * Enhances a failed command's error (see enhanceCommandError()) and logs it, the shared first
+ * step of every command's failure path. The caller decides whether to throw or return.
+ *
+ * @param connection - IMAP connection instance
+ * @param err - The command error
+ */
+export declare function reportCommandError(connection: ImapFlow, err: ImapFlowError): Promise<void>;
+/**
+ * Whether the session is authenticated, that is in the AUTHENTICATED or SELECTED state, which
+ * every mailbox-level command requires.
+ *
+ * @param connection - IMAP connection instance
+ */
+export declare function isAuthenticatedState(connection: ImapFlow): boolean;
+/**
+ * Returns the selected mailbox, or false when the connection is not in the SELECTED state.
+ * Message-level commands use it as their precondition, which also narrows the mailbox type.
+ *
+ * @param connection - IMAP connection instance
+ */
+export declare function getSelectedMailbox(connection: ImapFlow): MailboxObject | false;
 /**
  * Converts a flat list of mailbox folders into a tree structure.
  *
@@ -305,14 +346,14 @@ export declare function toValidDate(value: unknown): Date | null;
  * @param value - Date to format
  * @returns Formatted date string, or undefined if invalid
  */
-export declare function formatDate(value: Date | string | null | undefined): string | undefined;
+export declare function formatDate(value: unknown): string | undefined;
 /**
  * Formats a date value into IMAP date-time format (DD-Mon-YYYY HH:MM:SS +0000).
  *
  * @param value - Date to format
  * @returns Formatted date-time string, or undefined if invalid
  */
-export declare function formatDateTime(value: Date | string | null | undefined): string | undefined;
+export declare function formatDateTime(value: unknown): string | undefined;
 /**
  * Normalizes a flag string. Returns false for non-settable flags (e.g. \Recent),
  * and capitalizes system flags properly.

package/dist/cjs/tools.js

@@ -21,8 +21,13 @@ exports.normalizePath = normalizePath;
 exports.comparePaths = comparePaths;
 exports.updateCapabilities = updateCapabilities;
 exports.getStatusCode = getStatusCode;
+exports.emitSafe = emitSafe;
+exports.getTextValues = getTextValues;
 exports.getErrorText = getErrorText;
 exports.enhanceCommandError = enhanceCommandError;
+exports.reportCommandError = reportCommandError;
+exports.isAuthenticatedState = isAuthenticatedState;
+exports.getSelectedMailbox = getSelectedMailbox;
 exports.getFolderTree = getFolderTree;
 exports.getFlagColor = getFlagColor;
 exports.getColorFlags = getColorFlags;
@@ -208,15 +213,6 @@ function guardedReject(error) {
     promise.catch(exports.noop);
     return promise;
 }
-/**
- * Detaches a background timer from the event loop, so it cannot keep the process alive on its
- * own. Applied to every background timer (auto-IDLE, IDLE restart, fallback polling, throttle
- * back-off, held-lock diagnostics); connection and greeting deadlines are deliberately left
- * attached, because a caller is waiting for connect() to settle.
- *
- * @param timer - Timer handle returned by setTimeout
- * @returns The same timer handle
- */
 /**
  * Clears a timer that may already have been dropped. `clearTimeout()` accepts undefined but not
  * null, and the connection nulls its timer fields once cleared, so every site clears through here.
@@ -228,6 +224,15 @@ function clearTimer(timer) {
         clearTimeout(timer);
     }
 }
+/**
+ * Detaches a background timer from the event loop, so it cannot keep the process alive on its
+ * own. Applied to every background timer (auto-IDLE, IDLE restart, fallback polling, throttle
+ * back-off, held-lock diagnostics); connection and greeting deadlines are deliberately left
+ * attached, because a caller is waiting for connect() to settle.
+ *
+ * @param timer - Timer handle returned by setTimeout
+ * @returns The same timer handle
+ */
 function unrefTimer(timer) {
     /* c8 ignore next 3 */ // node timers always expose unref(); the guard covers replaced globals in tests
     if (timer && typeof timer.unref === 'function') {
@@ -443,7 +448,7 @@ function updateCapabilities(list) {
             }
             if (capability.startsWith('APPENDLIMIT=')) {
                 let splitPos = capability.indexOf('=');
-                map.set('APPENDLIMIT', parseUintValue(capability.substr(splitPos + 1)) || 0);
+                map.set('APPENDLIMIT', parseUintValue(capability.slice(splitPos + 1)) || 0);
                 return;
             }
             map.set(capability, true);
@@ -469,6 +474,34 @@ function getStatusCode(response) {
         ? response.attributes[0].section[0].value.toUpperCase().trim()
         : false;
 }
+/**
+ * Emits a state-change event from inside the command pipeline. A listener that throws must not
+ * abort the code that emitted it: select() emits before it releases the response, so the throw
+ * would leave the reader loop waiting forever, and close() would never get to emit 'close'. The
+ * error is logged instead, the same contract untagged handlers and the 'response' event get.
+ *
+ * @param connection - IMAP connection instance
+ * @param event - Event name
+ * @param args - Event arguments
+ */
+function emitSafe(connection, event, ...args) {
+    try {
+        connection.emit(event, ...args);
+    }
+    catch (err) {
+        connection.log.warn({ msg: 'Event listener failed', event, err, cid: connection.id });
+    }
+}
+/**
+ * Collects the values of the TEXT tokens of a parsed response (the human-readable
+ * part of a status response, a greeting or a BYE).
+ *
+ * @param attributes - Attributes of a parsed IMAP response
+ * @returns Values of the TEXT tokens, in order
+ */
+function getTextValues(attributes) {
+    return (attributes || []).filter(attr => attr?.type === 'TEXT').map(attr => String(attr?.value ?? ''));
+}
 /**
  * Compiles an IMAP response object back into a human-readable string.
  *
@@ -506,6 +539,35 @@ async function enhanceCommandError(err) {
     err.response = await getErrorText(err.response);
     return err;
 }
+/**
+ * Enhances a failed command's error (see enhanceCommandError()) and logs it, the shared first
+ * step of every command's failure path. The caller decides whether to throw or return.
+ *
+ * @param connection - IMAP connection instance
+ * @param err - The command error
+ */
+async function reportCommandError(connection, err) {
+    await enhanceCommandError(err);
+    connection.log.warn({ err, cid: connection.id });
+}
+/**
+ * Whether the session is authenticated, that is in the AUTHENTICATED or SELECTED state, which
+ * every mailbox-level command requires.
+ *
+ * @param connection - IMAP connection instance
+ */
+function isAuthenticatedState(connection) {
+    return connection.state === connection.states.AUTHENTICATED || connection.state === connection.states.SELECTED;
+}
+/**
+ * Returns the selected mailbox, or false when the connection is not in the SELECTED state.
+ * Message-level commands use it as their precondition, which also narrows the mailbox type.
+ *
+ * @param connection - IMAP connection instance
+ */
+function getSelectedMailbox(connection) {
+    return connection.state === connection.states.SELECTED && connection.mailbox ? connection.mailbox : false;
+}
 /**
  * Converts a flat list of mailbox folders into a tree structure.
  *
@@ -681,6 +743,12 @@ async function formatMessageResponse(untagged, mailbox) {
             if (Buffer.isBuffer(attribute.value)) {
                 return attribute.value;
             }
+            // A section is an nstring, so a server may answer with a quoted string
+            // instead of a literal (Yahoo does for small parts). The tokenizer decoded
+            // the line as UTF-8, so encoding the same way restores the bytes it sent.
+            if (typeof attribute.value === 'string') {
+                return Buffer.from(attribute.value);
+            }
         };
         // NIL (parsed as null) and other non-array values yield an empty array, so callers
         // can safely index into the result. RFC 8474 allows e.g. `THREADID NIL` when the
@@ -987,7 +1055,7 @@ function getStructuredParams(arr) {
             // nothing to do here, does not seem like a continuation param
             return;
         }
-        actualKey = key.substr(0, match.index).toLowerCase();
+        actualKey = key.substring(0, match.index).toLowerCase();
         nr = Number(match[2]) || 0;
         if (isUnsafeKey(actualKey)) {
             // A continuation key like "__proto__*0*" would group under "__proto__":
@@ -1239,7 +1307,7 @@ function formatDate(value) {
     if (!date) {
         return;
     }
-    let dateParts = date.toISOString().substr(0, 10).split('-');
+    let dateParts = date.toISOString().substring(0, 10).split('-');
     dateParts.reverse();
     let months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
     dateParts[1] = months[Number(dateParts[1]) - 1];
@@ -1257,7 +1325,7 @@ function formatDateTime(value) {
         return;
     }
     let dateStr = formatDate(date).replace(/^0/, ' '); //starts with date-day-fixed with leading 0 replaced by SP
-    let timeStr = date.toISOString().substr(11, 8);
+    let timeStr = date.toISOString().substring(11, 19);
     return `${dateStr} ${timeStr} +0000`;
 }
 /**
@@ -1411,8 +1479,8 @@ function expandRange(range) {
             }
             continue;
         }
-        let first = Number(entry.substr(0, colon));
-        let second = Number(entry.substr(colon + 1));
+        let first = Number(entry.substring(0, colon));
+        let second = Number(entry.slice(colon + 1));
         if (!isValidSequenceValue(first) || !isValidSequenceValue(second)) {
             continue;
         }

package/dist/cjs/types.d.ts

@@ -207,26 +207,32 @@ export interface IdInfoObject {
     'support-url'?: string | false | undefined;
     /** Date program was released */
     date?: Date | string | false | undefined;
-    [key: string]: any;
+    /** Any other field, sent as its string form */
+    [key: string]: unknown;
+}
+/**
+ * Usage and limit of one quota resource. The `storage` values are bytes (the wire format is
+ * kilobytes), the other resources are counts
+ */
+export interface QuotaResource {
+    /** Current usage, missing when the server did not send a usable number */
+    usage?: number | undefined;
+    /** The limit, missing when the server did not send a usable number */
+    limit?: number | undefined;
+    /** Usage as a percentage of the limit, e.g. "50%", set once a limit above zero is known */
+    status?: string | undefined;
 }
 export interface QuotaResponse {
     /** Mailbox path this quota applies to */
     path: string;
-    /** Storage quota if provided by server */
-    storage?: {
-        /** Used storage in bytes */
-        used: number;
-        /** Total storage available */
-        limit: number;
-    } | undefined;
-    /** Message count quota if provided by server */
-    messages?: {
-        /** Stored messages */
-        used: number;
-        /** Maximum messages allowed */
-        limit: number;
-    } | undefined;
-    [resource: string]: any;
+    /** The quota root the server reported for the mailbox, if any */
+    quotaRoot?: string | undefined;
+    /** The STORAGE resource, if the server reports one */
+    storage?: QuotaResource | undefined;
+    /** The MESSAGE resource, if the server reports one */
+    message?: QuotaResource | undefined;
+    /** Any other resource the server reports, under its lowercased name (e.g. "mailbox") */
+    [resource: string]: QuotaResource | string | undefined;
 }
 /**
  * Status data items to request with `status()` or the `statusQuery` listing option
@@ -616,6 +622,14 @@ export interface DownloadObject {
     /** Streamed content */
     content: Readable;
 }
+/**
+ * What `download()` resolves with when there is nothing to download: no mailbox is selected, or
+ * the message or part was not found. Check `content` before using the result.
+ */
+export interface DownloadNotFound {
+    meta?: undefined;
+    content?: undefined;
+}
 export interface DownloadOptions {
     /** If true then uses UID number instead of sequence number for `range` */
     uid?: boolean | undefined;

package/dist/esm/commands/append.js

@@ -1,4 +1,4 @@
-import { formatFlag, canUseFlag, formatDateTime, normalizePath, encodePath, comparePaths, enhanceCommandError, parseBigIntValue, parseUintValue, MAX_UINT32_DIGITS } from '../tools.js';
+import { formatFlag, canUseFlag, formatDateTime, normalizePath, encodePath, comparePaths, parseBigIntValue, parseUintValue, MAX_UINT32_DIGITS, getSelectedMailbox, emitSafe, isAuthenticatedState, reportCommandError } from '../tools.js';
 /**
  * Appends a message to a mailbox.
  *
@@ -11,7 +11,7 @@ import { formatFlag, canUseFlag, formatDateTime, normalizePath, encodePath, comp
  * @throws {Error} If the APPEND command fails or message exceeds APPENDLIMIT
  */
 export default async function append(connection, destination, content, flags, idate) {
-    if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state) || !destination) {
+    if (!isAuthenticatedState(connection) || !destination) {
         // nothing to do here
         return;
     }
@@ -31,7 +31,9 @@ export default async function append(connection, destination, content, flags, id
     destination = normalizePath(connection, destination);
     // If appending to the currently selected mailbox, we can listen for the
     // untagged EXISTS response to capture the new message's sequence number.
-    let expectExists = comparePaths(connection, connection.mailbox.path, destination);
+    let selected = getSelectedMailbox(connection);
+    // The selected mailbox when appending to it, false otherwise
+    const targetMailbox = selected && comparePaths(connection, selected.path, destination) ? selected : false;
     // Validate and format flags. Only flags allowed by the mailbox's permanentFlags are included.
     flags = (Array.isArray(flags) ? flags : [].concat(flags || []))
         .map(flag => flag && formatFlag(flag.toString()))
@@ -74,13 +76,12 @@ export default async function append(connection, destination, content, flags, id
         map.seq = seq;
         // Update the connection's mailbox state and emit 'exists' event if the
         // count changed (notifies listeners about the new message).
-        if (expectExists) {
-            let mailbox = connection.mailbox;
-            let prevCount = mailbox.exists;
+        if (targetMailbox) {
+            let prevCount = targetMailbox.exists;
             if (map.seq !== prevCount) {
-                mailbox.exists = map.seq;
-                connection.emit('exists', {
-                    path: mailbox.path,
+                targetMailbox.exists = map.seq;
+                emitSafe(connection, 'exists', {
+                    path: targetMailbox.path,
                     count: map.seq,
                     prevCount
                 });
@@ -91,7 +92,7 @@ export default async function append(connection, destination, content, flags, id
     try {
         response = await connection.exec('APPEND', attributes, {
             // Only listen for EXISTS if we're appending to the currently selected mailbox
-            untagged: expectExists ? { EXISTS: handleExistsUpdate } : false
+            untagged: targetMailbox ? { EXISTS: handleExistsUpdate } : false
         });
         // UIDPLUS (RFC 4315): the server may include APPENDUID response code in
         // the tagged OK. Format: [APPENDUID <uidValidity> <uid>]
@@ -116,7 +117,7 @@ export default async function append(connection, destination, content, flags, id
         response.next();
         // If we didn't get an EXISTS during APPEND (some servers don't send it
         // until the next command), issue a NOOP to flush pending notifications.
-        if (expectExists && !map.seq) {
+        if (targetMailbox && !map.seq) {
             try {
                 response = await connection.exec('NOOP', false, {
                     untagged: { EXISTS: handleExistsUpdate },
@@ -139,8 +140,7 @@ export default async function append(connection, destination, content, flags, id
         return map;
     }
     catch (err) {
-        await enhanceCommandError(err);
-        connection.log.warn({ err, cid: connection.id });
+        await reportCommandError(connection, err);
         throw err;
     }
 }

package/dist/esm/commands/authenticate.d.ts

@@ -1,16 +1,11 @@
 import type { ImapFlow } from '../imap-flow.js';
+import type { AuthOptions } from '../types.js';
 /**
- * Credentials for the AUTHENTICATE command
+ * Credentials for the AUTHENTICATE command: the auth options, with the password passed as `password`
  */
-export interface AuthenticateCredentials {
-    /** OAuth2 access token for OAUTHBEARER/XOAUTH2 authentication */
-    accessToken?: string | undefined;
+export interface AuthenticateCredentials extends Omit<AuthOptions, 'user' | 'pass'> {
     /** Password for PLAIN or LOGIN authentication */
     password?: string | undefined;
-    /** Force a specific login method (e.g., 'AUTH=PLAIN', 'AUTH=LOGIN') */
-    loginMethod?: string | undefined;
-    /** Authorization identity for PLAIN authentication */
-    authzid?: string | undefined;
 }
 /**
  * Authenticates user using the best available method.

package/dist/esm/commands/close.js

@@ -1,3 +1,4 @@
+import { emitSafe } from '../tools.js';
 /**
  * Closes the currently selected mailbox.
  *
@@ -23,7 +24,7 @@ export default async function close(connection) {
         connection.currentSelectCommand = false;
         connection.state = connection.states.AUTHENTICATED;
         if (currentMailbox) {
-            connection.emit('mailboxClose', currentMailbox);
+            emitSafe(connection, 'mailboxClose', currentMailbox);
         }
         return true;
     }

package/dist/esm/commands/copy.js

@@ -1,4 +1,4 @@
-import { normalizePath, encodePath, enhanceCommandError } from '../tools.js';
+import { normalizePath, encodePath, reportCommandError, getSelectedMailbox } from '../tools.js';
 import { parseCopyUid } from './copyuid-parser.js';
 /**
  * Copies messages from the current mailbox to another mailbox.
@@ -11,7 +11,8 @@ import { parseCopyUid } from './copyuid-parser.js';
  * @returns Copy result with UID mapping if available, false on failure, or undefined if preconditions not met
  */
 export default async function copy(connection, range, destination, options) {
-    if (connection.state !== connection.states.SELECTED || !range || !destination) {
+    let mailbox = getSelectedMailbox(connection);
+    if (!mailbox || !range || !destination) {
         // nothing to do here
         return;
     }
@@ -25,15 +26,14 @@ export default async function copy(connection, range, destination, options) {
     try {
         response = await connection.exec(options.uid ? 'UID COPY' : 'COPY', attributes);
         response.next();
-        let map = { path: connection.mailbox.path, destination };
+        let map = { path: mailbox.path, destination };
         // UIDPLUS (RFC 4315): the server may include a COPYUID response code in the
         // tagged OK response, providing a mapping from source UIDs to destination UIDs.
         parseCopyUid(response.response, map);
         return map;
     }
     catch (err) {
-        await enhanceCommandError(err);
-        connection.log.warn({ err, cid: connection.id });
+        await reportCommandError(connection, err);
         return false;
     }
 }

package/dist/esm/commands/create.js

@@ -1,4 +1,4 @@
-import { encodePath, normalizePath, getStatusCode, enhanceCommandError } from '../tools.js';
+import { encodePath, normalizePath, getStatusCode, isAuthenticatedState, reportCommandError } from '../tools.js';
 /**
  * Creates a new mailbox and subscribes to it.
  *
@@ -8,7 +8,7 @@ import { encodePath, normalizePath, getStatusCode, enhanceCommandError } from '.
  * @throws If the CREATE command fails (except when mailbox already exists)
  */
 export default async function create(connection, path) {
-    if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state)) {
+    if (!isAuthenticatedState(connection)) {
         // nothing to do here
         return;
     }
@@ -68,8 +68,7 @@ export default async function create(connection, path) {
                 created: false
             };
         }
-        await enhanceCommandError(err);
-        connection.log.warn({ err, cid: connection.id });
+        await reportCommandError(connection, err);
         throw err;
     }
 }

package/dist/esm/commands/delete.js

@@ -1,4 +1,4 @@
-import { encodePath, normalizePath, enhanceCommandError } from '../tools.js';
+import { encodePath, normalizePath, isAuthenticatedState, reportCommandError, getSelectedMailbox } from '../tools.js';
 /**
  * Deletes an existing mailbox.
  *
@@ -8,14 +8,15 @@ import { encodePath, normalizePath, enhanceCommandError } from '../tools.js';
  * @throws If the DELETE command fails
  */
 export default async function deleteMailbox(connection, path) {
-    if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state)) {
+    if (!isAuthenticatedState(connection)) {
         // nothing to do here
         return;
     }
     path = normalizePath(connection, path);
     // If the mailbox to delete is currently selected, we must close/deselect it first.
     // IMAP servers reject DELETE on the currently selected mailbox (RFC 3501 6.3.4).
-    if (connection.state === connection.states.SELECTED && connection.mailbox.path === path) {
+    let selected = getSelectedMailbox(connection);
+    if (selected && selected.path === path) {
         await connection.run('CLOSE');
     }
     let response;
@@ -28,8 +29,7 @@ export default async function deleteMailbox(connection, path) {
         return map;
     }
     catch (err) {
-        await enhanceCommandError(err);
-        connection.log.warn({ err, cid: connection.id });
+        await reportCommandError(connection, err);
         throw err;
     }
 }

package/dist/esm/commands/expunge.js

@@ -1,4 +1,4 @@
-import { enhanceCommandError, hasCapability, parseBigIntValue } from '../tools.js';
+import { hasCapability, parseBigIntValue, reportCommandError, getSelectedMailbox } from '../tools.js';
 /**
  * Deletes specified messages by flagging them as Deleted and expunging.
  *
@@ -9,14 +9,19 @@ import { enhanceCommandError, hasCapability, parseBigIntValue } from '../tools.j
  * @returns True on success, false on failure, or undefined if preconditions not met
  */
 export default async function expunge(connection, range, options) {
-    if (connection.state !== connection.states.SELECTED || !range) {
+    let mailbox = getSelectedMailbox(connection);
+    if (!mailbox || !range) {
         // nothing to do here
         return;
     }
     options = options || {};
     // Two-step deletion process per IMAP protocol:
     // Step 1: Mark the target messages with the \Deleted flag.
-    await connection.messageFlagsAdd(range, ['\\Deleted'], options);
+    // If that failed, EXPUNGE would not remove the target messages (and without
+    // UIDPLUS it would remove unrelated \Deleted messages), so report the failure instead.
+    if (!(await connection.messageFlagsAdd(range, ['\\Deleted'], options))) {
+        return false;
+    }
     // Step 2: Issue EXPUNGE to permanently remove \Deleted messages.
     // With UIDPLUS (RFC 4315): "UID EXPUNGE <uids>" removes only the specified UIDs,
     // leaving other \Deleted messages untouched, important for concurrent access.
@@ -35,7 +40,6 @@ export default async function expunge(connection, range, options) {
         if (responseCode.toUpperCase() === 'HIGHESTMODSEQ') {
             // A response code always comes with its section, see responseCode above
             let codeSection = section;
-            let mailbox = connection.mailbox;
             // Bounded digit runs only: isNaN() also passes '1e5', which BigInt() rejects with
             // a throw that the catch below would swallow, making messageDelete() report false
             // even though the server expunged the messages.
@@ -48,8 +52,7 @@ export default async function expunge(connection, range, options) {
         return true;
     }
     catch (err) {
-        await enhanceCommandError(err);
-        connection.log.warn({ err, cid: connection.id });
+        await reportCommandError(connection, err);
         return false;
     }
 }