meocord 4.2.1 → 4.2.3

package/dist/esm/core/theme-scope.js

@@ -64,50 +64,50 @@ const merges = new WeakMap();
     if (!merged) byLayer.set(layer, merged = deepFreeze(mergeInto(theme, layer)));
     return merged;
 }
-// Written by the deprecated `Theme` statics: beneath every theme an app sets
-let legacyLayer;
-let legacyVersion = 0;
-let defaults = DEFAULT_THEME;
+/**
+ * The theme state outside a call, one for both builds of this version so either reads what the other set: the defaults
+ * with what the deprecated `Theme` statics set beneath every theme, the app whose theme is read outside a call, and how
+ * an answer outside a call finds its theme.
+ */ const state = shared('themeState', ()=>({
+        defaults: DEFAULT_THEME,
+        legacyVersion: 0,
+        ambient: undefined,
+        ambientVersion: 0,
+        themeOutsideCalls: undefined
+    }));
 /** MeoCord's defaults, with what the deprecated `Theme` statics set over them. */ function defaultTheme() {
-    return defaults;
+    return state.defaults;
 }
 /** The number of times the legacy layer has changed, so a theme built on an older one is built again. */ function themeLayersVersion() {
-    return legacyVersion;
+    return state.legacyVersion;
 }
 /** Sets the layer the deprecated `Theme` statics write, merged over MeoCord's defaults. */ function setLegacyThemeLayer(layer) {
-    legacyLayer = layer === undefined ? undefined : copyLayer(layer);
-    defaults = mergeTheme(DEFAULT_THEME, legacyLayer);
-    legacyVersion++;
+    state.defaults = mergeTheme(DEFAULT_THEME, layer === undefined ? undefined : copyLayer(layer));
+    state.legacyVersion++;
 }
