meocord 4.1.1 → 4.2.0

package/dist/cjs/testing/index.cjs

@@ -2,11 +2,11 @@
 
 require('reflect-metadata');
 var inversify = require('inversify');
-var providers = require('../_shared/providers-BMMLp2SN.cjs');
+var providers = require('../_shared/providers-ChvMqnLd.cjs');
 var discord_js = require('discord.js');
 var enum_index = require('../enum/index.cjs');
-var controller_decorator = require('../_shared/controller.decorator-BywwkU9O.cjs');
-var startupRoots = require('../_shared/startup-roots-lFc69AxC.cjs');
+var controller_decorator = require('../_shared/controller.decorator-CRn9kWob.cjs');
+var startupRoots = require('../_shared/startup-roots-CQo8mSP8.cjs');
 var node_crypto = require('node:crypto');
 require('node:async_hooks');
 require('crypto');
@@ -21,7 +21,7 @@ require('dayjs/plugin/utc.js');
 require('dayjs/plugin/timezone.js');
 require('module');
 require('chalk');
-require('../_shared/translate-error-BnM8FbSH.cjs');
+require('../_shared/translate-error-DhDVbT5M.cjs');
 
 // Framework-agnostic mock function, so `meocord/testing` depends on neither jest nor vitest.
 // Both detect it through `_isMockFunction` and read `fn.mock.calls` in their assertions.
@@ -52,12 +52,70 @@ require('../_shared/translate-error-BnM8FbSH.cjs');
 // Every mock createMockFn made, held weakly so the mocks of a finished test can still be collected
 const created = new Set();
 const collected = new FinalizationRegistry((ref)=>created.delete(ref));
+// The runner's factory useMockFn registered, and for each of its mocks how to give back the implementation it was
+// created with, through the runner's own setter, which a mock's behaviour may wrap
+let runnerFactory;
+const restoreImpl = new WeakMap();
+/**
+ * Makes every mock `meocord/testing` creates with the test runner's own mock function, such as Vitest's `vi.fn`.
+ *
+ * Call it once in the runner's setup file. The runner then treats meocord's mocks as its own: its `clearMocks` and
+ * `mockReset` config and `vi.clearAllMocks()` reach them, its matchers read them, and its whole mock API is there.
+ * Without it, mocks are {@link createMockFn}'s own, which jest's and Vitest's `expect` read too.
+ *
+ * @remarks
+ * Each mock starts with the runner's mock holding meocord's behaviour, such as an interaction's replies, as its own
+ * implementation. {@link resetAllMocks} puts that behaviour back where the runner's `mockReset` drops it, as jest's and
+ * bun's do; a runner's own reset-all, such as jest's `resetMocks`, can't, so under jest and bun reset with
+ * {@link resetAllMocks}. node:test's `mock.fn` records calls in a shape of its own, so under node:test leave meocord's
+ * own function in place. Calling it again with the same factory does nothing; another, once a mock exists, throws.
+ *
+ * @param factory - The runner's mock function factory: `vi.fn`, `jest.fn` or bun's `mock`.
+ * @throws Error when a mock already exists from another factory, or when `factory` doesn't make a mock with jest's and
+ *   Vitest's API.
+ *
+ * @example
+ * ```ts
+ * // vitest.setup.ts
+ * import { vi } from 'vitest'
+ *
+ * useMockFn(vi.fn)
+ * ```
+ *
+ * @group Testing
+ * @category Mocks
+ * @see {@link createMockFn}
+ */ function useMockFn(factory) {
+    if (factory === runnerFactory) return;
+    if ([
+        ...created
+    ].some((ref)=>ref.deref() !== undefined)) {
+        throw new Error("useMockFn() goes before any mock is made: a mock made before it keeps meocord's own function, and the two kinds " + "would mix. Call it once, in the test runner's setup file.");
+    }
+    const probe = factory();
+    const api = [
+        'mockImplementation',
+        'mockClear',
+        'mockReset'
+    ];
+    if (!isMockFunction(probe) || !Array.isArray(probe.mock?.calls) || api.some((name)=>typeof probe[name] !== 'function')) {
+        throw new Error("useMockFn() takes a function that makes mocks with jest's and Vitest's API, such as vi.fn, jest.fn or bun's " + "mock. node:test's mock.fn records calls in its own shape, so under node:test leave meocord's own mock function " + 'in place.');
+    }
+    runnerFactory = factory;
+}
+/** Tracks a mock for clearAllMocks and resetAllMocks. */ function track(mockFn) {
+    const ref = new WeakRef(mockFn);
+    created.add(ref);
+    collected.register(mockFn, ref);
+    return mockFn;
+}
 /**
  * Clears the calls every mock from `meocord/testing` has recorded, keeping what each was told to do.
  *
- * Vitest's `clearMocks` and jest's `clearAllMocks()` reach only their own `vi.fn()` and `jest.fn()` mocks. This one
- * covers `createMockFn` and everything built on it, such as `createMockInteraction` and `createMockClient`. To also
- * undo what a test set, use {@link resetAllMocks}.
+ * Vitest's `clearMocks` and jest's `clearAllMocks()` reach only their own `vi.fn()` and `jest.fn()` mocks, and
+ * meocord's too once {@link useMockFn} makes them with the runner's function. This one covers `createMockFn` and
+ * everything built on it, such as `createMockInteraction` and `createMockClient`, either way. To also undo what a test
+ * set, use {@link resetAllMocks}.
  *
  * @example
  * ```ts
@@ -93,13 +151,20 @@ const collected = new FinalizationRegistry((ref)=>created.delete(ref));
  * @category Mocks
  * @see {@link clearAllMocks}
  */ function resetAllMocks() {
-    for (const ref of created)ref.deref()?.mockReset();
+    for (const ref of created){
+        const mockFn = ref.deref();
+        if (!mockFn) continue;
+        mockFn.mockReset();
+        // A runner whose reset drops the implementation the mock was created with, as jest's and bun's do, gets it back
+        restoreImpl.get(mockFn)?.();
+    }
 }
 /**
  * Creates a mock function that jest's and Vitest's `expect` both read.
  *
  * Use it for a function double in code that must not depend on one test runner, such as a shared test helper; in a
- * Vitest test, `vi.fn()` works as well. {@link clearAllMocks} and {@link resetAllMocks} reach it.
+ * Vitest test, `vi.fn()` works as well. {@link clearAllMocks} and {@link resetAllMocks} reach it. Once
+ * {@link useMockFn} registers a runner's function, it returns that runner's mock.
  *
  * @remarks
  * `mockReturnValue`, `mockResolvedValue`, `mockRejectedValue` and `mockImplementation` share one implementation, so
@@ -122,6 +187,14 @@ const collected = new FinalizationRegistry((ref)=>created.delete(ref));
  * @category Mocks
  * @see {@link MockInstance}
  */ function createMockFn(impl) {
+    if (runnerFactory) {
+        const runnerMock = runnerFactory(impl);
+        if (impl) {
+            const setImpl = runnerMock.mockImplementation.bind(runnerMock);
+            restoreImpl.set(runnerMock, ()=>setImpl(impl));
+        }
+        return track(runnerMock);
+    }
     // One persistent implementation and one queue of single-use ones, as in jest and vitest: the
     // four setters share the slot, so the last call wins, and the `*Once` variants share the queue,
     // so they run in declaration order.
@@ -234,10 +307,7 @@ const collected = new FinalizationRegistry((ref)=>created.delete(ref));
         name = n;
         return mockFn;
     };
