meocord 4.1.1 → 4.2.0

package/dist/cjs/_shared/{startup-roots-lFc69AxC.cjs → startup-roots-CQo8mSP8.cjs}

@@ -1,13 +1,39 @@
 'use strict';
 
 var discord_js = require('discord.js');
-var controller_decorator = require('./controller.decorator-BywwkU9O.cjs');
-var providers = require('./providers-BMMLp2SN.cjs');
+var controller_decorator = require('./controller.decorator-CRn9kWob.cjs');
+var providers = require('./providers-ChvMqnLd.cjs');
 var enum_index = require('../enum/index.cjs');
-var translateError = require('./translate-error-BnM8FbSH.cjs');
+var translateError = require('./translate-error-DhDVbT5M.cjs');
 
 /**
- * Every customId-pattern route of the given controllers, most specific first, read from metadata alone.
+ * How a pattern ranks, one character per segment twice over: `L` for literal text or `P` for a param, then how narrow
+ * each param is, the narrowest as the lowest digit. Two keys of one length compare as text: literal before param at
+ * the first segment where they differ, then the narrower type.
+ */ function rankKey(pattern) {
+    const narrowness = pattern.split('/').map(controller_decorator.paramNarrowness);
+    const kinds = narrowness.map((rank)=>rank === undefined ? 'L' : 'P').join('');
+    return `${kinds}/${narrowness.map((rank)=>String(rank === undefined ? 0 : 9 - rank)).join('')}`;
+}
+/**
+ * Orders two routes as dispatch tries them. Left to right, the first segment one pattern spells out as literal text
+ * while the other leaves it to a param ranks the literal one first: `a/{x}` before `{x}/abcd`, `profile/me/{section}`
+ * before `profile/{userId}/edit`. Between patterns that leaves tied, the first param where one type is narrower ranks
+ * it first: words to choose from, then `bool`, `uuid`, `snowflake`, `int`, `number`, then text. Patterns of different
+ * segment counts, which no customId matches both of, are ordered by count only so the order is total; component
+ * patterns have no catch-all param. What remains tied keeps its listing order.
+ */ function rank(keys) {
+    return (a, b)=>{
+        const [left, right] = [
+            keys.get(a),
+            keys.get(b)
+        ];
+        if (left.length !== right.length) return left.length - right.length;
+        return left < right ? -1 : left > right ? 1 : 0;
+    };
+}
+/**
+ * Every customId-pattern route of the given controllers, in the order dispatch tries them, read from metadata alone.
  * Throws for two handlers whose patterns match the same customIds of one component type; one handler
  * declared under two spellings of a pattern keeps one route.
  */ function buildComponentRoutes(controllerClasses) {
@@ -40,22 +66,11 @@ var translateError = require('./translate-error-BnM8FbSH.cjs');
             }
         }
     }
-    // A stable sort, so equally specific patterns keep the order their controllers and handlers are listed in
-    return routes.sort((a, b)=>(b.meta.specificity ?? 0) - (a.meta.specificity ?? 0));
-}
-/**
- * Whether `a` spells out the first segment where it and `b` differ as literal text while `b` leaves it to a
- * parameter, the tie-break between equally specific patterns in the next major version (5.0).
- */ function literalFirst(a, b) {
-    const [left, right] = [
-        a.split('/'),
-        b.split('/')
-    ];
-    for(let i = 0; i < Math.min(left.length, right.length); i++){
-        const leftLiteral = !left[i].includes('{');
-        if (leftLiteral !== !right[i].includes('{')) return leftLiteral;
-    }
-    return false;
+    // A stable sort, so what the ranking leaves tied keeps the order controllers and handlers are listed in
+    return routes.sort(rank(new Map(routes.map((route)=>[
+            route,
+            rankKey(route.pattern)
+        ]))));
 }
 /** A component type as an error names it: `button`, `modal submit`, `select menu`. */ const typeLabel = (type)=>type.toLowerCase().replaceAll('_', ' ');
 /**
@@ -80,6 +95,12 @@ const typesByPattern = new Map();
     if (!types) typesByPattern.set(pattern, types = controller_decorator.createRegexFromPattern(pattern).types);
     return types;
 }
+/**
+ * The params `pattern`, compiled as `regex`, captures from a customId, each typed param as its value:
+ * `undefined` when the customId does not match, or a segment is not a value of its param's type.
+ */ function readCustomId(pattern, regex, customId) {
+    return readCustomIdSegments(pattern, regex, customId)?.values;
+}
 /** {@link readCustomId}'s values, with each param's text as the customId gave it. */ function readCustomIdSegments(pattern, regex, customId) {
     const match = regex.exec(customId);
     if (!match) return undefined;
@@ -97,18 +118,40 @@ const typesByPattern = new Map();
         text
     };
 }
