meocord 4.1.2 → 4.2.1

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

@@ -1,9 +1,10 @@
 import 'reflect-metadata';
-import { handlerMethods, classLevelGuards, classChain, consumeDispatchMark, runDirectCall, declaringPrototype } from '../core/guard-runner.js';
+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 { deprecatedOnMethod } from '../util/refusal.util.js';
+import { declaring, deprecatedOnMethod } from '../util/refusal.util.js';
 
 /**
  * Adds guards to a method's class or method list, then republishes the effective list under
@@ -34,10 +35,10 @@ import { 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);
 }
@@ -119,14 +120,14 @@ import { deprecatedOnMethod } from '../util/refusal.util.js';
  * @see {@link UseGuard}
  * @see {@link GuardDeniedError}
  * @see {@link ExecutionContext}
- * @see {@link https://meocord.dev/docs/4.1/guards | Guards}
+ * @see {@link https://meocord.dev/docs/4.2/guards | Guards}
  */ function Guard(options = {}) {
-    return function(target, propertyKey) {
+    return declaring(function(target, propertyKey) {
         if (deprecatedOnMethod('@Guard', target, propertyKey)) return;
         makeInjectable(target);
         defineStageTypes(target, options.types, 'Guard');
         Reflect.defineMetadata(META.guardClass, true, target);
-    };
+    });
 }
 /**
  * Runs guards before a handler, or before every handler of a controller.
@@ -157,10 +158,10 @@ import { deprecatedOnMethod } from '../util/refusal.util.js';
  * @see {@link Guard}
  * @see {@link GuardDeniedError}
  * @see {@link ExecutionContext}
- * @see {@link https://meocord.dev/docs/4.1/guards | Guards}
+ * @see {@link https://meocord.dev/docs/4.2/guards | Guards}
  */ function UseGuard(...entries) {
     const guards = entries;
-    return function(target, propertyKey, descriptor) {
+    return declaring(function(target, propertyKey, descriptor) {
         const where = propertyKey === undefined ? String(target?.name) : `${target.constructor.name}.${String(propertyKey)}`;
         assertStageEntries('@UseGuard', 'guard', where, guards);
         if (descriptor && propertyKey) {
@@ -185,7 +186,7 @@ import { deprecatedOnMethod } from '../util/refusal.util.js';
                 }
             }
         }
-    };
+    });
 }
 
 export { Guard, UseGuard, guardOwnHandlersWithBaseGuards };

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

@@ -1,5 +1,5 @@
 import { inject } from 'inversify';