-    const ref = new WeakRef(mockFn);
-    created.add(ref);
-    collected.register(mockFn, ref);
-    return mockFn;
+    return track(mockFn);
 }
 
 const VISIBLE = new Set([
@@ -279,7 +349,7 @@ const VISIBLE = new Set([
  * @group Testing
  * @category Inspection
  * @see {@link TestingModule}
- * @see {@link https://meocord.dev/docs/4.1/invoke-and-dispatch | Invoke and dispatch}
+ * @see {@link https://meocord.dev/docs/4.2/invoke-and-dispatch | Invoke and dispatch}
  */ function getResponse(interaction) {
     const state = controller_decorator.existingResponse(interaction);
     // A mock records every answer it gets; respond()'s edits through the channel are its own, so they are merged in
@@ -337,6 +407,50 @@ const VISIBLE = new Set([
     }, code, 400, 'POST', 'https://discord.com/api/v10/interactions', {});
 }
 
+// Whether useStrictMocks() is on, and whether a mock was made before it could be
+let strict = false;
+let mockMade = false;
+/** Whether mocks compute discord.js's state, as {@link useStrictMocks} turns on. */ const strictMocks = ()=>strict;
+/** Notes that a mock was made, which useStrictMocks() must come before. */ function noteMockMade() {
+    mockMade = true;
+}
+/**
+ * Has every mock from `meocord/testing` compute the values discord.js computes, where it reads a placeholder otherwise.
+ *
+ * Call it once in the test runner's setup file. A message's `editable`, `deletable`, `pinnable`, `crosspostable`,
+ * `bulkDeletable`, `hasThread` and `partial`, a member's `manageable`, `kickable`, `bannable` and `moderatable`, a
+ * role's `editable`, a channel's and a thread's `viewable`, `manageable`, `deletable`, `joinable` and the rest, and
+ * `partial` on users, channels and reactions then run discord.js's own getters against the mock, and `message.thread`
+ * is `null` when the channel caches no thread under the message's id. No placeholder warning is logged.
+ *
+ * @remarks
+ * Those getters read what a server holds, so strict mocks also have it as Discord sends it: the bot's member is in
+ * the server's member cache from the start, @everyone has the permissions Discord gives it in a new server, and a
+ * channel or thread made without a server has one of its own, a thread with a text channel as its parent. A message
+ * has empty `content`, a thread is neither archived nor locked, and a reaction's `count` is 1. Give the bot's member
+ * a role to let it do more, such as kick a member its role ranks above. A value the test sets on a mock wins over the
+ * computed one. The next major version (5.0) computes these values without the call.
+ *
+ * @throws Error when a mock already exists, which was made without it.
+ *
+ * @example
+ * ```ts
+ * // vitest.setup.ts
+ * useStrictMocks()
+ * ```
+ *
+ * @group Testing
+ * @category Mocks
+ * @see {@link useMockFn}
+ * @see {@link https://meocord.dev/docs/4.2/mocks | Mocks}
+ */ function useStrictMocks() {
+    if (strict) return;
+    if (mockMade) {
+        throw new Error('useStrictMocks() goes before any mock is made: a mock made before it reads placeholders, and the two kinds would ' + "mix. Call it once, in the test runner's setup file.");
+    }
+    strict = true;
+}
+
 /** A permission set with none, frozen as discord.js freezes the ones it gives. */ const noPermissions = ()=>new discord_js.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');
 const snowflake = ()=>discord_js.SnowflakeUtil.generate().toString();
@@ -459,7 +573,14 @@ const snowflake = ()=>discord_js.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 discord_js.GuildMember ? interaction.member.permissions : null,
+        memberPermissions: (interaction)=>{
+            const { guildId } = interaction;
+            const member = interaction.member;
+            if (!guildId) return null;
+            if (member instanceof discord_js.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 discord_js.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;
@@ -520,10 +641,55 @@ const snowflake = ()=>discord_js.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(discord_js.Message, {
+        content: ()=>''
+    }),
+    defaultsOf(discord_js.Guild, {
+        rulesChannelId: ()=>null,
+        publicUpdatesChannelId: ()=>null
+    }),
+    defaultsOf(discord_js.ThreadChannel, {
+        guild: ()=>createMockGuild(),
+        guildId: (thread)=>thread.guild.id,
+        parentId: (thread)=>{
+            const parent = createMockChannel(discord_js.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(discord_js.GuildChannel, {
+        guild: ()=>createMockGuild()
+    }),
+    // Full once its members reach a user limit, which a voice channel has none of unless given one
+    defaultsOf(discord_js.BaseGuildVoiceChannel, {
+        userLimit: ()=>0,
+        full: REAL_GETTER
+    }),
+    defaultsOf(discord_js.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;
 }
@@ -665,6 +831,7 @@ const SKIP = new Set([
     'then'
 ]);
 function stubDeep(instance, externalStubs, onSet) {
+    noteMockMade();
     const stubs = externalStubs ?? new Map();
     const proxy = new Proxy(instance, {
         get (target, prop) {
@@ -705,7 +872,11 @@ function stubDeep(instance, externalStubs, onSet) {
                 const desc = Object.getOwnPropertyDescriptor(proto, key);
                 if (desc !== undefined) {
                     protoValue = desc.value;
-                    if (desc.get && PLACEHOLDER_BOOLEANS.get(proto)?.has(key)) warnBooleanPlaceholder(target, key);
+                    if (desc.get && isPlaceholder(proto, key)) {
+                        // Strict mocks run discord.js's getter, read live; otherwise the placeholder, with a warning once
+                        if (strictMocks()) return Reflect.get(target, prop, proxy);
+                        warnBooleanPlaceholder(target, key);
+                    }
                     break;
                 }
                 proto = Object.getPrototypeOf(proto);
@@ -795,9 +966,18 @@ const REAL_METHODS = new Map([
         ])
     ]
 ]);
+// What strict mocks also run for real: a thread's permissions are its parent channel's, as discord.js reads them
+const STRICT_REAL_METHODS = new Map([
+    [
+        discord_js.ThreadChannel.prototype,
+        new Set([
+            'permissionsFor'
+        ])
+    ]
+]);
 function isRealMethod(target, key) {
     for(let proto = Object.getPrototypeOf(target); proto !== null; proto = Object.getPrototypeOf(proto)){
-        if (REAL_METHODS.get(proto)?.has(key)) return true;
+        if (REAL_METHODS.get(proto)?.has(key) || strictMocks() && STRICT_REAL_METHODS.get(proto)?.has(key)) return true;
     }
     return false;
 }
@@ -857,6 +1037,12 @@ const PLACEHOLDER_BOOLEANS = new Map([
             'joinable'
         ])
     ],
+    [
+        discord_js.VoiceChannel.prototype,
+        new Set([
+            'speakable'
+        ])
+    ],
     [
         discord_js.User.prototype,
         new Set([
@@ -876,11 +1062,18 @@ const PLACEHOLDER_BOOLEANS = new Map([
         ])
     ]
 ]);
+/** Whether `proto`'s getter for `key` is one of those, or a subclass's override of one, such as a voice channel's `joinable`. */ function isPlaceholder(proto, key) {
+    for(; proto !== null; proto = Object.getPrototypeOf(proto)){
+        if (PLACEHOLDER_BOOLEANS.get(proto)?.has(key)) return true;
+    }
+    return false;
+}
 const mockLogger = new controller_decorator.Logger('Mocks');
 function warnBooleanPlaceholder(target, key) {
     const name = Object.getPrototypeOf(target).constructor.name;
-    const variable = name.charAt(0).toLowerCase() + name.slice(1);
-    controller_decorator.warnPlaceholder(mockLogger, `${name}.${key}`, 'the mock computes it as discord.js does', `Set it on the mock, such as ${variable}.${key} = false, to test either way.`);
+    // The class name in camel case, a leading acronym included: dmChannel, guildMember
+    const variable = name.replace(/^[A-Z]+(?=[A-Z][a-z])|^[A-Z]/, (start)=>start.toLowerCase());
+    controller_decorator.warnPlaceholder(mockLogger, `${name}.${key}`, 'the mock computes it as discord.js does', `Set it on the mock, such as ${variable}.${key} = false, to test either way, or call useStrictMocks() to have the mock compute it now.`);
 }
 // The client of a structure made without one: the one its guild has, else one of its own, made once
 const ownClients = new WeakMap();
@@ -1263,22 +1456,13 @@ const isSnowflake = (id)=>typeof id === 'string' && /^\d{1,20}$/.test(id);
     }
 }
 /** Where a mock interaction keeps every answer it got, through respond() or discord.js directly, in order. */ const RESPONSE_LOG = Symbol('response log');
-const ANSWER_METHODS = [
-    'reply',
-    'deferReply',
-    'editReply',
-    'followUp',
-    'deleteReply',
-    'update',
-    'deferUpdate',
-    'showModal'
-];
 /**
- * `mock`, recording each call in `log` as it is made, with what it sent and, once it settles, what it rejected with.
- * `withResponse` is how a call asks discord.js for the message back, not part of what it sends, so it is left out.
- */ function recorded(method, mock, log) {
-    return new Proxy(mock, {
-        apply (target, self, args) {
+ * A mock of an answer method, `impl` its behaviour, that records each call in `log` as it is made, with what it sent
+ * and, once it settles, what it rejected with. The record wraps every behaviour the mock is given, its own and any a
+ * test sets, so the mock stays the plain mock function a runner's matchers read, bun's included. `withResponse` is how
+ * a call asks discord.js for the message back, not part of what it sends, so it is left out.
+ */ function recordedMock(method, impl, log) {
+    const record = (behaviour)=>function(...args) {
             const [payload] = args;
             const sent = payload && typeof payload === 'object' && 'withResponse' in payload ? Object.fromEntries(Object.entries(payload).filter(([key])=>key !== 'withResponse')) : payload;
             const call = {
@@ -1288,7 +1472,7 @@ const ANSWER_METHODS = [
             controller_decorator.stampCall(call);
             log.push(call);
             try {
-                const result = Reflect.apply(target, self, args);
+                const result = Reflect.apply(behaviour, this, args);
                 // Recorded and passed on, so a rejection nobody awaits is unhandled in the test, as it is on a bot
                 if (result instanceof Promise) {
                     return result.then(undefined, (error)=>{
@@ -1301,8 +1485,38 @@ const ANSWER_METHODS = [
                 call.error = error;
                 throw error;
             }
-        }
-    });
+        };
+    const mock = createMockFn(record(impl));
+    const always = mock.mockImplementation.bind(mock);
+    const once = mock.mockImplementationOnce.bind(mock);
+    // Each way a test sets a behaviour goes through the record, a runner's own extras included where it has them
+    const setters = {
+        mockImplementation: (fn)=>fn,
+        mockReturnValue: (value)=>()=>value,
+        mockResolvedValue: (value)=>()=>Promise.resolve(value),
+        mockRejectedValue: (value)=>()=>Promise.reject(value)
+    };
+    // In place of the mock's own, keeping whether each is among its keys
+    const define = (name, value)=>Object.defineProperty(mock, name, {
+            value,
+            writable: true,
+            enumerable: Object.getOwnPropertyDescriptor(mock, name)?.enumerable ?? false,
+            configurable: true
+        });
+    for (const [name, behaviourOf] of Object.entries(setters)){
+        define(name, (value)=>(always(record(behaviourOf(value))), mock));
+        define(`${name}Once`, (value)=>(once(record(behaviourOf(value))), mock));
+    }
+    if (typeof mock.mockReturnThis === 'function') {
+        define('mockReturnThis', ()=>(always(record(function() {
+                return this;
+            })), mock));
+    }
+    const withImplementation = mock.withImplementation;
+    if (typeof withImplementation === 'function') {
+        define('withImplementation', (fn, callback)=>withImplementation.call(mock, record(fn), callback));
+    }
+    return mock;
 }
 /** The interaction a mock options resolver was given to, for the server a user option's member is in. */ const optionOwners = new WeakMap();
 /** An error as discord.js's options resolver throws it: a `TypeError` with discord.js's code and message. */ const optionError = (code, ...args)=>new discord_js.DiscordjsTypeError(code, ...args);
@@ -1325,13 +1539,10 @@ function createMockInteraction(Class, props) {
             instance[key] = value;
         }
     }
-    // Wire each type guard as a mock fn calling the real prototype implementation.
-    // Correct by default; overridable per test via .mockReturnValue().
+    // Each type guard runs the real prototype implementation, as the mock's own, so a reset keeps it; a test may override it
     for (const name of TYPE_GUARD_METHODS){
         const method = findPrototypeMethod(instance, name);
-        if (method !== null) {
-            stubs.set(name, createMockFn().mockImplementation(()=>method.call(instance)));
-        }
+        if (method !== null) stubs.set(name, createMockFn(()=>method.call(instance)));
     }
     // Guild checks read the mock's own data, since discord.js resolves `guild` through a client the
     // mock lacks: a guildId is a guild, a guild object with it a cached one, neither a DM. A member
@@ -1344,7 +1555,7 @@ function createMockInteraction(Class, props) {
         inRawGuild: ()=>Boolean(own('guildId') && !own('guild') && hasMember())
     };
     for (const [name, check] of Object.entries(guildChecks)){
-        if (findPrototypeMethod(instance, name) !== null) stubs.set(name, createMockFn().mockImplementation(check));
+        if (findPrototypeMethod(instance, name) !== null) stubs.set(name, createMockFn(check));
     }
     // Set up reply state machine for repliable interactions
     const isRepliableMethod = findPrototypeMethod(instance, 'isRepliable');
@@ -1364,21 +1575,27 @@ function createMockInteraction(Class, props) {
             if (typeof flags === 'bigint') return (flags & 64n) !== 0n;
             return false;
         };
-        stubs.set('reply', createMockFn(async (...args)=>{
+        // Every answer the interaction gets, through respond() or discord.js directly, in order, for getResponse
+        const log = [];
+        Object.defineProperty(instance, RESPONSE_LOG, {
+            value: log
+        });
+        const answer = (method, impl)=>stubs.set(method, recordedMock(method, impl, log));
+        answer('reply', async (...args)=>{
             if (instance.deferred || instance.replied) throw alreadyReplied();
             instance.replied = true;
             if (hasEphemeralFlag(args[0])) instance.ephemeral = true;
-        }));
-        stubs.set('deferReply', createMockFn(async (...args)=>{
+        });
+        answer('deferReply', async (...args)=>{
             if (instance.deferred || instance.replied) throw alreadyReplied();
             instance.deferred = true;
             if (hasEphemeralFlag(args[0])) instance.ephemeral = true;
-        }));
-        stubs.set('followUp', createMockFn(async ()=>{
+        });
+        answer('followUp', async ()=>{
             if (!instance.deferred && !instance.replied) throw notYetReplied('followUp');
             instance.replied = true;
             return createMockMessage();
-        }));
+        });
         // The interaction's own message as Discord holds it: the message a component is on, or the original response.
         // An edit replaces it in the shape Discord stores, with ids and resolved media, stamped with when it was edited,
         // and fetchReply() reads that back, so code comparing the two sees what it would against Discord.
@@ -1387,7 +1604,7 @@ function createMockInteraction(Class, props) {
         // A command answered with a modal has no original response, and Discord refuses one asked for
         let modalAnswered = false;
         const unknownMessage = ()=>createDiscordError(10008, 'Unknown Message');
-        stubs.set('editReply', createMockFn(async (options)=>{
+        answer('editReply', async (options)=>{
             if (!instance.deferred && !instance.replied) throw notYetReplied('editReply');
             if (modalAnswered) throw unknownMessage();
             instance.replied = true;
@@ -1397,42 +1614,33 @@ function createMockInteraction(Class, props) {
                 ...held,
                 components: held.returned ?? held.components
             });
-        }));
+        });
         stubs.set('fetchReply', createMockFn(async ()=>{
             if (modalAnswered) throw unknownMessage();
             return messageFrom(current());
         }));
-        stubs.set('deleteReply', createMockFn(async ()=>{
+        answer('deleteReply', async ()=>{
             if (!instance.deferred && !instance.replied) throw notYetReplied('deleteReply');
             if (modalAnswered) throw unknownMessage();
-        }));
+        });
         // showModal — the first response of a command or a component, like reply()
         if (instance.type === discord_js.InteractionType.ApplicationCommand || instance.type === discord_js.InteractionType.MessageComponent) {
-            stubs.set('showModal', createMockFn(async ()=>{
+            answer('showModal', async ()=>{
                 if (instance.deferred || instance.replied) throw alreadyReplied();
                 instance.replied = true;
                 modalAnswered = instance.type === discord_js.InteractionType.ApplicationCommand;
-            }));
+            });
         }
         // deferUpdate / update — components, and modals submitted from a message's component
         if (instance.type === discord_js.InteractionType.MessageComponent || instance.type === discord_js.InteractionType.ModalSubmit) {
-            stubs.set('update', createMockFn(async ()=>{
+            answer('update', async ()=>{
                 if (instance.deferred || instance.replied) throw alreadyReplied();
                 instance.replied = true;
-            }));
-            stubs.set('deferUpdate', createMockFn(async ()=>{
+            });
+            answer('deferUpdate', async ()=>{
                 if (instance.deferred || instance.replied) throw alreadyReplied();
                 instance.deferred = true;
-            }));
-        }
-        // Every answer the interaction gets, through respond() or discord.js directly, in order, for getResponse
-        const log = [];
-        Object.defineProperty(instance, RESPONSE_LOG, {
-            value: log
-        });
-        for (const method of ANSWER_METHODS){
-            const stub = stubs.get(method);
-            if (stub) stubs.set(method, recorded(method, stub, log));
+            });
         }
     }
     // Autocomplete is not repliable, but it has a response of its own: Discord accepts
@@ -1471,6 +1679,43 @@ function createMockInteraction(Class, props) {
         const unset = (key)=>!Object.prototype.hasOwnProperty.call(instance, key);
         const generatedId = unset('id') ? instance.id = nextSnowflake() : undefined;
         defineCreatedTime(instance, generatedId);
+        // A raw member is from a server the bot isn't in: no cached guild, and its user the interaction's, as discord.js reads it
+        const raw = own('member');
+        // Given with a guild, a raw-shaped member is kept as the cached server's member it was before raw members
+        if (isRawMember(raw) && own('guild')) {
+            controller_decorator.warnOnce(mockLogger, "The member given is a raw member, from a server the bot isn't in, but the mock was given a guild, so it reads as a " + 'cached server: leave the guild out for a raw member, or give a GuildMember.');
+        } else if (isRawMember(raw)) {
+            const rawOnly = "The member given is a raw member, from a server the bot isn't in";
+            if (!own('guildId')) throw new Error(`${rawOnly}, so the mock needs that server's guildId.`);
+            if (own('channel') !== undefined) throw new Error(`${rawOnly}, where discord.js caches no channel, but the mock was given a channel: leave the channel out.`);
+            const givenUser = own('user');
+            if (givenUser && givenUser.id !== raw.user.id) {
+                throw new Error(`The member given is user ${raw.user.id}'s, but the mock's user is ${givenUser.id}: give the same user, or leave one of them out.`);
+            }
+            if (!givenUser) {
+                const { id, username, global_name: globalName, discriminator, avatar } = raw.user;
+                instance.user = createMockUser({
+                    id,
+                    username,
+                    globalName: globalName ?? null,
+                    discriminator,
+                    avatar: avatar ?? null
+                });
+            }
+            Object.defineProperty(instance, 'guild', {
+                value: null,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+            // Only its channelId: discord.js caches no channel from a server the bot isn't in
+            Object.defineProperty(instance, 'channel', {
+                value: null,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+        }
         const userGiven = !unset('user');
         if (!userGiven) instance.user = mockUser();
         // Assigned once by discord.js's Base constructor, as on a message, and the gateway caches the user on it
@@ -1613,29 +1858,25 @@ function createMockInteraction(Class, props) {
  * on a double whose shape is an interface with nothing at runtime to read it from.
  */ function stubCallable() {
     const fn = createMockFn();
-    const nested = new Map();
-    return new Proxy(fn, {
-        get (target, prop) {
-            if (typeof prop === 'symbol') return Reflect.get(target, prop, target);
-            const key = prop;
+    // Any property beyond the mock's own API is a nested mock, made on first read and kept on the function, out of its
+    // keys. Its prototype makes them rather than a Proxy around it, so it stays the plain mock function matchers read
+    const inherited = Object.getPrototypeOf(fn);
+    Object.setPrototypeOf(fn, new Proxy(inherited, {
+        get (proto, prop, receiver) {
+            if (typeof prop === 'symbol' || prop in proto) return Reflect.get(proto, prop, receiver);
             // Never thenable — otherwise awaiting a mock hangs on itself
-            if (key === 'then') return undefined;
-            // The mock's own API (`mock`, `mockReturnValue`, `_isMockFunction`, …) and
-            // the function intrinsics pass straight through.
-            if (key in target) return Reflect.get(target, prop, target);
-            if (!nested.has(key)) nested.set(key, stubCallable());
-            return nested.get(key);
-        },
-        set (target, prop, value) {
-            Object.defineProperty(target, prop, {
-                value,
+            if (prop === 'then') return undefined;
+            const nested = stubCallable();
+            Object.defineProperty(receiver, prop, {
+                value: nested,
                 writable: true,
-                enumerable: true,
+                enumerable: false,
                 configurable: true
             });
-            return true;
+            return nested;
         }
-    });
+    }));
+    return fn;
 }
 /**
  * Creates a mock of any type, with no class needed, for service doubles and interfaces.
@@ -2111,10 +2352,16 @@ const CHANNEL_TYPE_GUARDS = [
     });
     return stubDeep(manager);
 }
-/** A server's @everyone role, which has the server's id and ranks lowest, at position 0. */ const everyoneRole = (guildId)=>createMockInteraction(discord_js.Role, {
+/** The permissions Discord gives a server's @everyone role in a server made today. */ const NEW_SERVER_EVERYONE_PERMISSIONS = 2248473465835073n;
+// A server's @everyone role, which has the server's id and ranks lowest, at position 0; with strict mocks, the
+// permissions Discord gives it in a new server
+const everyoneRole = (guildId)=>createMockInteraction(discord_js.Role, {
         id: guildId,
         name: '@everyone',
-        position: 0
+        position: 0,
+        ...strictMocks() ? {
+            permissions: new discord_js.PermissionsBitField(NEW_SERVER_EVERYONE_PERMISSIONS).freeze()
+        } : {}
     });
 /**
  * A guild's role manager with `roles` in its cache, and the guild's @everyone role: the one given with the guild's id,
@@ -2142,6 +2389,68 @@ const CHANNEL_TYPE_GUARDS = [
     });
     return manager;
 }
+/**
+ * Creates the member Discord sends with an interaction from a server the bot isn't in, as discord.js keeps it.
+ *
+ * Give it as an interaction's `member`, with the server's `guildId` and no `guild`, to test a user-installed command
+ * run there: the interaction reads `inRawGuild()` true, `guild` and `channel` null, `user` the member's user and
+ * `memberPermissions` the member's, and a user option's member is the plain member Discord resolves too.
+ *
+ * @remarks
+ * It is plain data, not a `GuildMember`: `roles` are role ids, `permissions` is the permission bitfield as a string,
+ * and the rest are as Discord sends them, `null` for what may be absent and `false` for a flag. Code that reads
+ * `member.roles.cache` throws on it, as it does in Discord.
+ *
+ * @param overrides - Fields for the member; see {@link MockRawMemberOverrides}.
+ * @returns The member, as an `APIInteractionGuildMember`.
+ *
+ * @example
+ * ```ts
+ * import { expect } from 'vitest'
+ *
+ * const member = createMockRawMember({ roles: ['300000000000000001'], permissions: [PermissionFlagsBits.SendMessages] })
+ * const command = createMockInteraction(ChatInputCommandInteraction, { guildId: '100000000000000001', member })
+ * expect(command.inRawGuild()).toBe(true)
+ * ```
+ *
+ * @group Testing
+ * @category Mocks
+ * @see {@link createMockMember}
+ */ function createMockRawMember(overrides = {}) {
+    const { permissions, user, ...given } = overrides;
+    return {
+        user: {
+            id: nextSnowflake(),
+            username: 'user',
+            discriminator: '0',
+            global_name: null,
+            avatar: null,
+            ...user
+        },
+        roles: [],
+        nick: null,
+        avatar: null,
+        banner: null,
+        premium_since: null,
+        communication_disabled_until: null,
+        joined_at: new Date().toISOString(),
+        deaf: false,
+        mute: false,
+        pending: false,
+        flags: 0,
+        ...given,
+        permissions: String(new discord_js.PermissionsBitField(permissions ?? NEW_SERVER_EVERYONE_PERMISSIONS).bitfield)
+    };
+}
+/** Whether `value` is a member Discord sends from a server the bot isn't in: plain data, not a `GuildMember`. */ function isRawMember(value) {
+    if (typeof value !== 'object' || value === null || value instanceof discord_js.GuildMember) return false;
+    const { roles, permissions, user } = value;
+    return Array.isArray(roles) && typeof permissions === 'string' && typeof user === 'object' && user !== null;
+}
+/** A user option's member as Discord resolves it with an interaction from a server the bot isn't in. */ function rawResolvedMember() {
+    const { user: _user, deaf: _deaf, mute: _mute, ...resolved } = createMockRawMember();
+    return resolved;
+}
 /**
  * Creates a mock {@link GuildMember}: a user in a server, with the roles given.
  *
@@ -2292,6 +2601,8 @@ const CHANNEL_TYPE_GUARDS = [
             if (!Object.prototype.hasOwnProperty.call(item, 'guild')) item.guild = guild;
         }
     }
+    // Strict mocks cache the bot's member from the start, as the gateway does when the bot joins, so lookups find it
+    if (strictMocks()) void members.me;
 }
 /** The ids each kind of mention in `content` names, in order and once each. */ function mentionedIds(content) {
     const ids = (pattern)=>[
@@ -2514,7 +2825,8 @@ const CHANNEL_TYPE_GUARDS = [
         get: ()=>{
             const found = cacheOf(instance.channel.threads)?.get(instance.id);
             if (found) return found;
-            controller_decorator.warnPlaceholder(mockLogger, 'Message.thread', 'it is null unless the channel caches a thread under the message id, as discord.js reads it', 'Cache one with message.channel.threads.cache.set(message.id, thread).');
+            if (strictMocks()) return null;
+            controller_decorator.warnPlaceholder(mockLogger, 'Message.thread', 'it is null unless the channel caches a thread under the message id, as discord.js reads it', 'Cache one with message.channel.threads.cache.set(message.id, thread), or call useStrictMocks() to have it read null now.');
             return placeholderThread ?? (placeholderThread = stubDeep(Object.create(discord_js.ThreadChannel.prototype)));
         },
         set: (value)=>Object.defineProperty(instance, 'thread', {
@@ -2783,7 +3095,8 @@ const CHANNEL_TYPE_GUARDS = [
             if (!unowned.has(name)) unowned.set(name, memberIn(undefined, user.id, user));
             return unowned.get(name);
         }
-        if (!members.has(name)) members.set(name, owner.guildId ? memberFor(owner.guild, user, true) : null);
+        const rawOwner = !owner.guild && isRawMember(Object.getOwnPropertyDescriptor(owner, 'member')?.value);
+        if (!members.has(name)) members.set(name, owner.guildId ? rawOwner ? rawResolvedMember() : memberFor(owner.guild, user, true) : null);
         return members.get(name) ?? null;
     };
     base.getUser = createMockFn((name, required)=>{
@@ -2872,7 +3185,7 @@ const CHANNEL_TYPE_GUARDS = [
  * @category Module
  * @see {@link MeoCordTestingModule}
  * @see {@link getResponse}
- * @see {@link https://meocord.dev/docs/4.1/invoke-and-dispatch | Invoke and dispatch}
+ * @see {@link https://meocord.dev/docs/4.2/invoke-and-dispatch | Invoke and dispatch}
  */ class TestingModule {
     /**
    * Resolves the module's `useFactory` providers, awaiting those that return a promise, in dependency
@@ -3146,6 +3459,8 @@ const CHANNEL_TYPE_GUARDS = [
             controllerClasses: this.controllers,
             messageOptions: this.messageOptions,
             logger,
+            // A test's fake clock can pass 5 s inside a handler, so the slow-handler warning waits to be asked for
+            warnSlowMessageHandlers: false,
             // Strict: an answer MeoCord fails to build rejects the dispatch, where a bot logs it and carries on
             fallback: startupRoots.createFallback(logger, ()=>this.messageOptions, {
                 strict: true,
@@ -3312,7 +3627,7 @@ const CHANNEL_TYPE_GUARDS = [
  * @group Testing
  * @category Module
  * @see {@link MeoCordTestingModule}
- * @see {@link https://meocord.dev/docs/4.1/testing | The testing module}
+ * @see {@link https://meocord.dev/docs/4.2/testing | The testing module}
  */ class TestingModuleBuilder {
     /**
    * Replaces a provider with a test double.
@@ -3460,199 +3775,236 @@ const CHANNEL_TYPE_GUARDS = [
    * its command's builder does not register, a customId pattern given as a command name, a builder that registers
    * another name, and component patterns that can match the same customId are named, as the bot names them.
    *
+   * Each check reports every startup error it finds, and the first is thrown, unchanged; when there are several, each
+   * is logged first, with the file it comes from. After {@link reportAllStartupErrors}, the errors decorators kept on
+   * the classes the module runs are among them.
+   *
    * @returns The compiled module.
+   * @throws Error for the first startup error the checks find.
    */ compile() {
         // The bound the bot's config gives it, with the same words
         const shutdownTimeout = this.options.shutdownTimeout === undefined ? undefined : startupRoots.shutdownTimeoutProblem(this.options.shutdownTimeout);
         if (shutdownTimeout) throw new TypeError(`shutdownTimeout ${shutdownTimeout}.`);
-        const container = new inversify.Container();
-        const stages = this.globalStages();
-        if (stages) providers.bindGlobalStages(container, stages);
-        // Bound first, as in the app, so a class that injects it gets this instance
-        const appClasses = [];
-        const translator = ()=>container.isBound(controller_decorator.Translator) ? container.get(controller_decorator.Translator) : undefined;
-        container.bind(providers.HandlerRegistry).toConstantValue(new providers.HandlerRegistry(appClasses, messagesOf(this.options.app), translator));
-        // A testing module runs as one process, so a cross-shard call runs once, here
-        container.bind(providers.ShardContext).toConstantValue(new providers.ShardContext(undefined, providers.shardCallHandler(container, ()=>[
-                ...appClasses,
-                ...[
-                    ...providers$1.keys()
-                ].filter(providers.isAppClassToken)
-            ], 'this testing module')));
-        providers.bindsOwnToken(container, providers.HandlerRegistry);
-        providers.bindsOwnToken(container, providers.ShardContext);
-        // Checked as the app checks its own: the app's providers in their order, then the test's, which replace them
-        // by token, then the overrides, which win
-        const providers$1 = providers.providerMap(this.wiring?.providers ?? [], '@MeoCord({ providers })');
-        for (const [token, provider] of providers.providerMap(this.options.providers ?? [], "the testing module's providers"))providers$1.set(token, provider);
-        for (const [token, override] of this.overrides)providers$1.set(token, override);
-        const services = this.wiring?.services ?? [];
-        const appOptions = this.options.app ? Reflect.getMetadata(controller_decorator.META.appOptions, this.options.app) : undefined;
-        // The app's own store, as the bot binds it, whether the module is given the app or built from it; none when the
-        // test provides the CooldownStore, so nothing builds the app's or asks for what it injects
-        const store = providers$1.has(controller_decorator.CooldownStore) ? undefined : appOptions?.cooldownStore;
-        // The themeFor class this module runs, the app's or overrideThemeFor's, bound on its own as the app binds it
-        const themeResolver = controller_decorator.themeResolverClass(stages?.themeFor?.resolvers);
-        // Every class the module runs, as the app finds them, except stage classes an override stands in for
-        const i18n = this.options.app && Reflect.getMetadata(controller_decorator.META.appOptions, this.options.app)?.i18n;
-        const startup = startupRoots.startupClasses({
-            controllers: this.options.controllers ?? [],
-            services,
-            providers: providers$1,
-            stages,
-            presenter: this.options.app && Reflect.getMetadata(controller_decorator.META.appOptions, this.options.app)?.presenter,
-            cooldownStore: store,
-            themeFor: stages?.themeFor?.resolvers,
-            observers: [
-                ...this.options.app ? providers.appObservers(this.options.app) : [],
-                ...this.options.observers ?? []
-            ],
-            stubs: [
-                ...this.guardOverrides.keys(),
-                ...this.interceptorOverrides.keys(),
-                ...this.filterOverrides.keys()
-            ]
-        });
-        const hasTranslator = i18n !== undefined || providers$1.has(controller_decorator.Translator);
-        startupRoots.assertStartupClasses(startup, {
-            translator: hasTranslator
-        });
-        providers.markStartupChecked(container, [
-            ...startup.classes,
-            ...providers.meocordClasses()
-        ], startupRoots.lateGuardCheck(providers$1, hasTranslator));
-        // The bot binds the Client it logs in with; a test gives its own, and is told so where one is needed
-        const needClient = startup.classes.filter((cls)=>providers.injectedTokens(cls).includes(discord_js.Client));
-        if (needClient.length > 0 && !providers$1.has(discord_js.Client)) {
-            container.bind(discord_js.Client).toDynamicValue(()=>{
-                throw new Error(`${needClient.map((cls)=>cls.name).join(', ')} ${needClient.length === 1 ? 'injects' : 'inject'} the Discord Client, ` + 'which a testing module does not make: give one in its providers, such as ' + '{ provide: Client, useValue: createMockClient() }.');
-            });
-        }
-        // Bind guard overrides — prevents inversify from auto-wiring guard dependencies
-        for (const [guardClass, stub] of this.guardOverrides){
-            container.bind(guardClass).toConstantValue(stub);
-        }
-        for (const [filterClass, stub] of this.filterOverrides){
-            container.bind(filterClass).toConstantValue(stub);
-        }
-        for (const [interceptorClass, stub] of this.interceptorOverrides){
-            container.bind(interceptorClass).toConstantValue(stub);
-        }
-        // The app's cooldown policy, so a test of a failing store sees what the bot would do
-        if (appOptions && !container.isBound(providers.COOLDOWN_POLICY)) container.bind(providers.COOLDOWN_POLICY).toConstantValue(providers.cooldownPolicyFrom(appOptions));
-        // The app's translator, unless a provider stands in for it
-        if (i18n && !providers$1.has(controller_decorator.Translator)) {
-            container.bind(controller_decorator.Translator).toConstantValue(i18n);
-            providers.bindsOwnToken(container, controller_decorator.Translator);
-        }
-        // Recursively bind controllers and their dependencies, skipping already-bound tokens
-        const bindClass = (cls)=>{
-            // A provided class is bound by its own provider, wherever in the list that provider comes
-            if (container.isBound(cls) || providers$1.has(cls)) return;
-            if (providers.injectedTokens(cls).includes(controller_decorator.ExecutionContext)) throw providers.singletonContextError(cls);
-            providers.assertStartupChecked(container, cls);
-            providers.makeInjectable(cls);
-            container.bind(cls).toSelf().inSingletonScope();
-            // By constructor type or @inject token, as the app binds them
-            for (const dep of providers.injectedTokens(cls)){
-                if (dep === controller_decorator.Translator && !container.isBound(controller_decorator.Translator)) throw controller_decorator.missingTranslatorError(cls);
-                if (providers.isAppClassToken(dep)) bindClass(dep);
-            }
-        };
-        // The app's own store, resolved like a service, unless the test provides the CooldownStore itself; bound first, as the
-        // app binds it, so a class that injects the token gets the store
-        if (!providers$1.has(controller_decorator.CooldownStore)) {
-            if (store) {
-                bindClass(store);
-                container.bind(controller_decorator.CooldownStore).toService(store);
-            } else {
-                container.bind(controller_decorator.CooldownStore).toConstantValue(new controller_decorator.MemoryCooldownStore());
-            }
-            providers.bindsOwnToken(container, controller_decorator.CooldownStore, store);
-        }
-        // Before the controllers, so a class token that is provided is not also bound as itself
-        for (const provider of providers$1.values())providers.bindProvider(container, provider, bindClass);
-        for (const ctrl of this.options.controllers ?? []){
-            bindClass(ctrl);
-            // Stamp container on controller class so @UseGuard works in tests too
-            Reflect.defineMetadata(controller_decorator.META.container, container, ctrl);
-        }
-        for (const service of services)bindClass(service);
-        if (themeResolver) bindClass(themeResolver);
-        // The classes whose @On and @Once handlers emit reaches: class providers bound as themselves, the
-        // controllers, and what they inject; factories resolve in the same order
-        const order = providers.resolutionOrder(container, providers$1, [
-            ...providers$1.keys(),
-            ...services,
-            ...themeResolver ? [
-                themeResolver
-            ] : [],
-            ...this.options.controllers ?? []
-        ], {
-            followOwnTokens: false
-        });
-        appClasses.push(...order.filter((token)=>{
-            const provider = providers$1.get(token);
-            return providers.isAppClassToken(token) && (!provider || providers.isClassProvider(provider) && provider.useClass === token);
-        }));
-        providers.assertProvided(container, providers$1, startup.classes, "the testing module's providers");
-        // Every class the module runs, so @UseGuard resolves guards on a direct call to any of them
-        for (const cls of startup.classes)Reflect.defineMetadata(controller_decorator.META.container, container, cls);
-        providers.prepareHandlerStages(container, appClasses);
-        const messages = messagesOf(this.options.app);
-        // As the app would at startup, refuses a message pattern that cannot be read or two that match the same messages
-        providers.buildMessageRoutes(this.options.controllers ?? [], messages);
-        // As the app does when it is created, so a test sees the refusal the bot would give
-        startupRoots.assertDistinctCommands(this.options.controllers ?? []);
-        // A handler with no builder is how a fixture is written, so only what is always a mistake is named
-        startupRoots.warnUnregisteredCommands(this.options.controllers ?? [], {
-            missingBuilders: false
-        });
-        startupRoots.warnInheritedRoutes(this.options.controllers ?? []);
-        startupRoots.warnOverlappingPatterns(this.options.controllers ?? []);
-        startupRoots.warnHandlersOffControllers(this.options.controllers ?? [], appClasses);
-        if (this.options.app) providers.bindAppPresenter(container, this.options.app);
-        const observers = [
-            ...this.options.app ? providers.appObservers(this.options.app) : [],
-            ...this.options.observers ?? []
-        ];
-        providers.assertObservers("the testing module's observers", observers);
-        providers.bindObservers(container, observers);
-        // The store calls ask: the test's own when it provides CooldownStore, else the app's
-        const boundStore = store ?? (providers$1.has(controller_decorator.CooldownStore) ? controller_decorator.CooldownStore : undefined);
-        // The order the app runs lifecycle hooks in: its cooldown store, then providers, controllers and observers, each
-        // after what it injects
-        const lifecycle = providers.resolutionOrder(container, providers$1, [
-            ...boundStore ? [
-                boundStore
-            ] : [],
-            ...providers$1.keys(),
-            ...services,
-            ...themeResolver ? [
-                themeResolver
+        // With startupErrors: 'all', what the decorators kept on the classes this module runs
+        const declared = controller_decorator.declaredErrorsOf([
+            ...this.options.app ? [
+                this.options.app
             ] : [],
             ...this.options.controllers ?? [],
-            ...observers
-        ]).map((token)=>({
-                token,
-                name: providers.tokenName(token),
-                dependencies: providers.tokenDependencies(container, providers$1, token),
-                ...token === boundStore && {
-                    cooldownStore: true
+            ...this.wiring?.services ?? [],
+            ...this.options.observers ?? []
+        ]);
+        // Every error each check finds is reported, as the bot reports them, and the first is thrown
+        try {
+            return controller_decorator.collectStartupErrors(()=>{
+                declared.forEach(controller_decorator.startupError);
+                const container = new inversify.Container();
+                const stages = this.globalStages();
+                if (stages) providers.bindGlobalStages(container, stages);
+                // Bound first, as in the app, so a class that injects it gets this instance
+                const appClasses = [];
+                const translator = ()=>container.isBound(controller_decorator.Translator) ? container.get(controller_decorator.Translator) : undefined;
+                container.bind(providers.HandlerRegistry).toConstantValue(new providers.HandlerRegistry(appClasses, messagesOf(this.options.app), translator));
+                // A testing module runs as one process, so a cross-shard call runs once, here
+                container.bind(providers.ShardContext).toConstantValue(new providers.ShardContext(undefined, providers.shardCallHandler(container, ()=>[
+                        ...appClasses,
+                        ...[
+                            ...providers$1.keys()
+                        ].filter(providers.isAppClassToken)
+                    ], 'this testing module')));
+                providers.bindsOwnToken(container, providers.HandlerRegistry);
+                providers.bindsOwnToken(container, providers.ShardContext);
+                // Checked as the app checks its own: the app's providers in their order, then the test's, which replace them
+                // by token, then the overrides, which win
+                const providers$1 = providers.providerMap(this.wiring?.providers ?? [], '@MeoCord({ providers })');
+                for (const [token, provider] of providers.providerMap(this.options.providers ?? [], "the testing module's providers"))providers$1.set(token, provider);
+                for (const [token, override] of this.overrides)providers$1.set(token, override);
+                // Each pass of checks ends before the next step that is no check, so a module with one error stops where it always did
+                controller_decorator.stopOnStartupErrors();
+                const services = this.wiring?.services ?? [];
+                const appOptions = this.options.app ? Reflect.getMetadata(controller_decorator.META.appOptions, this.options.app) : undefined;
+                // The app's own store, as the bot binds it, whether the module is given the app or built from it; none when the
+                // test provides the CooldownStore, so nothing builds the app's or asks for what it injects
+                const store = providers$1.has(controller_decorator.CooldownStore) ? undefined : appOptions?.cooldownStore;
+                // The themeFor class this module runs, the app's or overrideThemeFor's, bound on its own as the app binds it
+                const themeResolver = controller_decorator.themeResolverClass(stages?.themeFor?.resolvers);
+                // Every class the module runs, as the app finds them, except stage classes an override stands in for
+                const i18n = this.options.app && Reflect.getMetadata(controller_decorator.META.appOptions, this.options.app)?.i18n;
+                const startup = startupRoots.startupClasses({
+                    controllers: this.options.controllers ?? [],
+                    services,
+                    providers: providers$1,
+                    stages,
+                    presenter: this.options.app && Reflect.getMetadata(controller_decorator.META.appOptions, this.options.app)?.presenter,
+                    cooldownStore: store,
+                    themeFor: stages?.themeFor?.resolvers,
+                    observers: [
+                        ...this.options.app ? providers.appObservers(this.options.app) : [],
+                        ...this.options.observers ?? []
+                    ],
+                    stubs: [
+                        ...this.guardOverrides.keys(),
+                        ...this.interceptorOverrides.keys(),
+                        ...this.filterOverrides.keys()
+                    ]
+                });
+                const hasTranslator = i18n !== undefined || providers$1.has(controller_decorator.Translator);
+                startupRoots.assertStartupClasses(startup, {
+                    translator: hasTranslator
+                });
+                // Those of the stages, guards and other classes they reach
+                controller_decorator.declaredErrorsOf(startup.classes).forEach(controller_decorator.startupError);
+                controller_decorator.stopOnStartupErrors();
+                providers.markStartupChecked(container, [
+                    ...startup.classes,
+                    ...providers.meocordClasses()
+                ], startupRoots.lateGuardCheck(providers$1, hasTranslator));
+                // The bot binds the Client it logs in with; a test gives its own, and is told so where one is needed
+                const needClient = startup.classes.filter((cls)=>providers.injectedTokens(cls).includes(discord_js.Client));
+                if (needClient.length > 0 && !providers$1.has(discord_js.Client)) {
+                    container.bind(discord_js.Client).toDynamicValue(()=>{
+                        throw new Error(`${needClient.map((cls)=>cls.name).join(', ')} ${needClient.length === 1 ? 'injects' : 'inject'} the Discord Client, ` + 'which a testing module does not make: give one in its providers, such as ' + '{ provide: Client, useValue: createMockClient() }.');
+                    });
+                }
+                // Bind guard overrides — prevents inversify from auto-wiring guard dependencies
+                for (const [guardClass, stub] of this.guardOverrides){
+                    container.bind(guardClass).toConstantValue(stub);
+                }
+                for (const [filterClass, stub] of this.filterOverrides){
+                    container.bind(filterClass).toConstantValue(stub);
+                }
+                for (const [interceptorClass, stub] of this.interceptorOverrides){
+                    container.bind(interceptorClass).toConstantValue(stub);
                 }
-            }));
-        // Recorded as the container makes each one, so close() shuts down exactly what exists
-        const constructed = new Set();
-        for (const { token } of lifecycle){
-            container.onActivation(token, (_context, instance)=>{
-                constructed.add(token);
-                return instance;
+                // The app's cooldown policy, so a test of a failing store sees what the bot would do
+                if (appOptions && !container.isBound(providers.COOLDOWN_POLICY)) container.bind(providers.COOLDOWN_POLICY).toConstantValue(providers.cooldownPolicyFrom(appOptions));
+                // The app's translator, unless a provider stands in for it
+                if (i18n && !providers$1.has(controller_decorator.Translator)) {
+                    container.bind(controller_decorator.Translator).toConstantValue(i18n);
+                    providers.bindsOwnToken(container, controller_decorator.Translator);
+                }
+                // Recursively bind controllers and their dependencies, skipping already-bound tokens
+                const bindClass = (cls)=>{
+                    // A provided class is bound by its own provider, wherever in the list that provider comes
+                    if (container.isBound(cls) || providers$1.has(cls)) return;
+                    if (providers.injectedTokens(cls).includes(controller_decorator.ExecutionContext)) return controller_decorator.startupError(providers.singletonContextError(cls));
+                    providers.assertStartupChecked(container, cls);
+                    providers.makeInjectable(cls);
+                    container.bind(cls).toSelf().inSingletonScope();
+                    // By constructor type or @inject token, as the app binds them
+                    for (const dep of providers.injectedTokens(cls)){
+                        if (dep === controller_decorator.Translator && !container.isBound(controller_decorator.Translator)) controller_decorator.startupError(controller_decorator.missingTranslatorError(cls));
+                        else if (providers.isAppClassToken(dep)) bindClass(dep);
+                    }
+                };
+                // The app's own store, resolved like a service, unless the test provides the CooldownStore itself; bound first, as the
+                // app binds it, so a class that injects the token gets the store
+                if (!providers$1.has(controller_decorator.CooldownStore)) {
+                    if (store) {
+                        bindClass(store);
+                        container.bind(controller_decorator.CooldownStore).toService(store);
+                    } else {
+                        container.bind(controller_decorator.CooldownStore).toConstantValue(new controller_decorator.MemoryCooldownStore());
+                    }
+                    providers.bindsOwnToken(container, controller_decorator.CooldownStore, store);
+                }
+                // Before the controllers, so a class token that is provided is not also bound as itself
+                for (const provider of providers$1.values())providers.bindProvider(container, provider, bindClass);
+                for (const ctrl of this.options.controllers ?? [])bindClass(ctrl);
+                for (const service of services)bindClass(service);
+                if (themeResolver) bindClass(themeResolver);
+                // What follows walks what these bound, so a class refused here is not reported again as missing
+                controller_decorator.stopOnStartupErrors();
+                // The classes whose @On and @Once handlers emit reaches: class providers bound as themselves, the
+                // controllers, and what they inject; factories resolve in the same order
+                const order = providers.resolutionOrder(container, providers$1, [
+                    ...providers$1.keys(),
+                    ...services,
+                    ...themeResolver ? [
+                        themeResolver
+                    ] : [],
+                    ...this.options.controllers ?? []
+                ], {
+                    followOwnTokens: false
+                });
+                appClasses.push(...order.filter((token)=>{
+                    const provider = providers$1.get(token);
+                    return providers.isAppClassToken(token) && (!provider || providers.isClassProvider(provider) && provider.useClass === token);
+                }));
+                providers.assertProvided(container, providers$1, startup.classes, "the testing module's providers");
+                providers.prepareHandlerStages(container, appClasses);
+                const messages = messagesOf(this.options.app);
+                // As the app would at startup, refuses a message pattern that cannot be read or two that match the same messages
+                providers.buildMessageRoutes(this.options.controllers ?? [], messages);
+                // As the app does when it is created, so a test sees the refusal the bot would give
+                startupRoots.assertDistinctCommands(this.options.controllers ?? []);
+                if (this.options.app) providers.prepareAppPresenter(container, this.options.app);
+                const observers = [
+                    ...this.options.app ? providers.appObservers(this.options.app) : [],
+                    ...this.options.observers ?? []
+                ];
+                providers.assertObservers("the testing module's observers", observers);
+                // Only @Observer classes are bound as observers
+                controller_decorator.stopOnStartupErrors();
+                providers.bindObservers(container, observers);
+                // The store calls ask: the test's own when it provides CooldownStore, else the app's
+                const boundStore = store ?? (providers$1.has(controller_decorator.CooldownStore) ? controller_decorator.CooldownStore : undefined);
+                // The order the app runs lifecycle hooks in: its cooldown store, then providers, controllers and observers, each
+                // after what it injects
+                const lifecycle = providers.resolutionOrder(container, providers$1, [
+                    ...boundStore ? [
+                        boundStore
+                    ] : [],
+                    ...providers$1.keys(),
+                    ...services,
+                    ...themeResolver ? [
+                        themeResolver
+                    ] : [],
+                    ...this.options.controllers ?? [],
+                    ...observers
+                ]).map((token)=>({
+                        token,
+                        name: providers.tokenName(token),
+                        dependencies: providers.tokenDependencies(container, providers$1, token),
+                        ...token === boundStore && {
+                            cooldownStore: true
+                        }
+                    }));
+                // Every check has run, and touched only the container: from here the module is made, once none found an error
+                controller_decorator.stopOnStartupErrors();
+                // Every class the module runs, so @UseGuard resolves guards on a direct call to any of them
+                for (const cls of [
+                    ...this.options.controllers ?? [],
+                    ...startup.classes
+                ])Reflect.defineMetadata(controller_decorator.META.container, container, cls);
+                providers.prepareThemes(container, appClasses);
+                // A handler with no builder is how a fixture is written, so only what is always a mistake is named
+                startupRoots.warnUnregisteredCommands(this.options.controllers ?? [], {
+                    missingBuilders: false
+                });
+                startupRoots.warnInheritedRoutes(this.options.controllers ?? []);
+                startupRoots.warnOverlappingPatterns(this.options.controllers ?? []);
+                startupRoots.warnHandlersOffControllers(this.options.controllers ?? [], appClasses);
+                if (this.options.app) providers.bindAppPresenter(container, this.options.app);
+                // Recorded as the container makes each one, so close() shuts down exactly what exists
+                const constructed = new Set();
+                for (const { token } of lifecycle){
+                    container.onActivation(token, (_context, instance)=>{
+                        constructed.add(token);
+                        return instance;
+                    });
+                }
+                const warnUnanswered = this.options.app && Reflect.getMetadata(controller_decorator.META.appOptions, this.options.app)?.warnUnanswered;
+                return new TestingModule(container, [
+                    ...this.options.controllers ?? []
+                ], appClasses, providers$1, order, messages, lifecycle, constructed, warnUnanswered, services, this.options.shutdownTimeout ?? startupRoots.DEFAULT_SHUTDOWN_TIMEOUT_MS);
             });
+        } catch (error) {
+            if (controller_decorator.isRefusal(error) && !controller_decorator.isExplainedError(error)) {
+                if (controller_decorator.logStartupErrors(error, (text)=>new controller_decorator.Logger('TestingModule').error(text), 'the testing module did not compile')) controller_decorator.markExplained(error);
+            }
+            throw error;
         }
-        const warnUnanswered = this.options.app && Reflect.getMetadata(controller_decorator.META.appOptions, this.options.app)?.warnUnanswered;
-        return new TestingModule(container, [
-            ...this.options.controllers ?? []
-        ], appClasses, providers$1, order, messages, lifecycle, constructed, warnUnanswered, services, this.options.shutdownTimeout ?? startupRoots.DEFAULT_SHUTDOWN_TIMEOUT_MS);
     }
     constructor(options, wiring){
         this.options = options;
@@ -3690,7 +4042,7 @@ const CHANNEL_TYPE_GUARDS = [
  * @category Module
  * @see {@link TestingModuleBuilder}
  * @see {@link TestingModule}
- * @see {@link https://meocord.dev/docs/4.1/testing | The testing module}
+ * @see {@link https://meocord.dev/docs/4.2/testing | The testing module}
  */ class MeoCordTestingModule {
     /**
    * Starts building a testing module from the classes a test needs.
@@ -3780,6 +4132,29 @@ const CHANNEL_TYPE_GUARDS = [
 providers.adviseInPlaceOfInjecting(TestingModuleBuilder, 'build it with MeoCordTestingModule.create(…) or MeoCordTestingModule.fromApp(…)');
 providers.adviseInPlaceOfInjecting(TestingModule, 'make it with MeoCordTestingModule.create(…).compile()');
 
+/**
+ * Has decorators keep the startup errors they find, as a bot built with `startupErrors: 'all'` does, so a testing
+ * module reports every one at once.
+ *
+ * Call it once in the test runner's setup file, before any test imports a controller: a decorator runs when its class
+ * is defined, as its file is imported. A decorator given what it cannot use then throws nothing as the file loads, and
+ * `MeoCordTestingModule.create(...).compile()` logs every startup error of the classes it runs, each with its handler
+ * and file, then throws the first. Without it, a decorator throws its error as its class is defined.
+ *
+ * @example
+ * ```ts
+ * // vitest.setup.ts
+ * reportAllStartupErrors()
+ * ```
+ *
+ * @group Testing
+ * @category Module
+ * @see {@link MeoCordTestingModule}
+ * @see {@link https://meocord.dev/docs/4.2/configuration | Configuration}
+ */ function reportAllStartupErrors() {
+    controller_decorator.setStartupErrorsMode('all');
+}
+
 /** The options `@MeoCord` declares on an application class. */ function appOptionsOf(app) {
     const options = Reflect.getMetadata(controller_decorator.META.appOptions, app);
     if (!options) throw new TypeError(`${app.name || 'The given class'} is not decorated with @MeoCord().`);
@@ -3823,7 +4198,7 @@ providers.adviseInPlaceOfInjecting(TestingModule, 'make it with MeoCordTestingMo
  * @group Testing
  * @category Inspection
  * @see {@link findRouteConflicts}
- * @see {@link https://meocord.dev/docs/4.1/components | Buttons, selects and modals}
+ * @see {@link https://meocord.dev/docs/4.2/components | Buttons, selects and modals}
  */ function resolveRoute(app, input) {
     if ('content' in input) {
         const { messages = {} } = appOptionsOf(app);
@@ -3849,7 +4224,10 @@ providers.adviseInPlaceOfInjecting(TestingModule, 'make it with MeoCordTestingMo
     const { route, params, text } = matched;
     const method = route.meta.methodName;
     const typed = Object.keys(route.types).length > 0;
-    return {
+    // The routes ranked behind it that the customId matches too, which dispatch never reaches for it
+    const behind = routes.slice(routes.indexOf(route) + 1);
+    const alsoMatches = behind.filter((other)=>other.meta.type === input.type && startupRoots.readCustomId(other.pattern, other.meta.regex, input.customId)).map((other)=>other.pattern);
+    const resolved = {
         controller: route.controllerClass,
         method,
         handler: route.controllerClass.prototype[method],
@@ -3858,28 +4236,34 @@ providers.adviseInPlaceOfInjecting(TestingModule, 'make it with MeoCordTestingMo
             values: params
         }
     };
+    return alsoMatches.length > 0 ? readableOnly(resolved, {
+        alsoMatches
+    }) : resolved;
 }
 /**
- * Finds component patterns that can match the same `customId`, which MeoCord otherwise only warns about at startup.
+ * Finds component patterns that rank equally and can match the same `customId`, which MeoCord otherwise only warns
+ * about at startup.
  *
- * Use it in a test to keep the warning from reaching production: two patterns that trade a literal for a parameter
- * in opposite places both take one id, and neither is more specific. Patterns are compared within a component type.
+ * Use it in a test to keep the warning from reaching production. Patterns rank segment by segment, a literal before a
+ * param and then the narrower type, so two collide only with the same literals and equally narrow params at each
+ * position, such as `{action:close|reopen}` and `{step:close|confirm}`, which both take `close`; the one listed
+ * first runs. Patterns are compared within a component type.
  *
  * @param app - The application class decorated with `@MeoCord`.
- * @returns Each pair of patterns that can match the same `customId`, with its component type.
+ * @returns Each pair of patterns that rank equally and can match the same `customId`, with its component type.
  *
  * @example
  * ```ts
  * import { expect } from 'vitest'
  *
  * @Controller()
- * class CardController {
- *   @Command('card/{id}/open', CommandType.BUTTON)
- *   async open(interaction: ButtonInteraction) { await respond(interaction).send('Opened.') }
- *   @Command('card/new/{kind}', CommandType.BUTTON)
- *   async create(interaction: ButtonInteraction) { await respond(interaction).send('Created.') }
+ * class TicketController {
+ *   @Command('ticket/{action:close|reopen}', CommandType.BUTTON)
+ *   async act(interaction: ButtonInteraction) { await respond(interaction).send('Done.') }
+ *   @Command('ticket/{step:close|confirm}', CommandType.BUTTON)
+ *   async step(interaction: ButtonInteraction) { await respond(interaction).send('Next.') }
  * }
- * @MeoCord({ controllers: [CardController], clientOptions: { intents: [] } })
+ * @MeoCord({ controllers: [TicketController], clientOptions: { intents: [] } })
  * class App {}
  * expect(findRouteConflicts(App)).toHaveLength(1)
  * ```
@@ -3888,7 +4272,23 @@ providers.adviseInPlaceOfInjecting(TestingModule, 'make it with MeoCordTestingMo
  * @category Inspection
  * @see {@link resolveRoute}
  */ function findRouteConflicts(app) {
-    return startupRoots.findComponentRouteConflicts(startupRoots.buildComponentRoutes(controllersOf(app)));
+    return startupRoots.findComponentRouteConflicts(startupRoots.buildComponentRoutes(controllersOf(app))).map(({ type, patterns, runs })=>readableOnly({
+            type: type,
+            patterns
+        }, {
+            runs
+        }));
+}
+/**
+ * `target` with `fields` added as properties a test reads but `toEqual` and its kin, which compare enumerable keys,
+ * don't see, so an assertion written for the fields it had before still holds.
+ */ function readableOnly(target, fields) {
+    for (const [key, value] of Object.entries(fields))Object.defineProperty(target, key, {
+        value,
+        enumerable: false,
+        configurable: true
+    });
+    return target;
 }
 
 /**
@@ -4035,7 +4435,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[controller_decorator.CATALOGS];
     if (!catalogs) throw new Error('expectCompleteCatalog takes a translator made by createTranslator.');
@@ -4081,6 +4481,7 @@ const isMeoCordKey = (key)=>key.startsWith('meocord.');
 
 /** 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.
  *
@@ -4091,7 +4492,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.
@@ -4108,7 +4510,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 = node_crypto.randomUUID();
     const key = (label)=>`meocord-suite:${run}:${label}`;
@@ -4131,32 +4533,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 = {
@@ -4504,7 +4912,7 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
  * @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 controller_decorator.HandlerExecutionContext({
         controller,
@@ -4513,7 +4921,7 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
     });
     const globals = options.app ? providers.appStages(options.app) : undefined;
     const { guards, interceptors, filters } = providers.handlerStages(controller.prototype, methodName, globals);
-    return {
+    const inspection = {
         controller,
         methodName,
         guards: Object.freeze([
@@ -4535,6 +4943,23 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
         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(controller_decorator.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 = controller_decorator.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 [];
 }
 
 // Themes createMockTheme made, which withTheme uses as they are
@@ -4571,7 +4996,7 @@ function mockTheme(overrides, where) {
  * @group Testing
  * @category Mocks
  * @see {@link withTheme}
- * @see {@link https://meocord.dev/docs/4.1/theming | Theming}
+ * @see {@link https://meocord.dev/docs/4.2/theming | Theming}
  */ function createMockTheme(...[overrides]) {
     return mockTheme(overrides, 'createMockTheme');
 }
@@ -4618,6 +5043,7 @@ exports.createMockGuild = createMockGuild;
 exports.createMockInteraction = createMockInteraction;
 exports.createMockMember = createMockMember;
 exports.createMockMessage = createMockMessage;
+exports.createMockRawMember = createMockRawMember;
 exports.createMockTheme = createMockTheme;
 exports.createMockUser = createMockUser;
 exports.createModalFields = createModalFields;
@@ -4626,7 +5052,10 @@ exports.findRouteConflicts = findRouteConflicts;
 exports.getResponse = getResponse;
 exports.inspectHandler = inspectHandler;
 exports.isMockFunction = isMockFunction;
+exports.reportAllStartupErrors = reportAllStartupErrors;
 exports.resetAllMocks = resetAllMocks;
 exports.resolveRoute = resolveRoute;
 exports.testCooldownStore = testCooldownStore;
+exports.useMockFn = useMockFn;
+exports.useStrictMocks = useStrictMocks;
 exports.withTheme = withTheme;