meocord 4.1.2 → 4.2.0

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

@@ -1,9 +1,9 @@
 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 { 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
@@ -119,14 +119,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 +157,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 +185,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.0";
 var engines = {
 	node: ">=22.13"
 };

package/dist/esm/testing/catalog.js

@@ -79,7 +79,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.');

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.
  *
@@ -13,7 +14,8 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
  * 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
+ * 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 +32,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 +55,38 @@ 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);
         });
         test('counts each key on its own', async (store)=>{
             const limit = {

package/dist/esm/testing/discord-defaults.js

@@ -1,5 +1,6 @@
-import { GuildPremiumTier, GuildVerificationLevel, GuildNSFWLevel, Locale, Guild, ClientUser, User, GuildMember, Role, Collection, MessageType, Message, CommandInteraction, AutocompleteInteraction, GuildChannel, BaseInteraction, ChannelType, TextChannel, NewsChannel, VoiceChannel, ForumChannel, MediaChannel, ThreadChannel, DMChannel, BaseChannel, Client, BaseGuild, SnowflakeUtil, PermissionsBitField } from 'discord.js';
-import { memberRoles, createMockUser, createMockGuild } from './mock-interaction.js';
+import { Message, Guild, TextChannel, ThreadChannel, GuildChannel, BaseGuildVoiceChannel, MessageReaction, GuildPremiumTier, GuildVerificationLevel, GuildNSFWLevel, Locale, ClientUser, User, GuildMember, Role, Collection, MessageType, CommandInteraction, AutocompleteInteraction, PermissionsBitField, BaseInteraction, ChannelType, NewsChannel, VoiceChannel, ForumChannel, MediaChannel, DMChannel, BaseChannel, Client, BaseGuild, SnowflakeUtil } from 'discord.js';
+import { createMockChannel, createMockGuild, memberRoles, createMockUser, isRawMember } from './mock-interaction.js';
+import { strictMocks } from './strict-mocks.js';
 
 /** A permission set with none, frozen as discord.js freezes the ones it gives. */ const noPermissions = ()=>new PermissionsBitField().freeze();
 /** A property discord.js computes from the others: its own getter runs, reading the mock's values. */ const REAL_GETTER = Symbol('real getter');
@@ -123,7 +124,14 @@ const snowflake = ()=>SnowflakeUtil.generate().toString();
         version: ()=>1,
         context: ()=>null,
         // What Discord sends with an interaction in a server, the member's permissions there; typed for a cached one
-        memberPermissions: (interaction)=>interaction.guildId && interaction.member instanceof GuildMember ? interaction.member.permissions : null,
+        memberPermissions: (interaction)=>{
+            const { guildId } = interaction;
+            const member = interaction.member;
+            if (!guildId) return null;
+            if (member instanceof GuildMember) return member.permissions;
+            // A raw member's permissions are the string Discord sends, read as discord.js reads them
+            return isRawMember(member) && !interaction.guild ? new PermissionsBitField(BigInt(member.permissions)).freeze() : null;
+        },
         // The bot's permissions where the interaction was made: its member's in the channel, or none outside a server
         appPermissions: (interaction)=>{
             const { guild, channel } = interaction;
@@ -184,10 +192,55 @@ const snowflake = ()=>SnowflakeUtil.generate().toString();
         nameAcronym: REAL_GETTER
     })
 ]);
