@withbuddi/buddi 0.1.0-pre.20 → 0.1.0-pre.22

package/node_modules/hono/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "4.13.9",
+  "version": "4.13.10",
   "description": "Web framework built on Web Standards",
   "main": "dist/cjs/index.js",
   "type": "module",
@@ -11,29 +11,31 @@
     "!dist/**/*.tsbuildinfo"
   ],
   "scripts": {
-    "test": "tsc -p tsconfig.spec.json && vitest --run",
-    "test:watch": "vitest --watch",
+    "test": "tsc -p tsconfig.spec.json && vp test --run",
+    "test:watch": "vp test --watch",
     "test:deno": "deno test --allow-read --allow-env --allow-write --allow-net -c runtime-tests/deno/deno.json runtime-tests/deno && deno test --no-lock -c runtime-tests/deno-jsx/deno.precompile.json runtime-tests/deno-jsx && deno test --no-lock -c runtime-tests/deno-jsx/deno.react-jsx.json runtime-tests/deno-jsx",
-    "test:bun": "bun test --jsx-import-source ../../src/jsx runtime-tests/bun/*",
-    "test:fastly": "vitest --run --project fastly",
-    "test:node": "vitest --run --project node",
-    "test:workerd": "vitest --run --project workerd",
-    "test:lambda": "vitest --run --project lambda",
-    "test:lambda-edge": "vitest --run --project lambda-edge",
-    "test:all": "bun run test && bun test:deno && bun test:bun",
-    "lint": "eslint src runtime-tests build perf-measures benchmarks",
-    "lint:fix": "eslint src runtime-tests build perf-measures benchmarks --fix",
-    "format": "prettier --check --cache \"src/**/*.{js,ts,tsx}\" \"runtime-tests/**/*.{js,ts,tsx}\" \"build/**/*.{js,ts,tsx}\" \"perf-measures/**/*.{js,ts,tsx}\" \"benchmarks/**/*.{js,ts,tsx}\"",
-    "format:fix": "prettier --write --cache --cache-strategy metadata \"src/**/*.{js,ts,tsx}\" \"runtime-tests/**/*.{js,ts,tsx}\" \"build/**/*.{js,ts,tsx}\" \"perf-measures/**/*.{js,ts,tsx}\" \"benchmarks/**/*.{js,ts,tsx}\"",
+    "test:bun": "bun test --jsx-import-source ../../src/jsx runtime-tests/bun",
+    "test:fastly": "vp test --run --project fastly",
+    "test:node": "vp test --run --project node",
+    "test:workerd": "vp test --run --project workerd",
+    "test:all": "pnpm run test && pnpm run test:deno && pnpm run test:bun",
+    "check": "vp check",
+    "check:fix": "vp check --fix",
+    "lint": "vp lint src runtime-tests build perf-measures benchmarks adapters",
+    "lint:fix": "vp lint --fix src runtime-tests build perf-measures benchmarks adapters",
+    "format": "vp fmt --check \"src/**/*.{js,ts,tsx}\" \"runtime-tests/**/*.{js,ts,tsx}\" \"build/**/*.{js,ts,tsx}\" \"perf-measures/**/*.{js,ts,tsx}\" \"benchmarks/**/*.{js,ts,tsx}\" \"adapters/**/*.{js,ts,tsx}\"",
+    "format:fix": "vp fmt \"src/**/*.{js,ts,tsx}\" \"runtime-tests/**/*.{js,ts,tsx}\" \"build/**/*.{js,ts,tsx}\" \"perf-measures/**/*.{js,ts,tsx}\" \"benchmarks/**/*.{js,ts,tsx}\" \"adapters/**/*.{js,ts,tsx}\"",
     "editorconfig-checker": "editorconfig-checker",
     "copy:package.cjs.json": "cp ./package.cjs.json ./dist/cjs/package.json && cp ./package.cjs.json ./dist/types/package.json",
-    "build": "bun run --shell bun remove-dist && bun ./build/build.ts && bun run copy:package.cjs.json",
-    "postbuild": "publint",
-    "watch": "bun run --shell bun remove-dist && bun ./build/build.ts --watch && bun run copy:package.cjs.json",
-    "coverage": "vitest --run --coverage",
-    "prerelease": "bun test:deno && bun run build",
+    "build": "pnpm run remove-dist && vp pack && pnpm run copy:package.cjs.json && publint",
+    "watch": "pnpm run remove-dist && vp pack --watch && pnpm run copy:package.cjs.json",
+    "coverage": "vp test --run --coverage",
+    "prerelease": "pnpm run test:deno && pnpm run build",
     "release": "np --no-publish",
-    "remove-dist": "rm -rf dist"
+    "remove-dist": "rm -rf dist",
+    "build:adapters": "pnpm -r --filter \"./adapters/*\" run build",
+    "test:adapters": "pnpm -r --filter \"./adapters/*\" run test",
+    "release:adapter": "node ./build/release-adapter.ts"
   },
   "exports": {
     ".": {
@@ -674,32 +676,30 @@
     "nodejs"
   ],
   "devDependencies": {
-    "@hono/eslint-config": "^2.1.1",
     "@hono/node-server": "^2.0.12",
     "@types/jsdom": "^21.1.7",
     "@types/node": "^24.3.0",
     "@types/ws": "^8.18.1",
     "@typescript/native-preview": "7.0.0-dev.20260210.1",
-    "@vitest/coverage-v8": "^4.1.7",
+    "@vitest/coverage-v8": "5.0.1",
     "bun-types": "^1.2.20",
     "editorconfig-checker": "6.2.0",
     "esbuild": "^0.27.1",
-    "eslint": "^9.39.3",
     "jsdom": "22.1.0",
     "msw": "^2.6.0",
     "np": "11.2.1",
-    "oxc-parser": "^0.96.0",
     "pkg-pr-new": "^0.0.53",
-    "prettier": "3.7.4",
     "publint": "0.3.15",
+    "rolldown": "^1.2.10",
     "typescript": "^6.0.3",
     "vite-plugin-fastly-js-compute": "^0.4.2",
-    "vitest": "^4.1.9",
+    "vite-plus": "1.0.0-rc.1",
+    "vitest": "5.0.1",
     "wrangler": "4.107.0",
     "ws": "^8.21.0",
     "zod": "^3.23.8"
   },
-  "packageManager": "bun@1.2.20",
+  "packageManager": "pnpm@12.6.0",
   "engines": {
     "node": ">=16.9.0"
   }

package/node_modules/imapflow/CHANGELOG.md

@@ -1,5 +1,48 @@
 # Changelog
 
+## [2.1.2](https://github.com/postalsys/imapflow/compare/v2.1.1...v2.1.2) (2026-09-28)
+
+
+### Bug Fixes
+
+* **deps:** update libmime to 5.4.6 and mailsplit to 5.4.19 ([f6afb32](https://github.com/postalsys/imapflow/commit/f6afb32cbb1df43993a1df2cbd003e013bc10fa8))
+
+## [2.1.1](https://github.com/postalsys/imapflow/compare/v2.1.0...v2.1.1) (2026-09-28)
+
+
+### Bug Fixes
+
+* settle every pending connect on close, refuse empty search operands, keep NIL envelope rows, prefer top-level special-use folders ([27a93cc](https://github.com/postalsys/imapflow/commit/27a93ccd292fc95842bcc27cdc76e0cb0de613ba))
+
+## [2.1.0](https://github.com/postalsys/imapflow/compare/v2.0.8...v2.1.0) (2026-09-27)
+
+
+### Features
+
+* export ImapFlowErrorCode with the error codes the library sets ([50c909c](https://github.com/postalsys/imapflow/commit/50c909c30a8cda4731c397f1a77c3bf3d2d17102))
+* support `await using` through Symbol.asyncDispose ([baadd4b](https://github.com/postalsys/imapflow/commit/baadd4bd73a8d9c46aab2966beb55698a42e71b2))
+
+
+### Bug Fixes
+
+* accept a number or string uidValidity for QRESYNC ([e87d0c2](https://github.com/postalsys/imapflow/commit/e87d0c216e48e2dda23d94a7c942682ec28258ca))
+* give a special-use type to its next candidate when the best is taken ([5b0d357](https://github.com/postalsys/imapflow/commit/5b0d357ec1f30cd7b43a7ad06e3a22a9ac244bad))
+* keep a bracketed IPv6 host in a REFERRAL URL ([1e90b70](https://github.com/postalsys/imapflow/commit/1e90b706f72c54e4d1397e11e0c0b2aabc2f2549))
+* keep auto-IDLE off a socket handed over by unbind() ([a47b3ae](https://github.com/postalsys/imapflow/commit/a47b3ae99e5e1e00fd8b804a8072aeccc34c6a5a))
+* parse a chunk of many literals in a loop instead of recursing ([db4c704](https://github.com/postalsys/imapflow/commit/db4c704291054cff5a9d87386a093d113ea69fc3))
+* process a chunk that arrives while the input loop is winding down ([c73f3ea](https://github.com/postalsys/imapflow/commit/c73f3ea18f5557abf91414a0faf98da7150e3f4f)), closes [#408](https://github.com/postalsys/imapflow/issues/408)
+* read the last extension field of a BODYSTRUCTURE part ([d5cf6c0](https://github.com/postalsys/imapflow/commit/d5cf6c0282cf35df2de7eb153fed24ecd09448d3))
+* reject connect() right away on a BYE greeting ([dc5d80e](https://github.com/postalsys/imapflow/commit/dc5d80e6f6efdebe92f461e23f41dc64bce6c4aa))
+
+## [2.0.8](https://github.com/postalsys/imapflow/compare/v2.0.7...v2.0.8) (2026-09-27)
+
+
+### Bug Fixes
+
+* do not expunge the source when the MOVE fallback's COPY fails ([11bbf84](https://github.com/postalsys/imapflow/commit/11bbf84fb0501f7392a5ced9787562cfcdcf7c9f)), closes [#406](https://github.com/postalsys/imapflow/issues/406)
+* surface throttle, truncation and listener failures instead of hiding them ([03a0624](https://github.com/postalsys/imapflow/commit/03a0624d0f381e935bbc3b4e12002272426abbae))
+* **types:** describe the quota response the way getQuota() returns it ([a2363b6](https://github.com/postalsys/imapflow/commit/a2363b6658d25d1a05a177a8dec556faf3df597b))
+
 ## [2.0.7](https://github.com/postalsys/imapflow/compare/v2.0.6...v2.0.7) (2026-09-25)
 
 

package/node_modules/imapflow/README.md

@@ -68,6 +68,8 @@ const main = async () => {
 main().catch(console.error);
 ```
 
+An `ImapFlow` instance holds a single connection and cannot reconnect. Once the connection has closed, or after `connect()` has been called once, create a new instance to connect again. Calling `connect()` a second time on the same instance throws an error with the code `InstanceReused`.
+
 See the [Quick Start guide](https://imapflow.com/docs/getting-started/quick-start) for more examples, including Gmail, Outlook, and Yahoo configuration.
 
 ## Documentation

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

@@ -14,7 +14,7 @@ const tools_js_1 = require("../tools.js");
  * @throws {Error} If the APPEND command fails or message exceeds APPENDLIMIT
  */
 async function append(connection, destination, content, flags, idate) {
-    if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state) || !destination) {
+    if (!(0, tools_js_1.isAuthenticatedState)(connection) || !destination) {
         // nothing to do here
         return;
     }
@@ -34,7 +34,9 @@ async function append(connection, destination, content, flags, idate) {
     destination = (0, tools_js_1.normalizePath)(connection, destination);
     // If appending to the currently selected mailbox, we can listen for the
     // untagged EXISTS response to capture the new message's sequence number.
-    let expectExists = (0, tools_js_1.comparePaths)(connection, connection.mailbox.path, destination);
+    let selected = (0, tools_js_1.getSelectedMailbox)(connection);
+    // The selected mailbox when appending to it, false otherwise
+    const targetMailbox = selected && (0, tools_js_1.comparePaths)(connection, selected.path, destination) ? selected : false;
     // Validate and format flags. Only flags allowed by the mailbox's permanentFlags are included.
     flags = (Array.isArray(flags) ? flags : [].concat(flags || []))
         .map(flag => flag && (0, tools_js_1.formatFlag)(flag.toString()))
@@ -77,13 +79,12 @@ async function append(connection, destination, content, flags, idate) {
         map.seq = seq;
         // Update the connection's mailbox state and emit 'exists' event if the
         // count changed (notifies listeners about the new message).
-        if (expectExists) {
-            let mailbox = connection.mailbox;
-            let prevCount = mailbox.exists;
+        if (targetMailbox) {
+            let prevCount = targetMailbox.exists;
             if (map.seq !== prevCount) {
-                mailbox.exists = map.seq;
-                connection.emit('exists', {
-                    path: mailbox.path,
+                targetMailbox.exists = map.seq;
+                (0, tools_js_1.emitSafe)(connection, 'exists', {
+                    path: targetMailbox.path,
                     count: map.seq,
                     prevCount
                 });
@@ -94,7 +95,7 @@ async function append(connection, destination, content, flags, idate) {
     try {
         response = await connection.exec('APPEND', attributes, {
             // Only listen for EXISTS if we're appending to the currently selected mailbox
-            untagged: expectExists ? { EXISTS: handleExistsUpdate } : false
+            untagged: targetMailbox ? { EXISTS: handleExistsUpdate } : false
         });
         // UIDPLUS (RFC 4315): the server may include APPENDUID response code in
         // the tagged OK. Format: [APPENDUID <uidValidity> <uid>]
@@ -119,7 +120,7 @@ async function append(connection, destination, content, flags, idate) {
         response.next();
         // If we didn't get an EXISTS during APPEND (some servers don't send it
         // until the next command), issue a NOOP to flush pending notifications.
-        if (expectExists && !map.seq) {
+        if (targetMailbox && !map.seq) {
             try {
                 response = await connection.exec('NOOP', false, {
                     untagged: { EXISTS: handleExistsUpdate },
@@ -142,8 +143,7 @@ async function append(connection, destination, content, flags, idate) {
         return map;
     }
     catch (err) {
-        await (0, tools_js_1.enhanceCommandError)(err);
-        connection.log.warn({ err, cid: connection.id });
+        await (0, tools_js_1.reportCommandError)(connection, err);
         throw err;
     }
 }

package/node_modules/imapflow/dist/cjs/commands/authenticate.d.ts

@@ -1,16 +1,11 @@
 import type { ImapFlow } from '../imap-flow.js';
+import type { AuthOptions } from '../types.js';
 /**
- * Credentials for the AUTHENTICATE command
+ * Credentials for the AUTHENTICATE command: the auth options, with the password passed as `password`
  */
-export interface AuthenticateCredentials {
-    /** OAuth2 access token for OAUTHBEARER/XOAUTH2 authentication */
-    accessToken?: string | undefined;
+export interface AuthenticateCredentials extends Omit<AuthOptions, 'user' | 'pass'> {
     /** Password for PLAIN or LOGIN authentication */
     password?: string | undefined;
-    /** Force a specific login method (e.g., 'AUTH=PLAIN', 'AUTH=LOGIN') */
-    loginMethod?: string | undefined;
-    /** Authorization identity for PLAIN authentication */
-    authzid?: string | undefined;
 }
 /**
  * Authenticates user using the best available method.

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = close;
+const tools_js_1 = require("../tools.js");
 /**
  * Closes the currently selected mailbox.
  *
@@ -26,7 +27,7 @@ async function close(connection) {
         connection.currentSelectCommand = false;
         connection.state = connection.states.AUTHENTICATED;
         if (currentMailbox) {
-            connection.emit('mailboxClose', currentMailbox);
+            (0, tools_js_1.emitSafe)(connection, 'mailboxClose', currentMailbox);
         }
         return true;
     }

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

@@ -14,7 +14,8 @@ const copyuid_parser_js_1 = require("./copyuid-parser.js");
  * @returns Copy result with UID mapping if available, false on failure, or undefined if preconditions not met
  */
 async function copy(connection, range, destination, options) {
-    if (connection.state !== connection.states.SELECTED || !range || !destination) {
+    let mailbox = (0, tools_js_1.getSelectedMailbox)(connection);
+    if (!mailbox || !range || !destination) {
         // nothing to do here
         return;
     }
@@ -28,15 +29,14 @@ async function copy(connection, range, destination, options) {
     try {
         response = await connection.exec(options.uid ? 'UID COPY' : 'COPY', attributes);
         response.next();
-        let map = { path: connection.mailbox.path, destination };
+        let map = { path: mailbox.path, destination };
         // UIDPLUS (RFC 4315): the server may include a COPYUID response code in the
         // tagged OK response, providing a mapping from source UIDs to destination UIDs.
         (0, copyuid_parser_js_1.parseCopyUid)(response.response, map);
         return map;
     }
     catch (err) {
-        await (0, tools_js_1.enhanceCommandError)(err);
-        connection.log.warn({ err, cid: connection.id });
+        await (0, tools_js_1.reportCommandError)(connection, err);
         return false;
     }
 }

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

@@ -11,7 +11,7 @@ const tools_js_1 = require("../tools.js");
  * @throws If the CREATE command fails (except when mailbox already exists)
  */
 async function create(connection, path) {
-    if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state)) {
+    if (!(0, tools_js_1.isAuthenticatedState)(connection)) {
         // nothing to do here
         return;
     }
@@ -71,8 +71,7 @@ async function create(connection, path) {
                 created: false
             };
         }
-        await (0, tools_js_1.enhanceCommandError)(err);
-        connection.log.warn({ err, cid: connection.id });
+        await (0, tools_js_1.reportCommandError)(connection, err);
         throw err;
     }
 }

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

@@ -11,14 +11,15 @@ const tools_js_1 = require("../tools.js");
  * @throws If the DELETE command fails
  */
 async function deleteMailbox(connection, path) {
-    if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state)) {
+    if (!(0, tools_js_1.isAuthenticatedState)(connection)) {
         // nothing to do here
         return;
     }
     path = (0, tools_js_1.normalizePath)(connection, path);
     // If the mailbox to delete is currently selected, we must close/deselect it first.
     // IMAP servers reject DELETE on the currently selected mailbox (RFC 3501 6.3.4).
-    if (connection.state === connection.states.SELECTED && connection.mailbox.path === path) {
+    let selected = (0, tools_js_1.getSelectedMailbox)(connection);
+    if (selected && selected.path === path) {
         await connection.run('CLOSE');
     }
     let response;
@@ -31,8 +32,7 @@ async function deleteMailbox(connection, path) {
         return map;
     }
     catch (err) {
-        await (0, tools_js_1.enhanceCommandError)(err);
-        connection.log.warn({ err, cid: connection.id });
+        await (0, tools_js_1.reportCommandError)(connection, err);
         throw err;
     }
 }

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

@@ -12,14 +12,19 @@ const tools_js_1 = require("../tools.js");
  * @returns True on success, false on failure, or undefined if preconditions not met
  */
 async function expunge(connection, range, options) {
-    if (connection.state !== connection.states.SELECTED || !range) {
+    let mailbox = (0, tools_js_1.getSelectedMailbox)(connection);
+    if (!mailbox || !range) {
         // nothing to do here
         return;
     }
     options = options || {};
     // Two-step deletion process per IMAP protocol:
     // Step 1: Mark the target messages with the \Deleted flag.
-    await connection.messageFlagsAdd(range, ['\\Deleted'], options);
+    // If that failed, EXPUNGE would not remove the target messages (and without
+    // UIDPLUS it would remove unrelated \Deleted messages), so report the failure instead.
+    if (!(await connection.messageFlagsAdd(range, ['\\Deleted'], options))) {
+        return false;
+    }
     // Step 2: Issue EXPUNGE to permanently remove \Deleted messages.
     // With UIDPLUS (RFC 4315): "UID EXPUNGE <uids>" removes only the specified UIDs,
     // leaving other \Deleted messages untouched, important for concurrent access.
@@ -38,7 +43,6 @@ async function expunge(connection, range, options) {
         if (responseCode.toUpperCase() === 'HIGHESTMODSEQ') {
             // A response code always comes with its section, see responseCode above
             let codeSection = section;
-            let mailbox = connection.mailbox;
             // Bounded digit runs only: isNaN() also passes '1e5', which BigInt() rejects with
             // a throw that the catch below would swallow, making messageDelete() report false
             // even though the server expunged the messages.
@@ -51,8 +55,7 @@ async function expunge(connection, range, options) {
         return true;
     }
     catch (err) {
-        await (0, tools_js_1.enhanceCommandError)(err);
-        connection.log.warn({ err, cid: connection.id });
+        await (0, tools_js_1.reportCommandError)(connection, err);
         return false;
     }
 }

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

@@ -12,23 +12,23 @@ const tools_js_1 = require("../tools.js");
  * @returns Object with message count and list, or undefined if not in SELECTED state
  */
 async function fetch(connection, range, query, options) {
-    if (connection.state !== connection.states.SELECTED || !range) {
+    let mailbox = (0, tools_js_1.getSelectedMailbox)(connection);
+    if (!mailbox || !range) {
         // nothing to do here
         return;
     }
     options = options || {};
-    let mailbox = connection.mailbox;
     // Use BINARY extension for fetching if supported and requested, otherwise fall back to BODY.
     // RFC 9051 folds the FETCH side of the BINARY extension into base IMAP4rev2, so an active
     // rev2 session can use it even without the BINARY capability token (the APPEND side is NOT
     // folded in and stays gated on the token in append.ts)
     const canUseBinary = connection.capabilities.has('BINARY') || (0, tools_js_1.isRev2Active)(connection);
     const commandKey = canUseBinary && options.binary && !connection.disableBinary ? 'BINARY' : 'BODY';
-    // Retry logic for ETHROTTLE errors (server rate limiting) with exponential backoff
-    let retryCount = 0;
+    // Retry logic for ETHROTTLE errors (server rate limiting) with exponential backoff.
+    // Every pass returns or throws: the last throttled attempt throws instead of retrying.
     const maxRetries = 4;
     const baseDelay = 1000; // Start with 1 second delay
-    while (retryCount < maxRetries) {
+    for (let retryCount = 0;; retryCount++) {
         let messages = {
             count: 0,
             list: []
@@ -205,15 +205,18 @@ async function fetch(connection, range, query, options) {
             return messages;
         }
         catch (err) {
-            if (err.code === 'ETHROTTLE') {
+            // The last throttled attempt falls through and throws, so running out of retries
+            // is never mistaken for an empty result
+            if (err.code === 'ETHROTTLE' && retryCount < maxRetries - 1) {
                 // Server returned a throttle error (rate limiting). Retry with exponential backoff.
-                // Delay doubles each retry: 1s, 2s, 4s, 8s (capped at 30s).
+                // Delay doubles each retry: 1s, 2s, 4s.
                 // If server provides a throttleReset hint, use that if longer.
                 const backoffDelay = Math.min(baseDelay * Math.pow(2, retryCount), 30000); // Cap at 30 seconds
                 // Use throttle reset time if provided and longer than backoff. The hint is
                 // server-controlled, so the wait goes through connection.throttleWait(), which caps
-                // it and keeps the timer tracked and abortable.
-                const delay = err.throttleReset && err.throttleReset > backoffDelay ? err.throttleReset : backoffDelay;
+                // it and keeps the timer tracked and abortable. The connection already waited
+                // part of the back-off before rejecting (throttleWaited), so only the rest is left.
+                const delay = Math.max(err.throttleReset || 0, backoffDelay) - (err.throttleWaited || 0);
                 connection.log.warn({
                     msg: 'Retrying throttled request with exponential backoff',
                     cid: connection.id,
@@ -229,7 +232,6 @@ async function fetch(connection, range, query, options) {
                 if (aborted) {
                     throw connection.createNoConnectionError(connection.byeReason, { rejectedFrom: 'throttleAbort', command: 'FETCH' });
                 }
-                retryCount++;
                 continue;
             }
             connection.log.warn({ err, cid: connection.id });

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

@@ -124,7 +124,11 @@ async function runIdle(connection) {
     }
     catch (err) {
         (0, tools_js_1.logConnectionError)(connection, 'IDLE session failed', err);
-        if (preCheckWaitQueue.length) {
+        // A tagged NO or BAD only means the server refused IDLE; the connection is still usable,
+        // so the waiters are released by the finally block below and their own commands run.
+        // Anything else (close, lost socket, parser failure) fails the waiters too.
+        let refusedByServer = ['NO', 'BAD'].includes(err.responseStatus);
+        if (preCheckWaitQueue.length && !refusedByServer) {
             // One error for the whole queue: every waiter failed at the same site, for the same
             // reason. Built inside the guard so a teardown with nothing queued - the common case -
             // does not pay for an Error and its stack capture.
@@ -240,7 +244,7 @@ async function runPollingFallback(connection, maxIdleTime) {
                     return;
                 }
                 // The transport or the mailbox may be gone by the time the timer fires
-                if (!connection.socket || connection.socket.destroyed || connection.state !== connection.states.SELECTED || !connection.mailbox) {
+                if (!connection.socket || connection.socket.destroyed || !(0, tools_js_1.getSelectedMailbox)(connection)) {
                     return cancel();
                 }
                 pollOnce(connection, session)

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

@@ -151,10 +151,12 @@ async function list(connection, reference, mailbox, options) {
                         if (!untagged.attributes || !untagged.attributes.length) {
                             return;
                         }
+                        // A name sent as a literal arrives as a Buffer, so convert it once for both fields
+                        let rawPath = ((untagged.attributes[2] && untagged.attributes[2].value) || '').toString();
                         let entry = {
                             // Decode from modified UTF-7 wire format and normalize the path
-                            path: (0, tools_js_1.normalizePath)(connection, (0, tools_js_1.decodePath)(connection, ((untagged.attributes[2] && untagged.attributes[2].value) || ''))),
-                            pathAsListed: ((untagged.attributes[2] && untagged.attributes[2].value) || ''),
+                            path: (0, tools_js_1.normalizePath)(connection, (0, tools_js_1.decodePath)(connection, rawPath)),
+                            pathAsListed: rawPath,
                             flags: new Set((0, tools_js_1.getStringList)(untagged.attributes[0])),
                             delimiter: (untagged.attributes[1] && untagged.attributes[1].value),
                             listed: true
@@ -184,7 +186,7 @@ async function list(connection, reference, mailbox, options) {
                             entry.path = entry.path.slice(1);
                         }
                         // Build parent path hierarchy for tree construction and sorting
-                        entry.parentPath = entry.delimiter && entry.path ? entry.path.substr(0, entry.path.lastIndexOf(entry.delimiter)) : '';
+                        entry.parentPath = entry.delimiter && entry.path ? entry.path.substring(0, entry.path.lastIndexOf(entry.delimiter)) : '';
                         entry.parent = entry.delimiter ? entry.path.split(entry.delimiter) : [entry.path];
                         entry.name = entry.parent.pop();
                         // Try to detect special-use from server flags or well-known names
@@ -382,9 +384,11 @@ async function list(connection, reference, mailbox, options) {
                         if (!untagged.attributes || !untagged.attributes.length) {
                             return;
                         }
+                        // A name sent as a literal arrives as a Buffer, so convert it once for both fields
+                        let rawPath = ((untagged.attributes[2] && untagged.attributes[2].value) || '').toString();
                         let entry = {
-                            path: (0, tools_js_1.normalizePath)(connection, (0, tools_js_1.decodePath)(connection, ((untagged.attributes[2] && untagged.attributes[2].value) || ''))),
-                            pathAsListed: ((untagged.attributes[2] && untagged.attributes[2].value) || ''),
+                            path: (0, tools_js_1.normalizePath)(connection, (0, tools_js_1.decodePath)(connection, rawPath)),
+                            pathAsListed: rawPath,
                             flags: new Set((0, tools_js_1.getStringList)(untagged.attributes[0])),
                             delimiter: (untagged.attributes[1] && untagged.attributes[1].value),
                             subscribed: true
@@ -395,7 +399,7 @@ async function list(connection, reference, mailbox, options) {
                         if (entry.delimiter && entry.path.charAt(0) === entry.delimiter) {
                             entry.path = entry.path.slice(1);
                         }
-                        entry.parentPath = entry.delimiter && entry.path ? entry.path.substr(0, entry.path.lastIndexOf(entry.delimiter)) : '';
+                        entry.parentPath = entry.delimiter && entry.path ? entry.path.substring(0, entry.path.lastIndexOf(entry.delimiter)) : '';
                         entry.parent = entry.delimiter ? entry.path.split(entry.delimiter) : [entry.path];
                         entry.name = entry.parent.pop();
                         // Merge LSUB data into existing LIST entry if found
@@ -447,23 +451,35 @@ async function list(connection, reference, mailbox, options) {
                 connection.log.warn({ msg: 'Failed to request subscription info', err, cid: connection.id });
             }
         }
-        // Resolve special-use conflicts: for each type, pick the best candidate
-        // based on source priority (user > extension > name), then alphabetically.
-        // Only the winning entry gets the specialUse property set.
-        for (let type of Object.keys(specialUseMatches)) {
-            let sortedEntries = specialUseMatches[type].sort((a, b) => {
-                let aSource = SOURCE_SORT_ORDER.indexOf(a.source);
-                let bSource = SOURCE_SORT_ORDER.indexOf(b.source);
-                if (aSource === bSource) {
-                    return a.entry.path.localeCompare(b.entry.path);
-                }
+        // Resolve special-use conflicts. Each type goes to one mailbox and each mailbox gets
+        // at most one type. Candidates are taken in priority order across all types (user >
+        // extension > name, then alphabetically), so a mailbox claimed by a stronger match
+        // leaves its other type to that type's next candidate instead of to nobody. Within a
+        // source a shallower mailbox wins before the alphabetical order is consulted, so that
+        // INBOX.Sent is preferred over INBOX.Archive.Sent.
+        let candidates = Object.entries(specialUseMatches).flatMap(([type, matches]) => matches.map(match => ({ type, ...match })));
+        candidates.sort((a, b) => {
+            let aSource = SOURCE_SORT_ORDER.indexOf(a.source);
+            let bSource = SOURCE_SORT_ORDER.indexOf(b.source);
+            if (aSource !== bSource) {
                 return aSource - bSource;
-            });
-            if (!sortedEntries[0].entry.specialUse) {
-                let source = sortedEntries[0].source;
-                sortedEntries[0].entry.specialUse = type;
-                sortedEntries[0].entry.specialUseSource = PUBLIC_SOURCE[source] || source;
             }
+            // parent is set on every listed entry before the candidates are ranked
+            let aDepth = a.entry.parent.length;
+            let bDepth = b.entry.parent.length;
+            if (aDepth !== bDepth) {
+                return aDepth - bDepth;
+            }
+            return a.entry.path.localeCompare(b.entry.path);
+        });
+        let assignedTypes = new Set();
+        for (let { type, entry, source } of candidates) {
+            if (assignedTypes.has(type) || entry.specialUse) {
+                continue;
+            }
+            entry.specialUse = type;
+            entry.specialUseSource = PUBLIC_SOURCE[source] || source;
+            assignedTypes.add(type);
         }
         // No source answered, so "not subscribed" was never actually reported for any of
         // these folders - the state is unknown, not false. Reporting the whole listing as

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

@@ -14,7 +14,8 @@ const copyuid_parser_js_1 = require("./copyuid-parser.js");
  * @returns Move result with UID mapping if available, false on failure, or undefined if preconditions not met
  */
 async function move(connection, range, destination, options) {
-    if (connection.state !== connection.states.SELECTED || !range || !destination) {
+    let mailbox = (0, tools_js_1.getSelectedMailbox)(connection);
+    if (!mailbox || !range || !destination) {
         // nothing to do here
         return;
     }
@@ -24,13 +25,18 @@ async function move(connection, range, destination, options) {
         { type: 'SEQUENCE', value: range },
         { type: 'ATOM', value: (0, tools_js_1.encodePath)(connection, destination) }
     ];
-    let map = { path: connection.mailbox.path, destination };
+    let map = { path: mailbox.path, destination };
     // Fallback for servers without the MOVE extension (RFC 6851):
     // emulate MOVE using COPY + flag as \Deleted + EXPUNGE.
     if (!(0, tools_js_1.hasCapability)(connection, 'MOVE')) {
         let result = await connection.messageCopy(range, destination, options);
-        await connection.messageDelete(range, Object.assign({ silent: true }, options));
-        return result;
+        if (!result) {
+            // The source must stay untouched when the copy failed, otherwise the messages are lost
+            return result;
+        }
+        let deleted = await connection.messageDelete(range, Object.assign({ silent: true }, options));
+        // Messages that were copied but not removed from the source mean the move did not complete
+        return deleted ? result : false;
     }
     let response;
     try {
@@ -48,8 +54,7 @@ async function move(connection, range, destination, options) {
         return map;
     }
     catch (err) {
-        await (0, tools_js_1.enhanceCommandError)(err);
-        connection.log.warn({ err, cid: connection.id });
+        await (0, tools_js_1.reportCommandError)(connection, err);
         return false;
     }
 }

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

@@ -9,7 +9,7 @@ const tools_js_1 = require("../tools.js");
  * @returns The primary personal namespace, or an error object on failure
  */
 async function namespace(connection) {
-    if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state)) {
+    if (!(0, tools_js_1.isAuthenticatedState)(connection)) {
         // nothing to do here
         return;
     }