-import { refuseOnClass } from '../util/refusal.util.js';
+import { declaring, refuseOnClass } from '../util/refusal.util.js';
 
 /**
  * Injects what a token provides into a constructor parameter.
@@ -24,14 +24,14 @@ import { refuseOnClass } from '../util/refusal.util.js';
  * @category Params
  * @see {@link Service}
  * @see {@link createToken}
- * @see {@link https://meocord.dev/docs/4.1/services | Services}
+ * @see {@link https://meocord.dev/docs/4.2/services | Services}
  */ function Inject(token) {
     const decorate = inject(token);
-    return (target, propertyKey, parameterIndex)=>{
+    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');
         decorate(target, propertyKey, parameterIndex);
-    };
+    });
 }
 
 export { Inject };

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 { refuseOnMethod } from '../util/refusal.util.js';
+import { declaring, refuseOnMethod } from '../util/refusal.util.js';
 
 /**
  * Marks a class as an interceptor, which wraps a handler to act before and after it.
@@ -36,13 +36,13 @@ import { refuseOnMethod } from '../util/refusal.util.js';
  * @group Decorators
  * @category Pipeline stages
  * @see {@link UseInterceptor}
- * @see {@link https://meocord.dev/docs/4.1/interceptors | Interceptors}
+ * @see {@link https://meocord.dev/docs/4.2/interceptors | Interceptors}
  */ function Interceptor(options = {}) {
-    return function(target, propertyKey) {
+    return declaring(function(target, propertyKey) {
         refuseOnMethod('@Interceptor', target, propertyKey);
         makeInjectable(target);
         defineStageTypes(target, options.types, 'Interceptor');
-    };
+    });
 }
 /**
  * Runs interceptors around a handler, or around every handler of a controller.
@@ -73,9 +73,9 @@ import { refuseOnMethod } from '../util/refusal.util.js';
  * @group Decorators
  * @category Pipeline stages
  * @see {@link Interceptor}
- * @see {@link https://meocord.dev/docs/4.1/interceptors | Interceptors}
+ * @see {@link https://meocord.dev/docs/4.2/interceptors | Interceptors}
  */ function UseInterceptor(...interceptors) {
-    return function(target, propertyKey) {
+    return declaring(function(target, propertyKey) {
         const where = propertyKey === undefined ? target.name : `${target.constructor.name}.${String(propertyKey)}`;
         assertStageEntries('@UseInterceptor', 'interceptor', where, interceptors);
         // Decorators apply bottom-up, so a higher decorator's interceptors go first, as with @UseGuard.
@@ -92,7 +92,7 @@ import { refuseOnMethod } from '../util/refusal.util.js';
                 ...existing
             ], target, propertyKey);
         }
-    };
+    });
 }
 
 export { Interceptor, UseInterceptor };

package/dist/esm/decorator/observer.decorator.js

@@ -1,7 +1,7 @@
 import 'reflect-metadata';
 import { makeInjectable } from '../util/injectable.util.js';
 import { defineStageTypes } from '../core/stage-scope.js';