-/** The default a mock of `target`'s class has for `key`, read from the nearest class that has one. */ function discordDefault(target, key) {
-    for(let proto = Object.getPrototypeOf(target); proto !== null; proto = Object.getPrototypeOf(proto)){
-        const found = DEFAULTS.get(proto)?.[key];
-        if (found !== undefined) return found;
+/**
+ * What strict mocks also read as Discord sends it, for discord.js's getters that read it: a server for a channel or
+ * thread made without one, a thread's parent text channel in it, and data that is otherwise a placeholder.
+ */ const STRICT_DEFAULTS = new Map([
+    defaultsOf(Message, {
+        content: ()=>''
+    }),
+    defaultsOf(Guild, {
+        rulesChannelId: ()=>null,
+        publicUpdatesChannelId: ()=>null
+    }),
+    defaultsOf(ThreadChannel, {
+        guild: ()=>createMockGuild(),
+        guildId: (thread)=>thread.guild.id,
+        parentId: (thread)=>{
+            const parent = createMockChannel(TextChannel, {
+                guild: thread.guild
+            });
+            thread.guild.channels.cache.set(parent.id, parent);
+            return parent.id;
+        },
+        parent: REAL_GETTER,
+        ownerId: snowflake,
+        archived: ()=>false,
+        locked: ()=>false
+    }),
+    defaultsOf(GuildChannel, {
+        guild: ()=>createMockGuild()
+    }),
+    // Full once its members reach a user limit, which a voice channel has none of unless given one
+    defaultsOf(BaseGuildVoiceChannel, {
+        userLimit: ()=>0,
+        full: REAL_GETTER
+    }),
+    defaultsOf(MessageReaction, {
+        count: ()=>1
+    })
+]);
+/** The default a mock of `target`'s class has for `key`, read from the nearest class that has one, strict ones first. */ function discordDefault(target, key) {
+    for (const defaults of strictMocks() ? [
+        STRICT_DEFAULTS,
+        DEFAULTS
+    ] : [
+        DEFAULTS
+    ]){
+        for(let proto = Object.getPrototypeOf(target); proto !== null; proto = Object.getPrototypeOf(proto)){
+            const found = defaults.get(proto)?.[key];
+            if (found !== undefined) return found;
+        }
     }
     return undefined;
 }

package/dist/esm/testing/index.js

@@ -1,6 +1,8 @@
 export { MeoCordTestingModule, TestingModule, TestingModuleBuilder } from './meocord-testing-module.js';
-export { createChatInputOptions, createMock, createMockChannel, createMockClient, createMockGuild, createMockInteraction, createMockMember, createMockMessage, createMockUser } from './mock-interaction.js';
-export { clearAllMocks, createMockFn, isMockFunction, resetAllMocks } from './mock-fn.js';
+export { createChatInputOptions, createMock, createMockChannel, createMockClient, createMockGuild, createMockInteraction, createMockMember, createMockMessage, createMockRawMember, createMockUser } from './mock-interaction.js';
+export { clearAllMocks, createMockFn, isMockFunction, resetAllMocks, useMockFn } from './mock-fn.js';
+export { useStrictMocks } from './strict-mocks.js';
+export { reportAllStartupErrors } from './startup-errors.js';
 export { findRouteConflicts, resolveRoute } from './routing.js';
 export { createModalFields } from './modal-fields.js';
 export { expectCompleteCatalog } from './catalog.js';

package/dist/esm/testing/inspect-handler.js

@@ -2,7 +2,7 @@ import 'reflect-metadata';
 import { HandlerExecutionContext } from '../common/execution-context.js';
 import { appStages, handlerStages } from '../core/handler-pipeline.js';
 import { handlerCooldowns } from '../core/cooldown-runner.js';
-import { getMessageHandlers } from '../decorator/controller.decorator.js';
+import { getMessageHandlers, getHandlerRoutes, getDeclaredRoutes } from '../decorator/controller.decorator.js';
 import { appObservers } from '../core/observer-runner.js';
 
 /**
@@ -37,7 +37,7 @@ import { appObservers } from '../core/observer-runner.js';
  * @group Testing
  * @category Inspection
  * @see {@link createExecutionContext}
- * @see {@link https://meocord.dev/docs/4.1/testing-recipes | Testing recipes}
+ * @see {@link https://meocord.dev/docs/4.2/testing-recipes | Testing recipes}
  */ function inspectHandler(controller, methodName, options = {}) {
     const context = new HandlerExecutionContext({
         controller,
@@ -46,7 +46,7 @@ import { appObservers } from '../core/observer-runner.js';
     });
     const globals = options.app ? appStages(options.app) : undefined;
     const { guards, interceptors, filters } = handlerStages(controller.prototype, methodName, globals);
-    return {
+    const inspection = {
         controller,
         methodName,
         guards: Object.freeze([
@@ -68,6 +68,23 @@ import { appObservers } from '../core/observer-runner.js';
         get: (metadata)=>context.get(metadata),
         getAll: (metadata)=>context.getAll(metadata)
     };
+    // Read by a test but not compared by toEqual, so an assertion on the result's other fields holds
+    Object.defineProperty(inspection, 'inheritedRoutes', {
+        value: Object.freeze(inheritedRoutesOf(controller.prototype, methodName)),
+        enumerable: false
+    });
+    return inspection;
+}
+/** The routes `methodName` answers that the class declaring it last doesn't declare for it: those it inherits. */ function inheritedRoutesOf(prototype, methodName) {
+    const answered = [
+        ...new Set(getHandlerRoutes(prototype).filter((route)=>route.method === methodName).map((route)=>route.label))
+    ];
+    // The nearest class with its own decorators on the method; a class that only overrides it declares none
+    for(let at = prototype; at && at !== Object.prototype; at = Object.getPrototypeOf(at)){
+        const own = getDeclaredRoutes(at).filter((route)=>route.method === methodName).map((route)=>route.label);
+        if (own.length > 0) return at === prototype ? answered.filter((label)=>!own.includes(label)) : answered;
+    }
+    return [];
 }
 
 export { inspectHandler };