meocord 4.1.2 → 4.2.1

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-BZgJyfZS.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-XKMlcUZz.cjs');
+var startupRoots = require('../_shared/startup-roots-CgfPQrNl.cjs');
 var node_crypto = require('node:crypto');
 require('node:async_hooks');
 require('crypto');
@@ -21,12 +21,10 @@ require('dayjs/plugin/utc.js');
 require('dayjs/plugin/timezone.js');
 require('module');
 require('chalk');
-require('../_shared/translate-error-BnM8FbSH.cjs');
+require('../_shared/translate-error-BUAR1WYG.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.
-// Each call signature of `T`, up to four, as a union: `Parameters` and `ReturnType` read only an overloaded function's
-// last signature, such as the list form of a manager's `fetch`
 /**
  * Tells whether a value is a mock function: one from `meocord/testing`, `jest.fn()` or `vi.fn()`.
  *
@@ -49,15 +47,90 @@ require('../_shared/translate-error-BnM8FbSH.cjs');
  */ function isMockFunction(fn) {
     return typeof fn === 'function' && '_isMockFunction' in fn && fn._isMockFunction === true;
 }
-// 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));
+/**
+ * What `useMockFn` set and the mocks made, kept for both builds of this meocord version, so a setup file in one module
+ * format sets them for specs in the other:
+ * - `invocationOrder`: when each call of meocord's own mocks came, across all of them, as Vitest numbers its own;
+ * - `created`: every mock createMockFn made, held weakly so the mocks of a finished test can still be collected;
+ * - `runnerFactory` and `restoreImpl`: 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.
+ */ const mocks$1 = controller_decorator.shared('mocks', ()=>({
+        invocationOrder: 0,
+        created: new Set(),
+        runnerFactory: undefined,
+        restoreImpl: new WeakMap()
+    }));
+const collected = new FinalizationRegistry((ref)=>mocks$1.created.delete(ref));
+/**
+ * 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 === mocks$1.runnerFactory) return;
+    if ([
+        ...mocks$1.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 refusal = (cause)=>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.', cause === undefined ? undefined : {
+            cause
+        });
+    let probe;
+    try {
+        probe = factory();
+    } catch (error) {
+        // node:test's mock.fn, given on its own, throws for want of its tracker
+        throw refusal(error);
+    }
+    const api = [
+        'mockImplementation',
+        'mockClear',
+        'mockReset'
+    ];
+    if (!isMockFunction(probe) || !Array.isArray(probe.mock?.calls) || api.some((name)=>typeof probe[name] !== 'function')) {
+        throw refusal();
+    }
+    mocks$1.runnerFactory = factory;
+}
+/** Whether mocks are made with a runner's function, which {@link useMockFn} registered. */ const usesRunnerMockFn = ()=>mocks$1.runnerFactory !== undefined;
+/** Tracks a mock for clearAllMocks and resetAllMocks. */ function track(mockFn) {
+    const ref = new WeakRef(mockFn);
+    mocks$1.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
@@ -70,7 +143,7 @@ const collected = new FinalizationRegistry((ref)=>created.delete(ref));
  * @category Mocks
  * @see {@link resetAllMocks}
  */ function clearAllMocks() {
-    for (const ref of created)ref.deref()?.mockClear();
+    for (const ref of mocks$1.created)ref.deref()?.mockClear();
 }
 /**
  * Clears every mock from `meocord/testing`, and puts each back to the implementation it was created with.
@@ -93,18 +166,33 @@ 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 mocks$1.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
+        mocks$1.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
  * the last one set wins. The `*Once` variants queue, and run first, in the order they were set.
  *
+ * It records what Vitest's `toHaveResolved` and `toHaveBeenCalledBefore` read as well. Its call order is counted
+ * across meocord's own mocks, apart from the runner's, so compare the order of two of meocord's mocks, or of two of the
+ * runner's, not one of each.
+ *
+ * A promise the implementation returns is handed back as one that settles the same way, not as the same object: test
+ * it with `toEqual`, `toHaveReturnedWith` or by awaiting it, not with `toBe`. A property set on the given promise, such
+ * as a `cancel` method, isn't carried over.
+ *
  * @param impl - The implementation to run until another is set.
  *
  * @example
@@ -122,6 +210,15 @@ const collected = new FinalizationRegistry((ref)=>created.delete(ref));
  * @category Mocks
  * @see {@link MockInstance}
  */ function createMockFn(impl) {
+    const { runnerFactory } = mocks$1;
+    if (runnerFactory) {
+        const runnerMock = runnerFactory(impl);
+        if (impl) {
+            const setImpl = runnerMock.mockImplementation.bind(runnerMock);
+            mocks$1.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.
@@ -131,9 +228,20 @@ const collected = new FinalizationRegistry((ref)=>created.delete(ref));
     const calls = [];
     const results = [];
     const instances = [];
+    const settledResults = [];
+    const invocationCallOrder = [];
+    const contexts = [];
     const mockFn = function(...args) {
         calls.push(args);
         instances.push(this);
+        contexts.push(this);
+        invocationCallOrder.push(++mocks$1.invocationOrder);
+        // Updated in place as the call settles, so a promise's outcome shows once it resolves or rejects
+        const settled = {
+            type: 'incomplete',
+            value: undefined
+        };
+        settledResults.push(settled);
         let type = 'return';
         let value;
         try {
@@ -144,10 +252,36 @@ const collected = new FinalizationRegistry((ref)=>created.delete(ref));
             } else {
                 value = undefined;
             }
+            if (value instanceof Promise) {
+                // Returned in its place, so a rejection nobody awaits stays unhandled in the test, as it is on a bot: a handler
+                // on the implementation's own promise would mark it handled
+                value = value.then((resolved)=>{
+                    Object.assign(settled, {
+                        type: 'fulfilled',
+                        value: resolved
+                    });
+                    return resolved;
+                }, (rejected)=>{
+                    Object.assign(settled, {
+                        type: 'rejected',
+                        value: rejected
+                    });
+                    throw rejected;
+                });
+            } else {
+                Object.assign(settled, {
+                    type: 'fulfilled',
+                    value
+                });
+            }
             return value;
         } catch (err) {
             type = 'throw';
             value = err;
+            Object.assign(settled, {
+                type: 'rejected',
+                value: err
+            });
             throw err;
         } finally{
             results.push({
@@ -175,6 +309,18 @@ const collected = new FinalizationRegistry((ref)=>created.delete(ref));
             return calls.length > 0 ? calls[calls.length - 1] : undefined;
         }
     };
+    // Out of the mock's keys, so a test comparing `mock` as a whole sees the shape it always had
+    Object.defineProperties(mock, {
+        settledResults: {
+            get: ()=>settledResults
+        },
+        invocationCallOrder: {
+            get: ()=>invocationCallOrder
+        },
+        contexts: {
+            get: ()=>contexts
+        }
+    });
     Object.defineProperty(mockFn, 'mock', {
         value: mock,
         enumerable: false
@@ -211,16 +357,22 @@ const collected = new FinalizationRegistry((ref)=>created.delete(ref));
         onceQueue.push(fn);
         return mockFn;
     };
+    const forgetCalls = ()=>{
+        for (const record of [
+            calls,
+            results,
+            instances,
+            settledResults,
+            invocationCallOrder,
+            contexts
+        ])record.length = 0;
+    };
     mockFn.mockClear = ()=>{
-        calls.length = 0;
-        results.length = 0;
-        instances.length = 0;
+        forgetCalls();
         return mockFn;
     };
     mockFn.mockReset = ()=>{
-        calls.length = 0;
-        results.length = 0;
-        instances.length = 0;
+        forgetCalls();
         onceQueue = [];
         currentImpl = impl;
         return mockFn;
@@ -234,10 +386,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 +428,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,9 +486,136 @@ const VISIBLE = new Set([
     }, code, 400, 'POST', 'https://discord.com/api/v10/interactions', {});
 }
 
+/**
+ * The id of the bot every mock client is logged in as, so a test can mention it. Fixed, and below the
+ * ids other mocks take, so it is the same on every run and in any test order, and no mock shares it.
+ */ const MOCK_BOT_ID = '1300000000000000000';
+/**
+ * The last id a mock was given, for both builds of this meocord version; ids count up from a real snowflake, so each
+ * mock's is its own.
+ */ const ids = controller_decorator.shared('mockIds', ()=>({
+        last: 1400000000000000000n
+    }));
+/** A snowflake-shaped id nothing else a mock holds in this run has, for a mock or the media it resolves. */ const nextSnowflake = ()=>String(++ids.last);
+
+// Whether useStrictMocks() is on, and whether a mock was made before it could be, for both builds of this version
+const settings = controller_decorator.shared('strictMocks', ()=>({
+        strict: false,
+        mockMade: false
+    }));
+/** Whether mocks compute discord.js's state, as {@link useStrictMocks} turns on. */ const strictMocks = ()=>settings.strict;
+/** Notes that a mock was made, which useStrictMocks() must come before. */ function noteMockMade() {
+    settings.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, a voice
+ * channel's `full`, 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. So do a message's
+ * `editedAt`, a member's `presence`, a server's `verified` and `systemChannel` and a channel's `parent`, each `null` or
+ * `false` until the test gives what it is computed from. A reaction's `me` is `false`, a message's
+ * `mentions.repliedUser` and a modal's `message` are `null`, and a reaction has a whole message of its own, so
+ * MeoCord's dispatcher fetches neither. 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. A user, server or channel made
+ * with a generated id was created when the mock was made, as a message is. An interaction's `memberPermissions` apply
+ * its channel's overwrites, a thread's parent's for a thread, to its member's permissions. An interaction is in its
+ * message's channel and server, a guild's or a member's server, or, given a `guildId` alone, a server the bot isn't in.
+ * A message the bot sends is its `client.user`'s, and one it sends in a DM is in that DM. 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. An interaction's answer that discord.js would refuse, such as a second `reply()` after one a test set with
+ * `mockResolvedValue`, is refused too, where without it the mock runs it and warns. The next major version (5.0)
+ * computes these values, and refuses those answers, without the call.
+ *
+ * `invoke` also refuses a call that gives a handler fewer arguments than it declares where it builds none, such as a
+ * reaction handler given its reaction without its `ReactionEvent`; without strict mocks, it warns once and calls it.
+ *
+ * `compile()` also refuses an `overrideGuard`, `overrideInterceptor` or `overrideFilter` stub without the stage's
+ * method, `canActivate`, `intercept` or `catch`; without strict mocks, it warns and builds the module.
+ *
+ * @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 (settings.strict) return;
+    if (settings.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.");
+    }
+    settings.strict = true;
+}
+
+const mockLogger$1 = new controller_decorator.Logger('Mocks');
+/**
+ * A member's permissions where an interaction was made, as Discord computes them: under strict mocks, every permission
+ * for an Administrator or the owner, else the channel's overwrites on top of `member.permissions`, so a test that sets
+ * those keeps the base; otherwise `member.permissions`, with a warning once where strict mocks would read otherwise.
+ */ function inChannel(interaction, member) {
+    const base = member.permissions;
+    // Only a server the mock caches has the overwrites to apply
+    const { guild } = interaction;
+    if (!(guild instanceof discord_js.Guild)) return base;
+    const computed = base.has(discord_js.PermissionFlagsBits.Administrator) || member.id === guild.ownerId ? new discord_js.PermissionsBitField(discord_js.PermissionsBitField.All).freeze() : withOverwrites(base, overwritingChannel(interaction, guild), member);
+    if (strictMocks()) return computed;
+    if (!computed.equals(base)) {
+        const lost = new discord_js.PermissionsBitField(base).remove(computed).toArray();
+        const gained = new discord_js.PermissionsBitField(computed).remove(base).toArray();
+        const change = lost.length > 0 ? [
+            `without ${lost.join(', ')}`
+        ] : [];
+        if (gained.length > 0) change.push(`with ${gained.join(', ')}`);
+        controller_decorator.warnOnce(mockLogger$1, `${interaction.constructor.name}.memberPermissions reads the member's own permissions here, without the ` + "channel's overwrites or every permission an Administrator or the owner has; in the next major version (5.0) " + `it reads them as Discord computes them in the channel, ${change.join(' and ')}. Set memberPermissions on the ` + 'mock, or call useStrictMocks() to compute them now.');
+    }
+    // Unless the test set them, a member's permissions come from its roles, @everyone's included
+    if (!Object.prototype.hasOwnProperty.call(member, 'permissions')) warnOnUnsetEveryone(interaction, guild, 'memberPermissions', base);
+    return base;
+}
+/**
+ * Warns once, as `key`, where `permissions` read a server's @everyone role default mode made with none, and lack what
+ * strict mocks give @everyone in a new server.
+ */ function warnOnUnsetEveryone(interaction, guild, key, permissions) {
+    const everyone = guild.roles.everyone;
+    if (!everyone || !isUnsetEveryone(everyone) || permissions.has(NEW_SERVER_EVERYONE_PERMISSIONS)) return;
+    controller_decorator.warnOnce(mockLogger$1, `${interaction.constructor.name}.${key} reads the server's @everyone role here with no permissions; in the next major ` + 'version (5.0) it has the permissions Discord gives @everyone in a new server, as strict mocks read it. Set ' + 'guild.roles.everyone.permissions, or call useStrictMocks() to read it so now.');
+}
+/**
+ * The channel whose overwrites apply where an interaction was made, read without making or caching one: a thread's
+ * parent, or undefined where the channel, or a thread's parent, is one the mock would make, which has none.
+ */ function overwritingChannel(interaction, guild) {
+    const channel = heldChannelOf(interaction, guild);
+    // A thread's parent by the id the test gave it or one already read, so strict mocks' parent isn't made for this read
+    const parentId = (thread)=>Object.prototype.hasOwnProperty.call(thread, 'parentId') ? thread.parentId : madeParentIds.get(thread);
+    const at = channel instanceof discord_js.ThreadChannel ? guild.channels.cache.get(parentId(channel) ?? '') : channel;
+    return at instanceof discord_js.GuildChannel ? at : undefined;
+}
+// The parent id strict mocks made for each thread made without one, once read
+const madeParentIds = new WeakMap();
+// Private in discord.js's typings, though they are what its own permissionsFor computes with; called on the prototype
+// so a test's stub on the channel stays for its caller
+const channelPermissions = discord_js.GuildChannel.prototype;
+/** `base` with `channel`'s overwrites for `member` applied, in discord.js's order: @everyone's, the roles', the member's. */ function withOverwrites(base, channel, member) {
+    if (!channel) return base;
+    // Given the member and its roles as verified, as discord.js's memberPermissions does, so it resolves nothing again
+    const overwrites = channelPermissions.overwritesFor.call(channel, member, true, member.roles.cache);
+    return new discord_js.PermissionsBitField(base).remove(overwrites.everyone?.deny ?? 0n).add(overwrites.everyone?.allow ?? 0n).remove(overwrites.roles.length > 0 ? overwrites.roles.map((role)=>role.deny) : 0n).add(overwrites.roles.length > 0 ? overwrites.roles.map((role)=>role.allow) : 0n).remove(overwrites.member?.deny ?? 0n).add(overwrites.member?.allow ?? 0n).freeze();
+}
 /** 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();
 /** A class and its defaults, typed together so a default that stops fitting its property fails to compile. */ const defaultsOf = (Class, defaults)=>[
         Class.prototype,
         defaults
@@ -352,7 +628,7 @@ const snowflake = ()=>discord_js.SnowflakeUtil.generate().toString();
     defaultsOf(discord_js.Guild, {
         name: ()=>'Guild',
         preferredLocale: ()=>discord_js.Locale.EnglishUS,
-        ownerId: snowflake,
+        ownerId: nextSnowflake,
         memberCount: ()=>1,
         available: ()=>true,
         large: ()=>false,
@@ -365,6 +641,9 @@ const snowflake = ()=>discord_js.SnowflakeUtil.generate().toString();
         shardId: ()=>0,
         nsfwLevel: ()=>discord_js.GuildNSFWLevel.Default,
         verificationLevel: ()=>discord_js.GuildVerificationLevel.None,
+        presences: (guild)=>ownedManager(discord_js.PresenceManager.prototype, {
+                guild
+            }),
         premiumTier: ()=>discord_js.GuildPremiumTier.None,
         createdTimestamp: REAL_GETTER,
         createdAt: REAL_GETTER
@@ -379,6 +658,7 @@ const snowflake = ()=>discord_js.SnowflakeUtil.generate().toString();
         discriminator: ()=>'0',
         avatar: ()=>null,
         system: ()=>false,
+        flags: ()=>new discord_js.UserFlagsBitField(),
         tag: REAL_GETTER,
         displayName: REAL_GETTER,
         defaultAvatarURL: REAL_GETTER,
@@ -399,12 +679,12 @@ const snowflake = ()=>discord_js.SnowflakeUtil.generate().toString();
         premiumSinceTimestamp: ()=>null,
         communicationDisabledUntilTimestamp: ()=>null,
         pending: ()=>false,
+        flags: ()=>new discord_js.GuildMemberFlagsBitField().freeze(),
         displayName: REAL_GETTER,
         roles: (member)=>memberRoles(member, []),
         permissions: REAL_GETTER
     }),
     defaultsOf(discord_js.Role, {
-        id: snowflake,
         name: ()=>'role',
         // Above @everyone, which a server's role manager makes at position 0
         position: ()=>1,
@@ -442,30 +722,71 @@ const snowflake = ()=>discord_js.SnowflakeUtil.generate().toString();
         poll: ()=>null,
         interactionMetadata: ()=>null,
         stickers: ()=>new discord_js.Collection(),
+        messageSnapshots: ()=>new discord_js.Collection(),
+        reactions: (message)=>ownedManager(discord_js.ReactionManager.prototype, {
+                message
+            }),
         url: REAL_GETTER
     }),
     // A command's name and a component's customId say which handler a call is for, so they stay the test's to give
+    defaultsOf(discord_js.ChatInputCommandInteraction, {
+        options: ()=>createChatInputOptions()
+    }),
     defaultsOf(discord_js.CommandInteraction, {
-        commandId: snowflake,
+        commandId: nextSnowflake,
         commandGuildId: ()=>null
     }),
     defaultsOf(discord_js.AutocompleteInteraction, {
-        commandId: snowflake,
-        commandGuildId: ()=>null
+        commandId: nextSnowflake,
+        commandGuildId: ()=>null,
+        options: ()=>createChatInputOptions()
+    }),
+    defaultsOf(discord_js.MessageReaction, {
+        users: (reaction)=>ownedManager(discord_js.ReactionUserManager.prototype, {
+                reaction
+            })
     }),
     defaultsOf(discord_js.BaseInteraction, {
-        applicationId: snowflake,
+        applicationId: nextSnowflake,
         token: ()=>'mock-interaction-token',
         version: ()=>1,
         context: ()=>null,
+        entitlements: ()=>new discord_js.Collection(),
         // 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,
-        // 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;
-            const me = guild instanceof discord_js.Guild ? guild.members.me : null;
-            return (me && channel instanceof discord_js.GuildChannel ? channel.permissionsFor(me) : null) ?? noPermissions();
-        }
+        // Each reads where the interaction is as its own, and warns by its own name where strict mocks place it otherwise
+        memberPermissions: (interaction)=>readPlaceAs(interaction, 'memberPermissions', ()=>{
+                const { guildId } = interaction;
+                const member = interaction.member;
+                if (!guildId) return null;
+                if (member instanceof discord_js.GuildMember) return inChannel(interaction, member);
+                // 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 in a thread its parent, as
+        // discord.js computes them; none outside a server
+        appPermissions: (interaction)=>readPlaceAs(interaction, 'appPermissions', ()=>{
+                const { guild } = interaction;
+                const me = guild instanceof discord_js.Guild ? botMemberOf(guild) : null;
+                if (!(me instanceof discord_js.GuildMember) || heldChannelOf(interaction, guild) === null) return noPermissions();
+                // discord.js's own computation, given its own overwritesFor over a test's stub on the channel; a channel the
+                // mock would make has no overwrites
+                const at = overwritingChannel(interaction, guild) ?? {
+                    guild,
+                    permissionOverwrites: {
+                        cache: new discord_js.Collection()
+                    }
+                };
+                const channel = Object.create(at, {
+                    overwritesFor: {
+                        value: channelPermissions.overwritesFor
+                    }
+                });
+                const permissions = channelPermissions.memberPermissions.call(channel, me, true);
+                // The bot's member has @everyone's too
+                warnOnUnsetEveryone(interaction, guild, 'appPermissions', permissions);
+                return permissions;
+            }, // A server the bot isn't in has no guild in either mode, so no permissions in both
+            (place)=>!place.raw)
     }),
     defaultsOf(discord_js.TextChannel, {
         type: ()=>discord_js.ChannelType.GuildText,
@@ -501,7 +822,7 @@ const snowflake = ()=>discord_js.SnowflakeUtil.generate().toString();
     }),
     defaultsOf(discord_js.GuildChannel, {
         name: ()=>'channel',
-        guildId: (channel)=>typeof channel.guild?.id === 'string' ? channel.guild.id : snowflake(),
+        guildId: (channel)=>typeof channel.guild?.id === 'string' ? channel.guild.id : nextSnowflake(),
         position: ()=>0,
         rawPosition: ()=>0,
         parentId: ()=>null
@@ -520,20 +841,139 @@ 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) {
+/**
+ * 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: ()=>'',
+        editedTimestamp: ()=>null,
+        editedAt: REAL_GETTER
+    }),
+    defaultsOf(discord_js.MessageMentions, {
+        repliedUser: ()=>null
+    }),
+    defaultsOf(discord_js.Guild, {
+        rulesChannelId: ()=>null,
+        publicUpdatesChannelId: ()=>null,
+        systemChannel: REAL_GETTER
+    }),
+    defaultsOf(discord_js.BaseGuild, {
+        verified: REAL_GETTER
+    }),
+    defaultsOf(discord_js.GuildMember, {
+        presence: REAL_GETTER
+    }),
+    defaultsOf(discord_js.ModalSubmitInteraction, {
+        message: ()=>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);
+            madeParentIds.set(thread, parent.id);
+            return parent.id;
+        },
+        parent: REAL_GETTER,
+        ownerId: nextSnowflake,
+        archived: ()=>false,
+        locked: ()=>false
+    }),
+    defaultsOf(discord_js.GuildChannel, {
+        guild: ()=>createMockGuild(),
+        parent: REAL_GETTER
+    }),
+    // 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
+    }),
+    // A reaction's message, as discord.js always has one, is a whole one
+    defaultsOf(discord_js.MessageReaction, {
+        count: ()=>1,
+        me: ()=>false,
+        message: ()=>createMockMessage()
+    })
+]);
+/**
+ * What a mock reads as a placeholder unless strict mocks read it as discord.js gives it, by the value a test sets for
+ * that, which the warning on reading one names.
+ */ const PLACEHOLDER_VALUES = new Map([
+    [
+        discord_js.MessageReaction.prototype,
+        {
+            me: 'false',
+            message: 'createMockMessage()'
+        }
+    ],
+    [
+        discord_js.MessageMentions.prototype,
+        {
+            repliedUser: 'null'
+        }
+    ],
+    [
+        discord_js.Message.prototype,
+        {
+            editedAt: 'null'
+        }
+    ],
+    [
+        discord_js.GuildMember.prototype,
+        {
+            presence: 'null'
+        }
+    ],
+    [
+        discord_js.BaseGuild.prototype,
+        {
+            verified: 'false'
+        }
+    ],
+    [
+        discord_js.Guild.prototype,
+        {
+            systemChannel: 'null'
+        }
+    ],
+    [
+        discord_js.GuildChannel.prototype,
+        {
+            parent: 'null'
+        }
+    ],
+    [
+        discord_js.ModalSubmitInteraction.prototype,
+        {
+            message: 'null'
+        }
+    ]
+]);
+/** The value a test sets for `key` on a mock of `target`'s class, when a mock reads it as a placeholder. */ function placeholderValue(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;
+        const value = PLACEHOLDER_VALUES.get(proto)?.[key];
+        if (value !== undefined) return value;
+    }
+    return undefined;
+}
+/** 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;
 }
-
-/**
- * The id of the bot every mock client is logged in as, so a test can mention it. Fixed, and below the
- * ids other mocks take, so it is the same on every run and in any test order, and no mock shares it.
- */ const MOCK_BOT_ID = '1300000000000000000';
-/** The last id a mock was given; ids count up from a real snowflake, so each mock's is its own. */ let lastSnowflake = 1400000000000000000n;
-/** A snowflake-shaped id nothing else a mock holds in this run has, for a mock or the media it resolves. */ const nextSnowflake = ()=>String(++lastSnowflake);
 
 /** Where a mock resolves unfurled media to, as Discord's media proxy would. */ const PROXY = 'https://images-ext-1.discordapp.net/external/mock';
 /** Unfurled media as Discord stores it: the url given, resolved to a proxied image of a fixed size. */ function resolvedMedia(media) {
@@ -664,8 +1104,15 @@ const SKIP = new Set([
     'toJSON',
     'then'
 ]);
+// Each mock's own instance, which the proxy's traps receive as their target
+const mockTargets = new WeakMap();
+// Warnings a read answered by the stub logs first, by the mock's instance and the property
+const stubReadWarnings = new WeakMap();
 function stubDeep(instance, externalStubs, onSet) {
+    noteMockMade();
     const stubs = externalStubs ?? new Map();
+    // Placeholders read so far, by the value strict mocks give: a read of a kept one still warns, once
+    const placeholders = new Map();
     const proxy = new Proxy(instance, {
         get (target, prop) {
             // Always pass through symbols
@@ -679,12 +1126,17 @@ function stubDeep(instance, externalStubs, onSet) {
             if (Object.prototype.hasOwnProperty.call(target, key)) {
                 return Reflect.get(target, prop, target);
             }
+            stubReadWarnings.get(target)?.get(key)?.();
             // Skip passthrough props — return prototype value as-is
             if (SKIP.has(key)) {
                 return Reflect.get(target, prop, target);
             }
             // Return cached stub
-            if (stubs.has(key)) return stubs.get(key);
+            if (stubs.has(key)) {
+                const kept = placeholders.get(key);
+                if (kept !== undefined) warnPlaceholderRead(target, key, kept);
+                return stubs.get(key);
+            }
             // A value discord.js always gives, in its shape, rather than a stub: kept once read, or its getter run live
             const known = discordDefault(target, key);
             if (known === REAL_GETTER) {
@@ -698,6 +1150,12 @@ function stubDeep(instance, externalStubs, onSet) {
                 stubs.set(key, value);
                 return value;
             }
+            // A value strict mocks read as discord.js gives it, which is a placeholder otherwise
+            const strictValue = strictMocks() ? undefined : placeholderValue(target, key);
+            if (strictValue !== undefined) {
+                placeholders.set(key, strictValue);
+                warnPlaceholderRead(target, key, strictValue);
+            }
             // Walk the prototype chain to check if it's a function
             let proto = Object.getPrototypeOf(target);
             let protoValue;
@@ -705,14 +1163,18 @@ 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);
+                        warnPlaceholderRead(target, key, 'false');
+                    }
                     break;
                 }
                 proto = Object.getPrototypeOf(proto);
             }
             // A client the mock's structures share: its guild's, or one of its own
             if (key === 'client' && target instanceof discord_js.Base) return clientOf(target);
-            const stub = typeof protoValue === 'function' ? isRealMethod(target, key) ? createMockFn((...args)=>protoValue.apply(proxy, args)) : methodStub(target, key, protoValue, ()=>proxy) : stubDeep({});
+            const stub = typeof protoValue === 'function' ? isRealMethod(target, key) ? createMockFn((...args)=>quietly(target, key, ()=>protoValue.apply(proxy, args))) : methodStub(target, key, protoValue, ()=>proxy) : stubDeep({});
             stubs.set(key, stub);
             return stub;
         },
@@ -721,7 +1183,10 @@ function stubDeep(instance, externalStubs, onSet) {
         // and a plain write against one of those throws. Defining an own
         // data property shadows the accessor, which is what test setup means.
         set (target, prop, value) {
-            Object.defineProperty(target, prop, {
+            // An own accessor with a setter, such as a context menu's target, takes the value itself
+            const setter = Object.getOwnPropertyDescriptor(target, prop)?.set;
+            if (setter) setter.call(target, value);
+            else Object.defineProperty(target, prop, {
                 value,
                 writable: true,
                 enumerable: true,
@@ -731,6 +1196,7 @@ function stubDeep(instance, externalStubs, onSet) {
             return true;
         }
     });
+    mockTargets.set(proxy, instance);
     return proxy;
 }
 // discord.js methods that read only what the mock holds, so they run for real: looking items up in a manager's cache,
@@ -795,9 +1261,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;
 }
@@ -854,7 +1329,14 @@ const PLACEHOLDER_BOOLEANS = new Map([
     [
         discord_js.BaseGuildVoiceChannel.prototype,
         new Set([
-            'joinable'
+            'joinable',
+            'full'
+        ])
+    ],
+    [
+        discord_js.VoiceChannel.prototype,
+        new Set([
+            'speakable'
         ])
     ],
     [
@@ -876,11 +1358,49 @@ 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) {
+// Mock reactions, and their messages, that MeoCord's dispatcher reads `partial` on
+const dispatchedReactions = new WeakSet();
+let quiet = 0;
+/**
+ * Runs a real method, keeping quiet about the placeholders `mentions.has()` reads: a placeholder `repliedUser` matches
+ * no user, so its answer is discord.js's either way.
+ */ function quietly(target, key, run) {
+    if (!(target instanceof discord_js.MessageMentions && key === 'has')) return run();
+    quiet++;
+    try {
+        return run();
+    } finally{
+        quiet--;
+    }
+}
+/**
+ * Marks a mock reaction and its message as read by MeoCord's dispatcher, so a placeholder `partial` it reads warns
+ * that MeoCord read it, and fetched for it.
+ */ function noteReactionDispatch(reaction) {
+    const target = mockTargets.get(reaction);
+    if (!target) return;
+    dispatchedReactions.add(target);
+    const message = mockTargets.get(reaction.message ?? {});
+    if (message) dispatchedReactions.add(message);
+}
+function warnPlaceholderRead(target, key, strictValue) {
+    if (quiet > 0) return;
     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.`);
+    if (key === 'partial' && dispatchedReactions.has(target)) {
+        const fetched = target instanceof discord_js.MessageReaction ? 'the reaction' : "the reaction's message";
+        controller_decorator.warnPlaceholder(mockLogger, `${name}.${key}`, 'the mock computes it as discord.js does', `MeoCord's dispatcher read it while dispatching the reaction, and fetched ${fetched} since the placeholder is truthy. ` + 'Set reaction.partial = false and reaction.message.partial = false on the mock, or call useStrictMocks() to have the mock compute them now.');
+        return;
+    }
+    // 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} = ${strictValue}, 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();
@@ -988,25 +1508,37 @@ const MANAGER_ITEMS = [
     ],
     [
         discord_js.RoleManager,
-        (id)=>createMockInteraction(discord_js.Role, id ? {
-                id
-            } : {})
+        (id, manager)=>createMockInteraction(discord_js.Role, {
+                ...id ? {
+                    id
+                } : {},
+                ...guildOf(manager) ? {
+                    guild: guildOf(manager)
+                } : {}
+            })
     ],
     [
         discord_js.GuildBanManager,
         ()=>createMockInteraction(discord_js.GuildBan)
     ],
+    // A message fetched from a channel is in it, and another user's
     [
         discord_js.GuildMessageManager,
-        (id)=>createMockMessage(id ? {
-                id
-            } : {})
+        (id, manager)=>createMockMessage({
+                ...id ? {
+                    id
+                } : {},
+                ...channelOfManager(manager)
+            })
     ],
     [
         discord_js.DMMessageManager,
-        (id)=>createMockMessage(id ? {
-                id
-            } : {})
+        (id, manager)=>createMockMessage({
+                ...id ? {
+                    id
+                } : {},
+                ...channelOfManager(manager)
+            })
     ],
     [
         discord_js.GuildTextThreadManager,
@@ -1024,6 +1556,12 @@ const MANAGER_ITEMS = [
         discord_js.ThreadMemberManager,
         ()=>createMockInteraction(discord_js.ThreadMember)
     ],
+    [
+        discord_js.ReactionUserManager,
+        (id)=>createMockUser(id ? {
+                id
+            } : {})
+    ],
     [
         discord_js.ApplicationCommandManager,
         (id)=>createMockInteraction(discord_js.ApplicationCommand, id ? {
@@ -1051,6 +1589,12 @@ const MANAGER_ITEMS = [
 const returnsPromise = (key, method)=>method.constructor.name === 'AsyncFunction' || PROMISE_METHODS.has(key) || /^set[A-Z]/.test(key) && !SYNC_SETTERS.has(key);
 // The ids a fetch asks for: an id, a discord.js object, or options naming one or several, such as `{ user: id }` or
 // `{ user: [ids] }`; undefined for a fetch of a list
+/** The channel a message manager belongs to, as `createMockMessage` takes it. */ const channelOfManager = (manager)=>{
+    const channel = manager.channel;
+    return channel instanceof discord_js.BaseChannel ? {
+        channel: channel
+    } : {};
+};
 function fetchedIds(args) {
     const idOf = (value)=>typeof value === 'string' ? value : value instanceof discord_js.Base ? value.id : undefined;
     const [first] = args;
@@ -1086,6 +1630,10 @@ function fetchedIds(args) {
     if (key === 'send' && target instanceof discord_js.User) {
         return createMockFn(async (...args)=>(await receiver().createDM()).send(...args));
     }
+    // A channel's send resolves to the message it sent there
+    if (key === 'send' && target instanceof discord_js.BaseChannel) {
+        return createMockFn(async (options)=>sentMessage(sent(options, false), receiver()));
+    }
     if (MESSAGE_METHODS.has(key)) return createMockFn(async ()=>createMockMessage());
     if (target instanceof discord_js.BaseManager) {
         const item = MANAGER_ITEMS.find(([Manager])=>Manager.prototype.isPrototypeOf(target))?.[1];
@@ -1102,7 +1650,24 @@ function fetchedIds(args) {
                 return ids === undefined ? new discord_js.Collection() : one(ids);
             });
         }
-        if (item && (key === 'create' || key === 'edit')) return createMockFn(async ()=>item(undefined, receiver()));
+        if (item && key === 'edit') return createMockFn(async ()=>item(undefined, receiver()));
+        // A ban resolves to the member, user or id it was given, as discord.js's does, and caches nothing
+        if (key === 'create' && target instanceof discord_js.GuildBanManager) {
+            return createMockFn(async (user)=>{
+                if (user instanceof discord_js.GuildMember) return user;
+                if (user instanceof discord_js.User) return receiver().guild.members.resolve(user) ?? user;
+                return typeof user === 'string' ? user : user?.id;
+            });
+        }
+        // Every other manager here caches what its create() makes, as discord.js's does; check a manager's create when
+        // adding it to MANAGER_ITEMS
+        if (item && key === 'create') {
+            return createMockFn(async ()=>{
+                const made = item(undefined, receiver());
+                if (typeof made.id === 'string') cacheOf(receiver())?.set(made.id, made);
+                return made;
+            });
+        }
     } else if (target instanceof discord_js.Base && (SELF_METHODS.has(key) || /^set[A-Z]/.test(key))) {
         return createMockFn(async ()=>receiver());
     }
@@ -1262,23 +1827,46 @@ 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) {
+ * Gives a user, server or channel mock its creation time. Under strict mocks, a generated id gives the time the mock
+ * was made, as a message's. Otherwise it gives that id's own time, a fixed day in 2025, with a warning once when read.
+ * An id the test gives decides it in both modes, and a value the test sets replaces it.
+ */ function defineMadeTime(mock, generatedId) {
+    if (strictMocks()) return defineCreatedTime(mock, generatedId);
+    const own = (key)=>Object.prototype.hasOwnProperty.call(mock, key);
+    const name = Object.getPrototypeOf(mock).constructor.name;
+    if (!own('createdTimestamp')) {
+        Object.defineProperty(mock, 'createdTimestamp', {
+            get () {
+                if (this.id === generatedId) {
+                    controller_decorator.warnOnce(mockLogger, `${name}.createdTimestamp reads the time of its generated id here, a fixed day in 2025; in the next major version (5.0) ` + 'it is the time the mock was made. Give the mock an id or a createdTimestamp, or call useStrictMocks() to have it read the time the mock was made now.');
+                }
+                return isSnowflake(this.id) ? discord_js.SnowflakeUtil.timestampFrom(this.id) : null;
+            },
+            configurable: true
+        });
+    }
+    if (!own('createdAt')) {
+        Object.defineProperty(mock, 'createdAt', {
+            get () {
+                return this.createdTimestamp === null ? null : new Date(this.createdTimestamp);
+            },
+            configurable: true
+        });
+    }
+}
+/**
+ * Where a mock interaction keeps every answer it got, through respond() or discord.js directly, in order, under a key
+ * both builds of this meocord version read.
+ */ const RESPONSE_LOG = Symbol.for(controller_decorator.sharedName('responseLog'));
+/**
+ * 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, and `gate` keeps the
+ * reply state whichever behaviour runs. `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, gate) {
+    const record = (behaviour, byTest = true)=>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 = {
@@ -1287,34 +1875,81 @@ const ANSWER_METHODS = [
             };
             controller_decorator.stampCall(call);
             log.push(call);
+            let undo;
             try {
-                const result = Reflect.apply(target, self, 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)=>{
-                        call.error = error;
-                        throw error;
-                    });
-                }
-                return result;
+                // Before the behaviour, as discord.js changes the state at once: a second answer made without awaiting is refused
+                if (gate) undo = gate(args, byTest);
             } catch (error) {
+                call.error = error;
+                return Promise.reject(error);
+            }
+            const failed = (error)=>{
+                undo?.();
                 call.error = error;
                 throw error;
+            };
+            try {
+                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, failed);
+                return result;
+            } catch (error) {
+                return failed(error);
             }
-        }
-    });
+        };
+    const mock = createMockFn(record(impl, false));
+    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 throws it, with its code, and with `message` in place of discord.js's own text when given. */ function discordjsError(code, message) {
+    const error = new discord_js.DiscordjsError(code);
+    if (message !== undefined) error.message = message;
+    return error;
+}
 /** 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);
 // In discord.js's error codes, though missing from its typings
 const INVALID_CHANNEL_TYPE = 'CommandInteractionOptionInvalidChannelType';
 /** Records the interaction a mock options resolver belongs to. */ const ownOptions = (interaction, options)=>{
     if (typeof options === 'object' && options !== null) optionOwners.set(options, interaction);
 };
-/** A mock user that is a person, with an id of its own unless given one. */ const mockUser = (id = nextSnowflake())=>stubDeep(Object.assign(Object.create(discord_js.User.prototype), {
-        id,
+/** A mock user that is a person, with an id of its own unless given one. */ const mockUser = (id)=>{
+    const generatedId = id === undefined ? nextSnowflake() : undefined;
+    const user = Object.assign(Object.create(discord_js.User.prototype), {
+        id: id ?? generatedId,
         bot: false
-    }));
+    });
+    defineMadeTime(user, generatedId);
+    return stubDeep(user);
+};
 function createMockInteraction(Class, props) {
     const instance = Object.create(Class.prototype);
     const stubs = new Map();
@@ -1334,14 +1969,36 @@ function createMockInteraction(Class, props) {
     // mock lacks: a guildId is a guild, a guild object with it a cached one, neither a DM. A member
     // not given is the user's on an interaction, and the auto-stub elsewhere, so only one set to null or undefined fails.
     const own = (key)=>Object.prototype.hasOwnProperty.call(instance, key) ? instance[key] : undefined;
+    let strictPlace;
     const hasMember = ()=>!Object.prototype.hasOwnProperty.call(instance, 'member') || Boolean(instance.member);
     const guildChecks = {
         inGuild: ()=>Boolean(own('guildId') && hasMember()),
         inCachedGuild: ()=>Boolean(own('guildId') && own('guild') && hasMember()),
         inRawGuild: ()=>Boolean(own('guildId') && !own('guild') && hasMember())
     };
+    // What each answers where strict mocks place the mock: the place's guildId and guild for those the test left out, and
+    // a member wherever there is a guildId, unless the test gave one
+    const given = new Set(Object.keys(props ?? {}));
+    const strictChecks = (place)=>{
+        const pick = (key, placed)=>given.has(key) || placed === undefined ? own(key) : placed;
+        const guildId = pick('guildId', place.guildId);
+        const guild = place.raw ? null : pick('guild', place.guild);
+        const member = given.has('member') ? Boolean(own('member')) : Boolean(guildId);
+        return {
+            inGuild: Boolean(guildId && member),
+            inCachedGuild: Boolean(guildId && guild && member),
+            inRawGuild: Boolean(guildId && !guild && member)
+        };
+    };
+    // Each reads where the mock is as its own, and in default mode warns once, by its own name, where strict mocks answer
+    // otherwise or refuse the mock
     for (const [name, check] of Object.entries(guildChecks)){
-        if (findPrototypeMethod(instance, name) !== null) stubs.set(name, createMockFn(check));
+        if (findPrototypeMethod(instance, name) === null) continue;
+        stubs.set(name, createMockFn(()=>{
+            const answer = readPlaceQuietly(check);
+            if (strictPlace && !strictMocks() && (strictPlace.refused || strictChecks(strictPlace)[name] !== answer)) placeWarners.get(instance)?.warn(`${name}()`);
+            return answer;
+        }));
     }
     // Set up reply state machine for repliable interactions
     const isRepliableMethod = findPrototypeMethod(instance, 'isRepliable');
@@ -1350,86 +2007,204 @@ function createMockInteraction(Class, props) {
         instance.replied = false;
         instance.deferred = false;
         instance.ephemeral = false;
-        const alreadyReplied = ()=>new Error('The reply to this interaction has already been sent or deferred.');
-        const notYetReplied = (method)=>new Error(`Cannot call ${method}() before replying or deferring.`);
+        // discord.js's errors, with their codes; a call before any answer keeps the message the mock has always given
+        const alreadyReplied = ()=>discordjsError(discord_js.DiscordjsErrorCodes.InteractionAlreadyReplied);
+        const notYetReplied = (method)=>discordjsError(discord_js.DiscordjsErrorCodes.InteractionNotReplied, `Cannot call ${method}() before replying or deferring.`);
         // Only `flags` is read: discord.js deprecates the `ephemeral: true` reply option, and honouring it here would let
-        // a test pass against a deprecated call.
+        // a test pass against a deprecated call. Read as discord.js reads them, so a flag it refuses throws here too.
         const hasEphemeralFlag = (options)=>{
-            if (!options) return false;
-            const { flags } = options;
-            if (typeof flags === 'number') return (flags & 64) !== 0;
-            if (typeof flags === 'bigint') return (flags & 64n) !== 0n;
-            return false;
+            const flags = options?.flags;
+            if (typeof options !== 'object' || flags === null || flags === undefined) return false;
+            return new discord_js.MessageFlagsBitField(flags).has(discord_js.MessageFlags.Ephemeral);
         };
-        stubs.set('reply', createMockFn(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)=>{
-            if (instance.deferred || instance.replied) throw alreadyReplied();
-            instance.deferred = true;
-            if (hasEphemeralFlag(args[0])) instance.ephemeral = true;
-        }));
-        stubs.set('followUp', createMockFn(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.
-        let held;
-        const current = ()=>held ?? (held = heldFrom(instance.message));
+        const built = (held)=>typeof held === 'function' ? held() : held;
+        let original;
+        let originalGone = false;
+        const followUps = new Map();
+        // Whether the last answer ran a behaviour a test set, after which a second answer runs with a warning by default
+        let answeredByTest = false;
         // A command answered with a modal has no original response, and Discord refuses one asked for
         let modalAnswered = false;
+        const isComponent = instance.type === discord_js.InteractionType.MessageComponent;
+        // The original response of a component, or of a modal submitted from one, is the message it's on
+        const componentMessage = ()=>heldFrom(instance.message);
+        const snapshot = ()=>{
+            const saved = {
+                replied: instance.replied,
+                deferred: instance.deferred,
+                ephemeral: instance.ephemeral,
+                original,
+                originalGone,
+                followUps: new Map(followUps),
+                answeredByTest,
+                modalAnswered
+            };
+            return ()=>{
+                Object.assign(instance, {
+                    replied: saved.replied,
+                    deferred: saved.deferred,
+                    ephemeral: saved.ephemeral
+                });
+                ({ original, originalGone, answeredByTest, modalAnswered } = saved);
+                followUps.clear();
+                for (const [id, held] of saved.followUps)followUps.set(id, held);
+            };
+        };
+        /**
+     * Refuses an answer as discord.js does. Where the refusal turns on a behaviour a test set, this answer's or the
+     * one before it, which ran without one, default mode warns and lets it run; strict mocks refuse it.
+     */ const refuse = (method, error, byTest)=>{
+            if (!(byTest || answeredByTest) || strictMocks()) throw error;
+            controller_decorator.warnOnce(mockLogger, `${method}() here is refused by discord.js with "${error.message}", but the mock runs it, as a test set this ` + 'answer or the one before it. In the next major version (5.0) the mock refuses it; call useStrictMocks() to ' + 'have it refused now.');
+        };
+        const answered = ()=>instance.deferred || instance.replied;
+        /**
+     * What an answer sends, built now, as discord.js builds it when sending. One it refuses to build is refused under
+     * strict mocks; default mode warns and holds it to build when first read.
+     */ const hold = (method, build)=>{
+            try {
+                return build();
+            } catch (error) {
+                if (strictMocks()) throw error;
+                controller_decorator.warnOnce(mockLogger, `${method}() here sends what discord.js refuses to build: "${error.message}". The mock sends it and ` + 'builds it when read; in the next major version (5.0) it rejects, as discord.js does. Call useStrictMocks() to ' + 'have it rejected now.');
+                return build;
+            }
+        };
+        /** A first answer: refused once the interaction has one, else it replies or defers. */ const first = (method, kind, then)=>(args, byTest)=>{
+                if (answered()) refuse(method, alreadyReplied(), byTest);
+                // Read first: flags discord.js refuses throw before anything changes
+                const ephemeral = method === 'reply' || method === 'deferReply' ? hasEphemeralFlag(args[0]) : undefined;
+                const undo = snapshot();
+                instance[kind] = true;
+                if (ephemeral) instance.ephemeral = true;
+                answeredByTest = byTest;
+                try {
+                    then(args);
+                } catch (error) {
+                    undo();
+                    throw error;
+                }
+                return undo;
+            };
+        /** A later answer: refused before the interaction has one. */ const later = (method, then)=>(args, byTest)=>{
+                if (!answered()) refuse(method, notYetReplied(method), byTest);
+                const undo = snapshot();
+                try {
+                    then(args);
+                } catch (error) {
+                    undo();
+                    throw error;
+                }
+                return undo;
+            };
+        /** The id an edit, fetch or delete names, `undefined` for the original response. */ const targetId = (message)=>{
+            if (message === undefined || message === '@original') return undefined;
+            return typeof message === 'string' ? message : message.id ?? undefined;
+        };
+        /** The message an edit, fetch or delete reaches, or why Discord refuses it: it is gone or never was. */ const target = (id)=>{
+            if (id !== undefined) {
+                const held = followUps.get(id);
+                if (held) followUps.set(id, built(held));
+                return held && built(held);
+            }
+            if (originalGone || modalAnswered) return undefined;
+            // Answered without one of the mock's calls, as after a 40060 or a test setting `replied`: the original is there
+            if (!original && answered()) original = componentMessage();
+            if (original) original = built(original);
+            // An answer's message gets its id when first read, as it would be built then without strict mocks
+            if (original?.id === '') original = {
+                ...original,
+                id: nextSnowflake()
+            };
+            return original;
+        };
         const unknownMessage = ()=>createDiscordError(10008, 'Unknown Message');
-        stubs.set('editReply', createMockFn(async (options)=>{
-            if (!instance.deferred && !instance.replied) throw notYetReplied('editReply');
-            if (modalAnswered) throw unknownMessage();
+        // Where its answers are sent, read as the mock's own, so a placement warning stays the test's
+        const answeredIn = ()=>readPlaceQuietly(()=>[
+                    instance.channel,
+                    instance.client
+                ]);
+        // What each answer's message made for itself, by its id, so every read of it has the same author and place
+        const madePlaces = new Map();
+        const madeFor = (id)=>madePlaces.get(id) ?? madePlaces.set(id, {}).get(id);
+        // Each call's message, read by its behaviour right after the gate made it
+        let made;
+        let followUpMade;
+        // 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, gate)=>stubs.set(method, recordedMock(method, impl, log, gate));
+        answer('reply', async ()=>undefined, first('reply', 'replied', ([options])=>original = hold('reply', ()=>sent(options, false))));
+        answer('deferReply', async ()=>undefined, first('deferReply', 'deferred', ()=>original = sent(undefined)));
+        answer('followUp', // The follow-up as sent, which an edit, fetch or delete reaches by its id
+        async ()=>{
+            const held = followUps.get(followUpMade);
+            // One held to build when read resolves to its id alone, as building it now would refuse it
+            return typeof held === 'function' ? createMockMessage({
+                id: followUpMade
+            }) : messageFrom(held, madeFor(held.id), ...answeredIn());
+        }, later('followUp', ([options])=>{
             instance.replied = true;
-            held = edited(current(), options);
-            // The response has the message as Discord answers the edit, before its uploaded files have loaded again
-            return messageFrom({
+            // Held as it is when sent, as Discord stores it, so a later change to what was passed isn't seen; its id taken
+            // once built, so one that fails to build under strict mocks takes none
+            const held = hold('followUp', ()=>sent(options, false));
+            const id = nextSnowflake();
+            made = undefined;
+            followUps.set(id, typeof held === 'function' ? ()=>({
+                    ...held(),
+                    id
+                }) : {
                 ...held,
-                components: held.returned ?? held.components
+                id
             });
+            followUpMade = id;
         }));
-        stubs.set('fetchReply', createMockFn(async ()=>{
-            if (modalAnswered) throw unknownMessage();
-            return messageFrom(current());
+        // An edit replaces the message 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
+        answer('editReply', async ()=>{
+            if (!made) throw unknownMessage();
+            // The response has the message as Discord answers the edit, before its uploaded files have loaded again
+            return messageFrom({
+                ...made,
+                components: made.returned ?? made.components
+            }, madeFor(made.id), ...answeredIn());
+        }, later('editReply', ([options])=>{
+            const id = targetId(options?.message);
+            const held = target(id);
+            made = held && edited(held, options);
+            if (!made) return;
+            if (id === undefined) {
+                original = made;
+                instance.replied = true;
+            } else followUps.set(id, made);
         }));
-        stubs.set('deleteReply', createMockFn(async ()=>{
-            if (!instance.deferred && !instance.replied) throw notYetReplied('deleteReply');
-            if (modalAnswered) throw unknownMessage();
+        stubs.set('fetchReply', createMockFn(async (message)=>{
+            const held = target(targetId(message));
+            if (!held) throw unknownMessage();
+            return messageFrom(held, madeFor(held.id), ...answeredIn());
+        }));
+        answer('deleteReply', async ()=>{
+            if (!made) throw unknownMessage();
+        }, later('deleteReply', ([message])=>{
+            const id = targetId(message);
+            made = target(id);
+            if (!made) return;
+            if (id === undefined) originalGone = true;
+            else followUps.delete(id);
         }));
         // 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 ()=>{
-                if (instance.deferred || instance.replied) throw alreadyReplied();
-                instance.replied = true;
+        if (instance.type === discord_js.InteractionType.ApplicationCommand || isComponent) {
+            answer('showModal', async ()=>undefined, first('showModal', 'replied', ()=>{
                 modalAnswered = instance.type === discord_js.InteractionType.ApplicationCommand;
+                if (isComponent) original = componentMessage();
             }));
         }
         // 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 ()=>{
-                if (instance.deferred || instance.replied) throw alreadyReplied();
-                instance.replied = true;
-            }));
-            stubs.set('deferUpdate', createMockFn(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));
+        if (isComponent || instance.type === discord_js.InteractionType.ModalSubmit) {
+            answer('update', async ()=>undefined, first('update', 'replied', ([options])=>original = hold('update', ()=>edited(heldFrom(instance.message, false), options))));
+            answer('deferUpdate', async ()=>undefined, first('deferUpdate', 'deferred', ()=>original = componentMessage()));
         }
     }
     // Autocomplete is not repliable, but it has a response of its own: Discord accepts
@@ -1439,7 +2214,7 @@ function createMockInteraction(Class, props) {
     if (instance.type === discord_js.InteractionType.ApplicationCommandAutocomplete) {
         instance.responded = false;
         stubs.set('respond', createMockFn(async (choices)=>{
-            if (instance.responded) throw new Error('The reply to this interaction has already been sent or deferred.');
+            if (instance.responded) throw discordjsError(discord_js.DiscordjsErrorCodes.InteractionAlreadyReplied);
             // Discord refuses a list longer than its limit, and the menu shows nothing
             if (Array.isArray(choices) && choices.length > MAX_AUTOCOMPLETE_CHOICES) {
                 throw createDiscordError(50035, `Invalid Form Body\ndata.choices[BASE_TYPE_MAX_LENGTH]: Must be ${MAX_AUTOCOMPLETE_CHOICES} or fewer in length.`);
@@ -1468,6 +2243,71 @@ function createMockInteraction(Class, props) {
         const unset = (key)=>!Object.prototype.hasOwnProperty.call(instance, key);
         const generatedId = unset('id') ? instance.id = nextSnowflake() : undefined;
         defineCreatedTime(instance, generatedId);
+        // Strict mocks place it where its message, guild or member is, and a guildId alone in a server the bot isn't in
+        // Read as the mock's own, so a message's placement warning stays the test's
+        strictPlace = readPlaceQuietly(()=>strictPlaceOf(own));
+        if (strictPlace && strictMocks()) {
+            if (strictPlace.refused) throw new Error(strictPlace.refused);
+            const set = (key, value)=>Object.defineProperty(instance, key, {
+                    value,
+                    writable: true,
+                    enumerable: true,
+                    configurable: true
+                });
+            if (strictPlace.channel && unset('channel')) set('channel', strictPlace.channel);
+            if (strictPlace.guildId !== undefined && unset('guildId')) set('guildId', strictPlace.guildId);
+            if (strictPlace.guild !== undefined && unset('guild')) set('guild', strictPlace.guild);
+            if (strictPlace.raw) {
+                const user = own('user');
+                const rawUser = user && {
+                    id: user.id,
+                    username: user.username,
+                    global_name: user.globalName ?? null,
+                    discriminator: user.discriminator,
+                    avatar: user.avatar ?? null
+                };
+                set('member', createMockRawMember(rawUser ? {
+                    user: rawUser
+                } : {}));
+            }
+        }
+        // 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
@@ -1513,12 +2353,13 @@ function createMockInteraction(Class, props) {
                 configurable: true
             });
         }
-        // The channel it came from, as the gateway caches it for an interaction: one of its server's, or the user's DM
+        // The channel it came from, as the gateway caches it for an interaction: its server's cached one, looked up on each
+        // read so a channel the test caches later is the one read, or the user's DM
         let channel;
         if (unset('channel')) {
             Object.defineProperty(instance, 'channel', {
                 get: ()=>{
-                    if (channel === undefined) {
+                    if (channel === undefined || own('guildId') && own('guild') instanceof discord_js.Guild) {
                         channel = channelFor(own('guild'), own('guildId'), own('channelId'), own('user'));
                         cacheChannel(channel, own('guild'), own('client'));
                     }
@@ -1573,7 +2414,73 @@ function createMockInteraction(Class, props) {
                 live('targetMember', ()=>own('guildId') ? memberFor(own('guild'), targetUser(), true, own('guildId')) : null);
             }
         }
+        // A message context menu's target: the message given, else one made for its targetId. The message is the one
+        // source: targetId reads its id, and setting either one moves the other with it
+        if (discord_js.MessageContextMenuCommandInteraction.prototype.isPrototypeOf(instance)) {
+            let given = own('targetMessage');
+            let explicitId = own('targetId');
+            if (given && given.id === undefined) given.id = nextSnowflake();
+            if (given && explicitId !== undefined && explicitId !== given.id) {
+                const conflict = `The targetMessage given is message ${given.id}, but the mock's targetId is ${explicitId}: give the same id, or leave one of them out.`;
+                if (strictMocks()) throw new Error(conflict);
+                controller_decorator.warnOnce(mockLogger, `${conflict} The mock reads targetMessage's id; under useStrictMocks(), as in the next major version (5.0), it refuses the pair.`);
+                explicitId = undefined;
+            }
+            const generated = given || explicitId !== undefined ? undefined : nextSnowflake();
+            let made;
+            const accessor = (key, get, set)=>Object.defineProperty(instance, key, {
+                    get,
+                    set,
+                    enumerable: true,
+                    configurable: true
+                });
+            const targetId = ()=>explicitId ?? given?.id ?? generated;
+            accessor('targetId', targetId, (value)=>{
+                explicitId = value;
+                given = undefined;
+            });
+            // In the channel the menu was used in, and its server, as the message a menu is used on is: its channel is the
+            // menu's, read live, so making the message makes and caches no channel. Read as the mock's own, so a placement
+            // warning stays the test's
+            const makeTarget = ()=>readPlaceQuietly(()=>{
+                    const [guild, guildId] = [
+                        own('guild'),
+                        own('guildId') ?? null
+                    ];
+                    const message = messageMock({
+                        id: targetId(),
+                        guild: guildId && guild instanceof discord_js.Guild ? guild : null,
+                        client: instance.client
+                    }, undefined, {}, {
+                        channelId: own('channelId'),
+                        guildId,
+                        channel: ()=>readPlaceQuietly(()=>instance.channel)
+                    });
+                    // Where strict mocks place the menu elsewhere, its target's place warns as the menu's does, by the target's name
+                    const warner = placeWarners.get(instance);
+                    const target = mockTargets.get(message) ?? message;
+                    for (const key of warner?.keys ?? [])warnOnRead(target, key, ()=>readingPlace > 0 ? void placeReadsSeen?.add(key) : warner.warn(`targetMessage.${key}`));
+                    return message;
+                });
+            accessor('targetMessage', ()=>given ?? (made?.id === targetId() ? made : made = makeTarget()), (value)=>{
+                given = value;
+                if (given && given.id === undefined) given.id = nextSnowflake();
+                explicitId = undefined;
+            });
+        }
+    }
+    // A user has an id of its own, as Discord sends one, and was created when the mock was made under strict mocks
+    if (discord_js.User.prototype.isPrototypeOf(instance) && !Object.prototype.hasOwnProperty.call(instance, 'id')) {
+        const generatedId = instance.id = nextSnowflake();
+        defineMadeTime(instance, generatedId);
+    }
+    // A role too, created when the mock was made in both modes
+    if (discord_js.Role.prototype.isPrototypeOf(instance) && !Object.prototype.hasOwnProperty.call(instance, 'id')) {
+        const generatedId = instance.id = nextSnowflake();
+        defineCreatedTime(instance, generatedId);
     }
+    // An attachment too, from the same count as every mock's
+    if (discord_js.Attachment.prototype.isPrototypeOf(instance) && !Object.prototype.hasOwnProperty.call(instance, 'id')) instance.id = nextSnowflake();
     // Discord sends the user's locale with every interaction, and the server's preferred one with one made in a server
     if (discord_js.BaseInteraction.prototype.isPrototypeOf(instance)) {
         if (own('locale') === undefined) instance.locale = discord_js.Locale.EnglishUS;
@@ -1597,6 +2504,32 @@ function createMockInteraction(Class, props) {
         }
         for (const kind of choices)if (!Object.prototype.hasOwnProperty.call(instance, kind)) instance[kind] = new discord_js.Collection();
     }
+    // In default mode, where strict mocks place it elsewhere, reading where it is warns
+    if (strictPlace && !strictMocks()) warnOnPlaceReads(instance, strictPlace, new Set(Object.keys(props ?? {})));
+    // A message whose place the mock made moves to where the test placed the interaction under strict mocks, and is then
+    // one the test placed; in default mode it stays, and reading its place warns
+    const message = own('message');
+    const placed = [
+        'channel',
+        'guild',
+        'guildId'
+    ].some((key)=>Object.keys(props ?? {}).includes(key));
+    if (discord_js.BaseInteraction.prototype.isPrototypeOf(instance) && placed && typeof message === 'object' && message !== null && placeWasMade(message)) {
+        if (strictMocks()) {
+            const guild = own('guild');
+            const channel = instance.channel;
+            Object.assign(message, {
+                guild: guild ?? null,
+                guildId: own('guildId') ?? null,
+                ...channel && {
+                    channel,
+                    channelId: channel.id
+                }
+            });
+            if (guild) memberFor(guild, message.author, true);
+            placesMade.delete(mockTargets.get(message) ?? message);
+        } else warnOnMadePlaceReads(mockTargets.get(message) ?? message);
+    }
     // Options assigned after creation, directly or through Object.assign, belong to it as those given do
     return stubDeep(instance, stubs, (prop, value)=>{
         if (prop === 'options') ownOptions(instance, value);
@@ -1608,31 +2541,36 @@ function createMockInteraction(Class, props) {
 /**
  * A mock function that answers property access with another one, so `cache.store.flush()` works
  * on a double whose shape is an interface with nothing at runtime to read it from.
- */ function stubCallable() {
+ */ function stubCallable(member) {
     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;
+    // jest's mock reads `_protoImpl` from itself whenever it's called, so the prototype below must not answer it
+    if (usesRunnerMockFn()) Object.defineProperty(fn, '_protoImpl', {
+        value: undefined,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    });
+    // 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;
+            // jest's matchers take a function whose `calls` has `all` and `count` for a jasmine spy, read before `mock.calls`
+            if (member === 'calls' && (prop === 'all' || prop === 'count')) return undefined;
+            const nested = stubCallable(prop);
+            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.
@@ -1687,6 +2625,7 @@ function createMockInteraction(Class, props) {
             if (key === 'then') return undefined;
             // An explicitly supplied prop wins over the auto-stub.
             if (Object.prototype.hasOwnProperty.call(instance, key)) return Reflect.get(instance, prop, instance);
+            // The double itself is no function a matcher reads, so a `calls` member here keeps its `all` and `count`
             if (!stubs.has(key)) stubs.set(key, stubCallable());
             return stubs.get(key);
         },
@@ -1726,11 +2665,12 @@ function createMockInteraction(Class, props) {
  * @group Testing
  * @category Mocks
  * @see {@link createMockInteraction}
- */ const createMockUser = (props = {})=>createMockInteraction(discord_js.User, {
-        id: nextSnowflake(),
+ */ function createMockUser(props = {}) {
+    return createMockInteraction(discord_js.User, {
         bot: false,
         ...props
     });
+}
 /**
  * Creates a mock {@link Client}, with `users`, `channels`, `guilds` and `application.commands` ready to stub.
  *
@@ -1844,6 +2784,18 @@ const HOLDS = [
     [
         discord_js.PermissionOverwriteManager.prototype,
         discord_js.PermissionOverwrites
+    ],
+    [
+        discord_js.ReactionManager.prototype,
+        discord_js.MessageReaction
+    ],
+    [
+        discord_js.ReactionUserManager.prototype,
+        discord_js.User
+    ],
+    [
+        discord_js.PresenceManager.prototype,
+        discord_js.Presence
     ]
 ];
 /**
@@ -1859,6 +2811,11 @@ const HOLDS = [
         value: cache,
         writable: true
     });
+    // The same collection where discord.js's own methods read it past a subclass's `cache`, as `super.cache` does
+    Object.defineProperty(manager, '_cache', {
+        value: cache,
+        writable: true
+    });
     const holds = HOLDS.find(([Manager])=>Manager === prototype || Object.prototype.isPrototypeOf.call(Manager, prototype))?.[1];
     if (holds) Object.defineProperty(manager, 'holds', {
         value: holds
@@ -1866,14 +2823,25 @@ const HOLDS = [
     let own;
     Object.defineProperty(manager, 'client', {
         get: ()=>{
-            const owner = manager.guild ?? manager.channel ?? manager.thread;
+            const owner = manager.guild ?? manager.channel ?? manager.thread ?? manager.message;
             return owner instanceof discord_js.Base ? owner.client : own ?? (own = createMockClient());
         },
-        set: (value)=>own = value,
+        // A client the test sets is the one read from then on, as on any other mock
+        set: (value)=>Object.defineProperty(manager, 'client', {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            }),
         configurable: true
     });
     return stubDeep(manager);
 }
+/** An empty manager of `prototype` that `owner` names its own, such as `{ message }` for a message's reactions. */ function ownedManager(prototype, owner) {
+    const manager = managerWith(prototype, undefined);
+    Object.assign(manager, owner);
+    return manager;
+}
 /**
  * Creates a mock {@link Guild}, with the `members`, `channels`, `roles` and `bans` managers ready to stub.
  *
@@ -1910,8 +2878,9 @@ const HOLDS = [
  * @see {@link createMockMessage}
  */ function createMockGuild(overrides = {}) {
     const instance = Object.create(discord_js.Guild.prototype);
-    instance.id = nextSnowflake();
-    if (overrides.id !== undefined) instance.id = overrides.id;
+    const generatedId = overrides.id === undefined ? nextSnowflake() : undefined;
+    instance.id = overrides.id ?? generatedId;
+    defineMadeTime(instance, generatedId);
     if (overrides.name !== undefined) instance.name = overrides.name;
     if (overrides.preferredLocale !== undefined) instance.preferredLocale = overrides.preferredLocale;
     instance.members = managerWith(discord_js.GuildMemberManager.prototype, overrides.members);
@@ -1956,7 +2925,8 @@ const HOLDS = [
  * @see {@link createMockGuild}
  */ function createMockChannel(Class, props = {}) {
     const instance = Object.create(Class.prototype);
-    instance.id = nextSnowflake();
+    const generatedId = props.id === undefined ? nextSnowflake() : undefined;
+    instance.id = generatedId;
     const is = (Base)=>Base.prototype.isPrototypeOf(Class.prototype) || Class === Base;
     // Text and announcement channels: messages, and threads made in the channel
     if (is(discord_js.TextChannel) || is(discord_js.NewsChannel)) {
@@ -1984,6 +2954,7 @@ const HOLDS = [
     // A server's channel has its overwrites, none until a test puts some in the cache, which its permissions read
     if (is(discord_js.GuildChannel) && !is(discord_js.ThreadChannel)) instance.permissionOverwrites = managerWith(discord_js.PermissionOverwriteManager.prototype, undefined);
     Object.assign(instance, props);
+    defineMadeTime(instance, generatedId);
     const stubs = new Map();
     const channel = stubDeep(instance, stubs);
     // Each manager knows its channel, as discord.js's do, and a thread's members their thread
@@ -2108,11 +3079,25 @@ 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;
+// The @everyone roles default mode made with no permissions, where strict mocks give a new server's
+const madeEveryones = new WeakSet();
+/** Whether `role` is an @everyone role default mode made, whose permissions the test hasn't set. */ const isUnsetEveryone = (role)=>madeEveryones.has(role) && !Object.prototype.hasOwnProperty.call(role, 'permissions');
+// 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
+function everyoneRole(guildId) {
+    const strict = strictMocks();
+    const role = createMockInteraction(discord_js.Role, {
         id: guildId,
         name: '@everyone',
-        position: 0
+        position: 0,
+        ...strict ? {
+            permissions: new discord_js.PermissionsBitField(NEW_SERVER_EVERYONE_PERMISSIONS).freeze()
+        } : {}
     });
+    if (!strict) madeEveryones.add(role);
+    return role;
+}
 /**
  * A guild's role manager with `roles` in its cache, and the guild's @everyone role: the one given with the guild's id,
  * or a role of its own at position 0, as every server has one.
@@ -2139,6 +3124,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.
  *
@@ -2150,8 +3197,9 @@ const CHANNEL_TYPE_GUARDS = [
  * highest, by position, then the lower id. `permissions` are computed as discord.js computes them: every permission for
  * the server's owner, and otherwise its roles' permissions combined, @everyone's included, so a member with no roles has
  * @everyone's alone. The member is put in its guild's member cache, so an interaction or a message from its user in that
- * server has it as its `member`, and `memberPermissions` are its permissions. A DM sent to the member goes through its
- * user's `send()` and the user's one DM channel.
+ * server has it as its `member`, and `memberPermissions` are its permissions, with the interaction's channel's
+ * overwrites applied under `useStrictMocks()`. A DM sent to the member goes through its user's `send()` and the user's
+ * one DM channel.
  *
  * @param overrides - The member's user, server, roles and nickname; see {@link MockMemberOverrides}.
  * @returns The mock member.
@@ -2198,6 +3246,218 @@ const CHANNEL_TYPE_GUARDS = [
     return guild ? cached(cacheOf(guild.channels), channelId, make) : make();
 }
 /** A server's id as a refusal names it, or a DM. */ const placeName = (guildId)=>guildId === null ? 'a DM' : `server ${guildId}`;
+/**
+ * Where strict mocks place an interaction: in its message's channel and server, in a guild's or a member's server, and
+ * with a guildId alone in a server the bot isn't in. Undefined where a channel given, or nothing, places it.
+ */ // Mock messages whose channel and server the mock made, as neither was given
+const placesMade = new WeakSet();
+// Messages whose place reads already warn, so a message reused for several interactions is wrapped once
+const madePlaceWarned = new WeakSet();
+/**
+ * Has a message whose place the mock made warn once per key when its place is read, in default mode, where strict mocks
+ * move it to the interaction it was given to. A read made while reading another of these, or by the mock, stays quiet.
+ */ function warnOnMadePlaceReads(message) {
+    if (madePlaceWarned.has(message)) return;
+    madePlaceWarned.add(message);
+    for (const key of [
+        'guild',
+        'guildId',
+        'channel',
+        'channelId',
+        'member'
+    ]){
+        const descriptor = Object.getOwnPropertyDescriptor(message, key);
+        if (!descriptor) continue;
+        let value = descriptor.value;
+        Object.defineProperty(message, key, {
+            get: ()=>{
+                if (readingPlace === 0) {
+                    controller_decorator.warnOnce(mockLogger, `Message.${key} reads the place createMockMessage() made for this message here, though the interaction it was ` + "given to is placed elsewhere; in the next major version (5.0) the message moves to the interaction's place. " + 'Give the message a channel or guild, or call useStrictMocks() to move it now.');
+                }
+                readingPlace++;
+                try {
+                    return descriptor.get ? descriptor.get.call(message) : value;
+                } finally{
+                    readingPlace--;
+                }
+            },
+            set: (next)=>{
+                if (descriptor.set) descriptor.set.call(message, next);
+                else value = next;
+            },
+            enumerable: true,
+            configurable: true
+        });
+    }
+}
+// The DM channel each message the bot sent in a DM in default mode was sent in, where strict mocks place it
+const sentInDm = new WeakMap();
+/** Whether a message is one whose channel and server the mock made, which a test placing an interaction overrides. */ const placeWasMade = (message)=>placesMade.has(mockTargets.get(message) ?? message);
+function strictPlaceOf(own) {
+    const message = own('message');
+    const channel = own('channel');
+    const guild = own('guild');
+    const guildId = own('guildId');
+    const member = own('member');
+    // A message whose place the mock made has none a test meant, so where the test placed the interaction wins
+    const placed = channel !== undefined || guild !== undefined || guildId !== undefined;
+    if (typeof message === 'object' && message !== null && typeof message.channelId === 'string' && !(placed && placeWasMade(message))) {
+        // One the bot sent in a DM is in that DM, as strict mocks place it, though default mode reads a server for it
+        const dm = sentInDm.get(mockTargets.get(message) ?? message);
+        const channelId = dm ? dm.id : message.channelId;
+        const at = dm ? null : message.guildId ?? null;
+        const refused = channel && channel.id !== channelId ? `The message given is in channel ${channelId}, but the mock's channel is ${channel.id}: give the message's channel, or leave one of them out.` : guild !== undefined && (guild?.id ?? null) !== at ? `The message given is in ${placeName(at)}, but the mock's guild is ${placeName(guild?.id ?? null)}: give the message's guild, or leave one of them out.` : guildId !== undefined && guildId !== at ? `The message given is in ${placeName(at)}, but the mock's guildId is ${placeName(guildId)}: give the message's guildId, or leave one of them out.` : undefined;
+        return {
+            given: 'message',
+            channel: dm ?? message.channel,
+            guildId: at,
+            guild: dm ? null : message.guild ?? null,
+            refused
+        };
+    }
+    if (guild instanceof discord_js.Guild && guildId === undefined) return {
+        given: 'guild',
+        guildId: guild.id
+    };
+    if (member instanceof discord_js.GuildMember && member.guild instanceof discord_js.Guild && guild === undefined && guildId === undefined) {
+        return {
+            given: 'member',
+            guild: member.guild,
+            guildId: member.guild.id
+        };
+    }
+    if (typeof guildId === 'string' && guild === undefined && channel === undefined && !(member instanceof discord_js.GuildMember) && !isRawMember(member)) {
+        return {
+            given: 'guildId',
+            raw: true
+        };
+    }
+    return undefined;
+}
+// Set while one of the reads below runs, so what it reads in turn doesn't warn again
+let readingPlace = 0;
+/** Runs `read` as the mock's own read of where a mock is, which warns about no placement. */ function readPlaceQuietly(read) {
+    readingPlace++;
+    try {
+        return read();
+    } finally{
+        readingPlace--;
+    }
+}
+// Each interaction's strict place and its warning, by the read it names, for the mock's own reads that warn as the test's
+const placeWarners = new WeakMap();
+// The place keys a read of the mock's own read while it runs, so it warns by its own name where one would warn
+let placeReadsSeen;
+/**
+ * Runs `read`, a value of `mock`'s own that reads where the mock is, quietly; in default mode it warns once, as `key`,
+ * where one of those reads would warn, since strict mocks place the mock otherwise, unless `differs` says the value is
+ * the same in that place.
+ */ function readPlaceAs(mock, key, read, differs = ()=>true) {
+    const outer = placeReadsSeen;
+    const seen = placeReadsSeen = new Set();
+    try {
+        return readPlaceQuietly(read);
+    } finally{
+        placeReadsSeen = outer;
+        const warner = placeWarners.get(mockTargets.get(mock) ?? mock);
+        if (seen.size > 0 && warner && differs(warner.place)) warner.warn(key);
+    }
+}
+/** What reading `key`, where strict mocks place an interaction otherwise, warns: what it reads now, and in 5.0. */ function placeWarning(name, key, place) {
+    if (place.refused) {
+        return `${name}.${key} reads where the mock's channel, guild or guildId put it, not where its message is; under useStrictMocks(), as in the next major version (5.0), the mock is refused: ${place.refused}`;
+    }
+    const why = {
+        message: [
+            'a place other than its message\'s',
+            "the mock is in its message's channel and server",
+            "Give it the message's channel, or call useStrictMocks() to place it there now."
+        ],
+        guild: [
+            "a DM's value, though the mock was given a guild",
+            'the mock is in that guild',
+            'Give its guildId or one of its channels too, or call useStrictMocks() to place it there now.'
+        ],
+        member: [
+            "a DM's value, though the mock was given a member of a server",
+            "the mock is in the member's server",
+            "Give the member's guild too, or call useStrictMocks() to place it there now."
+        ],
+        guildId: [
+            'a server the bot is in, though the mock was given only a guildId',
+            "a guildId alone is a server the bot isn't in: guild and channel are null, and the member is a raw one",
+            'Give a guild too, or call useStrictMocks() to read it so now.'
+        ]
+    }[place.given];
+    return `${name}.${key} reads ${why[0]} here; in the next major version (5.0) ${why[1]}. ${why[2]}`;
+}
+/** Has a read of `instance`'s `key` call `warn` first, and what that read reads in turn stay quiet. */ function warnOnRead(instance, key, warn) {
+    const descriptor = Object.getOwnPropertyDescriptor(instance, key);
+    // One the mock answers with a stub stays unset, as the mock's own checks read it, and warns as the stub is read
+    if (!descriptor) {
+        if (!stubReadWarnings.has(instance)) stubReadWarnings.set(instance, new Map());
+        stubReadWarnings.get(instance).set(key, warn);
+        return;
+    }
+    const read = ()=>descriptor.get ? descriptor.get.call(instance) : descriptor.value;
+    Object.defineProperty(instance, key, {
+        get: ()=>{
+            warn();
+            readingPlace++;
+            try {
+                return read();
+            } finally{
+                readingPlace--;
+            }
+        },
+        set: (next)=>Object.defineProperty(instance, key, {
+                value: next,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            }),
+        enumerable: true,
+        configurable: true
+    });
+}
+/**
+ * Has each of an interaction's `guildId`, `guild`, `channelId`, `channel` and `member` that strict mocks read otherwise
+ * warn once when read, unless the test gave it.
+ */ function warnOnPlaceReads(instance, place, given) {
+    const value = (key)=>{
+        const descriptor = Object.getOwnPropertyDescriptor(instance, key);
+        return descriptor?.get ? undefined : descriptor?.value;
+    };
+    const keys = place.refused ? [
+        'guildId',
+        'guild',
+        'channelId',
+        'channel'
+    ] : place.raw ? [
+        'guild',
+        'channel',
+        'member'
+    ] : place.guildId !== value('guildId') ? [
+        'guildId',
+        'guild',
+        'channelId',
+        'channel',
+        'member'
+    ] : place.channel && place.channel.id !== value('channelId') ? [
+        'channelId',
+        'channel'
+    ] : [];
+    const name = Object.getPrototypeOf(instance).constructor.name;
+    placeWarners.set(instance, {
+        place,
+        keys,
+        warn: (read)=>controller_decorator.warnOnce(mockLogger, placeWarning(name, read, place))
+    });
+    for (const key of keys.filter((each)=>!given.has(each))){
+        // A read the mock makes stays quiet, noted for a read of the mock's own to warn by its name
+        warnOnRead(instance, key, ()=>readingPlace > 0 ? void placeReadsSeen?.add(key) : controller_decorator.warnOnce(mockLogger, placeWarning(name, key, place)));
+    }
+}
 /**
  * Where a channel a test gives puts the mock made in it, read from the channel as discord.js reads it: no server for a
  * DM channel, else the server the channel names. A server channel that names none is put in `fallback`'s, and named
@@ -2242,9 +3502,11 @@ const CHANNEL_TYPE_GUARDS = [
         cached(cacheOf(manager), id, ()=>channel);
     }
 }
-/** The guild a mock message carries: a guild with the same stubbed managers as createMockGuild. */ function createMockGuildForMessage(id = nextSnowflake()) {
+/** The guild a mock message carries: a guild with the same stubbed managers as createMockGuild. */ function createMockGuildForMessage(id) {
     const guild = Object.create(discord_js.Guild.prototype);
-    guild.id = id;
+    const generatedId = id === undefined ? nextSnowflake() : undefined;
+    guild.id = id ?? generatedId;
+    defineMadeTime(guild, generatedId);
     guild.members = managerWith(discord_js.GuildMemberManager.prototype, undefined);
     guild.channels = managerWith(discord_js.GuildChannelManager.prototype, undefined);
     guild.roles = guildRoleManager(guild.id, undefined);
@@ -2253,6 +3515,23 @@ const CHANNEL_TYPE_GUARDS = [
     settleGuild(guild, proxy);
     return proxy;
 }
+// Each settled guild's bot member as `members.me` reads it, without caching one made for the read
+const botMembers = new WeakMap();
+/** The bot's member in `guild` for the mock's own reads: the one `members.me` reads, made without caching it there. */ function botMemberOf(guild) {
+    return botMembers.get(guild)?.() ?? guild.members.me;
+}
+/**
+ * The channel an interaction's `channel` reads, for the mock's own reads: `null` in a DM, else one set on it or its
+ * server's cached one, without making or caching one. Undefined where `channel` would make one, which has no overwrites.
+ */ function heldChannelOf(interaction, guild) {
+    const target = mockTargets.get(interaction) ?? interaction;
+    return readPlaceQuietly(()=>{
+        const set = Object.getOwnPropertyDescriptor(target, 'channel');
+        if (set && 'value' in set) return set.value;
+        const { guildId, channelId } = target;
+        return guildId ? cacheOf(guild.channels)?.get(channelId) : null;
+    });
+}
 /** Gives a guild's managers the guild, as discord.js's do, so what they fetch or make is in it. */ function homeManagers(instance, guild) {
     for (const key of [
         'members',
@@ -2274,11 +3553,13 @@ const CHANNEL_TYPE_GUARDS = [
         configurable: true
     });
     const members = instance.members;
+    const botMember = (keep)=>{
+        const { user } = guild.client;
+        return keep ? cached(cacheOf(members), user.id, ()=>memberIn(guild, user.id, user)) : cacheOf(members)?.get(user.id) ?? memberIn(guild, user.id, user);
+    };
+    botMembers.set(guild, ()=>botMember(false));
     Object.defineProperty(members, 'me', {
-        get: ()=>{
-            const { user } = guild.client;
-            return cached(cacheOf(members), user.id, ()=>memberIn(guild, user.id, user));
-        },
+        get: ()=>botMember(true),
         configurable: true
     });
     for (const key of [
@@ -2289,6 +3570,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)=>[
@@ -2350,8 +3633,11 @@ const CHANNEL_TYPE_GUARDS = [
     };
     // Own values, so the prototype's getters, which read the raw mention data, are not reached
     const instance = Object.create(discord_js.MessageMentions.prototype);
+    const parsedUsers = new discord_js.Collection(mentioned.users);
     for (const [key, value] of Object.entries({
         ...mentioned,
+        parsedUsers,
+        crosspostedChannels: new discord_js.Collection(),
         everyone: false,
         client,
         guild: guild ?? null
@@ -2364,11 +3650,14 @@ const CHANNEL_TYPE_GUARDS = [
     return stubDeep(instance);
 }
 /** A value as its API JSON: a builder or discord.js structure through `toJSON()`, anything else as it is. */ const jsonOf = (value)=>value && typeof value.toJSON === 'function' ? value.toJSON() : value;
-/** The message a reply method starts from: the one a component is on, as it was, or an empty original response. */ function heldFrom(message) {
+/**
+ * The message a reply method starts from: the one a component is on, as it was, or an empty original response. Without
+ * `allocate`, one with no id of its own gets `''`, for its holder to give it one when first read.
+ */ function heldFrom(message, allocate = true) {
     // Read only what the message really has: a mock's unset fields are stubs
     const from = message ?? {};
     return {
-        id: typeof from.id === 'string' ? from.id : nextSnowflake(),
+        id: typeof from.id === 'string' ? from.id : allocate ? nextSnowflake() : '',
         content: typeof from.content === 'string' ? from.content : undefined,
         components: Array.isArray(from.components) ? from.components.map(jsonOf) : [],
         embeds: Array.isArray(from.embeds) ? from.embeds.map(jsonOf) : [],
@@ -2376,6 +3665,15 @@ const CHANNEL_TYPE_GUARDS = [
         editedTimestamp: typeof from.editedTimestamp === 'number' ? from.editedTimestamp : null
     };
 }
+/** A message as an answer sends it: a new one, with what the answer gave, never edited. */ const sent = (options, allocate = true)=>{
+    // Its id taken only once it builds, so a payload that fails to build takes none
+    const held = edited(heldFrom(undefined, false), options);
+    return {
+        ...held,
+        id: allocate ? nextSnowflake() : '',
+        editedTimestamp: null
+    };
+};
 /** A held message after an edit: what the edit sets replaced in Discord's shape, and a later edit stamp. */ function edited(held, options) {
     const edit = typeof options === 'string' ? {
         content: options
@@ -2404,29 +3702,28 @@ const CHANNEL_TYPE_GUARDS = [
         editedTimestamp: Math.max(Date.now(), (held.editedTimestamp ?? 0) + 1)
     };
 }
-/** A mock message showing a held message. */ function messageFrom(held) {
-    return createMockMessage({
+/** A mock message showing a held message, one the bot sent in `channel` by `client`, with what `made` keeps. */ function messageFrom(held, made, channel, client) {
+    return sentMessage(held, channel, client, {
         id: held.id,
-        ...held.content !== undefined && {
-            content: held.content
-        },
-        components: held.components,
-        embeds: held.embeds,
-        ...held.flags !== undefined && {
-            flags: held.flags
-        },
         editedTimestamp: held.editedTimestamp
-    });
+    }, made);
 }
 /**
- * A component or embed as a message holds it: a discord.js instance as it is; anything else as
- * its API JSON at the time of the call, behind `toJSON()`.
- */ function asHeld(value) {
+ * A component or embed as a message holds it: a discord.js instance as it is, anything else as the discord.js class
+ * built from its API JSON at the time of the call, as discord.js builds it, an unknown type as a plain `Component`.
+ */ function asHeld(value, kind) {
     if (value instanceof discord_js.Component || value instanceof discord_js.Embed) return value;
-    const json = structuredClone(typeof value.toJSON === 'function' ? value.toJSON() : value);
-    return {
-        toJSON: ()=>json
-    };
+    // A copy, since discord.js's classes keep what they are given, one level deep
+    const json = structuredClone(jsonOf(value));
+    if (kind === 'embed') return new discord_js.Embed(json);
+    // An action row builds each child with discord.js's own createComponent, which it doesn't export
+    const row = new discord_js.ActionRow({
+        type: discord_js.ComponentType.ActionRow,
+        components: [
+            json
+        ]
+    });
+    return row.components[0];
 }
 /**
  * Creates a mock {@link Message} that tracks whether it has been deleted.
@@ -2435,12 +3732,14 @@ const CHANNEL_TYPE_GUARDS = [
  * `@MessageHandler` does not skip it.
  *
  * @remarks
- * `delete()`, `edit()`, `reply()`, `react()`, `pin()` and `unpin()` throw once the message is deleted, and `edit()`
- * and `reply()` resolve to a new mock message. Without overrides the message is empty, in a server, from a new
- * person who is its `member`; with `guild: null` it is a direct message. Give `author` to send several messages as
- * one user, such as to reach a per-user cooldown. An author given, and the users, roles and channels the content
- * mentions, are cached as the gateway delivers them. It is typed as discord.js emits a message, never in a group DM,
- * so it fits `messageCreate` and the other message events.
+ * `delete()`, `edit()`, `reply()`, `react()`, `pin()` and `unpin()` throw once the message is deleted. `edit()` changes
+ * this message and resolves to it, and `reply()` resolves to the reply, sent in this message's channel and holding what
+ * was sent, as a channel's `send()` does. Under `useStrictMocks()` a message the bot sends is its `client.user`'s, and
+ * one sent in a DM is in that DM. Without overrides the message is empty, in a server, from a new person who is its
+ * `member`; with `guild: null` it is a direct message. Give `author` to send several messages as one user, such as to
+ * reach a per-user cooldown. An author given, and the users, roles and channels the content mentions, are cached as the
+ * gateway delivers them. It is typed as discord.js emits a message, never in a group DM, so it fits `messageCreate` and
+ * the other message events.
  *
  * @param overrides - The message's content, components and the rest; see {@link MockMessageOverrides}.
  *
@@ -2463,11 +3762,18 @@ const CHANNEL_TYPE_GUARDS = [
  * @see {@link MockMessageOverrides}
  * @see {@link createMockGuild}
  */ function createMockMessage(overrides = {}) {
+    return messageMock(overrides);
+}
+function messageMock(overrides = {}, sentBy, made = {}, at) {
+    var _made, _made1, _made2;
     const instance = Object.create(discord_js.Message.prototype);
     const stubs = new Map();
+    const unplaced = overrides.channel === undefined && overrides.guild === undefined;
+    // A message the bot sent is placed where it was sent, even where default mode reads a server of its own for a DM
+    if (unplaced && !sentBy) placesMade.add(instance);
     instance.deleted = false;
     // Constructor-assigned — set as prototype-based stubs; a user rather than a bot, as dispatch handles only those
-    instance.author = overrides.author ?? mockUser();
+    instance.author = overrides.author ?? (_made = made).author ?? (_made.author = mockUser());
     // Getters on the prototype, which the proxy would answer with a stub object: own properties shadow them
     // A channel given says where the message was sent, unless its guild is given too
     const place = overrides.channel ? placeOf(overrides.channel, overrides.guild === undefined ? undefined : overrides.guild?.id ?? null, ()=>{
@@ -2477,22 +3783,37 @@ const CHANNEL_TYPE_GUARDS = [
             guild
         };
     }) : undefined;
-    const guild = overrides.guild !== undefined ? overrides.guild : place?.guildId !== undefined ? place.guildId === null ? null : place.guild ?? createMockGuildForMessage(place.guildId) : createMockGuildForMessage();
-    const channel = overrides.channel ?? channelFor(guild, guild?.id ?? null, nextSnowflake(), instance.author);
-    Object.defineProperty(instance, 'channel', {
+    const guild = overrides.guild !== undefined ? overrides.guild : place?.guildId !== undefined ? place.guildId === null ? null : place.guild ?? createMockGuildForMessage(place.guildId) : unplaced ? (_made1 = made).guild ?? (_made1.guild = createMockGuildForMessage()) : createMockGuildForMessage();
+    const madeChannel = ()=>channelFor(guild, guild?.id ?? null, nextSnowflake(), instance.author);
+    const channel = at ? undefined : overrides.channel ?? (unplaced ? (_made2 = made).channel ?? (_made2.channel = madeChannel()) : madeChannel());
+    if (channel) Object.defineProperty(instance, 'channel', {
         value: channel,
-        writable: true
+        writable: true,
+        configurable: true
     });
+    else {
+        Object.defineProperty(instance, 'channel', {
+            get: at.channel,
+            set: (value)=>Object.defineProperty(instance, 'channel', {
+                    value,
+                    writable: true,
+                    configurable: true
+                }),
+            configurable: true
+        });
+    }
     Object.defineProperty(instance, 'guild', {
         value: guild,
-        writable: true
+        writable: true,
+        configurable: true
     });
     // The author as a member of the message's server; a direct message has none. A given author's member is the one
     // the server caches, as the gateway resolves it, so every message from that author has the same member
-    // The author's member, cached as the gateway caches it with the message; `member` reads the cache, as discord.js does
+    // The author's member, cached as the gateway caches it with the message; `member` reads the cache, as discord.js
+    // does, without calling the manager's resolve a test may stub
     if (guild) memberFor(guild, instance.author, true);
     Object.defineProperty(instance, 'member', {
-        get: ()=>guild ? guild.members.resolve(instance.author) : null,
+        get: ()=>instance.guild ? cacheOf(instance.guild.members)?.get(instance.author.id) ?? null : null,
         set: (value)=>Object.defineProperty(instance, 'member', {
                 value,
                 writable: true,
@@ -2503,15 +3824,16 @@ const CHANNEL_TYPE_GUARDS = [
         configurable: true
     });
     // In a server's text channel, the ids matching the objects; with no guild, a DM
-    instance.channelId = channel.id;
-    instance.guildId = guild?.id ?? null;
+    instance.channelId = channel?.id ?? at.channelId;
+    instance.guildId = at ? at.guildId : guild?.id ?? null;
     // The thread its channel caches under its id, as discord.js reads it; until 5.0, a placeholder thread otherwise
     let placeholderThread;
     Object.defineProperty(instance, 'thread', {
         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', {
@@ -2533,7 +3855,7 @@ const CHANNEL_TYPE_GUARDS = [
         configurable: true
     });
     if (guild instanceof discord_js.Guild) cached(cacheOf(client.guilds), guild.id, ()=>guild);
-    cacheChannel(channel, guild, client);
+    if (channel) cacheChannel(channel, guild, client);
     const userCache = cacheOf(client.users);
     for (const user of [
         ...overrides.users ?? [],
@@ -2543,8 +3865,8 @@ const CHANNEL_TYPE_GUARDS = [
     instance.mentions = mentionsOf(overrides.content, client, guild);
     // Data a message always has, real rather than stubbed, so code reading it sees an empty message
     instance.flags = new discord_js.MessageFlagsBitField(overrides.flags);
-    instance.components = (overrides.components ?? []).map(asHeld);
-    instance.embeds = (overrides.embeds ?? []).map(asHeld);
+    instance.components = (overrides.components ?? []).map((component)=>asHeld(component, 'component'));
+    instance.embeds = (overrides.embeds ?? []).map((embed)=>asHeld(embed, 'embed'));
     instance.attachments = new discord_js.Collection();
     instance.editedTimestamp = overrides.editedTimestamp ?? null;
     const generatedId = overrides.id === undefined ? nextSnowflake() : undefined;
@@ -2557,14 +3879,27 @@ const CHANNEL_TYPE_GUARDS = [
         if (instance.deleted) throw alreadyDeleted();
         instance.deleted = true;
     }));
-    stubs.set('edit', createMockFn(async ()=>{
+    // An edit changes this message, as Discord edits it in place, and resolves to it
+    stubs.set('edit', createMockFn(async (options)=>{
         if (instance.deleted) throw alreadyDeleted();
-        return createMockMessage();
+        const held = edited(heldFrom(undefined, false), options);
+        const edit = typeof options === 'string' ? {
+            content: options
+        } : options ?? {};
+        if (edit.content !== undefined) instance.content = held.content;
+        if (edit.components !== undefined) instance.components = held.components.map((component)=>asHeld(component, 'component'));
+        if (edit.embeds !== undefined) instance.embeds = held.embeds.map((embed)=>asHeld(embed, 'embed'));
+        if (edit.flags !== undefined) instance.flags = new discord_js.MessageFlagsBitField(held.flags);
+        instance.editedTimestamp = Math.max(Date.now(), (instance.editedTimestamp ?? 0) + 1);
+        return message;
     }));
-    stubs.set('reply', createMockFn(async ()=>{
+    stubs.set('reply', createMockFn(async (options)=>{
         if (instance.deleted) throw alreadyDeleted();
-        return createMockMessage();
+        return sentMessage(sent(options, false), instance.channel, instance.client);
     }));
+    // Crossposting publishes this message, and forwarding sends one in the channel it is forwarded to
+    stubs.set('crosspost', createMockFn(async ()=>message));
+    stubs.set('forward', createMockFn(async (channel)=>sentMessage(sent(undefined, false), channel, instance.client)));
     stubs.set('react', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
     }));
@@ -2574,7 +3909,85 @@ const CHANNEL_TYPE_GUARDS = [
     stubs.set('unpin', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
     }));
-    return stubDeep(instance, stubs);
+    if (sentBy) warnOnSentReads(instance, stubs, sentBy);
+    const message = stubDeep(instance, stubs);
+    return message;
+}
+/**
+ * Has a message the bot sent warn once where strict mocks read it otherwise: its author, the bot's `client.user` under
+ * strict mocks, and, for one sent in a DM, the server it reads as being in.
+ */ function warnOnSentReads(instance, stubs, sentBy) {
+    // A read made while reading another of these, as `member` reads `author`, warns only for the outer one
+    let reading = 0;
+    const read = (key, warning)=>{
+        const descriptor = Object.getOwnPropertyDescriptor(instance, key);
+        Object.defineProperty(instance, key, {
+            get: ()=>{
+                if (reading === 0) controller_decorator.warnOnce(mockLogger, warning);
+                reading++;
+                try {
+                    return descriptor?.get ? descriptor.get.call(instance) : descriptor?.value;
+                } finally{
+                    reading--;
+                }
+            },
+            set: (next)=>Object.defineProperty(instance, key, {
+                    value: next,
+                    writable: true,
+                    enumerable: true,
+                    configurable: true
+                }),
+            enumerable: true,
+            configurable: true
+        });
+    };
+    if (sentBy.bot) {
+        read('author', "Message.author reads a user here, though the bot sent this message; in the next major version (5.0) it is the bot's " + "client.user, as Discord sends it. Call useStrictMocks() to read client.user now.");
+    }
+    if (!sentBy.dm) return;
+    const inDm = (what)=>`Message.${what} reads a server here, though this message was sent in a DM; in the next major version (5.0) it reads ` + "as a DM's, with no server. Call useStrictMocks() to read it so now.";
+    const inGuild = Boolean(instance.guildId);
+    for (const key of [
+        'guild',
+        'guildId',
+        'member'
+    ])read(key, inDm(key));
+    stubs.set('inGuild', createMockFn(()=>(controller_decorator.warnOnce(mockLogger, inDm('inGuild()')), inGuild)));
+}
+/**
+ * A message the bot sent, as Discord returns it: in the channel it was sent in and that channel's server, holding what
+ * was sent. Under strict mocks it is the bot's `client.user`'s, and one sent in a DM is in that DM; default mode places
+ * a DM send in a server of its own and keeps another author, with a warning when read.
+ */ function sentMessage(held, channel, client, fields = {}, made) {
+    const by = client ?? channel?.client;
+    const inChannel = channel instanceof discord_js.BaseChannel;
+    const dm = inChannel && channel.isDMBased();
+    const strict = strictMocks();
+    const message = messageMock({
+        ...held.content !== undefined && {
+            content: held.content
+        },
+        components: held.components,
+        embeds: held.embeds,
+        ...held.flags !== undefined && {
+            flags: held.flags
+        },
+        ...inChannel && (!dm || strict) && {
+            channel: channel
+        },
+        ...by && {
+            client: by
+        },
+        ...strict && by?.user && {
+            author: by.user
+        },
+        ...fields
+    }, strict ? undefined : {
+        bot: Boolean(by?.user),
+        dm
+    }, made);
+    if (dm && !strict) sentInDm.set(mockTargets.get(message) ?? message, channel);
+    return message;
 }
 /** The option type Discord would have sent for a given JavaScript value. */ function optionTypeOf(value) {
     if (typeof value === 'boolean') return discord_js.ApplicationCommandOptionType.Boolean;
@@ -2663,11 +4076,32 @@ const CHANNEL_TYPE_GUARDS = [
     else if (isEntity) option.user = value;
     return option;
 }
+/**
+ * The option an autocomplete's user is typing, as Discord sends it: its value a string, `''` before anything is typed.
+ * A number given for it is its digits under strict mocks; otherwise it stays a number, with a warning when read.
+ */ function focusedOptionData(name, value) {
+    const option = toOptionData(name, value ?? '');
+    option.focused = true;
+    if (typeof value === 'number') {
+        if (strictMocks()) option.value = String(value);
+        else {
+            Object.defineProperty(option, 'value', {
+                get: ()=>{
+                    controller_decorator.warnOnce(mockLogger, `The focused option "${name}" reads the number ${value} here, where Discord sends a string; in the next major version (5.0) ` + `the mock gives it as one. Give it as a string, such as '${value}', or call useStrictMocks() to have the mock give it now.`);
+                    return value;
+                },
+                enumerable: true
+            });
+        }
+    }
+    return option;
+}
 /**
  * Nests the supplied options under the subcommand path they were invoked through,
  * matching the shape Discord sends rather than a flat list.
- */ function buildOptionData(subcommandGroup, subcommand, values, memberOf) {
-    const leaves = Object.entries(values).map(([name, value])=>toOptionData(name, value, memberOf));
+ */ function buildOptionData(subcommandGroup, subcommand, values, memberOf, focused) {
+    const leaves = Object.entries(values).map(([name, value])=>name === focused ? focusedOptionData(name, value) : toOptionData(name, value, memberOf));
+    if (focused !== null && !Object.hasOwn(values, focused)) leaves.push(focusedOptionData(focused, null));
     if (subcommand === null) return leaves;
     const sub = {
         name: subcommand,
@@ -2707,6 +4141,10 @@ const CHANNEL_TYPE_GUARDS = [
  * A whole number is an Integer option and a fraction a Number one, so
  * `getInteger()` reads only a whole number, and `getNumber()` reads either.
  *
+ * The `focused` option reads as Discord sends it, through `getFocused()`, `getFocused(true)` and `data` alike: a
+ * string, `''` when no value is given, and marked `focused` in `data`. A number given for it is its digits under
+ * `useStrictMocks()`; otherwise it stays the number, with a warning when read.
+ *
  * @typeParam Cached - `any` by default, to match `createMockInteraction(ChatInputCommandInteraction)`; pass it when the
  *   interaction under test is cache-pinned.
  *
@@ -2780,7 +4218,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)=>{
@@ -2826,15 +4265,19 @@ const CHANNEL_TYPE_GUARDS = [
         ], ()=>false, required));
     base.getFocused = createMockFn((getFull)=>{
         if (focused === null) throw optionError(discord_js.DiscordjsErrorCodes.AutocompleteInteractionOptionNoFocusedOption);
-        const option = toOptionData(focused, values[focused] ?? null, memberOf);
+        // The one options.data holds, so the two agree
+        const option = base._hoistedOptions.find((each)=>each.focused);
         return getFull === true ? {
-            ...option,
-            focused: true
+            ...option
         } : option.value;
     });
     // `data` is what the framework reads to build a handler's params, so it is materialised here rather than
     // auto-stubbed, or every params assertion would see an empty record.
-    base.data = buildOptionData(subcommandGroup, subcommand, values, memberOf);
+    base.data = buildOptionData(subcommandGroup, subcommand, values, memberOf, focused);
+    // The fields discord.js's constructor sets from it, which its toString() reads
+    base._group = subcommandGroup;
+    base._subcommand = subcommand;
+    base._hoistedOptions = subcommand === null ? base.data : (subcommandGroup === null ? base.data[0] : base.data[0].options[0]).options;
     const resolver = stubDeep(base);
     return resolver;
 }
@@ -2869,7 +4312,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
@@ -2908,7 +4351,7 @@ const CHANNEL_TYPE_GUARDS = [
         await this.resolving;
         if (options.ready) {
             const { client = createMockClient(), primary = true } = options.ready === true ? {} : options.ready;
-            this.readying ?? (this.readying = this.runReady(client, primary));
+            this.readying ?? (this.readying = this.readyPass.run(()=>this.runReady(client, primary)));
             await this.readying;
         }
         return this;
@@ -2923,12 +4366,21 @@ const CHANNEL_TYPE_GUARDS = [
    * It first gives up the theme read outside calls, if `init({ ready: true })` made it this module's;
    * reads outside calls then return MeoCord's defaults until another module or app is ready.
    *
+   * A stopped bot runs nothing more. Once `close()` is called, a module still runs what `dispatch`, `invoke` and `emit`
+   * are given, against services shut down, or shutting down, and warns once that it is closed, so a `close()` in the
+   * wrong place shows.
+   *
    * The cooldown store and what it injects shut down last, in the same sequence as the bot's. When any of them has an
    * `onShutdown`, the calls `invoke`, `dispatch` and `emit` have under way finish first, then the store operations
    * they started, so the store's last writes still reach it. The module stops waiting for the whole sequence after
    * its `shutdownTimeout`, 10 seconds unless set, and logs that it did. Give a test whose fake store never answers, or
    * whose `onShutdown` never settles, a short `shutdownTimeout`.
    *
+   * A `close()` while `init({ ready: true })` runs the `onReady` hooks waits for them first, within the same
+   * `shutdownTimeout`. An `onReady` still running once only the hooks' share of it is left is named in a warning, and
+   * its class is shut down all the same, as everything the module constructed is. One that calls `close()` itself isn't
+   * waited for.
+   *
    * @returns Once every hook has run. Rejects with the error of a hook that failed, or an
    *   `AggregateError` naming each when several did.
    *
@@ -2943,14 +4395,18 @@ const CHANNEL_TYPE_GUARDS = [
    * expect(module.get(POOL).ended).toBe(true)
    * ```
    */ async close() {
+        // An onReady awaiting close() would otherwise hold up the close that waits for it
+        this.readyPass.excuseCurrent();
         this.closing ?? (this.closing = (async ()=>{
-            // A close during init waits for the hooks it started, so it shuts down whatever they constructed
-            await this.readying?.catch(()=>undefined);
-            const entries = this.lifecycle.filter((unit)=>this.constructed.has(unit.token))// Already made, so this returns the instance; a provided value may be anything, null included
-            .map((unit)=>startupRoots.lifecycleEntry(unit, this.container.get(unit.token) ?? {}));
+            // A close during init waits for the providers it started, and the sequence for its onReady hooks, so it shuts
+            // down whatever they constructed
+            await this.resolving?.catch(()=>undefined);
+            const entries = ()=>this.lifecycle.filter((unit)=>this.constructed.has(unit.token))// Already made, so this returns the instance; a provided value may be anything, null included
+                .map((unit)=>startupRoots.lifecycleEntry(unit, this.container.get(unit.token) ?? {}));
             const failures = [];
             await startupRoots.runShutdownSequence(this.container, entries, {
                 drainCalls: ()=>startupRoots.callsSettled(this.calls),
+                readyPass: this.readyPass,
                 timeoutMs: this.shutdownTimeout,
                 hookFailed: (name, error)=>failures.push({
                         name,
@@ -2964,6 +4420,11 @@ const CHANNEL_TYPE_GUARDS = [
         })());
         await this.closing;
     }
+    /** Warns once, after `close()`, that a call runs against services already shut down. */ warnIfClosed() {
+        if (this.closing === undefined || this.warnedClosed) return;
+        this.warnedClosed = true;
+        new controller_decorator.Logger('TestingModule').warn('This testing module is closed, and its services are shut down, or shutting down, so dispatch, invoke and emit run ' + 'against that state. Close it after the last call, in afterEach.');
+    }
     async runReady(client, primary) {
         // As the bot claims it before it comes online, so onReady reads the app's theme
         providers.claimAmbientAppTheme(this.container);
@@ -2979,6 +4440,8 @@ const CHANNEL_TYPE_GUARDS = [
         }, [], {
             resolveFailed: failed,
             hookFailed: failed
+        }, {
+            runOnReady: this.readyPass.runOnReady
         });
         throwFailures('onReady', failures);
     }
@@ -3050,7 +4513,9 @@ const CHANNEL_TYPE_GUARDS = [
    * @returns Whether the handler ran, and the error a filter handled, if any. Rejects with an error no
    *   filter handles, or with the error a filter throws: the built-in fallback, which answers such
    *   errors in the bot, does not run here. Rejects before running anything with an interaction or a
-   *   message the handler's route does not match, naming both.
+   *   message the handler's route does not match, naming both. Given fewer arguments than the handler
+   *   declares, with a first that is neither an interaction nor a message, such as a reaction without its
+   *   `ReactionEvent`, it rejects under `useStrictMocks()`, and otherwise warns once and runs the handler.
    *
    * @example
    * ```ts
@@ -3072,6 +4537,7 @@ const CHANNEL_TYPE_GUARDS = [
    * expect(outcome.error).toBeInstanceOf(GuardDeniedError)
    * ```
    */ async invoke(controller, methodName, ...args) {
+        this.warnIfClosed();
         await this.init();
         if (!this.controllers.includes(controller)) {
             throw new Error(`${controller.name} is not a controller of this testing module. Add it to \`controllers\`.`);
@@ -3101,6 +4567,7 @@ const CHANNEL_TYPE_GUARDS = [
                 hooks = providers.messageCommandHooks(route, params, first, start, given, this.messageOptions.types);
             }
         }
+        this.checkArgumentCount(controller, methodName, instance[methodName], first, callArgs.length);
         const presenter = providers.appPresenterOf(this.container);
         // A message command's errors are drawn by the app's presenter too, as an interaction's are
         const client = first instanceof discord_js.BaseInteraction || first instanceof discord_js.Message ? first.client : undefined;
@@ -3117,6 +4584,19 @@ const CHANNEL_TYPE_GUARDS = [
             error
         };
     }
+    /**
+   * Refuses under `useStrictMocks()`, or warns once otherwise, a call that gives a handler fewer arguments than it
+   * declares when `invoke` builds none for it, as for a reaction given without its `ReactionEvent`.
+   */ checkArgumentCount(controller, methodName, method, first, given) {
+        if (first instanceof discord_js.BaseInteraction || first instanceof discord_js.Message || method.length <= given) return;
+        const reaction = controller_decorator.getReactionHandlers(controller.prototype).some((handler)=>handler.method === methodName);
+        const problem = `${controller.name}.${methodName} takes ${method.length} arguments, and invoke was given ${given}: ` + (reaction ? 'pass its ReactionEvent after the reaction, as { user, action }.' : 'pass each argument it takes.');
+        if (strictMocks()) throw new Error(problem);
+        const key = `${controller.name}.${methodName}`;
+        if (this.warnedArgumentCounts.has(key)) return;
+        this.warnedArgumentCounts.add(key);
+        new controller_decorator.Logger('TestingModule').warn(problem);
+    }
     /** Counts `call` as under way until it settles. */ track(call) {
         this.calls.add(call);
         void call.then(()=>this.calls.delete(call), ()=>this.calls.delete(call));
@@ -3143,6 +4623,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,
@@ -3160,6 +4642,7 @@ const CHANNEL_TYPE_GUARDS = [
         return this.dispatcher;
     }
     async dispatch(input, options) {
+        this.warnIfClosed();
         await this.init();
         this.registerClient(input);
         const dispatcher = this.dispatcherOf();
@@ -3177,6 +4660,7 @@ const CHANNEL_TYPE_GUARDS = [
             unhandled: (error)=>unhandled.push(error)
         };
         if (options) {
+            noteReactionDispatch(input);
             await this.track(dispatcher.reaction(input, {
                 user: options.user,
                 action: options.action ?? enum_index.ReactionHandlerAction.ADD
@@ -3206,15 +4690,20 @@ const CHANNEL_TYPE_GUARDS = [
         };
     }
     /**
-   * Emits a client event to the module's `@On` and `@Once` handlers, through the same pipeline the app
-   * runs them in: the global guards of the module's `app`, then each handler's own. Handlers on the
-   * module's controllers, class providers and their dependencies all receive it. A `@Once` handler
-   * handles only the first event, as it would on a client.
+   * Emits a client event to the module's `@On` and `@Once` handlers, through the pipeline the app runs
+   * them in up to its event fallback: the global guards of the module's `app`, then each handler's own.
+   * Handlers on the module's controllers, class providers and their dependencies all receive it. A
+   * `@Once` handler handles only the first event, as it would on a client.
+   *
+   * The bot's event fallback doesn't run here. On a bot, a guard's `GuardDeniedError` is logged and the
+   * event skipped, and a handler's `UserError` is logged and, when the event carries a message, answered
+   * as a reply to it; here both reject `emit` as any error does, so a test checks them with `rejects`.
    *
    * @param event - The client event, such as `'guildMemberAdd'`.
    * @param args - The event's arguments, typed from discord.js's `ClientEvents`.
-   * @returns How many handlers ran. Rejects once every handler has settled if any threw: with that
-   *   error when one handler failed, or an `AggregateError` of them when several did.
+   * @returns How many handlers ran. Rejects once every handler has settled if any threw, a guard's
+   *   `GuardDeniedError` and a handler's `UserError` included: with that error when one handler failed,
+   *   or an `AggregateError` of them when several did.
    *
    * @example
    * ```ts
@@ -3226,6 +4715,7 @@ const CHANNEL_TYPE_GUARDS = [
    * expect(ran).toBe(1)
    * ```
    */ async emit(event, ...args) {
+        this.warnIfClosed();
         await this.init();
         const calls = [];
         for (const cls of this.eventClasses){
@@ -3270,7 +4760,10 @@ const CHANNEL_TYPE_GUARDS = [
         this.appWarnUnanswered = appWarnUnanswered;
         this.services = services;
         this.shutdownTimeout = shutdownTimeout;
+        /** The `onReady` hooks' pass, which `close()` waits for, less one whose `onReady` called `close()`. */ this.readyPass = new startupRoots.ReadyPass();
+        this.warnedClosed = false;
         /** The `@Once` handlers that have already handled their event, as a client forgets its once listeners. */ this.firedOnce = new Set();
+        /** The handlers already warned about for being given fewer arguments than they take, so each is named once. */ this.warnedArgumentCounts = new Set();
         /** The calls under way, each removed once it settles: what `close()` lets finish before the cooldown store stops. */ this.calls = new Set();
     }
 }
@@ -3309,7 +4802,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.
@@ -3335,6 +4828,10 @@ const CHANNEL_TYPE_GUARDS = [
     /**
    * Replaces a guard with a stub wherever it applies, globally or on a controller or handler.
    *
+   * It stands in for the guard wherever the guard is bound, a provider of the same token included, and wins over an
+   * `overrideProvider` of it. The stub needs a `canActivate`, its own or its prototype's: `compile()` refuses one without
+   * it under `useStrictMocks()`, and otherwise warns.
+   *
    * @param guard - The guard class to replace.
    * @example
    * ```ts
@@ -3352,6 +4849,10 @@ const CHANNEL_TYPE_GUARDS = [
    * Replaces an interceptor with a stub wherever it applies, globally or on a controller or handler.
    * The stub's `intercept` receives the context and `next`; call `next.handle()` to run the handler.
    *
+   * It stands in for the interceptor wherever it is bound, a provider of the same token included, and wins over an
+   * `overrideProvider` of it. A stub without `intercept` is refused by `compile()` under `useStrictMocks()`, and
+   * otherwise warned about.
+   *
    * @param interceptor - The interceptor class to replace.
    * @example
    * ```ts
@@ -3369,6 +4870,10 @@ const CHANNEL_TYPE_GUARDS = [
    * Replaces an exception filter with a stub wherever it applies. The filter's `@Catch` still decides
    * which errors reach the stub.
    *
+   * It stands in for the filter wherever it is bound, a provider of the same token included, and wins over an
+   * `overrideProvider` of it. A stub without `catch` is refused by `compile()` under `useStrictMocks()`, and otherwise
+   * warned about.
+   *
    * @param filter - The filter class to replace.
    * @example
    * ```ts
@@ -3457,199 +4962,271 @@ 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);
+                // A stage override stands in for its class wherever the class is bound. A stage also provided takes the stub in
+                // place of its provider, one binding per token, and runs lifecycle hooks as that provider would; any other is
+                // bound on its own below, as the bot never makes a lifecycle unit of it. A stub that can't run is named here
+                const stageStubs = new Map();
+                for (const [method, overrides, kind] of [
+                    [
+                        'canActivate',
+                        this.guardOverrides,
+                        'overrideGuard'
+                    ],
+                    [
+                        'intercept',
+                        this.interceptorOverrides,
+                        'overrideInterceptor'
+                    ],
+                    [
+                        'catch',
+                        this.filterOverrides,
+                        'overrideFilter'
+                    ]
+                ]){
+                    for (const [stage, stub] of overrides){
+                        if (providers$1.has(stage)) providers$1.set(stage, {
+                            provide: stage,
+                            useValue: stub
+                        });
+                        else stageStubs.set(stage, stub);
+                        if (typeof stub[method] === 'function') continue;
+                        const problem = `${kind}(${stage.name}).useValue(…) has no ${method} method.`;
+                        if (strictMocks()) controller_decorator.startupError(new Error(problem));
+                        else controller_decorator.warnOnce(new controller_decorator.Logger('TestingModule'), `${problem} A call that reaches ${stage.name} fails; useStrictMocks() refuses it here.`);
+                    }
                 }
-            }));
-        // 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;
+                // 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 appPresenterClass = this.options.app && Reflect.getMetadata(controller_decorator.META.appOptions, this.options.app)?.presenter;
+                const startup = startupRoots.startupClasses({
+                    controllers: this.options.controllers ?? [],
+                    services,
+                    providers: providers$1,
+                    stages,
+                    presenter: appPresenterClass,
+                    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() }.');
+                    });
+                }
+                // A stage override nothing provides, bound before the classes so none of them binds the stage itself
+                for (const [stage, stub] of stageStubs)container.bind(stage).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)) 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);
+                // What the stages and presenter inject, as the bot makes it; a stage the test replaced contributes nothing
+                const stageServices = startupRoots.stageDependencies(startup, providers$1, appPresenterClass);
+                for (const service of stageServices)bindClass(service);
+                // 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,
+                    ...stageServices,
+                    ...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);
+                // And each instance with the module that made it, as another module made from the same classes stamps them again
+                providers.recordInstanceContainers(container, [
+                    ...this.options.controllers ?? [],
+                    ...startup.classes
+                ]);
+                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;
@@ -3687,7 +5264,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.
@@ -3695,7 +5272,15 @@ const CHANNEL_TYPE_GUARDS = [
    * @param options - The controllers, providers, observers and app the module is built from.
    * @returns The builder, to override what the test replaces before `compile()`.
    */ static create(options) {
-        return new TestingModuleBuilder(options);
+        // A controller listed twice is one controller, as the bot and fromApp take it
+        return new TestingModuleBuilder({
+            ...options,
+            ...options.controllers && {
+                controllers: [
+                    ...new Set(options.controllers)
+                ]
+            }
+        });
     }
     /**
    * Starts building a testing module from a whole `@MeoCord` app, wired as the bot wires it.
@@ -3777,6 +5362,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().`);
@@ -3820,7 +5428,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);
@@ -3846,7 +5454,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],
@@ -3855,28 +5466,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)
  * ```
@@ -3885,7 +5502,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;
 }
 
 /**
@@ -3954,7 +5587,15 @@ providers.adviseInPlaceOfInjecting(TestingModule, 'make it with MeoCordTestingMo
     return new Fields(components);
 }
 
-const isPlural = (value)=>typeof value === 'object' && value !== null && typeof value.other === 'string';
+const PLURAL_CATEGORIES = new Set([
+    'zero',
+    'one',
+    'two',
+    'few',
+    'many',
+    'other'
+]);
+/** A plural: an object whose every key is a plural category, as the translator's types read one; any other is a group. */ const isPlural = (value)=>typeof value === 'object' && value !== null && Object.keys(value).length > 0 && Object.keys(value).every((key)=>PLURAL_CATEGORIES.has(key));
 /** Every message key of a catalog, and whether it is a plural. */ function leaves(catalog, prefix = '') {
     return Object.entries(catalog).flatMap(([name, value])=>{
         const key = `${prefix}${name}`;
@@ -3973,8 +5614,9 @@ const isPlural = (value)=>typeof value === 'object' && value !== null && typeof
         return leaves(value, `${key}.`);
     });
 }
-function at(catalog, key) {
-    return key.split('.').reduce((current, part)=>current?.[part], catalog);
+/** A translation's text, which an empty string isn't: the translator reads `''` as missing, as tools export one untranslated. */ const isText = (value)=>typeof value === 'string' && value !== '';
+/** The value at a key's path, through own properties only, so `constructor` or `toString` is not read off a prototype. */ function at(catalog, key) {
+    return key.split('.').reduce((current, part)=>typeof current === 'object' && current !== null && Object.hasOwn(current, part) ? current[part] : undefined, catalog);
 }
 const MEOCORD_KEYS = new Set(leaves(controller_decorator.MEOCORD_MESSAGES).map(({ key })=>key));
 const isMeoCordKey = (key)=>key.startsWith('meocord.');
@@ -3997,9 +5639,11 @@ const isMeoCordKey = (key)=>key.startsWith('meocord.');
  *
  * Use it in a test for a team that wants no fallback in production. It reports the messages a locale lacks, the
  * messages the default catalog doesn't have, the plural forms a language needs but a plural lacks, such as `few` for
- * Russian, and each `{param}` a translation uses that the message it translates doesn't take. It reads the catalogs'
- * own strings, so it checks the params of a catalog from a plain variable or a JSON file too, which the compiler
- * can't.
+ * Russian, a translation of another shape than the default's, a text for a plural or a plural for a text, and each
+ * `{param}` a translation uses that the message it translates doesn't take. An empty translation, `''`, counts as
+ * lacking, as the translator reads it as missing. It reads the catalogs' own strings, so it checks the params of a
+ * catalog from a plain variable or a JSON file too, which the compiler can't. An object counts as a plural only when
+ * its every key is a plural category, so a group with an `other` key is a group.
  *
  * @remarks
  * MeoCord's own texts, a catalog's `meocord` group, fall back to English by design, so only a key MeoCord lacks, and
@@ -4032,7 +5676,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.');
@@ -4046,12 +5690,17 @@ const isMeoCordKey = (key)=>key.startsWith('meocord.');
         const categories = new Intl.PluralRules(locale).resolvedOptions().pluralCategories;
         for (const { key, plural } of reference){
             const message = at(catalog, key);
-            if (message === undefined) {
+            if (message === undefined || message === '') {
                 problems.push(`missing ${key}`);
                 continue;
             }
-            if (plural && isPlural(message)) {
-                const missing = categories.filter((category)=>typeof message[category] !== 'string');
+            // A translation of another shape than the default's can't be read as it: a text for a plural, or the reverse
+            if (plural !== isPlural(message) || !plural && typeof message !== 'string') {
+                problems.push(`${key} should be a ${plural ? 'plural' : 'text'}, as the default is`);
+                continue;
+            }
+            if (plural) {
+                const missing = categories.filter((category)=>!isText(message[category]));
                 if (missing.length > 0) problems.push(`${key} lacks ${missing.join(', ')}`);
             }
             const original = at(defaultCatalog, key);
@@ -4059,7 +5708,7 @@ const isMeoCordKey = (key)=>key.startsWith('meocord.');
             for (const name of stray)problems.push(`${key} takes no {${name}}; the default is "${shown(original)}"`);
         }
         if (options.meocord && !locale.startsWith('en-')) {
-            for (const key of MEOCORD_KEYS)if (at(catalog, key) === undefined) problems.push(`missing ${key}`);
+            for (const key of MEOCORD_KEYS)if (at(catalog, key) === undefined || at(catalog, key) === '') problems.push(`missing ${key}`);
         }
         for (const { key } of leaves(catalog)){
             if (isMeoCordKey(key)) {
@@ -4078,6 +5727,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.
  *
@@ -4086,9 +5736,11 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
  *
  * @remarks
  * The cases cover what a shared store most often gets wrong: a sliding window rather than fixed buckets,
- * `retryAfterMs` from the oldest call still in the window, calls in the same millisecond kept apart, and concurrent
- * calls at the limit where exactly one may pass. They use real time, with windows short enough that the suite takes
- * a few seconds, and each case counts under keys of its own. Each window is a whole number of milliseconds, as
+ * `retryAfterMs` until a use frees up, from the oldest of the newest `uses` calls in the window, calls in the same
+ * millisecond kept apart, concurrent calls at the limit where exactly one may pass, a batch refusal that names the
+ * longest wait, and a release that frees only the call it gave back. They use real time, with windows short enough that the suite takes
+ * a few seconds and margins wide enough that a correct store passes when timers fire late, as on a busy CI runner,
+ * and each case counts under keys of its own. Each window is a whole number of milliseconds, as
  * `@Cooldown` gives a store: it rounds its `seconds` to the millisecond.
  *
  * @param name - What the store is called in the report.
@@ -4105,7 +5757,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}`;
@@ -4128,32 +5780,62 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
             expect(refused.retryAfterMs).toBeLessThanOrEqual(limit.windowMs);
         });
         test('slides its window: a call is allowed once the oldest leaves it, not when a bucket resets', async (store)=>{
+            // A second between calls, in a 2 s window, leaves room for a timer that fires late on a busy runner
             const limit = {
                 uses: 2,
-                windowMs: 500
+                windowMs: 2000
             };
             await store.consume(key('sliding'), limit);
-            await sleep(250);
+            await sleep(1000);
             await store.consume(key('sliding'), limit);
             const refused = await store.consume(key('sliding'), limit);
             expect(refused.allowed).toBe(false);
             await sleep(refused.retryAfterMs + 40);
-            // The first call has left the window; the second, 250ms younger, still holds its use.
+            // The first call has left the window; the second, a second younger, still holds its use.
             expect((await store.consume(key('sliding'), limit)).allowed).toBe(true);
             expect((await store.consume(key('sliding'), limit)).allowed).toBe(false);
         });
         test('counts retryAfterMs from the oldest call still in the window', async (store)=>{
             const limit = {
                 uses: 2,
-                windowMs: 1000
+                windowMs: 2000
             };
+            const firstSent = Date.now();
             await store.consume(key('retry'), limit);
-            await sleep(300);
+            const firstDone = Date.now();
+            await sleep(1000);
+            const secondSent = Date.now();
             await store.consume(key('retry'), limit);
-            // From the oldest call, about 700ms remain; from the newest, about 1000ms would.
             const { retryAfterMs } = await store.consume(key('retry'), limit);
-            expect(retryAfterMs).toBeGreaterThan(limit.windowMs - 600);
-            expect(retryAfterMs).toBeLessThanOrEqual(limit.windowMs - 200);
+            const thirdDone = Date.now();
+            // What is left of the oldest call's window, by the times measured around each call, as timers may fire late;
+            // counted from the newest call, nearly the whole window would be left instead
+            expect(retryAfterMs).toBeLessThanOrEqual(limit.windowMs - (secondSent - firstDone) + CLOCK_SLACK_MS);
+            expect(retryAfterMs).toBeGreaterThanOrEqual(limit.windowMs - (thirdDone - firstSent) - CLOCK_SLACK_MS);
+        });
+        // @Cooldown keeps the calls counted so far when a limit is lowered, so a key can hold more calls than `uses`
+        test('counts retryAfterMs from the oldest of the newest `uses` calls when a lowered limit leaves more in the window', async (store)=>{
+            const windowMs = 2000;
+            for(let call = 0; call < 3; call += 1)await store.consume(key('lowered'), {
+                uses: 5,
+                windowMs
+            });
+            await sleep(1000);
+            const newerSent = Date.now();
+            for(let call = 0; call < 2; call += 1)await store.consume(key('lowered'), {
+                uses: 5,
+                windowMs
+            });
+            const { allowed, retryAfterMs } = await store.consume(key('lowered'), {
+                uses: 2,
+                windowMs
+            });
+            const refusedDone = Date.now();
+            expect(allowed).toBe(false);
+            // A use frees up when the older of the two newest calls leaves the window; counted from the oldest call, it would
+            // be a second sooner
+            expect(retryAfterMs).toBeGreaterThanOrEqual(windowMs - (refusedDone - newerSent) - CLOCK_SLACK_MS);
+            expect(retryAfterMs).toBeLessThanOrEqual(windowMs + CLOCK_SLACK_MS);
         });
         test('counts each key on its own', async (store)=>{
             const limit = {
@@ -4216,6 +5898,41 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
             expect(refused.retryAfterMs).toBeGreaterThan(short.windowMs);
             expect(refused.retryAfterMs).toBeLessThanOrEqual(long.windowMs);
         });
+        // A refusal names the wait until every cooldown of the batch allows the call; the default consumeMany stops at the first
+        test('names the longest wait when several cooldowns refuse a batch, or with the default consumeMany, the first', async (store)=>{
+            const short = {
+                uses: 1,
+                windowMs: 1000
+            };
+            const long = {
+                uses: 1,
+                windowMs: 2000
+            };
+            const batch = [
+                {
+                    key: key('both-short'),
+                    limit: short
+                },
+                {
+                    key: key('both-long'),
+                    limit: long
+                }
+            ];
+            await store.consume(batch[0].key, short);
+            await store.consume(batch[1].key, long);
+            const refused = await store.consumeMany(batch);
+            expect(refused.allowed).toBe(false);
+            const [blocked, limit] = overridesConsumeMany(store) ? [
+                1,
+                long
+            ] : [
+                0,
+                short
+            ];
+            expect(refused.blocked).toBe(blocked);
+            expect(refused.retryAfterMs).toBeGreaterThan(limit.windowMs - 1000);
+            expect(refused.retryAfterMs).toBeLessThanOrEqual(limit.windowMs);
+        });
         // The default consumeMany counts in order and stops at the first refusal, so the entries before it count
         test('records nothing when one cooldown of a batch refuses it, or with the default consumeMany, counts those before it', async (store)=>{
             const limit = {
@@ -4258,10 +5975,11 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
             }, ()=>store.consumeMany(batch)));
             expect(verdicts.filter((verdict)=>verdict.allowed).length).toBe(1);
         });
-        // A store without release keeps a counted call counted, as the default consumeMany does
-        test('releases a call it counted when the verdict gives release, or keeps it counted without one', async (store)=>{
+        // A store without release keeps a counted call counted, as the default consumeMany does. Two uses tell a release of
+        // the one call apart from one that frees the key's other calls too
+        test('releases only the call it counted when the verdict gives release, or keeps it counted without one', async (store)=>{
             const limit = {
-                uses: 1,
+                uses: 2,
                 windowMs: 2000
             };
             const entries = [
@@ -4274,6 +5992,7 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
                     limit
                 }
             ];
+            expect((await store.consumeMany(entries)).allowed).toBe(true);
             const counted = await store.consumeMany(entries);
             expect(counted.allowed).toBe(true);
             if (!counted.release) {
@@ -4501,7 +6220,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,
@@ -4510,7 +6229,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([
@@ -4532,6 +6251,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
@@ -4568,7 +6304,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');
 }
@@ -4615,6 +6351,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;
@@ -4623,7 +6360,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;