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

package/node_modules/express/package.json

@@ -1,7 +1,7 @@
 {
   "name": "express",
   "description": "Fast, unopinionated, minimalist web framework",
-  "version": "5.2.1",
+  "version": "5.3.0",
   "author": "TJ Holowaychuk <tj@vision-media.ca>",
   "contributors": [
     "Aaron Heckmann <aaron.heckmann+github@gmail.com>",
@@ -33,9 +33,9 @@
   ],
   "dependencies": {
     "accepts": "^2.0.0",
-    "body-parser": "^2.2.1",
-    "content-disposition": "^1.0.0",
-    "content-type": "^1.0.5",
+    "body-parser": "^2.3.0",
+    "content-disposition": "^2.0.1",
+    "content-type": "^2.0.0",
     "cookie": "^0.7.1",
     "cookie-signature": "^1.2.1",
     "debug": "^4.4.0",
@@ -51,14 +51,14 @@
     "on-finished": "^2.4.1",
     "once": "^1.4.0",
     "parseurl": "^1.3.3",
-    "proxy-addr": "^2.0.7",
-    "qs": "^6.14.0",
+    "proxy-addr": "^2.0.8",
+    "qs": "^6.16.0",
     "range-parser": "^1.2.1",
     "router": "^2.2.0",
     "send": "^1.1.0",
     "serve-static": "^2.2.0",
     "statuses": "^2.0.1",
-    "type-is": "^2.0.1",
+    "type-is": "^2.1.0",
     "vary": "^1.1.2"
   },
   "devDependencies": {
@@ -69,11 +69,11 @@
     "ejs": "^3.1.10",
     "eslint": "8.47.0",
     "express-session": "^1.18.1",
-    "hbs": "4.2.0",
+    "hbs": "4.3.1",
     "marked": "^15.0.3",
     "method-override": "3.0.0",
-    "mocha": "^10.7.3",
-    "morgan": "1.10.1",
+    "mocha": "^11.7.5",
+    "morgan": "1.12.1",
     "nyc": "^17.1.0",
     "pbkdf2-password": "1.2.1",
     "supertest": "^6.3.0",

package/node_modules/imapflow/CHANGELOG.md

@@ -1,5 +1,38 @@
 # Changelog
 
+## [2.4.0](https://github.com/postalsys/imapflow/compare/v2.3.0...v2.4.0) (2026-10-10)
+
+
+### Features
+
+* re-raise unexpected parser exceptions as coded ParserErrorInternal errors ([dda3f7e](https://github.com/postalsys/imapflow/commit/dda3f7e71e3c227479763a8c6af617fd4f57679a))
+
+
+### Bug Fixes
+
+* keep append literals in sync with their data and fail downloads cleanly ([752248e](https://github.com/postalsys/imapflow/commit/752248e07fd8930cb0943287c32e3bab88484d80))
+
+## [2.3.0](https://github.com/postalsys/imapflow/compare/v2.2.11...v2.3.0) (2026-10-08)
+
+
+### Features
+
+* emit an alert event for ALERT response codes ([dcc0e42](https://github.com/postalsys/imapflow/commit/dcc0e42cef3c5c51226b29fd3a6bddd844728357))
+
+
+### Bug Fixes
+
+* a throttled login is not a rejected credential ([83fdbce](https://github.com/postalsys/imapflow/commit/83fdbce9968651c3d833b1e74bc20151c26fc769))
+* ask the first chunk of a download again when the answer comes back empty ([83fdbce](https://github.com/postalsys/imapflow/commit/83fdbce9968651c3d833b1e74bc20151c26fc769))
+
+## [2.2.11](https://github.com/postalsys/imapflow/compare/v2.2.10...v2.2.11) (2026-10-08)
+
+
+### Bug Fixes
+
+* ask a download chunk again when the answer comes back empty instead of failing the download ([0e6e46a](https://github.com/postalsys/imapflow/commit/0e6e46aa81a16a44ccb78df25382ab78a5708ce3))
+* read NAMESPACE prefixes, QUOTAROOT names and ID values that the server sends as literals ([9c77594](https://github.com/postalsys/imapflow/commit/9c7759468f7d64ad6ef857b1861d4a846a8c7c04))
+
 ## [2.2.10](https://github.com/postalsys/imapflow/compare/v2.2.9...v2.2.10) (2026-10-07)
 
 

package/node_modules/imapflow/dist/cjs/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/cjs/commands/append.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = append;
 const tools_js_1 = require("../tools.js");
+const errors_js_1 = require("../errors.js");
 /**
  * Appends a message to a mailbox.
  *
@@ -18,14 +19,24 @@ async function append(connection, destination, content, flags, idate) {
         // 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 (0, errors_js_1.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;
@@ -82,9 +93,9 @@ async function append(connection, destination, content, flags, idate) {
     // 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/cjs/commands/compress.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = compress;
+const errors_js_1 = require("../errors.js");
 /**
  * Requests DEFLATE compression from the server.
  *
@@ -36,8 +37,7 @@ 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 = (0, errors_js_1.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/cjs/commands/id.js

@@ -39,17 +39,19 @@ 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 = (0, tools_js_1.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 (!(0, tools_js_1.isUnsafeKey)(name)) {
-                                map[name] = val.value;
+                                map[name] = value;
                             }
                         }
                     });

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = idle;
 const tools_js_1 = require("../tools.js");
+const errors_js_1 = require("../errors.js");
 const NOOP_INTERVAL = 2 * 60 * 1000;
 /**
  * Marks the connection as idling on behalf of one session and returns a release function.
@@ -127,14 +128,15 @@ async function runIdle(connection) {
     }
     catch (err) {
         (0, tools_js_1.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 = (0, tools_js_1.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 ((0, tools_js_1.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.
@@ -191,9 +193,7 @@ async function pollOnce(connection, session) {
                 highestModseq: true
             });
             if (!status) {
-                let err = new Error('STATUS poll failed');
-                err.code = 'PollFailed';
-                throw err;
+                throw (0, errors_js_1.createImapError)('STATUS poll failed', 'PollFailed');
             }
             break;
         }

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

@@ -158,7 +158,7 @@ async function list(connection, reference, mailbox, options) {
                             path: (0, tools_js_1.normalizePath)(connection, (0, tools_js_1.decodePath)(connection, rawPath)),
                             pathAsListed: rawPath,
                             flags: new Set((0, tools_js_1.getStringList)(untagged.attributes[0])),
-                            delimiter: (untagged.attributes[1] && untagged.attributes[1].value),
+                            delimiter: (0, tools_js_1.getStringValue)(untagged.attributes[1]),
                             listed: true
                         };
                         normalizeFlags(entry);
@@ -399,7 +399,7 @@ async function list(connection, reference, mailbox, options) {
                             path: (0, tools_js_1.normalizePath)(connection, (0, tools_js_1.decodePath)(connection, rawPath)),
                             pathAsListed: rawPath,
                             flags: new Set((0, tools_js_1.getStringList)(untagged.attributes[0])),
-                            delimiter: (untagged.attributes[1] && untagged.attributes[1].value),
+                            delimiter: (0, tools_js_1.getStringValue)(untagged.attributes[1]),
                             subscribed: true
                         };
                         if (entry.path.toUpperCase() === 'INBOX') {

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

@@ -94,8 +94,9 @@ async function getListPrefix(connection) {
                         return;
                     }
                     map.flags = new Set((0, tools_js_1.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 = (0, tools_js_1.getStringValue)(untagged.attributes[1]) || null;
+                    map.prefix = (0, tools_js_1.getStringValue)(untagged.attributes[2]) || '';
                     if (map.delimiter && map.prefix.charAt(0) === map.delimiter) {
                         map.prefix = map.prefix.slice(1);
                     }
@@ -120,24 +121,27 @@ 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 = (0, tools_js_1.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 : (0, tools_js_1.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;
 }
 module.exports = exports.default;
 Object.defineProperty(module.exports, 'default', { value: exports.default, enumerable: false, writable: true, configurable: true });

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

@@ -82,9 +82,8 @@ 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 = (0, tools_js_1.getStringValue)(untagged.attributes && untagged.attributes[1]);
                     if (quotaRoot) {
                         map.quotaRoot = quotaRoot;
                     }

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = status;
 const tools_js_1 = require("../tools.js");
 const status_fields_js_1 = require("./status-fields.js");
+const errors_js_1 = require("../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 = {
@@ -99,10 +100,7 @@ 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 (0, errors_js_1.createImapError)(`Mailbox doesn't exist: ${path}`, 'NotFound', { response: err });
             }
         }
         connection.log.warn({ err, cid: connection.id });

package/node_modules/imapflow/dist/cjs/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/cjs/connection-deadline.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectionDeadline = exports.CONNECT_TIMEOUT = void 0;
 const tools_js_1 = require("./tools.js");
+const errors_js_1 = require("./errors.js");
 // Default upper bound for establishing a usable transport, including DNS and proxy negotiation.
 exports.CONNECT_TIMEOUT = 90 * 1000;
 /**
@@ -31,10 +32,7 @@ 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 (0, errors_js_1.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

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

@@ -18,6 +18,7 @@ const limited_passthrough_js_1 = require("./limited-passthrough.js");
 // What a wait on the head stream listens for: it can take more input, it failed, or it went
 // away (a consumer destroying it closes it without a 'drain')
 const DRAIN_WAIT_EVENTS = ['drain', 'error', 'close'];
+const errors_js_1 = require("./errors.js");
 const tools_js_1 = require("./tools.js");
 const isEmptySection = (value) => !value?.length;
 /**
@@ -40,8 +41,9 @@ const partialStarts = (requests) => {
     }
     return starts;
 };
-// How many times a request is repeated after answers that belong to another request
-const MAX_FOREIGN_ANSWERS = 3;
+// Attempts per request when the answer belongs to another request or, for a message known to
+// exist, is empty
+const MAX_FETCH_ATTEMPTS = 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) {
@@ -63,11 +65,19 @@ const isForeignAnswer = (response, expected) => {
  * 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.
+ * and the request repeated. An empty answer is repeated too while `expected.retryEmpty()` says
+ * the message exists, as the data of a late answer arrives with the repeated request.
  */
 async function fetchExpected(client, range, query, options, expected) {
     for (let attempt = 1;; attempt++) {
         let response = await client.fetchOne(range, query, options);
+        if (response === false && expected.retryEmpty && expected.retryEmpty() && attempt < MAX_FETCH_ATTEMPTS) {
+            // The answer may come late instead (after the tagged OK, with the next answer), then
+            // it shows up in the answer to the repeated request. A message that is really gone
+            // answers empty every time, and the caller reports it.
+            client.log.warn({ msg: 'Server answered a request for an existing message with no data, asking again', attempt, cid: client.id });
+            continue;
+        }
         if (!response || !isForeignAnswer(response, expected)) {
             return response;
         }
@@ -78,11 +88,8 @@ async function fetchExpected(client, range, query, options, expected) {
             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;
+        if (attempt >= MAX_FETCH_ATTEMPTS) {
+            throw (0, errors_js_1.createImapError)('Server kept answering with data of another request', 'DownloadIncomplete', { cid: client.id });
         }
     }
 }
@@ -108,7 +115,8 @@ async function refetchDroppedSections(client, response, range, options, sections
     let uid = response.uid;
     let retry = await fetchExpected(client, uid || range, { uid: true, bodyParts: sections }, uid ? { ...options, uid: true } : options, {
         uid,
-        origins: partialStarts(sections)
+        origins: partialStarts(sections),
+        retryEmpty: () => true
     });
     if (!retry) {
         return;
@@ -154,7 +162,13 @@ async function downloadMessage(client, range, part, options) {
         // Special handling for part "1": in single-node emails (no childNodes),
         // the body is accessed via "TEXT" rather than "1", and headers via
         // "HEADER" instead of "1.MIME". Check bodyStructure to detect this.
-        let response = await client.fetchOne(range, { uid: true, bodyStructure: true }, downloadOptions);
+        let expectedUid = requestedUid(range, downloadOptions);
+        let response = await fetchExpected(client, range, { uid: true, bodyStructure: true }, downloadOptions, {
+            uid: expectedUid,
+            origins: new Map(),
+            // a message addressed by UID is taken to exist, see getNextPart() below
+            retryEmpty: expectedUid ? () => true : undefined
+        });
         if (!response) {
             return {};
         }
@@ -170,6 +184,14 @@ async function downloadMessage(client, range, part, options) {
             part = 'TEXT';
         }
     }
+    // The decoder pipeline, built once the head chunk told what the part is (see below)
+    let stream;
+    let output;
+    let fetchAborted = false;
+    // A consumer that gave up: its 'close' may still be a tick away from setting fetchAborted,
+    // so the stream's own flag is checked as well
+    // `output` is unset until the head chunk is in, and the head chunk's retry asks already
+    let downloadAborted = () => fetchAborted || !!output?.destroyed;
     let getNextPart = async (query) => {
         query = query || {};
         let mimeKey;
@@ -203,12 +225,23 @@ async function downloadMessage(client, range, part, options) {
             };
             query.bodyParts.push(contentRequest);
         }
+        let expectedUid = uid || requestedUid(range, downloadOptions);
         let expected = {
-            uid: uid || requestedUid(range, downloadOptions),
-            origins: new Map([[part || '', processed]])
+            uid: expectedUid,
+            origins: new Map([[part || '', processed]]),
+            // Every chunk after the first is of a message that was there a moment ago, and a
+            // message the caller addresses by UID is taken to exist: an empty answer may be a
+            // late one (Apache James), a message that is really gone costs two more requests
+            retryEmpty: processed > 0 || expectedUid ? () => !downloadAborted() : undefined
         };
         let response = await fetchExpected(client, range, query, downloadOptions, expected);
         if (!response) {
+            // An empty answer also comes from a connection that closed while the consumer was
+            // paused between chunks (fetchOne() finds no mailbox then), and that is not a
+            // missing message: a caller that retries would skip it
+            if (!client.usable) {
+                throw client.createNoConnectionError(false, { rejectedFrom: 'download' });
+            }
             return { response: false, chunk: false };
         }
         if (!uid && response.uid) {
@@ -316,9 +349,6 @@ async function downloadMessage(client, range, part, options) {
             meta.filename = filename;
         }
     }
-    let stream;
-    let output;
-    let fetchAborted = false;
     // Build a decoder pipeline that progressively transforms the raw FETCH data:
     //   1. Transfer-encoding decoder (base64 or quoted-printable -> binary)
     //   2. Format decoder (format=flowed -> plain text, if applicable)
@@ -348,13 +378,19 @@ async function downloadMessage(client, range, part, options) {
     // would still pull the entire part off the wire.
     let limiters = [];
     let isLimited = () => limiters.some(entry => entry.limited);
+    // Every stage after the head, so a download that ends early can release all of them
+    let stages = [];
     // Appending a stage means forwarding the current tail's errors to it before piping, so a
-    // failure anywhere reaches the stream the caller is reading
+    // failure anywhere reaches the stream the caller is reading. The stage is destroyed with
+    // the error rather than only emitting it: pipe() does not end its destination on a source
+    // error, so a consumer that only listens for 'finish' or 'close' (a plain .pipe() into a
+    // file) would otherwise wait forever.
     let pipeStage = (stage) => {
         output.on('error', err => {
-            stage.emit('error', err);
+            stage.destroy(err);
         });
         output = output.pipe(stage);
+        stages.push(stage);
         return stage;
     };
     let isTextNode = ['text/html', 'text/plain', 'text/x-amp-html'].includes(meta.contentType) || (part === '1' && !meta.contentType);
@@ -399,8 +435,8 @@ async function downloadMessage(client, range, part, options) {
     // Cleanup function
     const cleanup = () => {
         fetchAborted = true;
-        if (stream && !stream.destroyed) {
-            stream.destroy();
+        for (let entry of [stream, ...stages]) {
+            entry.destroy();
         }
     };
     // Listen for stream destruction
@@ -473,26 +509,18 @@ async function downloadMessage(client, range, part, options) {
                 // Loud on purpose. Everything written downstream by this point holds
                 // duplicated content, and a quiet stop is indistinguishable from a clean EOF,
                 // so the consumer would store a corrupt body believing it intact.
-                let err = new Error('Download exceeded the expected message size');
-                err.code = 'DownloadOverflow';
-                err.maxSize = maxTotalBytes;
-                err.cid = client.id;
-                throw err;
+                throw (0, errors_js_1.createImapError)('Download exceeded the expected message size', 'DownloadOverflow', { maxSize: maxTotalBytes, cid: client.id });
             }
             let { response, chunk } = await getNextPart();
-            // A consumer that gave up while the chunk was in flight: its 'close' may still be a
-            // tick away from setting fetchAborted, so the stream's own flag is checked as well
-            if (fetchAborted || output.destroyed) {
+            // A consumer that gave up while the chunk was in flight
+            if (downloadAborted()) {
                 break;
             }
             if (response === false) {
                 // The message is gone mid-download (expunged by another client, or the
                 // mailbox was closed). Ending the stream here would pass the truncated body
                 // off as complete, so the consumer is told the same way as for an overflow.
-                let err = new Error('Message disappeared before the download completed');
-                err.code = 'DownloadIncomplete';
-                err.cid = client.id;
-                throw err;
+                throw (0, errors_js_1.createImapError)('Message disappeared before the download completed', 'DownloadIncomplete', { cid: client.id });
             }
             if (!chunk) {
                 break;
@@ -522,7 +550,7 @@ async function downloadMessage(client, range, part, options) {
         fetchAllParts(head)
             .catch(err => {
             if (!fetchAborted && stream && !stream.destroyed) {
-                stream.emit('error', err);
+                stream.destroy(err);
                 /* c8 ignore start */ // the else logs when a fetch error arrives after the stream was already torn down (timing-dependent)
             }
             else {
@@ -547,7 +575,7 @@ async function downloadMessage(client, range, part, options) {
             // above rejects a promise nobody holds and takes the process down on
             // unhandledRejection. Reaching it always means an invariant broke - the head
             // stream kept pipeStage()'s error forwarder for the life of the download, so
-            // emit('error') above has somewhere to go - which is why it logs at error even
+            // destroy(err) above has somewhere to go - which is why it logs at error even
             // for a routine-looking connection code.
             .catch(err => client.log.error({ msg: 'Failed to fail the download stream', err, cid: client.id }));
     };
@@ -586,9 +614,12 @@ async function downloadMessageParts(client, range, parts, options) {
         contentRequests.set(part, contentRequest);
         query.bodyParts.push(contentRequest);
     }
+    let expectedUid = requestedUid(range, downloadOptions);
     let response = await fetchExpected(client, range, query, downloadOptions, {
-        uid: requestedUid(range, downloadOptions),
-        origins: partialStarts(query.bodyParts)
+        uid: expectedUid,
+        origins: partialStarts(query.bodyParts),
+        // a message addressed by UID is taken to exist, as for download()
+        retryEmpty: expectedUid ? () => true : undefined
     });
     if (!response || !response.bodyParts) {
         return {};

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

@@ -29,6 +29,7 @@ export declare const ImapFlowErrorCode: {
     readonly MissingServerExtension: "MissingServerExtension";
     readonly ParserError: "ParserError";
     readonly ParserErrorExchange: "ParserErrorExchange";
+    readonly ParserErrorInternal: "ParserErrorInternal";
     readonly MAX_IMAP_NESTING_REACHED: "MAX_IMAP_NESTING_REACHED";
     readonly LineTooLarge: "LineTooLarge";
     readonly LiteralTooLarge: "LiteralTooLarge";
@@ -38,6 +39,7 @@ export declare const ImapFlowErrorCode: {
     readonly InvalidTextValue: "InvalidTextValue";
     readonly InvalidSequenceSet: "InvalidSequenceSet";
     readonly InvalidSearchQuery: "InvalidSearchQuery";
+    readonly InvalidMessageContent: "InvalidMessageContent";
     readonly DownloadOverflow: "DownloadOverflow";
     readonly DownloadIncomplete: "DownloadIncomplete";
     readonly ProxyError: "ProxyError";
@@ -48,6 +50,8 @@ export declare const ImapFlowErrorCode: {
 };
 /** One of the {@link ImapFlowErrorCode} values */
 export type ImapFlowErrorCode = (typeof ImapFlowErrorCode)[keyof typeof ImapFlowErrorCode];
+/** A numbered parser error code, `ParserError1` and up */
+export type ParserErrorCode = `ParserError${number}`;
 /**
  * An Error raised by ImapFlow, with the extra properties the library attaches to describe
  * the failure. Every property is optional: which ones are present depends on where the
@@ -132,3 +136,14 @@ export declare class AuthenticationFailure extends Error implements ImapFlowErro
     response?: string | undefined;
     oauthError?: any;
 }
+/**
+ * Creates an {@link ImapFlowError} with a code and optional extra properties. The code is
+ * checked by the compiler against {@link ImapFlowErrorCode}, so a typo or an undeclared
+ * code fails the build instead of reaching consumers.
+ *
+ * @param message - The error message
+ * @param code - The error code
+ * @param props - Extra properties to set on the error
+ * @returns The error, ready to throw or reject with
+ */
+export declare function createImapError(message: string, code: ImapFlowErrorCode | ParserErrorCode, props?: Omit<ImapFlowError, 'name' | 'message' | 'stack' | 'code'> | undefined): ImapFlowError;