imapflow 1.4.8 → 1.5.0

package/test/commands-integration-test.js

@@ -49,6 +49,10 @@ const createMockConnection = (overrides = {}) => {
         close: overrides.close || (() => {}),
         emit: overrides.emit || (() => {}),
         currentSelectCommand: false,
+        skipListSubscribedArg: false,
+        skipListStatusArgs: false,
+        skipListAuxArgs: false,
+        skipLsub: false,
         messageFlagsAdd: overrides.messageFlagsAdd || (async () => {}),
         run: overrides.run || (async () => {}),
         exec:
@@ -64,6 +68,20 @@ const createMockConnection = (overrides = {}) => {
 // Decodes the base64 SASL payload that authenticate() hands to exec().
 const decodeSaslPayload = execArgs => Buffer.from(execArgs.args[1].value, 'base64').toString();
 
+// Builds the error shape the reader loop attaches to failed commands: tagged
+// rejections carry responseStatus ('BAD'/'NO'), transport and throttling
+// failures carry a code ('NoConnection', 'ETHROTTLE').
+const commandError = (message, responseStatus, code) => {
+    let err = new Error(message);
+    if (responseStatus) {
+        err.responseStatus = responseStatus;
+    }
+    if (code) {
+        err.code = code;
+    }
+    return err;
+};
+
 // ============================================
 // CAPABILITY Command Tests
 // ============================================
@@ -442,6 +460,136 @@ module.exports['Commands: search with ALL'] = async test => {
     test.done();
 };
 
+module.exports['Commands: search collects results from an ESEARCH reply to plain SEARCH'] = async test => {
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([['IMAP4rev2', true]]),
+        exec: async (cmd, attrs, opts) => {
+            // IMAP4rev2 servers answer a plain SEARCH with an untagged ESEARCH
+            // response instead of the deprecated SEARCH response
+            if (opts && opts.untagged && opts.untagged.ESEARCH) {
+                await opts.untagged.ESEARCH({
+                    attributes: [
+                        [
+                            { type: 'ATOM', value: 'TAG' },
+                            { type: 'STRING', value: 'A282' }
+                        ],
+                        { type: 'ATOM', value: 'ALL' },
+                        { type: 'ATOM', value: '1:3,5' }
+                    ]
+                });
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await searchCommand(connection, true, {});
+    test.deepEqual(result, [1, 2, 3, 5]);
+    test.done();
+};
+
+module.exports['Commands: search returns empty array for an ESEARCH reply without ALL'] = async test => {
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([['IMAP4rev2', true]]),
+        exec: async (cmd, attrs, opts) => {
+            // RFC 9051: an ESEARCH response with no matches omits the ALL item
+            if (opts && opts.untagged && opts.untagged.ESEARCH) {
+                await opts.untagged.ESEARCH({
+                    attributes: [
+                        [
+                            { type: 'ATOM', value: 'TAG' },
+                            { type: 'STRING', value: 'A282' }
+                        ],
+                        { type: 'ATOM', value: 'COUNT' },
+                        { type: 'ATOM', value: '0' }
+                    ]
+                });
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await searchCommand(connection, true, {});
+    test.deepEqual(result, []);
+    test.done();
+};
+
+module.exports['Commands: search caps a hostile ESEARCH ALL range at the mailbox size'] = async test => {
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([['IMAP4rev2', true]]),
+        mailbox: { path: 'INBOX', exists: 100 },
+        exec: async (cmd, attrs, opts) => {
+            // A few bytes of hostile response must not expand into billions of ids
+            await opts.untagged.ESEARCH({
+                attributes: [
+                    { type: 'ATOM', value: 'ALL' },
+                    { type: 'ATOM', value: '1:4294967295' }
+                ]
+            });
+            return { next: () => {} };
+        }
+    });
+
+    const result = await searchCommand(connection, true, {});
+    // A conforming server cannot match more messages than the mailbox holds
+    test.equal(result.length, 100);
+    test.equal(result[0], 1);
+    test.equal(result[99], 100);
+    test.done();
+};
+
+module.exports['Commands: search resolves * in an ESEARCH ALL sequence-set'] = async test => {
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([['IMAP4rev2', true]]),
+        mailbox: { path: 'INBOX', exists: 5 },
+        exec: async (cmd, attrs, opts) => {
+            await opts.untagged.ESEARCH({
+                attributes: [
+                    { type: 'ATOM', value: 'ALL' },
+                    { type: 'ATOM', value: '3:*' }
+                ]
+            });
+            return { next: () => {} };
+        }
+    });
+
+    const result = await searchCommand(connection, true, {});
+    // '*' means the largest sequence number in use, which is the EXISTS count
+    test.deepEqual(result, [3, 4, 5]);
+    test.done();
+};
+
+module.exports['Commands: search drops * from ESEARCH UID results'] = async test => {
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([['IMAP4rev2', true]]),
+        mailbox: { path: 'INBOX', exists: 5, uidNext: 1000 },
+        exec: async (cmd, attrs, opts) => {
+            await opts.untagged.ESEARCH({
+                attributes: [
+                    [
+                        { type: 'ATOM', value: 'TAG' },
+                        { type: 'STRING', value: 'A1' }
+                    ],
+                    { type: 'ATOM', value: 'UID' },
+                    { type: 'ATOM', value: 'ALL' },
+                    { type: 'ATOM', value: '7,3:*' }
+                ]
+            });
+            return { next: () => {} };
+        }
+    });
+
+    const result = await searchCommand(connection, true, { uid: true });
+    // Server-sent UID sets may not contain '*' (RFC 9051 4.1.1) - the offending
+    // part is dropped, valid parts are kept
+    test.deepEqual(result, [7]);
+    test.done();
+};
+
 module.exports['Commands: search with UID option'] = async test => {
     let execCmd = null;
     const connection = createMockConnection({
@@ -572,6 +720,26 @@ module.exports['Commands: store add flags'] = async test => {
     test.done();
 };
 
+module.exports['Commands: store drops the Recent flag from the wire'] = async test => {
+    let execArgs = null;
+    const connection = createMockConnection({
+        state: 3,
+        exec: async (cmd, attrs) => {
+            execArgs = { cmd, attrs };
+            return { next: () => {} };
+        }
+    });
+
+    // \Recent is owned by the server (and removed entirely in IMAP4rev2) - a
+    // client-side STORE must never try to set it
+    const result = await storeCommand(connection, '1:10', ['\\Seen', '\\Recent'], { operation: 'add' });
+    test.equal(result, true);
+    const attrsStr = JSON.stringify(execArgs.attrs);
+    test.ok(attrsStr.includes('\\\\Seen'));
+    test.ok(!attrsStr.toLowerCase().includes('recent'));
+    test.done();
+};
+
 module.exports['Commands: store remove flags'] = async test => {
     let execArgs = null;
     const connection = createMockConnection({
@@ -1208,6 +1376,23 @@ module.exports['Commands: move with UID and MOVE capability'] = async test => {
     test.done();
 };
 
+module.exports['Commands: move uses MOVE via folded rev2 capability'] = async test => {
+    let execCmd = null;
+    const connection = createMockConnection({
+        state: 3,
+        // No MOVE token - RFC 9051 folds MOVE into base IMAP4rev2
+        capabilities: new Map([['IMAP4rev2', true]]),
+        exec: async cmd => {
+            execCmd = cmd;
+            return { next: () => {}, response: { attributes: [] } };
+        }
+    });
+
+    await moveCommand(connection, '1:10', 'Archive', {});
+    test.equal(execCmd, 'MOVE');
+    test.done();
+};
+
 module.exports['Commands: move skips when not selected'] = async test => {
     const connection = createMockConnection({ state: 2 });
 
@@ -1561,6 +1746,25 @@ module.exports['Commands: expunge with UID range'] = async test => {
     test.done();
 };
 
+module.exports['Commands: expunge uses UID EXPUNGE via folded rev2 capability'] = async test => {
+    let execCmd = null;
+    const connection = createMockConnection({
+        state: 3,
+        // No UIDPLUS token - RFC 9051 folds UIDPLUS into base IMAP4rev2. Falling
+        // back to plain EXPUNGE here would purge every \Deleted message instead
+        // of only the requested range.
+        capabilities: new Map([['IMAP4rev2', true]]),
+        exec: async cmd => {
+            execCmd = cmd;
+            return { next: () => {}, response: { attributes: [] } };
+        }
+    });
+
+    await expungeCommand(connection, '1:100', { uid: true });
+    test.equal(execCmd, 'UID EXPUNGE');
+    test.done();
+};
+
 module.exports['Commands: expunge skips when not selected'] = async test => {
     const connection = createMockConnection({ state: 2 });
 
@@ -2480,6 +2684,79 @@ module.exports['Commands: enable handles error'] = async test => {
     test.done();
 };
 
+module.exports['Commands: enable passes IMAP4rev2 through the capability prefilter'] = async test => {
+    let enableAttrs = null;
+    const connection = createMockConnection({
+        state: 2,
+        capabilities: new Map([
+            ['ENABLE', true],
+            ['IMAP4rev1', true],
+            // Canonical mixed-case key as stored by updateCapabilities
+            ['IMAP4rev2', true]
+        ]),
+        exec: async (cmd, attrs, opts) => {
+            enableAttrs = attrs;
+            if (opts && opts.untagged && opts.untagged.ENABLED) {
+                await opts.untagged.ENABLED({ attributes: [{ value: 'IMAP4rev2' }] });
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await enableCommand(connection, ['IMAP4rev2']);
+    // The mixed-case capability key must not trip the case-sensitive lookup
+    test.ok(enableAttrs);
+    test.ok(enableAttrs.some(attr => attr.value === 'IMAP4REV2'));
+    test.ok(result.has('IMAP4REV2'));
+    test.done();
+};
+
+module.exports['Commands: enable merges into previously enabled extensions'] = async test => {
+    const connection = createMockConnection({
+        state: 2,
+        capabilities: new Map([
+            ['ENABLE', true],
+            ['IMAP4rev1', true],
+            ['IMAP4rev2', true]
+        ]),
+        enabled: new Set(['CONDSTORE']),
+        exec: async (cmd, attrs, opts) => {
+            if (opts && opts.untagged && opts.untagged.ENABLED) {
+                await opts.untagged.ENABLED({ attributes: [{ value: 'IMAP4rev2' }] });
+            }
+            return { next: () => {} };
+        }
+    });
+
+    await enableCommand(connection, ['IMAP4rev2']);
+    // The ENABLED response only lists newly enabled extensions - earlier grants
+    // must survive
+    test.ok(connection.enabled.has('CONDSTORE'));
+    test.ok(connection.enabled.has('IMAP4REV2'));
+    test.done();
+};
+
+module.exports['Commands: enable works without the ENABLE token on rev2-only servers'] = async test => {
+    let execCalled = false;
+    const connection = createMockConnection({
+        state: 2,
+        // ENABLE is part of base IMAP4rev2 - rev2-only servers may omit the token
+        capabilities: new Map([['IMAP4rev2', true]]),
+        exec: async (cmd, attrs, opts) => {
+            execCalled = true;
+            if (opts && opts.untagged && opts.untagged.ENABLED) {
+                await opts.untagged.ENABLED({ attributes: [{ value: 'IMAP4rev2' }] });
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await enableCommand(connection, ['IMAP4rev2']);
+    test.equal(execCalled, true);
+    test.ok(result.has('IMAP4REV2'));
+    test.done();
+};
+
 // ============================================
 // COMPRESS Command Tests
 // ============================================
@@ -2745,6 +3022,97 @@ module.exports['Commands: fetch with BINARY capability'] = async test => {
     test.done();
 };
 
+module.exports['Commands: fetch with binary uses BINARY on rev2-only servers without the token'] = async test => {
+    let queryAttrs = null;
+    const connection = createMockConnection({
+        state: 3,
+        // rev2-only server: no BINARY token, but RFC 9051 folds the FETCH side of
+        // the BINARY extension into base IMAP4rev2
+        capabilities: new Map([['IMAP4rev2', true]]),
+        exec: async (cmd, attrs) => {
+            queryAttrs = attrs;
+            return { next: () => {} };
+        }
+    });
+
+    await fetchCommand(connection, '1', { source: true }, { binary: true });
+    test.ok(queryAttrs);
+    test.ok(JSON.stringify(queryAttrs).includes('BINARY.PEEK'));
+    test.done();
+};
+
+module.exports['Commands: fetch with binary keeps BODY for non-numeric sections'] = async test => {
+    let queryAttrs = null;
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([['BINARY', true]]),
+        exec: async (cmd, attrs) => {
+            queryAttrs = attrs;
+            return { next: () => {} };
+        }
+    });
+
+    // RFC 3516/RFC 9051: section-binary only allows numeric part specifiers -
+    // BINARY[HEADER], BINARY[TEXT] and BINARY[n.MIME] are invalid syntax that
+    // servers reject, so those sections must stay BODY fetches even with
+    // options.binary set
+    await fetchCommand(connection, '1', { headers: true, bodyParts: ['TEXT', '1.MIME', '1.2'] }, { binary: true });
+    test.ok(queryAttrs);
+    const sections = [];
+    const walk = list => {
+        for (let entry of Array.isArray(list) ? list : [list]) {
+            if (Array.isArray(entry)) {
+                walk(entry);
+            } else if (entry && entry.section) {
+                sections.push({ value: entry.value, section: entry.section.length ? entry.section[0].value : '' });
+            }
+        }
+    };
+    walk(queryAttrs);
+
+    for (let entry of sections) {
+        if (['HEADER', 'TEXT', '1.MIME'].includes(entry.section)) {
+            test.equal(entry.value, 'BODY.PEEK', `${entry.section} must be fetched via BODY.PEEK`);
+        }
+        if (entry.section === '1.2') {
+            test.equal(entry.value, 'BINARY.PEEK', 'numeric part specifiers may use BINARY.PEEK');
+        }
+    }
+    test.ok(
+        sections.some(entry => entry.section === '1.2'),
+        'numeric body part present'
+    );
+    test.ok(
+        sections.some(entry => entry.section === 'TEXT'),
+        'TEXT body part present'
+    );
+    test.done();
+};
+
+module.exports['Commands: fetch with binary keeps BODY on unenabled dual rev1+rev2 servers'] = async test => {
+    let queryAttrs = null;
+    const connection = createMockConnection({
+        state: 3,
+        // dual server without ENABLE IMAP4rev2 - rev2 semantics are not active, so
+        // the BINARY fold must not apply
+        capabilities: new Map([
+            ['IMAP4rev1', true],
+            ['IMAP4rev2', true]
+        ]),
+        exec: async (cmd, attrs) => {
+            queryAttrs = attrs;
+            return { next: () => {} };
+        }
+    });
+
+    await fetchCommand(connection, '1', { source: true }, { binary: true });
+    test.ok(queryAttrs);
+    const queryStr = JSON.stringify(queryAttrs);
+    test.ok(queryStr.includes('BODY.PEEK'));
+    test.ok(!queryStr.includes('BINARY.PEEK'));
+    test.done();
+};
+
 module.exports['Commands: fetch with OBJECTID capability'] = async test => {
     let queryAttrs = null;
     const connection = createMockConnection({
@@ -3223,14 +3591,11 @@ module.exports['Commands: list with statusQuery'] = async test => {
     test.done();
 };
 
-module.exports['Commands: list with CONDSTORE status query'] = async test => {
+module.exports['Commands: list statusQuery parses inline SIZE and DELETED on rev2 sessions'] = async test => {
     let listAttrs = null;
     const connection = createMockConnection({
         state: 3,
-        capabilities: new Map([
-            ['LIST-STATUS', true],
-            ['CONDSTORE', true]
-        ]),
+        capabilities: new Map([['IMAP4rev2', true]]),
         exec: async (cmd, attrs, opts) => {
             if (cmd === 'LIST') {
                 listAttrs = attrs;
@@ -3239,49 +3604,117 @@ module.exports['Commands: list with CONDSTORE status query'] = async test => {
                         attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'INBOX' }]
                     });
                 }
+                if (opts && opts.untagged && opts.untagged.STATUS) {
+                    await opts.untagged.STATUS({
+                        attributes: [
+                            { value: 'INBOX' },
+                            [{ value: 'MESSAGES' }, { value: '10' }, { value: 'SIZE' }, { value: '12345678901234' }, { value: 'DELETED' }, { value: '3' }]
+                        ]
+                    });
+                }
             }
             return { next: () => {} };
         }
     });
 
-    await listCommand(connection, '', '*', {
-        statusQuery: { highestModseq: true }
+    const result = await listCommand(connection, '', '*', {
+        statusQuery: { messages: true, size: true, deleted: true }
     });
-    test.ok(listAttrs);
     const attrsStr = JSON.stringify(listAttrs);
-    test.ok(attrsStr.includes('HIGHESTMODSEQ'));
+    test.ok(attrsStr.includes('SIZE'));
+    test.ok(attrsStr.includes('DELETED'));
+    const inbox = result.find(entry => entry.path === 'INBOX');
+    test.ok(inbox);
+    test.equal(inbox.status.messages, 10);
+    // STATUS SIZE is a number64 - values beyond 2^32 must survive
+    test.strictEqual(inbox.status.size, 12345678901234);
+    test.strictEqual(inbox.status.deleted, 3);
     test.done();
 };
 
-module.exports['Commands: list with listOnly option'] = async test => {
-    let lsubCalled = false;
+module.exports['Commands: list tolerates an OLDNAME extended data item'] = async test => {
     const connection = createMockConnection({
         state: 3,
+        capabilities: new Map([['IMAP4rev2', true]]),
         exec: async (cmd, attrs, opts) => {
-            if (cmd === 'LSUB') {
-                lsubCalled = true;
-            }
             if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
+                // RFC 9051 6.3.9.7: a LIST response may carry an OLDNAME extended
+                // data item after a RENAME or name normalization - the client must
+                // parse the response without choking on the extra attribute
                 await opts.untagged.LIST({
-                    attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'INBOX' }]
+                    attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'NewBox' }, [{ value: 'OLDNAME' }, [{ value: 'OldBox' }]]]
                 });
             }
             return { next: () => {} };
         }
     });
 
-    const result = await listCommand(connection, '', '*', { listOnly: true });
-    test.equal(lsubCalled, false);
-    test.ok(Array.isArray(result));
+    const result = await listCommand(connection, '', '*');
+    const entry = result.find(folder => folder.path === 'NewBox');
+    test.ok(entry, 'mailbox with OLDNAME extended data must be listed');
+    test.ok(entry.flags.has('\\HasNoChildren'));
     test.done();
 };
 
-module.exports['Commands: list with specialUseHints'] = async test => {
+module.exports['Commands: list with CONDSTORE status query'] = async test => {
+    let listAttrs = null;
     const connection = createMockConnection({
         state: 3,
-        exec: async (cmd, attrs, opts) => {
-            if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
-                await opts.untagged.LIST({
+        capabilities: new Map([
+            ['LIST-STATUS', true],
+            ['CONDSTORE', true]
+        ]),
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LIST') {
+                listAttrs = attrs;
+                if (opts && opts.untagged && opts.untagged.LIST) {
+                    await opts.untagged.LIST({
+                        attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'INBOX' }]
+                    });
+                }
+            }
+            return { next: () => {} };
+        }
+    });
+
+    await listCommand(connection, '', '*', {
+        statusQuery: { highestModseq: true }
+    });
+    test.ok(listAttrs);
+    const attrsStr = JSON.stringify(listAttrs);
+    test.ok(attrsStr.includes('HIGHESTMODSEQ'));
+    test.done();
+};
+
+module.exports['Commands: list with listOnly option'] = async test => {
+    let lsubCalled = false;
+    const connection = createMockConnection({
+        state: 3,
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LSUB') {
+                lsubCalled = true;
+            }
+            if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
+                await opts.untagged.LIST({
+                    attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'INBOX' }]
+                });
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await listCommand(connection, '', '*', { listOnly: true });
+    test.equal(lsubCalled, false);
+    test.ok(Array.isArray(result));
+    test.done();
+};
+
+module.exports['Commands: list with specialUseHints'] = async test => {
+    const connection = createMockConnection({
+        state: 3,
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
+                await opts.untagged.LIST({
                     attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'Sent Items' }]
                 });
             }
@@ -3447,51 +3880,839 @@ module.exports['Commands: list status fallback when LIST-STATUS not supported']
     test.done();
 };
 
-module.exports['Commands: list handles STATUS errors gracefully'] = async test => {
+module.exports['Commands: list handles STATUS errors gracefully'] = async test => {
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map(),
+        run: async cmd => {
+            if (cmd === 'STATUS') {
+                throw new Error('Status failed');
+            }
+        },
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
+                await opts.untagged.LIST({
+                    attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'INBOX' }]
+                });
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await listCommand(connection, '', '*', {
+        statusQuery: { messages: true }
+    });
+    const inbox = result.find(e => e.path === 'INBOX');
+    test.ok(inbox);
+    // Status should have error property
+    test.ok(inbox.status);
+    test.ok(inbox.status.error);
+    test.done();
+};
+
+module.exports['Commands: list sorts by special use'] = async test => {
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([['SPECIAL-USE', true]]),
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
+                // Add folders out of order
+                await opts.untagged.LIST({
+                    attributes: [[{ value: '\\Trash' }], { value: '/' }, { value: 'Trash' }]
+                });
+                await opts.untagged.LIST({
+                    attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'INBOX' }]
+                });
+                await opts.untagged.LIST({
+                    attributes: [[{ value: '\\Sent' }], { value: '/' }, { value: 'Sent' }]
+                });
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await listCommand(connection, '', '*');
+    // INBOX should be first (has \\Inbox special use)
+    test.equal(result[0].specialUse, '\\Inbox');
+    test.done();
+};
+
+module.exports['Commands: list handles delimiter in path'] = async test => {
+    const connection = createMockConnection({
+        state: 3,
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
+                await opts.untagged.LIST({
+                    attributes: [
+                        [{ value: '\\HasNoChildren' }],
+                        { value: '/' },
+                        { value: '/Leading/Slash' } // Path starts with delimiter
+                    ]
+                });
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await listCommand(connection, '', '*');
+    const folder = result.find(e => e.name === 'Slash');
+    test.ok(folder);
+    // Leading delimiter should be removed
+    test.equal(folder.path, 'Leading/Slash');
+    test.done();
+};
+
+module.exports['Commands: list skips Noselect folders for status'] = async test => {
+    let statusCalls = 0;
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map(),
+        run: async cmd => {
+            if (cmd === 'STATUS') {
+                statusCalls++;
+                return { messages: 10 };
+            }
+        },
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
+                await opts.untagged.LIST({
+                    attributes: [[{ value: '\\Noselect' }], { value: '/' }, { value: 'Parent' }]
+                });
+            }
+            return { next: () => {} };
+        }
+    });
+
+    await listCommand(connection, '', '*', { statusQuery: { messages: true } });
+    // STATUS should not be called for Noselect folders
+    test.equal(statusCalls, 0);
+    test.done();
+};
+
+module.exports['Commands: list adds Noselect to NonExistent mailboxes'] = async test => {
+    const connection = createMockConnection({
+        state: 3,
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
+                await opts.untagged.LIST({
+                    attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'INBOX' }]
+                });
+                await opts.untagged.LIST({
+                    attributes: [[{ value: '\\NonExistent' }], { value: '/' }, { value: 'Phantom' }]
+                });
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await listCommand(connection, '', '*');
+    const phantom = result.find(e => e.path === 'Phantom');
+    test.ok(phantom);
+    // RFC 5258: \\NonExistent implies \\Noselect
+    test.equal(phantom.flags.has('\\Noselect'), true);
+    // The original flag is preserved, not replaced
+    test.equal(phantom.flags.has('\\NonExistent'), true);
+    const inbox = result.find(e => e.path === 'INBOX');
+    test.ok(inbox);
+    test.equal(inbox.flags.has('\\Noselect'), false);
+    test.done();
+};
+
+module.exports['Commands: list LSUB merge adds Noselect to NonExistent'] = async test => {
+    const connection = createMockConnection({
+        state: 3,
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
+                await opts.untagged.LIST({
+                    attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'Folder1' }]
+                });
+            }
+            if (cmd === 'LSUB' && opts && opts.untagged && opts.untagged.LSUB) {
+                // Some servers only report \\NonExistent in LSUB responses
+                await opts.untagged.LSUB({
+                    attributes: [[{ value: '\\NonExistent' }], { value: '/' }, { value: 'Folder1' }]
+                });
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await listCommand(connection, '', '*');
+    const folder = result.find(e => e.path === 'Folder1');
+    test.ok(folder);
+    test.equal(folder.subscribed, true);
+    test.equal(folder.flags.has('\\NonExistent'), true);
+    // RFC 5258: \\NonExistent merged from LSUB implies \\Noselect
+    test.equal(folder.flags.has('\\Noselect'), true);
+    test.done();
+};
+
+module.exports['Commands: list uses RETURN (SUBSCRIBED) instead of LSUB on IMAP4rev2'] = async test => {
+    let lsubCalled = false;
+    let listAttrs = false;
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([['IMAP4rev2', true]]),
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LSUB') {
+                lsubCalled = true;
+            }
+            if (cmd === 'LIST') {
+                listAttrs = attrs;
+                if (opts && opts.untagged && opts.untagged.LIST) {
+                    await opts.untagged.LIST({
+                        attributes: [[{ value: '\\Subscribed' }, { value: '\\HasNoChildren' }], { value: '/' }, { value: 'Folder1' }]
+                    });
+                    await opts.untagged.LIST({
+                        attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'Folder2' }]
+                    });
+                }
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await listCommand(connection, '', '*');
+    // IMAP4rev2 removed LSUB, subscription state comes from RETURN (SUBSCRIBED)
+    test.equal(lsubCalled, false);
+    test.ok(JSON.stringify(listAttrs).includes('SUBSCRIBED'));
+    const folder1 = result.find(e => e.path === 'Folder1');
+    test.ok(folder1);
+    test.equal(folder1.subscribed, true);
+    // The \Subscribed attribute is folded into the subscribed property
+    test.equal(folder1.flags.has('\\Subscribed'), false);
+    const folder2 = result.find(e => e.path === 'Folder2');
+    test.ok(folder2);
+    test.ok(!folder2.subscribed);
+    test.done();
+};
+
+module.exports['Commands: list uses RETURN (SUBSCRIBED) with LIST-EXTENDED'] = async test => {
+    let lsubCalled = false;
+    let listAttrs = false;
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([
+            ['IMAP4rev1', true],
+            ['LIST-EXTENDED', true]
+        ]),
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LSUB') {
+                lsubCalled = true;
+            }
+            if (cmd === 'LIST') {
+                listAttrs = attrs;
+                if (opts && opts.untagged && opts.untagged.LIST) {
+                    await opts.untagged.LIST({
+                        attributes: [[{ value: '\\Subscribed' }, { value: '\\HasNoChildren' }], { value: '/' }, { value: 'INBOX' }]
+                    });
+                }
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await listCommand(connection, '', '*');
+    test.equal(lsubCalled, false);
+    test.ok(JSON.stringify(listAttrs).includes('SUBSCRIBED'));
+    const inbox = result.find(e => e.path === 'INBOX');
+    test.ok(inbox);
+    test.equal(inbox.subscribed, true);
+    test.done();
+};
+
+module.exports['Commands: list listOnly does not add RETURN args on IMAP4rev2'] = async test => {
+    let listAttrs = false;
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([['IMAP4rev2', true]]),
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LIST') {
+                listAttrs = attrs;
+                if (opts && opts.untagged && opts.untagged.LIST) {
+                    await opts.untagged.LIST({
+                        attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'INBOX' }]
+                    });
+                }
+            }
+            return { next: () => {} };
+        }
+    });
+
+    await listCommand(connection, '', '*', { listOnly: true });
+    // Just reference and pattern, no RETURN block
+    test.equal(listAttrs.length, 2);
+    test.done();
+};
+
+module.exports['Commands: list survives LSUB rejection'] = async test => {
+    let lsubCalls = 0;
+    const connection = createMockConnection({
+        state: 3,
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LSUB') {
+                lsubCalls++;
+                // e.g. Exchange in IMAP4rev2 mode responds "BAD Command Argument Error"
+                throw commandError('Command failed', 'BAD');
+            }
+            if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
+                await opts.untagged.LIST({
+                    attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'INBOX' }]
+                });
+                await opts.untagged.LIST({
+                    attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'Folder1' }]
+                });
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await listCommand(connection, '', '*');
+    test.equal(result.length, 2);
+    const inbox = result.find(e => e.path === 'INBOX');
+    test.ok(inbox);
+    // INBOX is always reported as subscribed even without LSUB data
+    test.equal(inbox.subscribed, true);
+
+    // The rejection is remembered - a follow-up listing skips LSUB entirely
+    test.equal(connection.skipLsub, true);
+    await listCommand(connection, '', '*');
+    test.equal(lsubCalls, 1);
+    test.done();
+};
+
+module.exports['Commands: list fails when LSUB dies without a server rejection'] = async test => {
+    const connection = createMockConnection({
+        state: 3,
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LSUB') {
+                // Transport failure, no tagged BAD/NO from the server
+                throw commandError('Connection not available', null, 'NoConnection');
+            }
+            if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
+                await opts.untagged.LIST({
+                    attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'INBOX' }]
+                });
+            }
+            return { next: () => {} };
+        }
+    });
+
+    try {
+        await listCommand(connection, '', '*');
+        test.ok(false, 'Should have thrown');
+    } catch (err) {
+        test.equal(err.code, 'NoConnection');
+    }
+    // A transport failure says nothing about LSUB support - must not latch
+    test.ok(!connection.skipLsub);
+    test.done();
+};
+
+module.exports['Commands: list rewrites a parsed error response into text'] = async test => {
+    const connection = createMockConnection({
+        state: 3,
+        exec: async () => {
+            // Same shape as the reader loop attaches for a tagged BAD
+            let err = commandError('Command failed', 'BAD');
+            err.response = { tag: '5', command: 'BAD', attributes: [{ type: 'TEXT', value: 'Command Argument Error. 12' }] };
+            throw err;
+        }
+    });
+
+    try {
+        await listCommand(connection, '', '*');
+        test.ok(false, 'Should have thrown');
+    } catch (err) {
+        // enhanceCommandError folds the parsed object into a plain string
+        test.equal(typeof err.response, 'string');
+        test.ok(err.response.includes('Command Argument Error'));
+    }
+    test.done();
+};
+
+module.exports['Commands: list retries with plain LIST when RETURN is rejected'] = async test => {
+    let listCalls = 0;
+    let lsubCalled = false;
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([
+            ['IMAP4rev1', true],
+            ['LIST-EXTENDED', true]
+        ]),
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LSUB' && opts && opts.untagged && opts.untagged.LSUB) {
+                lsubCalled = true;
+                await opts.untagged.LSUB({
+                    attributes: [[], { value: '/' }, { value: 'Folder1' }]
+                });
+            }
+            if (cmd === 'LIST') {
+                listCalls++;
+                if (JSON.stringify(attrs).includes('SUBSCRIBED')) {
+                    // Partial untagged response arrives before the tagged BAD
+                    if (opts && opts.untagged && opts.untagged.LIST) {
+                        await opts.untagged.LIST({
+                            attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'Folder1' }]
+                        });
+                    }
+                    throw commandError('Command failed', 'BAD');
+                }
+                // Retry must be a plain LIST without RETURN args
+                test.equal(attrs.length, 2);
+                if (opts && opts.untagged && opts.untagged.LIST) {
+                    await opts.untagged.LIST({
+                        attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'Folder1' }]
+                    });
+                }
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await listCommand(connection, '', '*');
+    // Extended attempt, auxiliary-free attempt, plain attempt
+    test.equal(listCalls, 3);
+    test.equal(lsubCalled, true);
+    // Partial rejected-attempt results were discarded - no duplicate entries
+    test.equal(result.filter(e => e.path === 'Folder1').length, 1);
+    const folder = result.find(e => e.path === 'Folder1');
+    test.equal(folder.subscribed, true);
+
+    // The plain retry succeeding right after the rejection proves SUBSCRIBED was
+    // the offending option - a follow-up listing goes straight to plain LIST
+    test.equal(connection.skipListSubscribedArg, true);
+    test.ok(!connection.skipListStatusArgs);
+    await listCommand(connection, '', '*');
+    test.equal(listCalls, 4);
+    test.done();
+};
+
+module.exports['Commands: list does not retry extended LIST on transport errors'] = async test => {
+    let listCalls = 0;
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([['IMAP4rev2', true]]),
+        exec: async cmd => {
+            if (cmd === 'LIST') {
+                listCalls++;
+                // Dropped connection - no tagged BAD/NO from the server
+                throw commandError('Connection not available', null, 'NoConnection');
+            }
+            return { next: () => {} };
+        }
+    });
+
+    try {
+        await listCommand(connection, '', '*');
+        test.ok(false, 'Should have thrown');
+    } catch (err) {
+        test.equal(err.code, 'NoConnection');
+    }
+    // A doomed retry against a dead connection is pointless
+    test.equal(listCalls, 1);
+    test.ok(!connection.skipListSubscribedArg);
+    test.done();
+};
+
+module.exports['Commands: list does not retry extended LIST on NO responses'] = async test => {
+    let listCalls = 0;
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([['IMAP4rev2', true]]),
+        exec: async cmd => {
+            if (cmd === 'LIST') {
+                listCalls++;
+                // RFC 9051: unrecognized RETURN options are rejected with BAD;
+                // NO is a transient operational failure
+                throw commandError('Command failed', 'NO');
+            }
+            return { next: () => {} };
+        }
+    });
+
+    try {
+        await listCommand(connection, '', '*');
+        test.ok(false, 'Should have thrown');
+    } catch (err) {
+        test.equal(err.responseStatus, 'NO');
+    }
+    test.equal(listCalls, 1);
+    test.ok(!connection.skipListSubscribedArg);
+    test.done();
+};
+
+module.exports['Commands: list does not treat throttling as a RETURN rejection'] = async test => {
+    let listCalls = 0;
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([['IMAP4rev2', true]]),
+        exec: async cmd => {
+            if (cmd === 'LIST') {
+                listCalls++;
+                // O365-style throttling surfaces as BAD plus code ETHROTTLE
+                throw commandError('Request is throttled', 'BAD', 'ETHROTTLE');
+            }
+            return { next: () => {} };
+        }
+    });
+
+    try {
+        await listCommand(connection, '', '*');
+        test.ok(false, 'Should have thrown');
+    } catch (err) {
+        test.equal(err.code, 'ETHROTTLE');
+    }
+    // Re-issuing against a throttled server and permanently downgrading the
+    // connection would both be wrong
+    test.equal(listCalls, 1);
+    test.ok(!connection.skipListSubscribedArg);
+    test.done();
+};
+
+module.exports['Commands: list drops RETURN option groups one stage at a time'] = async test => {
+    let listAttempts = [];
+    let lsubCalled = false;
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([
+            ['IMAP4rev1', true],
+            ['LIST-EXTENDED', true],
+            ['LIST-STATUS', true]
+        ]),
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LSUB') {
+                lsubCalled = true;
+            }
+            if (cmd === 'LIST') {
+                let flat = JSON.stringify(attrs);
+                listAttempts.push(flat);
+                if (flat.includes('STATUS')) {
+                    throw commandError('Command failed', 'BAD');
+                }
+                if (opts && opts.untagged && opts.untagged.LIST) {
+                    await opts.untagged.LIST({
+                        attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'Folder1' }]
+                    });
+                }
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await listCommand(connection, '', '*', { statusQuery: { messages: true } });
+    test.equal(listAttempts.length, 4);
+    // Stage 1: both option groups with the auxiliary options
+    test.ok(listAttempts[0].includes('STATUS'));
+    test.ok(listAttempts[0].includes('SUBSCRIBED'));
+    test.ok(listAttempts[0].includes('CHILDREN'));
+    // Stage 2: the same groups without the auxiliary options - the rejection
+    // might have been about the auxiliaries alone
+    test.ok(listAttempts[1].includes('STATUS'));
+    test.ok(listAttempts[1].includes('SUBSCRIBED'));
+    test.ok(!listAttempts[1].includes('CHILDREN'));
+    // Stage 3: SUBSCRIBED dropped, STATUS kept
+    test.ok(listAttempts[2].includes('STATUS'));
+    test.ok(!listAttempts[2].includes('SUBSCRIBED'));
+    // Stage 4: plain
+    test.ok(!listAttempts[3].includes('RETURN'));
+
+    // Only the group whose removal was followed by success is latched - the BAD of
+    // the earlier stages might have been caused by the STATUS group alone, so
+    // SUBSCRIBED stays unproven and gets retried on the next listing
+    test.equal(connection.skipListStatusArgs, true);
+    test.ok(!connection.skipListSubscribedArg);
+    test.ok(!connection.skipListAuxArgs);
+    test.equal(lsubCalled, true);
+    test.equal(result.length, 1);
+
+    // Next listing converges: SUBSCRIBED-only first, no STATUS args
+    const result2 = await listCommand(connection, '', '*', { statusQuery: { messages: true } });
+    test.equal(listAttempts.length, 5);
+    test.ok(listAttempts[4].includes('SUBSCRIBED'));
+    test.ok(!listAttempts[4].includes('STATUS'));
+    test.equal(result2.length, 1);
+    test.done();
+};
+
+module.exports['Commands: list does not latch flags when the reduced retry also dies'] = async test => {
+    let listCalls = 0;
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([
+            ['IMAP4rev1', true],
+            ['LIST-EXTENDED', true],
+            ['LIST-STATUS', true]
+        ]),
+        exec: async cmd => {
+            if (cmd === 'LIST') {
+                listCalls++;
+                if (listCalls === 1) {
+                    throw commandError('Command failed', 'BAD');
+                }
+                // The reduced retry dies on a transport error
+                throw commandError('Connection not available', null, 'NoConnection');
+            }
+            return { next: () => {} };
+        }
+    });
+
+    try {
+        await listCommand(connection, '', '*', { statusQuery: { messages: true } });
+        test.ok(false, 'Should have thrown');
+    } catch (err) {
+        test.equal(err.code, 'NoConnection');
+    }
+    // Nothing was proven - no flag may be latched
+    test.equal(listCalls, 2);
+    test.ok(!connection.skipListSubscribedArg);
+    test.ok(!connection.skipListStatusArgs);
+    test.ok(!connection.skipListAuxArgs);
+    test.done();
+};
+
+module.exports['Commands: list tolerates LSUB NO without latching'] = async test => {
+    let lsubCalls = 0;
+    const connection = createMockConnection({
+        state: 3,
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LSUB') {
+                lsubCalls++;
+                // Transient operational failure, not a missing command
+                throw commandError('Server busy', 'NO');
+            }
+            if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
+                await opts.untagged.LIST({
+                    attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'INBOX' }]
+                });
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await listCommand(connection, '', '*');
+    test.equal(result.length, 1);
+    // NO is transient - the next listing must try LSUB again
+    test.ok(!connection.skipLsub);
+    await listCommand(connection, '', '*');
+    test.equal(lsubCalls, 2);
+    test.done();
+};
+
+module.exports['Commands: list rethrows throttled LSUB without latching'] = async test => {
+    const connection = createMockConnection({
+        state: 3,
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LSUB') {
+                throw commandError('Request is throttled', 'BAD', 'ETHROTTLE');
+            }
+            if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
+                await opts.untagged.LIST({
+                    attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'INBOX' }]
+                });
+            }
+            return { next: () => {} };
+        }
+    });
+
+    try {
+        await listCommand(connection, '', '*');
+        test.ok(false, 'Should have thrown');
+    } catch (err) {
+        test.equal(err.code, 'ETHROTTLE');
+    }
+    // Throttling says nothing about LSUB support
+    test.ok(!connection.skipLsub);
+    test.done();
+};
+
+module.exports['Commands: list folds LSUB-delivered Subscribed flag into the property'] = async test => {
+    const connection = createMockConnection({
+        state: 3,
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
+                await opts.untagged.LIST({
+                    attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'Folder1' }]
+                });
+            }
+            if (cmd === 'LSUB' && opts && opts.untagged && opts.untagged.LSUB) {
+                // Some servers echo the RFC 5258 \Subscribed attribute in LSUB
+                await opts.untagged.LSUB({
+                    attributes: [[{ value: '\\Subscribed' }], { value: '/' }, { value: 'Folder1' }]
+                });
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await listCommand(connection, '', '*');
+    const folder = result.find(e => e.path === 'Folder1');
+    test.equal(folder.subscribed, true);
+    // The flag is folded into the property on the LSUB merge path too
+    test.equal(folder.flags.has('\\Subscribed'), false);
+    test.done();
+};
+
+module.exports['Commands: list retries INBOX fixup plain without latching'] = async test => {
+    let listAttempts = [];
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([
+            ['IMAP4rev1', true],
+            ['LIST-EXTENDED', true]
+        ]),
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LIST') {
+                let flat = JSON.stringify(attrs);
+                listAttempts.push(flat);
+                if (listAttempts.length === 2) {
+                    // Fixup call with RETURN args is rejected by a quirky server
+                    throw commandError('Command failed', 'BAD');
+                }
+                if (opts && opts.untagged && opts.untagged.LIST) {
+                    if (listAttempts.length === 1) {
+                        await opts.untagged.LIST({
+                            attributes: [[{ value: '\\Subscribed' }, { value: '\\HasNoChildren' }], { value: '.' }, { value: 'Prefix.Folder1' }]
+                        });
+                    } else {
+                        await opts.untagged.LIST({
+                            attributes: [[{ value: '\\HasNoChildren' }], { value: '.' }, { value: 'INBOX' }]
+                        });
+                    }
+                }
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await listCommand(connection, 'Prefix.', '*');
+    // Main listing + rejected fixup + plain fixup retry
+    test.equal(listAttempts.length, 3);
+    test.ok(listAttempts[1].includes('SUBSCRIBED'));
+    test.ok(!listAttempts[2].includes('RETURN'));
+    // Entries from the successful main run were kept
+    test.ok(result.find(e => e.path === 'Prefix.Folder1'));
+    test.ok(result.find(e => e.path === 'INBOX'));
+    // The main run succeeded with the same RETURN args - nothing may be latched
+    test.ok(!connection.skipListSubscribedArg);
+    test.ok(!connection.skipListStatusArgs);
+    test.done();
+};
+
+module.exports['Commands: list discards partial results from a rejected INBOX fixup'] = async test => {
+    let listAttempts = [];
+    const connection = createMockConnection({
+        state: 3,
+        capabilities: new Map([
+            ['IMAP4rev1', true],
+            ['LIST-EXTENDED', true]
+        ]),
+        exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LIST') {
+                listAttempts.push(JSON.stringify(attrs));
+                if (listAttempts.length === 1) {
+                    await opts.untagged.LIST({
+                        attributes: [[{ value: '\\Subscribed' }, { value: '\\HasNoChildren' }], { value: '.' }, { value: 'Prefix.Folder1' }]
+                    });
+                } else if (listAttempts.length === 2) {
+                    // The fixup attempt streams an untagged INBOX line and THEN gets
+                    // the tagged BAD - the partial line must not survive the retry
+                    await opts.untagged.LIST({
+                        attributes: [[{ value: '\\HasNoChildren' }], { value: '.' }, { value: 'INBOX' }]
+                    });
+                    throw commandError('Command failed', 'BAD');
+                } else {
+                    await opts.untagged.LIST({
+                        attributes: [[{ value: '\\HasNoChildren' }], { value: '.' }, { value: 'INBOX' }]
+                    });
+                }
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await listCommand(connection, 'Prefix.', '*');
+    test.equal(listAttempts.length, 3);
+    // Exactly one INBOX entry - the rejected attempt's partial line was discarded
+    test.equal(result.filter(e => e.path === 'INBOX').length, 1);
+    test.ok(result.find(e => e.path === 'Prefix.Folder1'));
+    test.done();
+};
+
+module.exports['Commands: list latches only the auxiliary options when the server rejects them'] = async test => {
+    let listAttempts = [];
     const connection = createMockConnection({
         state: 3,
-        capabilities: new Map(),
-        run: async cmd => {
-            if (cmd === 'STATUS') {
-                throw new Error('Status failed');
-            }
-        },
+        capabilities: new Map([
+            ['IMAP4rev1', true],
+            ['LIST-EXTENDED', true],
+            ['LIST-STATUS', true],
+            ['SPECIAL-USE', true]
+        ]),
         exec: async (cmd, attrs, opts) => {
-            if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
+            if (cmd === 'LIST') {
+                let flat = JSON.stringify(attrs);
+                listAttempts.push(flat);
+                if (flat.includes('SPECIAL-USE') || flat.includes('CHILDREN')) {
+                    throw commandError('Command failed', 'BAD');
+                }
                 await opts.untagged.LIST({
-                    attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'INBOX' }]
+                    attributes: [[{ value: '\\Subscribed' }, { value: '\\HasNoChildren' }], { value: '/' }, { value: 'Folder1' }]
                 });
+                if (opts.untagged.STATUS) {
+                    await opts.untagged.STATUS({
+                        attributes: [{ value: 'Folder1' }, [{ value: 'MESSAGES' }, { value: '3' }]]
+                    });
+                }
             }
             return { next: () => {} };
         }
     });
 
-    const result = await listCommand(connection, '', '*', {
-        statusQuery: { messages: true }
-    });
-    const inbox = result.find(e => e.path === 'INBOX');
-    test.ok(inbox);
-    // Status should have error property
-    test.ok(inbox.status);
-    test.ok(inbox.status.error);
+    const result = await listCommand(connection, '', '*', { statusQuery: { messages: true } });
+    // Extended attempt with auxiliaries, then the same groups without them
+    test.equal(listAttempts.length, 2);
+    test.ok(listAttempts[0].includes('SPECIAL-USE'));
+    test.ok(listAttempts[1].includes('STATUS'));
+    test.ok(listAttempts[1].includes('SUBSCRIBED'));
+    test.ok(!listAttempts[1].includes('SPECIAL-USE'));
+    test.ok(!listAttempts[1].includes('CHILDREN'));
+    // Only the auxiliaries are latched - both option groups survived intact
+    test.equal(connection.skipListAuxArgs, true);
+    test.ok(!connection.skipListSubscribedArg);
+    test.ok(!connection.skipListStatusArgs);
+    let folder = result.find(e => e.path === 'Folder1');
+    test.equal(folder.subscribed, true);
+    test.equal(folder.status.messages, 3);
+
+    // The next listing goes straight to the auxiliary-free extended form
+    await listCommand(connection, '', '*', { statusQuery: { messages: true } });
+    test.equal(listAttempts.length, 3);
+    test.ok(listAttempts[2].includes('STATUS'));
+    test.ok(listAttempts[2].includes('SUBSCRIBED'));
+    test.ok(!listAttempts[2].includes('SPECIAL-USE'));
     test.done();
 };
 
