@withbuddi/buddi 0.1.0-pre.51 → 0.1.0-pre.53

package/node_modules/imapflow/dist/cjs/tools.js

@@ -32,6 +32,7 @@ exports.getSelectedMailbox = getSelectedMailbox;
 exports.getFolderTree = getFolderTree;
 exports.getFlagColor = getFlagColor;
 exports.getColorFlags = getColorFlags;
+exports.mergeFetchRows = mergeFetchRows;
 exports.formatMessageResponse = formatMessageResponse;
 exports.processName = processName;
 exports.decodeText = decodeText;
@@ -48,6 +49,7 @@ exports.isValidSequenceValue = isValidSequenceValue;
 exports.isDecimalString = isDecimalString;
 exports.isUnsafeKey = isUnsafeKey;
 exports.getStringList = getStringList;
+exports.getStringValue = getStringValue;
 exports.parseBigIntValue = parseBigIntValue;
 exports.parseUintValue = parseUintValue;
 exports.expandRange = expandRange;
@@ -144,13 +146,7 @@ const CONNECTION_ERROR_SITE_KEYS = ['rejectedFrom', 'command', 'path'];
  * @returns The stamped error
  */
 function buildConnectionError(cid, code, message, meta) {
-    const error = new Error(message);
-    error.code = code;
-    error.cid = cid;
-    if (meta) {
-        Object.assign(error, meta);
-    }
-    return error;
+    return (0, errors_js_1.createImapError)(message, code, { cid, ...meta });
 }
 /**
  * Re-stamps an existing connection error for a different rejection site.
@@ -172,6 +168,7 @@ function buildConnectionError(cid, code, message, meta) {
  * @returns A separate error describing the same failure at the new site
  */
 function restampConnectionError(err, meta) {
+    // the original code is carried over unchanged, whatever its origin
     let error = buildConnectionError(err.cid, err.code, err.message, err);
     for (let key of CONNECTION_ERROR_SITE_KEYS) {
         delete error[key];
@@ -271,12 +268,15 @@ function logConnectionError(connection, msg, err) {
 /**
  * Whether a command failed because the server answered it with a tagged NO or BAD, as opposed
  * to a lost connection, a timeout or a local failure that says nothing about the server's answer.
+ * A throttled command (ETHROTTLE, Microsoft 365 answers it with BAD) was not refused: the server
+ * asks to try again later, so a throttled login is not a rejected credential and a throttled
+ * IDLE does not mean the server lacks IDLE.
  *
  * @param err - The error the command failed with
- * @returns True for a tagged NO or BAD
+ * @returns True for a tagged NO or BAD that is not throttling
  */
 function isServerRefusal(err) {
-    return !!err && (err.responseStatus === 'NO' || err.responseStatus === 'BAD');
+    return !!err && (err.responseStatus === 'NO' || err.responseStatus === 'BAD') && err.code !== errors_js_1.ImapFlowErrorCode.ETHROTTLE;
 }
 /**
  * Checks whether IMAP4rev2 semantics are active for the connection: either the
@@ -522,12 +522,13 @@ function getTextValues(attributes) {
  * @param response - Parsed IMAP server response
  * @returns Compiled response text, or false if no response
  */
+// Async although nothing in it awaits any more: `imapflow/lib/tools` deep imports may chain on the promise
 async function getErrorText(response) {
     if (!response) {
         return false;
     }
     try {
-        return (await (0, imap_handler_js_1.compiler)(response)).toString();
+        return (0, imap_handler_js_1.compiler)(response).toString();
     }
     catch {
         // The wire encoder refuses values that cannot be expressed as a valid IMAP
@@ -536,7 +537,7 @@ async function getErrorText(response) {
         // tolerates stray bytes inside an OK/NO/BAD atom, and those bytes then have
         // no valid re-encoding. This text is diagnostic, so fall back to the logging
         // encoder rather than replacing the server's error with an encoding failure.
-        return (await (0, imap_handler_js_1.compiler)(response, { isLogging: true })).toString();
+        return (0, imap_handler_js_1.compiler)(response, { isLogging: true }).toString();
     }
 }
 /**
@@ -713,6 +714,34 @@ function getColorFlags(color) {
     }
     return result;
 }
+/**
+ * Merges the FETCH rows a server sent for one message into one message object. A server may
+ * split the data items of a message over several FETCH responses, and may put an unsolicited
+ * one (a flag change made by another session) in between (RFC 9051 sections 7.5.2 and 5.2).
+ * Later rows win for single values, bodyParts, binaryParts and partialOrigins are combined.
+ *
+ * @param rows - Formatted rows of the same message, in the order they arrived
+ * @returns One message object holding the data of every row
+ */
+function mergeFetchRows(rows) {
+    if (rows.length === 1) {
+        return rows[0];
+    }
+    let merged = {};
+    let partialOrigins;
+    for (let row of rows) {
+        let { bodyParts, binaryParts, ...rest } = row;
+        Object.assign(merged, rest);
+        // combined into collections of their own, so the rows stay untouched
+        bodyParts?.forEach((value, key) => (merged.bodyParts ??= new Map()).set(key, value));
+        binaryParts?.forEach(key => (merged.binaryParts ??= new Set()).add(key));
+        row.partialOrigins?.forEach((value, key) => (partialOrigins ??= new Map()).set(key, value));
+    }
+    if (partialOrigins) {
+        Object.defineProperty(merged, 'partialOrigins', { value: partialOrigins, writable: true, configurable: true });
+    }
+    return merged;
+}
 /**
  * Formats a raw untagged FETCH response into a structured message object.
  *
@@ -722,6 +751,7 @@ function getColorFlags(color) {
  * @param connection - Connection the response arrived on, decodes Gmail labels like mailbox names
  * @returns Formatted message object with properties like seq, uid, flags, envelope, etc.
  */
+// Async although nothing in it awaits any more: `imapflow/lib/tools` deep imports may chain on the promise
 async function formatMessageResponse(untagged, mailbox, idHashAlgorithm, connection) {
     let map = {};
     // The sequence number indexes into mailbox state, so an unusable one is dropped rather
@@ -744,9 +774,9 @@ async function formatMessageResponse(untagged, mailbox, idHashAlgorithm, connect
         let attribute = attributes[i];
         if (i % 2 === 0) {
             origin = false;
-            key = (await (0, imap_handler_js_1.compiler)({
+            key = (0, imap_handler_js_1.compiler)({
                 attributes: [attribute]
-            }))
+            })
                 .toString()
                 .toLowerCase()
                 .replace(/<(\d+)(\.\d+)?>$/, (match, start) => {
@@ -1473,16 +1503,27 @@ function getStringList(list) {
     }
     let strings = [];
     for (let entry of list) {
-        let value = entry && entry.value;
-        if (Buffer.isBuffer(value)) {
-            value = value.toString();
-        }
-        if (value && typeof value === 'string') {
+        let value = getStringValue(entry);
+        if (value) {
             strings.push(value);
         }
     }
     return strings;
 }
+/**
+ * Reads the text of a string value from a response. A server may send any string as a literal,
+ * which arrives as a Buffer and is decoded as UTF-8.
+ *
+ * @param attribute - Parsed attribute from a response
+ * @returns The string, or undefined when the attribute holds no string (NIL, a list)
+ */
+function getStringValue(attribute) {
+    let value = attribute && attribute.value;
+    if (Buffer.isBuffer(value)) {
+        return value.toString();
+    }
+    return typeof value === 'string' ? value : undefined;
+}
 /**
  * Parses an untrusted decimal value from a server response into a BigInt.
  *

package/node_modules/imapflow/dist/cjs/types.d.ts

@@ -499,6 +499,8 @@ export interface FetchQueryObject {
         /** Include full message in the response, up to maxLength bytes */
         maxLength?: number | undefined;
     } | undefined;
+    /** Email ID (OBJECTID EMAILID or Gmail X-GM-MSGID) is always requested when the server supports either extension, so this is accepted but changes nothing */
+    emailId?: boolean | undefined;
     /** If true then include thread ID in the response (only if server supports either OBJECTID or X-GM-EXT-1 extensions) */
     threadId?: boolean | undefined;
     /** If true then include GMail labels in the response (only if server supports X-GM-EXT-1 extension) */
@@ -653,9 +655,11 @@ export interface DownloadOptions {
     maxBytes?: number | undefined;
     /** How large content parts to ask from the server. Defaults to 65536 */
     chunkSize?: number | undefined;
+    /** If true then requests the content with FETCH BINARY when the server supports it (BINARY or IMAP4rev2), so the server removes the transfer encoding */
+    binary?: boolean | undefined;
 }
 /** Options for downloadMany(): the download() options without `chunkSize`, as the parts come in one FETCH */
-export type DownloadManyOptions = Pick<DownloadOptions, 'uid' | 'maxBytes'>;
+export type DownloadManyOptions = Pick<DownloadOptions, 'uid' | 'maxBytes' | 'binary'>;
 export interface DownloadManyPart {
     meta: DownloadMeta;
     content?: Buffer | null | undefined;
@@ -706,6 +710,10 @@ export interface MailboxOpenOptions {
     readOnly?: boolean | undefined;
     /** Optional description for mailbox lock tracking */
     description?: string | undefined;
+    /** QRESYNC (RFC 7162): HIGHESTMODSEQ from an earlier session. With `uidValidity` and QRESYNC enabled, changes since then are reported as `flags` and `expunge` events. getMailboxLock() only applies it when it selects the mailbox, not when the mailbox is already open */
+    changedSince?: bigint | number | string | undefined;
+    /** QRESYNC (RFC 7162): the UIDVALIDITY known from the previous session, required with `changedSince` */
+    uidValidity?: bigint | number | string | undefined;
 }
 export interface MailboxLockOptions extends MailboxOpenOptions {
     /**
@@ -797,6 +805,15 @@ export interface LogEvent {
     /** Additional log data */
     [key: string]: any;
 }
+/** A message the server marked with the ALERT response code, to be shown to the user (RFC 9051 section 7.1) */
+export interface AlertEvent {
+    /** The alert text */
+    message: string;
+    /** The response that carried it */
+    response: 'OK' | 'NO' | 'BAD' | 'BYE' | 'PREAUTH';
+    /** Tag of the command it completed, missing for an untagged response */
+    tag?: string | undefined;
+}
 export interface ResponseEvent {
     /** Response type */
     response: string;
@@ -862,4 +879,6 @@ export interface ImapFlowEvents {
     log: [entry: LogEvent];
     /** Response event */
     response: [response: ResponseEvent];
+    /** The server sent an ALERT: text meant for the user, such as a planned shutdown or an account problem */
+    alert: [alert: AlertEvent];
 }

package/node_modules/imapflow/dist/esm/commands/append.d.ts

@@ -19,4 +19,4 @@ export interface AppendResult extends AppendResponseObject {
  * @returns Append result with UID info if available, or undefined if preconditions not met
  * @throws {Error} If the APPEND command fails or message exceeds APPENDLIMIT
  */
-export default function append(connection: ImapFlow, destination: string | string[], content: Buffer | string, flags?: string | string[] | undefined, idate?: Date | string | false | undefined): Promise<AppendResult | undefined>;
+export default function append(connection: ImapFlow, destination: string | string[], content: Buffer | Uint8Array | string, flags?: string | string[] | undefined, idate?: Date | string | false | undefined): Promise<AppendResult | undefined>;

package/node_modules/imapflow/dist/esm/commands/append.js

@@ -1,4 +1,5 @@
 import { formatFlag, canUseFlag, formatDateTime, normalizePath, encodePath, comparePaths, parseBigIntValue, parseUintValue, MAX_UINT32_DIGITS, getSelectedMailbox, emitSafe, isAuthenticatedState, reportCommandError, logConnectionError } from '../tools.js';
+import { createImapError } from '../errors.js';
 /**
  * Appends a message to a mailbox.
  *
@@ -15,14 +16,24 @@ export default async function append(connection, destination, content, flags, id
         // nothing to do here
         return;
     }
+    // The literal size marker is announced from these bytes, so anything that is not
+    // bytes (a Readable, a plain object) is refused here instead of desyncing the session
+    let message;
     if (typeof content === 'string') {
-        content = Buffer.from(content);
+        message = Buffer.from(content);
+    }
+    else if (content instanceof Uint8Array) {
+        // a Buffer as is, any other Uint8Array as a view over the same memory, not a copy
+        message = Buffer.isBuffer(content) ? content : Buffer.from(content.buffer, content.byteOffset, content.byteLength);
+    }
+    else {
+        throw createImapError('Message content must be a Buffer, Uint8Array or string', 'InvalidMessageContent');
     }
     // APPENDLIMIT capability (RFC 7889): server may advertise the maximum message
     // size it accepts. Check before sending to avoid a wasted round-trip.
     if (connection.capabilities.has('APPENDLIMIT')) {
         let appendLimit = connection.capabilities.get('APPENDLIMIT');
-        if (typeof appendLimit === 'number' && appendLimit < content.length) {
+        if (typeof appendLimit === 'number' && appendLimit < message.length) {
             let err = new Error('Message content too big for APPENDLIMIT=' + appendLimit);
             err.serverResponseCode = 'APPENDLIMIT';
             throw err;
@@ -79,9 +90,9 @@ export default async function append(connection, destination, content, flags, id
     // Regular literals cannot contain NUL bytes per the IMAP grammar.
     let isLiteral8 = false;
     if (connection.capabilities.has('BINARY') && !connection.disableBinary) {
-        isLiteral8 = content.indexOf(Buffer.from([0])) >= 0;
+        isLiteral8 = message.indexOf(0) >= 0;
     }
-    attributes.push({ type: 'LITERAL', value: content, isLiteral8 });
+    attributes.push({ type: 'LITERAL', value: message, isLiteral8 });
     let map = { destination };
     if (connection.mailbox && connection.mailbox.path) {
         map.path = connection.mailbox.path;

package/node_modules/imapflow/dist/esm/commands/compress.js

@@ -1,3 +1,4 @@
+import { createImapError } from '../errors.js';
 /**
  * Requests DEFLATE compression from the server.
  *
@@ -33,8 +34,7 @@ export default async function compress(connection) {
     // back its unconsumed tail on unpipe so the transport can feed it into the
     // inflater - not something a command module can reach from here.
     if (response.hasTrailingData) {
-        let error = new Error('Server sent data between the COMPRESS response and the compression layer switch');
-        error.code = 'COMPRESS_TRAILING_DATA';
+        let error = createImapError('Server sent data between the COMPRESS response and the compression layer switch', 'COMPRESS_TRAILING_DATA');
         connection.log.error({ err: error, cid: connection.id });
         // Schedule the close before releasing parser backpressure, so the buffered
         // deflate-framed bytes cannot settle anything before teardown begins. This is

package/node_modules/imapflow/dist/esm/commands/id.js

@@ -1,4 +1,4 @@
-import { formatDateTime, isUnsafeKey } from '../tools.js';
+import { formatDateTime, isUnsafeKey, getStringValue } from '../tools.js';
 /**
  * Sends ID info to the server and updates server info data based on the response.
  *
@@ -36,17 +36,19 @@ export default async function id(connection, clientInfo) {
                     let params = untagged.attributes && untagged.attributes[0];
                     let key;
                     (Array.isArray(params) ? params : [].concat(params || [])).forEach((val, i) => {
+                        // keys are strings and values nstrings, either may come as a literal
+                        let value = getStringValue(val);
                         if (i % 2 === 0) {
-                            key = val.value;
+                            key = value;
                         }
-                        else if (typeof key === 'string' && typeof val.value === 'string') {
+                        else if (key !== undefined && value !== undefined) {
                             // The server picks the keys of this object, which the caller reads
                             // back as serverInfo: a prototype-chain name is skipped as it is for
                             // every other server-named key, so it can neither be shadowed nor
                             // written through
                             let name = key.toLowerCase().trim();
                             if (!isUnsafeKey(name)) {
-                                map[name] = val.value;
+                                map[name] = value;
                             }
                         }
                     });

package/node_modules/imapflow/dist/esm/commands/idle.js

@@ -1,4 +1,5 @@
 import { guardedPromise, hasCapability, isServerRefusal, logConnectionError, restampConnectionError, unrefTimer, clearTimer, getSelectedMailbox } from '../tools.js';
+import { createImapError } from '../errors.js';
 const NOOP_INTERVAL = 2 * 60 * 1000;
 /**
  * Marks the connection as idling on behalf of one session and returns a release function.
@@ -124,14 +125,15 @@ async function runIdle(connection) {
     }
     catch (err) {
         logConnectionError(connection, 'IDLE session failed', err);
-        // A tagged NO or BAD only means the server refused IDLE; the connection is still usable,
-        // so the waiters are released by the finally block below and their own commands run.
-        // Anything else (close, lost socket, parser failure) fails the waiters too.
-        let refusedByServer = isServerRefusal(err);
-        if (refusedByServer) {
+        // A tagged NO or BAD only means the server did not run IDLE; the connection is still
+        // usable, so the waiters are released by the finally block below and their own commands
+        // run. Anything else (close, lost socket, parser failure) fails the waiters too. Only a
+        // refusal turns IDLE off for the session, a throttled IDLE is tried again later.
+        let answeredByServer = err.responseStatus === 'NO' || err.responseStatus === 'BAD';
+        if (isServerRefusal(err)) {
             connection.skipIdle = true;
         }
-        if (preCheckWaitQueue.length && !refusedByServer) {
+        if (preCheckWaitQueue.length && !answeredByServer) {
             // One error for the whole queue: every waiter failed at the same site, for the same
             // reason. Built inside the guard so a teardown with nothing queued - the common case -
             // does not pay for an Error and its stack capture.
@@ -188,9 +190,7 @@ async function pollOnce(connection, session) {
                 highestModseq: true
             });
             if (!status) {
-                let err = new Error('STATUS poll failed');
-                err.code = 'PollFailed';
-                throw err;
+                throw createImapError('STATUS poll failed', 'PollFailed');
             }
             break;
         }

package/node_modules/imapflow/dist/esm/commands/list.js

@@ -1,4 +1,4 @@
-import { decodePath, encodePath, normalizePath, enhanceCommandError, hasCapability, isRev2Active, buildStatusQueryAttributes, getStringList } from '../tools.js';
+import { decodePath, encodePath, normalizePath, enhanceCommandError, hasCapability, isRev2Active, buildStatusQueryAttributes, getStringList, getStringValue } from '../tools.js';
 import { parseStatusList } from './status-fields.js';
 import { specialUse } from '../special-use.js';
 /**
@@ -155,7 +155,7 @@ export default async function list(connection, reference, mailbox, options) {
                             path: normalizePath(connection, decodePath(connection, rawPath)),
                             pathAsListed: rawPath,
                             flags: new Set(getStringList(untagged.attributes[0])),
-                            delimiter: (untagged.attributes[1] && untagged.attributes[1].value),
+                            delimiter: getStringValue(untagged.attributes[1]),
                             listed: true
                         };
                         normalizeFlags(entry);
@@ -396,7 +396,7 @@ export default async function list(connection, reference, mailbox, options) {
                             path: normalizePath(connection, decodePath(connection, rawPath)),
                             pathAsListed: rawPath,
                             flags: new Set(getStringList(untagged.attributes[0])),
-                            delimiter: (untagged.attributes[1] && untagged.attributes[1].value),
+                            delimiter: getStringValue(untagged.attributes[1]),
                             subscribed: true
                         };
                         if (entry.path.toUpperCase() === 'INBOX') {

package/node_modules/imapflow/dist/esm/commands/namespace.js

@@ -1,4 +1,4 @@
-import { hasCapability, getStringList, isAuthenticatedState } from '../tools.js';
+import { hasCapability, getStringList, getStringValue, isAuthenticatedState } from '../tools.js';
 /**
  * Requests NAMESPACE info from the server.
  *
@@ -91,8 +91,9 @@ async function getListPrefix(connection) {
                         return;
                     }
                     map.flags = new Set(getStringList(untagged.attributes[0]));
-                    map.delimiter = (untagged.attributes[1] && untagged.attributes[1].value);
-                    map.prefix = ((untagged.attributes[2] && untagged.attributes[2].value) || '');
+                    // the name may be a literal, which arrives as a Buffer
+                    map.delimiter = getStringValue(untagged.attributes[1]) || null;
+                    map.prefix = getStringValue(untagged.attributes[2]) || '';
                     if (map.delimiter && map.prefix.charAt(0) === map.delimiter) {
                         map.prefix = map.prefix.slice(1);
                     }
@@ -117,22 +118,25 @@ function getNamsepaceInfo(attribute) {
     if (!attribute || !Array.isArray(attribute) || !attribute.length) {
         return false;
     }
-    return attribute
-        .filter(entry => {
-        let pair = entry;
-        // RFC 2342 section 5 allows the delimiter to be NIL when the namespace has
-        // no hierarchy. The token parser emits a literal `null` for NIL.
-        return pair.length >= 2 && pair[0] && typeof pair[0].value === 'string' && (pair[1] === null || (pair[1] && typeof pair[1].value === 'string'));
-    })
-        .map(entry => {
+    let entries = [];
+    for (let entry of attribute) {
+        if (!Array.isArray(entry)) {
+            continue;
+        }
         let pair = entry;
-        let prefix = pair[0].value;
-        let delimiter = pair[1] === null ? null : pair[1].value;
+        let prefix = getStringValue(pair[0]);
+        // RFC 2342 section 5 allows the delimiter to be NIL when the namespace has no hierarchy.
+        // The token parser emits a literal `null` for NIL.
+        let delimiter = pair[1] === null ? null : getStringValue(pair[1]);
+        if (pair.length < 2 || prefix === undefined || delimiter === undefined) {
+            continue;
+        }
         // Append the delimiter to the prefix if it doesn't already end with one,
         // so callers can construct full paths by simply concatenating prefix + name.
         if (delimiter && prefix && prefix.charAt(prefix.length - 1) !== delimiter) {
             prefix += delimiter;
         }
-        return { prefix, delimiter };
-    });
+        entries.push({ prefix, delimiter });
+    }
+    return entries;
 }

package/node_modules/imapflow/dist/esm/commands/quota.js

@@ -1,4 +1,4 @@
-import { encodePath, normalizePath, parseUintValue, isUnsafeKey, isAuthenticatedState, reportCommandError } from '../tools.js';
+import { encodePath, normalizePath, parseUintValue, isUnsafeKey, isAuthenticatedState, reportCommandError, getStringValue } from '../tools.js';
 /**
  * Requests quota information for a mailbox.
  *
@@ -79,9 +79,8 @@ export default async function quota(connection, path) {
                 // QUOTAROOT response tells us which quota root applies to this mailbox.
                 // A mailbox may have zero or one quota root.
                 QUOTAROOT: async (untagged) => {
-                    let quotaRoot = untagged.attributes && untagged.attributes[1] && typeof untagged.attributes[1].value === 'string'
-                        ? untagged.attributes[1].value
-                        : false;
+                    // the root name is an astring, which may come as a literal
+                    let quotaRoot = getStringValue(untagged.attributes && untagged.attributes[1]);
                     if (quotaRoot) {
                         map.quotaRoot = quotaRoot;
                     }

package/node_modules/imapflow/dist/esm/commands/select.d.ts

@@ -1,24 +1,13 @@
 import type { ImapFlow } from '../imap-flow.js';
 import type { MailboxObject, MailboxOpenOptions } from '../types.js';
-/**
- * Options for SELECT/EXAMINE: the public open options plus the QRESYNC resynchronization
- * parameters, which are only honored when the QRESYNC extension has been enabled
- */
-export interface SelectOptions extends MailboxOpenOptions {
-    /** QRESYNC modseq value to fetch changes since */
-    changedSince?: bigint | number | string | undefined;
-    /** QRESYNC UID validity value */
-    uidValidity?: bigint | number | string | undefined;
-}
+/** SELECT/EXAMINE options, the QRESYNC parameters are part of the public mailboxOpen() options */
+export type SelectOptions = MailboxOpenOptions;
 /**
  * Selects or examines a mailbox, making it the current mailbox for subsequent operations.
  *
  * @param connection - IMAP connection instance
  * @param path - Mailbox path to select
- * @param options - Select options
- * @param options.readOnly - If true, use EXAMINE instead of SELECT (read-only access)
- * @param options.changedSince - QRESYNC modseq value to fetch changes since
- * @param options.uidValidity - QRESYNC UID validity value
+ * @param options - Select options, see MailboxOpenOptions
  * @returns Mailbox info object with path, flags, exists, uidNext, uidValidity, highestModseq, etc., or undefined if preconditions not met
  * @throws If the SELECT/EXAMINE command fails
  */

package/node_modules/imapflow/dist/esm/commands/select.js

@@ -48,10 +48,7 @@ const VALUED_RESPONSE_CODES = Object.assign(Object.create(null), {
  *
  * @param connection - IMAP connection instance
  * @param path - Mailbox path to select
- * @param options - Select options
- * @param options.readOnly - If true, use EXAMINE instead of SELECT (read-only access)
- * @param options.changedSince - QRESYNC modseq value to fetch changes since
- * @param options.uidValidity - QRESYNC UID validity value
+ * @param options - Select options, see MailboxOpenOptions
  * @returns Mailbox info object with path, flags, exists, uidNext, uidValidity, highestModseq, etc., or undefined if preconditions not met
  * @throws If the SELECT/EXAMINE command fails
  */

package/node_modules/imapflow/dist/esm/commands/status.js

@@ -1,5 +1,6 @@
 import { encodePath, normalizePath, buildStatusQueryAttributes, isRev2Active, isAuthenticatedState, emitSafe, getSelectedMailbox, logConnectionError } from '../tools.js';
 import { parseStatusList } from './status-fields.js';
+import { createImapError } from '../errors.js';
 // STATUS fields that also refresh the live mailbox state when the queried mailbox is the
 // currently selected one. Keyed by the output property name parseStatusList() reports.
 const MAILBOX_UPDATERS = {
@@ -96,10 +97,7 @@ export default async function status(connection, path, query) {
                 return false;
             });
             if (folders && !folders.length) {
-                let error = new Error(`Mailbox doesn't exist: ${path}`);
-                error.code = 'NotFound';
-                error.response = err;
-                throw error;
+                throw createImapError(`Mailbox doesn't exist: ${path}`, 'NotFound', { response: err });
             }
         }
         connection.log.warn({ err, cid: connection.id });

package/node_modules/imapflow/dist/esm/connection-deadline.d.ts

@@ -1,4 +1,4 @@
-import type { ImapFlowError } from './errors.js';
+import { type ImapFlowError } from './errors.js';
 export declare const CONNECT_TIMEOUT: number;
 /**
  * One deadline for an entire connection attempt.

package/node_modules/imapflow/dist/esm/connection-deadline.js

@@ -1,4 +1,5 @@
 import { clearTimer } from './tools.js';
+import { createImapError } from './errors.js';
 // Default upper bound for establishing a usable transport, including DNS and proxy negotiation.
 export const CONNECT_TIMEOUT = 90 * 1000;
 /**
@@ -28,10 +29,7 @@ export class ConnectionDeadline {
      * @returns The shared `CONNECT_TIMEOUT` error.
      */
     error() {
-        let err = new Error('Failed to establish connection in required time');
-        err.code = 'CONNECT_TIMEOUT';
-        err.details = { connectionTimeout: this.timeout };
-        return err;
+        return createImapError('Failed to establish connection in required time', 'CONNECT_TIMEOUT', { details: { connectionTimeout: this.timeout } });
     }
     /**
      * Maps a dependency's own expiry onto the shared `CONNECT_TIMEOUT` shape, so callers see one