meocord 4.2.1 → 4.2.3

package/dist/cjs/_shared/{controller.decorator-XKMlcUZz.cjs → controller.decorator-hp5xdJU4.cjs}

@@ -91,9 +91,22 @@ let problem;
  * module, or imports a file that isn't there. Otherwise its code threw as it ran.
  */ function fixedInConfig(error) {
     const code = error?.code;
-    if (error instanceof SyntaxError || code === 'ERR_MODULE_NOT_FOUND' || code === 'MODULE_NOT_FOUND') return true;
+    if (unparsable(error) || code === 'ERR_MODULE_NOT_FOUND' || code === 'MODULE_NOT_FOUND') return true;
     return typeof code === 'string' && code.startsWith('ERR_REQUIRE_');
 }
+/** The name of Bun's error for a module it could not parse; several of them come together in an AggregateError. */ const BUN_PARSE_ERROR = 'BuildMessage';
+/**
+ * Whether a module could not be parsed, so none of its code ran: on Node, a SyntaxError thrown from compiling it, whose
+ * first frame is Node's own; on Bun, its parse error. A SyntaxError the config's code throws as it runs, from
+ * `JSON.parse` or `new RegExp` on an environment value, is not one.
+ */ function unparsable(error) {
+    const bunParseError = (each)=>each?.name === BUN_PARSE_ERROR;
+    if (bunParseError(error)) return true;
+    if (error instanceof AggregateError) return error.errors.length > 0 && error.errors.every(bunParseError);
+    if (!(error instanceof SyntaxError)) return false;
+    const firstFrame = error.stack?.split('\n').find((line)=>line.trimStart().startsWith('at '));
+    return firstFrame === undefined || /[( ]node:/.test(firstFrame);
+}
 /**
  * The package a module-not-found error names, when it is a package rather than a file: `dotenv` for `dotenv/config`,
  * `@scope/name` for `@scope/name/sub`, with the installed package that imports it, if one does. Undefined for any other
@@ -128,7 +141,7 @@ let problem;
     try {
         // Called through a variable so a bundler does not try to resolve the path while building the
         // application; the file is only there once the build is done.
-        const load = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('_shared/controller.decorator-XKMlcUZz.cjs', document.baseURI).href)));
+        const load = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('_shared/controller.decorator-hp5xdJU4.cjs', document.baseURI).href)));
         const loaded = load(compiledPath);
         return loaded.default ?? loaded;
     } catch (error) {
@@ -142,6 +155,28 @@ let problem;
     }
 }
 
+var version = "4.2.3";
+var packageJson = {
+	version: version};
+
+/**
+ * The name of a key the ES module and CommonJS builds of this meocord version share, and no other version has, for
+ * `Symbol.for`: a process that loads both builds of one install keeps one state under it, and two installed versions
+ * keep theirs apart. `Symbol.for(sharedName(...))` written out types as a `unique symbol`.
+ */ const sharedName = (name)=>`meocord@${packageJson.version}:${name}`;
+/** The key named {@link sharedName}. */ function sharedKey(name) {
+    return Symbol.for(sharedName(name));
+}
+/** The state both builds of this version keep on `globalThis` under `name`, made by whichever asks first. */ function shared(name, make) {
+    const key = sharedKey(name);
+    const store = globalThis;
+    if (!Object.hasOwn(store, key)) Object.defineProperty(store, key, {
+        value: make(),
+        configurable: true
+    });
+    return store[key];
+}
+
 /** The environment variable that sets the level for one run, over `logLevel` in meocord.config.ts. */ const LOG_LEVEL_ENV = 'MEOCORD_LOG_LEVEL';
 /** Each level's rank: a line prints when its rank is at least the level's. `silent` outranks every line. */ const LOG_LEVEL_RANK = {
     debug: 0,
@@ -151,32 +186,35 @@ let problem;
     silent: 4
 };
 const isLogLevel = (value)=>typeof value === 'string' && Object.hasOwn(LOG_LEVEL_RANK, value);
-let threshold;
-let rejectedEnv;
+// One per process for this meocord version, so both builds print at one level and warn about a bad variable once
+const level = shared('logLevel', ()=>({
+        threshold: undefined,
+        rejectedEnv: undefined
+    }));
 /**
  * The rank a line needs to print. Resolved on first use and kept, so logging reads neither the
  * environment nor the config again: `MEOCORD_LOG_LEVEL`, then `logLevel`, then `debug` in development
  * and `log` otherwise. `logLevel` applies to the built bot only; the CLI and tests would otherwise read
  * it from whatever `dist` a previous build left.
  */ function logThreshold() {
-    if (threshold === undefined) {
+    if (level.threshold === undefined) {
         // The config first: loading it runs its dotenv call, which may set the variable
         const configured = isBuiltApplication() ? loadMeoCordConfig()?.logLevel : undefined;
         const raw = process.env[LOG_LEVEL_ENV];
         // An environment variable is often written in capitals, DEBUG for debug
         const fromEnv = raw?.toLowerCase();
-        rejectedEnv = raw && !isLogLevel(fromEnv) ? raw : undefined;
-        const level = isLogLevel(fromEnv) ? fromEnv : isLogLevel(configured) ? configured : process.env.NODE_ENV === 'development' ? 'debug' : 'log';
-        threshold = LOG_LEVEL_RANK[level];
+        level.rejectedEnv = raw && !isLogLevel(fromEnv) ? raw : undefined;
+        const chosen = isLogLevel(fromEnv) ? fromEnv : isLogLevel(configured) ? configured : process.env.NODE_ENV === 'development' ? 'debug' : 'log';
+        level.threshold = LOG_LEVEL_RANK[chosen];
     }
-    return threshold;
+    return level.threshold;
 }
 /**
  * An unknown `MEOCORD_LOG_LEVEL` the last resolution ignored, handed out once so the logger can warn
  * about it; undefined afterwards.
  */ function takeRejectedLogLevel() {
-    const rejected = rejectedEnv;
-    rejectedEnv = undefined;
+    const rejected = level.rejectedEnv;
+    level.rejectedEnv = undefined;
     return rejected;
 }
 
@@ -204,7 +242,8 @@ const tagColours = TAG_COLOURS;
  * The shortest value registered: a bot's credential is far longer, and a short value, such as a test's placeholder,
  * would replace ordinary words in every line.
  */ const MIN_HIDDEN_LENGTH = 16;
-const hiddenValues = new Set();
+// One per process for this meocord version, so a value hidden through one build stays out of the other's lines
+const hiddenValues = shared('hiddenValues', ()=>new Set());
 /**
  * Keeps `value`, such as the bot's credential, out of every line Logger prints from now on, whatever object, string
  * or error carries it: trimmed, and without the `Bot ` or `Bearer ` prefix discord.js strips.
@@ -345,7 +384,8 @@ const redact = (text)=>{
     }
 }
 
-const warned = new Set();
+// One per process for this meocord version, so a warning both builds give prints once
+const warned = shared('deprecationWarnings', ()=>new Set());
 /** Warns once per run that `old` goes in 5.0, naming what to use instead. */ function warnDeprecated(logger, old, replacement) {
     warnOnce(logger, `${old} is deprecated and will be removed in the next major version (5.0). Use ${replacement} instead.`);
 }
@@ -403,28 +443,6 @@ const warned = new Set();
     }
 });
 
-var version = "4.2.1";
-var packageJson = {
-	version: version};
-
-/**
- * The name of a key the ES module and CommonJS builds of this meocord version share, and no other version has, for
- * `Symbol.for`: a process that loads both builds of one install keeps one state under it, and two installed versions
- * keep theirs apart. `Symbol.for(sharedName(...))` written out types as a `unique symbol`.
- */ const sharedName = (name)=>`meocord@${packageJson.version}:${name}`;
-/** The key named {@link sharedName}. */ function sharedKey(name) {
-    return Symbol.for(sharedName(name));
-}
-/** The state both builds of this version keep on `globalThis` under `name`, made by whichever asks first. */ function shared(name, make) {
-    const key = sharedKey(name);
-    const store = globalThis;
-    if (!Object.hasOwn(store, key)) Object.defineProperty(store, key, {
-        value: make(),
-        configurable: true
-    });
-    return store[key];
-}
-
 // One per process for this meocord version, so a call's theme reads the same from its ES module and CommonJS builds
 const scope = shared('themeScope', ()=>new node_async_hooks.AsyncLocalStorage());
 const isPlainObject$1 = (value)=>{
@@ -487,50 +505,50 @@ const merges = new WeakMap();
     if (!merged) byLayer.set(layer, merged = deepFreeze(mergeInto(theme, layer)));
     return merged;
 }
-// Written by the deprecated `Theme` statics: beneath every theme an app sets
-let legacyLayer;
-let legacyVersion = 0;
-let defaults = DEFAULT_THEME;
+/**
+ * The theme state outside a call, one for both builds of this version so either reads what the other set: the defaults
+ * with what the deprecated `Theme` statics set beneath every theme, the app whose theme is read outside a call, and how
+ * an answer outside a call finds its theme.
+ */ const state = shared('themeState', ()=>({
+        defaults: DEFAULT_THEME,
+        legacyVersion: 0,
+        ambient: undefined,
+        ambientVersion: 0,
+        themeOutsideCalls: undefined
+    }));
 /** MeoCord's defaults, with what the deprecated `Theme` statics set over them. */ function defaultTheme() {
-    return defaults;
+    return state.defaults;
 }
 /** The number of times the legacy layer has changed, so a theme built on an older one is built again. */ function themeLayersVersion() {
-    return legacyVersion;
+    return state.legacyVersion;
 }
 /** Sets the layer the deprecated `Theme` statics write, merged over MeoCord's defaults. */ function setLegacyThemeLayer(layer) {
-    legacyLayer = layer === undefined ? undefined : copyLayer(layer);
-    defaults = mergeTheme(DEFAULT_THEME, legacyLayer);
-    legacyVersion++;
+    state.defaults = mergeTheme(DEFAULT_THEME, layer === undefined ? undefined : copyLayer(layer));
+    state.legacyVersion++;
 }
