imapflow 2.0.8 → 2.1.1

package/dist/cjs/imap-flow.js

@@ -39,14 +39,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImapFlow = exports.AuthenticationFailure = void 0;
+exports.ImapFlow = exports.ImapFlowErrorCode = exports.AuthenticationFailure = void 0;
 const node_tls_1 = __importDefault(require("node:tls"));
 const node_net_1 = __importDefault(require("node:net"));
 const node_crypto_1 = __importDefault(require("node:crypto"));
 const node_zlib_1 = __importDefault(require("node:zlib"));
 const node_events_1 = require("node:events");
 const node_stream_1 = require("node:stream");
-const logger_js_1 = __importDefault(require("./logger.js"));
+const logger_js_1 = require("./logger.js");
 const packageInfo = __importStar(require("./package-info.js"));
 const imap_stream_js_1 = require("./handler/imap-stream.js");
 const imap_handler_js_1 = require("./handler/imap-handler.js");
@@ -58,6 +58,7 @@ const imap_commands_js_1 = __importDefault(require("./imap-commands.js"));
 const tools_js_1 = require("./tools.js");
 var errors_js_2 = require("./errors.js");
 Object.defineProperty(exports, "AuthenticationFailure", { enumerable: true, get: function () { return errors_js_2.AuthenticationFailure; } });
+Object.defineProperty(exports, "ImapFlowErrorCode", { enumerable: true, get: function () { return errors_js_2.ImapFlowErrorCode; } });
 const GREETING_TIMEOUT = 16 * 1000;
 const UPGRADE_TIMEOUT = 10 * 1000;
 const SOCKET_TIMEOUT = 5 * 60 * 1000;
