imapkit 4.3.1 → 5.0.1

package/dist/cjs/envelope.d.ts

@@ -1,7 +1,7 @@
 import type { ParsedAddress } from './addressparser.js';
 import type { ParsedHeader } from './mimeparser.js';
 /** An address of the ENVELOPE (RFC 3501 section 9): name, source route, mailbox and host, all NIL for a group end */
-export type EnvelopeAddress = [name: string | null, adl: null, mailbox: string | null, host: string | null];
+export type EnvelopeAddress = [name: string | null, adl: string | null, mailbox: string | null, host: string | null];
 /** The fields of the ENVELOPE (RFC 3501 section 7.4.2), in order */
 export type Envelope = [
     date: string | null,

package/dist/cjs/envelope.js

@@ -3,6 +3,29 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = envelope;
 exports.processAddress = processAddress;
+// RFC 5322 section 4.4: obs-angle-addr = [CFWS] "<" obs-route addr-spec ">" [CFWS], obs-route = obs-domain-list ":",
+// obs-domain-list = *(CFWS / ",") "@" domain *("," [CFWS] ["@" domain]). A domain-literal can hold a colon
+const OBS_ROUTE = /^[\s,]*(@(?:[^:[]|\[[^\]]*\])*):/;
+/**
+ * Splits an obsolete source route from an address: the route goes to addr-adl, the rest is the addr-spec
+ * (RFC 9051 section 7.5.2: the at-domain-list is the "source route and obs-route ABNF production from [RFC5322]",
+ * the mailbox name the "local-part ABNF production"). The route is sent like Dovecot does, "@a,@b"
+ *
+ * @param {String} address Address from the angle brackets
+ * @return {Array} [route or null, addr-spec]
+ */
+function splitRoute(address) {
+    const match = address.match(OBS_ROUTE);
+    if (!match) {
+        return [null, address];
+    }
+    const route = match[1]
+        .split(',')
+        .map(domain => domain.trim())
+        .filter(domain => domain)
+        .join(',');
+    return [route, address.substr(match[0].length).trim()];
+}
 /**
  * Convert a message object to an ENVELOPE object
  *
@@ -61,12 +84,14 @@ function processAddress(arr, def) {
         if (!address) {
             return;
         }
+        const [route, addrSpec] = splitRoute(address);
+        address = addrSpec;
         const at = address.lastIndexOf('@');
         const user = at >= 0 ? address.substr(0, at) : address;
         // RFC 3501 7.4.2 reserves a NIL host for group markers, so an address without a domain gets
         // the placeholder host that Dovecot uses for the same input
         const domain = (at >= 0 ? address.substr(at + 1) : '') || 'MISSING_DOMAIN';
-        result.push([name, null, user || null, domain]);
+        result.push([name, route, user || null, domain]);
     });
     // env-from = "(" 1*address ")", there is no SP between the addresses (RFC 3501 section 9)
     Object.defineProperty(result, 'adjacentLists', { value: true });

package/dist/cjs/index.d.ts

@@ -1,10 +1,18 @@
 import createServer, { TAG_REGEX, IMAPServer, IMAPConnection } from './server.js';
-export { TAG_REGEX, IMAPServer, IMAPConnection };
+import { ImapKitError } from './control.js';
+import { quirks } from './quirks.js';
+import { storageSchema, validateStorage } from './storage-schema.js';
+export { TAG_REGEX, IMAPServer, IMAPConnection, ImapKitError, quirks, storageSchema, validateStorage };
 export type { Attribute, ParsedCommand, IMAPResponse, Notification, Callback, CommandHandler, CommandOptions, Plugin, IMAPError, Message, Mailbox, StorageNamespace, UserData, IMAPServerOptions } from './types.js';
 export type { ScriptRule, ScriptContext, ScriptEvent, ScriptBytes, ScriptHandle } from './script.js';
+export type { Quirk } from './quirks.js';
+export type { Control, MailboxInfo, MessageInfo, SessionInfo, NewMessage, UserOptions, SessionFilter, ControlRoute, RouteRequest } from './control.js';
+export type { FlagMode, UidMode, UidValidityOptions } from './store-operations.js';
 declare const imapkit: typeof createServer & {
     TAG_REGEX: RegExp;
     IMAPServer: typeof IMAPServer;
     IMAPConnection: typeof IMAPConnection;
+    ImapKitError: typeof ImapKitError;
+    quirks: Record<string, import("./quirks.js").Quirk>;
 };
 export default imapkit;

package/dist/cjs/index.js

@@ -33,14 +33,21 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IMAPConnection = exports.IMAPServer = exports.TAG_REGEX = void 0;
+exports.validateStorage = exports.storageSchema = exports.quirks = exports.ImapKitError = exports.IMAPConnection = exports.IMAPServer = exports.TAG_REGEX = void 0;
 const server_js_1 = __importStar(require("./server.js"));
 Object.defineProperty(exports, "TAG_REGEX", { enumerable: true, get: function () { return server_js_1.TAG_REGEX; } });
 Object.defineProperty(exports, "IMAPServer", { enumerable: true, get: function () { return server_js_1.IMAPServer; } });
 Object.defineProperty(exports, "IMAPConnection", { enumerable: true, get: function () { return server_js_1.IMAPConnection; } });
+const control_js_1 = require("./control.js");
+Object.defineProperty(exports, "ImapKitError", { enumerable: true, get: function () { return control_js_1.ImapKitError; } });
+const quirks_js_1 = require("./quirks.js");
+Object.defineProperty(exports, "quirks", { enumerable: true, get: function () { return quirks_js_1.quirks; } });
+const storage_schema_js_1 = require("./storage-schema.js");
+Object.defineProperty(exports, "storageSchema", { enumerable: true, get: function () { return storage_schema_js_1.storageSchema; } });
+Object.defineProperty(exports, "validateStorage", { enumerable: true, get: function () { return storage_schema_js_1.validateStorage; } });
 // `imapkit(options)` creates a server. TAG_REGEX was a property of the CommonJS export, it and the
 // classes are properties of the factory with both module formats
-const imapkit = Object.assign(server_js_1.default, { TAG_REGEX: server_js_1.TAG_REGEX, IMAPServer: server_js_1.IMAPServer, IMAPConnection: server_js_1.IMAPConnection });
+const imapkit = Object.assign(server_js_1.default, { TAG_REGEX: server_js_1.TAG_REGEX, IMAPServer: server_js_1.IMAPServer, IMAPConnection: server_js_1.IMAPConnection, ImapKitError: control_js_1.ImapKitError, quirks: quirks_js_1.quirks });
 exports.default = imapkit;
 {
     const defaultExport = exports.default;

package/dist/cjs/load-plugins.d.ts

@@ -15,7 +15,9 @@ declare function listPlugins(): string[];
  *
  * @param {Object} server IMAPServer instance
  * @param {Array|String|Function} plugins List of plugins to load
+ * @param {Map} [exclude] Plugins a quirk preset leaves out, plugin name to quirk name
+ * @throws {Error} when a loaded plugin requires an excluded one
  */
-declare function loadPlugins(server: IMAPServer, plugins: (string | Plugin)[] | string | Plugin | null | undefined): void;
+declare function loadPlugins(server: IMAPServer, plugins: (string | Plugin)[] | string | Plugin | null | undefined, exclude?: Map<string, string>): void;
 export default loadPlugins;
 export { listPlugins };

package/dist/cjs/load-plugins.js

@@ -49,13 +49,27 @@ function resolvePlugin(name) {
  *
  * @param {Object} server IMAPServer instance
  * @param {Array|String|Function} plugins List of plugins to load
+ * @param {Map} [exclude] Plugins a quirk preset leaves out, plugin name to quirk name
+ * @throws {Error} when a loaded plugin requires an excluded one
  */
-function loadPlugins(server, plugins) {
+function loadPlugins(server, plugins, exclude) {
     const loaded = new Set();
-    const load = (entry) => {
+    // plugins a quirk preset leaves out (no-move), they are not loaded even when listed, and the quirk that removes them
+    const excluded = new Map();
+    (exclude || new Map()).forEach((quirk, name) => {
+        const resolved = resolvePlugin(name);
+        if (resolved) {
+            excluded.set(index_js_1.plugins[resolved], quirk);
+        }
+    });
+    // `requiredBy` names the plugin whose `requires` lists this one
+    const load = (entry, requiredBy) => {
         let plugin = entry;
         if (typeof plugin === 'string') {
             const name = resolvePlugin(plugin);
+            if (!name && plugin.toUpperCase() === 'XTOYBIRD') {
+                throw new Error('XTOYBIRD was removed in 5.0.0, use the control API (server.control.snapshot(), server.control.addUser() ...) instead, see the README');
+            }
             if (!name) {
                 throw new Error('Unknown plugin "' + plugin + '". Available plugins: ' + listPlugins().join(', '));
             }
@@ -64,14 +78,24 @@ function loadPlugins(server, plugins) {
         if (typeof plugin !== 'function') {
             throw new TypeError('Invalid plugin, expecting a plugin name or a function');
         }
+        const quirk = excluded.get(plugin);
+        if (quirk) {
+            if (requiredBy) {
+                // the plugin can not work without it (IMAP4rev2 folds in MOVE and UIDPLUS, RFC 9051 Appendix E), so
+                // advertising it without the required plugin would break its RFC
+                throw new Error(requiredBy + ' requires ' + entry + ', which the "' + quirk + '" quirk removes');
+            }
+            return;
+        }
         if (loaded.has(plugin)) {
             return;
         }
         loaded.add(plugin);
-        [].concat(plugin.requires || []).forEach(load);
+        const name = typeof entry === 'string' ? entry.trim() : plugin.name;
+        [].concat(plugin.requires || []).forEach(required => load(required, name));
         plugin(server);
     };
-    [].concat(plugins || []).forEach(load);
+    [].concat(plugins || []).forEach(entry => load(entry));
     server.emit('pluginsLoaded');
 }
 exports.default = loadPlugins;

package/dist/cjs/plugins/acl.js

@@ -11,6 +11,7 @@ const list_extensions_js_1 = require("../list-extensions.js");
 const select_js_1 = require("../commands/select.js");
 const append_js_1 = require("../commands/append.js");
 const arguments_js_1 = require("../arguments.js");
+const store_operations_js_1 = require("../store-operations.js");
 /**
  * @help Adds ACL [RFC4314] capability with RIGHTS=texk
  * @help The owner (server option "aclOwner", default "testuser")
@@ -205,6 +206,33 @@ function aclPlugin(server) {
         change(acl);
         server.emit('acl', mailbox, previous);
     };
+    /**
+     * Changes the rights of an identifier like SETACL (RFC 4314 section 3.1): "+" adds, "-" removes, no mode
+     * replaces. An identifier without rights is removed from the ACL
+     *
+     * @param {Object} mailbox Mailbox
+     * @param {String} identifier Identifier
+     * @param {String} mode "+", "-" or ""
+     * @param {Set} rights Parsed rights
+     */
+    const applyRights = (mailbox, identifier, mode, rights) => {
+        changeAcl(mailbox, acl => {
+            const current = new Set(acl.get(identifier) || []);
+            if (mode === '+') {
+                rights.forEach(right => current.add(right));
+            }
+            else if (mode === '-') {
+                rights.forEach(right => current.delete(right));
+            }
+            const updated = mode ? current : rights;
+            if (updated.size) {
+                acl.set(identifier, updated);
+            }
+            else {
+                acl.delete(identifier);
+            }
+        });
+    };
     // CATENATE (RFC 4469 section 5): reading a message through an IMAP URL needs the "r" right, a
     // mailbox without "l" is reported like one that does not exist (RFC 4314 section 6)
     server.urlAccessChecks.push((connection, mailbox) => {
@@ -360,22 +388,7 @@ function aclPlugin(server) {
         if (!checkAclCommand(connection, parsed, data, mailbox, hasAdmin) || refuseOwnerIdentifier(connection, parsed, data)) {
             return;
         }
-        changeAcl(mailbox, acl => {
-            const current = new Set(acl.get(identifier) || []);
-            if (mode === '+') {
-                rights.forEach(right => current.add(right));
-            }
-            else if (mode === '-') {
-                rights.forEach(right => current.delete(right));
-            }
-            const updated = mode ? current : rights;
-            if (updated.size) {
-                acl.set(identifier, updated);
-            }
-            else {
-                acl.delete(identifier);
-            }
-        });
+        applyRights(mailbox, identifier, mode, rights);
         connection.sendStatus(parsed, data, 'OK', 'Setacl complete');
     }), Object.assign({ astringArguments: [1, 2] }, aclOptions));
     // RFC 4314 section 3.2
@@ -473,7 +486,7 @@ function aclPlugin(server) {
                 }
                 flags = [].concat(flags);
                 // invalid flags are still refused with BAD, even if the user could not set them anyway
-                flags.forEach((flag) => (0, flags_js_1.checkSystemFlags)(connection, (0, flags_js_1.normalizeSystemFlag)(flagValue(flag))));
+                flags.forEach((flag) => (0, flags_js_1.checkSystemFlags)(connection.server, (0, flags_js_1.normalizeSystemFlag)(flagValue(flag))));
                 let allowed = flags.filter((flag) => canSetFlag(rights, flag));
                 if (item.charAt(0) !== '+' && item.charAt(0) !== '-') {
                     // replacing the flags keeps the ones the user can not change
@@ -568,7 +581,7 @@ function aclPlugin(server) {
         const flags = parsed.attributes[1];
         if (Array.isArray(flags) && flags.every((flag) => flag && flag.type === 'ATOM')) {
             try {
-                flags.forEach((flag) => (0, flags_js_1.checkSystemFlags)(connection, (0, flags_js_1.normalizeSystemFlag)(flag.value)));
+                flags.forEach((flag) => (0, flags_js_1.checkSystemFlags)(connection.server, (0, flags_js_1.normalizeSystemFlag)(flag.value)));
                 // the server MUST NOT fail APPEND for flags the user can not set
                 parsed.attributes[1] = flags.filter((flag) => canSetFlag(rights, flag));
             }
@@ -740,7 +753,7 @@ function aclPlugin(server) {
         }
         const flags = [].concat(args[args.length - 1] || []);
         try {
-            flags.forEach(flag => (0, flags_js_1.checkSystemFlags)(connection, (0, flags_js_1.normalizeSystemFlag)(flagValue(flag))));
+            flags.forEach(flag => (0, flags_js_1.checkSystemFlags)(connection.server, (0, flags_js_1.normalizeSystemFlag)(flagValue(flag))));
         }
         catch {
             // invalid flags are refused with BAD by the STORE handler
@@ -839,40 +852,94 @@ function aclPlugin(server) {
             });
         }
     });
-    // The DELETE command MUST delete the ACL of the mailbox (RFC 4314 section 4), this matters when a
-    // \Noselect placeholder stays for the children of the mailbox
-    // DELETE and CREATE are core commands, so the handlers exist
-    const prevDelete = server.getCommandHandler('DELETE');
-    server.setCommandHandler('DELETE', (connection, parsed, data, callback) => {
-        const mailbox = argumentMailbox(parsed, 0);
-        prevDelete(connection, parsed, data, () => {
-            const placeholder = argumentMailbox(parsed, 0);
-            if (placeholder && placeholder !== mailbox) {
+    server.on('mailbox', (event) => {
+        if (event.type === 'delete') {
+            // DELETE MUST delete the ACL of the mailbox (RFC 4314 section 4), this matters when a \Noselect
+            // placeholder stays for the children of the mailbox
+            const placeholder = server.getMailbox(event.path);
+            if (placeholder && placeholder !== event.mailbox) {
                 delete placeholder.acl;
             }
-            callback();
-        });
-    });
-    // A new mailbox inherits the ACL of its parent (RFC 4314 section 4, CREATE SHOULD)
-    const prevCreate = server.getCommandHandler('CREATE');
-    server.setCommandHandler('CREATE', (connection, parsed, data, callback) => {
-        const existing = new Set(Object.keys(server.folderCache));
-        prevCreate(connection, parsed, data, () => {
-            Object.keys(server.folderCache)
-                .filter(path => !existing.has(path))
-                .sort((a, b) => a.length - b.length)
-                .forEach(path => {
+        }
+        else if (event.type === 'create') {
+            // A new mailbox inherits the ACL of its parent (RFC 4314 section 4, CREATE SHOULD)
+            (event.created || []).forEach((path) => {
                 const parent = getParent(path);
                 const mailbox = server.folderCache[path];
-                if (parent && parent !== mailbox) {
+                if (parent && mailbox && parent !== mailbox) {
                     const acl = new Map();
                     getAcl(parent).forEach((rights, identifier) => acl.set(identifier, new Set(rights)));
                     mailbox.acl = acl;
                 }
             });
-            callback();
+        }
+    });
+    // Control API (README "Control API"): ACLs as objects of identifier to rights, like the storage option
+    const aclObject = (mailbox) => {
+        const result = {};
+        getAcl(mailbox).forEach((rights, identifier) => {
+            result[identifier] = formatRights(rights);
         });
+        return result;
+    };
+    const controlMailbox = (path) => server.control.requireMailbox(path);
+    // the snapshot keeps ACLs in the form of the storage option, the parsed ACL is a Map
+    server.control.snapshotHandlers.push((mailbox, copy) => {
+        if (mailbox.acl instanceof Map) {
+            copy.acl = aclObject(mailbox);
+        }
     });
+    const getAclOperation = (path) => aclObject(controlMailbox(path));
+    // rights replace the rights of the identifier, "+rights" adds and "-rights" removes like SETACL (RFC 4314
+    // section 3.1), empty rights remove the identifier
+    const setAclOperation = (path, identifier, rights) => {
+        const mailbox = controlMailbox(path);
+        if (typeof identifier !== 'string' || !identifier || typeof rights !== 'string') {
+            throw (0, store_operations_js_1.storeError)('setAcl expects an identifier and a rights string', 'INVALID');
+        }
+        const mode = /^[+-]/.test(rights) ? rights.charAt(0) : '';
+        let parsed;
+        try {
+            parsed = parseRights(rights.substr(mode.length));
+        }
+        catch (err) {
+            throw (0, store_operations_js_1.storeError)(err.message, 'INVALID');
+        }
+        applyRights(mailbox, identifier, mode, parsed);
+        return aclObject(mailbox);
+    };
+    const deleteAclOperation = (path, identifier) => {
+        const mailbox = controlMailbox(path);
+        if (typeof identifier !== 'string' || !getAcl(mailbox).has(identifier)) {
+            throw (0, store_operations_js_1.storeError)('No ACL entry for ' + JSON.stringify(identifier), 'NONEXISTENT');
+        }
+        changeAcl(mailbox, acl => acl.delete(identifier));
+        return aclObject(mailbox);
+    };
+    server.control.register('getAcl', getAclOperation, [
+        {
+            method: 'GET',
+            path: '/v1/mailboxes/{path}/acl',
+            summary: 'The ACL of a mailbox (ACL plugin)',
+            handler: ({ params }) => server.control.getAcl(params.path)
+        }
+    ]);
+    server.control.register('setAcl', setAclOperation, [
+        {
+            method: 'PUT',
+            path: '/v1/mailboxes/{path}/acl/{identifier}',
+            summary: 'Sets the rights of an identifier ({ rights }, "+" or "-" in front adds or removes, ACL plugin)',
+            handler: ({ params, body }) => server.control.setAcl(params.path, params.identifier, body.rights)
+        }
+    ]);
+    server.control.register('deleteAcl', deleteAclOperation, [
+        {
+            method: 'DELETE',
+            path: '/v1/mailboxes/{path}/acl/{identifier}',
+            summary: 'Removes an identifier from the ACL (ACL plugin)',
+            handler: ({ params }) => server.control.deleteAcl(params.path, params.identifier)
+        }
+    ]);
 }
 {
     const defaultExport = exports.default;

package/dist/cjs/plugins/binary.js

@@ -109,7 +109,8 @@ function getDecodedSection(connection, message, query) {
     }
     const node = (0, mimeparser_js_1.resolveNode)((0, mimeparser_js_1.getMessageData)(message).tree, section[0].value, connection.messageGlobal);
     if (!node) {
-        // like BODY[<section>], a part that does not exist is empty
+        // like BODY[<section>], a part that does not exist is empty: RFC 3516 and RFC 9051 section 6.4.5 define no
+        // error for it, and BINARY follows the semantics of BODY (RFC 3516 section 4.2)
         return '';
     }
     if (!isLeaf(node, connection.messageGlobal)) {

package/dist/cjs/plugins/condstore.js

@@ -78,6 +78,13 @@ function condstorePlugin(server) {
     server.on('expunge', mailbox => {
         bumpModseq(mailbox);
     });
+    // Flags changed outside of STORE (the control API, see changeFlags() in store-operations.ts): every changed
+    // message gets a new mod-sequence (RFC 7162 section 3.1.1), before the sessions are told
+    server.on('flags', (mailbox, messages) => {
+        messages.forEach(message => {
+            message.MODSEQ = bumpModseq(mailbox);
+        });
+    });
     // RFC 7162 section 3.2.11: SELECT or EXAMINE closes the selected mailbox, a CONDSTORE server marks
     // where the responses for the new mailbox start
     server.closedChecks.push(() => true);

package/dist/cjs/plugins/context-search.js

@@ -252,8 +252,8 @@ function contextSearchPlugin(server) {
         // knows the current message list, so new matches can be reported after their EXISTS and FETCH responses
         // (RFC 5267 section 4.3.2). A command that closes the mailbox gets no updates, its tagged response ends them
         const processNotifications = connection.processNotifications;
-        connection.processNotifications = function (data) {
-            processNotifications.call(this, data);
+        connection.processNotifications = function (data, beforeCommand) {
+            processNotifications.call(this, data, beforeCommand);
             const command = ((data && data.command) || '').toUpperCase();
             if (this.searchContexts && this.searchContexts.size && !this.notificationQueue.length && !CLOSING_COMMANDS.has(command)) {
                 checkContexts(this);

package/dist/cjs/plugins/create-special-use.d.ts

@@ -1,7 +1,2 @@
 import type { IMAPServer } from '../types.js';
-/**
- * @help Enables CREATE-SPECIAL-USE [RFC6154] capability
- * @help Allowed special flags can be set with server
- * @help option "special-use"
- */
 export default function createSpecialUsePlugin(server: IMAPServer): void;

package/dist/cjs/plugins/create-special-use.js

@@ -1,11 +1,18 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = createSpecialUsePlugin;
+const formal_1 = __importDefault(require("imap-handler/lib/formal"));
+const arguments_js_1 = require("../arguments.js");
 /**
  * @help Enables CREATE-SPECIAL-USE [RFC6154] capability
  * @help Allowed special flags can be set with server
  * @help option "special-use"
  */
+// use-attr-ext = "\" atom (RFC 6154 section 6), with the ATOM-CHAR of the imap-handler grammar (RFC 3501 section 9)
+const USE_ATTR = new RegExp('^\\\\[' + formal_1.default['ATOM-CHAR']().replace(/[\\\]^-]/g, '\\$&') + ']+$');
 function createSpecialUsePlugin(server) {
     // Register capability
     server.registerCapability('CREATE-SPECIAL-USE');
@@ -34,7 +41,10 @@ function createSpecialUsePlugin(server) {
         }
         if (specialUseList) {
             for (i = 0, len = specialUseList.length; i < len; i++) {
-                if (['ATOM', 'STRING', 'LITERAL'].indexOf(specialUseList[i].type) < 0) {
+                // RFC 6154 section 6: use-attr-ext = "\" atom, so every entry is an atom that starts with a backslash,
+                // not NIL, a string, a literal, a number or a list
+                const entry = specialUseList[i];
+                if (!(0, arguments_js_1.isAtom)(entry) || !USE_ATTR.test(entry.value)) {
                     connection.send({
                         tag: parsed.tag,
                         command: 'BAD',

package/dist/cjs/plugins/imap4rev2.js

@@ -128,6 +128,11 @@ function imap4rev2Plugin(server) {
         }, 'SELECT LIST', parsed, data, mailbox);
     };
     server.outputHandlers.push((connection, response, description, parsed, data) => {
+        if (description === 'RECENT NOTIFICATION' && isRev2(connection)) {
+            // Appendix E item 12: no RECENT response after the EXISTS of new messages either
+            response.skipResponse = true;
+            return;
+        }
         if (!parsed || !response || !isRev2(connection)) {
             return;
         }

package/dist/cjs/plugins/index.js

@@ -59,7 +59,6 @@ const unselect_js_1 = __importDefault(require("./unselect.js"));
 const utf8_accept_js_1 = __importDefault(require("./utf8-accept.js"));
 const x_gm_ext_1_js_1 = __importDefault(require("./x-gm-ext-1.js"));
 const xoauth2_js_1 = __importDefault(require("./xoauth2.js"));
-const xtoybird_js_1 = __importDefault(require("./xtoybird.js"));
 exports.plugins = {
     acl: acl_js_1.default,
     appendlimit: appendlimit_js_1.default,
@@ -114,6 +113,5 @@ exports.plugins = {
     unselect: unselect_js_1.default,
     'utf8-accept': utf8_accept_js_1.default,
     'x-gm-ext-1': x_gm_ext_1_js_1.default,
-    xoauth2: xoauth2_js_1.default,
-    xtoybird: xtoybird_js_1.default
+    xoauth2: xoauth2_js_1.default
 };

package/dist/cjs/plugins/metadata-server.d.ts

@@ -1,7 +1,11 @@
 import type { IMAPServer } from '../types.js';
 /**
  * @help Adds METADATA-SERVER [RFC5464] capability, like METADATA but
- * @help only for server annotations (mailbox name ""). With METADATA
+ * @help only for server annotations (mailbox name ""), loads ENABLE. With METADATA
  * @help also loaded, only METADATA is advertised
  */
-export default function metadataServerPlugin(server: IMAPServer): void;
+declare function metadataServerPlugin(server: IMAPServer): void;
+declare namespace metadataServerPlugin {
+    var requires: string[];
+}
+export default metadataServerPlugin;

package/dist/cjs/plugins/metadata-server.js

@@ -4,12 +4,14 @@ exports.default = metadataServerPlugin;
 const metadata_js_1 = require("./metadata.js");
 /**
  * @help Adds METADATA-SERVER [RFC5464] capability, like METADATA but
- * @help only for server annotations (mailbox name ""). With METADATA
+ * @help only for server annotations (mailbox name ""), loads ENABLE. With METADATA
  * @help also loaded, only METADATA is advertised
  */
 function metadataServerPlugin(server) {
     (0, metadata_js_1.setup)(server, false);
 }
+// RFC 5464 section 4.1: a server that sends unsolicited METADATA responses "MUST support the ENABLE command"
+metadataServerPlugin.requires = ['ENABLE'];
 {
     const defaultExport = exports.default;
     if (defaultExport && (typeof defaultExport === 'function' || typeof defaultExport === 'object')) {

package/dist/cjs/plugins/metadata.d.ts

@@ -7,5 +7,9 @@ import type { IMAPServer } from '../types.js';
  * @param {Boolean} mailboxes If true, mailbox annotations are supported, otherwise only server annotations
  */
 declare function setup(server: IMAPServer, mailboxes: boolean): void;
-export default function metadataPlugin(server: IMAPServer): void;
+declare function metadataPlugin(server: IMAPServer): void;
+declare namespace metadataPlugin {
+    var requires: string[];
+}
+export default metadataPlugin;
 export { setup };