-import { refuseOnMethod, refuse } from '../util/refusal.util.js';
+import { declaring, refuseOnMethod, refuse } from '../util/refusal.util.js';
 import { META } from '../util/metadata-keys.js';
 
 /**
@@ -35,9 +35,9 @@ import { META } from '../util/metadata-keys.js';
  * @pipeline observers-settled once the call has settled and been answered, however it ended
  * @group Decorators
  * @category Pipeline stages
- * @see {@link https://meocord.dev/docs/4.1/observers | Observers}
+ * @see {@link https://meocord.dev/docs/4.2/observers | Observers}
  */ function Observer(options = {}) {
-    return function(target, propertyKey) {
+    return declaring(function(target, propertyKey) {
         refuseOnMethod('@Observer', target, propertyKey);
         if (typeof target.prototype.onSettled !== 'function') {
             throw refuse(new Error(`${target.name}: an @Observer needs an onSettled method, and it has none.`));
@@ -45,7 +45,7 @@ import { META } from '../util/metadata-keys.js';
         makeInjectable(target);
         defineStageTypes(target, options.types, 'Observer');
         Reflect.defineMetadata(META.observerClass, true, target);
-    };
+    });
 }
 
 export { Observer };

package/dist/esm/decorator/service.decorator.js

@@ -1,6 +1,6 @@
 import 'reflect-metadata';
 import { makeInjectable } from '../util/injectable.util.js';
-import { deprecatedOnMethod } from '../util/refusal.util.js';
+import { declaring, deprecatedOnMethod } from '../util/refusal.util.js';
 
 /**
  * Marks a class as a service, which controllers and other services inject by its type.
@@ -27,12 +27,12 @@ import { deprecatedOnMethod } from '../util/refusal.util.js';
  * @group Decorators
  * @category App
  * @see {@link Inject}
- * @see {@link https://meocord.dev/docs/4.1/services | Services}
+ * @see {@link https://meocord.dev/docs/4.2/services | Services}
  */ function Service() {
-    return function(target, propertyKey) {
+    return declaring(function(target, propertyKey) {
         if (deprecatedOnMethod('@Service', target, propertyKey)) return;
         makeInjectable(target);
-    };
+    });
 }
 
 export { Service };

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 { refuse } from '../util/refusal.util.js';
+import { declaring, refuse } from '../util/refusal.util.js';
 import { META } from '../util/metadata-keys.js';
 
 /**
@@ -35,7 +35,7 @@ import { META } from '../util/metadata-keys.js';
  * @group Decorators
  * @category Controllers
  */ function UseTheme(theme) {
-    return function(target, propertyKey) {
+    return declaring(function(target, propertyKey) {
         const onClass = propertyKey === undefined;
         const owner = onClass ? target : target.constructor;
         const where = `${owner.name}${onClass ? '' : `.${String(propertyKey)}`}: @UseTheme`;
@@ -47,7 +47,7 @@ import { META } from '../util/metadata-keys.js';
         if (onClass) Reflect.defineMetadata(key, layer, target);
         else Reflect.defineMetadata(key, layer, target, propertyKey);
         THEMED_CLASSES.add(owner);
-    };
+    });
 }
 
 export { UseTheme };

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 { refuseOnMethod, refuseOnClass, refuse } from '../util/refusal.util.js';
+import { declaring, refuseOnClass, refuse, refuseOnMethod } from '../util/refusal.util.js';
 import { META } from '../util/metadata-keys.js';
 
 /**
@@ -37,9 +37,9 @@ import { META } from '../util/metadata-keys.js';
  * @category Pipeline stages
  * @see {@link UsePipe}
  * @see {@link ValidationError}
- * @see {@link https://meocord.dev/docs/4.1/validation | Validation and pipes}
+ * @see {@link https://meocord.dev/docs/4.2/validation | Validation and pipes}
  */ function Validate(schema, options = {}) {
-    return function(target, propertyKey, _descriptor) {
+    return declaring(function(target, propertyKey, _descriptor) {
         refuseOnClass('@Validate', target, propertyKey);
         // Checked where it applies, so the refusal names the handler
         if (typeof schema?.['~standard']?.validate !== 'function') {
@@ -57,7 +57,7 @@ import { META } from '../util/metadata-keys.js';
             pipes: options.pipes ?? {}
         };
         Reflect.defineMetadata(META.methodValidation, metadata, target, propertyKey);
-    };
+    });
 }
 /**
  * Runs pipes on one value of a handler's input, to turn it into what the handler works with.
@@ -89,9 +89,9 @@ import { META } from '../util/metadata-keys.js';
  * @category Pipeline stages
  * @see {@link Pipe}
  * @see {@link Validate}
- * @see {@link https://meocord.dev/docs/4.1/validation | Validation and pipes}
+ * @see {@link https://meocord.dev/docs/4.2/validation | Validation and pipes}
  */ function UsePipe(key, ...pipes) {
-    return function(target, propertyKey, _descriptor) {
+    return declaring(function(target, propertyKey, _descriptor) {
         refuseOnClass('@UsePipe', target, propertyKey);
         assertStageEntries('@UsePipe', 'pipe', `${target.constructor.name}.${propertyKey}`, pipes);
         // Decorators apply bottom-up, so a higher @UsePipe's pipes go first, in the order they read.
@@ -103,7 +103,7 @@ import { META } from '../util/metadata-keys.js';
                 })),
             ...existing
         ], target, propertyKey);
-    };
+    });
 }
 /**
  * Marks a class as a pipe, which turns one input value into what the handler works with.
@@ -129,12 +129,12 @@ import { META } from '../util/metadata-keys.js';
  * @group Decorators
  * @category Pipeline stages
  * @see {@link UsePipe}
- * @see {@link https://meocord.dev/docs/4.1/validation | Validation and pipes}
+ * @see {@link https://meocord.dev/docs/4.2/validation | Validation and pipes}
  */ function Pipe() {
-    return function(target, propertyKey) {
+    return declaring(function(target, propertyKey) {
         refuseOnMethod('@Pipe', target, propertyKey);
         makeInjectable(target);
-    };
+    });
 }
 
 export { Pipe, UsePipe, Validate };

