meocord 4.1.2 → 4.2.1

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

@@ -27,6 +27,7 @@ var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
 
 /** Where the built bundle's pre-entry records the bundle's own path. */ const BUNDLE_ENTRY_KEY = Symbol.for('meocord.bundleEntry');
 /** Where the built bundle's pre-entry records the mode the bundle was built in. */ const BUILD_MODE_KEY = Symbol.for('meocord.buildMode');
+/** Where the built bot's pre-entry records `startupErrors` from its config, before the application's modules load. */ const STARTUP_ERRORS_KEY = Symbol.for('meocord.startupErrorsMode');
 /**
  * The file a shard process runs: the built bundle, as its pre-entry recorded it, else the script this
  * process was started with; undefined when there is none, as for code run with `node -e` outside a built bundle.
@@ -79,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
@@ -119,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-BywwkU9O.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) {
@@ -352,7 +361,7 @@ const warned = new Set();
  */ function warnPlaceholder(logger, value, outcome, how) {
     warnOnce(logger, `${value} reads a placeholder here; in the next major version (5.0) ${outcome}. ${how}`);
 }
-function warnOnce(logger, text) {
+/** Logs `text` once per run, however often it is asked for. */ function warnOnce(logger, text) {
     if (warned.has(text)) return;
     warned.add(text);
     logger.warn(text);
@@ -394,7 +403,30 @@ function warnOnce(logger, text) {
     }
 });
 