-// The theme outside any call: the one of the app or testing module that claimed it, until it gives it up
-let ambient;
-let ambientVersion = 0;
 /** The number of times the app read outside a call has changed, so each app decides again whether its calls need a scope. */ function ambientThemeVersion() {
-    return ambientVersion;
-}
-/** Whether some app's theme is the one read outside a call. */ function hasAmbientTheme() {
-    return ambient !== undefined;
+    return state.ambientVersion;
 }
 /**
  * Makes an app's theme the one read outside a call, when no other app has: a bot runs one app, and code it runs
  * outside a handler, such as a scheduled job, then reads that app's theme. A second app in the same process keeps
  * its theme to its own calls.
  */ function claimAmbientTheme(owner, theme) {
-    if (ambient && ambient.owner !== owner) return false;
-    if (!ambient) ambientVersion++;
-    ambient = {
+    if (state.ambient && state.ambient.owner !== owner) return false;
+    if (!state.ambient) state.ambientVersion++;
+    state.ambient = {
         owner,
         theme
     };
     return true;
 }
 /** Gives up the theme read outside a call, when `owner` has it: its start failed, or it has shut down. */ function releaseAmbientTheme(owner) {
-    if (ambient?.owner !== owner) return;
-    ambient = undefined;
-    ambientVersion++;
+    if (state.ambient?.owner !== owner) return;
+    state.ambient = undefined;
+    state.ambientVersion++;
 }
 /** Whether `owner` is the app whose theme is read outside a call. */ function ownsAmbientTheme(owner) {
-    return ambient?.owner === owner;
+    return state.ambient?.owner === owner;
 }
 /** Runs `fn` with `theme` as the theme of the call, for everything it runs, awaits or starts. */ function runWithTheme(theme, fn) {
     return scope.run({
@@ -123,10 +123,8 @@ let ambientVersion = 0;
 /** Runs `fn` in `themeScope`, whose theme may be replaced while it runs, as a per-server theme is found. */ function runInThemeScope(themeScope, fn) {
     return scope.run(themeScope, fn);
 }
-// Set by the runtime: the theme an app gives an interaction answered outside any call, as in a collector
-let themeOutsideCalls;
 /** Sets how an answer outside any call finds its theme: from the interaction's app, server and user. */ function setThemeOutsideCalls(resolve) {
-    themeOutsideCalls = resolve;
+    state.themeOutsideCalls = resolve;
 }
 /**
  * The theme an answer to `interaction` uses: the running call's, or, outside any call, as in a collector's callback,
@@ -134,7 +132,7 @@ let themeOutsideCalls;
  */ function themeForInteraction(interaction) {
     const call = scope.getStore();
     if (call) return call.theme;
-    return themeOutsideCalls?.(interaction) ?? useTheme();
+    return state.themeOutsideCalls?.(interaction) ?? useTheme();
 }
 /**
  * The theme of the running call, with every role present.
@@ -163,7 +161,7 @@ let themeOutsideCalls;
  *
  * @group Responses
  */ function useTheme() {
-    return scope.getStore()?.theme ?? ambient?.theme() ?? defaults;
+    return scope.getStore()?.theme ?? state.ambient?.theme() ?? state.defaults;
 }
 /**
  * Makes a function run in the theme of the call that binds it, wherever it is called from later.
@@ -172,6 +170,9 @@ let themeOutsideCalls;
  * Such a listener runs in its emitter's context, so without it a `useTheme()` inside reads the theme outside any call.
  * Timers and promises the handler starts keep its theme without it.
  *
+ * The theme is the binding call's whole theme, its server's and user's themes included, so every later call, whoever
+ * it is for, is answered in the starting member's theme.
+ *
  * @param fn - The function to run in the call's theme; `this` and its arguments are passed through.
  * @returns A function that runs `fn` in the theme `useTheme()` returns where `bindTheme` is called.
  *
@@ -181,7 +182,7 @@ let themeOutsideCalls;
  * async poll(message: Message) {
  *   const collector = message.createMessageComponentCollector({ componentType: ComponentType.Button, time: 60_000 })
  *   collector.on('collect', bindTheme(async (click: ButtonInteraction) => {
- *     const { emojis } = useTheme() // the handler's theme, @UseTheme included
+ *     const { emojis } = useTheme() // the starting member's theme, @UseTheme included
  *     await click.reply(`${emojis.success} Picked`)
  *   }))
  * }
@@ -195,4 +196,4 @@ let themeOutsideCalls;
     };
 }
 
-export { ambientThemeVersion, bindTheme, claimAmbientTheme, copyLayer, defaultTheme, hasAmbientTheme, mergeTheme, outsideThemeScope, ownsAmbientTheme, releaseAmbientTheme, runInThemeScope, runWithTheme, setLegacyThemeLayer, setThemeOutsideCalls, themeForInteraction, themeLayersVersion, useTheme };
+export { ambientThemeVersion, bindTheme, claimAmbientTheme, copyLayer, defaultTheme, mergeTheme, outsideThemeScope, ownsAmbientTheme, releaseAmbientTheme, runInThemeScope, runWithTheme, setLegacyThemeLayer, setThemeOutsideCalls, themeForInteraction, themeLayersVersion, useTheme };

package/dist/esm/core/theme-validation.js

@@ -51,7 +51,7 @@ const describeGroup = (value, quote = asWritten)=>Array.isArray(value) ? 'an arr
     const prototype = Object.getPrototypeOf(value);
     return prototype === Object.prototype || prototype === null;
 };
-const PLAIN = "give a plain object, such as { ...value }, or a row's toObject(), since anything else would replace the whole";
+const PLAIN = "give a plain object: a database row's plain form, such as Mongoose's toObject() or Sequelize's get({ plain: true }), or an object literal of the values you set, since anything else would replace the whole";
 /** What a non-plain object is: by its class, or as one without a plain prototype when it has none named. */ const describeInstance = (value)=>{
     const name = value.constructor?.name;
     return typeof name === 'string' && name ? `a ${name}` : 'an object without a plain prototype';

package/dist/esm/decorator/app.decorator.js

@@ -8,9 +8,12 @@ import { assertObservers } from '../core/observer-runner.js';
 import { assertValidTheme, themeForProblem } from '../core/theme-validation.js';
 import { copyLayer } from '../core/theme-scope.js';
 import { declaring, deprecatedOnMethod, refuse } from '../util/refusal.util.js';
-import { timeoutProblem } from '../util/timer-limit.util.js';
+import { timeoutProblem, timerKeepsSeconds, MAX_TIMER_SECONDS } from '../util/timer-limit.util.js';
+import { Logger } from '../common/logger.js';
+import { isConstructor, describeValue } from '../util/value.util.js';
 import { META } from '../util/metadata-keys.js';
 
+const logger = new Logger('MeoCord');
 /** Refuses a `messages` option of the wrong type where the app is declared, rather than at the first message. */ function assertMessageOptions(appName, messages, i18n) {
     if (!messages) return;
     const { prefix, mention, caseSensitive } = messages;
@@ -38,6 +41,9 @@ import { META } from '../util/metadata-keys.js';
     if (deleteUsageRepliesAfter !== undefined && !(typeof deleteUsageRepliesAfter === 'number' && deleteUsageRepliesAfter >= 0 && Number.isFinite(deleteUsageRepliesAfter))) {
         throw refuse(new TypeError(`${appName}: @MeoCord({ messages: { deleteUsageRepliesAfter } }) takes a number of seconds, or 0 to keep usage replies.`));
     }
+    if (deleteUsageRepliesAfter !== undefined && !timerKeepsSeconds(deleteUsageRepliesAfter)) {
+        logger.warn(`${appName}: @MeoCord({ messages: { deleteUsageRepliesAfter } }) is ${deleteUsageRepliesAfter} seconds, longer than a timer ` + `can wait (${MAX_TIMER_SECONDS}), so usage replies are kept. The next major version (5.0) refuses it.`);
+    }
     const { help } = messages;
     // One word each, since help is asked for by its first word
     const isWord = (value)=>typeof value === 'string' && /^\S+$/.test(value);
@@ -52,6 +58,35 @@ import { META } from '../util/metadata-keys.js';
         if (type.labelKey !== undefined) assertLabelKey(appName, name, type.labelKey, i18n);
     }
 }
+/**
+ * Refuses an option that takes a class given anything else, such as an object or an arrow function, where the app is
+ * declared: the startup checks read each class's prototype, and would otherwise fail on it without naming the option.
+ */ function assertClassOptions(appName, { presenter, cooldownStore, controllers, services }) {
+    for (const [name, value, implementing] of [
+        [
+            'presenter',
+            presenter,
+            'ResponsePresenter'
+        ],
+        [
+            'cooldownStore',
+            cooldownStore,
+            'CooldownStore'
+        ]
+    ]){
+        if (value !== undefined && !isConstructor(value)) {
+            throw refuse(new TypeError(`${appName}: @MeoCord({ ${name} }) takes a class implementing ${implementing}, not ${describeValue(value)}.`));
+        }
+    }
+    for (const controller of controllers ?? []){
+        if (!isConstructor(controller)) throw refuse(new TypeError(`${appName}: @MeoCord({ controllers }) takes classes, not ${describeValue(controller)}.`));
+    }
+    // A string or symbol is a token, which a provider has to provide; that is checked as the app is created
+    for (const service of services ?? []){
+        if (isConstructor(service) || typeof service === 'string' || typeof service === 'symbol') continue;
+        throw refuse(new TypeError(`${appName}: @MeoCord({ services }) takes classes, or tokens that providers provide, not ${describeValue(service)}.`));
+    }
+}
 /** Refuses a type's `labelKey` that no message of the app's default catalog has, as it would be shown as the key. */ function assertLabelKey(appName, name, labelKey, i18n) {
     const where = `${appName}: @MeoCord({ messages: { types } }): "${name}" has labelKey`;
     if (typeof labelKey !== 'string') throw refuse(new TypeError(`${where} ${String(labelKey)}; it takes a message key, such as 'types.${name}'.`));
@@ -96,6 +131,7 @@ import { META } from '../util/metadata-keys.js';
  */ function MeoCord(options) {
     return declaring((target, propertyKey)=>{
         if (deprecatedOnMethod('@MeoCord', target, propertyKey)) return;
+        assertClassOptions(target.name, options);
         assertStageEntries('@MeoCord({ guards })', 'guard', target.name, options.guards ?? []);
         assertStageEntries('@MeoCord({ interceptors })', 'interceptor', target.name, options.interceptors ?? []);
         assertStageEntries('@MeoCord({ filters })', 'filter', target.name, options.filters ?? []);

package/dist/esm/decorator/command-builder.decorator.js

@@ -2,7 +2,15 @@ import 'reflect-metadata';
 import { makeInjectable } from '../util/injectable.util.js';
 import { META } from '../util/metadata-keys.js';
 import { declaring, deprecatedOnMethod } from '../util/refusal.util.js';
+import { Logger } from '../common/logger.js';
 
+const logger = new Logger('CommandBuilder');
+/** The nearest base class of `target` that gives `guilds`, which `target` inherits when it gives none. */ function guildsBase(target) {
+    for(let base = Object.getPrototypeOf(target); base && base !== Function.prototype; base = Object.getPrototypeOf(base)){
+        if (Reflect.hasOwnMetadata(META.builderGuilds, base)) return base;
+    }
+    return undefined;
+}
 /**
  * Marks a class as a command's builder, which describes the command MeoCord registers with Discord.
  *
@@ -40,6 +48,12 @@ import { declaring, deprecatedOnMethod } from '../util/refusal.util.js';
         if (options.guilds) Reflect.defineMetadata(META.builderGuilds, [
             ...options.guilds
         ], target);
+        else {
+            const base = guildsBase(target);
+            if (base) {
+                logger.warn(`${target.name} gives no guilds and inherits ${base.name}'s; declare guilds on ${target.name} to keep them. ` + 'The next major version (5.0) registers it in the configured scope.');
+            }
+        }
     });
 }
 

package/dist/esm/decorator/controller-class.decorator.js

@@ -1,5 +1,5 @@
 import { dropInheritedRoutes } from './controller.decorator.js';
-import { guardOwnHandlersWithBaseGuards } from './guard.decorator.js';
+import { guardOwnHandlersWithBaseGuards } from '../core/guard-runner.js';
 import { makeInjectable } from '../util/injectable.util.js';
 import { META } from '../util/metadata-keys.js';
 import { declaring, deprecatedOnMethod } from '../util/refusal.util.js';

package/dist/esm/decorator/controller.decorator.js

@@ -7,8 +7,8 @@ import { wrapsMethod } from '../util/method-wrapper.util.js';
 import { warnDeprecatedBehaviour } from '../common/deprecation.js';
 import { Logger } from '../common/logger.js';
 import { routeSpecificity } from '../core/route-specificity.js';
-import { lookupTable, isSegmentType, choicesOf, parseSegment } from '../core/scalar-types.js';
-import { declaring, refuse, refuseOnClass } from '../util/refusal.util.js';
+import { lookupTable, isSegmentType, choicesOf, shortestSegment, parseSegment } from '../core/scalar-types.js';
+import { declaring, refuse, refuseOnClass, decoratedName } from '../util/refusal.util.js';
 import { withArticle, describeValue } from '../util/value.util.js';
 import { META } from '../util/metadata-keys.js';
 
@@ -18,6 +18,12 @@ import { META } from '../util/metadata-keys.js';
     return `; it was given ${describeValue(value)}`;
 }
 const logger = new Logger('Command');
+/** The interaction types a method's `@Command` routes declare, each once. */ function routeTypesOf(prototype, method) {
+    const metas = Object.values(getCommandMap(prototype) ?? {}).flat();
+    return [
+        ...new Set(metas.filter((meta)=>meta.methodName === method).map((meta)=>meta.type))
+    ];
+}
 /**
  * The class's own handler list, started from a copy of the inherited one, so a subclass's
  * handlers never land in its base class's metadata.
@@ -43,6 +49,10 @@ const autocompleteRoute = (method, commandPath, optionName)=>({
         method,
         label: `autocomplete of ${optionName === undefined ? 'every option' : `"${optionName}"`} in "${commandPath}"`
     });
+/** An `@On` or `@Once` handler as a warning names its route; one event per method, as a subclass replaces it. */ const eventRoute = ({ method, event })=>({
+        method,
+        label: `event "${event}"`
+    });
 /** Records a route a class's own decorator declares for a method, which the startup check reads. */ function declareRoute(target, declared) {
     const routes = Reflect.getOwnMetadata(META.declaredRoutes, target) ?? [];
     routes.push(declared);
@@ -70,13 +80,22 @@ const autocompleteRoute = (method, commandPath, optionName)=>({
     else handlers[index] = entry;
     Reflect.defineMetadata(key, handlers, target);
 }
+/** The `@On` and `@Once` entries a class's own decorators declare, without those it inherits from its base. */ function ownEventHandlers(prototype) {
+    const inherited = Reflect.getMetadata(META.eventHandlers, Object.getPrototypeOf(prototype)) ?? [];
+    return ownHandlerList(META.eventHandlers, prototype).filter((entry)=>!inherited.includes(entry));
+}
 /**
  * Leaves each method the class's own decorators declare only those routes, of every kind, dropping the ones it inherits
  * for it: what `@Controller({ inheritedRoutes: 'replace' })` does once the class's method decorators have run.
  */ function dropInheritedRoutes(prototype) {
-    const redeclared = new Set(getDeclaredRoutes(prototype).map((route)=>route.method));
-    if (redeclared.size === 0) return;
     const base = Object.getPrototypeOf(prototype);
+    // The class's own @On and @Once re-declare their methods too
+    const ownEvents = ownEventHandlers(prototype);
+    const redeclared = new Set([
+        ...getDeclaredRoutes(prototype).map((route)=>route.method),
+        ...ownEvents.map((entry)=>entry.method)
+    ]);
+    if (redeclared.size === 0) return;
     // An entry the class takes from its base, for a method it re-declares
     const inheritedFor = (inherited, method)=>(entry)=>inherited.includes(entry) && redeclared.has(method(entry));
     const commands = ownCommandMap(prototype);
@@ -99,6 +118,10 @@ const autocompleteRoute = (method, commandPath, optionName)=>({
         [
             META.autocompleteHandlers,
             (entry)=>entry.methodName
+        ],
+        [
+            META.eventHandlers,
+            (entry)=>entry.method
         ]
     ];
     for (const [key, method] of lists){
@@ -125,13 +148,14 @@ const autocompleteRoute = (method, commandPath, optionName)=>({
 function MessageHandler(pattern, options = {}) {
     return declaring(function(target, propertyKey) {
         refuseOnClass('@MessageHandler', target, propertyKey);
-        // An empty pattern means every message, as no pattern does
-        if (pattern === '') {
-            warnDeprecatedBehaviour(logger, `@MessageHandler('') on ${target.constructor.name}.${propertyKey}`, 'is refused', '@MessageHandler()');
+        // An empty pattern, or one of spaces alone, means every message, as no pattern does
+        const blank = pattern !== undefined && pattern.trim() === '';
+        if (blank) {
+            warnDeprecatedBehaviour(logger, `@MessageHandler('${pattern}') on ${decoratedName(target, propertyKey)}`, 'is refused', '@MessageHandler()');
         }
         const method = propertyKey.toString();
         const declared = {
-            pattern: pattern || undefined,
+            pattern: blank ? undefined : pattern,
             method,
             options
         };
@@ -253,13 +277,14 @@ const WHOLE_PLACEHOLDER = new RegExp(`^${PLACEHOLDER_PATTERN.source}$`);
         params: params.length,
         typed: Object.values(types).reduce((sum, type)=>sum + (choicesOf(type) ? 4 : type === 'bool' ? 3 : type === 'int' ? 2 : 1), 0)
     });
-    // Each param takes at least one character
+    // Each param takes at least the shortest value of its type
+    const shortest = literalLength + params.reduce((sum, param)=>sum + shortestSegment(types[param] ?? 'string'), 0);
     return {
         regex,
         params,
         types: lookupTable(types),
         specificity,
-        shortest: literalLength + params.length
+        shortest
     };
 }
 /** Why a `{name:type}` cannot type a customId segment, which holds text the bot wrote, with no message to read. */ function segmentTypeProblem(param, type) {
@@ -332,13 +357,17 @@ const WHOLE_PLACEHOLDER = new RegExp(`^${PLACEHOLDER_PATTERN.source}$`);
         refuseOnClass('@Command', target, propertyKey);
         const originalMethod = _descriptor.value;
         if (!originalMethod) {
-            throw refuse(new Error(`${target.constructor.name}.${propertyKey}: @Command is on something with no implementation.`));
+            throw refuse(new Error(`${decoratedName(target, propertyKey)}: @Command is on something with no implementation.`));
         }
         // Wrap original method for interaction type validation
         const declaredAs = typeof builderOrType === 'function' ? builderOrType.name : `CommandType.${builderOrType}`;
         const checked = function(interaction, params) {
-            if (!matchesCommandType(commandType, interaction)) {
-                throw new Error(`${target.constructor.name}.${propertyKey}: @Command('${commandName}', ${declaredAs}) takes ` + `${interactionClassName(commandType)}${givenInstead(interaction)}.`);
+            // Every type the method's routes declare, in the class the call is made on: each @Command wraps it, so one alone
+            // would refuse the others' interactions, and an override that adds a route type reaches this one through super
+            const called = typeof this === 'object' && this !== null && Object.prototype.isPrototypeOf.call(target, this) ? Object.getPrototypeOf(this) : target;
+            const types = routeTypesOf(called, propertyKey);
+            if (!types.some((type)=>matchesCommandType(type, interaction))) {
+                throw new Error(types.length <= 1 ? `${decoratedName(target, propertyKey)}: @Command('${commandName}', ${declaredAs}) takes ` + `${interactionClassName(commandType)}${givenInstead(interaction)}.` : `${decoratedName(target, propertyKey)}: its @Command routes take ${types.map(interactionClassName).join(' or ')}` + `${givenInstead(interaction)}.`);
             }
             return originalMethod.apply(this, [
                 interaction,
@@ -356,7 +385,7 @@ const WHOLE_PLACEHOLDER = new RegExp(`^${PLACEHOLDER_PATTERN.source}$`);
         let guilds;
         // Determine command type and builder
         if (typeof builderOrType === 'function') {
-            const where = `${target.constructor.name}.${propertyKey}`;
+            const where = decoratedName(target, propertyKey);
             // A subcommand is part of its command's builder, which belongs on the command's own name
             const subcommandPath = Reflect.getMetadata(META.commandType, builderOrType) === CommandType.SLASH && commandName.includes(' ');
             const command = commandName.split(' ')[0];
@@ -403,12 +432,12 @@ const WHOLE_PLACEHOLDER = new RegExp(`^${PLACEHOLDER_PATTERN.source}$`);
         if (isCustomIdRouted(commandType)) {
             // A route warned as it was made
             const braces = typeof name === 'string' ? literalBraces(commandName) : undefined;
-            if (braces) logger.warn(`${target.constructor.name}.${propertyKey}: in the pattern "${commandName}", ${braces}`);
+            if (braces) logger.warn(`${decoratedName(target, propertyKey)}: in the pattern "${commandName}", ${braces}`);
             let pattern;
             try {
                 pattern = createRegexFromPattern(commandName);
             } catch (error) {
-                throw refuse(new Error(`${target.constructor.name}.${propertyKey}: ${error.message}`, {
+                throw refuse(new Error(`${decoratedName(target, propertyKey)}: ${error.message}`, {
                     cause: error
                 }));
             }
@@ -418,7 +447,7 @@ const WHOLE_PLACEHOLDER = new RegExp(`^${PLACEHOLDER_PATTERN.source}$`);
             // Warned rather than refused, so a bot that carries such a handler still starts
             if (pattern.shortest === 0 || pattern.shortest > MAX_CUSTOM_ID_LENGTH) {
                 const length = pattern.shortest === 0 ? 'the pattern is empty' : `its shortest is ${pattern.shortest} characters`;
-                logger.warn(`${target.constructor.name}.${propertyKey}: the pattern "${commandName}" matches no customId: Discord's customIds ` + `are 1 to ${MAX_CUSTOM_ID_LENGTH} characters, and ${length}, so the handler never runs.`);
+                logger.warn(`${decoratedName(target, propertyKey)}: the pattern "${commandName}" matches no customId: Discord's customIds ` + `are 1 to ${MAX_CUSTOM_ID_LENGTH} characters, and ${length}, so the handler never runs.`);
             }
         }
         const declared = {
@@ -470,7 +499,7 @@ const WHOLE_PLACEHOLDER = new RegExp(`^${PLACEHOLDER_PATTERN.source}$`);
     const registered = built?.type;
     if (!declared || registered === undefined || declared.kind === registered) return;
     const kind = registered === ApplicationCommandType.User ? 'user' : 'message';
-    throw refuse(new Error(`${target.constructor.name}.${propertyKey}: it takes a ${declared.name} context menu interaction, but ${builderName} ` + `registers "${commandName}" as a ${kind} context menu command. Declare the handler's interaction as the kind the ` + `builder's setType() names.`));
+    throw refuse(new Error(`${decoratedName(target, propertyKey)}: it takes a ${declared.name} context menu interaction, but ${builderName} ` + `registers "${commandName}" as a ${kind} context menu command. Declare the handler's interaction as the kind the ` + `builder's setType() names.`));
 }
 /**
  * Retrieves the command map for a given controller.
@@ -608,4 +637,4 @@ const narrowness = (type)=>choicesOf(type) ? 6 : NARROWNESS[type];
     return values.every((value)=>value !== undefined) ? values.join(PARAM_SEPARATOR) : undefined;
 }
 
-export { Autocomplete, Command, MAX_CUSTOM_ID_LENGTH, MessageHandler, PARAM_SEPARATOR, ReactionHandler, commandsNamed, createRegexFromPattern, dropInheritedRoutes, getAutocompleteHandlers, getCommandMap, getDeclaredRoutes, getHandlerRoutes, getMessageHandlers, getReactionHandlers, literalBraces, matchesEmoji, ownHandlerList, paramNarrowness, patternShape, sharedCustomId };
+export { Autocomplete, Command, MAX_CUSTOM_ID_LENGTH, MessageHandler, PARAM_SEPARATOR, ReactionHandler, addOwnHandler, commandsNamed, createRegexFromPattern, dropInheritedRoutes, eventRoute, getAutocompleteHandlers, getCommandMap, getDeclaredRoutes, getHandlerRoutes, getMessageHandlers, getReactionHandlers, literalBraces, matchesEmoji, ownEventHandlers, ownHandlerList, paramNarrowness, patternShape, sharedCustomId };

package/dist/esm/decorator/defer.decorator.js

@@ -1,6 +1,6 @@
 import 'reflect-metadata';
 import { nonInteractionHandler, deferMisuseError } from '../core/defer.js';
-import { declaring, refuseOnClass, refuse } from '../util/refusal.util.js';
+import { declaring, refuseOnClass, refuse, ownerName } from '../util/refusal.util.js';
 import { META } from '../util/metadata-keys.js';
 
 /**
@@ -43,7 +43,7 @@ import { META } from '../util/metadata-keys.js';
         refuseOnClass('@Defer', target, propertyKey);
         const methodName = String(propertyKey);
         const kind = nonInteractionHandler(target, methodName);
-        if (kind) throw refuse(deferMisuseError(target.constructor.name, methodName, kind));
+        if (kind) throw refuse(deferMisuseError(ownerName(target), methodName, kind));
         Reflect.defineMetadata(META.deferOptions, {
             ...options
         }, target, methodName);

package/dist/esm/decorator/event.decorator.js

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import { ownHandlerList } from './controller.decorator.js';
+import { addOwnHandler } from './controller.decorator.js';
 import { META } from '../util/metadata-keys.js';
 import { declaring, refuseOnClass } from '../util/refusal.util.js';
 
@@ -7,13 +7,12 @@ function eventDecorator(event, once) {
     // Generic over the method, so it is checked against the event's arguments rather than required to match exactly
     return declaring(function(target, propertyKey, _descriptor) {
         refuseOnClass(once ? '@Once' : '@On', target, propertyKey);
-        const handlers = ownHandlerList(META.eventHandlers, target);
-        handlers.push({
+        // One the class inherits for the same method and event is replaced, as for every other kind of handler
+        addOwnHandler(META.eventHandlers, target, {
             event,
             method: propertyKey,
             once
-        });
-        Reflect.defineMetadata(META.eventHandlers, handlers, target);
+        }, (other)=>other.method === propertyKey && other.event === event);
     });
 }
 /**

package/dist/esm/decorator/filter.decorator.js

@@ -3,9 +3,9 @@ import { makeInjectable } from '../util/injectable.util.js';
 import { assertStageEntries } from '../core/stage-scope.js';
 import { Logger } from '../common/logger.js';
 import { warnDeprecatedBehaviour } from '../common/deprecation.js';
-import { isConstructor, describeValue } from '../util/value.util.js';
+import { isConstructible, describeValue } from '../util/value.util.js';
 import { META } from '../util/metadata-keys.js';
-import { declaring, refuseOnMethod } from '../util/refusal.util.js';
+import { declaring, refuseOnMethod, decoratedName } from '../util/refusal.util.js';
 
 /**
  * Marks a class as an exception filter for the given error types.
@@ -40,7 +40,7 @@ import { declaring, refuseOnMethod } from '../util/refusal.util.js';
         refuseOnMethod('@Catch', target, propertyKey);
         makeInjectable(target);
         errorTypes.forEach((type, index)=>{
-            if (isConstructor(type)) return;
+            if (isConstructible(type)) return;
             const entry = ORDINALS[index] ? `${ORDINALS[index]} entry` : `entry ${index + 1}`;
             warnDeprecatedBehaviour(logger, `${target.name}: @Catch's ${entry}, ${describeValue(type)}, which matches no error,`, 'is refused', 'an error class, such as @Catch(CooldownError),');
         });
@@ -88,7 +88,7 @@ const ORDINALS = [
  * @see {@link https://meocord.dev/docs/4.2/exception-filters | Exception filters}
  */ function UseFilter(...filters) {
     return declaring(function(target, propertyKey) {
-        const where = propertyKey === undefined ? target.name : `${target.constructor.name}.${String(propertyKey)}`;
+        const where = decoratedName(target, propertyKey);
         assertStageEntries('@UseFilter', 'filter', where, filters);
         // Decorators apply bottom-up, so a higher decorator's filters are tried first.
         if (propertyKey === undefined) {

package/dist/esm/decorator/guard.decorator.js

@@ -1,47 +1,10 @@
 import 'reflect-metadata';
-import { handlerMethods, classLevelGuards, consumeDispatchMark, runDirectCall, declaringPrototype, classChain } from '../core/guard-runner.js';
+import { applyGuards, recordGuards, handlerMethods, classLevelGuards, declaringPrototype } from '../core/guard-runner.js';
 import { makeInjectable } from '../util/injectable.util.js';
-import { wrapsMethod } from '../util/method-wrapper.util.js';
 import { defineStageTypes, assertStageEntries } from '../core/stage-scope.js';
 import { META } from '../util/metadata-keys.js';
-import { declaring, deprecatedOnMethod } from '../util/refusal.util.js';
+import { declaring, deprecatedOnMethod, decoratedName } from '../util/refusal.util.js';
 
-/**
- * Adds guards to a method's class or method list, then republishes the effective list under
- * `META.guards`, in the order they run: the bases' before the class's own, and within one class or method the
- * latest decorator first, since it wraps outermost.
- */ function recordGuards(key, guards, prototype, methodName) {
-    const existing = Reflect.getOwnMetadata(key, prototype, methodName) ?? [];
-    const bases = key === META.classGuards ? Reflect.getOwnMetadata(META.baseClassGuards, prototype, methodName) ?? 0 : 0;
-    Reflect.defineMetadata(key, [
-        ...existing.slice(0, bases),
-        ...guards,
-        ...existing.slice(bases)
-    ], prototype, methodName);
-    const [classGuards, inheritedGuards, methodGuards] = [
-        META.classGuards,
-        META.inheritedGuards,
-        META.methodGuards
-    ].map((list)=>Reflect.getOwnMetadata(list, prototype, methodName) ?? []);
-    Reflect.defineMetadata(META.guards, [
-        ...inheritedGuards,
-        ...classGuards,
-        ...methodGuards
-    ], prototype, methodName);
-}
-/**
- * Wraps a method so a direct call runs its guards first: the wrapper entered first runs the whole
- * chain dispatch resolves for the handler, and lets the ones inside it through. A call from dispatch,
- * which has already run the guards, passes through every wrapper.
- */ function applyGuards(descriptor, prototype, propertyKey) {
-    const originalMethod = descriptor.value;
-    descriptor.value = wrapsMethod(async function(...args) {
-        if (consumeDispatchMark(args[0], this, propertyKey)) return originalMethod.apply(this, args);
-        return runDirectCall(this, propertyKey, args, ()=>originalMethod.apply(this, args));
-    }, originalMethod);
-    const wrappers = Reflect.getOwnMetadata(META.guardWrappers, prototype, propertyKey) ?? 0;
-    Reflect.defineMetadata(META.guardWrappers, wrappers + 1, prototype, propertyKey);
-}
 /**
  * The class's own descriptor for a handler. An inherited handler gets one that calls the inherited
  * method, starting from its guard lists and wrapper count, so class guards wrap it like an own method.
@@ -69,26 +32,6 @@ import { declaring, deprecatedOnMethod } from '../util/refusal.util.js';
         ...inherited
     };
 }
-/**
- * Gives each handler a controller declares itself the class-level guards of the classes it extends,
- * as its inherited handlers have: recorded under `META.guards`, and wrapped so a direct call
- * runs them when no other guard wraps the handler. `@Controller` calls this.
- */ function guardOwnHandlersWithBaseGuards(target) {
-    const prototype = target.prototype;
-    for (const methodName of handlerMethods(prototype)){
-        const descriptor = Object.getOwnPropertyDescriptor(prototype, methodName);
-        // Inherited handlers have the chain of the class that declares them
-        if (typeof descriptor?.value !== 'function' || Reflect.getOwnMetadata(META.inheritedFrom, prototype, methodName)) continue;
-        // Base first, as dispatch runs them
-        const guards = classChain(prototype, prototype).slice(1).reverse().flatMap(classLevelGuards);
-        if (guards.length === 0) continue;
-        if (!Reflect.getOwnMetadata(META.guardWrappers, prototype, methodName)) {
-            applyGuards(descriptor, prototype, methodName);
-            Object.defineProperty(prototype, methodName, descriptor);
-        }
-        recordGuards(META.inheritedGuards, guards, prototype, methodName);
-    }
-}
 /**
  * Marks a class as a guard, which decides whether a handler runs.
  *
@@ -162,7 +105,7 @@ import { declaring, deprecatedOnMethod } from '../util/refusal.util.js';
  */ function UseGuard(...entries) {
     const guards = entries;
     return declaring(function(target, propertyKey, descriptor) {
-        const where = propertyKey === undefined ? String(target?.name) : `${target.constructor.name}.${String(propertyKey)}`;
+        const where = decoratedName(target, propertyKey);
         assertStageEntries('@UseGuard', 'guard', where, guards);
         if (descriptor && propertyKey) {
             // Method Decorator
@@ -189,4 +132,4 @@ import { declaring, deprecatedOnMethod } from '../util/refusal.util.js';
     });
 }
 
-export { Guard, UseGuard, guardOwnHandlersWithBaseGuards };
+export { Guard, UseGuard };

package/dist/esm/decorator/inject.decorator.js

@@ -1,5 +1,5 @@
 import { inject } from 'inversify';
-import { declaring, refuseOnClass } from '../util/refusal.util.js';
+import { declaring, refuseOnClass, refuse, decoratedName } from '../util/refusal.util.js';
 
 /**
  * Injects what a token provides into a constructor parameter.
@@ -30,6 +30,9 @@ import { declaring, refuseOnClass } from '../util/refusal.util.js';
     return declaring((target, propertyKey, parameterIndex)=>{
         // A constructor parameter has no property key either, but has an index
         if (typeof parameterIndex !== 'number') refuseOnClass('@Inject', target, propertyKey, 'a constructor parameter or a property');
+        else if (propertyKey !== undefined) {
+            throw refuse(new Error(`${decoratedName(target, propertyKey)}: @Inject goes on a constructor parameter or a property, not a method parameter.`));
+        }
         decorate(target, propertyKey, parameterIndex);
     });
 }

package/dist/esm/decorator/interceptor.decorator.js

@@ -2,7 +2,7 @@ import 'reflect-metadata';
 import { makeInjectable } from '../util/injectable.util.js';
 import { defineStageTypes, assertStageEntries } from '../core/stage-scope.js';
 import { META } from '../util/metadata-keys.js';
-import { declaring, refuseOnMethod } from '../util/refusal.util.js';
+import { declaring, refuseOnMethod, decoratedName } from '../util/refusal.util.js';
 
 /**
  * Marks a class as an interceptor, which wraps a handler to act before and after it.
@@ -76,7 +76,7 @@ import { declaring, refuseOnMethod } from '../util/refusal.util.js';
  * @see {@link https://meocord.dev/docs/4.2/interceptors | Interceptors}
  */ function UseInterceptor(...interceptors) {
     return declaring(function(target, propertyKey) {
-        const where = propertyKey === undefined ? target.name : `${target.constructor.name}.${String(propertyKey)}`;
+        const where = decoratedName(target, propertyKey);
         assertStageEntries('@UseInterceptor', 'interceptor', where, interceptors);
         // Decorators apply bottom-up, so a higher decorator's interceptors go first, as with @UseGuard.
         if (propertyKey === undefined) {