@withbuddi/buddi 0.1.0-pre.50 → 0.1.0-pre.52

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

@@ -19,6 +19,113 @@ const limited_passthrough_js_1 = require("./limited-passthrough.js");
 // away (a consumer destroying it closes it without a 'drain')
 const DRAIN_WAIT_EVENTS = ['drain', 'error', 'close'];
 const tools_js_1 = require("./tools.js");
+const isEmptySection = (value) => !value?.length;
+/**
+ * The section to ask again when exactly one of a part's MIME headers and content came back
+ * empty (see refetchDroppedSections()), undefined when both or neither did
+ */
+const droppedSection = (mime, content, mimeRequest, contentRequest) => {
+    if (isEmptySection(mime) === isEmptySection(content)) {
+        return undefined;
+    }
+    return isEmptySection(content) ? contentRequest : mimeRequest;
+};
+/** Start offset of every partial section among the requests, keyed by section */
+const partialStarts = (requests) => {
+    let starts = new Map();
+    for (let request of requests) {
+        if (typeof request !== 'string') {
+            starts.set(request.key, Number(request.start) || 0);
+        }
+    }
+    return starts;
+};
+// How many times a request is repeated after answers that belong to another request
+const MAX_FOREIGN_ANSWERS = 3;
+const requestedUid = (range, options) => options.uid && /^\d+$/.test(String(range)) ? Number(range) : undefined;
+const isForeignAnswer = (response, expected) => {
+    if (expected.uid && response.uid && response.uid !== expected.uid) {
+        return true;
+    }
+    for (let [key, start] of expected.origins) {
+        let origin = response.partialOrigins && response.partialOrigins.get(key);
+        // An answer without the origin is taken as is: some servers leave it out, and some
+        // ignore the partial specifier altogether
+        if (typeof origin === 'number' && origin !== start) {
+            return true;
+        }
+    }
+    return false;
+};
+/**
+ * fetchOne() that takes only an answer belonging to the request. Apache James now and then
+ * writes the head of a FETCH answer after its tagged OK, so the data of one request shows up
+ * within the answer to the next one. Taken at face value it would be the data of that next
+ * request, and a download would end without an error but with misplaced bytes. An answer for
+ * another UID, or with a partial section that starts at another offset than asked, is dropped
+ * and the request repeated.
+ */
+async function fetchExpected(client, range, query, options, expected) {
+    for (let attempt = 1;; attempt++) {
+        let response = await client.fetchOne(range, query, options);
+        if (!response || !isForeignAnswer(response, expected)) {
+            return response;
+        }
+        client.log.warn({
+            msg: 'Server answered with data of another request, asking again',
+            uid: response.uid,
+            origins: response.partialOrigins && Object.fromEntries(response.partialOrigins),
+            attempt,
+            cid: client.id
+        });
+        if (attempt >= MAX_FOREIGN_ANSWERS) {
+            let err = new Error('Server kept answering with data of another request');
+            err.code = 'DownloadIncomplete';
+            err.cid = client.id;
+            throw err;
+        }
+    }
+}
+/**
+ * Apache James (and the servers built on it, Twake Mail among them) answers only the first
+ * section it is asked for each MIME part of one FETCH and returns the other one empty:
+ * BODY[2.MIME] with BODY[2] yields the headers and a zero-length body, the reverse order loses
+ * the headers (FetchGroup.addPartContent() keeps the first descriptor for a part path). Asks the
+ * sections that came back empty again, in a FETCH of their own, and merges the answer into
+ * `response`. Callers only list a section whose companion did arrive, so a compliant server
+ * pays the extra round trip only for a part that really is empty.
+ */
+async function refetchDroppedSections(client, response, range, options, sections) {
+    if (!sections.length) {
+        return;
+    }
+    client.log.debug({
+        msg: 'Server answered a body section empty while its companion section was not, asking it again separately',
+        sections: sections.map(section => (typeof section === 'string' ? section : section.key)),
+        cid: client.id
+    });
+    // the UID pins the message even when the first command addressed it by sequence number
+    let uid = response.uid;
+    let retry = await fetchExpected(client, uid || range, { uid: true, bodyParts: sections }, uid ? { ...options, uid: true } : options, {
+        uid,
+        origins: partialStarts(sections)
+    });
+    if (!retry) {
+        return;
+    }
+    if (retry.headers) {
+        response.headers = retry.headers;
+    }
+    for (let [key, value] of retry.bodyParts || []) {
+        (response.bodyParts ??= new Map()).set(key, value);
+        if (retry.binaryParts && retry.binaryParts.has(key)) {
+            (response.binaryParts ??= new Set()).add(key);
+        }
+        else if (response.binaryParts) {
+            response.binaryParts.delete(key);
+        }
+    }
+}
 /**
  * Implements ImapFlow.download(), see its documentation
  *
@@ -66,6 +173,7 @@ async function downloadMessage(client, range, part, options) {
     let getNextPart = async (query) => {
         query = query || {};
         let mimeKey;
+        let contentRequest;
         if (!part) {
             query.source = {
                 start: processed,
@@ -88,13 +196,18 @@ async function downloadMessage(client, range, part, options) {
                     query.bodyParts.push(mimeKey);
                 }
             }
-            query.bodyParts.push({
+            contentRequest = {
                 key: part,
                 start: processed,
                 maxLength: chunkSize
-            });
+            };
+            query.bodyParts.push(contentRequest);
         }
-        let response = await client.fetchOne(range, query, downloadOptions);
+        let expected = {
+            uid: uid || requestedUid(range, downloadOptions),
+            origins: new Map([[part || '', processed]])
+        };
+        let response = await fetchExpected(client, range, query, downloadOptions, expected);
         if (!response) {
             return { response: false, chunk: false };
         }
@@ -104,6 +217,12 @@ async function downloadMessage(client, range, part, options) {
             range = uid;
             downloadOptions.uid = true;
         }
+        if (mimeKey && contentRequest) {
+            let dropped = droppedSection(mimeKey === 'header' ? response.headers : response.bodyParts?.get(mimeKey), response.bodyParts?.get(part), mimeKey, contentRequest);
+            if (dropped) {
+                await refetchDroppedSections(client, response, range, downloadOptions, [dropped]);
+            }
+        }
         let chunk = !part ? response.source : response.bodyParts && response.bodyParts.get(part);
         if (!chunk) {
             return {};
@@ -458,16 +577,31 @@ async function downloadMessageParts(client, range, parts, options) {
     // again on the answer for servers that ignore the partial specifier
     let maxBytes = (0, limited_passthrough_js_1.normalizeByteLimit)(downloadOptions.maxBytes);
     let query = { bodyParts: [] };
+    let contentRequests = new Map();
     for (let part of parts) {
         query.bodyParts.push(part + '.mime');
         // The partial specifier carries a 32-bit length (RFC 9051 "number"), so a cap beyond
         // that is applied on the answer alone
-        query.bodyParts.push(maxBytes > 0xffffffff ? part : { key: part, start: 0, maxLength: maxBytes });
+        let contentRequest = maxBytes > 0xffffffff ? part : { key: part, start: 0, maxLength: maxBytes };
+        contentRequests.set(part, contentRequest);
+        query.bodyParts.push(contentRequest);
     }
-    let response = await client.fetchOne(range, query, downloadOptions);
+    let response = await fetchExpected(client, range, query, downloadOptions, {
+        uid: requestedUid(range, downloadOptions),
+        origins: partialStarts(query.bodyParts)
+    });
     if (!response || !response.bodyParts) {
         return {};
     }
+    let dropped = [];
+    for (let [part, contentRequest] of contentRequests) {
+        let section = droppedSection(response.bodyParts.get(part + '.mime'), response.bodyParts.get(part), part + '.mime', contentRequest);
+        if (section) {
+            dropped.push(section);
+        }
+    }
+    // Sections of different parts do not collide, so every dropped one fits in one FETCH
+    await refetchDroppedSections(client, response, range, downloadOptions, dropped);
     let data = {};
     for (let [part, content] of response.bodyParts) {
         let keyParts = part.split('.mime');

package/node_modules/imapflow/dist/cjs/imap-flow.d.ts

@@ -122,8 +122,8 @@ export declare class ImapFlow extends EventEmitter {
      */
     usable: boolean;
     /**
-     * Currently authenticated user or `false` if mailbox is not open
-     * or `true` if connection was authenticated by PREAUTH
+     * `true` once the connection is authenticated (by LOGIN, AUTHENTICATE or a PREAUTH greeting),
+     * `false` before that. The user name is in `options.auth.user`
      */
     authenticated: string | boolean;
     /**

package/node_modules/imapflow/dist/cjs/imap-flow.js

@@ -1500,9 +1500,8 @@ class ImapFlow extends node_events_1.EventEmitter {
                 // of the IP - accepting any "localhost" certificate for any IP-hosted
                 // server, and rejecting legitimate IP-SAN certificates.
                 host: this.host,
-                servername: this.servername,
                 port: this.port
-            }, this.options.tls || {});
+            }, this.tlsServername(), this.options.tls || {});
             this.clearSocketHandlers();
             let settled = false;
             // Single settlement path for the upgrade. Every terminal outcome - handshake
@@ -1513,6 +1512,13 @@ class ImapFlow extends node_events_1.EventEmitter {
             // socket event cannot re-enter an already settled upgrade or leave state behind.
             const settle = (err, result) => {
                 if (settled) {
+                    // A failed handshake can produce more than one error (Bun emits ECONNRESET on
+                    // the TLS socket after the one that settled the upgrade). settle() stays the
+                    // error listener of both sockets until they are torn down, so later errors
+                    // end up here instead of being thrown as unhandled 'error' events.
+                    if (err) {
+                        this.log.debug({ msg: 'Socket error after the TLS upgrade was settled', err, cid: this.id });
+                    }
                     return;
                 }
                 settled = true;
@@ -1520,9 +1526,12 @@ class ImapFlow extends node_events_1.EventEmitter {
                 this.upgradeTimeout = null;
                 this.upgrading = false;
                 this._upgradeReject = null;
-                socketPlain.removeListener('error', settle);
-                if (this.socket && this.socket !== socketPlain) {
-                    this.socket.removeListener('error', settle);
+                if (!err) {
+                    // the generic socket handlers took over in the success callback
+                    socketPlain.removeListener('error', settle);
+                    if (this.socket && this.socket !== socketPlain) {
+                        this.socket.removeListener('error', settle);
+                    }
                 }
                 if (err) {
                     (0, tools_js_1.clearTimer)(this.connectTimeout);
@@ -1540,7 +1549,7 @@ class ImapFlow extends node_events_1.EventEmitter {
             // one function, one settlement, and removeListener() in settle() needs no separate
             // handler references. A TLS handshake failure (bad certificate, protocol mismatch)
             // is emitted on the new TLS socket rather than on the plain one, so both are covered.
-            socketPlain.once('error', settle);
+            socketPlain.on('error', settle);
             /* c8 ignore start */ // UPGRADE_TIMEOUT is 10s; firing it deterministically would make the test suite hang
             this.upgradeTimeout = setTimeout(() => {
                 let err = new Error('Failed to upgrade connection in required time');
@@ -1618,7 +1627,7 @@ class ImapFlow extends node_events_1.EventEmitter {
             // error listener during the handshake window; the generic handlers are installed
             // by setSocketHandlers() inside the success callback above, so a handshake error
             // has a single error path.
-            tlsSocket.once('error', settle);
+            tlsSocket.on('error', settle);
             this.writeSocket = tlsSocket;
         });
         if (upgraded) {
@@ -1892,12 +1901,18 @@ class ImapFlow extends node_events_1.EventEmitter {
             uids = untagged.attributes[0].value;
         }
         let uidList = (0, tools_js_1.expandRange)(uids);
+        let earlier = tags.includes('EARLIER');
+        // RFC 7162 section 3.2.10: unlike VANISHED (EARLIER), a plain VANISHED reports messages the
+        // client knows about and decrements the message count like the same number of EXPUNGEs would
+        if (!earlier) {
+            mailbox.exists = Math.max(0, mailbox.exists - uidList.length);
+        }
         for (let uid of uidList) {
             let payload = {
                 path: mailbox.path,
                 uid,
                 vanished: true,
-                earlier: tags.includes('EARLIER')
+                earlier
             };
             await this.notifyExpunge(payload);
         }
@@ -1909,7 +1924,7 @@ class ImapFlow extends node_events_1.EventEmitter {
             // mailbox closed, ignore
             return;
         }
-        let message = await (0, tools_js_1.formatMessageResponse)(untagged, mailbox, this.idHashAlgorithm);
+        let message = await (0, tools_js_1.formatMessageResponse)(untagged, mailbox, this.idHashAlgorithm, this);
         if (message.flags) {
             let updateEvent = {
                 path: mailbox.path,
@@ -1938,6 +1953,12 @@ class ImapFlow extends node_events_1.EventEmitter {
         }
         return true;
     }
+    // servername for tls.connect(), left out for an IP literal host (this.servername is false then):
+    // Node treats a false value like a missing one, but Bun throws a TypeError for it
+    /** @internal */
+    tlsServername() {
+        return this.servername ? { servername: this.servername } : {};
+    }
     // Normalizes a message range from various input formats into an IMAP-compatible
     // sequence string (e.g., "1:5,7,10:*"). Handles: numbers, "*", {all:true},
     // {uid:value}, search query objects (resolved via SEARCH), and arrays of numbers.
@@ -1980,6 +2001,11 @@ class ImapFlow extends node_events_1.EventEmitter {
         if (!value) {
             return false;
         }
+        // An empty mailbox has no message numbers: every sequence set, "1:*" included, would get a
+        // BAD (RFC 9051 section 9, seq-number). UID sets may point past the end, so they are sent.
+        if (!options.uid && this.mailbox && !this.mailbox.exists) {
+            return false;
+        }
         return value;
     }
     // The single definition of "the connection is not free". A held or queued mailbox lock, a
@@ -2049,9 +2075,8 @@ class ImapFlow extends node_events_1.EventEmitter {
         let connector = this.secureConnection ? node_tls_1.default : node_net_1.default;
         let opts = Object.assign({
             host: this.host,
-            servername: this.servername,
             port: this.port
-        }, this.options.tls || {});
+        }, this.tlsServername(), this.options.tls || {});
         this.untaggedHandlers.OK = (...args) => this.initialOK(...args);
         this.untaggedHandlers.BYE = (...args) => this.serverBye(...args);
         this.untaggedHandlers.PREAUTH = () => this.initialPREAUTH();
@@ -3137,7 +3162,21 @@ class ImapFlow extends node_events_1.EventEmitter {
         if (!response || !response.list || !response.list.length) {
             return false;
         }
-        return response.list[0];
+        // Every FETCH row that arrived during the command is in the list, also unsolicited ones
+        // for other messages or with only a flag change, and a server may split the answer for
+        // one message over several rows. Taking the first row returned a flag update instead
+        // of the requested data, which ended a download after its first chunk (issue #426).
+        let rows = response.list;
+        let requested = (0, tools_js_1.parseUintValue)(String(seq), tools_js_1.MAX_UINT32_DIGITS);
+        // a range: the first message of the answer, as before
+        let target = requested === false ? rows[0] : rows.find(row => (options && options.uid ? row.uid : row.seq) === requested);
+        if (!target) {
+            return false;
+        }
+        // rows of the same message, without the ones a malformed answer gives no usable
+        // sequence number or another UID
+        let { seq: targetSeq, uid: targetUid } = target;
+        return targetSeq ? (0, tools_js_1.mergeFetchRows)(rows.filter(row => row.seq === targetSeq && (!row.uid || !targetUid || row.uid === targetUid))) : target;
     }
     /**
      * Download either full rfc822 formatted message or a specific bodystructure part as a Stream.

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

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

package/node_modules/imapflow/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.2.7";
+exports.version = "2.2.10";
 exports.homepage = "https://imapflow.com/";

package/node_modules/imapflow/dist/cjs/search-compiler.js

@@ -371,10 +371,13 @@ const searchCompiler = (connection, query) => {
                             fail('InvalidSearchQuery', `Search value for ${term.toLowerCase()} must be a string`);
                         }
                         let flag = (0, tools_js_1.formatFlag)(params[term]);
-                        // formatFlag() refuses \Recent, which is not a keyword. Dropping the
-                        // criterion would widen the search, so the query is refused instead
+                        // formatFlag() refuses \Recent, which is not a keyword, and values that are
+                        // not atoms. Dropping the criterion would widen the search, so the query is
+                        // refused instead
                         if (flag === false) {
-                            fail('InvalidSearchQuery', `${params[term]} can not be searched as a keyword, use the "recent" search key instead`);
+                            fail('InvalidSearchQuery', /^\\recent$/i.test(params[term])
+                                ? `${params[term]} can not be searched as a keyword, use the "recent" search key instead`
+                                : `${params[term]} is not a valid keyword`);
                         }
                         // Compiled even when the mailbox does not allow the keyword: the
                         // correct answer is then the empty set, which dropping the

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

@@ -287,15 +287,26 @@ export declare function getColorFlags(color: string | null | undefined): {
     add: string[];
     remove: string[];
 } | null;
+/**
+ * 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
+ */
+export declare function mergeFetchRows(rows: FetchMessageObject[]): FetchMessageObject;
 /**
  * Formats a raw untagged FETCH response into a structured message object.
  *
  * @param untagged - Parsed untagged IMAP response
  * @param mailbox - Current mailbox state object
  * @param idHashAlgorithm - Hash for the fallback message id, `md5` unless the client was told otherwise
+ * @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.
  */
-export declare function formatMessageResponse(untagged: ImapResponse, mailbox: MailboxObject, idHashAlgorithm?: string): Promise<FetchMessageObject>;
+export declare function formatMessageResponse(untagged: ImapResponse, mailbox: MailboxObject, idHashAlgorithm?: string, connection?: ImapFlow): Promise<FetchMessageObject>;
 /**
  * Strips surrounding double quotes from a name string.
  *
@@ -364,8 +375,8 @@ export declare function formatDate(value: unknown): 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.
+ * Normalizes a flag string. Returns false for non-settable flags (e.g. \Recent) and for
+ * values that are not valid flags (keywords must be atoms), and capitalizes system flags properly.
  *
  * @param flag - Flag string to normalize
  * @returns Normalized flag string, or false if the flag cannot be set

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;
@@ -56,6 +57,7 @@ exports.packMessageRange = packMessageRange;
 const libmime_1 = __importDefault(require("libmime"));
 const charsets_js_1 = require("./charsets.js");
 const imap_handler_js_1 = require("./handler/imap-handler.js");
+const imap_formal_syntax_js_1 = __importDefault(require("./handler/imap-formal-syntax.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"));
@@ -336,7 +338,8 @@ function buildStatusQueryAttributes(connection, statusQuery) {
                 }
                 break;
             case 'HIGHESTMODSEQ':
-                if (connection.capabilities.has('CONDSTORE')) {
+                // QRESYNC implies CONDSTORE (RFC 7162 3.2.3)
+                if (connection.capabilities.has('CONDSTORE') || connection.capabilities.has('QRESYNC')) {
                     attributes.push({ type: 'ATOM', value: key.toUpperCase() });
                 }
                 break;
@@ -711,30 +714,74 @@ 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.
  *
  * @param untagged - Parsed untagged IMAP response
  * @param mailbox - Current mailbox state object
  * @param idHashAlgorithm - Hash for the fallback message id, `md5` unless the client was told otherwise
+ * @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 function formatMessageResponse(untagged, mailbox, idHashAlgorithm) {
+async function formatMessageResponse(untagged, mailbox, idHashAlgorithm, connection) {
     let map = {};
     // The sequence number indexes into mailbox state, so an unusable one is dropped rather
     // than coerced to NaN or Infinity
     map.seq = parseUintValue(untagged.command, exports.MAX_UINT32_DIGITS) || undefined;
     let key;
+    // the <origin> of a partial section ("BODY[2]<1024>"), kept for the value that follows
+    let origin = false;
+    let partialOrigins;
+    let recordOrigin = (sectionKey) => {
+        if (origin !== false) {
+            if (!partialOrigins) {
+                partialOrigins = new Map();
+            }
+            partialOrigins.set(sectionKey, origin);
+        }
+    };
     let attributes = ((untagged.attributes && untagged.attributes[1]) || []);
     for (let i = 0, len = attributes.length; i < len; i++) {
         let attribute = attributes[i];
         if (i % 2 === 0) {
+            origin = false;
             key = (await (0, imap_handler_js_1.compiler)({
                 attributes: [attribute]
             }))
                 .toString()
                 .toLowerCase()
-                .replace(/<\d+(\.\d+)?>$/, '');
+                .replace(/<(\d+)(\.\d+)?>$/, (match, start) => {
+                origin = parseUintValue(start, exports.MAX_UINT32_DIGITS);
+                return '';
+            });
             continue;
         }
         /* c8 ignore start */ // defensive: key is always a string produced by the compiler above
@@ -779,6 +826,7 @@ async function formatMessageResponse(untagged, mailbox, idHashAlgorithm) {
             case 'body[]':
             case 'binary[]':
                 map.source = getBuffer(attribute);
+                recordOrigin('');
                 break;
             case 'uid':
                 // A UID feeds mailbox.uidNext one line below, and from there every range
@@ -825,7 +873,8 @@ async function formatMessageResponse(untagged, mailbox, idHashAlgorithm) {
                 map.threadId = getString(attribute);
                 break;
             case 'x-gm-labels':
-                map.labels = new Set(getArray(attribute));
+                // labels are mailbox names, modified UTF-7 unless UTF-8 is enabled
+                map.labels = new Set(getArray(attribute).map(label => (connection ? decodePath(connection, label) : label)));
                 break;
             case 'rfc822.size':
                 map.size = getUint(attribute) || 0;
@@ -871,6 +920,7 @@ async function formatMessageResponse(untagged, mailbox, idHashAlgorithm) {
                         map.bodyParts = new Map();
                     }
                     map.bodyParts.set(partKey, value);
+                    recordOrigin(partKey);
                     if (match[1].toLowerCase() === 'binary') {
                         // The part arrived via FETCH BINARY (RFC 3516, FETCH side folded
                         // into IMAP4rev2), so the server has already removed the
@@ -912,6 +962,10 @@ async function formatMessageResponse(untagged, mailbox, idHashAlgorithm) {
                     .update([path, mailbox.uidValidity?.toString() || '', map.uid.toString()].join(':'))
                     .digest('hex');
     }
+    if (partialOrigins) {
+        // non-enumerable, so it stays out of logged and serialized fetch results
+        Object.defineProperty(map, 'partialOrigins', { value: partialOrigins, writable: true, configurable: true });
+    }
     if (map.flags) {
         let flagColor = getFlagColor(map.flags);
         if (flagColor) {
@@ -1354,14 +1408,22 @@ function formatDateTime(value) {
     let timeStr = date.toISOString().substring(11, 19);
     return `${dateStr} ${timeStr} +0000`;
 }
+// the memoized ATOM-CHAR set of RFC 9051 section 9
+const atomChars = imap_formal_syntax_js_1.default['ATOM-CHAR'];
 /**
- * Normalizes a flag string. Returns false for non-settable flags (e.g. \Recent),
- * and capitalizes system flags properly.
+ * Normalizes a flag string. Returns false for non-settable flags (e.g. \Recent) and for
+ * values that are not valid flags (keywords must be atoms), and capitalizes system flags properly.
  *
  * @param flag - Flag string to normalize
  * @returns Normalized flag string, or false if the flag cannot be set
  */
 function formatFlag(flag) {
+    // RFC 9051 section 9: flag-keyword is an atom and flag-extension is "\\" atom, the same check
+    // the compiler uses to decide what it can send unquoted
+    let atom = flag.charAt(0) === '\\' ? flag.slice(1) : flag;
+    if (!atom || imap_formal_syntax_js_1.default.verify(atom, atomChars()) >= 0) {
+        return false;
+    }
     switch (flag.toLowerCase()) {
         case '\\recent':
             // can not set or remove

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 {
     /**

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

@@ -63,15 +63,26 @@ async function authOauth(connection, username, accessToken) {
         // Empty breaker: XOAUTH2 expects an empty response to abort the SASL exchange
         breaker = '';
     }
+    let encoded = Buffer.from(oauthbearer).toString('base64');
+    // Without SASL-IR the payload may not ride on the command line (RFC 4959 section 3): it is
+    // sent as the answer to the first, empty continuation request instead
+    let payloadPending = !connection.capabilities.has('SASL-IR');
     let errorResponse = false;
     try {
-        let response = await connection.exec('AUTHENTICATE', [
-            { type: 'ATOM', value: command },
-            { type: 'ATOM', value: Buffer.from(oauthbearer).toString('base64'), sensitive: true }
-        ], {
+        let attributes = [{ type: 'ATOM', value: command }];
+        if (!payloadPending) {
+            attributes.push({ type: 'ATOM', value: encoded, sensitive: true });
+        }
+        let response = await connection.exec('AUTHENTICATE', attributes, {
             // Server sends a "+" continuation if auth fails, with a base64 JSON error payload.
             // We decode it for diagnostics, then send the breaker to terminate the exchange.
             onPlusTag: async (resp) => {
+                if (payloadPending) {
+                    payloadPending = false;
+                    connection.log.debug({ src: 'c', msg: '(* value hidden *)', comment: `Encoded response for AUTH=${command}`, cid: connection.id });
+                    connection.write(encoded);
+                    return;
+                }
                 if (resp.attributes && resp.attributes[0] && resp.attributes[0].type === 'TEXT') {
                     try {
                         errorResponse = JSON.parse(Buffer.from(resp.attributes[0].value, 'base64').toString());