-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);
@@ -692,10 +724,10 @@ const REFUSAL = Symbol.for('meocord.refusal');
 // A stack frame's function and file: `at fn (file:line:col)` or `at file:line:col`, the file possibly a file:// URL
 const FRAME = /^\s*at (?:(.*?) \()?(.+?):\d+:\d+\)?$/;
 /**
- * A refusal as the application reports it: the message, and the first file of the application's own source the stack
- * passes through, other than its entry, which only loads the rest. The file alone: a line from a development build's
- * source map can be off, and a compiler's decorate helper can be placed in any file, so those frames are skipped.
- */ function describeRefusal(error, root, windows = process.platform === 'win32') {
+ * The first file of the application's own source an error's stack passes through, other than its entry, which only
+ * loads the rest, relative to `root`. The file alone: a line from a development build's source map can be off, and a
+ * compiler's decorate helper can be placed in any file, so those frames are skipped.
+ */ function sourceFileOf(error, root, windows = process.platform === 'win32') {
     const paths = windows ? path__default.default.win32 : path__default.default.posix;
     const source = comparablePath(paths.join(root, 'src') + paths.sep, windows);
     const entry = comparablePath(paths.join(root, 'src', 'main.ts'), windows);
@@ -706,9 +738,149 @@ const FRAME = /^\s*at (?:(.*?) \()?(.+?):\d+:\d+\)?$/;
         const file = paths.normalize(framePath(name, windows));
         const compared = comparablePath(file, windows);
         if (!compared.startsWith(source) || compared === entry || compared.includes(dependencies)) continue;
-        return `${error.message}\n    in ${paths.relative(root, file).split(paths.sep).join('/')}`;
+        return paths.relative(root, file).split(paths.sep).join('/');
     }
-    return error.message;
+    return undefined;
+}
+/**
+ * A refusal as the application reports it: the message, led by the declaration it is about where the message does not
+ * name it, and the file of the application's source it comes from; see {@link sourceFileOf}.
+ */ function describeRefusal(error, root, windows = process.platform === 'win32') {
+    const declaration = declarationOf(error);
+    const message = declaration && !error.message.startsWith(declaration) ? `${declaration}: ${error.message}` : error.message;
+    const file = sourceFileOf(error, root, windows);
+    return file ? `${message}\n    in ${file}` : message;
+}
+// ---------------------------------------------------------------------------
+// Startup errors: those create() and a testing module's compile() find, and those decorators find at import
+// ---------------------------------------------------------------------------
+const STARTUP_ERRORS = Symbol.for('meocord.startupErrors');
+const DECLARED = Symbol.for('meocord.declaredStartupErrors');
+const ALL_DECLARED = Symbol.for('meocord.allDeclaredStartupErrors');
+// The startup errors kept while checks run under collectStartupErrors; undefined outside them
+let kept;
+/**
+ * Reports an error a startup check finds. Outside {@link collectStartupErrors} it is thrown, as a refusal; inside, it
+ * is kept, and the check goes on to find the rest.
+ */ function startupError(error) {
+    refuse(error);
+    if (!kept) throw error;
+    // Two checks of one mistake, such as a class needing a translator, name it once
+    if (!kept.some((other)=>other.message === error.message)) kept.push(error);
+}
+/**
+ * Runs startup checks, and once they are done throws the first error they found, unchanged, with every one found on it
+ * for {@link startupErrorsOf}. An error that ends the checks after one was found is left out, as one the found error
+ * caused; one that ends them before any was found is thrown as it is.
+ */ function collectStartupErrors(checks) {
+    const outer = kept;
+    const found = [];
+    kept = found;
+    let result;
+    try {
+        result = checks();
+    } catch (error) {
+        if (found.length === 0) throw error;
+        if (isRefusal(error) && !found.includes(error)) found.push(error);
+        throw firstOf(found);
+    } finally{
+        kept = outer;
+    }
+    if (found.length > 0) throw firstOf(found);
+    return result;
+}
+/**
+ * Ends the checks under way with the errors found so far, before a step that is no check, such as binding or a warning:
+ * a run with one error stops where it stopped when the first error was thrown, and the errors of one pass of the
+ * checks are still reported together.
+ */ function stopOnStartupErrors() {
+    if (kept && kept.length > 0) throw kept[0];
+}
+function firstOf(errors) {
+    const [first] = errors;
+    Object.defineProperty(first, STARTUP_ERRORS, {
+        value: errors,
+        configurable: true
+    });
+    return first;
+}
+/** Every startup error found together with `error`, the first of them; `error` alone when it was the only one. */ function startupErrorsOf(error) {
+    return error[STARTUP_ERRORS] ?? [
+        error
+    ];
+}
+/**
+ * Logs each startup error found with `error` as the application reports a refusal, and how many there were, when there
+ * was more than one; a lone error is left to whoever reports it now.
+ */ function logStartupErrors(error, log, ending) {
+    const errors = startupErrorsOf(error);
+    if (errors.length < 2) return false;
+    for (const each of errors)log(describeRefusal(each, process.cwd()));
+    log(`MeoCord found ${errors.length} startup errors; ${ending}.`);
+    return true;
+}
+/** Sets how decorators report startup errors from here on, before the application's modules load. */ function setStartupErrorsMode(mode) {
+    globalThis[STARTUP_ERRORS_KEY] = mode;
+}
+/** Whether decorators keep their startup errors for create(), as `startupErrors: 'all'` has them. */ const keepsDeclaredErrors = ()=>globalThis[STARTUP_ERRORS_KEY] === 'all';
+/** The declaration a decorator's startup error is about, `Class.method` or `Class`. */ function declarationOf(error) {
+    return error.declaration;
+}
+/**
+ * A decorator that names, on each startup error it throws, the declaration it was applied to, `Class.method` or
+ * `Class`, as `declaration`, and the source file it is declared in, as `file`: the same error, thrown at the same
+ * moment, with its message unchanged. With `startupErrors: 'all'` the error is kept on the class instead, for create()
+ * to report with the rest, and the decorator applies nothing more.
+ */ function declaring(decorate) {
+    return function(target, propertyKey, ...rest) {
+        try {
+            return decorate.call(this, target, propertyKey, ...rest);
+        } catch (error) {
+            if (!isRefusal(error)) throw error;
+            keepOrThrow(error, target, propertyKey);
+            return undefined;
+        }
+    };
+}
+function keepOrThrow(error, target, propertyKey) {
+    var _globalThis, _ALL_DECLARED;
+    // A decorator applied through another, such as applyDecorators, names the declaration once, where it was first thrown
+    if (declarationOf(error) === undefined) {
+        Object.defineProperty(error, 'declaration', {
+            value: decoratedName(target, propertyKey),
+            configurable: true
+        });
+        Object.defineProperty(error, 'file', {
+            get: ()=>sourceFileOf(error, process.cwd()),
+            configurable: true
+        });
+    }
+    if (!keepsDeclaredErrors()) throw error;
+    const owner = typeof target === 'function' ? target : target.constructor;
+    if (!Object.prototype.hasOwnProperty.call(owner, DECLARED)) Object.defineProperty(owner, DECLARED, {
+        value: []
+    });
+    const declared = owner[DECLARED];
+    if (!declared.includes(error)) declared.push(error);
+    const all = (_globalThis = globalThis)[_ALL_DECLARED = ALL_DECLARED] ?? (_globalThis[_ALL_DECLARED] = []);
+    if (!all.includes(error)) all.push(error);
+}
+/** The startup errors decorators kept on `classes` and the classes they extend, each once, in the order they were found. */ function declaredErrorsOf(classes) {
+    const found = new Set();
+    for (const cls of classes){
+        for(let current = cls; typeof current === 'function' && current !== Function.prototype; current = Object.getPrototypeOf(current)){
+            if (Object.prototype.hasOwnProperty.call(current, DECLARED)) for (const error of current[DECLARED])found.add(error);
+        }
+    }
+    const order = allDeclaredErrors();
+    return [
+        ...found
+    ].sort((a, b)=>order.indexOf(a) - order.indexOf(b));
+}
+/** Every startup error decorators kept in this process, in the order they were found. */ function allDeclaredErrors() {
+    return [
+        ...globalThis[ALL_DECLARED] ?? []
+    ];
 }
 /**
  * Reports a refusal nothing catches as one line, with its source file, and exits 1; other errors keep the runtime's
@@ -736,6 +908,38 @@ const FRAME = /^\s*at (?:(.*?) \()?(.+?):\d+:\d+\)?$/;
     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
@@ -760,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);
@@ -777,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;
@@ -810,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 [
@@ -826,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)) {
@@ -834,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;
@@ -902,9 +1112,9 @@ const PLAIN = "give a plain object, such as { ...value }, or a row's toObject(),
  *
  * @group Utilities
  * @see {@link createMetadata}
- * @see {@link https://meocord.dev/docs/4.1/custom-decorators | Custom decorators}
+ * @see {@link https://meocord.dev/docs/4.2/custom-decorators | Custom decorators}
  */ function applyDecorators(...decorators) {
-    return function(target, propertyKey, descriptor) {
+    return declaring(function(target, propertyKey, descriptor) {
         // Last first, as TypeScript applies decorators stacked, each given what the one before it returned
         const ordered = [
             ...decorators
@@ -917,7 +1127,7 @@ const PLAIN = "give a plain object, such as { ...value }, or a row's toObject(),
         let current = target;
         for (const decorator of ordered)current = decorator(current) ?? current;
         return current;
-    };
+    });
 }
 const logger$5 = new Logger('SetMetadata');
 /** The prefix of every key MeoCord keeps its own metadata under. */ const MEOCORD_PREFIX = 'meocord:';
@@ -956,7 +1166,7 @@ const logger$5 = new Logger('SetMetadata');
  * @see {@link createMetadata}
  */ function SetMetadata(metadataKey, metadataValue) {
     warnDeprecated(logger$5, 'SetMetadata', 'createMetadata');
-    return function(target, propertyKey) {
+    return declaring(function(target, propertyKey) {
         // Checked where it applies, so the refusal names the handler or controller
         const owner = metadataKey.startsWith(MEOCORD_PREFIX) ? `MeoCord keeps its own metadata under keys beginning "${MEOCORD_PREFIX}"` : INJECTION_KEYS.has(metadataKey) ? 'dependency injection reads how to make the class from it' : undefined;
         if (owner) {
@@ -967,7 +1177,7 @@ const logger$5 = new Logger('SetMetadata');
         } else {
             Reflect.defineMetadata(metadataKey, metadataValue, target);
         }
-    };
+    });
 }
 
 /**
@@ -1029,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.`);
 }
@@ -1077,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 = [];
@@ -1095,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;
@@ -1128,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 = {}) {
@@ -1211,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);
 }
@@ -1315,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;
@@ -1333,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);
@@ -1456,7 +1698,7 @@ const issueTexts = new WeakMap();
  * @group Responses
  * @category Errors
  * @see {@link Catch}
- * @see {@link https://meocord.dev/docs/4.1/exception-filters | Exception filters}
+ * @see {@link https://meocord.dev/docs/4.2/exception-filters | Exception filters}
  */ class CommandNotFoundError extends Error {
     /** @param message - What the error says, `No handler matched the interaction.` unless given. */ constructor(message = 'No handler matched the interaction.'){
         super(message);
@@ -1529,7 +1771,7 @@ const issueTexts = new WeakMap();
  * @category Errors
  * @see {@link MessageHandler}
  * @see {@link translateError}
- * @see {@link https://meocord.dev/docs/4.1/message-commands | Message commands}
+ * @see {@link https://meocord.dev/docs/4.2/message-commands | Message commands}
  */ class MessageUsageError extends Error {
     /**
    * @param usage - The command as the user should type it, such as `!ban <target> [reason…]`, or one line per
@@ -1696,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,
@@ -1712,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);
@@ -1752,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
@@ -1849,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);
@@ -2127,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;
 /**
@@ -2220,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));
@@ -2231,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);
@@ -2362,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;
 }
 
 /**
@@ -2501,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;
@@ -2748,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
@@ -2810,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() {
@@ -3144,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
@@ -3156,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', {
@@ -3166,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() {
@@ -3173,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() {
@@ -3283,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();
@@ -3305,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;
@@ -3425,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
@@ -3573,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)) {
@@ -3618,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;
@@ -3629,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));
@@ -3700,7 +4050,7 @@ const states = new WeakMap();
  * @group Utilities
  * @see {@link createMetadata}
  * @see {@link StageParams}
- * @see {@link https://meocord.dev/docs/4.1/guards | Guards}
+ * @see {@link https://meocord.dev/docs/4.2/guards | Guards}
  */ class ExecutionContext {
     /**
    * The response state of the interaction being handled, the same one `respond(interaction)` returns,
@@ -4099,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?.();
     }
@@ -4399,10 +4757,25 @@ const messageOf = (error)=>String(error?.message ?? error);
 }
 
 /**
- * How specific a route pattern is, for ranking the patterns that can match one input: more literal
- * text first, then a fixed length before one taking the rest, then no optional param before one, then
- * fewer params, then narrower typed params, whose segments take fewer values. Component patterns count literal
- * characters; message patterns count literal words.
+ * 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
+ * fewer params, then narrower typed params, whose words take fewer values. Component patterns count literal
+ * characters, for CommandMeta.specificity alone.
  */ function routeSpecificity({ literals, params, rest = false, optional = false, typed = 0 }) {
     return literals * 1000 - (rest ? 500 : 0) - (optional ? 250 : 0) - params + typed / 1000;
 }
@@ -4443,14 +4816,26 @@ const UNIT_MS = lookupTable({
         return total + Number(amount) * UNIT_MS[unit];
     }, 0);
 }
+/** The largest snowflake: Discord's IDs are unsigned 64-bit integers. */ const MAX_SNOWFLAKE = 2n ** 64n - 1n;
+/**
+ * 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;
 /** 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
+    bool,
+    snowflake,
+    uuid
 });
-/** Whether `type` can type a customId segment: `string`, `int`, `number`, `bool`, or words to choose from. */ const isSegmentType = (type)=>type in SEGMENT_TYPES || choicesOf(type) !== undefined;
+/**
+ * Whether `type` can type a customId segment: `string`, `int`, `number`, `bool`, `snowflake`, `uuid`, or words to
+ * choose from.
+ */ const isSegmentType = (type)=>type in SEGMENT_TYPES || choicesOf(type) !== undefined;
 /** 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;
@@ -4481,6 +4866,7 @@ const UNIT_MS = lookupTable({
     /** How many guard wrappers `@UseGuard` and `@Controller` put around one method. */ guardWrappers: 'meocord:guard-wrappers',
     /** The prototype whose method a class-level `@UseGuard` re-declared on a subclass. */ inheritedFrom: 'meocord:inherited-from',
     /** `false` when `@Controller({ inheritStages: false })` stops class stages at this class. */ inheritStages: 'meocord:inherit-stages',
+    /** `true` when `@Controller({ inheritedRoutes: 'replace' })` drops the routes this class's re-decorated methods inherit. */ replacesInheritedRoutes: 'meocord:replaces-inherited-routes',
     /** A controller's class-level `@Cooldown`s. */ classCooldowns: 'meocord:class-cooldowns',
     /** A method's `@Cooldown`s, in declaration order. */ methodCooldowns: 'meocord:method-cooldowns',
     /** The error types a filter's `@Catch` names; empty to catch everything. */ catchTypes: 'meocord:catch-types',
@@ -4555,19 +4941,60 @@ const autocompleteRoute = (method, commandPath, optionName)=>({
     else handlers[index] = entry;
     Reflect.defineMetadata(key, handlers, target);
 }
-/** The class's own command map, started from a copy of the inherited one, for the same reason. */ function ownCommandMap(target) {
+/**
+ * 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);
+    // 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) ?? Object.create(null);
+    for (const [name, metas] of Object.entries(commands)){
+        const kept = metas.filter((meta)=>!inheritedFor(commandsNamed(baseCommands, name), (entry)=>entry.methodName)(meta));
+        if (kept.length > 0) commands[name] = kept;
+        else delete commands[name];
+    }
+    Reflect.defineMetadata(META.commands, commands, prototype);
+    const lists = [
+        [
+            META.messageHandlers,
+            (entry)=>entry.method
+        ],
+        [
+            META.reactionHandlers,
+            (entry)=>entry.method
+        ],
+        [
+            META.autocompleteHandlers,
+            (entry)=>entry.methodName
+        ]
+    ];
+    for (const [key, method] of lists){
+        const inherited = Reflect.getMetadata(key, base) ?? [];
+        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. 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 function(target, propertyKey) {
+    return declaring(function(target, propertyKey) {
         refuseOnClass('@MessageHandler', target, propertyKey);
         // An empty pattern means every message, as no pattern does
         if (pattern === '') {
@@ -4581,7 +5008,7 @@ function MessageHandler(pattern, options = {}) {
         };
         addOwnHandler(META.messageHandlers, target, declared, (other)=>other.method === method && other.pattern === declared.pattern);
         declareRoute(target, messageRoute(method, declared.pattern));
-    };
+    });
 }
 function ReactionHandler(emojiOrSettings, settings = {}) {
     const [emoji, own] = typeof emojiOrSettings === 'object' ? [
@@ -4591,7 +5018,7 @@ function ReactionHandler(emojiOrSettings, settings = {}) {
         emojiOrSettings,
         settings
     ];
-    return function(target, propertyKey) {
+    return declaring(function(target, propertyKey) {
         refuseOnClass('@ReactionHandler', target, propertyKey);
         const method = propertyKey.toString();
         addOwnHandler(META.reactionHandlers, target, {
@@ -4600,7 +5027,7 @@ function ReactionHandler(emojiOrSettings, settings = {}) {
             settings: own
         }, (other)=>other.method === method && other.emoji === emoji);
         declareRoute(target, reactionRoute(method, emoji));
-    };
+    });
 }
 /** A custom emoji as Discord writes it in a message: `<:name:id>`, or `<a:name:id>` for an animated one. */ const CUSTOM_EMOJI = /^<a?:\w+:(\d+)>$/;
 /**
@@ -4629,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 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
@@ -4655,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('')) {
@@ -4672,25 +5118,23 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
     literalLength += trailing.length;
     regexPattern += escapeLiteral(trailing);
     const regex = new RegExp(`^${regexPattern}$`);
-    // Literal text is the signal: a pattern spelling out more of the id describes it
-    // more exactly than one leaving it to a parameter. Fewer parameters breaks a tie
-    // between equal-length patterns, then narrower typed params; the order the controllers
-    // and handlers are listed in settles what is left, and the startup warning names the pair.
+    // What 4.1 ranked by, kept for code that reads CommandMeta.specificity; routing ranks segment by segment
     const specificity = routeSpecificity({
         literals: literalLength,
         params: params.length,
-        typed: Object.values(types).reduce((sum, type)=>sum + narrowness(type), 0)
+        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
     };
 }
-/** How few values a segment type takes, so a narrower type ranks first: words to choose from, then bool, int, number. */ const narrowness = (type)=>choicesOf(type) ? 4 : type === 'bool' ? 3 : type === 'int' ? 2 : 1;
 /** Why a `{name:type}` cannot type a customId segment, which holds text the bot wrote, with no message to read. */ function segmentTypeProblem(param, type) {
-    const kinds = 'string, int, number, bool, or words to choose from such as {mode:on|off}';
+    const kinds = 'string, int, number, bool, snowflake, uuid, or words to choose from such as {mode:on|off}';
     if ([
         'member',
         'user',
@@ -4714,10 +5158,11 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
  * the keys the handler's params require are checked against the pattern or route, a typed segment's value against
  * its type, and a select menu's choices, such as `values: string[]`, against what discord.js gives; a key a pipe
  * produces is declared `Piped<T>`, and left to the pipe. Two component handlers of one type whose patterns match
- * exactly the same ids stop the bot at startup; patterns that only overlap are warned about, naming the one that
- * runs: the more specific, or between equally specific ones, the one listed first. In the next major version (5.0),
- * the one that spells out the first segment where two equally specific patterns differ runs instead, and the warning
- * names the pairs that changes. A context menu handler receives the kind its builder's `setType()` names, and one
+ * exactly the same ids stop the bot at startup. Patterns that both match an id rank segment by segment, left to
+ * right: at the first segment one spells out as literal text and the other leaves to a param, the literal one runs,
+ * so `profile/me/{section}` takes `profile/me/edit` from `profile/{userId}/edit`; between patterns that leaves tied,
+ * the narrower type at the first param where they differ. Two still tied are warned about as the bot starts, and the
+ * one listed first runs. A context menu handler receives the kind its builder's `setType()` names, and one
  * declaring the other kind fails to compile; when the compiler cannot tell the kind, `@Command` checks the parameter
  * type it emits as it applies. A subclass that re-declares an inherited handler on the same name or pattern takes its
  * own builder and options; on another it still answers the inherited one too, which the bot warns about as it
@@ -4750,12 +5195,11 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
  * @category Handlers
  * @see {@link CommandBuilder}
  * @see {@link route}
- * @see {@link https://meocord.dev/docs/4.1/slash-commands | Slash commands}
- * @see {@link https://meocord.dev/docs/4.1/components | Buttons, selects and modals}
+ * @see {@link https://meocord.dev/docs/4.2/slash-commands | Slash commands}
+ * @see {@link https://meocord.dev/docs/4.2/components | Buttons, selects and modals}
  */ function Command(name, builderOrType) {
     const commandName = typeof name === 'string' ? name : name.pattern;
-    return function(target, propertyKey, _descriptor) {
-        var _commands, _commandName;
+    return declaring(function(target, propertyKey, _descriptor) {
         refuseOnClass('@Command', target, propertyKey);
         const originalMethod = _descriptor.value;
         if (!originalMethod) {
@@ -4763,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)}.`);
             }
@@ -4772,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;
@@ -4807,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
                 }));
             }
@@ -4827,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);
@@ -4835,10 +5283,14 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
                     cause: error
                 }));
             }
-            const { regex: generatedRegex, params, specificity: patternSpecificity } = pattern;
-            regex = generatedRegex;
-            dynamicParams = params;
-            specificity = patternSpecificity;
+            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,
@@ -4855,14 +5307,15 @@ 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;
         Reflect.defineMetadata(META.commands, commands, target);
         declareRoute(target, commandRoute(propertyKey, commandType, commandName));
-    };
+    });
 }
 /** The interaction class Discord sends for each context menu kind. */ const CONTEXT_MENU_INTERACTIONS = new Map([
     [
@@ -4934,9 +5387,9 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
  * @group Decorators
  * @category Handlers
  * @see {@link Command}
- * @see {@link https://meocord.dev/docs/4.1/autocomplete | Autocomplete}
+ * @see {@link https://meocord.dev/docs/4.2/autocomplete | Autocomplete}
  */ function Autocomplete(commandPath, optionName) {
-    return function(target, propertyKey, _descriptor) {
+    return declaring(function(target, propertyKey, _descriptor) {
         refuseOnClass('@Autocomplete', target, propertyKey);
         const methodName = propertyKey.toString();
         addOwnHandler(META.autocompleteHandlers, target, {
@@ -4945,7 +5398,7 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
             methodName
         }, (other)=>other.methodName === methodName && other.commandPath === commandPath && other.optionName === optionName);
         declareRoute(target, autocompleteRoute(methodName, commandPath, optionName));
-    };
+    });
 }
 /**
  * Returns a controller's autocomplete handlers, option-specific ones first.
@@ -4967,52 +5420,63 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
     const match = new RegExp(`^${PLACEHOLDER_PATTERN.source}$`).exec(segment);
     return match ? typeKey(match[2]) : undefined;
 }
-/** Whether a segment's two readings can both take one value: a literal, text, or a typed param. */ function segmentsOverlap(left, right) {
+/**
+ * How few values a segment type takes, so a narrower type ranks first: words to choose from, then bool, uuid,
+ * snowflake, int, number, and text last. A snowflake is narrower than a number, which takes all its values.
+ */ const NARROWNESS = lookupTable({
+    bool: 5,
+    uuid: 4,
+    snowflake: 3,
+    int: 2,
+    number: 1,
+    '': 0
+});
+const narrowness = (type)=>choicesOf(type) ? 6 : NARROWNESS[type];
+/**
+ * How narrow a pattern segment that is a param, `{name}` or `{name:type}`, is: from `0` for text to `4` for words to
+ * choose from. `undefined` for a segment of literal text.
+ */ function paramNarrowness(segment) {
+    const type = segmentParamType(segment);
+    return type === undefined ? undefined : narrowness(type);
+}
+/** A value of each scalar segment type: an int, a bool, a snowflake and a uuid; text takes any. */ const SAMPLE_VALUES = [
+    '1',
+    'true',
+    '10000000000000000',
+    '00000000-0000-0000-0000-000000000000'
+];
+/** A value both readings of a segment take: a literal, text, or a typed param; `undefined` when they share none. */ function sharedValue(left, right) {
     const [a, b] = [
         segmentParamType(left),
         segmentParamType(right)
     ];
-    if (a === undefined && b === undefined) return left === right;
-    if (a === undefined || b === undefined) {
-        const [type, literal] = a === undefined ? [
-            b,
+    const takes = (type, segment, value)=>type === undefined ? segment === value : type === '' || parseSegment(type, value) !== undefined;
+    // Every type takes one of these when it takes anything another reading takes: a literal, a listed word, or a value
+    // of each scalar type
+    const candidates = [
+        ...a === undefined ? [
             left
-        ] : [
-            a,
+        ] : [],
+        ...b === undefined ? [
             right
-        ];
-        return type === '' || parseSegment(type, literal) !== undefined;
-    }
-    if (a === '' || b === '' || a === b) return true;
-    // Words to choose from overlap another type when one of them is a value of it
-    const [wordsA, wordsB] = [
-        choicesOf(a),
-        choicesOf(b)
+        ] : [],
+        ...choicesOf(a ?? '') ?? [],
+        ...choicesOf(b ?? '') ?? [],
+        ...SAMPLE_VALUES
     ];
-    if (wordsA) return wordsA.some((word)=>parseSegment(b, word) !== undefined);
-    if (wordsB) return wordsB.some((word)=>parseSegment(a, word) !== undefined);
-    // Of the scalar types, only a whole number and a number share values
-    return a === 'int' && b === 'number' || a === 'number' && b === 'int';
-}
-/**
- * Finds pairs of customId patterns that can both match one id, such as `a/{x}/c` and `a/b/{y}`.
- * @returns Each ambiguous pair once, in the order the patterns were given.
- */ function findAmbiguousRoutes(patterns) {
-    const segmentsOf = (pattern)=>pattern.split(PARAM_SEPARATOR);
-    const collisions = [];
-    for(let i = 0; i < patterns.length; i++){
-        for(let j = i + 1; j < patterns.length; j++){
-            const left = segmentsOf(patterns[i]);
-            const right = segmentsOf(patterns[j]);
-            if (left.length !== right.length) continue;
-            const disjoint = left.some((segment, index)=>!segmentsOverlap(segment, right[index]));
-            if (!disjoint) collisions.push([
-                patterns[i],
-                patterns[j]
-            ]);
-        }
-    }
-    return collisions;
+    return candidates.find((value)=>takes(a, left, value) && takes(b, right, value));
+}
+/**
+ * A customId both patterns match, such as `ticket/1/close` for `ticket/{id}/close` and `ticket/{n:int}/close`;
+ * `undefined` when no id matches both.
+ */ function sharedCustomId(left, right) {
+    const [a, b] = [
+        left.split(PARAM_SEPARATOR),
+        right.split(PARAM_SEPARATOR)
+    ];
+    if (a.length !== b.length) return undefined;
+    const values = a.map((segment, index)=>sharedValue(segment, b[index]));
+    return values.every((value)=>value !== undefined) ? values.join(PARAM_SEPARATOR) : undefined;
 }
 
 exports.Autocomplete = Autocomplete;
@@ -5027,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;
@@ -5036,11 +5501,13 @@ 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;
 exports.UserError = UserError;
 exports.ValidationError = ValidationError;
+exports.allDeclaredErrors = allDeclaredErrors;
 exports.ambientThemeVersion = ambientThemeVersion;
 exports.applyDecorators = applyDecorators;
 exports.assertValidTheme = assertValidTheme;
@@ -5053,6 +5520,8 @@ exports.bundleEntry = bundleEntry;
 exports.callOrder = callOrder;
 exports.choicesOf = choicesOf;
 exports.claimAmbientTheme = claimAmbientTheme;
+exports.collectStartupErrors = collectStartupErrors;
+exports.commandsNamed = commandsNamed;
 exports.compiledConfigMessage = compiledConfigMessage;
 exports.cooldownMessage = cooldownMessage;
 exports.cooldownStoreMessage = cooldownStoreMessage;
@@ -5060,6 +5529,8 @@ exports.cooldownText = cooldownText;
 exports.copyLayer = copyLayer;
 exports.createRegexFromPattern = createRegexFromPattern;
 exports.createTranslator = createTranslator;
+exports.declaredErrorsOf = declaredErrorsOf;
+exports.declaring = declaring;
 exports.decoratedName = decoratedName;
 exports.defaultTheme = defaultTheme;
 exports.defineCatalog = defineCatalog;
@@ -5067,10 +5538,11 @@ exports.deprecatedOnMethod = deprecatedOnMethod;
 exports.describeInteraction = describeInteraction;
 exports.describeRefusal = describeRefusal;
 exports.describeValue = describeValue;
+exports.dropInheritedRoutes = dropInheritedRoutes;
 exports.duration = duration;
 exports.escapeForLog = escapeForLog;
 exports.existingResponse = existingResponse;
-exports.findAmbiguousRoutes = findAmbiguousRoutes;
+exports.fitText = fitText;
 exports.focusedOptionName = focusedOptionName;
 exports.forgetRecorded = forgetRecorded;
 exports.getAutocompleteHandlers = getAutocompleteHandlers;
@@ -5094,8 +5566,10 @@ exports.isRefusal = isRefusal;
 exports.isTooLarge = isTooLarge;
 exports.isUserOutcome = isUserOutcome;
 exports.listed = listed;
+exports.literalBraces = literalBraces;
 exports.loadMeoCordConfig = loadMeoCordConfig;
 exports.logFailedSend = logFailedSend;
+exports.logStartupErrors = logStartupErrors;
 exports.lookup = lookup;
 exports.lookupLayers = lookupLayers;
 exports.lookupTable = lookupTable;
@@ -5109,6 +5583,7 @@ exports.missingTranslatorError = missingTranslatorError;
 exports.number = number;
 exports.ownHandlerList = ownHandlerList;
 exports.ownsAmbientTheme = ownsAmbientTheme;
+exports.paramNarrowness = paramNarrowness;
 exports.parseSegment = parseSegment;
 exports.patternShape = patternShape;
 exports.placeholderNames = placeholderNames;
@@ -5131,9 +5606,16 @@ 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;
 exports.textOfIssue = textOfIssue;
 exports.textRenderer = textRenderer;
 exports.themeForInteraction = themeForInteraction;
@@ -5148,7 +5630,9 @@ exports.useTheme = useTheme;
 exports.userWords = userWords;
 exports.warnDeprecated = warnDeprecated;
 exports.warnDeprecatedBehaviour = warnDeprecatedBehaviour;
+exports.warnOnce = warnOnce;
 exports.warnPlaceholder = warnPlaceholder;
 exports.withRelease = withRelease;
 exports.withSendableFiles = withSendableFiles;
 exports.withoutFiles = withoutFiles;
+exports.wrapsMethod = wrapsMethod;