-module.exports['Commands: list sorts by special use'] = async test => {
+module.exports['Commands: list falls back to LSUB when RETURN (SUBSCRIBED) is silently ignored'] = async test => {
+    let lsubCalled = false;
     const connection = createMockConnection({
         state: 3,
-        capabilities: new Map([['SPECIAL-USE', true]]),
+        capabilities: new Map([
+            ['IMAP4rev1', true],
+            ['LIST-EXTENDED', true]
+        ]),
         exec: async (cmd, attrs, opts) => {
-            if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
-                // Add folders out of order
-                await opts.untagged.LIST({
-                    attributes: [[{ value: '\\Trash' }], { value: '/' }, { value: 'Trash' }]
-                });
-                await opts.untagged.LIST({
-                    attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'INBOX' }]
+            if (cmd === 'LSUB' && opts && opts.untagged && opts.untagged.LSUB) {
+                lsubCalled = true;
+                await opts.untagged.LSUB({
+                    attributes: [[], { value: '/' }, { value: 'Folder1' }]
                 });
+            }
+            if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
+                // Server accepted RETURN (SUBSCRIBED) but returned no \Subscribed flags
                 await opts.untagged.LIST({
-                    attributes: [[{ value: '\\Sent' }], { value: '/' }, { value: 'Sent' }]
+                    attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'Folder1' }]
                 });
             }
             return { next: () => {} };
@@ -3499,118 +4720,127 @@ module.exports['Commands: list sorts by special use'] = async test => {
     });
 
     const result = await listCommand(connection, '', '*');
-    // INBOX should be first (has \\Inbox special use)
-    test.equal(result[0].specialUse, '\\Inbox');
+    test.equal(lsubCalled, true);
+    test.equal(result.find(e => e.path === 'Folder1').subscribed, true);
     test.done();
 };
 
