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

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

@@ -11,6 +11,7 @@ import { LimitedPassthrough, normalizeByteLimit } from './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'];
+import { createImapError } from './errors.js';
 import { getDecoder, isUnsafeKey } from './tools.js';
 const isEmptySection = (value) => !value?.length;
 /**
@@ -33,8 +34,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) {
@@ -56,11 +58,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;
         }
@@ -71,11 +81,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 createImapError('Server kept answering with data of another request', 'DownloadIncomplete', { cid: client.id });
         }
     }
 }
@@ -101,7 +108,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;
@@ -147,7 +155,13 @@ export 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 {};
         }
@@ -163,6 +177,14 @@ export 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;
@@ -196,12 +218,23 @@ export 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) {
@@ -309,9 +342,6 @@ export 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)
@@ -341,13 +371,19 @@ export 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);
@@ -392,8 +428,8 @@ export 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
@@ -466,26 +502,18 @@ export 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 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 createImapError('Message disappeared before the download completed', 'DownloadIncomplete', { cid: client.id });
             }
             if (!chunk) {
                 break;
@@ -515,7 +543,7 @@ export 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 {
@@ -540,7 +568,7 @@ export 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 }));
     };
@@ -579,9 +607,12 @@ export 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/esm/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;

package/node_modules/imapflow/dist/esm/errors.js

@@ -32,6 +32,8 @@ export const ImapFlowErrorCode = {
     // response parsing and size limits
     ParserError: 'ParserError',
     ParserErrorExchange: 'ParserErrorExchange',
+    // an unexpected exception inside the parser, re-raised with a code; a parser bug
+    ParserErrorInternal: 'ParserErrorInternal',
     MAX_IMAP_NESTING_REACHED: 'MAX_IMAP_NESTING_REACHED',
     LineTooLarge: 'LineTooLarge',
     LiteralTooLarge: 'LiteralTooLarge',
@@ -42,6 +44,7 @@ export const ImapFlowErrorCode = {
     InvalidTextValue: 'InvalidTextValue',
     InvalidSequenceSet: 'InvalidSequenceSet',
     InvalidSearchQuery: 'InvalidSearchQuery',
+    InvalidMessageContent: 'InvalidMessageContent',
     // download()
     DownloadOverflow: 'DownloadOverflow',
     DownloadIncomplete: 'DownloadIncomplete',
@@ -62,3 +65,21 @@ export class AuthenticationFailure extends Error {
         this.authenticationFailed = true;
     }
 }
+/**
+ * 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 function createImapError(message, code, props) {
+    const error = new Error(message);
+    error.code = code;
+    if (props) {
+        Object.assign(error, props);
+    }
+    return error;
+}

package/node_modules/imapflow/dist/esm/handler/imap-compiler.d.ts

@@ -12,13 +12,13 @@ import type { CompilerOptions, ImapCompileInput } from './types.js';
  * @param options.isLogging - If true, redacts sensitive values and truncates long strings/literals for logging purposes.
  * @param options.literalPlus - If true, uses the LITERAL+ extension (appends "+" to literal length markers).
  * @param options.literalMinus - If true, uses the LITERAL- extension for literals up to 4096 bytes.
- * @returns A promise that resolves to an array of Buffers (if asArray is true) or a single concatenated Buffer.
+ * @returns An array of Buffers (if asArray is true) or a single concatenated Buffer.
  */
 declare function compiler(response: ImapCompileInput, options: CompilerOptions & {
     asArray: true;
-}): Promise<Buffer[]>;
+}): Buffer[];
 declare function compiler(response: ImapCompileInput, options?: (CompilerOptions & {
     asArray?: false | undefined;
-}) | undefined): Promise<Buffer>;
-declare function compiler(response: ImapCompileInput, options?: CompilerOptions | undefined): Promise<Buffer | Buffer[]>;
+}) | undefined): Buffer;
+declare function compiler(response: ImapCompileInput, options?: CompilerOptions | undefined): Buffer | Buffer[];
 export default compiler;

