meocord 4.2.0 → 4.2.1

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

@@ -1,5 +1,6 @@
 import { ButtonStyle, Colors } from 'discord.js';
 import { refuse } from '../util/refusal.util.js';
+import { escapeForLog, quoteForLog } from '../util/user-text.util.js';
 
 /**
  * The role names MeoCord keeps for roles it may add to `colors`, `emojis` and `buttons`: the runtime copy of
@@ -25,9 +26,10 @@ const EMOJI = 'a unicode emoji, or a custom one written <:name:id> or <a:name:id
 const BUTTON = 'ButtonStyle.Primary, Secondary, Success or Danger';
 /** A custom emoji as Discord writes one in text: its name, 2 to 32 word characters, and its id. */ const CUSTOM_EMOJI = /^<a?:\w{2,32}:\d{17,20}>$/;
 /**
- * One unicode emoji: a flag of two regional indicators, a keycap, or a pictograph with an optional presentation
- * selector or skin tone, joined to others by zero-width joiners into one sequence.
- */ const UNICODE_EMOJI = /^(?:\p{Regional_Indicator}{2}|[#*0-9]️?⃣|\p{Extended_Pictographic}(?:️|\p{Emoji_Modifier})?(?:‍\p{Extended_Pictographic}(?:️|\p{Emoji_Modifier})?)*)$/u;
+ * One unicode emoji: a flag of two regional indicators, a subdivision flag (a black flag, tag characters and a cancel
+ * tag, as England's), a keycap, or a pictograph with an optional presentation selector or skin tone, joined to others by
+ * zero-width joiners into one sequence.
+ */ const UNICODE_EMOJI = /^(?:\p{Regional_Indicator}{2}|\u{1F3F4}[\u{E0020}-\u{E007E}]+\u{E007F}|[#*0-9]️?⃣|\p{Extended_Pictographic}(?:️|\p{Emoji_Modifier})?(?:‍\p{Extended_Pictographic}(?:️|\p{Emoji_Modifier})?)*)$/u;
 const byte = (value)=>Number.isInteger(value) && value >= 0 && value <= 255;
 /** Whether discord.js resolves the value to a colour Discord takes. Stricter on tuples, whose channels it only sums. */ function isColour(value) {
     if (typeof value === 'string') return /^#?[\da-f]{6}$/i.test(value) || value === 'Random' || value === 'Default' || Object.hasOwn(Colors, value);
@@ -42,8 +44,9 @@ const THEMED_BUTTON_STYLES = [
     ButtonStyle.Danger
 ];
 const isButtonStyle = (value)=>THEMED_BUTTON_STYLES.includes(value);
-const describe = (value)=>typeof value === 'string' ? `'${value}'` : Array.isArray(value) ? `[${value.map((item)=>typeof item === 'string' ? `'${item}'` : String(item)).join(', ')}]` : value === null ? 'null' : typeof value === 'object' ? 'an object' : String(value);
-const describeGroup = (value)=>Array.isArray(value) ? 'an array' : describe(value);
+const asWritten = (text)=>`'${text}'`;
+const describe = (value, quote = asWritten)=>typeof value === 'string' ? quote(value) : Array.isArray(value) ? `[${value.map((item)=>typeof item === 'string' ? quote(item) : String(item)).join(', ')}]` : value === null ? 'null' : typeof value === 'object' ? 'an object' : String(value);
+const describeGroup = (value, quote = asWritten)=>Array.isArray(value) ? 'an array' : describe(value, quote);
 /** Whether a value is a plain object, as an object literal or `JSON.parse` makes: one a theme merges key by key. */ const isPlainObject = (value)=>{
     const prototype = Object.getPrototypeOf(value);
     return prototype === Object.prototype || prototype === null;
@@ -75,11 +78,15 @@ const PLAIN = "give a plain object, such as { ...value }, or a row's toObject(),
  * roles an app added, a colour discord.js cannot resolve, an emoji Discord would refuse, a button style other than
  * Discord's four coloured ones, or a reserved role name. A group of the app's own is its to check.
  * @param where - Where it was set, such as `themeFor.guild for guild 123`, to begin each line with.
- */ function themeProblems(theme, where) {
+ * @param options.forLog - Shows values and role names as a log line shows text from outside the code, for a theme a
+ *   `themeFor` resolver returned: escaped, and a value quoted and cut short.
+ */ function themeProblems(theme, where, { forLog = false } = {}) {
     const at = where ? `${where}: ` : '';
+    const quote = forLog ? quoteForLog : asWritten;
+    const name = forLog ? escapeForLog : (role)=>role;
     if (typeof theme !== 'object' || theme === null || Array.isArray(theme)) {
         return [
-            `${at}theme must be an object of groups (got ${describeGroup(theme)})`
+            `${at}theme must be an object of groups (got ${describeGroup(theme, quote)})`
         ];
     }
     if (!isPlainObject(theme)) return [
@@ -91,7 +98,7 @@ const PLAIN = "give a plain object, such as { ...value }, or a row's toObject(),
         const roles = theme[group];
         if (roles === undefined) continue;
         if (typeof roles !== 'object' || roles === null || Array.isArray(roles)) {
-            problems.push(`${at}theme.${group} must be an object of roles (got ${describeGroup(roles)})`);
+            problems.push(`${at}theme.${group} must be an object of roles (got ${describeGroup(roles, quote)})`);
             continue;
         }
         if (!isPlainObject(roles)) {
@@ -99,8 +106,8 @@ const PLAIN = "give a plain object, such as { ...value }, or a row's toObject(),
             continue;
         }
         for (const [role, value] of Object.entries(roles)){
-            if (reserved.has(role)) problems.push(`${at}theme.${group}.${role}: MeoCord reserves the role name ${role} for a role it may add; rename yours`);
-            else if (value !== undefined && !check(value)) problems.push(`${at}theme.${group}.${role}: ${describe(value)} is not ${what}: give ${instead}`);
+            if (reserved.has(role)) problems.push(`${at}theme.${group}.${name(role)}: MeoCord reserves the role name ${name(role)} for a role it may add; rename yours`);
+            else if (value !== undefined && !check(value)) problems.push(`${at}theme.${group}.${name(role)}: ${describe(value, quote)} is not ${what}: give ${instead}`);
         }
     }
     return problems;

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

@@ -2,7 +2,8 @@ import 'reflect-metadata';
 import { UserContextMenuCommandInteraction, ApplicationCommandType, MessageContextMenuCommandInteraction } from 'discord.js';
 import { CommandType } from '../enum/controller.enum.js';
 import { MetadataKey } from '../enum/metadata-key.enum.js';
-import { matchesCommandType, interactionClassName, isCustomIdRouted } from '../util/interaction.util.js';
+import { isCustomIdRouted, matchesCommandType, interactionClassName } from '../util/interaction.util.js';
+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';
@@ -79,9 +80,9 @@ const autocompleteRoute = (method, commandPath, optionName)=>({
     // An entry the class takes from its base, for a method it re-declares
     const inheritedFor = (inherited, method)=>(entry)=>inherited.includes(entry) && redeclared.has(method(entry));
     const commands = ownCommandMap(prototype);
-    const baseCommands = Reflect.getMetadata(META.commands, base) ?? {};
+    const baseCommands = Reflect.getMetadata(META.commands, base) ?? Object.create(null);
     for (const [name, metas] of Object.entries(commands)){
-        const kept = metas.filter((meta)=>!inheritedFor(baseCommands[name] ?? [], (entry)=>entry.methodName)(meta));
+        const kept = metas.filter((meta)=>!inheritedFor(commandsNamed(baseCommands, name), (entry)=>entry.methodName)(meta));
         if (kept.length > 0) commands[name] = kept;
         else delete commands[name];
     }
@@ -105,16 +106,21 @@ const autocompleteRoute = (method, commandPath, optionName)=>({
         Reflect.defineMetadata(key, ownHandlerList(key, prototype).filter((entry)=>!inheritedFor(inherited, method)(entry)), prototype);
     }
 }
-/** The class's own command map, started from a copy of the inherited one, for the same reason. */ function ownCommandMap(target) {
+/**
+ * The class's own command map, started from a copy of the inherited one, for the same reason. Keyed by command name
+ * without a prototype, so a command named like an inherited key, such as `constructor`, is a key like any other.
+ */ function ownCommandMap(target) {
     const own = Reflect.getOwnMetadata(META.commands, target);
     if (own) return own;
     const inherited = Reflect.getMetadata(META.commands, target) ?? {};
-    return Object.fromEntries(Object.entries(inherited).map(([name, metas])=>[
-            name,
-            [
-                ...metas
-            ]
-        ]));
+    const copy = Object.create(null);
+    for (const [name, metas] of Object.entries(inherited))copy[name] = [
+        ...metas
+    ];
+    return copy;
+}
+/** The handlers a command map holds for `name`: its own entry only, never one `Object.prototype` holds. */ function commandsNamed(map, name) {
+    return map && Object.hasOwn(map, name) ? map[name] : [];
 }
 function MessageHandler(pattern, options = {}) {
     return declaring(function(target, propertyKey) {
@@ -179,12 +185,24 @@ function ReactionHandler(emojiOrSettings, settings = {}) {
 }
 // `{name}`, or `{name:type}` with the type read as far as the brace, so a type no segment can hold is named
 const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
+// The whole of a brace pair that is a param, as PLACEHOLDER_PATTERN reads one
+const WHOLE_PLACEHOLDER = new RegExp(`^${PLACEHOLDER_PATTERN.source}$`);
+/**
+ * Why a pattern's brace pairs that aren't params are matched as literal text, or undefined when it has none: a
+ * param's name is ASCII letters, digits and _, so `{café}` is text.
+ */ function literalBraces(pattern) {
+    const braces = (pattern.match(/\{[^{}]*}/g) ?? []).filter((brace)=>!WHOLE_PLACEHOLDER.test(brace));
+    if (braces.length === 0) return undefined;
+    const one = braces.length === 1;
+    return `${braces.join(', ')} ${one ? "isn't a param" : "aren't params"}, since a param's name is ASCII letters, digits and _; ` + `${one ? 'it is' : 'they are'} matched as literal text.`;
+}
 /** The character a parameter will not cross, so one pattern segment maps to one value. */ const PARAM_SEPARATOR = '/';
+/** The longest customId Discord accepts; the shortest is one character. */ const MAX_CUSTOM_ID_LENGTH = 100;
 /** Escapes a literal stretch of a pattern so only placeholders stay meaningful. */ const escapeLiteral = (literal)=>literal.replace(/[/\\^$*+?.()|[\]{}]/g, '\\$&');
 /**
- * Compiles a pattern into a regex, its parameter names, their types and its 4.1 specificity. A `{name}` takes a
- * whole `/`-separated segment, so a uuid is captured whole and `profile/{uuid}` never overlaps
- * `profile/{uuid}/{id}`; a param that shares a segment with literal text is refused.
+ * Compiles a pattern into a regex, its parameter names, their types, its 4.1 specificity and the length of the
+ * shortest customId it matches. A `{name}` takes a whole `/`-separated segment, so a uuid is captured whole and
+ * `profile/{uuid}` never overlaps `profile/{uuid}/{id}`; a param that shares a segment with literal text is refused.
  */ function createRegexFromPattern(pattern) {
     const params = [];
     // By the param's own name, so one named like an inherited key, such as `__proto__`, keeps its type
@@ -205,6 +223,13 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
         if (literal !== '' && !literal.endsWith(PARAM_SEPARATOR) || after !== undefined && after !== PARAM_SEPARATOR) {
             throw refuse(new Error(`Invalid pattern "${pattern}": {${param}} must occupy a whole segment, so it has to be ` + `preceded and followed by "${PARAM_SEPARATOR}" or by the ends of the pattern. ` + `Write "a${PARAM_SEPARATOR}{${param}}" rather than "a-{${param}}".`));
         }
+        // A regex group's name, which the engine would refuse with the compiled regex in place of the pattern
+        if (params.includes(param)) {
+            throw refuse(new Error(`Invalid pattern "${pattern}": {${param}} appears twice; give each param its own name.`));
+        }
+        if (/^\d/.test(param)) {
+            throw refuse(new Error(`Invalid pattern "${pattern}": {${param}} starts with a digit; start a param's name with a letter or _.`));
+        }
         if (type !== undefined) {
             if (!isSegmentType(type)) throw refuse(new Error(`Invalid pattern "${pattern}": ${segmentTypeProblem(param, type)}`));
             if (choicesOf(type)?.includes('')) {
@@ -228,11 +253,13 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
         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
     return {
         regex,
         params,
         types: lookupTable(types),
-        specificity
+        specificity,
+        shortest: literalLength + params.length
     };
 }
 /** Why a `{name:type}` cannot type a customId segment, which holds text the bot wrote, with no message to read. */ function segmentTypeProblem(param, type) {
@@ -302,7 +329,6 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
  */ function Command(name, builderOrType) {
     const commandName = typeof name === 'string' ? name : name.pattern;
     return declaring(function(target, propertyKey, _descriptor) {
-        var _commands, _commandName;
         refuseOnClass('@Command', target, propertyKey);
         const originalMethod = _descriptor.value;
         if (!originalMethod) {
@@ -310,7 +336,7 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
         }
         // Wrap original method for interaction type validation
         const declaredAs = typeof builderOrType === 'function' ? builderOrType.name : `CommandType.${builderOrType}`;
-        _descriptor.value = function(interaction, params) {
+        const checked = function(interaction, params) {
             if (!matchesCommandType(commandType, interaction)) {
                 throw new Error(`${target.constructor.name}.${propertyKey}: @Command('${commandName}', ${declaredAs}) takes ` + `${interactionClassName(commandType)}${givenInstead(interaction)}.`);
             }
@@ -319,6 +345,7 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
                 params
             ]);
         };
+        _descriptor.value = wrapsMethod(checked, originalMethod);
         // This class's own map, inherited routes included
         const commands = ownCommandMap(target);
         let builderInstance;
@@ -354,7 +381,7 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
                     }));
                 }
                 // discord.js builders validate as they are set, and their errors name neither the command nor the field.
-                throw refuse(new Error(`${where}: ${builderOrType.name} could not build "${commandName}": ${detail}. Check its names, descriptions and ` + `localizations, which Discord limits to 32 and 100 characters.`, {
+                throw refuse(new Error(`${where}: ${builderOrType.name} could not build "${commandName}": ${detail}. Check its names, descriptions and ` + 'localizations, which Discord limits to 32 characters for a name and 100 for a description. A name is letters, ' + 'numbers, `-` and `_`, lowercase where the script has case, and without spaces, in every locale.', {
                     cause: error
                 }));
             }
@@ -374,6 +401,9 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
             commandType = builderOrType;
         }
         if (isCustomIdRouted(commandType)) {
+            // A route warned as it was made
+            const braces = typeof name === 'string' ? literalBraces(commandName) : undefined;
+            if (braces) logger.warn(`${target.constructor.name}.${propertyKey}: in the pattern "${commandName}", ${braces}`);
             let pattern;
             try {
                 pattern = createRegexFromPattern(commandName);
@@ -385,6 +415,11 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
             regex = pattern.regex;
             dynamicParams = pattern.params;
             specificity = pattern.specificity;
+            // Warned rather than refused, so a bot that carries such a handler still starts
+            if (pattern.shortest === 0 || pattern.shortest > MAX_CUSTOM_ID_LENGTH) {
+                const length = pattern.shortest === 0 ? 'the pattern is empty' : `its shortest is ${pattern.shortest} characters`;
+                logger.warn(`${target.constructor.name}.${propertyKey}: the pattern "${commandName}" matches no customId: Discord's customIds ` + `are 1 to ${MAX_CUSTOM_ID_LENGTH} characters, and ${length}, so the handler never runs.`);
+            }
         }
         const declared = {
             methodName: propertyKey,
@@ -401,8 +436,9 @@ const PLACEHOLDER_PATTERN = /\{(\w+)(?::([^}/]*))?}/g;
             }
         };
         // One the class inherits for this method and route is replaced where it stands, so this one's options apply
-        const metas = (_commands = commands)[_commandName = commandName] ?? (_commands[_commandName] = []);
-        const inherited = getCommandMap(Object.getPrototypeOf(target))?.[commandName] ?? [];
+        if (!Object.hasOwn(commands, commandName)) commands[commandName] = [];
+        const metas = commands[commandName];
+        const inherited = commandsNamed(getCommandMap(Object.getPrototypeOf(target)), commandName);
         const replaced = metas.findIndex((meta)=>inherited.includes(meta) && meta.methodName === propertyKey && meta.type === commandType);
         if (replaced === -1) metas.push(declared);
         else metas[replaced] = declared;
@@ -572,4 +608,4 @@ const narrowness = (type)=>choicesOf(type) ? 6 : NARROWNESS[type];
     return values.every((value)=>value !== undefined) ? values.join(PARAM_SEPARATOR) : undefined;
 }
 
-export { Autocomplete, Command, MessageHandler, PARAM_SEPARATOR, ReactionHandler, createRegexFromPattern, dropInheritedRoutes, getAutocompleteHandlers, getCommandMap, getDeclaredRoutes, getHandlerRoutes, getMessageHandlers, getReactionHandlers, matchesEmoji, ownHandlerList, paramNarrowness, patternShape, sharedCustomId };
+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 };

package/dist/esm/decorator/cooldown.decorator.js

@@ -1,5 +1,7 @@
 import 'reflect-metadata';
+import { Logger } from '../common/logger.js';
 import { declaring, refuse, decoratedName } from '../util/refusal.util.js';
+import { describeValue } from '../util/value.util.js';
 import { META } from '../util/metadata-keys.js';
 
 function Cooldown(options) {
@@ -14,6 +16,7 @@ function Cooldown(options) {
         // Checked where it applies, so the refusal names the handler or controller
         const problem = cooldownProblem(seconds, uses, per, by);
         if (problem) throw refuse(new Error(`${decoratedName(target, propertyKey)}: ${problem}`));
+        for (const warning of cooldownWarnings(options))logger.warn(`${decoratedName(target, propertyKey)}: ${warning}`);
         // Decorators apply bottom-up; prepending keeps them in the order they read.
         if (propertyKey === undefined) {
             const existing = Reflect.getOwnMetadata(META.classCooldowns, target) ?? [];
@@ -34,6 +37,20 @@ function Cooldown(options) {
  * The longest window, in seconds: half the furthest time a `Date` holds, 8.64e15 ms, so the moment a wait ends, now
  * plus the window, is a real date for a refusal's `retryAt` and the time it shows.
  */ const MAX_SECONDS = 4320000000000;
+const logger = new Logger('Cooldown');
+/**
+ * What a cooldown's options get wrong that the types refuse, yet still counts: a `bypass` that is not a function, which
+ * fails every call, and a `seconds` that is not a number, read as one. A falsy `bypass` means none.
+ */ function cooldownWarnings({ seconds, bypass }) {
+    const warnings = [];
+    if (bypass && typeof bypass !== 'function') {
+        warnings.push(`@Cooldown takes bypass as a function of the call, returning whether the call skips the cooldown, not ${describeValue(bypass)}; ` + 'every call it counts fails with it. In the next major version (5.0) it is refused.');
+    }
+    if (typeof seconds !== 'number') {
+        warnings.push(`@Cooldown takes seconds as a number, not ${describeValue(seconds)}, which it counts as a window of ` + `${Math.round(seconds * 1000)} ms. In the next major version (5.0) it is refused.`);
+    }
+    return warnings;
+}
 /** Why a cooldown's options cannot be counted, or undefined when they can. */ function cooldownProblem(seconds, uses, per, by) {
     if (!(seconds >= 0.001 && seconds <= MAX_SECONDS)) return `@Cooldown needs a number of seconds from 0.001 to ${MAX_SECONDS}, not ${seconds}.`;
     if (!Number.isInteger(uses) || uses < 1) return `@Cooldown needs a whole number of uses of at least 1, not ${uses}.`;

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

@@ -1,6 +1,7 @@
 import 'reflect-metadata';
 import { handlerMethods, classLevelGuards, consumeDispatchMark, runDirectCall, declaringPrototype, classChain } 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';
@@ -34,10 +35,10 @@ import { declaring, deprecatedOnMethod } from '../util/refusal.util.js';
  * which has already run the guards, passes through every wrapper.
  */ function applyGuards(descriptor, prototype, propertyKey) {
     const originalMethod = descriptor.value;
-    descriptor.value = async function(...args) {
+    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);
 }

package/dist/esm/package.json.js

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

package/dist/esm/testing/catalog.js

@@ -1,7 +1,15 @@
 import { CATALOGS, placeholderNames } from '../common/translator.js';
 import { MEOCORD_MESSAGES } from '../common/meocord-messages.js';
 
-const isPlural = (value)=>typeof value === 'object' && value !== null && typeof value.other === 'string';
+const PLURAL_CATEGORIES = new Set([
+    'zero',
+    'one',
+    'two',
+    'few',
+    'many',
+    'other'
+]);
+/** A plural: an object whose every key is a plural category, as the translator's types read one; any other is a group. */ const isPlural = (value)=>typeof value === 'object' && value !== null && Object.keys(value).length > 0 && Object.keys(value).every((key)=>PLURAL_CATEGORIES.has(key));
 /** Every message key of a catalog, and whether it is a plural. */ function leaves(catalog, prefix = '') {
     return Object.entries(catalog).flatMap(([name, value])=>{
         const key = `${prefix}${name}`;
@@ -20,8 +28,9 @@ const isPlural = (value)=>typeof value === 'object' && value !== null && typeof
         return leaves(value, `${key}.`);
     });
 }
-function at(catalog, key) {
-    return key.split('.').reduce((current, part)=>current?.[part], catalog);
+/** 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 !== '';
+/** 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);
 }
 const MEOCORD_KEYS = new Set(leaves(MEOCORD_MESSAGES).map(({ key })=>key));
 const isMeoCordKey = (key)=>key.startsWith('meocord.');
@@ -44,9 +53,11 @@ 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, and each `{param}` a translation uses that the message it translates doesn't take. 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.
+ * 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.
  *
  * @remarks
  * MeoCord's own texts, a catalog's `meocord` group, fall back to English by design, so only a key MeoCord lacks, and
@@ -93,12 +104,17 @@ 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) {
+            if (message === undefined || message === '') {
                 problems.push(`missing ${key}`);
                 continue;
             }
-            if (plural && isPlural(message)) {
-                const missing = categories.filter((category)=>typeof message[category] !== 'string');
+            // A translation of another shape than the default's can't be read as it: a text for a plural, or the reverse
+            if (plural !== isPlural(message) || !plural && typeof message !== 'string') {
+                problems.push(`${key} should be a ${plural ? 'plural' : 'text'}, as the default is`);
+                continue;
+            }
+            if (plural) {
+                const missing = categories.filter((category)=>!isText(message[category]));
                 if (missing.length > 0) problems.push(`${key} lacks ${missing.join(', ')}`);
             }
             const original = at(defaultCatalog, key);
@@ -106,7 +122,7 @@ 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) problems.push(`missing ${key}`);
+            for (const key of MEOCORD_KEYS)if (at(catalog, key) === undefined || at(catalog, key) === '') problems.push(`missing ${key}`);
         }
         for (const { key } of leaves(catalog)){
             if (isMeoCordKey(key)) {

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

@@ -12,8 +12,9 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
  *
  * @remarks
  * The cases cover what a shared store most often gets wrong: a sliding window rather than fixed buckets,
- * `retryAfterMs` from the oldest call still in the window, calls in the same millisecond kept apart, and concurrent
- * calls at the limit where exactly one may pass. They use real time, with windows short enough that the suite takes
+ * `retryAfterMs` until a use frees up, from the oldest of the newest `uses` calls in the window, calls in the same
+ * millisecond kept apart, concurrent calls at the limit where exactly one may pass, a batch refusal that names the
+ * longest wait, and a release that frees only the call it gave back. They use real time, with windows short enough that the suite takes
  * a few seconds and margins wide enough that a correct store passes when timers fire late, as on a busy CI runner,
  * and each case counts under keys of its own. Each window is a whole number of milliseconds, as
  * `@Cooldown` gives a store: it rounds its `seconds` to the millisecond.
@@ -88,6 +89,30 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
             expect(retryAfterMs).toBeLessThanOrEqual(limit.windowMs - (secondSent - firstDone) + CLOCK_SLACK_MS);
             expect(retryAfterMs).toBeGreaterThanOrEqual(limit.windowMs - (thirdDone - firstSent) - CLOCK_SLACK_MS);
         });
+        // @Cooldown keeps the calls counted so far when a limit is lowered, so a key can hold more calls than `uses`
+        test('counts retryAfterMs from the oldest of the newest `uses` calls when a lowered limit leaves more in the window', async (store)=>{
+            const windowMs = 2000;
+            for(let call = 0; call < 3; call += 1)await store.consume(key('lowered'), {
+                uses: 5,
+                windowMs
+            });
+            await sleep(1000);
+            const newerSent = Date.now();
+            for(let call = 0; call < 2; call += 1)await store.consume(key('lowered'), {
+                uses: 5,
+                windowMs
+            });
+            const { allowed, retryAfterMs } = await store.consume(key('lowered'), {
+                uses: 2,
+                windowMs
+            });
+            const refusedDone = Date.now();
+            expect(allowed).toBe(false);
+            // A use frees up when the older of the two newest calls leaves the window; counted from the oldest call, it would
+            // be a second sooner
+            expect(retryAfterMs).toBeGreaterThanOrEqual(windowMs - (refusedDone - newerSent) - CLOCK_SLACK_MS);
+            expect(retryAfterMs).toBeLessThanOrEqual(windowMs + CLOCK_SLACK_MS);
+        });
         test('counts each key on its own', async (store)=>{
             const limit = {
                 uses: 1,
@@ -149,6 +174,41 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
             expect(refused.retryAfterMs).toBeGreaterThan(short.windowMs);
             expect(refused.retryAfterMs).toBeLessThanOrEqual(long.windowMs);
         });
+        // A refusal names the wait until every cooldown of the batch allows the call; the default consumeMany stops at the first
+        test('names the longest wait when several cooldowns refuse a batch, or with the default consumeMany, the first', async (store)=>{
+            const short = {
+                uses: 1,
+                windowMs: 1000
+            };
+            const long = {
+                uses: 1,
+                windowMs: 2000
+            };
+            const batch = [
+                {
+                    key: key('both-short'),
+                    limit: short
+                },
+                {
+                    key: key('both-long'),
+                    limit: long
+                }
+            ];
+            await store.consume(batch[0].key, short);
+            await store.consume(batch[1].key, long);
+            const refused = await store.consumeMany(batch);
+            expect(refused.allowed).toBe(false);
+            const [blocked, limit] = overridesConsumeMany(store) ? [
+                1,
+                long
+            ] : [
+                0,
+                short
+            ];
+            expect(refused.blocked).toBe(blocked);
+            expect(refused.retryAfterMs).toBeGreaterThan(limit.windowMs - 1000);
+            expect(refused.retryAfterMs).toBeLessThanOrEqual(limit.windowMs);
+        });
         // The default consumeMany counts in order and stops at the first refusal, so the entries before it count
         test('records nothing when one cooldown of a batch refuses it, or with the default consumeMany, counts those before it', async (store)=>{
             const limit = {
@@ -191,10 +251,11 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
             }, ()=>store.consumeMany(batch)));
             expect(verdicts.filter((verdict)=>verdict.allowed).length).toBe(1);
         });
-        // A store without release keeps a counted call counted, as the default consumeMany does
-        test('releases a call it counted when the verdict gives release, or keeps it counted without one', async (store)=>{
+        // A store without release keeps a counted call counted, as the default consumeMany does. Two uses tell a release of
+        // the one call apart from one that frees the key's other calls too
+        test('releases only the call it counted when the verdict gives release, or keeps it counted without one', async (store)=>{
             const limit = {
-                uses: 1,
+                uses: 2,
                 windowMs: 2000
             };
             const entries = [
@@ -207,6 +268,7 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
                     limit
                 }
             ];
+            expect((await store.consumeMany(entries)).allowed).toBe(true);
             const counted = await store.consumeMany(entries);
             expect(counted.allowed).toBe(true);
             if (!counted.release) {