-module.exports['Commands: list handles delimiter in path'] = async test => {
+module.exports['Commands: list skips the LSUB safety net on rev2 sessions'] = async test => {
+    let lsubCalled = false;
     const connection = createMockConnection({
         state: 3,
+        capabilities: new Map([['IMAP4rev2', true]]),
         exec: async (cmd, attrs, opts) => {
+            if (cmd === 'LSUB') {
+                lsubCalled = true;
+            }
             if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
+                // No folder is subscribed - legitimate on a fresh account, and rev2
+                // removed LSUB so there is nothing to fall back to
                 await opts.untagged.LIST({
-                    attributes: [
-                        [{ value: '\\HasNoChildren' }],
-                        { value: '/' },
-                        { value: '/Leading/Slash' } // Path starts with delimiter
-                    ]
+                    attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'Folder1' }]
                 });
             }
             return { next: () => {} };
         }
     });
 
-    const result = await listCommand(connection, '', '*');
-    const folder = result.find(e => e.name === 'Slash');
-    test.ok(folder);
-    // Leading delimiter should be removed
-    test.equal(folder.path, 'Leading/Slash');
+    await listCommand(connection, '', '*');
+    test.equal(lsubCalled, false);
     test.done();
 };
 
-module.exports['Commands: list skips Noselect folders for status'] = async test => {
-    let statusCalls = 0;
+module.exports['Commands: list honors special-use flags on rev2-only servers'] = async test => {
     const connection = createMockConnection({
         state: 3,
-        capabilities: new Map(),
-        run: async cmd => {
-            if (cmd === 'STATUS') {
-                statusCalls++;
-                return { messages: 10 };
-            }
-        },
+        capabilities: new Map([['IMAP4rev2', true]]),
         exec: async (cmd, attrs, opts) => {
             if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
+                // RFC 9051 folds the RFC 6154 attributes into base rev2 - no separate
+                // SPECIAL-USE capability token is required
                 await opts.untagged.LIST({
-                    attributes: [[{ value: '\\Noselect' }], { value: '/' }, { value: 'Parent' }]
+                    attributes: [[{ value: '\\Sent' }, { value: '\\HasNoChildren' }], { value: '/' }, { value: 'Custom-Sent-Name' }]
                 });
             }
             return { next: () => {} };
         }
     });
 
-    await listCommand(connection, '', '*', { statusQuery: { messages: true } });
-    // STATUS should not be called for Noselect folders
-    test.equal(statusCalls, 0);
+    const result = await listCommand(connection, '', '*');
+    const folder = result.find(e => e.path === 'Custom-Sent-Name');
+    test.equal(folder.specialUse, '\\Sent');
     test.done();
 };
 