-// The theme outside any call: the one of the app or testing module that claimed it, until it gives it up
-let ambient;
-let ambientVersion = 0;
 /** The number of times the app read outside a call has changed, so each app decides again whether its calls need a scope. */ function ambientThemeVersion() {
-    return ambientVersion;
-}
-/** Whether some app's theme is the one read outside a call. */ function hasAmbientTheme() {
-    return ambient !== undefined;
+    return state.ambientVersion;
 }
 /**
  * Makes an app's theme the one read outside a call, when no other app has: a bot runs one app, and code it runs
  * outside a handler, such as a scheduled job, then reads that app's theme. A second app in the same process keeps
  * its theme to its own calls.
  */ function claimAmbientTheme(owner, theme) {
-    if (ambient && ambient.owner !== owner) return false;
-    if (!ambient) ambientVersion++;
-    ambient = {
+    if (state.ambient && state.ambient.owner !== owner) return false;
+    if (!state.ambient) state.ambientVersion++;
+    state.ambient = {
         owner,
         theme
     };
     return true;
 }
 /** Gives up the theme read outside a call, when `owner` has it: its start failed, or it has shut down. */ function releaseAmbientTheme(owner) {
-    if (ambient?.owner !== owner) return;
-    ambient = undefined;
-    ambientVersion++;
+    if (state.ambient?.owner !== owner) return;
+    state.ambient = undefined;
+    state.ambientVersion++;
 }
 /** Whether `owner` is the app whose theme is read outside a call. */ function ownsAmbientTheme(owner) {
-    return ambient?.owner === owner;
+    return state.ambient?.owner === owner;
 }
 /** Runs `fn` with `theme` as the theme of the call, for everything it runs, awaits or starts. */ function runWithTheme(theme, fn) {
     return scope.run({
@@ -546,10 +564,8 @@ let ambientVersion = 0;
 /** Runs `fn` in `themeScope`, whose theme may be replaced while it runs, as a per-server theme is found. */ function runInThemeScope(themeScope, fn) {
     return scope.run(themeScope, fn);
 }
-// Set by the runtime: the theme an app gives an interaction answered outside any call, as in a collector
-let themeOutsideCalls;
 /** Sets how an answer outside any call finds its theme: from the interaction's app, server and user. */ function setThemeOutsideCalls(resolve) {
-    themeOutsideCalls = resolve;
+    state.themeOutsideCalls = resolve;
 }
 /**
  * The theme an answer to `interaction` uses: the running call's, or, outside any call, as in a collector's callback,
@@ -557,7 +573,7 @@ let themeOutsideCalls;
  */ function themeForInteraction(interaction) {
     const call = scope.getStore();
     if (call) return call.theme;
-    return themeOutsideCalls?.(interaction) ?? useTheme();
+    return state.themeOutsideCalls?.(interaction) ?? useTheme();
 }
 /**
  * The theme of the running call, with every role present.
@@ -586,7 +602,7 @@ let themeOutsideCalls;
  *
  * @group Responses
  */ function useTheme() {
-    return scope.getStore()?.theme ?? ambient?.theme() ?? defaults;
+    return scope.getStore()?.theme ?? state.ambient?.theme() ?? state.defaults;
 }
 /**
  * Makes a function run in the theme of the call that binds it, wherever it is called from later.
@@ -595,6 +611,9 @@ let themeOutsideCalls;
  * Such a listener runs in its emitter's context, so without it a `useTheme()` inside reads the theme outside any call.
  * Timers and promises the handler starts keep its theme without it.
  *
+ * The theme is the binding call's whole theme, its server's and user's themes included, so every later call, whoever
+ * it is for, is answered in the starting member's theme.
+ *
  * @param fn - The function to run in the call's theme; `this` and its arguments are passed through.
  * @returns A function that runs `fn` in the theme `useTheme()` returns where `bindTheme` is called.
  *
@@ -604,7 +623,7 @@ let themeOutsideCalls;
  * async poll(message: Message) {
  *   const collector = message.createMessageComponentCollector({ componentType: ComponentType.Button, time: 60_000 })
  *   collector.on('collect', bindTheme(async (click: ButtonInteraction) => {
- *     const { emojis } = useTheme() // the handler's theme, @UseTheme included
+ *     const { emojis } = useTheme() // the starting member's theme, @UseTheme included
  *     await click.reply(`${emojis.success} Picked`)
  *   }))
  * }
@@ -632,7 +651,10 @@ const EXPLAINED = Symbol.for('meocord.explained');
  *
  * Use it where a bot logs a startup failure, so an error MeoCord explained is not logged twice: an app
  * `MeoCordFactory.create()` refuses, such as two handlers for one command, or Discord refusing the bot token or a
- * privileged intent at login. The error is otherwise unchanged.
+ * privileged intent at login. A built bot has `process.exitCode` set for such an error already, and a start that a stop
+ * ended, which is explained too, leaves it as it was, so the process exits 0. Outside a build, as a script run by hand,
+ * `MeoCordFactory.create()` sets no code for an app it refuses, so a catch that returns early for an explained error,
+ * as below, sets `process.exitCode` itself there. The error is otherwise unchanged.
  *
  * @param error - An error `MeoCordFactory.create()` threw or `app.start()` rejected with.
  * @returns `true` when MeoCord explained the error.
@@ -648,9 +670,10 @@ const EXPLAINED = Symbol.for('meocord.explained');
  *   await app.start()
  * }
  *
- * // An error MeoCord explained, such as an app it refuses or a token Discord refused, is already logged
+ * // An error MeoCord explained, such as an app it refuses or a token Discord refused, is already logged, with the exit code set
  * bootstrap().catch(error => {
- *   if (!isExplainedError(error)) logger.error('Error during startup:', error)
+ *   if (isExplainedError(error)) return
+ *   logger.error('Error during startup:', error)
  *   process.exitCode = 1
  * })
  * ```
@@ -679,10 +702,16 @@ const EXPLAINED = Symbol.for('meocord.explained');
 }
 
 const REFUSAL = Symbol.for('meocord.refusal');
-/** Whether this process reports refusals yet; see `reportRefusals`. */ let reporting = false;
-/** Refusals someone else reports, and ends the process for, which `reportRefusals` leaves to them. */ const handedOff = new WeakSet();
+/**
+ * One per process for this meocord version, so the two builds report a refusal once: whether this process reports
+ * refusals yet (see `reportRefusals`), and the refusals someone else reports, and ends the process for, which it leaves
+ * to them.
+ */ const refusals = shared('refusalReporting', ()=>({
+        reporting: false,
+        handedOff: new WeakSet()
+    }));
 /** Leaves a refusal to whoever reports it instead, such as a shard's manager: going uncaught, it is neither logged nor exits. */ function handOffRefusal(error) {
-    handedOff.add(error);
+    refusals.handedOff.add(error);
 }
 /**
  * Marks an error MeoCord raises for code it refuses as the application loads, such as a decorator given what it
@@ -693,18 +722,29 @@ const REFUSAL = Symbol.for('meocord.refusal');
         enumerable: false
     });
     // Before the error is thrown, so a built application reports it however the throw ends
-    if (!reporting && isBuiltApplication()) reportRefusals();
+    if (!refusals.reporting && isBuiltApplication()) reportRefusals();
     return error;
 }
-/** What a decorator is applied to, as a refusal names it: `Class.method` on a method, `Class` on a class. */ function decoratedName(target, propertyKey) {
+/** The name of the class a member decorator is applied in: a static member's target is the class itself. */ function ownerName(target) {
+    return (typeof target === 'function' ? target : target.constructor).name;
+}
+/**
+ * What a decorator is applied to, as a refusal names it: `Class.method` on a method, a static one included, `Class` on
+ * a class.
+ */ function decoratedName(target, propertyKey) {
     if (propertyKey === undefined) return target.name || 'a class';
-    return `${target.constructor.name}.${String(propertyKey)}`;
+    return `${ownerName(target)}.${String(propertyKey)}`;
 }
 /**
  * Refuses a decorator that goes only on a method, or on a member, where it is applied to a class, directly or through
- * `applyDecorators`, rather than store what nothing reads or fail on the method it lacks.
+ * `applyDecorators`, rather than store what nothing reads or fail on the method it lacks. On a static member, where
+ * nothing reads it either, it warns; the next major version (5.0) refuses it there too.
  */ function refuseOnClass(decorator, target, propertyKey, place = 'a method') {
     if (propertyKey === undefined) throw refuse(new Error(`${decoratedName(target)}: ${decorator} goes on ${place}, not on a class.`));
+    if (typeof target === 'function') {
+        const where = place === 'a method' ? 'an instance method, not a static one; it never runs' : 'an instance member, not a static one, where nothing reads it';
+        warnOnce(new Logger(decorator.slice(1)), `${decoratedName(target, propertyKey)}: ${decorator} goes on ${where}. The next major version (5.0) refuses it.`);
+    }
 }
 /** Refuses a decorator that goes only on a class where it is applied to a method, directly or through `applyDecorators`. */ function refuseOnMethod(decorator, target, propertyKey) {
     if (propertyKey !== undefined) throw refuse(new Error(`${decoratedName(target, propertyKey)}: ${decorator} goes on a class, not on a method.`));
@@ -887,9 +927,9 @@ function keepOrThrow(error, target, propertyKey) {
  * report. Installed by the first refusal in a built application. Bun has no monitor event for a rejection, so there a
  * listener reports a refused rejection and rejects any other again without itself, unless the app listens itself.
  */ function reportRefusals(log = (text)=>new Logger('MeoCord').error(text), exit = (code)=>process.exit(code), { bun = process.versions.bun !== undefined, reject = (reason)=>void Promise.reject(reason) } = {}) {
-    reporting = true;
+    refusals.reporting = true;
     const report = (error)=>{
-        if (handedOff.has(error)) return;
+        if (refusals.handedOff.has(error)) return;
         if (!isExplainedError(error)) log(describeRefusal(error, process.cwd()));
         exit(1);
     };
@@ -908,8 +948,8 @@ function keepOrThrow(error, target, propertyKey) {
     process.on('unhandledRejection', onRejection);
 }
 
-/** Characters a log line shows escaped: C0 and C1 controls, DEL, line and paragraph separators, and bidi controls. */ const UNSAFE_IN_LOG = /[\u0000-\u001f\u007f-\u009f\u2028\u2029\u202a-\u202e\u2066-\u2069]/g;
-/** The same, with the quote and the backslash, for text shown between quotes. */ const UNSAFE_IN_QUOTES = /[\u0000-\u001f\u007f-\u009f\u2028\u2029\u202a-\u202e\u2066-\u2069"\\]/g;
+/** Characters a log line shows escaped: C0 and C1 controls, DEL, line and paragraph separators, and bidi controls. */ const UNSAFE_IN_LOG = /[\u0000-\u001f\u007f-\u009f\u2028\u2029\p{Bidi_Control}]/gu;
+/** The same, with the quote and the backslash, for text shown between quotes. */ const UNSAFE_IN_QUOTES = /[\u0000-\u001f\u007f-\u009f\u2028\u2029\p{Bidi_Control}"\\]/gu;
 const SHORT_ESCAPES = {
     '\n': '\\n',
     '\r': '\\r',
@@ -933,8 +973,12 @@ const escapeChar = (char)=>SHORT_ESCAPES[char] ?? `\\u${char.charCodeAt(0).toStr
     if (characters.length <= LOGGED_CHARACTERS) return quoted(text);
     return `${quoted(`${characters.slice(0, LOGGED_CHARACTERS).join('')}…`)} (${characters.length} characters)`;
 }
-/** Words a user wrote, as a reply quotes them: on one line, with their markdown, masked links included, shown as typed. */ function userWords(text) {
-    return discord_js.escapeMarkdown(text.replace(/\s+/g, ' ').trim(), {
+/**
+ * Words a user wrote, as a reply quotes them: on one line, with their markdown, masked links included, shown as typed.
+ * Each run of whitespace reads as one space, and the spaces around the words are kept, since a word in quotes can
+ * carry them and be refused for them.
+ */ function userWords(text) {
+    return discord_js.escapeMarkdown(text.replace(/\s+/g, ' '), {
         maskedLink: true
     });
 }
@@ -989,7 +1033,7 @@ const describeGroup = (value, quote = asWritten)=>Array.isArray(value) ? 'an arr
     const prototype = Object.getPrototypeOf(value);
     return prototype === Object.prototype || prototype === null;
 };
-const PLAIN = "give a plain object, such as { ...value }, or a row's toObject(), since anything else would replace the whole";
+const PLAIN = "give a plain object: a database row's plain form, such as Mongoose's toObject() or Sequelize's get({ plain: true }), or an object literal of the values you set, since anything else would replace the whole";
 /** What a non-plain object is: by its class, or as one without a plain prototype when it has none named. */ const describeInstance = (value)=>{
     const name = value.constructor?.name;
     return typeof name === 'string' && name ? `a ${name}` : 'an object without a plain prototype';
@@ -1085,6 +1129,107 @@ const PLAIN = "give a plain object, such as { ...value }, or a row's toObject(),
     throw refuse(new Error(`${where}: the theme has ${problems.length} problem${problems.length === 1 ? '' : 's'}:\n${problems.map((problem)=>`  ${problem}`).join('\n')}`));
 }
 
+/** The theme role each static stands for; `errorColor` is a fault in the bot, `danger`. */ const ROLES = {
+    primaryColor: 'primary',
+    successColor: 'success',
+    infoColor: 'info',
+    errorColor: 'danger',
+    warningColor: 'warning'
+};
+const logger$6 = new Logger('Theme');
+// One per process for this meocord version, so a static set through one build keeps those set through the other
+const assigned = shared('legacyThemeColors', ()=>({}));
+/** Reads a role of the theme where it is read, warning once a run for each static read. */ function read(name) {
+    warnDeprecated(logger$6, `Theme.${name}`, `useTheme().colors.${ROLES[name]}`);
+    return useTheme().colors[ROLES[name]];
+}
+/** Sets a role beneath every theme an app sets; a value that is no colour is reported instead. */ function assign(name, value) {
+    const role = ROLES[name];
+    warnDeprecated(logger$6, `Assigning Theme.${name}`, `colors.${role} in @MeoCord({ theme })`);
+    const [problem] = themeProblems({
+        colors: {
+            [role]: value
+        }
+    }, `Theme.${name}`);
+    if (problem) {
+        logger$6.warn(`${problem}. It was left unset.`);
+        return;
+    }
+    assigned[role] = value;
+    setLegacyThemeLayer({
+        colors: {
+            ...assigned
+        }
+    });
+}
+/**
+ * Five of the theme's colours as static properties: primary, success, info, danger and warning.
+ *
+ * Each one reads the matching role of the theme where it is read, `useTheme().colors`, so code written against it
+ * follows `@MeoCord({ theme })` and `@UseTheme` with no change. Assigning one recolours MeoCord's views, as a
+ * role beneath every theme an app sets. Reading or assigning each one logs a warning once.
+ *
+ * @deprecated Since 4.1, and removed in the next major version (5.0). Use `useTheme().colors` instead. Themes
+ * follow the app, a controller and a server; set the colours in `@MeoCord({ theme })`: `primaryColor` is
+ * `colors.primary`, `successColor` `colors.success`, `infoColor` `colors.info`, `errorColor` `colors.danger` and
+ * `warningColor` `colors.warning`.
+ *
+ * @example
+ * ```ts
+ * // Both colour the embed with the call's primary colour; write the second in new code
+ * new EmbedBuilder().setColor(Theme.primaryColor)
+ * new EmbedBuilder().setColor(useTheme().colors.primary)
+ * ```
+ *
+ * @group Responses
+ */ class Theme {
+    /**
+   * @deprecated Since 4.1, and removed in the next major version (5.0). Use `useTheme().colors.primary` instead. It
+   * reads the theme where it is read; set `colors.primary` in `@MeoCord({ theme })`.
+   */ static get primaryColor() {
+        return read('primaryColor');
+    }
+    static set primaryColor(value) {
+        assign('primaryColor', value);
+    }
+    /**
+   * @deprecated Since 4.1, and removed in the next major version (5.0). Use `useTheme().colors.success` instead. It
+   * reads the theme where it is read; set `colors.success` in `@MeoCord({ theme })`.
+   */ static get successColor() {
+        return read('successColor');
+    }
+    static set successColor(value) {
+        assign('successColor', value);
+    }
+    /**
+   * @deprecated Since 4.1, and removed in the next major version (5.0). Use `useTheme().colors.info` instead. It
+   * reads the theme where it is read; set `colors.info` in `@MeoCord({ theme })`.
+   */ static get infoColor() {
+        return read('infoColor');
+    }
+    static set infoColor(value) {
+        assign('infoColor', value);
+    }
+    /**
+   * @deprecated Since 4.1, and removed in the next major version (5.0). Use `useTheme().colors.danger` instead. It
+   * reads the theme where it is read; set `colors.danger` in `@MeoCord({ theme })`.
+   */ static get errorColor() {
+        return read('errorColor');
+    }
+    static set errorColor(value) {
+        assign('errorColor', value);
+    }
+    /**
+   * @deprecated Since 4.1, and removed in the next major version (5.0). Use `useTheme().colors.warning` instead. It
+   * reads the theme where it is read; set `colors.warning` in `@MeoCord({ theme })`.
+   */ static get warningColor() {
+        return read('warningColor');
+    }
+    static set warningColor(value) {
+        assign('warningColor', value);
+    }
+}
+
 /**
  * Composes several class or method decorators into one.
  *
@@ -1246,17 +1391,36 @@ const logger$5 = new Logger('SetMetadata');
 }
 const DISCORD_LOCALES = new Set(Object.values(discord_js.Locale));
 const languageOf = (locale)=>locale.split('-')[0];
-/** A message by its dotted key, or undefined when the catalog lacks it or the key names a group. */ function lookup(catalog, key) {
+const PLURAL_CATEGORIES = new Set([
+    'zero',
+    'one',
+    'two',
+    'few',
+    'many',
+    'other'
+]);
+/** A plural's shape: a non-empty object whose every key is a plural category, as the types read one; any other is a group. */ const isPluralShape = (value)=>typeof value === 'object' && value !== null && Object.keys(value).length > 0 && Object.keys(value).every((key)=>PLURAL_CATEGORIES.has(key));
+/** The value at a dotted key's path, or undefined where the path ends early. */ function valueAt(catalog, key) {
     let current = catalog;
     for (const part of key.split('.')){
         if (typeof current !== 'object' || current === null) return undefined;
         current = current[part];
     }
+    return current;
+}
+/**
+ * A message by its dotted key, or undefined when the catalog lacks it or the key names a group. `reference`, the
+ * default catalog for a translation, decides where it has a group that an object is that group, so a translation that
+ * keeps only a group's `other` message isn't read as a plural. Where it has a message, or lacks the key, the object's
+ * own keys decide, so a translation may give a plural for a message its language needs one for. A plural without an
+ * `other` form reads as missing, so a translation that left it out falls back to the next catalog.
+ */ function lookup(catalog, key, reference = catalog) {
+    const current = valueAt(catalog, key);
     if (typeof current === 'string') return current;
-    if (typeof current === 'object' && current !== null && typeof current.other === 'string') {
-        return current;
-    }
-    return undefined;
+    if (!isPluralShape(current) || typeof current.other !== 'string') return undefined;
+    const shape = reference === catalog ? current : valueAt(reference, key);
+    const group = typeof shape === 'object' && shape !== null && !isPluralShape(shape);
+    return group ? undefined : current;
 }
 const plurals = new Map();
 /** The form of a found message to use: a plain message itself, or a plural's form for `count` in its locale's rules. */ function pluralForm({ message, locale }, count) {
@@ -1320,7 +1484,7 @@ class CatalogTranslator extends Translator {
     }
     translate(requested, key, params = {}) {
         for (const locale of this[LOCALE_CHAIN](requested)){
-            const message = lookup(this.catalogs[locale], key);
+            const message = lookup(this.catalogs[locale], key, this.catalogs[this.defaultLocale]);
             if (message === undefined) continue;
             // An empty translation, as tools export an untranslated string, counts as missing: Discord refuses an empty reply
             const text = pluralForm({
@@ -1356,7 +1520,7 @@ class CatalogTranslator extends Translator {
         const localized = {};
         for (const locale of this.locales){
             if (locale === this.defaultLocale) continue;
-            const message = lookup(this.catalogs[locale], key);
+            const message = lookup(this.catalogs[locale], key, this.catalogs[this.defaultLocale]);
             // A translation with a {param} is left out, as Discord would show it as written, and so is an empty one
             if (typeof message === 'string' && message !== '' && placeholderNames(message).length === 0) {
                 localized[locale] = fillPlaceholders(message, (_name, whole)=>whole);
@@ -1530,8 +1694,9 @@ const ENGLISH = 'en-US';
 /**
  * The message a text is in for `locale`, and whether it is the app's: the app's catalogs down the locale's chain, with
  * MeoCord's English as the English catalog. An English request reads it after the app's English catalogs and before a
- * default in another language; any other request reads it last.
- */ function findText(translator, locale, key) {
+ * default in another language; any other request reads it last. A message whose form for `count` is empty, as tools
+ * export an untranslated string, counts as missing, as it does for the app's own texts.
+ */ function findText(translator, locale, key, count) {
     const english = ()=>{
         const message = lookup(MEOCORD_MESSAGES, key);
         return message === undefined ? undefined : {
@@ -1546,7 +1711,10 @@ const ENGLISH = 'en-US';
         const beforeDefault = englishFirst && served === translator.defaultLocale ? english() : undefined;
         if (beforeDefault) return beforeDefault;
         const message = lookup(translator[CATALOGS][served], key);
-        if (message !== undefined) return {
+        if (message !== undefined && pluralForm({
+            message,
+            locale: served
+        }, count) !== '') return {
             message,
             locale: served,
             own: true
@@ -1567,9 +1735,9 @@ const lists = new Map();
  * that has it; any other list is joined with its `joiner`, a comma unless given, as Intl's `unit` lists join with
  * nothing in zh-CN and with a space in ja.
  */ function renderText(translator, locale, text) {
-    const found = findText(translator, locale, text.key);
-    if (!found) return text.fallback ?? text.key;
     const params = text.params ?? {};
+    const found = findText(translator, locale, text.key, params.count);
+    if (!found) return text.fallback ?? text.key;
     return fillPlaceholders(pluralForm(found, params.count), (name, whole)=>{
         if (!Object.hasOwn(params, name)) return whole;
         const value = params[name];
@@ -1595,7 +1763,8 @@ const translators = shared('clientTranslators', ()=>new WeakMap());
 /** A text for an interaction, in its user's language through its app's translator. */ function textFor(interaction, text) {
     return renderText(translatorOfClient(interaction.client), interactionLocale(interaction), text);
 }
-const issueTexts = new WeakMap();
+// One per process for this meocord version, so an issue made by one build is translated by the other
+const issueTexts = shared('issueTexts', ()=>new WeakMap());
 /** An issue of a usage error, whose message is the text in English, keeping the text to translate it later. */ function usageIssue(text, param) {
     const issue = {
         ...param !== undefined && {
@@ -1978,7 +2147,24 @@ brand(CooldownStoreError, 'CooldownStoreError');
     else logger.error(`Could not ${what}:`, error);
 }
 
-/** Whether a value is a class, which a stage entry or a `@Catch` type must be: what `new` and `instanceof` take. */ const isConstructor = (value)=>typeof value === 'function';
+/** Whether `new` takes a value, as `instanceof` needs of its right side, such as a `@Catch` type. */ function isConstructible(value) {
+    if (typeof value !== 'function') return false;
+    try {
+        // Fails unless value can be new.target, which only a constructor can; none of value's constructor code runs
+        Reflect.construct(String, [], value);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+/**
+ * Whether a value is a class, which a stage entry or an app option must be: constructible, with an object prototype for
+ * the metadata MeoCord reads. An arrow function, a method, an async or a generator function is none.
+ */ function isConstructor(value) {
+    if (!isConstructible(value)) return false;
+    const prototype = value.prototype;
+    return typeof prototype === 'object' && prototype !== null;
+}
 /** A value as a refusal or a warning names it: a string quoted, `null` and `undefined` as written, else its kind. */ function describeValue(value) {
     if (value === null || value === undefined) return String(value);
     if (typeof value === 'string') return quoteForLog(value);
@@ -1987,15 +2173,26 @@ brand(CooldownStoreError, 'CooldownStoreError');
 }
 /** A class's name after its article, such as `an AutocompleteInteraction`; a `U` name reads as "you", so takes `a`. */ const withArticle = (name)=>`${/^[AEIO]/i.test(name) ? 'an' : 'a'} ${name}`;
 /**
- * Sets `key` on `target` as an own, enumerable data property: unlike `target[key] = value`, a key named `__proto__`
- * is a key like any other rather than the object's prototype.
+ * Sets `key` on a plain object `target` as an own, enumerable data property: unlike `target[key] = value`, a key
+ * named `__proto__` is a key like any other rather than the object's prototype, and a key such as `toString` is set
+ * even where `Object.prototype` is frozen.
  */ function setOwn(target, key, value) {
-    Object.defineProperty(target, key, {
+    // An assignment would call __proto__'s setter, and throw for a member of a frozen Object.prototype. Any other key
+    // assigned is an own data property already; defining each would cost V8 its fast object shape
+    if (key in Object.prototype) Object.defineProperty(target, key, {
         value,
         enumerable: true,
         writable: true,
         configurable: true
     });
+    else target[key] = value;
+}
+/** `target`'s own value for `key`, never one it inherits, such as `Object.prototype.toString` for `toString`. */ const ownValue = (target, key)=>Object.hasOwn(target, key) ? target[key] : undefined;
+/**
+ * Gives each of `keys`, names `Object.prototype` has such as `toString` or `constructor`, that `target` doesn't hold
+ * an own `undefined`, so reading one left out gives `undefined` rather than the inherited member.
+ */ function shadowInherited(target, keys) {
+    for (const key of keys)if (!Object.hasOwn(target, key)) setOwn(target, key, undefined);
 }
 
 /**
@@ -2163,37 +2360,48 @@ brand(CooldownStoreError, 'CooldownStoreError');
  *
  * @group Utilities
  */ function getInstallContext(interaction) {
-    const owners = interaction.authorizingIntegrationOwners ?? {};
-    const guildInstalled = owners[discord_js.ApplicationIntegrationType.GuildInstall] !== undefined;
-    const userInstalled = owners[discord_js.ApplicationIntegrationType.UserInstall] !== undefined;
+    const botInstalled = isBotInstalled(interaction);
     switch(interaction.context){
         case discord_js.InteractionContextType.BotDM:
             return {
                 where: 'bot-dm',
-                botInstalled: true
+                botInstalled
             };
         case discord_js.InteractionContextType.PrivateChannel:
             return {
                 where: 'private-channel',
-                botInstalled: false
+                botInstalled
             };
         case discord_js.InteractionContextType.Guild:
-            // With no owners reported, the interaction came through the bot, as every interaction did before user installs.
             return {
                 where: 'guild',
-                botInstalled: guildInstalled || !userInstalled
+                botInstalled
             };
         default:
-            // Discord omits the context for interactions it created before contexts existed, which reached only the bot.
-            return interaction.guildId ? {
-                where: 'guild',
-                botInstalled: true
-            } : {
-                where: 'bot-dm',
-                botInstalled: true
+            return {
+                where: interaction.guildId ? 'guild' : 'bot-dm',
+                botInstalled
             };
     }
 }
+/**
+ * Whether the bot is present where an interaction happened, as {@link getInstallContext} reports it, read from Discord's
+ * `context` and the integrations that authorized it alone: no `guildId`, which only `where` needs.
+ */ function isBotInstalled(interaction) {
+    switch(interaction.context){
+        case discord_js.InteractionContextType.PrivateChannel:
+            return false;
+        case discord_js.InteractionContextType.Guild:
+            {
+                const owners = interaction.authorizingIntegrationOwners ?? {};
+                // With no owners reported, the interaction came through the bot, as every interaction did before user installs
+                return owners[discord_js.ApplicationIntegrationType.GuildInstall] !== undefined || owners[discord_js.ApplicationIntegrationType.UserInstall] === undefined;
+            }
+        default:
+            // A DM with the bot, or an interaction from before contexts existed, which reached only the bot
+            return true;
+    }
+}
 
 const { Ephemeral, SuppressEmbeds, SuppressNotifications, IsComponentsV2 } = discord_js.MessageFlags;
 /** The flags each call accepts; Discord rejects or ignores the rest. */ const ALLOWED = {
@@ -2226,6 +2434,22 @@ const { Ephemeral, SuppressEmbeds, SuppressNotifications, IsComponentsV2 } = dis
 /** The names of the flags set in a value, for warnings. */ function flagNames(flags) {
     return new discord_js.MessageFlagsBitField(flags).toArray();
 }
+/** Each call as a warning names it, its article included. */ const STEP_NAMES = {
+    deferReply: 'a deferred reply',
+    reply: 'a reply',
+    update: 'an update',
+    edit: 'an edit',
+    followUp: 'a follow-up'
+};
+/** What an update or an edit does with `Ephemeral` instead, and how to answer only the member. */ const PRIVATE_HINT = {
+    update: 'An update changes the message the member clicked, for everyone; to answer only them, use respond(interaction).followUp() with MessageFlags.Ephemeral.',
+    edit: 'An edit keeps the message as public or private as it was; to answer only the member, use respond(interaction).followUp() with MessageFlags.Ephemeral.'
+};
+/** The development warning for the flags a call dropped, with how to answer privately when `Ephemeral` is one of them. */ function droppedFlagsWarning(step, dropped) {
+    const text = `Dropped flags ${flagNames(dropped).join(', ')}, which ${STEP_NAMES[step]} cannot take.`;
+    const hint = hasEphemeral(dropped) ? PRIVATE_HINT[step] : undefined;
+    return hint ? `${text} ${hint}` : text;
+}
 
 const CDN_HOSTS = new Set([
     'cdn.discordapp.com',
@@ -2374,8 +2598,12 @@ function rewriteComponent(component, kept) {
 /** The id MeoCord gives the containers it renders, so a view left behind can be found again. */ const RENDERED_CONTAINER_ID = 0x4d43;
 // Shared by both builds of this version, so either answers with the app's presenter
 const presenters = shared('clientPresenters', ()=>new WeakMap());
-/** Sets the presenter for the interactions a client receives. */ function setPresenter(client, presenter) {
-    presenters.set(client, presenter);
+/** Sets the presenter for the interactions a client receives; without one, they take the default. */ function setPresenter(client, presenter) {
+    if (presenter) presenters.set(client, presenter);
+    else presenters.delete(client);
+}
+/** The presenter set on a client, if any. */ function clientPresenter(client) {
+    return presenters.get(client);
 }
 /** The presenter for an interaction's client, or the default one. */ function presenterFor(client) {
     return client && presenters.get(client) || defaultPresenter;
@@ -2770,15 +2998,25 @@ const logger$4 = new Logger('Theme');
         ]).finally(()=>clearTimeout(timer));
     }
     /**
-   * A result as a layer: copied, then checked; one with problems is left out, with a warning once per id when `report`.
-   * `null`, as a database gives for a missing row, is no theme, as `undefined` is.
+   * A result as a layer: copied, then checked; one with problems, or that throws as it is read, is left out, with a
+   * warning once per id when `report`. `null`, as a database gives for a missing row, is no theme, as `undefined` is.
    */ accept(id, result, report) {
         if (result === undefined || result === null) return undefined;
-        const layer = copyLayer(result);
-        // A value from the app's data, such as a user's saved choice, shown as a log line shows outside text
-        const problems = themeProblems(layer, `themeFor.${this.kind} for ${this.kind} ${id}`, {
-            forLog: true
-        });
+        const where = `themeFor.${this.kind} for ${this.kind} ${id}`;
+        let layer;
+        let problems;
+        try {
+            layer = copyLayer(result);
+            // A value from the app's data, such as a user's saved choice, shown as a log line shows outside text
+            problems = themeProblems(layer, where, {
+                forLog: true
+            });
+        } catch (error) {
+            // A cycle overflows the copy, and a getter may throw: the result is left out as one with problems is
+            problems = [
+                `${where}: theme cannot be read: ${quoteForLog(String(error?.message ?? error))}`
+            ];
+        }
         if (problems.length === 0) {
             if (report) this.warned.delete(id);
             return layer;
@@ -2907,13 +3145,14 @@ const logger$4 = new Logger('Theme');
 const idOf = (value)=>typeof value === 'string' ? value : undefined;
 /**
  * The server and user a call comes from: an interaction's or a message's server and its user or author; a
- * reaction's message's server and the user who reacted, which a reaction handler gets second; an event argument's
- * server and user, when it has them.
+ * reaction's message's server and the user who reacted, which a reaction handler gets second as `{ user }` and a
+ * reaction event as the `User`; an event argument's server and user, when it has them.
  */ function themeTargets(args) {
     const [first, second] = args;
     if (!first || typeof first !== 'object') return {};
     const guildId = idOf(first.guildId) ?? idOf(first.guild?.id) ?? idOf(first.message?.guildId);
-    const userId = idOf(first.user?.id) ?? idOf(first.author?.id) ?? idOf(second?.user?.id);
+    // Only a User's own id: an event of an old and a new channel, role or message would give the new one's otherwise
+    const userId = idOf(first.user?.id) ?? idOf(first.author?.id) ?? idOf(second?.user?.id) ?? (second instanceof discord_js.User ? idOf(second.id) : undefined);
     return {
         guildId,
         userId
@@ -2940,7 +3179,8 @@ const idOf = (value)=>typeof value === 'string' ? value : undefined;
         user
     ];
 }
-const stores = new WeakMap();
+// One per process for this meocord version, as the rest of an app's theme state is
+const stores = shared('themeCaches', ()=>new WeakMap());
 /**
  * An app's cache of the themes `@MeoCord({ themeFor })` looked up, by server and by user.
  *
@@ -2985,6 +3225,16 @@ const stores = new WeakMap();
     else stores.delete(themeCache);
 }
 
+function _class_private_field_loose_base(receiver, privateKey) {
+    if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
+        throw new TypeError("attempted to use private field on non-instance");
+    }
+    return receiver;
+}
+var id = 0;
+function _class_private_field_loose_key(name) {
+    return "__private_" + id++ + "_" + name;
+}
 const ALREADY_ACKNOWLEDGED = 40060;
 /** Discord's code for an interaction it no longer knows, such as one past its three seconds unacknowledged. */ const UNKNOWN_INTERACTION = 10062;
 const TOKEN_EXPIRED = new Set([
@@ -3082,6 +3332,7 @@ const messageLocks = shared('messageLocks', ()=>new Map());
 function toJson(value) {
     return typeof value?.toJSON === 'function' ? value.toJSON() : value;
 }
+var _location = /*#__PURE__*/ _class_private_field_loose_key("_location");
 /** The response state behind `respond()`, with what `@Defer` and the testing helpers use besides. */ class InteractionResponse {
     get state() {
         this.sync();
@@ -3120,7 +3371,7 @@ function toJson(value) {
     flagsFor(step, requested, v2 = this.v2) {
         const { flags, dropped } = resolveFlags(step, requested, v2);
         if (dropped && development()) {
-            logger$3.warn(`Dropped flags ${flagNames(dropped).join(', ')}, which a ${step} cannot take.`);
+            logger$3.warn(droppedFlagsWarning(step, dropped));
         }
         return flags;
     }
@@ -3383,15 +3634,15 @@ function toJson(value) {
         });
     }
     /**
-   * Undoes `@Defer`'s acknowledgement after a guard denied the call silently: a command's deferred
-   * reply is deleted while nothing was sent into it; a component's invisible acknowledgement needs
-   * nothing. Never throws.
+   * Ends a call a guard denied silently. A component still unanswered is acknowledged invisibly, with or without
+   * `@Defer`, since Discord tells the user an unanswered call failed; so is a command `@Defer`'s 'auto' timer was
+   * waiting on, whose deferred reply is then deleted, as `@Defer`'s is while nothing was sent into it. Never throws.
    */ abandon() {
         const waiting = this.timer !== undefined;
         this.cancelScheduled();
         return this.queued(async ()=>{
-            // Denied before the 'auto' timer: acknowledged here, since Discord tells the user an unanswered call failed
-            if (waiting) await this.acknowledgeUnanswered({
+            // A command's acknowledgement shows "thinking…", so one is made only for the timer that would have made it
+            if (waiting || !answersWithOwnMessage(this.interaction)) await this.acknowledgeUnanswered({
                 ephemeral: true
             });
             this.sync();
@@ -3644,7 +3895,7 @@ function toJson(value) {
         } catch (error) {
             const message = this.message;
             const expired = Date.now() - this.interaction.createdTimestamp >= TOKEN_EXPIRED_AFTER_MS;
-            if (!TOKEN_EXPIRED.has(errorCode(error)) || !expired || !this.location.botInstalled || !message) throw error;
+            if (!TOKEN_EXPIRED.has(errorCode(error)) || !expired || !isBotInstalled(this.interaction) || !message) throw error;
             this.lastMessage = await this.call('message.edit', sent, ()=>message.edit(sent));
         }
         this.phase = 'replied';
@@ -3956,6 +4207,10 @@ function toJson(value) {
         } : body;
     }
     constructor(interaction){
+        Object.defineProperty(this, _location, {
+            writable: true,
+            value: void 0
+        });
         this.interaction = interaction;
         this.phase = 'unanswered';
         /** The answer steps asked for, run one after another; `pending` counts those not yet settled. */ this.queue = Promise.resolve();
@@ -3973,7 +4228,14 @@ function toJson(value) {
         this.suppressNotifications = false;
         // Set by @Defer's first step, so an error can name what acknowledged the interaction
         this.underDefer = false;
-        this.location = getInstallContext(interaction);
+        Object.defineProperty(this, 'location', {
+            get: ()=>{
+                var _class_private_field_loose_base1, _location1;
+                return (_class_private_field_loose_base1 = _class_private_field_loose_base(this, _location))[_location1 = _location] ?? (_class_private_field_loose_base1[_location1] = getInstallContext(interaction));
+            },
+            enumerable: true,
+            configurable: true
+        });
         const message = 'message' in interaction ? interaction.message : undefined;
         this.v2 = Boolean(message?.flags?.has(discord_js.MessageFlags.IsComponentsV2));
     }
@@ -4055,8 +4317,10 @@ const states = shared('responseStates', ()=>new WeakMap());
     /**
    * The response state of the interaction being handled, the same one `respond(interaction)` returns,
    * or `undefined` for anything that cannot be answered: a message, a reaction, an event or
-   * autocomplete.
+   * autocomplete. An `@On('interactionCreate')` handler's call has none either, as MeoCord answers that interaction
+   * through the handler it dispatches it to.
    */ get response() {
+        if (this.getType() === 'event') return undefined;
         const interaction = this.getInteraction();
         return interaction?.isRepliable() ? respond(interaction) : undefined;
     }
@@ -4193,17 +4457,30 @@ const logger$2 = new Logger('ExecutionContext');
     }
 }
 
-/**
- * How many calls a cooldown allows, and in how long a window.
- *
- * @group Types
- */ /** `verdict` with `release` added as a non-enumerable property, as the built-in stores give it. */ function withRelease(verdict, release) {
+/** `verdict` with `release` added as a non-enumerable property, as the built-in stores give it. */ function withRelease(verdict, release) {
     return Object.defineProperty(verdict, 'release', {
         value: release,
         enumerable: false,
         configurable: true
     });
 }
+/**
+ * `verdict` with `retryTimestamp` added as a non-enumerable property, unless it holds the field already, so a refusal
+ * that gains it compares and serialises as it did.
+ */ function withRetryTimestamp(verdict, retryTimestamp) {
+    if (retryTimestamp === undefined || Object.hasOwn(verdict, 'retryTimestamp')) return verdict;
+    return Object.defineProperty(verdict, 'retryTimestamp', {
+        value: retryTimestamp,
+        enumerable: false,
+        configurable: true
+    });
+}
+/** A batch verdict for one key, as the built-in stores' `consume` gives it: `allowed`, `retryAfterMs`, and the wait's end. */ function singleVerdict({ allowed, retryAfterMs, retryTimestamp }) {
+    return withRetryTimestamp({
+        allowed,
+        retryAfterMs
+    }, retryTimestamp);
+}
 /**
  * Where `@Cooldown` counts calls.
  *
@@ -4254,10 +4531,11 @@ const logger$2 = new Logger('ExecutionContext');
    */ async consumeMany(entries) {
         for (const [index, { key, limit }] of entries.entries()){
             const verdict = await this.consume(key, limit);
-            if (!verdict.allowed) return {
+            // The wait's end by name, as a built-in store's consume gives it non-enumerable, which a spread leaves out
+            if (!verdict.allowed) return withRetryTimestamp({
                 ...verdict,
                 blocked: index
-            };
+            }, verdict.retryTimestamp);
         }
         return {
             allowed: true,
@@ -4283,6 +4561,18 @@ const logger$2 = new Logger('ExecutionContext');
         });
     }
 }
+// CooldownStore's own consumeMany and peekMany carry a mark both builds share, so a check can tell a store's
+// override from either build's default, as a store that extends one build's class can be checked by the other's
+const DEFAULT_BATCH_METHOD = sharedKey('cooldown-store:default-batch-method');
+for (const method of [
+    CooldownStore.prototype.consumeMany,
+    CooldownStore.prototype.peekMany
+]){
+    Object.defineProperty(method, DEFAULT_BATCH_METHOD, {
+        value: true
+    });
+}
+/** Whether `method` is CooldownStore's own consumeMany or peekMany, from either build of this version. */ const isDefaultBatchMethod = (method)=>typeof method === 'function' && DEFAULT_BATCH_METHOD in method;
 /**
  * Of several refusals, the one a caller waits on: the call runs only once every entry allows it, so the
  * longest wait. Undefined when nothing refused.
@@ -4373,16 +4663,12 @@ const logger$2 = new Logger('ExecutionContext');
  * @see {@link CooldownStore}
  */ class MemoryCooldownStore extends CooldownStore {
     async consume(key, limit) {
-        const { allowed, retryAfterMs } = await this.consumeMany([
+        return singleVerdict(await this.consumeMany([
             {
                 key,
                 limit
             }
-        ]);
-        return {
-            allowed,
-            retryAfterMs
-        };
+        ]));
     }
     /**
    * Checks every entry, and records the call against all of them only if all allow it.
@@ -4605,16 +4891,12 @@ const DEFAULT_PREFIX = 'meocord:cooldown:';
    * @param limit - The calls allowed, and the window they are counted over.
    * @returns Whether this call was recorded, and if not, how long until one can be.
    */ async consume(key, limit) {
-        const { allowed, retryAfterMs } = await this.consumeMany([
+        return singleVerdict(await this.consumeMany([
             {
                 key,
                 limit
             }
-        ]);
-        return {
-            allowed,
-            retryAfterMs
-        };
+        ]));
     }
     /**
    * Records a call against every entry if all allow it, as one script: one round trip, however many
@@ -4803,34 +5085,70 @@ const UNIT_MS = lookupTable({
     w: 604800000
 });
 /** A number written in full, `whole` for an integer: `undefined` for anything else. */ function number(word, whole) {
-    if (!(whole ? /^[+-]?\d+$/ : /^[+-]?(\d+\.?\d*|\.\d+)(e[+-]?\d+)?$/i).test(word)) return undefined;
+    // Each run of digits splits only one way, so refusing a word takes time linear in its length
+    if (!(whole ? /^[+-]?\d+$/ : /^[+-]?(\d+(?:\.\d*)?|\.\d+)(e[+-]?\d+)?$/i).test(word)) return undefined;
     const value = Number(word);
     return Number.isFinite(value) && (!whole || Number.isSafeInteger(value)) ? value : undefined;
 }
 /** `yes`, `no`, `true`, `false`, `on` or `off`, in any case, as a boolean. */ const bool = (word)=>BOOLEANS[word.toLowerCase()];
-/** A length of time written as amounts and units, such as `90s`, `2h30m` or `1.5d`, in milliseconds. */ function duration(word) {
-    const parts = word.toLowerCase().match(/(\d+(?:\.\d+)?)(ms|s|m|h|d|w)/g);
+/**
+ * A length of time written as amounts and units, such as `90s`, `2h30m` or `1.5d`, in milliseconds: `undefined` for one
+ * too long to add up.
+ */ function duration(word) {
+    // Sticky: each part starts where the last ended, so the scan stops at the first that doesn't and reads each part once
+    const parts = word.toLowerCase().match(/(\d+(?:\.\d+)?)(ms|s|m|h|d|w)/gy);
     if (!parts || parts.join('') !== word.toLowerCase()) return undefined;
-    return parts.reduce((total, part)=>{
+    const total = parts.reduce((sum, part)=>{
         const [, amount, unit] = /^(\d+(?:\.\d+)?)(ms|s|m|h|d|w)$/.exec(part);
-        return total + Number(amount) * UNIT_MS[unit];
+        return sum + Number(amount) * UNIT_MS[unit];
     }, 0);
+    // Too long to add up, as number() refuses a value past the largest number
+    return Number.isFinite(total) ? total : undefined;
 }
 /** The largest snowflake: Discord's IDs are unsigned 64-bit integers. */ const MAX_SNOWFLAKE = 2n ** 64n - 1n;
+/** The fewest and most digits a snowflake has, and the words of that many digits, with no leading zero. */ const SNOWFLAKE_DIGITS = {
+    min: 17,
+    max: 20
+};
+const SNOWFLAKE = new RegExp(`^[1-9]\\d{${SNOWFLAKE_DIGITS.min - 1},${SNOWFLAKE_DIGITS.max - 1}}$`);
 /**
  * A Discord ID, kept as its text: 17 to 20 digits, no leading zero, up to the largest 64-bit value. An ID's top 42 bits
  * are milliseconds since 2015-01-01, so every ID made from 2015-01-28 on has 17 digits or more, and none is a safe
  * integer.
- */ const snowflake = (word)=>/^[1-9]\d{16,19}$/.test(word) && BigInt(word) <= MAX_SNOWFLAKE ? word : undefined;
-/** A UUID in its canonical 8-4-4-4-12 form, in either case, kept as written. */ const uuid = (word)=>/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/i.test(word) ? word : undefined;
+ */ const snowflake = (word)=>SNOWFLAKE.test(word) && BigInt(word) <= MAX_SNOWFLAKE ? word : undefined;
+/** A UUID's canonical 8-4-4-4-12 form, 36 characters with its dashes. */ const UUID = /^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/i;
+const UUID_LENGTH = 36;
+/** A UUID in its canonical 8-4-4-4-12 form, in either case, kept as written. */ const uuid = (word)=>UUID.test(word) ? word : undefined;
 /** The words a type such as `on|off` chooses from, or `undefined` for any other type. */ const choicesOf = (type)=>type.includes('|') ? type.split('|') : undefined;
-/** The types a component's customId segment can take: each parsed from the segment alone, with no request. */ const SEGMENT_TYPES = lookupTable({
-    string: (segment)=>segment,
-    int: (segment)=>number(segment, true),
-    number: (segment)=>number(segment, false),
-    bool,
-    snowflake,
-    uuid
+/** The shortest segment of any type: one character. */ const SHORTEST_SEGMENT = 1;
+/**
+ * The types a component's customId segment can take: each parsed from the segment alone, with no request, and the
+ * fewest characters a segment of it has, which the check for a pattern no customId can match counts.
+ */ const SEGMENT_TYPES = lookupTable({
+    string: {
+        parse: (segment)=>segment,
+        shortest: SHORTEST_SEGMENT
+    },
+    int: {
+        parse: (segment)=>number(segment, true),
+        shortest: SHORTEST_SEGMENT
+    },
+    number: {
+        parse: (segment)=>number(segment, false),
+        shortest: SHORTEST_SEGMENT
+    },
+    bool: {
+        parse: bool,
+        shortest: Math.min(...Object.keys(BOOLEANS).map((word)=>word.length))
+    },
+    snowflake: {
+        parse: snowflake,
+        shortest: SNOWFLAKE_DIGITS.min
+    },
+    uuid: {
+        parse: uuid,
+        shortest: UUID_LENGTH
+    }
 });
 /**
  * Whether `type` can type a customId segment: `string`, `int`, `number`, `bool`, `snowflake`, `uuid`, or words to
@@ -4839,7 +5157,12 @@ const UNIT_MS = lookupTable({
 /** A customId segment as its type's value, words to choose from compared as written: `undefined` when it is not one. */ function parseSegment(type, segment) {
     const choices = choicesOf(type);
     if (choices) return choices.includes(segment) ? segment : undefined;
-    return SEGMENT_TYPES[type](segment);
+    return SEGMENT_TYPES[type].parse(segment);
+}
+/** The fewest characters a customId segment of `type` has: words to choose from count their shortest word. */ function shortestSegment(type) {
+    const choices = choicesOf(type);
+    if (choices) return Math.min(...choices.map((word)=>word.length));
+    return SEGMENT_TYPES[type]?.shortest ?? SHORTEST_SEGMENT;
 }
 
 /**
@@ -4889,6 +5212,12 @@ const UNIT_MS = lookupTable({
     return `; it was given ${describeValue(value)}`;
 }
 const logger = new Logger('Command');
+/** The interaction types a method's `@Command` routes declare, each once. */ function routeTypesOf(prototype, method) {
+    const metas = Object.values(getCommandMap(prototype) ?? {}).flat();
+    return [
+        ...new Set(metas.filter((meta)=>meta.methodName === method).map((meta)=>meta.type))
+    ];
+}
 /**
  * The class's own handler list, started from a copy of the inherited one, so a subclass's
  * handlers never land in its base class's metadata.
@@ -4914,6 +5243,10 @@ const autocompleteRoute = (method, commandPath, optionName)=>({
         method,
         label: `autocomplete of ${optionName === undefined ? 'every option' : `"${optionName}"`} in "${commandPath}"`
     });
+/** An `@On` or `@Once` handler as a warning names its route; one event per method, as a subclass replaces it. */ const eventRoute = ({ method, event })=>({
+        method,
+        label: `event "${event}"`
+    });
 /** Records a route a class's own decorator declares for a method, which the startup check reads. */ function declareRoute(target, declared) {
     const routes = Reflect.getOwnMetadata(META.declaredRoutes, target) ?? [];
     routes.push(declared);
@@ -4941,13 +5274,22 @@ const autocompleteRoute = (method, commandPath, optionName)=>({
     else handlers[index] = entry;
     Reflect.defineMetadata(key, handlers, target);
 }
+/** The `@On` and `@Once` entries a class's own decorators declare, without those it inherits from its base. */ function ownEventHandlers(prototype) {
+    const inherited = Reflect.getMetadata(META.eventHandlers, Object.getPrototypeOf(prototype)) ?? [];
+    return ownHandlerList(META.eventHandlers, prototype).filter((entry)=>!inherited.includes(entry));
+}
 /**
  * Leaves each method the class's own decorators declare only those routes, of every kind, dropping the ones it inherits
  * for it: what `@Controller({ inheritedRoutes: 'replace' })` does once the class's method decorators have run.
  */ function dropInheritedRoutes(prototype) {
-    const redeclared = new Set(getDeclaredRoutes(prototype).map((route)=>route.method));
-    if (redeclared.size === 0) return;
     const base = Object.getPrototypeOf(prototype);
+    // The class's own @On and @Once re-declare their methods too
+    const ownEvents = ownEventHandlers(prototype);
+    const redeclared = new Set([
+        ...getDeclaredRoutes(prototype).map((route)=>route.method),
+        ...ownEvents.map((entry)=>entry.method)
+    ]);
+    if (redeclared.size === 0) return;
     // An entry the class takes from its base, for a method it re-declares
     const inheritedFor = (inherited, method)=>(entry)=>inherited.includes(entry) && redeclared.has(method(entry));
     const commands = ownCommandMap(prototype);
@@ -4970,6 +5312,10 @@ const autocompleteRoute = (method, commandPath, optionName)=>({
         [
             META.autocompleteHandlers,
             (entry)=>entry.methodName
+        ],
+        [
+            META.eventHandlers,
+            (entry)=>entry.method
         ]
     ];
     for (const [key, method] of lists){
@@ -4996,13 +5342,14 @@ const autocompleteRoute = (method, commandPath, optionName)=>({
 function MessageHandler(pattern, options = {}) {
     return declaring(function(target, propertyKey) {
         refuseOnClass('@MessageHandler', target, propertyKey);
-        // An empty pattern means every message, as no pattern does
-        if (pattern === '') {
-            warnDeprecatedBehaviour(logger, `@MessageHandler('') on ${target.constructor.name}.${propertyKey}`, 'is refused', '@MessageHandler()');
+        // An empty pattern, or one of spaces alone, means every message, as no pattern does
+        const blank = pattern !== undefined && pattern.trim() === '';
+        if (blank) {
+            warnDeprecatedBehaviour(logger, `@MessageHandler('${pattern}') on ${decoratedName(target, propertyKey)}`, 'is refused', '@MessageHandler()');
         }
         const method = propertyKey.toString();
         const declared = {
-            pattern: pattern || undefined,
+            pattern: blank ? undefined : pattern,
             method,
             options
         };
@@ -5124,13 +5471,14 @@ const WHOLE_PLACEHOLDER = new RegExp(`^${PLACEHOLDER_PATTERN.source}$`);
         params: params.length,
         typed: Object.values(types).reduce((sum, type)=>sum + (choicesOf(type) ? 4 : type === 'bool' ? 3 : type === 'int' ? 2 : 1), 0)
     });
-    // Each param takes at least one character
+    // Each param takes at least the shortest value of its type
+    const shortest = literalLength + params.reduce((sum, param)=>sum + shortestSegment(types[param] ?? 'string'), 0);
     return {
         regex,
         params,
         types: lookupTable(types),
         specificity,
-        shortest: literalLength + params.length
+        shortest
     };
 }
 /** Why a `{name:type}` cannot type a customId segment, which holds text the bot wrote, with no message to read. */ function segmentTypeProblem(param, type) {
@@ -5203,13 +5551,17 @@ const WHOLE_PLACEHOLDER = new RegExp(`^${PLACEHOLDER_PATTERN.source}$`);
         refuseOnClass('@Command', target, propertyKey);
         const originalMethod = _descriptor.value;
         if (!originalMethod) {
-            throw refuse(new Error(`${target.constructor.name}.${propertyKey}: @Command is on something with no implementation.`));
+            throw refuse(new Error(`${decoratedName(target, propertyKey)}: @Command is on something with no implementation.`));
         }
         // Wrap original method for interaction type validation
         const declaredAs = typeof builderOrType === 'function' ? builderOrType.name : `CommandType.${builderOrType}`;
         const checked = function(interaction, params) {
-            if (!matchesCommandType(commandType, interaction)) {
-                throw new Error(`${target.constructor.name}.${propertyKey}: @Command('${commandName}', ${declaredAs}) takes ` + `${interactionClassName(commandType)}${givenInstead(interaction)}.`);
+            // Every type the method's routes declare, in the class the call is made on: each @Command wraps it, so one alone
+            // would refuse the others' interactions, and an override that adds a route type reaches this one through super
+            const called = typeof this === 'object' && this !== null && Object.prototype.isPrototypeOf.call(target, this) ? Object.getPrototypeOf(this) : target;
+            const types = routeTypesOf(called, propertyKey);
+            if (!types.some((type)=>matchesCommandType(type, interaction))) {
+                throw new Error(types.length <= 1 ? `${decoratedName(target, propertyKey)}: @Command('${commandName}', ${declaredAs}) takes ` + `${interactionClassName(commandType)}${givenInstead(interaction)}.` : `${decoratedName(target, propertyKey)}: its @Command routes take ${types.map(interactionClassName).join(' or ')}` + `${givenInstead(interaction)}.`);
             }
             return originalMethod.apply(this, [
                 interaction,
@@ -5227,7 +5579,7 @@ const WHOLE_PLACEHOLDER = new RegExp(`^${PLACEHOLDER_PATTERN.source}$`);
         let guilds;
         // Determine command type and builder
         if (typeof builderOrType === 'function') {
-            const where = `${target.constructor.name}.${propertyKey}`;
+            const where = decoratedName(target, propertyKey);
             // A subcommand is part of its command's builder, which belongs on the command's own name
             const subcommandPath = Reflect.getMetadata(META.commandType, builderOrType) === enum_index.CommandType.SLASH && commandName.includes(' ');
             const command = commandName.split(' ')[0];
@@ -5274,12 +5626,12 @@ const WHOLE_PLACEHOLDER = new RegExp(`^${PLACEHOLDER_PATTERN.source}$`);
         if (isCustomIdRouted(commandType)) {
             // A route warned as it was made
             const braces = typeof name === 'string' ? literalBraces(commandName) : undefined;
-            if (braces) logger.warn(`${target.constructor.name}.${propertyKey}: in the pattern "${commandName}", ${braces}`);
+            if (braces) logger.warn(`${decoratedName(target, propertyKey)}: in the pattern "${commandName}", ${braces}`);
             let pattern;
             try {
                 pattern = createRegexFromPattern(commandName);
             } catch (error) {
-                throw refuse(new Error(`${target.constructor.name}.${propertyKey}: ${error.message}`, {
+                throw refuse(new Error(`${decoratedName(target, propertyKey)}: ${error.message}`, {
                     cause: error
                 }));
             }
@@ -5289,7 +5641,7 @@ const WHOLE_PLACEHOLDER = new RegExp(`^${PLACEHOLDER_PATTERN.source}$`);
             // Warned rather than refused, so a bot that carries such a handler still starts
             if (pattern.shortest === 0 || pattern.shortest > MAX_CUSTOM_ID_LENGTH) {
                 const length = pattern.shortest === 0 ? 'the pattern is empty' : `its shortest is ${pattern.shortest} characters`;
-                logger.warn(`${target.constructor.name}.${propertyKey}: the pattern "${commandName}" matches no customId: Discord's customIds ` + `are 1 to ${MAX_CUSTOM_ID_LENGTH} characters, and ${length}, so the handler never runs.`);
+                logger.warn(`${decoratedName(target, propertyKey)}: the pattern "${commandName}" matches no customId: Discord's customIds ` + `are 1 to ${MAX_CUSTOM_ID_LENGTH} characters, and ${length}, so the handler never runs.`);
             }
         }
         const declared = {
@@ -5341,7 +5693,7 @@ const WHOLE_PLACEHOLDER = new RegExp(`^${PLACEHOLDER_PATTERN.source}$`);
     const registered = built?.type;
     if (!declared || registered === undefined || declared.kind === registered) return;
     const kind = registered === discord_js.ApplicationCommandType.User ? 'user' : 'message';
-    throw refuse(new Error(`${target.constructor.name}.${propertyKey}: it takes a ${declared.name} context menu interaction, but ${builderName} ` + `registers "${commandName}" as a ${kind} context menu command. Declare the handler's interaction as the kind the ` + `builder's setType() names.`));
+    throw refuse(new Error(`${decoratedName(target, propertyKey)}: it takes a ${declared.name} context menu interaction, but ${builderName} ` + `registers "${commandName}" as a ${kind} context menu command. Declare the handler's interaction as the kind the ` + `builder's setType() names.`));
 }
 /**
  * Retrieves the command map for a given controller.
@@ -5502,11 +5854,13 @@ exports.ReactionHandler = ReactionHandler;
 exports.RedisCooldownStore = RedisCooldownStore;
 exports.SetMetadata = SetMetadata;
 exports.TEXT_LIMITS = TEXT_LIMITS;
+exports.Theme = Theme;
 exports.ThemeCache = ThemeCache;
 exports.Translator = Translator;
 exports.UnroutedExecutionContext = UnroutedExecutionContext;
 exports.UserError = UserError;
 exports.ValidationError = ValidationError;
+exports.addOwnHandler = addOwnHandler;
 exports.allDeclaredErrors = allDeclaredErrors;
 exports.ambientThemeVersion = ambientThemeVersion;
 exports.applyDecorators = applyDecorators;
@@ -5520,6 +5874,7 @@ exports.bundleEntry = bundleEntry;
 exports.callOrder = callOrder;
 exports.choicesOf = choicesOf;
 exports.claimAmbientTheme = claimAmbientTheme;
+exports.clientPresenter = clientPresenter;
 exports.collectStartupErrors = collectStartupErrors;
 exports.commandsNamed = commandsNamed;
 exports.compiledConfigMessage = compiledConfigMessage;
@@ -5541,6 +5896,7 @@ exports.describeValue = describeValue;
 exports.dropInheritedRoutes = dropInheritedRoutes;
 exports.duration = duration;
 exports.escapeForLog = escapeForLog;
+exports.eventRoute = eventRoute;
 exports.existingResponse = existingResponse;
 exports.fitText = fitText;
 exports.focusedOptionName = focusedOptionName;
@@ -5553,15 +5909,17 @@ exports.getInstallContext = getInstallContext;
 exports.getMessageHandlers = getMessageHandlers;
 exports.getReactionHandlers = getReactionHandlers;
 exports.handOffRefusal = handOffRefusal;
-exports.hasAmbientTheme = hasAmbientTheme;
 exports.hasCustomId = hasCustomId;
 exports.hideInLogs = hideInLogs;
 exports.inferContextType = inferContextType;
 exports.interactionLocale = interactionLocale;
 exports.isBuiltApplication = isBuiltApplication;
+exports.isConstructible = isConstructible;
 exports.isConstructor = isConstructor;
 exports.isCustomIdRouted = isCustomIdRouted;
+exports.isDefaultBatchMethod = isDefaultBatchMethod;
 exports.isExplainedError = isExplainedError;
+exports.isPluralShape = isPluralShape;
 exports.isRefusal = isRefusal;
 exports.isTooLarge = isTooLarge;
 exports.isUserOutcome = isUserOutcome;
@@ -5581,7 +5939,9 @@ exports.mergeTheme = mergeTheme;
 exports.messageLocale = messageLocale;
 exports.missingTranslatorError = missingTranslatorError;
 exports.number = number;
-exports.ownHandlerList = ownHandlerList;
+exports.ownEventHandlers = ownEventHandlers;
+exports.ownValue = ownValue;
+exports.ownerName = ownerName;
 exports.ownsAmbientTheme = ownsAmbientTheme;
 exports.paramNarrowness = paramNarrowness;
 exports.parseSegment = parseSegment;
@@ -5605,33 +5965,34 @@ exports.responseOf = responseOf;
 exports.routeSpecificity = routeSpecificity;
 exports.runInThemeScope = runInThemeScope;
 exports.runWithTheme = runWithTheme;
-exports.setLegacyThemeLayer = setLegacyThemeLayer;
 exports.setOwn = setOwn;
 exports.setPresenter = setPresenter;
 exports.setStartupErrorsMode = setStartupErrorsMode;
 exports.setThemeOutsideCalls = setThemeOutsideCalls;
+exports.shadowInherited = shadowInherited;
 exports.shared = shared;
 exports.sharedCustomId = sharedCustomId;
 exports.sharedName = sharedName;
+exports.singleVerdict = singleVerdict;
 exports.stampCall = stampCall;
 exports.startupError = startupError;
+exports.startupErrorsOf = startupErrorsOf;
 exports.stopOnStartupErrors = stopOnStartupErrors;
 exports.textOfIssue = textOfIssue;
 exports.textRenderer = textRenderer;
 exports.themeForInteraction = themeForInteraction;
 exports.themeForProblem = themeForProblem;
 exports.themeLayersVersion = themeLayersVersion;
-exports.themeProblems = themeProblems;
 exports.themeResolverClass = themeResolverClass;
 exports.translatorOfClient = translatorOfClient;
 exports.usageHeading = usageHeading;
 exports.usageIssue = usageIssue;
 exports.useTheme = useTheme;
 exports.userWords = userWords;
-exports.warnDeprecated = warnDeprecated;
 exports.warnDeprecatedBehaviour = warnDeprecatedBehaviour;
 exports.warnOnce = warnOnce;
 exports.warnPlaceholder = warnPlaceholder;
+exports.withArticle = withArticle;
 exports.withRelease = withRelease;
 exports.withSendableFiles = withSendableFiles;
 exports.withoutFiles = withoutFiles;