-/** Pattern pairs that can match one customId, compared only within a component type, as dispatch does. */ function findComponentRouteConflicts(routes) {
-    const byType = new Map();
-    for (const { meta, pattern } of routes)byType.set(meta.type, [
-        ...byType.get(meta.type) ?? [],
-        pattern
-    ]);
-    return [
-        ...byType
-    ].flatMap(([type, patterns])=>controller_decorator.findAmbiguousRoutes(patterns).map((pair)=>({
-                type,
-                patterns: pair
-            })));
+/**
+ * Pattern pairs of one component type that the ranking leaves tied and that can match one customId, each with the
+ * pattern that runs, the one ranked first in `routes`, and an id both match. Only patterns of one rank key, read
+ * together, can tie, so each group is compared within itself.
+ */ function findComponentRouteConflicts(routes) {
+    const groups = new Map();
+    for (const route of routes){
+        // The literal text and each param's narrowness: patterns that differ in either rank apart or match no id in common
+        const key = `${route.meta.type}\0${route.pattern.split('/').map((segment)=>controller_decorator.paramNarrowness(segment) ?? `=${segment}`).join('\0')}`;
+        groups.set(key, [
+            ...groups.get(key) ?? [],
+            route
+        ]);
+    }
+    const conflicts = [];
+    for (const group of groups.values()){
+        for(let i = 0; i < group.length; i++){
+            for(let j = i + 1; j < group.length; j++){
+                const customId = controller_decorator.sharedCustomId(group[i].pattern, group[j].pattern);
+                if (customId === undefined) continue;
+                const patterns = [
+                    group[i].pattern,
+                    group[j].pattern
+                ];
+                conflicts.push({
+                    type: group[i].meta.type,
+                    patterns,
+                    runs: group[i].pattern,
+                    customId
+                });
+            }
+        }
+    }
+    return conflicts;
 }
 
 const where = ({ controllerClass, meta })=>`${controllerClass.name}.${meta.methodName}`;
@@ -131,7 +174,7 @@ const where = ({ controllerClass, meta })=>`${controllerClass.name}.${meta.metho
  * Refuses commands of which only one could run or be registered: two handlers of one slash command name or subcommand
  * path or of one context menu name and kind, or two builders of one command; a command's subcommands, and a user and a
  * message context menu of one name, are no clash. The app, `meocord register`, the shard manager and testing call it.
- * @throws Error naming both handlers, or both builders, with what to do instead.
+ * Each clash is a startup error, naming both handlers or both builders with what to do instead; see `startupError`.
  */ function assertDistinctCommands(controllerClasses) {
     const handlers = new Map();
     const builders = new Map();
@@ -149,7 +192,8 @@ const where = ({ controllerClass, meta })=>`${controllerClass.name}.${meta.metho
                 const key = `${meta.type}\0${name}`;
                 const earlier = (handlers.get(key) ?? []).find((other)=>overlap(other.meta, meta));
                 if (earlier) {
-                    throw controller_decorator.refuse(new Error(`${where(earlier)}: it and ${where(here)} both handle the ${describe(meta.type, name, contextMenuKind(meta) ?? contextMenuKind(earlier.meta))}, ` + `so only ${where(earlier)} would ever run. Keep one handler for it, or give the other a name or ` + `subcommand path of its own.`));
+                    controller_decorator.startupError(new Error(`${where(earlier)}: it and ${where(here)} both handle the ${describe(meta.type, name, contextMenuKind(meta) ?? contextMenuKind(earlier.meta))}, ` + `so only ${where(earlier)} would ever run. Keep one handler for it, or give the other a name or ` + `subcommand path of its own.`));
+                    continue;
                 }
                 handlers.set(key, [
                     ...handlers.get(key) ?? [],
@@ -170,7 +214,7 @@ const where = ({ controllerClass, meta })=>`${controllerClass.name}.${meta.metho
                         name: typeof body.name === 'string' ? body.name : name
                     });
                 } else if (built.meta.builderClass !== meta.builderClass) {
-                    throw controller_decorator.refuse(new Error(`${where(built)}: its builder ${built.meta.builderClass.name} and ${meta.builderClass.name} on ${where(here)} both ` + `build the ${describe(meta.type, built.name, contextMenuKind(meta))}, and Discord registers one command ` + `per name and type, so only the first would be. Keep one builder, on a single @Command, and declare ` + `the other handlers with CommandType.${meta.type}.`));
+                    controller_decorator.startupError(new Error(`${where(built)}: its builder ${built.meta.builderClass.name} and ${meta.builderClass.name} on ${where(here)} both ` + `build the ${describe(meta.type, built.name, contextMenuKind(meta))}, and Discord registers one command ` + `per name and type, so only the first would be. Keep one builder, on a single @Command, and declare ` + `the other handlers with CommandType.${meta.type}.`));
                 }
             }
         }
@@ -348,18 +392,21 @@ const quoted = (names)=>names.length < 2 ? names.map((name)=>`"${name}"`).join('
 /**
  * Warns about a handler a subclass re-declares on other routes while it still answers the ones it inherits, for
  * `@Command`, `@MessageHandler`, `@ReactionHandler` and `@Autocomplete` alike. The next major version (5.0) drops
- * the inherited routes. Every class a listed controller extends is checked once, a base that is not listed included.
+ * the inherited routes. Every class a listed controller extends is checked, a base that is not listed included, for
+ * the methods the controller still inherits through it.
  */ function warnInheritedRoutes(controllerClasses) {
-    const checked = new Set();
-    const problems = [];
+    // A set, so a class two listed controllers extend is named once, for the routes either of them still answers
+    const problems = new Set();
     for (const controllerClass of controllerClasses){
+        // Methods a class below re-declares with @Controller({ inheritedRoutes: 'replace' }): the listed controller inherits
+        // nothing of them from above it, so a class above is not named for them
+        const cut = new Set();
         for(let prototype = controllerClass.prototype; prototype && prototype !== Object.prototype; prototype = Object.getPrototypeOf(prototype)){
-            if (checked.has(prototype)) break;
-            checked.add(prototype);
             const declared = controller_decorator.getDeclaredRoutes(prototype);
             const base = Object.getPrototypeOf(prototype);
             if (declared.length === 0 || !base) continue;
-            const inherited = controller_decorator.getHandlerRoutes(base);
+            if (Reflect.getOwnMetadata(controller_decorator.META.replacesInheritedRoutes, prototype)) for (const route of declared)cut.add(route.method);
+            const inherited = controller_decorator.getHandlerRoutes(base).filter((route)=>!cut.has(route.method));
             for (const method of new Set(declared.map((route)=>route.method))){
                 const own = [
                     ...new Set(declared.filter((route)=>route.method === method).map((route)=>route.label))
@@ -369,17 +416,19 @@ const quoted = (names)=>names.length < 2 ? names.map((name)=>`"${name}"`).join('
                 ].filter((label)=>!own.includes(label));
                 if (kept.length === 0) continue;
                 const name = prototype.constructor.name;
-                problems.push(`  ${name}.${method} answers ${controller_decorator.listed(kept)}, which it inherits, as well as its own ${controller_decorator.listed(own)}.`);
+                problems.add(`  ${name}.${method} answers ${controller_decorator.listed(kept)}, which it inherits, as well as its own ${controller_decorator.listed(own)}.`);
             }
         }
     }
-    if (problems.length === 0) return;
-    const one = problems.length === 1;
-    logger.warn(`${problems.length} re-declared ${one ? 'handler still answers routes it inherits' : 'handlers still answer routes they inherit'}:\n` + `${problems.join('\n')}\nIn the next major version (5.0), a handler's own routes replace the ones it inherits. ` + "To keep an inherited route, declare it on the subclass's method as well.");
+    if (problems.size === 0) return;
+    const one = problems.size === 1;
+    logger.warn(`${problems.size} re-declared ${one ? 'handler still answers routes it inherits' : 'handlers still answer routes they inherit'}:\n` + `${[
+        ...problems
+    ].join('\n')}\nIn the next major version (5.0), a handler's own routes replace the ones it inherits. ` + "To keep an inherited route, declare it on the subclass's method as well; to drop it now, give the subclass " + "@Controller({ inheritedRoutes: 'replace' }).");
 }
 /**
- * Warns of customId patterns of one component type that can match one customId, naming the handler that runs and why;
- * an app whose patterns overlap works, so refusing to start would turn a latent mis-route into an outage.
+ * Warns of customId patterns of one component type that rank equally and can match one customId, naming an id both
+ * match and the handler that runs. An app with such a pair works, so it starts; the next major version (5.0) refuses.
  * @throws Error for two handlers whose patterns match the same customIds, which the app refuses as well.
  */ function warnOverlappingPatterns(controllerClasses) {
     const routes = buildComponentRoutes(controllerClasses);
@@ -389,23 +438,16 @@ const quoted = (names)=>names.length < 2 ? names.map((name)=>`"${name}"`).join('
             `${route.meta.type}\0${route.pattern}`,
             route
         ]));
-    const lines = conflicts.map(({ type, patterns: [left, right] })=>{
-        const outcome = ambiguityOutcome(routeOf.get(`${type}\0${left}`), routeOf.get(`${type}\0${right}`));
-        return `  "${left}"  vs  "${right}": ${outcome}`;
-    });
-    logger.warn(`${conflicts.length} pattern pair(s) can match the same customId, so which one runs is decided by ranking rather ` + `than by the ids themselves:\n${lines.join('\n')}`);
-}
-/**
- * Which of two overlapping routes runs for the ids both match, and why: `runs` ranks first. Between equally
- * specific patterns, the order they are listed in decides until 5.0, which prefers the earlier literal segment.
- */ function ambiguityOutcome(runs, other) {
     const name = ({ controllerClass, meta })=>`${controllerClass.name}.${meta.methodName}`;
-    if ((runs.meta.specificity ?? 0) !== (other.meta.specificity ?? 0)) return `${name(runs)} runs, as its pattern is more specific.`;
-    const together = runs.controllerClass === other.controllerClass;
-    const listed = together ? 'it is declared first' : 'its controller is listed first';
-    if (!literalFirst(other.pattern, runs.pattern)) return `${name(runs)} runs, as ${listed}.`;
-    const reorder = together ? `Declare ${name(other)} first` : `List ${other.controllerClass.name} first`;
-    return `${name(runs)} runs, as ${listed}. In the next major version (5.0), ${name(other)} runs instead, as ` + `"${other.pattern}" spells out the first segment where the two differ. ${reorder}, or make the patterns distinct.`;
+    const lines = conflicts.map(({ type, patterns: [left, right], customId })=>{
+        const [runs, other] = [
+            routeOf.get(`${type}\0${left}`),
+            routeOf.get(`${type}\0${right}`)
+        ];
+        const listed = runs.controllerClass === other.controllerClass ? 'it is declared first' : 'its controller is listed first';
+        return `  "${left}"  vs  "${right}", which both match "${customId}": ${name(runs)} runs, as ${listed}.`;
+    });
+    logger.warn(`${conflicts.length} pattern pair(s) rank equally and can match the same customId, so the order they are listed in ` + `decides which one runs:\n${lines.join('\n')}\nMake the patterns distinct: in the next major version (5.0), ` + 'MeoCord refuses to start with such a pair.');
 }
 
 const UNKNOWN_INTERACTION = 10062;
@@ -1100,6 +1142,7 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
     if (state && state !== 'unanswered') return true;
     return 'replied' in interaction && (interaction.replied || interaction.deferred);
 }