-module.exports['Commands: list adds Noselect to NonExistent mailboxes'] = async test => {
+module.exports['Commands: list uses inline STATUS on rev2-only servers and omits RECENT'] = async test => {
+    let listAttrs = false;
+    let statusCommands = 0;
     const connection = createMockConnection({
         state: 3,
+        capabilities: new Map([['IMAP4rev2', true]]),
+        run: async cmd => {
+            if (cmd === 'STATUS') {
+                statusCommands++;
+            }
+            return {};
+        },
         exec: async (cmd, attrs, opts) => {
-            if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
-                await opts.untagged.LIST({
-                    attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'INBOX' }]
-                });
-                await opts.untagged.LIST({
-                    attributes: [[{ value: '\\NonExistent' }], { value: '/' }, { value: 'Phantom' }]
-                });
+            if (cmd === 'LIST') {
+                listAttrs = JSON.stringify(attrs);
+                if (opts && opts.untagged && opts.untagged.LIST) {
+                    await opts.untagged.LIST({
+                        attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'INBOX' }]
+                    });
+                }
+                if (opts && opts.untagged && opts.untagged.STATUS) {
+                    await opts.untagged.STATUS({
+                        attributes: [{ value: 'INBOX' }, [{ value: 'MESSAGES' }, { value: '5' }]]
+                    });
+                }
             }
             return { next: () => {} };
         }
     });
 