package/node_modules/imapflow/dist/esm/handler/imap-compiler.js

@@ -1,5 +1,6 @@
 /* eslint no-console: 0, new-cap: 0 */
 import imapFormalSyntax from './imap-formal-syntax.js';
+import { createImapError } from '../errors.js';
 // A single element of a sequence-set as defined by the RFC 9051 grammar: a number
 // or a range, where "*" stands for the largest number in use. Digit strings are not
 // range-checked here (a server rejects "0" or an overlong number on its own); the
@@ -41,13 +42,11 @@ const CRLF = /[\r\n]/;
  */
 const quoteString = (value) => {
     if (NOT_QUOTABLE.test(value)) {
-        let error = new Error('Unquotable character in IMAP string value');
-        error.code = 'InvalidStringValue';
-        throw error;
+        throw createImapError('Unquotable character in IMAP string value', 'InvalidStringValue');
     }
     return '"' + value.replace(/["\\]/g, char => '\\' + char) + '"';
 };
-async function compiler(response, options) {
+function compiler(response, options) {
     let { asArray, isLogging, literalPlus, literalMinus } = options || {};
     const respParts = [];
     // Formats an entry (string, number or Buffer) into the Buffer that is written to
@@ -62,9 +61,7 @@ async function compiler(response, options) {
     const emitEntry = (entry, opts) => {
         let { returnEmpty, raw } = opts || {};
         if (!raw && !isLogging && (typeof entry === 'string' || Buffer.isBuffer(entry)) && CRLF.test(entry.toString('latin1'))) {
-            let error = new Error('Line terminator in IMAP token');
-            error.code = 'InvalidTokenValue';
-            throw error;
+            throw createImapError('Line terminator in IMAP token', 'InvalidTokenValue');
         }
         if (typeof entry === 'string') {
             return Buffer.from(entry);
@@ -88,7 +85,7 @@ async function compiler(response, options) {
     // Set right after the compiler writes "(" or "[" itself, so the first element inside gets no
     // leading space
     let afterOpener = false;
-    let walk = async (node, options) => {
+    let walk = (node, options) => {
         options = options || {};
         // Add a space separator when:
         // - The previous token was a LITERAL. Literal data ends exactly at its declared length, so
@@ -120,7 +117,7 @@ async function compiler(response, options) {
                 if (subArray && !Array.isArray(child)) {
                     subArray = false;
                 }
-                await walk(child, { subArray });
+                walk(child, { subArray });
             }
             resp.push(emitEntry(')'));
             afterOpener = false;
@@ -154,6 +151,11 @@ async function compiler(response, options) {
                     resp.push(emitEntry(logPlaceholder(node.value.length, 'literal')));
                 }
                 else {
+                    // The size marker must match the bytes emitEntry() writes, and it writes
+                    // nothing for a value that is not a Buffer or a string
+                    if (node.value && !Buffer.isBuffer(node.value) && typeof node.value !== 'string') {
+                        throw createImapError('Literal value must be a Buffer or a string', 'InvalidTokenValue');
+                    }
                     // The literal size marker counts octets - string values are written as
                     // UTF-8, so their UTF-16 .length would undercount multi-byte characters
                     let literalLength = !node.value ? 0 : Buffer.isBuffer(node.value) ? node.value.length : Buffer.byteLength(node.value.toString());
@@ -208,9 +210,7 @@ async function compiler(response, options) {
                 if (!isLogging) {
                     val = node.value === null || node.value === undefined ? '' : node.value.toString();
                     if (!isValidSequenceSet(val)) {
-                        let error = new Error('Invalid sequence set value');
-                        error.code = 'InvalidSequenceSet';
-                        throw error;
+                        throw createImapError('Invalid sequence set value', 'InvalidSequenceSet');
                     }
                     resp.push(emitEntry(val, { raw: true }));
                 }
@@ -225,9 +225,7 @@ async function compiler(response, options) {
                 // this check runs first only to raise the more specific InvalidTextValue code.
                 if (node.value) {
                     if (!isLogging && CRLF.test(node.value.toString())) {
-                        let error = new Error('Line terminator in IMAP text value');
-                        error.code = 'InvalidTextValue';
-                        throw error;
+                        throw createImapError('Line terminator in IMAP text value', 'InvalidTextValue');
                     }
                     resp.push(emitEntry(node.value));
                 }
@@ -262,7 +260,7 @@ async function compiler(response, options) {
                     resp.push(emitEntry('['));
                     afterOpener = true;
                     for (let child of node.section) {
-                        await walk(child);
+                        walk(child);
                     }
                     resp.push(emitEntry(']'));
                     afterOpener = false;
@@ -281,13 +279,15 @@ async function compiler(response, options) {
     if (response.attributes) {
         let attributes = Array.isArray(response.attributes) ? response.attributes : [].concat(response.attributes);
         for (let child of attributes) {
-            await walk(child);
+            walk(child);
         }
     }
     if (resp.length) {
         respParts.push(resp);
     }
-    const compiled = respParts.map(part => Buffer.concat(part));
+    // A part with a single entry (the data of a synchronizing literal) is used as is: copying a
+    // large message only to send it doubles its memory
+    const compiled = respParts.map(part => (part.length === 1 ? part[0] : Buffer.concat(part)));
     // without asArray there is a single part, returned as is instead of copied
     return asArray ? compiled : compiled.length === 1 ? compiled[0] : Buffer.concat(compiled);
 }

package/node_modules/imapflow/dist/esm/handler/imap-parser.js

@@ -1,5 +1,30 @@
 import imapFormalSyntax from './imap-formal-syntax.js';
 import { ParserInstance } from './parser-instance.js';
+import { createImapError } from '../errors.js';
+import { boundedInput } from './limits.js';
+// The codes the parser raises on purpose: the numbered ParserErrorN codes, ParserErrorExchange,
+// the nesting limit and the inline literal size limit
+const PARSER_ERROR_CODES = /^(?:ParserError\d+|ParserErrorExchange|MAX_IMAP_NESTING_REACHED|LiteralTooLarge)$/;
+/**
+ * Anything the parser throws other than one of its own coded errors - a TypeError from a parser
+ * bug, a RangeError from runaway recursion or a bad Buffer offset (which carries a Node code), a
+ * thrown non-Error - is re-raised as a coded `ParserErrorInternal`, so callers that match on
+ * codes still handle it and settle the command the line belonged to. The fuzz suite treats this
+ * code as a failure, so the guard does not hide parser bugs from the tests.
+ *
+ * @param err - The thrown value
+ * @param input - The line that was being parsed
+ * @returns The error to rethrow
+ */
+function asParserError(err, input) {
+    if (err instanceof Error && PARSER_ERROR_CODES.test(err.code || '')) {
+        return err;
+    }
+    return createImapError(`Unexpected parser failure: ${err instanceof Error ? err.message : String(err)}`, 'ParserErrorInternal', {
+        parserContext: boundedInput(input.toString()),
+        ...(err instanceof Error ? { _err: err } : {})
+    });
+}
 /**
  * Parses a raw IMAP command or response buffer into a structured object.
  * Handles edge cases such as null-byte-padded responses from buggy servers and
@@ -20,7 +45,7 @@ export default async function parser(command, options) {
     // Workaround for buggy IMAP servers that pad responses with leading NUL (\x00) bytes.
     // Some servers (observed in the wild) prepend null bytes to their output, which would
     // cause parsing to fail. We strip them and note how many were removed for diagnostics.
-    if (command[0] === 0) {
+    if (Buffer.isBuffer(command) && command[0] === 0) {
         // find the first non null byte and trim
         let firstNonNull = -1;
         for (let i = 0; i < command.length; i++) {
@@ -33,7 +58,7 @@ export default async function parser(command, options) {
             // All bytes are null, treat as a BAD response
             return { tag: '*', command: 'BAD', attributes: [] };
         }
-        command = command.slice(firstNonNull);
+        command = command.subarray(firstNonNull);
         nullBytesRemoved = firstNonNull;
     }
     const parserInstance = new ParserInstance(command, options);
@@ -65,7 +90,7 @@ export default async function parser(command, options) {
         }
     }
     catch (err) {
-        let error = err;
+        let error = asParserError(err, command);
         if (error.code === 'ParserErrorExchange' && error.parserContext && error.parserContext.value) {
             return error.parserContext.value;
         }

package/node_modules/imapflow/dist/esm/handler/imap-stream.js

@@ -1,6 +1,7 @@
 import { Transform } from 'node:stream';
 import { createConnectionLogger } from '../logger.js';
 import { MAX_LITERAL_SIZE, MAX_LINE_SIZE, MAX_RESPONSE_SIZE, normalizeLimit, createLiteralTooLargeError } from './limits.js';
+import { createImapError } from '../errors.js';
 const LINE = 0x01;
 const LITERAL = 0x02;
 const LF = 0x0a;
@@ -177,10 +178,10 @@ export class ImapStream extends Transform {
         if (lineLength <= this.maxLineLength) {
             return true;
         }
-        const err = new Error(`Line length ${lineLength} exceeds maximum allowed size of ${this.maxLineLength} bytes`);
-        err.code = 'LineTooLarge';
-        err.lineLength = lineLength;
-        err.maxSize = this.maxLineLength;
+        const err = createImapError(`Line length ${lineLength} exceeds maximum allowed size of ${this.maxLineLength} bytes`, 'LineTooLarge', {
+            lineLength,
+            maxSize: this.maxLineLength
+        });
         return this.failStream(err);
     }
     /**
@@ -203,10 +204,10 @@ export class ImapStream extends Transform {
             }
             return true;
         }
-        const err = new Error(`Response size ${total} exceeds maximum allowed size of ${this.maxResponseSize} bytes`);
-        err.code = 'ResponseTooLarge';
-        err.responseSize = total;
-        err.maxSize = this.maxResponseSize;
+        const err = createImapError(`Response size ${total} exceeds maximum allowed size of ${this.maxResponseSize} bytes`, 'ResponseTooLarge', {
+            responseSize: total,
+            maxSize: this.maxResponseSize
+        });
         return this.failStream(err);
     }
     /**

package/node_modules/imapflow/dist/esm/handler/limits.d.ts

@@ -1,4 +1,4 @@
-import type { ImapFlowError } from '../errors.js';
+import { type ImapFlowError } from '../errors.js';
 export declare const MAX_LITERAL_SIZE: number;
 export declare const MAX_LINE_SIZE: number;
 export declare const MAX_RESPONSE_SIZE: number;

package/node_modules/imapflow/dist/esm/handler/limits.js

@@ -1,6 +1,7 @@
 // Shared response-size limits for the IMAP parser. Kept in one place so the streaming parser
 // (ImapStream) and the standalone token parser cannot drift apart, and so the documented
 // defaults in the ImapFlowOptions type describe both paths.
+import { createImapError } from '../errors.js';
 // Maximum allowed literal size: 1GB (1073741824 bytes)
 export const MAX_LITERAL_SIZE = 1024 * 1024 * 1024;
 // Default maximum length of a single line (a response without a literal). Matches the literal cap:
@@ -51,10 +52,7 @@ export const normalizeLimit = (value, defaultValue) => (Number.isInteger(value)
  * @param reason - What the bound was, when it is not the configured maximum.
  * @returns The error to emit or throw.
  */
-export const createLiteralTooLargeError = (literalSize, maxSize, reason) => {
-    const err = new Error(`Literal size ${literalSize} exceeds ${reason || `maximum allowed size of ${maxSize} bytes`}`);
-    err.code = 'LiteralTooLarge';
-    err.literalSize = literalSize;
-    err.maxSize = maxSize;
-    return err;
-};
+export const createLiteralTooLargeError = (literalSize, maxSize, reason) => createImapError(`Literal size ${literalSize} exceeds ${reason || `maximum allowed size of ${maxSize} bytes`}`, 'LiteralTooLarge', {
+    literalSize,
+    maxSize
+});