+/** How long a message's handler may take, with others waiting after it, before it is named as slow. */ const SLOW_HANDLER_MS = 5000;
 /**
  * Routes interactions, messages and reactions to the handlers that take them, as the bot does, and runs
  * each through its pipeline. The app and the testing module share it, so a test routes exactly as the bot.
@@ -1355,22 +1398,64 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
                 message
             ], error, this.runOptions(call));
         }
+        // The matched handler, then every listener, each resolved from the container only as it starts
+        const runs = [];
         if (target) {
             const { route, params, start, given } = target;
             noteInvocation(message, `${start}${providers.commandWordsOf(route.tokens).join(' ')}`);
             const hooks = providers.messageCommandHooks(route, params, message, start, given, this.messageOptions.types);
-            await this.invokeHandler(this.getInstance(route.controllerClass), route.method, [
-                message,
-                params
-            ], call, hooks);
+            runs.push({
+                name: `${route.controllerClass.name}.${route.method}`,
+                run: (at)=>this.invokeHandler(this.getInstance(route.controllerClass), route.method, [
+                        message,
+                        params
+                    ], at, hooks)
+            });
         }
         for (const { controllerClass, method } of this.messageListeners){
-            await this.invokeHandler(this.getInstance(controllerClass), method, [
-                message
-            ], call);
+            runs.push({
+                name: `${controllerClass.name}.${method}`,
+                run: (at)=>this.invokeHandler(this.getInstance(controllerClass), method, [
+                        message
+                    ], at)
+            });
+        }
+        if (this.messageOptions.handlers === 'concurrent') await this.runTogether(runs, call);
+        else await this.runInTurn(runs, call);
+    }
+    /** Runs a message's handlers one after another, warning once about one that held the rest back for long. */ async runInTurn(runs, call) {
+        const warn = this.messageOptions.slowHandlerWarning ?? this.options.warnSlowMessageHandlers ?? true;
+        for (const [index, { name, run }] of runs.entries()){
+            const started = performance.now();
+            await run(call);
+            const waiting = runs.length - 1 - index;
+            if (warn && waiting > 0) this.warnSlowOnce(name, performance.now() - started, waiting);
         }
     }
     /**
+   * Starts a message's handlers together and settles once all have. Each is reported as settled in the order the
+   * handlers are listed, whichever settles first, and a call that rejects, rejects this once every one has settled.
+   */ async runTogether(runs, call) {
+        const { record } = call;
+        const reports = runs.map(()=>[]);
+        const results = await Promise.allSettled(runs.map(({ run }, index)=>run(record ? {
+                ...call,
+                record: {
+                    settled: (...report)=>reports[index].push(report),
+                    unhandled: (error)=>record.unhandled(error)
+                }
+            } : call)));
+        for (const report of reports.flat())record?.settled(...report);
+        const failed = results.find((result)=>result.status === 'rejected');
+        if (failed) throw failed.reason;
+    }
+    /** Warns, once per handler, that it took `SLOW_HANDLER_MS` or longer with `waiting` handlers held back behind it. */ warnSlowOnce(name, took, waiting) {
+        if (took < SLOW_HANDLER_MS || this.warnedSlow.has(name)) return;
+        this.warnedSlow.add(name);
+        const held = waiting === 1 ? 'the listener after it' : `the ${waiting} listeners after it`;
+        this.logger.warn(`${name} took ${(took / 1000).toFixed(1)} s on a message, and held back ${held}. ` + "@MeoCord({ messages: { handlers: 'concurrent' } }) runs them side by side; messages: { slowHandlerWarning: false } turns this off.");
+    }
+    /**
    * Answers a message that asks the built-in help, when `messages.help` is on and no handler took the message:
    * through the presenter's `messageHelp` when it has one, else in plain text, once the app's guards allow it.
    * `known` is the message's starts when they hold the app's prefixes already. Whether it answered, or a
@@ -1491,6 +1576,7 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
         this.controllerInstancesCache = new Map();
         /** Handler and name pairs already warned about, so a collision warns once, not on every submit or selection. */ this.warnedCollisions = new Set();
         /** The handlers already warned about, so each is named once however often it runs. */ this.warnedUnanswered = new Set();