-    const result = await listCommand(connection, '', '*');
-    const phantom = result.find(e => e.path === 'Phantom');
-    test.ok(phantom);
-    // RFC 5258: \\NonExistent implies \\Noselect
-    test.equal(phantom.flags.has('\\Noselect'), true);
-    // The original flag is preserved, not replaced
-    test.equal(phantom.flags.has('\\NonExistent'), true);
-    const inbox = result.find(e => e.path === 'INBOX');
-    test.ok(inbox);
-    test.equal(inbox.flags.has('\\Noselect'), false);
+    const result = await listCommand(connection, '', '*', { statusQuery: { messages: true, recent: true } });
+    // LIST-STATUS is part of base rev2, so STATUS data arrives inline
+    test.ok(listAttrs.includes('STATUS'));
+    // RECENT was removed in rev2 and must not be requested
+    test.ok(!listAttrs.includes('RECENT'));
+    test.equal(statusCommands, 0);
+    test.equal(result.find(e => e.path === 'INBOX').status.messages, 5);
+    // The requested recent value is synthesized - rev2 defines it as always 0
+    test.equal(result.find(e => e.path === 'INBOX').status.recent, 0);
     test.done();
 };
 
-module.exports['Commands: list LSUB merge adds Noselect to NonExistent'] = async test => {
+module.exports['Commands: list does not let NonExistent phantoms win special-use by name'] = async test => {
     const connection = createMockConnection({
         state: 3,
         exec: async (cmd, attrs, opts) => {
             if (cmd === 'LIST' && opts && opts.untagged && opts.untagged.LIST) {
+                // Phantom subscription leftover of a deleted folder
                 await opts.untagged.LIST({
-                    attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'Folder1' }]
+                    attributes: [[{ value: '\\NonExistent' }, { value: '\\Subscribed' }], { value: '/' }, { value: 'Sent' }]
                 });
-            }
-            if (cmd === 'LSUB' && opts && opts.untagged && opts.untagged.LSUB) {
-                // Some servers only report \\NonExistent in LSUB responses
-                await opts.untagged.LSUB({
-                    attributes: [[{ value: '\\NonExistent' }], { value: '/' }, { value: 'Folder1' }]
+                // The real sent-mail folder, matched by name
+                await opts.untagged.LIST({
+                    attributes: [[{ value: '\\HasNoChildren' }], { value: '/' }, { value: 'Sent Messages' }]
                 });
             }
+            if (cmd === 'LSUB') {
+                throw commandError('Command failed', 'BAD');
+            }
             return { next: () => {} };
         }
     });
 
     const result = await listCommand(connection, '', '*');
-    const folder = result.find(e => e.path === 'Folder1');
-    test.ok(folder);
-    test.equal(folder.subscribed, true);
-    test.equal(folder.flags.has('\\NonExistent'), true);
-    // RFC 5258: \\NonExistent merged from LSUB implies \\Noselect
-    test.equal(folder.flags.has('\\Noselect'), true);
+    const phantom = result.find(e => e.path === 'Sent');
+    const real = result.find(e => e.path === 'Sent Messages');
+    test.ok(phantom);
+    test.notEqual(phantom.specialUse, '\\Sent');
+    test.equal(real.specialUse, '\\Sent');
     test.done();
 };
 
@@ -4673,6 +5903,150 @@ module.exports['Commands: status skips when no query attributes'] = async test =
     test.done();
 };
 
