meocord 4.1.1 → 4.2.0

package/dist/cjs/_shared/{controller.decorator-BywwkU9O.cjs → controller.decorator-CRn9kWob.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.
@@ -119,7 +120,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-CRn9kWob.cjs', document.baseURI).href)));
         const loaded = load(compiledPath);
         return loaded.default ?? loaded;
     } catch (error) {
@@ -352,7 +353,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);
@@ -692,10 +693,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 +707,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
@@ -902,9 +1043,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 +1058,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 +1097,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 +1108,7 @@ const logger$5 = new Logger('SetMetadata');
         } else {
             Reflect.defineMetadata(metadataKey, metadataValue, target);
         }
-    };
+    });
 }
 
 /**
@@ -1456,7 +1597,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 +1670,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
@@ -3700,7 +3841,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,
@@ -4399,10 +4540,10 @@ 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.
+ * 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 +4584,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 +4634,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,6 +4709,42 @@ const autocompleteRoute = (method, commandPath, optionName)=>({
     else handlers[index] = entry;
     Reflect.defineMetadata(key, handlers, 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) ?? {};
+    for (const [name, metas] of Object.entries(commands)){
+        const kept = metas.filter((meta)=>!inheritedFor(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. */ function ownCommandMap(target) {
     const own = Reflect.getOwnMetadata(META.commands, target);
     if (own) return own;
@@ -4567,7 +4757,7 @@ const autocompleteRoute = (method, commandPath, optionName)=>({
         ]));
 }
 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 +4771,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 +4781,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 +4790,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+)>$/;
 /**
@@ -4632,7 +4822,7 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
 /** The character a parameter will not cross, so one pattern segment maps to one value. */ const PARAM_SEPARATOR = '/';
 /** 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
+ * 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.
  */ function createRegexFromPattern(pattern) {
@@ -4672,14 +4862,11 @@ 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)
     });
     return {
         regex,
@@ -4688,9 +4875,8 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
         specificity
     };
 }
-/** 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 +4900,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,11 +4937,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) {
+    return declaring(function(target, propertyKey, _descriptor) {
         var _commands, _commandName;
         refuseOnClass('@Command', target, propertyKey);
         const originalMethod = _descriptor.value;
@@ -4835,10 +5022,9 @@ 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;
         }
         const declared = {
             methodName: propertyKey,
@@ -4862,7 +5048,7 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
         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 +5120,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 +5131,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 +5153,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';
+    return candidates.find((value)=>takes(a, left, value) && takes(b, right, value));
 }
 /**
- * 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;
+ * 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;
@@ -5041,6 +5238,7 @@ 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 +5251,7 @@ exports.bundleEntry = bundleEntry;
 exports.callOrder = callOrder;
 exports.choicesOf = choicesOf;
 exports.claimAmbientTheme = claimAmbientTheme;
+exports.collectStartupErrors = collectStartupErrors;
 exports.compiledConfigMessage = compiledConfigMessage;
 exports.cooldownMessage = cooldownMessage;
 exports.cooldownStoreMessage = cooldownStoreMessage;
@@ -5060,6 +5259,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 +5268,10 @@ 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.focusedOptionName = focusedOptionName;
 exports.forgetRecorded = forgetRecorded;
 exports.getAutocompleteHandlers = getAutocompleteHandlers;
@@ -5096,6 +5297,7 @@ exports.isUserOutcome = isUserOutcome;
 exports.listed = listed;
 exports.loadMeoCordConfig = loadMeoCordConfig;
 exports.logFailedSend = logFailedSend;
+exports.logStartupErrors = logStartupErrors;
 exports.lookup = lookup;
 exports.lookupLayers = lookupLayers;
 exports.lookupTable = lookupTable;
@@ -5109,6 +5311,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;
@@ -5132,8 +5335,12 @@ exports.runInThemeScope = runInThemeScope;
 exports.runWithTheme = runWithTheme;
 exports.setLegacyThemeLayer = setLegacyThemeLayer;
 exports.setPresenter = setPresenter;
+exports.setStartupErrorsMode = setStartupErrorsMode;
 exports.setThemeOutsideCalls = setThemeOutsideCalls;
+exports.sharedCustomId = sharedCustomId;
 exports.stampCall = stampCall;
+exports.startupError = startupError;
+exports.stopOnStartupErrors = stopOnStartupErrors;
 exports.textOfIssue = textOfIssue;
 exports.textRenderer = textRenderer;
 exports.themeForInteraction = themeForInteraction;
@@ -5148,6 +5355,7 @@ exports.useTheme = useTheme;
 exports.userWords = userWords;
 exports.warnDeprecated = warnDeprecated;
 exports.warnDeprecatedBehaviour = warnDeprecatedBehaviour;
+exports.warnOnce = warnOnce;
 exports.warnPlaceholder = warnPlaceholder;
 exports.withRelease = withRelease;
 exports.withSendableFiles = withSendableFiles;