+        /** The message handlers already warned about as slow, so each is named once. */ this.warnedSlow = new Set();
         this.container = options.container;
         this.controllerClasses = options.controllerClasses;
         this.messageOptions = options.messageOptions ?? {};
@@ -1600,8 +1686,7 @@ async function replyToMessage(message, error, logger, withEmoji, answering) {
 /** Runs the startup checks over every class an app runs, so a class that cannot be made is refused by name now. */ function assertStartupClasses({ classes, decorators }, { translator }) {
     providers.assertTypedParameters(classes, decorators);
     if (translator) return;
-    const needsOne = classes.find((cls)=>providers.injectedTokens(cls).includes(controller_decorator.Translator));
-    if (needsOne) throw controller_decorator.refuse(controller_decorator.missingTranslatorError(needsOne));
+    for (const needsOne of classes.filter((cls)=>providers.injectedTokens(cls).includes(controller_decorator.Translator)))controller_decorator.startupError(controller_decorator.missingTranslatorError(needsOne));
 }
 
 exports.DEFAULT_SHUTDOWN_TIMEOUT_MS = DEFAULT_SHUTDOWN_TIMEOUT_MS;
@@ -1622,6 +1707,7 @@ exports.matchComponentRoute = matchComponentRoute;
 exports.messageDecorator = messageDecorator;
 exports.ownInteractionListener = ownInteractionListener;
 exports.reactionDecorator = reactionDecorator;
+exports.readCustomId = readCustomId;
 exports.replyWithUserError = replyWithUserError;
 exports.runReadyHooks = runReadyHooks;
 exports.runShutdownSequence = runShutdownSequence;

package/dist/cjs/_shared/{translate-error-BnM8FbSH.cjs → translate-error-DhDVbT5M.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var controller_decorator = require('./controller.decorator-BywwkU9O.cjs');
+var controller_decorator = require('./controller.decorator-CRn9kWob.cjs');
 var discord_js = require('discord.js');
 
 /** The longest customId Discord accepts. */ const MAX_CUSTOM_ID_LENGTH = 100;
@@ -16,6 +16,10 @@ const PLACEHOLDER = /\{(\w+)(?::([^}/]*))?}/g;
             decodeSegment(value)
         ]));
 }