+module.exports['Commands: status returns synthetic recent on rev2 sessions'] = async test => {
+    let execCalled = false;
+    const connection = createMockConnection({
+        state: 2,
+        capabilities: new Map([['IMAP4rev2', true]]),
+        exec: async () => {
+            execCalled = true;
+            return { next: () => {} };
+        }
+    });
+
+    // RECENT does not exist in IMAP4rev2 - the caller still gets a status object
+    // (recent is 0 by definition) instead of false, and no command is sent
+    const result = await statusCommand(connection, 'INBOX', { recent: true });
+    test.equal(execCalled, false);
+    test.deepEqual(result, { path: 'INBOX', recent: 0 });
+    test.done();
+};
+
+module.exports['Commands: status merges synthetic recent into rev2 query results'] = async test => {
+    let queryAttrs = null;
+    const connection = createMockConnection({
+        state: 2,
+        capabilities: new Map([['IMAP4rev2', true]]),
+        exec: async (cmd, attrs, opts) => {
+            queryAttrs = JSON.stringify(attrs);
+            await opts.untagged.STATUS({
+                attributes: [{ value: 'INBOX' }, [{ value: 'MESSAGES' }, { value: '100' }]]
+            });
+            return { next: () => {} };
+        }
+    });
+
+    const result = await statusCommand(connection, 'INBOX', { messages: true, recent: true });
+    // RECENT must not be requested from a rev2 session, but the result keeps the
+    // rev1 shape for the same query
+    test.ok(!queryAttrs.includes('RECENT'));
+    test.equal(result.messages, 100);
+    test.equal(result.recent, 0);
+    test.done();
+};
+
+module.exports['Commands: status requests and parses SIZE and DELETED on rev2 sessions'] = async test => {
+    let queryAttrs = null;
+    const connection = createMockConnection({
+        state: 2,
+        // rev2-only server: STATUS=SIZE is folded in and DELETED is a base rev2
+        // status item (RFC 9051 Appendix E item 3)
+        capabilities: new Map([['IMAP4rev2', true]]),
+        exec: async (cmd, attrs, opts) => {
+            queryAttrs = JSON.stringify(attrs);
+            await opts.untagged.STATUS({
+                attributes: [
+                    { value: 'INBOX' },
+                    [{ value: 'MESSAGES' }, { value: '100' }, { value: 'SIZE' }, { value: '12345678901234' }, { value: 'DELETED' }, { value: '3' }]
+                ]
+            });
+            return { next: () => {} };
+        }
+    });
+
+    const result = await statusCommand(connection, 'INBOX', { messages: true, size: true, deleted: true });
+    test.ok(queryAttrs.includes('SIZE'));
+    test.ok(queryAttrs.includes('DELETED'));
+    test.equal(result.messages, 100);
+    // STATUS SIZE is a number64 - values beyond 2^32 must survive
+    test.strictEqual(result.size, 12345678901234);
+    test.strictEqual(result.deleted, 3);
+    test.done();
+};
+
+module.exports['Commands: status requests SIZE with the STATUS=SIZE token on rev1 sessions'] = async test => {
+    let queryAttrs = null;
+    const connection = createMockConnection({
+        state: 2,
+        // RFC 8438 server: SIZE is available via the capability token, DELETED is
+        // rev2-only and must be dropped
+        capabilities: new Map([
+            ['IMAP4rev1', true],
+            ['STATUS=SIZE', true]
+        ]),
+        exec: async (cmd, attrs, opts) => {
+            queryAttrs = JSON.stringify(attrs);
+            await opts.untagged.STATUS({
+                attributes: [{ value: 'INBOX' }, [{ value: 'SIZE' }, { value: '2048' }]]
+            });
+            return { next: () => {} };
+        }
+    });
+
+    const result = await statusCommand(connection, 'INBOX', { size: true, deleted: true });
+    test.ok(queryAttrs.includes('SIZE'));
+    test.ok(!queryAttrs.includes('DELETED'));
+    test.strictEqual(result.size, 2048);
+    test.done();
+};
+
+module.exports['Commands: status requests DELETED with QUOTA=RES-MESSAGE on rev1 sessions'] = async test => {
+    let queryAttrs = null;
+    const connection = createMockConnection({
+        state: 2,
+        // RFC 9208: the DELETED status item is mandatory when QUOTA=RES-MESSAGE
+        // is advertised, even without IMAP4rev2
+        capabilities: new Map([
+            ['IMAP4rev1', true],
+            ['QUOTA=RES-MESSAGE', true]
+        ]),
+        exec: async (cmd, attrs, opts) => {
+            queryAttrs = JSON.stringify(attrs);
+            await opts.untagged.STATUS({
+                attributes: [{ value: 'INBOX' }, [{ value: 'DELETED' }, { value: '4' }]]
+            });
+            return { next: () => {} };
+        }
+    });
+
+    const result = await statusCommand(connection, 'INBOX', { deleted: true });
+    test.ok(queryAttrs.includes('DELETED'));
+    test.strictEqual(result.deleted, 4);
+    test.done();
+};
+
+module.exports['Commands: status drops SIZE and DELETED on rev1 sessions without support'] = async test => {
+    let queryAttrs = null;
+    const connection = createMockConnection({
+        state: 2,
+        exec: async (cmd, attrs, opts) => {
+            queryAttrs = JSON.stringify(attrs);
+            await opts.untagged.STATUS({
+                attributes: [{ value: 'INBOX' }, [{ value: 'MESSAGES' }, { value: '100' }]]
+            });
+            return { next: () => {} };
+        }
+    });
+
+    // requesting them must not poison the whole STATUS command on a server that
+    // does not know these items
+    const result = await statusCommand(connection, 'INBOX', { messages: true, size: true, deleted: true });
+    test.ok(!queryAttrs.includes('SIZE'));
+    test.ok(!queryAttrs.includes('DELETED'));
+    test.equal(result.messages, 100);
+    test.done();
+};
+
 module.exports['Commands: status skips when all query values are false'] = async test => {
     const connection = createMockConnection({ state: 2 });
 
@@ -5772,6 +7146,27 @@ module.exports['Commands: idle with IDLE capability'] = async test => {
     test.done();
 };
 
+module.exports['Commands: idle uses IDLE on rev2-only servers without the IDLE token'] = async test => {
+    let execCommand = '';
+    const connection = createMockConnection({
+        state: 3,
+        // IDLE is part of base IMAP4rev2 - no separate token required
+        capabilities: new Map([['IMAP4rev2', true]]),
+        exec: async (cmd, attrs, opts) => {
+            execCommand = cmd;
+            if (opts && opts.onPlusTag) {
+                await opts.onPlusTag();
+            }
+            return { next: () => {} };
+        },
+        write: () => {}
+    });
+
+    await idleCommand(connection);
+    test.equal(execCommand, 'IDLE');
+    test.done();
+};
+
 module.exports['Commands: idle skips when not selected'] = async test => {
     const connection = createMockConnection({ state: 2 }); // AUTHENTICATED
 
@@ -6501,6 +7896,30 @@ module.exports['Commands: namespace with NAMESPACE capability'] = async test =>
     test.done();
 };
 
+module.exports['Commands: namespace uses the real command on rev2-only servers without the token'] = async test => {
+    const connection = createMockConnection({
+        state: 2,
+        // NAMESPACE is folded into base IMAP4rev2 (RFC 9051 Appendix E) - a
+        // rev2-only server gets a real NAMESPACE command, not the LIST fallback
+        capabilities: new Map([['IMAP4rev2', true]]),
+        exec: async (cmd, args, opts) => {
+            test.equal(cmd, 'NAMESPACE');
+            if (opts && opts.untagged && opts.untagged.NAMESPACE) {
+                await opts.untagged.NAMESPACE({
+                    attributes: [[[{ value: '' }, { value: '/' }]], null, null]
+                });
+            }
+            return { next: () => {} };
+        }
+    });
+
+    const result = await namespaceCommand(connection);
+    test.ok(result);
+    test.equal(result.prefix, '');
+    test.equal(result.delimiter, '/');
+    test.done();
+};
+
 module.exports['Commands: namespace fallback without capability'] = async test => {
     const connection = createMockConnection({
         state: 2, // AUTHENTICATED
@@ -8608,10 +10027,11 @@ module.exports['Commands: enable updates connection.enabled'] = async test => {
     });
 
     await enableCommand(connection, ['CONDSTORE', 'UTF8=ACCEPT']);
-    // connection.enabled should be replaced with new set
+    // New grants are merged in; earlier grants survive because the untagged
+    // ENABLED response only lists extensions enabled by this command (RFC 5161)
     test.ok(connection.enabled.has('CONDSTORE'));
     test.ok(connection.enabled.has('UTF8=ACCEPT'));
-    test.ok(!connection.enabled.has('EXISTING')); // Old value should be gone
+    test.ok(connection.enabled.has('EXISTING'));
     test.done();
 };