@@ -1601,6 +1602,7 @@ class ImapFlow extends node_events_1.EventEmitter {
     /** @internal */
     beginSession(onUnhandledError) {
         (0, tools_js_1.clearTimer)(this.greetingTimeout);
+        this.greetingReceived = true;
         this.untaggedHandlers.OK = null;
         this.untaggedHandlers.PREAUTH = null;
         if (this.isClosed) {
@@ -1660,6 +1662,12 @@ class ImapFlow extends node_events_1.EventEmitter {
         this.byeReason = reason || 'Server closed connection';
         this.untaggedHandlers.BYE = null;
         this.state = this.states.LOGOUT;
+        // A BYE greeting rejects the connection outright. Do not wait for the server to close
+        // the socket: one that keeps it open would leave connect() pending until the greeting
+        // timeout.
+        if (!this.greetingReceived) {
+            this.closeAfter();
+        }
     }
     // Drops every capability-derived field together - the counterpart of
     // updateCapabilitiesFromRaw() below, which sets them together. rawCapabilities is
@@ -1892,7 +1900,7 @@ class ImapFlow extends node_events_1.EventEmitter {
     /** @internal */
     autoidle() {
         (0, tools_js_1.clearTimer)(this.idleStartTimer);
-        if (this.options.disableAutoIdle || this.state !== this.states.SELECTED) {
+        if (this.options.disableAutoIdle || !this.usable || this.state !== this.states.SELECTED) {
             return;
         }
         if (this.connectionBusy()) {
@@ -1904,7 +1912,7 @@ class ImapFlow extends node_events_1.EventEmitter {
             // missed clearTimeout would inject IDLE between a caller's own commands. Declining
             // postpones rather than cancels: whatever made the connection busy calls autoidle()
             // again when it finishes.
-            if (this.state !== this.states.SELECTED || this.connectionBusy()) {
+            if (!this.usable || this.state !== this.states.SELECTED || this.connectionBusy()) {
                 return;
             }
             this.idle().catch(err => (0, tools_js_1.logConnectionError)(this, 'Auto-IDLE failed', err));
@@ -1923,9 +1931,17 @@ class ImapFlow extends node_events_1.EventEmitter {
     async connect() {
         if (this._connectCalled) {
             // Prevent re-using ImapFlow instances by allowing to call connect just once.
-            throw new Error('Can not re-use ImapFlow instance');
+            let err = new Error('Can not re-use ImapFlow instance');
+            err.code = 'InstanceReused';
+            throw err;
         }
         this._connectCalled = true;
+        let closedError = () => this.createNoConnectionError(this.byeReason, { rejectedFrom: 'connect' });
+        // close() already ran, so there is no connection to set up and nothing would ever
+        // settle a connect attempt started now.
+        if (this.isClosed) {
+            throw closedError();
+        }
         // One deadline for the whole attempt, started before anything is resolved or negotiated.
         // Proxy DNS and proxy negotiation used to run entirely outside the timer, so a stalled
         // proxy could hang far beyond the documented connectionTimeout.
@@ -1971,9 +1987,20 @@ class ImapFlow extends node_events_1.EventEmitter {
                 error._err = err;
                 throw error;
             }
+            // close() during proxy setup found no socket to destroy and no connect to reject,
+            // so the tunnel that just opened is dropped here instead of being handed to a
+            // closed client.
+            if (this.isClosed) {
+                socket.destroy();
+                throw closedError();
+            }
         }
         // Guarded: close() rejects a pending connect() synchronously. See guardedPromise().
         let connectPromise = (0, tools_js_1.guardedPromise)((resolve, reject) => {
+            // Stored before the transport is up, so a close() that lands before onConnect
+            // still rejects this attempt through closeConnectSteps().
+            this.initialResolve = resolve;
+            this.initialReject = reject;
             // Whatever the proxy phase already used is gone from the budget
             this.connectTimeout = setTimeout(() => {
                 let err = deadline.error();
@@ -2025,9 +2052,6 @@ class ImapFlow extends node_events_1.EventEmitter {
                     this.setSocketHandlers();
                     this.setEventHandlers();
                     connected.pipe(this.streamer);
-                    // executed by initial "* OK"
-                    this.initialResolve = resolve;
-                    this.initialReject = reject;
                     /* c8 ignore next 4 */ // defensive: the onConnect setup body does not throw under normal operation
                 }
                 catch (ex) {
@@ -2211,7 +2235,10 @@ class ImapFlow extends node_events_1.EventEmitter {
             this._upgradeReject = null;
             reject(this.createNoConnectionError(false, { rejectedFrom: 'upgrade' }));
         }
-        if (typeof this.initialReject === 'function' && !this.options.verifyOnly) {
+        // A verifyOnly session closes itself with LOGOUT and startSession() settles connect()
+        // with the outcome, so the close is not a failure there. Before the greeting nothing
+        // else can settle it (BYE greeting, FIN, close() while the transport is still coming up).
+        if (typeof this.initialReject === 'function' && (!this.options.verifyOnly || !this.greetingReceived)) {
             (0, tools_js_1.clearTimer)(this.greetingTimeout);
             let reject = this.initialReject;
             this.initialResolve = false;
@@ -2522,7 +2549,26 @@ class ImapFlow extends node_events_1.EventEmitter {
      * // 125
      */
     async mailboxOpen(path, options) {
-        return await this.run('SELECT', path, options);
+        try {
+            return await this.run('SELECT', path, options);
+        }
+        catch (err) {
+            if (err.responseStatus === 'NO') {
+                // SELECT failed with NO: verify whether the mailbox exists at all by running
+                // LIST. This sets mailboxMissing on the error so the caller can distinguish
+                // "doesn't exist" from other failures, for getMailboxLock() callers as well.
+                try {
+                    let folders = await this.run('LIST', '', (0, tools_js_1.normalizePath)(this, path), { listOnly: true });
+                    if (!folders || !folders.length) {
+                        err.mailboxMissing = true;
+                    }
+                }
+                catch (E) {
+                    this.log.trace({ msg: 'Failed to verify failed mailbox', path, err: E });
+                }
+            }
+            throw err;
+        }
     }
     /**
      * Closes a previously opened mailbox
@@ -3224,20 +3270,7 @@ class ImapFlow extends node_events_1.EventEmitter {
                     break; // Wait for this lock to be released
                 }
                 catch (err) {
-                    if (err.responseStatus === 'NO') {
-                        // SELECT failed with NO: verify whether the mailbox exists
-                        // at all by running LIST. This sets mailboxMissing on the error
-                        // so the caller can distinguish "doesn't exist" from other failures.
-                        try {
-                            let folders = await this.run('LIST', '', path, { listOnly: true });
-                            if (!folders || !folders.length) {
-                                err.mailboxMissing = true;
-                            }
-                        }
-                        catch (E) {
-                            this.log.trace({ msg: 'Failed to verify failed mailbox', path, err: E });
-                        }
-                    }
+                    // mailboxOpen() has already marked a missing mailbox (mailboxMissing)
                     this.log.trace({
                         msg: 'Failed to acquire mailbox lock',
                         path,
@@ -3328,12 +3361,14 @@ class ImapFlow extends node_events_1.EventEmitter {
     }
     /** @internal */
     getLogger() {
-        let mainLogger = this.options.logger && typeof this.options.logger === 'object'
-            ? this.options.logger
-            : logger_js_1.default.child({
-                component: 'imap-connection',
-                cid: this.id
-            });
+        let mainLogger = {};
+        if (this.options.logger && typeof this.options.logger === 'object') {
+            mainLogger = this.options.logger;
+        }
+        else if (this.options.logger !== false) {
+            // {logger:false} never consults mainLogger, so it does not create the default logger
+            mainLogger = (0, logger_js_1.createConnectionLogger)({ cid: this.id, logRaw: this.options.logRaw });
+        }
         let synteticLogger = {};
         let levels = ['trace', 'debug', 'info', 'warn', 'error', 'fatal'];
         for (let level of levels) {
@@ -3389,7 +3424,8 @@ class ImapFlow extends node_events_1.EventEmitter {
     }
     /**
      * Detaches sockets from the IMAP pipeline. Useful for upgrading the connection
-     * (e.g., STARTTLS) or transferring socket ownership.
+     * (e.g., STARTTLS) or transferring socket ownership. Call it while the connection is not
+     * idling: an IDLE in progress is not broken first, so the server still expects `DONE`.
      *
      * @returns Socket objects: `readSocket` is the read socket (inflated socket if compression is enabled, raw socket otherwise),
      *   `writeSocket` the write socket and `socket` the raw underlying socket (same as readSocket/writeSocket when compression is disabled)
@@ -3404,6 +3440,11 @@ class ImapFlow extends node_events_1.EventEmitter {
         // compression is active, the PassThrough writeSocket - so the connection
         // is fully released to the caller.
         this.clearSocketHandlers();
+        // The socket now belongs to the caller. Marking the client unusable keeps
+        // auto-IDLE (armed now, or re-armed by a lock release or a finished download)
+        // and a later dispose from writing IDLE or LOGOUT onto it.
+        this.usable = false;
+        (0, tools_js_1.clearTimer)(this.idleStartTimer);
         const readSocket = this._inflate || socket;
         const writeSocket = this.writeSocket || socket;
         // Defense-in-depth: when compression is active the raw socket is orphaned
@@ -3502,6 +3543,23 @@ exports.ImapFlow = ImapFlow;
  *     console.log(`${entry.cid} ${entry.msg}`);
  * });
  */
+// Installed outside the class body: a computed `[Symbol.asyncDispose]` key would turn into a
+// method named "undefined" on Node.js 20.0-20.3, which predate the symbol
+if (typeof Symbol.asyncDispose === 'symbol') {
+    ImapFlow.prototype[Symbol.asyncDispose] = async function () {
+        if (this.usable) {
+            try {
+                await this.logout();
+            }
+            catch (err) {
+                (0, tools_js_1.logConnectionError)(this, 'LOGOUT failed while disposing', err);
+            }
+        }
+        // logout() already closes the connection; close() is idempotent and covers a client
+        // that never connected or whose logout was skipped
+        this.close();
+    };
+}
 // Both `import { ImapFlow } from 'imapflow'` and `import imapflow from 'imapflow'` work, the
 // latter matching the shape `require('imapflow')` has always had
 const imapflow = { ImapFlow, AuthenticationFailure: errors_js_1.AuthenticationFailure };

package/dist/cjs/logger.d.ts

@@ -1,3 +1,21 @@
-import pino from 'pino';
-declare const logger: pino.Logger<never, boolean>;
-export default logger;
+import { type Logger as PinoLogger } from 'pino';
+/**
+ * Returns the shared default logger, used when a connection is given no logger of its own.
+ * Created on first use, so importing the library does not set up a stdout logger nobody asked
+ * for. Level info: a caller that asks for raw socket data (logRaw) lowers its own child logger
+ * to trace.
+ *
+ * @returns The default pino logger
+ */
+export declare function getDefaultLogger(): PinoLogger;
+/**
+ * Returns the child of the default logger a connection logs through when it was given no
+ * logger of its own.
+ *
+ * @param options - cid is the connection id to stamp on entries, logRaw asks for raw socket data
+ * @returns A child logger of the default logger
+ */
+export declare function createConnectionLogger(options: {
+    cid?: string | undefined;
+    logRaw?: boolean | undefined;
+}): PinoLogger;

package/dist/cjs/logger.js

@@ -3,9 +3,39 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultLogger = getDefaultLogger;
+exports.createConnectionLogger = createConnectionLogger;
 const pino_1 = __importDefault(require("pino"));
-const logger = (0, pino_1.default)();
-logger.level = 'trace';
-exports.default = logger;
-module.exports = exports.default;
-Object.defineProperty(module.exports, 'default', { value: exports.default, enumerable: false, writable: true, configurable: true });
+let logger = null;
+/**
+ * Returns the shared default logger, used when a connection is given no logger of its own.
+ * Created on first use, so importing the library does not set up a stdout logger nobody asked
+ * for. Level info: a caller that asks for raw socket data (logRaw) lowers its own child logger
+ * to trace.
+ *
+ * @returns The default pino logger
+ */
+function getDefaultLogger() {
+    if (!logger) {
+        logger = (0, pino_1.default)({ level: 'info' });
+    }
+    return logger;
+}
+/**
+ * Returns the child of the default logger a connection logs through when it was given no
+ * logger of its own.
+ *
+ * @param options - cid is the connection id to stamp on entries, logRaw asks for raw socket data
+ * @returns A child logger of the default logger
+ */
+function createConnectionLogger(options) {
+    let child = getDefaultLogger().child({
+        component: 'imap-connection',
+        cid: options.cid
+    });
+    // Raw socket data is logged at trace level, so asking for it lowers the threshold
+    if (options.logRaw) {
+        child.level = 'trace';
+    }
+    return child;
+}

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

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

package/dist/cjs/package-info.js

@@ -3,5 +3,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.homepage = exports.version = exports.name = void 0;
 exports.name = "imapflow";
-exports.version = "2.0.8";
+exports.version = "2.1.1";
 exports.homepage = "https://imapflow.com/";

package/dist/cjs/search-compiler.d.ts

@@ -9,7 +9,7 @@ export type SearchAttribute = ImapAttributeNode | SearchAttribute[];
  * Compiles a JavaScript object query into IMAP search command attributes.
  * Supports standard IMAP search criteria and extensions like OBJECTID and Gmail extensions.
  *
- * @param connection - IMAP connection object (capabilities, enabled extensions and the current mailbox are read)
+ * @param connection - IMAP connection object (capabilities and enabled extensions are read)
  * @param query - Search query object
  * @returns Array of IMAP search attributes
  * @throws {Error} When required server extensions are not available

package/dist/cjs/search-compiler.js

@@ -91,6 +91,17 @@ let processDateField = (attributes, term, value) => {
 };
 // Pre-compiled regex for better performance
 const UNICODE_PATTERN = /[^\x00-\x7F]/;
+/**
+ * Throws a coded search compilation error.
+ *
+ * @param code - Error code, one of the ImapFlowErrorCode values
+ * @param message - Error message
+ */
+let fail = (code, message) => {
+    let error = new Error(message);
+    error.code = code;
+    throw error;
+};
 /**
  * Checks if a string contains Unicode characters.
  * Used to determine if CHARSET UTF-8 needs to be specified.
@@ -110,7 +121,7 @@ let isUnicodeString = (str) => {
  * Compiles a JavaScript object query into IMAP search command attributes.
  * Supports standard IMAP search criteria and extensions like OBJECTID and Gmail extensions.
  *
- * @param connection - IMAP connection object (capabilities, enabled extensions and the current mailbox are read)
+ * @param connection - IMAP connection object (capabilities and enabled extensions are read)
  * @param query - Search query object
  * @returns Array of IMAP search attributes
  * @throws {Error} When required server extensions are not available
@@ -136,21 +147,29 @@ const searchCompiler = (connection, query) => {
     const attributes = [];
     // Track if we need to specify UTF-8 charset
     let hasUnicode = false;
-    const mailbox = connection.mailbox;
     /**
      * Recursively walks through the query object and builds IMAP attributes.
      * @param params - Query parameters to process
      */
     const walk = (params) => {
-        // Walks a query object and wraps the resulting attributes in a
-        // sub-array so the IMAP compiler emits parentheses around them.
-        // Used when a single search-key is required (NOT, OR operands)
-        // but the condition has multiple keys (RFC 3501 Section 6.4.4).
-        let walkGrouped = (obj) => {
+        // Compiles one NOT or OR operand, which the caller has already put its operator in
+        // front of. An operand with several keys is wrapped in a sub-array so the IMAP compiler
+        // emits parentheses around it, as the operator takes a single search-key
+        // (RFC 3501 Section 6.4.4). An operand that compiles to nothing (an invalid date, an
+        // empty object, ...) is refused: the operator would otherwise bind to whatever
+        // criterion follows it and invert or widen the search.
+        let walkOperand = (operator, obj) => {
             let startIdx = attributes.length;
-            walk(obj);
-            let subAttrs = attributes.splice(startIdx);
-            attributes.push(subAttrs);
+            if (obj && typeof obj === 'object') {
+                walk(obj);
+            }
+            if (attributes.length === startIdx) {
+                fail('InvalidSearchQuery', `Search operand for ${operator} does not include any usable search criteria`);
+            }
+            if (Object.keys(obj).length > 1) {
+                let subAttrs = attributes.splice(startIdx);
+                attributes.push(subAttrs);
+            }
         };
         Object.keys(params || {}).forEach(term => {
             switch (term.toUpperCase()) {
@@ -196,9 +215,7 @@ const searchCompiler = (connection, query) => {
                         // reject the whole search with a tagged BAD, so fail with a
                         // descriptive error instead
                         if ((0, tools_js_1.isRev2Active)(connection)) {
-                            let error = new Error(`The "${term.toLowerCase()}" search key does not exist in IMAP4rev2`);
-                            error.code = 'MissingServerExtension';
-                            throw error;
+                            fail('MissingServerExtension', `The "${term.toLowerCase()}" search key does not exist in IMAP4rev2`);
                         }
                         setBoolOpt(attributes, term, true);
                     }
@@ -244,6 +261,11 @@ const searchCompiler = (connection, query) => {
                         // Fallback to Gmail message ID
                         setOpt(attributes, 'X-GM-MSGID', params[term]);
                     }
+                    else if (params[term]) {
+                        // Dropping the criterion would widen the search to every message
+                        // matching the rest of the query, which a delete or move acts on
+                        fail('MissingServerExtension', 'Server does not support OBJECTID or X-GM-EXT-1 extension required for EMAILID');
+                    }
                     break;
                 // Thread ID support (OBJECTID or Gmail extension)
                 case 'THREADID':
@@ -254,6 +276,11 @@ const searchCompiler = (connection, query) => {
                         // Fallback to Gmail thread ID
                         setOpt(attributes, 'X-GM-THRID', params[term]);
                     }
+                    else if (params[term]) {
+                        // Dropping the criterion would widen the search to every message
+                        // matching the rest of the query, which a delete or move acts on
+                        fail('MissingServerExtension', 'Server does not support OBJECTID or X-GM-EXT-1 extension required for THREADID');
+                    }
                     break;
                 // Gmail raw search
                 case 'GMRAW':
@@ -265,9 +292,7 @@ const searchCompiler = (connection, query) => {
                         setOpt(attributes, 'X-GM-RAW', params[term]);
                     }
                     else {
-                        let error = new Error('Server does not support X-GM-EXT-1 extension required for X-GM-RAW');
-                        error.code = 'MissingServerExtension';
-                        throw error;
+                        fail('MissingServerExtension', 'Server does not support X-GM-EXT-1 extension required for X-GM-RAW');
                     }
                     break;
                 // Gmail label search. Compiles { has, not } into an X-GM-RAW "label:"/"-label:" query
@@ -301,9 +326,7 @@ const searchCompiler = (connection, query) => {
                         break;
                     }
                     if (!connection.capabilities.has('X-GM-EXT-1')) {
-                        let error = new Error('Server does not support X-GM-EXT-1 extension required for label search');
-                        error.code = 'MissingServerExtension';
-                        throw error;
+                        fail('MissingServerExtension', 'Server does not support X-GM-EXT-1 extension required for label search');
                     }
                     let rawQuery = rawParts.join(' ');
                     if (isUnicodeString(rawQuery)) {
@@ -347,8 +370,10 @@ const searchCompiler = (connection, query) => {
                 case 'UNKEYWORD':
                     {
                         let flag = (0, tools_js_1.formatFlag)(params[term]);
-                        // Only add if flag is supported or already exists in mailbox
-                        if ((0, tools_js_1.canUseFlag)(mailbox, flag) || mailbox.flags.has(flag)) {
+                        // Compiled even when the mailbox does not allow the keyword: the
+                        // correct answer is then the empty set, which dropping the
+                        // criterion would turn into every message matching the rest
+                        if (flag) {
                             setOpt(attributes, term, flag);
                         }
                     }
@@ -377,12 +402,7 @@ const searchCompiler = (connection, query) => {
                 case 'NOT':
                     if (params[term] && typeof params[term] === 'object') {
                         attributes.push({ type: 'ATOM', value: 'NOT' });
-                        if (Object.keys(params[term]).length > 1) {
-                            walkGrouped(params[term]);
-                        }
-                        else {
-                            walk(params[term]);
-                        }
+                        walkOperand('NOT', params[term]);
                     }
                     break;
                 // OR operator - complex logic for building OR trees
@@ -441,14 +461,7 @@ const searchCompiler = (connection, query) => {
                                 entry.forEach(walkOrTree);
                                 return;
                             }
-                            if (entry && typeof entry === 'object') {
-                                if (Object.keys(entry).length > 1) {
-                                    walkGrouped(entry);
-                                }
-                                else {
-                                    walk(entry);
-                                }
-                            }
+                            walkOperand('OR', entry);
                         };
                         walkOrTree(genOrTree(params[term]));
                     }

package/dist/cjs/tools.d.ts

@@ -1,6 +1,6 @@
 import type { Transform } from 'node:stream';
 import type { ImapFlow } from './imap-flow.js';
-import type { ConnectionErrorSite, ImapFlowError } from './errors.js';
+import { type ConnectionErrorSite, type ImapFlowError } from './errors.js';
 import type { ImapAttributeList, ImapAttributeNode, ImapResponse } from './handler/types.js';
 import type { FetchMessageObject, ListResponse, ListTreeResponse, MailboxObject, MessageEnvelopeObject, MessageStructureObject, ImapFlowEvents, StatusQuery } from './types.js';
 export { AuthenticationFailure } from './errors.js';

package/dist/cjs/tools.js

@@ -58,11 +58,12 @@ const imap_handler_js_1 = require("./handler/imap-handler.js");
 const node_crypto_1 = require("node:crypto");
 const jp_decoder_js_1 = require("./jp-decoder.js");
 const iconv_lite_1 = __importDefault(require("iconv-lite"));
-var errors_js_1 = require("./errors.js");
-Object.defineProperty(exports, "AuthenticationFailure", { enumerable: true, get: function () { return errors_js_1.AuthenticationFailure; } });
+const errors_js_1 = require("./errors.js");
+var errors_js_2 = require("./errors.js");
+Object.defineProperty(exports, "AuthenticationFailure", { enumerable: true, get: function () { return errors_js_2.AuthenticationFailure; } });
 const FLAG_COLORS = ['red', 'orange', 'yellow', 'green', 'blue', 'purple', 'grey'];
 // Error codes that only mean the connection is no longer usable. See logConnectionError().
-const CONNECTION_GONE_CODES = new Set(['NoConnection', 'EConnectionClosed', 'StateLogout']);
+const CONNECTION_GONE_CODES = new Set([errors_js_1.ImapFlowErrorCode.NoConnection, errors_js_1.ImapFlowErrorCode.EConnectionClosed, errors_js_1.ImapFlowErrorCode.StateLogout]);
 // Upper bound for expanding server-supplied sequence ranges (see expandRange). 2^24
 // entries in total is far beyond any legitimate mailbox while keeping the worst-case
 // expansion of a hostile range set bounded.
@@ -815,11 +816,18 @@ async function formatMessageResponse(untagged, mailbox) {
             case 'flags':
                 map.flags = new Set(getArray(attribute));
                 break;
+            // A server with nothing to report can answer ENVELOPE NIL or BODYSTRUCTURE NIL.
+            // The field is left unset then: parsing NIL threw, and the whole message
+            // disappeared from the FETCH result.
             case 'envelope':
-                map.envelope = parseEnvelope(attribute);
+                if (Array.isArray(attribute)) {
+                    map.envelope = parseEnvelope(attribute);
+                }
                 break;
             case 'bodystructure':
-                map.bodyStructure = parseBodystructure(attribute);
+                if (Array.isArray(attribute)) {
+                    map.bodyStructure = parseBodystructure(attribute);
+                }
                 break;
             case 'internaldate': {
                 let value = getString(attribute);
@@ -1147,7 +1155,7 @@ function parseBodystructure(entry) {
             curNode.type = 'multipart/' + ((node[i++] || {}).value || '').toString().toLowerCase();
             // extension data (not available for BODY requests)
             // body parameter parenthesized list
-            if (i < node.length - 1) {
+            if (i < node.length) {
                 if (node[i]) {
                     curNode.parameters = getStructuredParams(node[i]);
                 }
@@ -1229,7 +1237,7 @@ function parseBodystructure(entry) {
             }
             // extension data (not available for BODY requests)
             // md5
-            if (i < node.length - 1) {
+            if (i < node.length) {
                 if (node[i]) {
                     curNode.md5 = (node[i].value || '').toString().toLowerCase();
                 }
@@ -1239,7 +1247,7 @@ function parseBodystructure(entry) {
         // the following are shared extension values (for both multipart and non-multipart parts)
         // not available for BODY requests
         // body disposition
-        if (i < node.length - 1) {
+        if (i < node.length) {
             let disposition = node[i];
             if (Array.isArray(disposition) && disposition.length) {
                 curNode.disposition = ((disposition[0] && disposition[0].value) || '').toString().toLowerCase();
@@ -1250,7 +1258,7 @@ function parseBodystructure(entry) {
             i++;
         }
         // body language
-        if (i < node.length - 1) {
+        if (i < node.length) {
             if (node[i]) {
                 /* c8 ignore next */ // node[i] is truthy inside this guard, so the [] fallback is unreachable
                 curNode.language = [].concat(node[i] || []).map(val => ((val && val.value) || '').toString().toLowerCase());
@@ -1260,7 +1268,7 @@ function parseBodystructure(entry) {
         // body location
         // NB! defined as a "string list" in RFC3501 but replaced in errata document with "string"
         // Errata: http://www.rfc-editor.org/errata_search.php?rfc=3501
-        if (i < node.length - 1) {
+        if (i < node.length) {
             if (node[i]) {
                 curNode.location = (node[i].value || '').toString();
             }