+/** The segment types whose value is text, which `build` takes only as a string. */ const TEXT_TYPES = new Set([
+    'snowflake',
+    'uuid'
+]);
 /**
  * Makes a typed route from a customId pattern, so one declaration serves the handler and the ids that reach it.
  *
@@ -50,7 +54,7 @@ const PLACEHOLDER = /\{(\w+)(?::([^}/]*))?}/g;
  *
  * @group Utilities
  * @see {@link Route}
- * @see {@link https://meocord.dev/docs/4.1/components | Buttons, selects and modals}
+ * @see {@link https://meocord.dev/docs/4.2/components | Buttons, selects and modals}
  */ function route(pattern) {
     const { params, types } = controller_decorator.createRegexFromPattern(pattern);
     const names = new Set(params);
@@ -62,6 +66,11 @@ const PLACEHOLDER = /\{(\w+)(?::([^}/]*))?}/g;
             const value = Object.hasOwn(values, name) ? values[name] : undefined;
             const type = Object.hasOwn(types, name) ? types[name] : undefined;
             if (value === undefined || value === null) throw new TypeError(`route('${pattern}').build() needs a value for ${placeholder}.`);
+            // A snowflake's or uuid's value is its text: a number for a snowflake may have lost digits before it got here
+            if (type && TEXT_TYPES.has(type) && typeof value !== 'string') {
+                const lost = type === 'snowflake' ? ' A number may have lost digits already: pass the ID as text, such as user.id.' : '';
+                throw new TypeError(`route('${pattern}').build() got the ${typeof value} ${String(value)} for ${placeholder}, which takes its value as a string.${lost}`);
+            }
             const text = String(value);
             if (text === '') throw new TypeError(`route('${pattern}').build() got an empty {${name}}, which no customId segment can hold.`);
             // A typed segment must read back as the value it was built from, or the route could never match it
