meocord 4.2.2 → 4.2.3

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

@@ -5,7 +5,7 @@ import { Logger } from '../common/logger.js';
 import { warnDeprecatedBehaviour } from '../common/deprecation.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.
@@ -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) {

package/dist/esm/decorator/theme.decorator.js

@@ -2,7 +2,7 @@ import 'reflect-metadata';
 import { assertValidTheme } from '../core/theme-validation.js';
 import { THEMED_CLASSES } from '../core/theme-runtime.js';
 import { copyLayer } from '../core/theme-scope.js';
-import { declaring, refuse } from '../util/refusal.util.js';
+import { declaring, decoratedName, refuse } from '../util/refusal.util.js';
 import { META } from '../util/metadata-keys.js';
 
 /**
@@ -37,8 +37,9 @@ import { META } from '../util/metadata-keys.js';
  */ function UseTheme(theme) {
     return declaring(function(target, propertyKey) {
         const onClass = propertyKey === undefined;
-        const owner = onClass ? target : target.constructor;
-        const where = `${owner.name}${onClass ? '' : `.${String(propertyKey)}`}: @UseTheme`;
+        // The class it themes: the target itself on a class or a static member, else the target's constructor
+        const owner = onClass || typeof target === 'function' ? target : target.constructor;
+        const where = `${decoratedName(target, propertyKey)}: @UseTheme`;
         assertValidTheme(theme, where);
         const key = onClass ? META.classTheme : META.methodTheme;
         const existing = onClass ? Reflect.getOwnMetadata(key, target) : Reflect.getOwnMetadata(key, target, propertyKey);

package/dist/esm/decorator/validation.decorator.js

@@ -1,7 +1,7 @@
 import 'reflect-metadata';
 import { makeInjectable } from '../util/injectable.util.js';
 import { assertStageEntries } from '../core/stage-scope.js';
-import { declaring, refuseOnClass, refuse, refuseOnMethod } from '../util/refusal.util.js';
+import { declaring, refuseOnClass, refuse, decoratedName, refuseOnMethod } from '../util/refusal.util.js';
 import { META } from '../util/metadata-keys.js';
 
 /**
@@ -43,15 +43,15 @@ import { META } from '../util/metadata-keys.js';
         refuseOnClass('@Validate', target, propertyKey);
         // Checked where it applies, so the refusal names the handler
         if (typeof schema?.['~standard']?.validate !== 'function') {
-            throw refuse(new Error(`${target.constructor.name}.${propertyKey}: @Validate takes a Standard Schema, such as a zod, valibot or arktype schema.`));
+            throw refuse(new Error(`${decoratedName(target, propertyKey)}: @Validate takes a Standard Schema, such as a zod, valibot or arktype schema.`));
         }
         if (Reflect.hasOwnMetadata(META.methodValidation, target, propertyKey)) {
-            throw refuse(new Error(`${target.constructor.name}.${propertyKey}: more than one @Validate; one @Validate per handler: combine the schemas into one.`));
+            throw refuse(new Error(`${decoratedName(target, propertyKey)}: more than one @Validate; one @Validate per handler: combine the schemas into one.`));
         }
         const inlinePipes = Object.values(options.pipes ?? {}).flatMap((entries)=>Array.isArray(entries) ? entries : [
                 entries
             ]);
-        assertStageEntries('@Validate', 'pipe', `${target.constructor.name}.${propertyKey}`, inlinePipes);
+        assertStageEntries('@Validate', 'pipe', decoratedName(target, propertyKey), inlinePipes);
         const metadata = {
             schema,
             pipes: options.pipes ?? {}
@@ -93,7 +93,7 @@ import { META } from '../util/metadata-keys.js';
  */ function UsePipe(key, ...pipes) {
     return declaring(function(target, propertyKey, _descriptor) {
         refuseOnClass('@UsePipe', target, propertyKey);
-        assertStageEntries('@UsePipe', 'pipe', `${target.constructor.name}.${propertyKey}`, pipes);
+        assertStageEntries('@UsePipe', 'pipe', decoratedName(target, propertyKey), pipes);
         // Decorators apply bottom-up, so a higher @UsePipe's pipes go first, in the order they read.
         const existing = Reflect.getOwnMetadata(META.methodPipes, target, propertyKey) ?? [];
         Reflect.defineMetadata(META.methodPipes, [

package/dist/esm/package.json.js

@@ -1,4 +1,4 @@
-var version = "4.2.2";
+var version = "4.2.3";
 var engines = {
 	node: ">=22.13"
 };

package/dist/esm/testing/catalog.js

@@ -1,25 +1,33 @@
 import { isPluralShape, CATALOGS, placeholderNames } from '../common/translator.js';
 import { MEOCORD_MESSAGES } from '../common/meocord-messages.js';
 
-/** Every message key of a catalog, and whether it is a plural. */ function leaves(catalog, prefix = '') {
+/**
+ * Every message key of a catalog, and whether it is a plural. `reference` decides whether an object is a plural or a
+ * group, as the translator reads a translation by the default catalog's shapes; where it lacks a key, the object's own
+ * keys decide.
+ */ function leaves(catalog, prefix = '', reference = catalog) {
     return Object.entries(catalog).flatMap(([name, value])=>{
         const key = `${prefix}${name}`;
-        if (typeof value === 'string') return [
+        // A null message is one where it stands, which the checks below read as missing
+        if (typeof value === 'string' || value === null) return [
             {
                 key,
                 plural: false
             }
         ];
-        if (isPluralShape(value)) return [
+        const shape = typeof reference === 'object' && reference !== null && Object.hasOwn(reference, name) ? reference[name] : undefined;
+        const plural = typeof shape === 'object' && shape !== null ? isPluralShape(shape) : isPluralShape(value);
+        if (plural) return [
             {
                 key,
                 plural: true
             }
         ];
-        return leaves(value, `${key}.`);
+        return leaves(value, `${key}.`, shape);
     });
 }
 /** A translation's text, which an empty string isn't: the translator reads `''` as missing, as tools export one untranslated. */ const isText = (value)=>typeof value === 'string' && value !== '';
+/** A message the translator reads as missing: none, `null` or `''`, as tools export one untranslated. */ const isMissing = (value)=>value === undefined || value === null || value === '';
 /** The value at a key's path, through own properties only, so `constructor` or `toString` is not read off a prototype. */ function at(catalog, key) {
     return key.split('.').reduce((current, part)=>typeof current === 'object' && current !== null && Object.hasOwn(current, part) ? current[part] : undefined, catalog);
 }
@@ -44,11 +52,13 @@ const isMeoCordKey = (key)=>key.startsWith('meocord.');
  *
  * Use it in a test for a team that wants no fallback in production. It reports the messages a locale lacks, the
  * messages the default catalog doesn't have, the plural forms a language needs but a plural lacks, such as `few` for
- * Russian, a translation of another shape than the default's, a text for a plural or a plural for a text, and each
- * `{param}` a translation uses that the message it translates doesn't take. An empty translation, `''`, counts as
- * lacking, as the translator reads it as missing. It reads the catalogs' own strings, so it checks the params of a
- * catalog from a plain variable or a JSON file too, which the compiler can't. An object counts as a plural only when
- * its every key is a plural category, so a group with an `other` key is a group.
+ * Russian, a translation of another shape than the default's, a text for a plural or a group, or a plural for a text, and each
+ * `{param}` a translation uses that the message it translates doesn't take. An empty translation, `''` or `null`, counts
+ * as lacking, as the translator reads it as missing. It reads the catalogs' own strings, so it checks the params of a
+ * catalog from a plain variable or a JSON file too, which the compiler can't. An object in the default catalog counts as
+ * a plural only when its every key is a plural category, so a group with an `other` key is a group, and a translation
+ * is read by the default catalog's shapes, as the translator reads it: one that keeps only a group's `other` message
+ * lacks the group's other messages.
  *
  * @remarks
  * MeoCord's own texts, a catalog's `meocord` group, fall back to English by design, so only a key MeoCord lacks, and
@@ -95,7 +105,7 @@ const isMeoCordKey = (key)=>key.startsWith('meocord.');
         const categories = new Intl.PluralRules(locale).resolvedOptions().pluralCategories;
         for (const { key, plural } of reference){
             const message = at(catalog, key);
-            if (message === undefined || message === '') {
+            if (isMissing(message)) {
                 problems.push(`missing ${key}`);
                 continue;
             }
@@ -113,9 +123,11 @@ const isMeoCordKey = (key)=>key.startsWith('meocord.');
             for (const name of stray)problems.push(`${key} takes no {${name}}; the default is "${shown(original)}"`);
         }
         if (options.meocord && !locale.startsWith('en-')) {
-            for (const key of MEOCORD_KEYS)if (at(catalog, key) === undefined || at(catalog, key) === '') problems.push(`missing ${key}`);
+            for (const key of MEOCORD_KEYS)if (isMissing(at(catalog, key))) problems.push(`missing ${key}`);
         }
-        for (const { key } of leaves(catalog)){
+        for (const { key } of leaves(catalog, '', defaultCatalog)){
+            // A message left out, as a null one is, that the default has is reported missing above, and is nothing extra
+            if (isMissing(at(catalog, key)) && at(defaultCatalog, key) !== undefined) continue;
             if (isMeoCordKey(key)) {
                 if (!MEOCORD_KEYS.has(key)) problems.push(`${key} is not one of MeoCord's texts`);
                 else {
@@ -123,7 +135,11 @@ const isMeoCordKey = (key)=>key.startsWith('meocord.');
                     const stray = strayParams(at(catalog, key), english);
                     for (const name of stray)problems.push(`${key} takes no {${name}}: MeoCord's English is "${shown(english)}"`);
                 }
-            } else if (!referenceKeys.has(key)) problems.push(`${key} is not in the default catalog`);
+            } else if (!referenceKeys.has(key)) {
+                // A text where the default has a group: the key is the default's, in another shape
+                const original = at(defaultCatalog, key);
+                problems.push(typeof original === 'object' && original !== null ? `${key} should be a group, as the default is` : `${key} is not in the default catalog`);
+            }
         }
         if (problems.length > 0) gaps.push(`  ${locale}: ${problems.join('; ')}`);
     }

package/dist/esm/testing/cooldown-store-suite.js

@@ -1,5 +1,5 @@
 import { randomUUID } from 'node:crypto';
-import { CooldownStore } from '../common/cooldown-store.js';
+import { isDefaultBatchMethod } from '../common/cooldown-store.js';
 
 /** Long enough for a store over the network to answer each case, short enough that the suite takes seconds. */ const CASE_TIMEOUT_MS = 10000;
 const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
@@ -408,10 +408,10 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
     });
 }
 /** Whether a store overrides `consumeMany`, as a store that counts a batch at once does. */ function overridesConsumeMany(store) {
-    return store.consumeMany !== CooldownStore.prototype.consumeMany;
+    return !isDefaultBatchMethod(store.consumeMany);
 }
 /** Whether a store overrides `peekMany`, as a store that can check a batch without recording it does. */ function overridesPeekMany(store) {
-    return store.peekMany !== CooldownStore.prototype.peekMany;
+    return !isDefaultBatchMethod(store.peekMany);
 }
 
 export { testCooldownStore };