meocord 4.2.0 → 4.2.1

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

@@ -80,12 +80,20 @@ let problem;
         const reason = (problem.error instanceof Error ? problem.error.message : String(problem.error)).replace(/\.$/, '');
         const missing = missingPackage(problem.error);
         const neededBy = missing?.importer ? `, which ${missing.importer} imports,` : '';
-        const fix = missing ? `Install ${missing.name}${neededBy} in the project` : 'Fix meocord.config.ts';
-        return `MeoCord config at ${problem.path} failed to load: ${reason}. ${fix}, then run \`meocord build\`.`;
+        const fix = missing ? `Install ${missing.name}${neededBy} in the project, then run \`meocord build\`.` : fixedInConfig(problem.error) ? 'Fix meocord.config.ts, then run `meocord build`.' : 'It threw as it loaded: check the environment it reads, such as its .env files.';
+        return `MeoCord config at ${problem.path} failed to load: ${reason}. ${fix}`;
     }
     const where = problem?.path ?? 'meocord.config.mjs';
     return `MeoCord config not found at ${where} (working directory ${process.cwd()}). Run \`meocord build\`, and start the bot from the dist it writes.`;
 }
+/**
+ * Whether the config's file or imports are at fault, which a rebuild after fixing it mends: it could not be read as a
+ * 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;
+    return typeof code === 'string' && code.startsWith('ERR_REQUIRE_');
+}
 /**
  * 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
@@ -120,7 +128,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-CRn9kWob.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-XKMlcUZz.cjs', document.baseURI).href)));
         const loaded = load(compiledPath);
         return loaded.default ?? loaded;
     } catch (error) {
@@ -395,7 +403,30 @@ const warned = new Set();
     }
 });
 
-const scope = new node_async_hooks.AsyncLocalStorage();
+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)=>{
     if (value === null || typeof value !== 'object') return false;
     const prototype = Object.getPrototypeOf(value);
@@ -877,6 +908,38 @@ 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;
+const SHORT_ESCAPES = {
+    '\n': '\\n',
+    '\r': '\\r',
+    '\t': '\\t',
+    '"': '\\"',
+    '\\': '\\\\'
+};
+const escapeChar = (char)=>SHORT_ESCAPES[char] ?? `\\u${char.charCodeAt(0).toString(16).padStart(4, '0')}`;
+/** Text for a log line, on one line: its control characters escaped, so it can't start a line of its own. */ function escapeForLog(text) {
+    return text.replace(UNSAFE_IN_LOG, escapeChar);
+}
+/** How many characters of a user's text a log line quotes before cutting it short. */ const LOGGED_CHARACTERS = 200;
+/**
+ * A user's text as a log line quotes it: escaped as {@link escapeForLog} does, with its quotes and backslashes too,
+ * and cut short after 200 characters, with its length.
+ */ function quoteForLog(text) {
+    const characters = [
+        ...text
+    ];
+    const quoted = (shown)=>`"${shown.replace(UNSAFE_IN_QUOTES, escapeChar)}"`;
+    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(), {
+        maskedLink: true
+    });
+}
+/** Items as a sentence lists them: `a`, `a and b`, `a, b and c`. */ const listed = (items)=>items.length < 2 ? items.join('') : `${items.slice(0, -1).join(', ')} and ${items[items.length - 1]}`;
+
 /**
  * The role names MeoCord keeps for roles it may add to `colors`, `emojis` and `buttons`: the runtime copy of
  * `ReservedThemeRole`, which refuses them in TypeScript at the root theme, so that a JavaScript app is told too. A type
@@ -901,9 +964,10 @@ const EMOJI = 'a unicode emoji, or a custom one written <:name:id> or <a:name:id
 const BUTTON = 'ButtonStyle.Primary, Secondary, Success or Danger';
 /** A custom emoji as Discord writes one in text: its name, 2 to 32 word characters, and its id. */ const CUSTOM_EMOJI$1 = /^<a?:\w{2,32}:\d{17,20}>$/;
 /**
- * One unicode emoji: a flag of two regional indicators, a keycap, or a pictograph with an optional presentation
- * selector or skin tone, joined to others by zero-width joiners into one sequence.
- */ const UNICODE_EMOJI = /^(?:\p{Regional_Indicator}{2}|[#*0-9]️?⃣|\p{Extended_Pictographic}(?:️|\p{Emoji_Modifier})?(?:‍\p{Extended_Pictographic}(?:️|\p{Emoji_Modifier})?)*)$/u;
+ * One unicode emoji: a flag of two regional indicators, a subdivision flag (a black flag, tag characters and a cancel
+ * tag, as England's), a keycap, or a pictograph with an optional presentation selector or skin tone, joined to others by
+ * zero-width joiners into one sequence.
+ */ const UNICODE_EMOJI = /^(?:\p{Regional_Indicator}{2}|\u{1F3F4}[\u{E0020}-\u{E007E}]+\u{E007F}|[#*0-9]️?⃣|\p{Extended_Pictographic}(?:️|\p{Emoji_Modifier})?(?:‍\p{Extended_Pictographic}(?:️|\p{Emoji_Modifier})?)*)$/u;
 const byte = (value)=>Number.isInteger(value) && value >= 0 && value <= 255;
 /** Whether discord.js resolves the value to a colour Discord takes. Stricter on tuples, whose channels it only sums. */ function isColour(value) {
     if (typeof value === 'string') return /^#?[\da-f]{6}$/i.test(value) || value === 'Random' || value === 'Default' || Object.hasOwn(discord_js.Colors, value);
@@ -918,8 +982,9 @@ const THEMED_BUTTON_STYLES = [
     discord_js.ButtonStyle.Danger
 ];
 const isButtonStyle = (value)=>THEMED_BUTTON_STYLES.includes(value);
-const describe = (value)=>typeof value === 'string' ? `'${value}'` : Array.isArray(value) ? `[${value.map((item)=>typeof item === 'string' ? `'${item}'` : String(item)).join(', ')}]` : value === null ? 'null' : typeof value === 'object' ? 'an object' : String(value);
-const describeGroup = (value)=>Array.isArray(value) ? 'an array' : describe(value);
+const asWritten = (text)=>`'${text}'`;
+const describe = (value, quote = asWritten)=>typeof value === 'string' ? quote(value) : Array.isArray(value) ? `[${value.map((item)=>typeof item === 'string' ? quote(item) : String(item)).join(', ')}]` : value === null ? 'null' : typeof value === 'object' ? 'an object' : String(value);
+const describeGroup = (value, quote = asWritten)=>Array.isArray(value) ? 'an array' : describe(value, quote);
 /** Whether a value is a plain object, as an object literal or `JSON.parse` makes: one a theme merges key by key. */ const isPlainObject = (value)=>{
     const prototype = Object.getPrototypeOf(value);
     return prototype === Object.prototype || prototype === null;
@@ -951,11 +1016,15 @@ const PLAIN = "give a plain object, such as { ...value }, or a row's toObject(),
  * roles an app added, a colour discord.js cannot resolve, an emoji Discord would refuse, a button style other than
  * Discord's four coloured ones, or a reserved role name. A group of the app's own is its to check.
  * @param where - Where it was set, such as `themeFor.guild for guild 123`, to begin each line with.
- */ function themeProblems(theme, where) {
+ * @param options.forLog - Shows values and role names as a log line shows text from outside the code, for a theme a
+ *   `themeFor` resolver returned: escaped, and a value quoted and cut short.
+ */ function themeProblems(theme, where, { forLog = false } = {}) {
     const at = where ? `${where}: ` : '';
+    const quote = forLog ? quoteForLog : asWritten;
+    const name = forLog ? escapeForLog : (role)=>role;
     if (typeof theme !== 'object' || theme === null || Array.isArray(theme)) {
         return [
-            `${at}theme must be an object of groups (got ${describeGroup(theme)})`
+            `${at}theme must be an object of groups (got ${describeGroup(theme, quote)})`
         ];
     }
     if (!isPlainObject(theme)) return [
@@ -967,7 +1036,7 @@ const PLAIN = "give a plain object, such as { ...value }, or a row's toObject(),
         const roles = theme[group];
         if (roles === undefined) continue;
         if (typeof roles !== 'object' || roles === null || Array.isArray(roles)) {
-            problems.push(`${at}theme.${group} must be an object of roles (got ${describeGroup(roles)})`);
+            problems.push(`${at}theme.${group} must be an object of roles (got ${describeGroup(roles, quote)})`);
             continue;
         }
         if (!isPlainObject(roles)) {
@@ -975,8 +1044,8 @@ const PLAIN = "give a plain object, such as { ...value }, or a row's toObject(),
             continue;
         }
         for (const [role, value] of Object.entries(roles)){
-            if (reserved.has(role)) problems.push(`${at}theme.${group}.${role}: MeoCord reserves the role name ${role} for a role it may add; rename yours`);
-            else if (value !== undefined && !check(value)) problems.push(`${at}theme.${group}.${role}: ${describe(value)} is not ${what}: give ${instead}`);
+            if (reserved.has(role)) problems.push(`${at}theme.${group}.${name(role)}: MeoCord reserves the role name ${name(role)} for a role it may add; rename yours`);
+            else if (value !== undefined && !check(value)) problems.push(`${at}theme.${group}.${name(role)}: ${describe(value, quote)} is not ${what}: give ${instead}`);
         }
     }
     return problems;
@@ -1170,8 +1239,8 @@ const logger$5 = new Logger('SetMetadata');
 /**
  * Where a translator made by `createTranslator` keeps its catalogs, for MeoCord's texts, `@MeoCord` and
  * `expectCompleteCatalog`.
- */ const CATALOGS = Symbol('catalogs');
-/** How MeoCord's own texts read a translator made by `createTranslator`: the catalogs that serve a locale, in order. */ const LOCALE_CHAIN = Symbol('localeChain');
+ */ const CATALOGS = Symbol.for(sharedName('translator:catalogs'));
+/** How MeoCord's own texts read a translator made by `createTranslator`: the catalogs that serve a locale, in order. */ const LOCALE_CHAIN = Symbol.for(sharedName('translator:localeChain'));
 /** For a class that injects `Translator` in an app that configured none. */ function missingTranslatorError(cls) {
     return new Error(`${cls.name}: it injects Translator, but @MeoCord has no i18n. Pass @MeoCord({ i18n: t }), where t comes from createTranslator.`);
 }
@@ -1218,6 +1287,22 @@ function interpolate(message, params) {
     }
     return typeof current === 'object' && current !== null;
 }
+/** The locale Discord shows a locale's users when that locale has no localization of its own, by its locale fallbacks. */ const FALLBACK_PARTNERS = {
+    [discord_js.Locale.EnglishUS]: discord_js.Locale.EnglishGB,
+    [discord_js.Locale.EnglishGB]: discord_js.Locale.EnglishUS,
+    [discord_js.Locale.SpanishLATAM]: discord_js.Locale.SpanishES
+};
+/** Each key with a `.` in it, which `lookup` splits as a path and so never reaches, with the group it sits in. */ function dottedKeys(catalog, group = '') {
+    return Object.entries(catalog).flatMap(([name, value])=>[
+            ...name.includes('.') ? [
+                {
+                    name,
+                    group
+                }
+            ] : [],
+            ...typeof value === 'object' && value !== null ? dottedKeys(value, group ? `${group}.${name}` : name) : []
+        ]);
+}
 class CatalogTranslator extends Translator {
     /** The catalogs that serve a locale, most specific first, ending with the default. */ [LOCALE_CHAIN](requested) {
         const chain = [];
@@ -1236,10 +1321,13 @@ class CatalogTranslator extends Translator {
     translate(requested, key, params = {}) {
         for (const locale of this[LOCALE_CHAIN](requested)){
             const message = lookup(this.catalogs[locale], key);
-            if (message !== undefined) return interpolate(pluralForm({
+            if (message === undefined) continue;
+            // An empty translation, as tools export an untranslated string, counts as missing: Discord refuses an empty reply
+            const text = pluralForm({
                 message,
                 locale
-            }, params.count), params);
+            }, params.count);
+            if (text !== '') return interpolate(text, params);
         }
         this.warnUnknown(key);
         return key;
@@ -1269,11 +1357,16 @@ class CatalogTranslator extends Translator {
         for (const locale of this.locales){
             if (locale === this.defaultLocale) continue;
             const message = lookup(this.catalogs[locale], key);
-            // A translation with a {param} is left out: Discord would show it as written
-            if (typeof message === 'string' && placeholderNames(message).length === 0) {
+            // 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);
             }
         }
+        // Discord gives a locale it falls back from its partner's value, so the default keeps its own wording beside one
+        const partner = FALLBACK_PARTNERS[this.defaultLocale];
+        if (partner && localized[partner] !== undefined && typeof original === 'string' && original !== '') {
+            localized[this.defaultLocale] = fillPlaceholders(original, (_name, whole)=>whole);
+        }
         return localized;
     }
     for(interaction, options = {}) {
@@ -1352,6 +1445,12 @@ class CatalogTranslator extends Translator {
         }
     }
     if (!locales[defaultLocale]) throw refuse(new Error(`The default locale "${defaultLocale}" has no catalog in locales.`));
+    const logger = new Logger('Translator');
+    for (const [locale, catalog] of Object.entries(locales)){
+        for (const { name, group } of dottedKeys(catalog)){
+            logger.warn(`The ${locale} catalog's key "${name}"${group ? ` in ${group}` : ''} has a ".", which a lookup reads as a path, so its ` + 'message is never found. Nest it as a group instead.');
+        }
+    }
     // Typed by the default catalog; at runtime every catalog is read the same way.
     return new CatalogTranslator(defaultLocale, locales);
 }
@@ -1456,16 +1555,17 @@ const ENGLISH = 'en-US';
     return english();
 }
 const lists = new Map();
-/** A list in a locale's words: "a, b, or c" in en-US, or, for a unit, "a, b, c". */ function listIn(locale, style, items) {
-    let format = lists.get(`${locale} ${style}`);
-    if (!format) lists.set(`${locale} ${style}`, format = new Intl.ListFormat(locale, {
-        type: style === 'or' ? 'disjunction' : 'unit'
+/** An `or` list in a locale's words, such as "a, b, or c" in en-US. */ function orListIn(locale, items) {
+    let format = lists.get(locale);
+    if (!format) lists.set(locale, format = new Intl.ListFormat(locale, {
+        type: 'disjunction'
     }));
     return format.format(items);
 }
 /**
- * A text in `locale`, as {@link findText} finds it. A list in MeoCord's English is joined with its `joiner`, a comma
- * unless given; in an app's catalog, in the words of the locale that has it.
+ * A text in `locale`, as {@link findText} finds it. An `or` list in an app's catalog reads in the words of the locale
+ * 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;
@@ -1474,14 +1574,15 @@ const lists = new Map();
         if (!Object.hasOwn(params, name)) return whole;
         const value = params[name];
         if (typeof value !== 'object') return String(value);
-        if ('list' in value) return found.own ? listIn(found.locale, value.style, value.list) : value.list.join(value.joiner ?? ', ');
+        if ('list' in value) return found.own && value.style === 'or' ? orListIn(found.locale, value.list) : value.list.join(value.joiner ?? ', ');
         return renderText(translator, locale, value);
     });
 }
 /** Renders texts in one locale through one translator: a word or number as it is, a text in the locale's words. */ function textRenderer(translator, locale) {
     return (text)=>typeof text !== 'object' ? String(text) : 'list' in text ? text.list.join(text.joiner ?? ', ') : renderText(translator, locale, text);
 }
-const translators = new WeakMap();
+// Shared by both builds of this version, so either answers in the app's language
+const translators = shared('clientTranslators', ()=>new WeakMap());
 /** Records the translator of the app a client's interactions and messages come to. */ function registerClientTranslator(client, translator) {
     if (translator) translators.set(client, translator);
     else translators.delete(client);
@@ -1837,6 +1938,30 @@ const issueTexts = new WeakMap();
         this.name = 'CooldownStoreError';
     }
 }
+/**
+ * Makes `instanceof` hold for an error from either build of this meocord version, ES module or CommonJS: the class's
+ * prototype carries a brand both builds share, which `instanceof` on the class itself checks. A subclass, such as an
+ * app's own `UserError`, keeps the usual check, so it still matches only its own instances.
+ */ function brand(error, name) {
+    const key = sharedKey(`error:${name}`);
+    Object.defineProperty(error.prototype, key, {
+        value: true
+    });
+    Object.defineProperty(error, Symbol.hasInstance, {
+        value (value) {
+            if (this !== error) return Function.prototype[Symbol.hasInstance].call(this, value);
+            return (typeof value === 'object' || typeof value === 'function') && value !== null && key in value;
+        }
+    });
+}
+// Named as written, since a minifier may rename the classes themselves
+brand(GuardDeniedError, 'GuardDeniedError');
+brand(UserError, 'UserError');
+brand(CommandNotFoundError, 'CommandNotFoundError');
+brand(ValidationError, 'ValidationError');
+brand(MessageUsageError, 'MessageUsageError');
+brand(CooldownError, 'CooldownError');
+brand(CooldownStoreError, 'CooldownStoreError');
 
 /** Discord's codes for a body it could not read: invalid form body or JSON, or an empty message. */ const MALFORMED_BODY = new Set([
     discord_js.RESTJSONErrorCodes.InvalidFormBodyOrContentType,
@@ -1853,38 +1978,6 @@ const issueTexts = new WeakMap();
     else logger.error(`Could not ${what}:`, error);
 }
 
-/** 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;
-const SHORT_ESCAPES = {
-    '\n': '\\n',
-    '\r': '\\r',
-    '\t': '\\t',
-    '"': '\\"',
-    '\\': '\\\\'
-};
-const escapeChar = (char)=>SHORT_ESCAPES[char] ?? `\\u${char.charCodeAt(0).toString(16).padStart(4, '0')}`;
-/** Text for a log line, on one line: its control characters escaped, so it can't start a line of its own. */ function escapeForLog(text) {
-    return text.replace(UNSAFE_IN_LOG, escapeChar);
-}
-/** How many characters of a user's text a log line quotes before cutting it short. */ const LOGGED_CHARACTERS = 200;
-/**
- * A user's text as a log line quotes it: escaped as {@link escapeForLog} does, with its quotes and backslashes too,
- * and cut short after 200 characters, with its length.
- */ function quoteForLog(text) {
-    const characters = [
-        ...text
-    ];
-    const quoted = (shown)=>`"${shown.replace(UNSAFE_IN_QUOTES, escapeChar)}"`;
-    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(), {
-        maskedLink: true
-    });
-}
-/** Items as a sentence lists them: `a`, `a and b`, `a, b and c`. */ const listed = (items)=>items.length < 2 ? items.join('') : `${items.slice(0, -1).join(', ')} and ${items[items.length - 1]}`;
-
 /** 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';
 /** 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);
@@ -1893,6 +1986,17 @@ const escapeChar = (char)=>SHORT_ESCAPES[char] ?? `\\u${char.charCodeAt(0).toStr
     return typeof value === 'object' ? 'an object' : `a ${typeof value}`;
 }
 /** 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.
+ */ function setOwn(target, key, value) {
+    Object.defineProperty(target, key, {
+        value,
+        enumerable: true,
+        writable: true,
+        configurable: true
+    });
+}
 
 /**
  * The discord.js interaction class each command type handles, shared by `@Command`, the dispatcher and the testing
@@ -1990,7 +2094,7 @@ const escapeChar = (char)=>SHORT_ESCAPES[char] ?? `\\u${char.charCodeAt(0).toStr
                 walk(option.options ?? []);
                 continue;
             }
-            params[option.name] = resolveOptionValue(option);
+            setOwn(params, option.name, resolveOptionValue(option));
         }
     };
     walk(data);
@@ -2268,16 +2372,41 @@ 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;
-const presenters = new WeakMap();
+// 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);
 }
 /** The presenter for an interaction's client, or the default one. */ function presenterFor(client) {
     return client && presenters.get(client) || defaultPresenter;
 }
-function textOf(view) {
-    return view.emoji ? `${view.emoji} ${view.text}` : view.text;
+/** Discord's limits on a message's text, counted by `String.length` as discord.js's builders count them. */ const TEXT_LIMITS = {
+    embed: 4096,
+    v2: 4000,
+    content: 2000
+};
+/** `text` cut to `limit` characters ending in `…`, on a code point boundary so no surrogate pair is split. */ function fitText(text, limit) {
+    if (text.length <= limit) return text;
+    let cut = text.slice(0, Math.max(0, limit - 1));
+    const last = cut.charCodeAt(cut.length - 1);
+    if (last >= 0xd800 && last <= 0xdbff) cut = cut.slice(0, -1);
+    return `${cut}…`;
 }
+/**
+ * An error's message as a presenter is given it: fitted to `limit`, and, when empty or only whitespace, which Discord
+ * refuses as a text, MeoCord's generic error text, so a presenter that writes it as its text always renders.
+ */ function presentedMessage(message, limit, generic) {
+    return fitText(message.trim() === '' ? generic() : message, limit);
+}
+/**
+ * The view's text after what MeoCord puts before it, its emoji and a Text Display's title line. When only those take
+ * the two past `limit`, the text is cut so they fit; a text past `limit` by itself is left, a view MeoCord can't render.
+ */ function textAfter(prefix, view, limit) {
+    const total = prefix.length + view.text.length;
+    if (total <= limit || view.text.length > limit || prefix.length >= limit) return prefix + view.text;
+    return prefix + fitText(view.text, limit - prefix.length);
+}
+const emojiOf = (view)=>view.emoji ? `${view.emoji} ` : '';
 /** Discord's limit of attachments on one message. */ const ATTACHMENT_LIMIT = 10;
 /** The most items Discord shows in one media gallery. */ const MEDIA_GALLERY_LIMIT = 10;
 /**
@@ -2361,7 +2490,7 @@ const IMAGE = /\.(png|jpe?g|gif|webp)$/i;
     return (view.files ?? []).filter((file)=>!shown.has(`attachment://${nameOf(file)}`));
 }
 /** A view as an embed: its image, or else its first image file not its thumbnail, as the embed's image. */ function renderEmbed(view) {
-    const embed = new discord_js.EmbedBuilder().setDescription(textOf(view));
+    const embed = new discord_js.EmbedBuilder().setDescription(textAfter(emojiOf(view), view, TEXT_LIMITS.embed));
     if (view.title) embed.setTitle(view.title);
     if (view.color !== undefined) embed.setColor(view.color);
     const image = view.image ?? unshownFiles(view).map(nameOf).find((name)=>IMAGE.test(name));
@@ -2372,7 +2501,8 @@ const IMAGE = /\.(png|jpe?g|gif|webp)$/i;
 /** A view as a Components V2 container, carrying MeoCord's id. */ function renderContainer(view) {
     const container = new discord_js.ContainerBuilder().setId(RENDERED_CONTAINER_ID);
     if (view.color !== undefined) container.setAccentColor(discord_js.resolveColor(view.color));
-    const text = new discord_js.TextDisplayBuilder().setContent(view.title ? `### ${view.title}\n${textOf(view)}` : textOf(view));
+    const titleLine = view.title ? `### ${view.title}\n` : '';
+    const text = new discord_js.TextDisplayBuilder().setContent(textAfter(titleLine + emojiOf(view), view, TEXT_LIMITS.v2));
     if (view.thumbnail) {
         container.addSectionComponents(new discord_js.SectionBuilder().addTextDisplayComponents(text).setThumbnailAccessory(new discord_js.ThumbnailBuilder().setURL(urlOf(view, view.thumbnail))));
     } else container.addTextDisplayComponents(text);
@@ -2503,13 +2633,16 @@ const EMBED_CONTENT = [
     return sameJson(content(a), content(b));
 }
 
-let last = 0;
-const order = new WeakMap();
+// One count for both builds of this version, so calls either makes merge in the order made
+const calls = shared('callOrder', ()=>({
+        last: 0,
+        order: new WeakMap()
+    }));
 /** Marks a Discord call as made now, so calls recorded in different places can be merged in the order made. */ function stampCall(call) {
-    order.set(call, ++last);
+    calls.order.set(call, ++calls.last);
 }
 /** When a call stamped by {@link stampCall} was made, relative to the others. */ function callOrder(call) {
-    return order.get(call) ?? 0;
+    return calls.order.get(call) ?? 0;
 }
 
 /**
@@ -2642,7 +2775,10 @@ const logger$4 = new Logger('Theme');
    */ accept(id, result, report) {
         if (result === undefined || result === null) return undefined;
         const layer = copyLayer(result);
-        const problems = themeProblems(layer, `themeFor.${this.kind} for ${this.kind} ${id}`);
+        // 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
+        });
         if (problems.length === 0) {
             if (report) this.warned.delete(id);
             return layer;
@@ -2889,7 +3025,8 @@ function toBody(payload) {
  */ function editedSince(stamp, ours) {
     return typeof stamp === 'number' && ours !== undefined && stamp > ours;
 }
-const messageLocks = new Map();
+// Both builds of this meocord version keep one, so a message one locks, the other sees locked
+const messageLocks = shared('messageLocks', ()=>new Map());
 /** How long a locked message is remembered once no call holds it. */ const LOCK_MEMORY_MS = 60000;
 /**
  * A body with the theme's primary colour where the app left one unset: an embed with no `color`, and a
@@ -2951,9 +3088,12 @@ function toJson(value) {
         return this.phase;
     }
     get message() {
+        // A deleted answer, or a follow-up in its place, leaves the component's own message behind
+        if (this.answer.kind !== 'original') return this.lastMessage;
         return this.lastMessage ?? ('message' in this.interaction ? this.interaction.message ?? undefined : undefined);
     }
     get original() {
+        // Each component is a top-level component's API JSON, as `toJSON()` gave it; the lock reads them as plain JSON
         return this.snapshot;
     }
     /** The Discord calls made through this state, for tests. */ get history() {
@@ -3285,9 +3425,11 @@ function toJson(value) {
         this.sync();
         const body = await this.themed(payload, options);
         if (this.phase === 'unanswered') return this.reply(body);
-        if (this.phase === 'deferred' && answersWithOwnMessage(this.interaction)) {
+        // Once the answer is deleted, the next message sent is the answer
+        if (this.answer.kind === 'deleted') return this.answerWith(body);
+        if (this.phase === 'deferred' && answersWithOwnMessage(this.interaction) && this.answer.kind === 'original') {
             // Discord makes a follow-up to a deferred, unsent reply that reply, ignoring its flags: a private one
-            // would be shown to everyone on a public deferral, so that deferral is deleted first.
+            // would be shown to everyone on a public deferral, so that deferral is deleted, and the follow-up is the answer.
             const requested = Number(discord_js.MessageFlagsBitField.resolve(body.flags ?? 0));
             if (!hasEphemeral(requested)) return this.editMessage(body);
             // A private deferral is already what the flag asks for, which an edit cannot take
@@ -3297,7 +3439,11 @@ function toJson(value) {
             });
             await this.call('deleteReply', undefined, ()=>this.interaction.deleteReply());
             this.phase = 'replied';
+            return this.answerWith(body);
         }
+        return (await this.sendFollowUp(body)).message;
+    }
+    /** Sends a follow-up, with the flags it was sent with. */ async sendFollowUp(body) {
         const flags = this.withSuppression(this.flagsFor('followUp', body.flags, false));
         const sent = forMode(body, hasComponentsV2(flags));
         const message = await this.call('followUp', {
@@ -3307,6 +3453,20 @@ function toJson(value) {
                 ...sent,
                 flags
             }));
+        return {
+            message: message,
+            flags
+        };
+    }
+    /** Sends a follow-up that becomes the answer, which later edits and `delete()` act on by its id. */ async answerWith(body) {
+        const { message, flags } = await this.sendFollowUp(body);
+        // Its privacy as sent, not as read back from the message
+        this.answer = {
+            kind: 'followUp',
+            id: message.id,
+            ephemeral: hasEphemeral(flags)
+        };
+        this.lastMessage = message;
         return message;
     }
     delete() {
@@ -3314,7 +3474,22 @@ function toJson(value) {
             this.sync();
             if (this.phase === 'unanswered') throw new Error('There is no answer to delete: the interaction has not been answered.');
             this.refuseAfterModal();
-            await this.call('deleteReply', undefined, ()=>this.interaction.deleteReply());
+            const { answer } = this;
+            if (answer.kind === 'deleted') throw new Error('There is no answer to delete: it was deleted.');
+            // A follow-up is as private as it was sent, a command's own reply as the interaction's answer, a component's
+            // message as its flags
+            const shown = this.message?.flags?.has(discord_js.MessageFlags.Ephemeral) ?? false;
+            const ephemeral = answer.kind === 'followUp' ? answer.ephemeral : answersWithOwnMessage(this.interaction) ? Boolean(this.interaction.ephemeral) || shown : shown;
+            if (answer.kind === 'followUp') await this.call('deleteReply', answer.id, ()=>this.interaction.deleteReply(answer.id));
+            else await this.call('deleteReply', undefined, ()=>this.interaction.deleteReply());
+            this.answer = {
+                kind: 'deleted',
+                ephemeral
+            };
+            this.lastMessage = undefined;
+            // The message is gone: nothing is left to put back as it was before a lock
+            this.settled = true;
+            this.leave();
         });
     }
     /** A modal is the interaction's whole answer: what the user enters arrives as a submit interaction of its own. */ refuseAfterModal() {
@@ -3424,7 +3599,20 @@ function toJson(value) {
     withAttachments(body) {
         return rewriteAttachmentUrls(body, keptAttachmentNames(body, this.message?.attachments?.values() ?? []));
     }
-    /** Edits the answer through the interaction, and through the channel only once its token has expired. */ async editMessage(body, { restoring = false } = {}) {
+    /**
+   * Edits the answer through the interaction, and through the channel only once its token has expired. Once the answer
+   * is deleted, the edit is sent as a follow-up that becomes the answer, as private as the deleted one unless it sets
+   * flags of its own.
+   */ async editMessage(body, { restoring = false } = {}) {
+        const { answer } = this;
+        if (answer.kind === 'deleted') {
+            if (restoring) return undefined;
+            const { attachments: _attachments, ...rest } = body;
+            return this.answerWith({
+                ...rest,
+                flags: body.flags ?? (answer.ephemeral ? discord_js.MessageFlags.Ephemeral : 0)
+            });
+        }
         if (!restoring) {
             this.settled = true;
             this.leave();
@@ -3446,8 +3634,13 @@ function toJson(value) {
             ...this.withAttachments(forMode(body, this.v2)),
             flags
         };
+        // A follow-up that is the answer is edited by its id
+        const edit = answer.kind === 'followUp' ? {
+            ...sent,
+            message: answer.id
+        } : sent;
         try {
-            this.lastMessage = await this.call('editReply', sent, ()=>this.interaction.editReply(sent));
+            this.lastMessage = await this.call('editReply', edit, ()=>this.interaction.editReply(edit));
         } catch (error) {
             const message = this.message;
             const expired = Date.now() - this.interaction.createdTimestamp >= TOKEN_EXPIRED_AFTER_MS;
@@ -3566,12 +3759,16 @@ function toJson(value) {
    * place, and the failure is returned for the caller to report once the user is answered.
    */ async drawnView(error, message, theme) {
         const tone = isUserOutcome(error, this.interaction) ? 'warning' : 'danger';
+        const context = this.presenterContext(this.v2, theme);
+        // Fitted to the mode's limit first, so a presenter that writes the message as its text, MeoCord's own included, renders
+        const generic = ()=>textFor(this.interaction, {
+                key: 'meocord.fallback.error'
+            });
         const presented = {
-            message,
+            message: presentedMessage(message, TEXT_LIMITS[context.mode], generic),
             error,
             tone
         };
-        const context = this.presenterContext(this.v2, theme);
         const ready = (view)=>{
             const sendable = this.sendable(themedView(view, theme), this.keptBeside());
             // Rendered once here, so a view MeoCord cannot render fails before anything is sent
@@ -3714,6 +3911,11 @@ function toJson(value) {
             await this.followUpNow(this.privateError(view));
             return;
         }
+        // A deleted message has nothing to add the error to or put back: the error follows up, and is the answer
+        if (this.answer.kind === 'deleted') {
+            await this.followUpNow(this.privateError(view));
+            return;
+        }
         // The message the component is on: whether it is private does not change with edits.
         const current = 'message' in this.interaction ? this.interaction.message ?? undefined : this.message;
         if (current?.flags?.has(discord_js.MessageFlags.Ephemeral)) {
@@ -3759,6 +3961,12 @@ function toJson(value) {
         /** The answer steps asked for, run one after another; `pending` counts those not yet settled. */ this.queue = Promise.resolve();
         this.pending = 0;
         /** Whether the answer was a modal, which has no message to edit or delete. */ this.modalShown = false;
+        /**
+   * Which message is the answer: the interaction's own reply, a follow-up that took its place, or none since `delete()`,
+   * with whether the deleted one was private. `sync()` leaves it alone, so every edit follows it.
+   */ this.answer = {
+            kind: 'original'
+        };
         this.calls = [];
         /** Whether the interaction was acknowledged with a private deferred reply for a drawn error view, which that view replaces. */ this.privateDeferral = false;
         /** Whether the locked message was answered, so nothing restores it again. */ this.settled = false;
@@ -3770,7 +3978,8 @@ function toJson(value) {
         this.v2 = Boolean(message?.flags?.has(discord_js.MessageFlags.IsComponentsV2));
     }
 }
-const states = new WeakMap();
+// One state per interaction for both builds of this version, so either sees where the other left its answer
+const states = shared('responseStates', ()=>new WeakMap());
 /** The response state of a repliable interaction, created on first use. */ function responseOf(interaction) {
     let state = states.get(interaction);
     if (!state) states.set(interaction, state = new InteractionResponse(interaction));
@@ -4240,9 +4449,17 @@ const logger$2 = new Logger('ExecutionContext');
             };
         });
     }
-    /** Drops the keys whose calls have all left their window, once a minute from the store's first call. */ startSweeping() {
+    /**
+   * Drops the keys whose calls have all left their window, once a minute from a call, until a sweep leaves none: an
+   * idle store then holds no timer, so one nothing references is collected, and its next call starts the sweep again.
+   */ startSweeping() {
         if (this.sweeper) return;
-        this.sweeper = setInterval(()=>sweep(this.calls, Date.now()), SWEEP_INTERVAL_MS);
+        this.sweeper = setInterval(()=>{
+            sweep(this.calls, Date.now());
+            if (this.calls.size > 0) return;
+            clearInterval(this.sweeper);
+            this.sweeper = undefined;
+        }, SWEEP_INTERVAL_MS);
         // A cooldown must never be what keeps a stopping bot alive.
         this.sweeper.unref?.();
     }
@@ -4539,6 +4756,21 @@ const messageOf = (error)=>String(error?.message ?? error);
     };
 }
 
+/**
+ * Gives a decorator's `wrapper` the `length` and `name` of the method it replaces, so whatever reads the handler, such
+ * as `invoke` counting the arguments it takes, sees the method as it was declared.
+ */ function wrapsMethod(wrapper, original) {
+    Object.defineProperty(wrapper, 'length', {
+        value: original.length,
+        configurable: true
+    });
+    Object.defineProperty(wrapper, 'name', {
+        value: original.name,
+        configurable: true
+    });
+    return wrapper;
+}
+
 /**
  * How specific a route pattern is, for ranking the message patterns that can match one message: more literal
  * words first, then a fixed length before one taking the rest, then no optional param before one, then
@@ -4719,9 +4951,9 @@ const autocompleteRoute = (method, commandPath, optionName)=>({
     // 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);
-    const baseCommands = Reflect.getMetadata(META.commands, base) ?? {};
+    const baseCommands = Reflect.getMetadata(META.commands, base) ?? Object.create(null);
     for (const [name, metas] of Object.entries(commands)){
-        const kept = metas.filter((meta)=>!inheritedFor(baseCommands[name] ?? [], (entry)=>entry.methodName)(meta));
+        const kept = metas.filter((meta)=>!inheritedFor(commandsNamed(baseCommands, name), (entry)=>entry.methodName)(meta));
         if (kept.length > 0) commands[name] = kept;
         else delete commands[name];
     }
@@ -4745,16 +4977,21 @@ const autocompleteRoute = (method, commandPath, optionName)=>({
         Reflect.defineMetadata(key, ownHandlerList(key, prototype).filter((entry)=>!inheritedFor(inherited, method)(entry)), prototype);
     }
 }
-/** The class's own command map, started from a copy of the inherited one, for the same reason. */ function ownCommandMap(target) {
+/**
+ * The class's own command map, started from a copy of the inherited one, for the same reason. Keyed by command name
+ * without a prototype, so a command named like an inherited key, such as `constructor`, is a key like any other.
+ */ function ownCommandMap(target) {
     const own = Reflect.getOwnMetadata(META.commands, target);
     if (own) return own;
     const inherited = Reflect.getMetadata(META.commands, target) ?? {};
-    return Object.fromEntries(Object.entries(inherited).map(([name, metas])=>[
-            name,
-            [
-                ...metas
-            ]
-        ]));
+    const copy = Object.create(null);
+    for (const [name, metas] of Object.entries(inherited))copy[name] = [
+        ...metas
+    ];
+    return copy;
+}
+/** The handlers a command map holds for `name`: its own entry only, never one `Object.prototype` holds. */ function commandsNamed(map, name) {
+    return map && Object.hasOwn(map, name) ? map[name] : [];
 }
 function MessageHandler(pattern, options = {}) {
     return declaring(function(target, propertyKey) {
@@ -4819,12 +5056,24 @@ function ReactionHandler(emojiOrSettings, settings = {}) {
 }
 // `{name}`, or `{name:type}` with the type read as far as the brace, so a type no segment can hold is named
 const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
+// The whole of a brace pair that is a param, as PLACEHOLDER_PATTERN reads one
+const WHOLE_PLACEHOLDER = new RegExp(`^${PLACEHOLDER_PATTERN.source}$`);
+/**
+ * Why a pattern's brace pairs that aren't params are matched as literal text, or undefined when it has none: a
+ * param's name is ASCII letters, digits and _, so `{café}` is text.
+ */ function literalBraces(pattern) {
+    const braces = (pattern.match(/\{[^{}]*}/g) ?? []).filter((brace)=>!WHOLE_PLACEHOLDER.test(brace));
+    if (braces.length === 0) return undefined;
+    const one = braces.length === 1;
+    return `${braces.join(', ')} ${one ? "isn't a param" : "aren't params"}, since a param's name is ASCII letters, digits and _; ` + `${one ? 'it is' : 'they are'} matched as literal text.`;
+}
 /** The character a parameter will not cross, so one pattern segment maps to one value. */ const PARAM_SEPARATOR = '/';
+/** The longest customId Discord accepts; the shortest is one character. */ const MAX_CUSTOM_ID_LENGTH = 100;
 /** Escapes a literal stretch of a pattern so only placeholders stay meaningful. */ const escapeLiteral = (literal)=>literal.replace(/[/\\^$*+?.()|[\]{}]/g, '\\$&');
 /**
- * Compiles a pattern into a regex, its parameter names, their types and its 4.1 specificity. A `{name}` takes a
- * whole `/`-separated segment, so a uuid is captured whole and `profile/{uuid}` never overlaps
- * `profile/{uuid}/{id}`; a param that shares a segment with literal text is refused.
+ * Compiles a pattern into a regex, its parameter names, their types, its 4.1 specificity and the length of the
+ * shortest customId it matches. A `{name}` takes a whole `/`-separated segment, so a uuid is captured whole and
+ * `profile/{uuid}` never overlaps `profile/{uuid}/{id}`; a param that shares a segment with literal text is refused.
  */ function createRegexFromPattern(pattern) {
     const params = [];
     // By the param's own name, so one named like an inherited key, such as `__proto__`, keeps its type
@@ -4845,6 +5094,13 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
         if (literal !== '' && !literal.endsWith(PARAM_SEPARATOR) || after !== undefined && after !== PARAM_SEPARATOR) {
             throw refuse(new Error(`Invalid pattern "${pattern}": {${param}} must occupy a whole segment, so it has to be ` + `preceded and followed by "${PARAM_SEPARATOR}" or by the ends of the pattern. ` + `Write "a${PARAM_SEPARATOR}{${param}}" rather than "a-{${param}}".`));
         }
+        // A regex group's name, which the engine would refuse with the compiled regex in place of the pattern
+        if (params.includes(param)) {
+            throw refuse(new Error(`Invalid pattern "${pattern}": {${param}} appears twice; give each param its own name.`));
+        }
+        if (/^\d/.test(param)) {
+            throw refuse(new Error(`Invalid pattern "${pattern}": {${param}} starts with a digit; start a param's name with a letter or _.`));
+        }
         if (type !== undefined) {
             if (!isSegmentType(type)) throw refuse(new Error(`Invalid pattern "${pattern}": ${segmentTypeProblem(param, type)}`));
             if (choicesOf(type)?.includes('')) {
@@ -4868,11 +5124,13 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
         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
     return {
         regex,
         params,
         types: lookupTable(types),
-        specificity
+        specificity,
+        shortest: literalLength + params.length
     };
 }
 /** Why a `{name:type}` cannot type a customId segment, which holds text the bot wrote, with no message to read. */ function segmentTypeProblem(param, type) {
@@ -4942,7 +5200,6 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
  */ function Command(name, builderOrType) {
     const commandName = typeof name === 'string' ? name : name.pattern;
     return declaring(function(target, propertyKey, _descriptor) {
-        var _commands, _commandName;
         refuseOnClass('@Command', target, propertyKey);
         const originalMethod = _descriptor.value;
         if (!originalMethod) {
@@ -4950,7 +5207,7 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
         }
         // Wrap original method for interaction type validation
         const declaredAs = typeof builderOrType === 'function' ? builderOrType.name : `CommandType.${builderOrType}`;
-        _descriptor.value = function(interaction, params) {
+        const checked = function(interaction, params) {
             if (!matchesCommandType(commandType, interaction)) {
                 throw new Error(`${target.constructor.name}.${propertyKey}: @Command('${commandName}', ${declaredAs}) takes ` + `${interactionClassName(commandType)}${givenInstead(interaction)}.`);
             }
@@ -4959,6 +5216,7 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
                 params
             ]);
         };
+        _descriptor.value = wrapsMethod(checked, originalMethod);
         // This class's own map, inherited routes included
         const commands = ownCommandMap(target);
         let builderInstance;
@@ -4994,7 +5252,7 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
                     }));
                 }
                 // discord.js builders validate as they are set, and their errors name neither the command nor the field.
-                throw refuse(new Error(`${where}: ${builderOrType.name} could not build "${commandName}": ${detail}. Check its names, descriptions and ` + `localizations, which Discord limits to 32 and 100 characters.`, {
+                throw refuse(new Error(`${where}: ${builderOrType.name} could not build "${commandName}": ${detail}. Check its names, descriptions and ` + 'localizations, which Discord limits to 32 characters for a name and 100 for a description. A name is letters, ' + 'numbers, `-` and `_`, lowercase where the script has case, and without spaces, in every locale.', {
                     cause: error
                 }));
             }
@@ -5014,6 +5272,9 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
             commandType = builderOrType;
         }
         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}`);
             let pattern;
             try {
                 pattern = createRegexFromPattern(commandName);
@@ -5025,6 +5286,11 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
             regex = pattern.regex;
             dynamicParams = pattern.params;
             specificity = pattern.specificity;
+            // 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.`);
+            }
         }
         const declared = {
             methodName: propertyKey,
@@ -5041,8 +5307,9 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
             }
         };
         // One the class inherits for this method and route is replaced where it stands, so this one's options apply
-        const metas = (_commands = commands)[_commandName = commandName] ?? (_commands[_commandName] = []);
-        const inherited = getCommandMap(Object.getPrototypeOf(target))?.[commandName] ?? [];
+        if (!Object.hasOwn(commands, commandName)) commands[commandName] = [];
+        const metas = commands[commandName];
+        const inherited = commandsNamed(getCommandMap(Object.getPrototypeOf(target)), commandName);
         const replaced = metas.findIndex((meta)=>inherited.includes(meta) && meta.methodName === propertyKey && meta.type === commandType);
         if (replaced === -1) metas.push(declared);
         else metas[replaced] = declared;
@@ -5224,6 +5491,7 @@ exports.ExecutionContext = ExecutionContext;
 exports.GuardDeniedError = GuardDeniedError;
 exports.HandlerExecutionContext = HandlerExecutionContext;
 exports.Logger = Logger;
+exports.MAX_CUSTOM_ID_LENGTH = MAX_CUSTOM_ID_LENGTH;
 exports.MEOCORD_MESSAGES = MEOCORD_MESSAGES;
 exports.META = META;
 exports.MemoryCooldownStore = MemoryCooldownStore;
@@ -5233,6 +5501,7 @@ exports.REFUSED_AS_TOO_LARGE = REFUSED_AS_TOO_LARGE;
 exports.ReactionHandler = ReactionHandler;
 exports.RedisCooldownStore = RedisCooldownStore;
 exports.SetMetadata = SetMetadata;
+exports.TEXT_LIMITS = TEXT_LIMITS;
 exports.ThemeCache = ThemeCache;
 exports.Translator = Translator;
 exports.UnroutedExecutionContext = UnroutedExecutionContext;
@@ -5252,6 +5521,7 @@ exports.callOrder = callOrder;
 exports.choicesOf = choicesOf;
 exports.claimAmbientTheme = claimAmbientTheme;
 exports.collectStartupErrors = collectStartupErrors;
+exports.commandsNamed = commandsNamed;
 exports.compiledConfigMessage = compiledConfigMessage;
 exports.cooldownMessage = cooldownMessage;
 exports.cooldownStoreMessage = cooldownStoreMessage;
@@ -5272,6 +5542,7 @@ exports.dropInheritedRoutes = dropInheritedRoutes;
 exports.duration = duration;
 exports.escapeForLog = escapeForLog;
 exports.existingResponse = existingResponse;
+exports.fitText = fitText;
 exports.focusedOptionName = focusedOptionName;
 exports.forgetRecorded = forgetRecorded;
 exports.getAutocompleteHandlers = getAutocompleteHandlers;
@@ -5295,6 +5566,7 @@ exports.isRefusal = isRefusal;
 exports.isTooLarge = isTooLarge;
 exports.isUserOutcome = isUserOutcome;
 exports.listed = listed;
+exports.literalBraces = literalBraces;
 exports.loadMeoCordConfig = loadMeoCordConfig;
 exports.logFailedSend = logFailedSend;
 exports.logStartupErrors = logStartupErrors;
@@ -5334,10 +5606,13 @@ 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.shared = shared;
 exports.sharedCustomId = sharedCustomId;
+exports.sharedName = sharedName;
 exports.stampCall = stampCall;
 exports.startupError = startupError;
 exports.stopOnStartupErrors = stopOnStartupErrors;
@@ -5360,3 +5635,4 @@ exports.warnPlaceholder = warnPlaceholder;
 exports.withRelease = withRelease;
 exports.withSendableFiles = withSendableFiles;
 exports.withoutFiles = withoutFiles;
+exports.wrapsMethod = wrapsMethod;