@@ -139,7 +148,7 @@ const PLACEHOLDER = /\{(\w+)(?::([^}/]*))?}/g;
  * @group Utilities
  * @category Localisation
  * @see {@link createTranslator}
- * @see {@link https://meocord.dev/docs/4.1/localisation | Localisation}
+ * @see {@link https://meocord.dev/docs/4.2/localisation | Localisation}
  */ function translateError(error, t, target) {
     const locale = target instanceof discord_js.BaseInteraction ? controller_decorator.interactionLocale(target) : target instanceof discord_js.Message ? controller_decorator.messageLocale(target) : target;
     return errorText(error, t, locale);

package/dist/cjs/common/index.cjs

@@ -1,9 +1,9 @@
 'use strict';
 
-var controller_decorator = require('../_shared/controller.decorator-BywwkU9O.cjs');
+var controller_decorator = require('../_shared/controller.decorator-CRn9kWob.cjs');
 require('reflect-metadata');
-var translateError = require('../_shared/translate-error-BnM8FbSH.cjs');
-var shardedCooldownStore = require('../_shared/sharded-cooldown-store-B65iaiAy.cjs');
+var translateError = require('../_shared/translate-error-DhDVbT5M.cjs');
+var shardedCooldownStore = require('../_shared/sharded-cooldown-store-BdAUTdYs.cjs');
 require('../enum/index.cjs');
 require('discord.js');
 require('path');
@@ -150,7 +150,7 @@ const assigned = {};
  *
  * @group Utilities
  * @see {@link ExecutionContext}
- * @see {@link https://meocord.dev/docs/4.1/guards | Guards}
+ * @see {@link https://meocord.dev/docs/4.2/guards | Guards}
  */ function createMetadata(description) {
     const key = Symbol(description);
     const decorator = (value)=>function(target, propertyKey) {