package/dist/esm/package.json.js

@@ -1,4 +1,4 @@
-var version = "4.1.2";
+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
@@ -79,7 +90,7 @@ const isMeoCordKey = (key)=>key.startsWith('meocord.');
  * @group Testing
  * @category Inspection
  * @see {@link createTranslator}
- * @see {@link https://meocord.dev/docs/4.1/localisation | Localisation}
+ * @see {@link https://meocord.dev/docs/4.2/localisation | Localisation}
  */ function expectCompleteCatalog(translator, options = {}) {
     const catalogs = translator[CATALOGS];
     if (!catalogs) throw new Error('expectCompleteCatalog takes a translator made by createTranslator.');
@@ -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

@@ -3,6 +3,7 @@ import { CooldownStore } 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));
+/** How far a store's clock may run from this process's, as a store's server keeps its own time. */ const CLOCK_SLACK_MS = 50;
 /**
  * Checks that a `CooldownStore` counts calls as `MemoryCooldownStore` does, as a suite of test cases.
  *
@@ -11,9 +12,11 @@ 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
- * a few seconds, and each case counts under keys of its own. Each window is a whole number of milliseconds, as
+ * `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.
  *
  * @param name - What the store is called in the report.
@@ -30,7 +33,7 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
  * @group Testing
  * @category Inspection
  * @see {@link CooldownStore}
- * @see {@link https://meocord.dev/docs/4.1/recipes/cooldown-stores | Cooldown stores}
+ * @see {@link https://meocord.dev/docs/4.2/recipes/cooldown-stores | Cooldown stores}
  */ function testCooldownStore(name, factory, { describe, it, expect }) {
     const run = randomUUID();
     const key = (label)=>`meocord-suite:${run}:${label}`;
@@ -53,32 +56,62 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
             expect(refused.retryAfterMs).toBeLessThanOrEqual(limit.windowMs);
         });
         test('slides its window: a call is allowed once the oldest leaves it, not when a bucket resets', async (store)=>{
+            // A second between calls, in a 2 s window, leaves room for a timer that fires late on a busy runner
             const limit = {
                 uses: 2,
-                windowMs: 500
+                windowMs: 2000
             };
             await store.consume(key('sliding'), limit);
-            await sleep(250);
+            await sleep(1000);
             await store.consume(key('sliding'), limit);
             const refused = await store.consume(key('sliding'), limit);
             expect(refused.allowed).toBe(false);
             await sleep(refused.retryAfterMs + 40);
-            // The first call has left the window; the second, 250ms younger, still holds its use.
+            // The first call has left the window; the second, a second younger, still holds its use.
             expect((await store.consume(key('sliding'), limit)).allowed).toBe(true);
             expect((await store.consume(key('sliding'), limit)).allowed).toBe(false);
         });
         test('counts retryAfterMs from the oldest call still in the window', async (store)=>{
             const limit = {
                 uses: 2,
-                windowMs: 1000
+                windowMs: 2000
             };
+            const firstSent = Date.now();
             await store.consume(key('retry'), limit);
-            await sleep(300);
+            const firstDone = Date.now();
+            await sleep(1000);
+            const secondSent = Date.now();
             await store.consume(key('retry'), limit);
-            // From the oldest call, about 700ms remain; from the newest, about 1000ms would.
             const { retryAfterMs } = await store.consume(key('retry'), limit);
-            expect(retryAfterMs).toBeGreaterThan(limit.windowMs - 600);
-            expect(retryAfterMs).toBeLessThanOrEqual(limit.windowMs - 200);
+            const thirdDone = Date.now();
+            // What is left of the oldest call's window, by the times measured around each call, as timers may fire late;
+            // counted from the newest call, nearly the whole window would be left instead
+            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 = {
@@ -141,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 = {
@@ -183,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 = [
@@ -199,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) {