meocord 4.2.1 → 4.2.3

package/dist/cjs/testing/index.cjs

@@ -2,26 +2,26 @@
 
 require('reflect-metadata');
 var inversify = require('inversify');
-var providers = require('../_shared/providers-BZgJyfZS.cjs');
+var providers = require('../_shared/providers-BBvbnmLP.cjs');
 var discord_js = require('discord.js');
 var enum_index = require('../enum/index.cjs');
-var controller_decorator = require('../_shared/controller.decorator-XKMlcUZz.cjs');
-var startupRoots = require('../_shared/startup-roots-CgfPQrNl.cjs');
+var controller_decorator = require('../_shared/controller.decorator-hp5xdJU4.cjs');
+var eventSources = require('../_shared/event-sources-DzqTODXg.cjs');
 var node_crypto = require('node:crypto');
 require('node:async_hooks');
 require('crypto');
 require('fs');
 require('path');
 require('cli-table3');
-require('node:fs');
-require('node:url');
 require('node:util');
 require('dayjs');
 require('dayjs/plugin/utc.js');
 require('dayjs/plugin/timezone.js');
 require('module');
+require('node:fs');
 require('chalk');
-require('../_shared/translate-error-BUAR1WYG.cjs');
+require('node:url');
+require('../_shared/translate-error-wsgfsUET.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.
@@ -236,7 +236,13 @@ const collected = new FinalizationRegistry((ref)=>mocks$1.created.delete(ref));
         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
+        // Recorded as the call starts, so each call's results sit at its own index however calls nest, and filled in as it
+        // ends: a promise's outcome shows in settledResults once it resolves or rejects
+        const result = {
+            type: 'incomplete',
+            value: undefined
+        };
+        results.push(result);
         const settled = {
             type: 'incomplete',
             value: undefined
@@ -284,7 +290,7 @@ const collected = new FinalizationRegistry((ref)=>mocks$1.created.delete(ref));
             });
             throw err;
         } finally{
-            results.push({
+            Object.assign(result, {
                 type,
                 value
             });
@@ -389,6 +395,11 @@ const collected = new FinalizationRegistry((ref)=>mocks$1.created.delete(ref));
     return track(mockFn);
 }
 
+/**
+ * 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'));
+
 const VISIBLE = new Set([
     'reply',
     'update',
@@ -400,9 +411,10 @@ const VISIBLE = new Set([
  * Reports how an interaction was answered: where its answer stands, and every answer call it got, in order.
  *
  * Use it after `invoke` or `dispatch` to check what the member sees. A mock interaction records each `reply`,
- * `deferReply`, `editReply`, `followUp`, `deleteReply`, `update`, `deferUpdate` and `showModal`, whether the handler
- * made it through `respond()` or with discord.js directly, so both are reported, each once. For a message or a
- * reaction, read the mock's own methods.
+ * `deferReply`, `editReply`, `followUp`, `deleteReply`, `update`, `deferUpdate` and `showModal`, and under
+ * `useStrictMocks()` each `launchActivity`, `sendPremiumRequired` and autocomplete `respond` too, whether the handler made
+ * it through `respond()` or with discord.js directly, so both are reported, each once. For a message or a reaction, read
+ * the mock's own methods.
  *
  * @param interaction - The interaction a handler answered.
  * @returns The state, whether anything the member can see was sent, and the calls, in order.
@@ -447,7 +459,8 @@ const VISIBLE = new Set([
         sent,
         calls: calls
     };
-    const answered = interaction.isRepliable() ? interaction.replied : false;
+    // An autocomplete's choices are its answer, as observers read it, where its mock records them, under strict mocks
+    const answered = interaction.isRepliable() ? interaction.replied : Boolean(log) && interaction.isAutocomplete() && interaction.responded;
     const deferred = interaction.isRepliable() ? interaction.deferred : false;
     return {
         state: answered ? 'replied' : deferred ? 'deferred' : 'unanswered',
@@ -486,6 +499,72 @@ const VISIBLE = new Set([
     }, code, 400, 'POST', 'https://discord.com/api/v10/interactions', {});
 }
 
+/**
+ * Builds the `fields` of a submitted form, as discord.js does when a user submits one.
+ *
+ * Use it for a mock `ModalSubmitInteraction`: discord.js keeps the `ModalSubmitFields` constructor private, so a test
+ * cannot build one directly.
+ *
+ * @param values - Each field's value, keyed by its customId: a string for a text input, an array of strings for a
+ *   select's chosen values, or an array of `Attachment`s for a file upload. An empty array is a select with nothing
+ *   chosen.
+ * @returns Fields that `getTextInputValue`, `getStringSelectValues`, `getUploadedFiles` and a handler's params all
+ *   read.
+ *
+ * @example
+ * ```ts
+ * import { expect } from 'vitest'
+ *
+ * @Controller()
+ * class FeedbackController {
+ *   @Command('feedback/{topic}', CommandType.MODAL_SUBMIT)
+ *   async submit(interaction: ModalSubmitInteraction, { topic, body }: { topic: string; body: string }) {
+ *     await respond(interaction).send(`Thanks: ${topic}, ${body}`)
+ *   }
+ * }
+ * const module = MeoCordTestingModule.create({ controllers: [FeedbackController] }).compile()
+ * const fields = createModalFields({ body: 'It crashed' })
+ * const interaction = createMockInteraction(ModalSubmitInteraction, { customId: 'feedback/bugs', fields })
+ * await module.invoke(FeedbackController, 'submit', interaction)
+ * expect(getResponse(interaction).calls[0].payload).toMatchObject({ content: 'Thanks: bugs, It crashed' })
+ * ```
+ *
+ * @group Testing
+ * @category Mocks
+ * @see {@link createMockInteraction}
+ */ function createModalFields(values) {
+    const component = (customId, value)=>{
+        if (!Array.isArray(value)) return {
+            type: discord_js.ComponentType.TextInput,
+            customId,
+            value
+        };
+        if (!value.some((item)=>item instanceof discord_js.Attachment)) return {
+            type: discord_js.ComponentType.StringSelect,
+            customId,
+            values: value
+        };
+        const attachments = new discord_js.Collection(value.map((file)=>[
+                file.id,
+                file
+            ]));
+        return {
+            type: discord_js.ComponentType.FileUpload,
+            customId,
+            values: [
+                ...attachments.keys()
+            ],
+            attachments
+        };
+    };
+    const components = Object.entries(values).map(([customId, value])=>({
+            type: discord_js.ComponentType.Label,
+            component: component(customId, value)
+        }));
+    const Fields = discord_js.ModalSubmitFields;
+    return new Fields(components);
+}
+
 /**
  * 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.
@@ -517,8 +596,9 @@ const settings = controller_decorator.shared('strictMocks', ()=>({
  * 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.
+ * `mentions.repliedUser` and a modal's `message` are `null`, an interaction's `ephemeral` is `null` until `reply()` or
+ * `deferReply()` decides it, 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
@@ -531,11 +611,14 @@ const settings = controller_decorator.shared('strictMocks', ()=>({
  * 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.
+ * `mockResolvedValue`, is refused too, where without it the mock runs it and warns. An answer marks the interaction
+ * `replied`, `deferred` or `responded` once it resolves, as discord.js does, so code that doesn't await one fails as it
+ * would on a bot, within one run of the test's code. 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.
+ * It refuses an autocomplete that dispatch gives to another `@Autocomplete` handler, or to none, the same way.
  *
  * `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.
@@ -561,48 +644,6 @@ const settings = controller_decorator.shared('strictMocks', ()=>({
 }
 
 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
@@ -620,285 +661,7 @@ const channelPermissions = discord_js.GuildChannel.prototype;
         Class.prototype,
         defaults
     ];
-/**
- * What a mock reads for a data property discord.js always sets, where the test gave none: a value in Discord's shape,
- * such as `'en-US'` for a locale, `null` for what may be absent and `false` for a flag, or the property's own getter
- * for one discord.js computes. The classes a mock descends from are read nearest first.
- */ const DEFAULTS = new Map([
-    defaultsOf(discord_js.Guild, {
-        name: ()=>'Guild',
-        preferredLocale: ()=>discord_js.Locale.EnglishUS,
-        ownerId: nextSnowflake,
-        memberCount: ()=>1,
-        available: ()=>true,
-        large: ()=>false,
-        features: ()=>[],
-        description: ()=>null,
-        icon: ()=>null,
-        banner: ()=>null,
-        splash: ()=>null,
-        systemChannelId: ()=>null,
-        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
-    }),
-    defaultsOf(discord_js.ClientUser, {
-        username: ()=>'bot'
-    }),
-    defaultsOf(discord_js.User, {
-        username: ()=>'user',
-        bot: ()=>false,
-        globalName: ()=>null,
-        discriminator: ()=>'0',
-        avatar: ()=>null,
-        system: ()=>false,
-        flags: ()=>new discord_js.UserFlagsBitField(),
-        tag: REAL_GETTER,
-        displayName: REAL_GETTER,
-        defaultAvatarURL: REAL_GETTER,
-        createdTimestamp: REAL_GETTER,
-        createdAt: REAL_GETTER
-    }),
-    defaultsOf(discord_js.GuildMember, {
-        user: ()=>createMockUser(),
-        id: REAL_GETTER,
-        nickname: ()=>null,
-        avatar: ()=>null,
-        // In the server since the mock was made, as a member Discord sends always is
-        joinedTimestamp: ()=>Date.now(),
-        joinedAt: REAL_GETTER,
-        partial: REAL_GETTER,
-        premiumSince: REAL_GETTER,
-        communicationDisabledUntil: REAL_GETTER,
-        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, {
-        name: ()=>'role',
-        // Above @everyone, which a server's role manager makes at position 0
-        position: ()=>1,
-        // Every role has a server; one made without is in one of its own, unless a guild given it takes it in
-        guild: ()=>createMockGuild(),
-        rawPosition: (role)=>role.position,
-        permissions: noPermissions,
-        hoist: ()=>false,
-        managed: ()=>false,
-        mentionable: ()=>false,
-        icon: ()=>null,
-        unicodeEmoji: ()=>null,
-        tags: ()=>null,
-        colors: ()=>({
-                primaryColor: 0,
-                secondaryColor: null,
-                tertiaryColor: null
-            }),
-        hexColor: REAL_GETTER,
-        createdTimestamp: REAL_GETTER,
-        createdAt: REAL_GETTER
-    }),
-    // A message's text says which handler it is for, so it stays the test's to give, as a command's name does
-    defaultsOf(discord_js.Message, {
-        pinned: ()=>false,
-        tts: ()=>false,
-        type: ()=>discord_js.MessageType.Default,
-        system: ()=>false,
-        webhookId: ()=>null,
-        applicationId: ()=>null,
-        nonce: ()=>null,
-        position: ()=>null,
-        activity: ()=>null,
-        reference: ()=>null,
-        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: nextSnowflake,
-        commandGuildId: ()=>null
-    }),
-    defaultsOf(discord_js.AutocompleteInteraction, {
-        commandId: nextSnowflake,
-        commandGuildId: ()=>null,
-        options: ()=>createChatInputOptions()
-    }),
-    defaultsOf(discord_js.MessageReaction, {
-        users: (reaction)=>ownedManager(discord_js.ReactionUserManager.prototype, {
-                reaction
-            })
-    }),
-    defaultsOf(discord_js.BaseInteraction, {
-        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
-        // 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,
-        nsfw: ()=>false,
-        topic: ()=>null,
-        rateLimitPerUser: ()=>0
-    }),
-    defaultsOf(discord_js.NewsChannel, {
-        type: ()=>discord_js.ChannelType.GuildAnnouncement,
-        nsfw: ()=>false,
-        topic: ()=>null
-    }),
-    defaultsOf(discord_js.VoiceChannel, {
-        type: ()=>discord_js.ChannelType.GuildVoice,
-        nsfw: ()=>false
-    }),
-    defaultsOf(discord_js.ForumChannel, {
-        type: ()=>discord_js.ChannelType.GuildForum,
-        nsfw: ()=>false,
-        topic: ()=>null
-    }),
-    defaultsOf(discord_js.MediaChannel, {
-        type: ()=>discord_js.ChannelType.GuildMedia,
-        nsfw: ()=>false,
-        topic: ()=>null
-    }),
-    defaultsOf(discord_js.ThreadChannel, {
-        type: ()=>discord_js.ChannelType.PublicThread,
-        name: ()=>'thread'
-    }),
-    defaultsOf(discord_js.DMChannel, {
-        type: ()=>discord_js.ChannelType.DM
-    }),
-    defaultsOf(discord_js.GuildChannel, {
-        name: ()=>'channel',
-        guildId: (channel)=>typeof channel.guild?.id === 'string' ? channel.guild.id : nextSnowflake(),
-        position: ()=>0,
-        rawPosition: ()=>0,
-        parentId: ()=>null
-    }),
-    defaultsOf(discord_js.BaseChannel, {
-        createdTimestamp: REAL_GETTER,
-        createdAt: REAL_GETTER
-    }),
-    defaultsOf(discord_js.Client, {
-        readyTimestamp: ()=>Date.now(),
-        readyAt: REAL_GETTER,
-        uptime: REAL_GETTER,
-        token: ()=>null
-    }),
-    defaultsOf(discord_js.BaseGuild, {
-        nameAcronym: REAL_GETTER
-    })
-]);
-/**
- * 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()
-    })
-]);
+/** A channel's or thread's server id, its guild's, as discord.js sets it; one of its own for a guild the mock lacks. */ const guildIdOf = (channel)=>typeof channel.guild?.id === 'string' ? channel.guild.id : nextSnowflake();
 /**
  * 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.
@@ -960,19 +723,453 @@ const channelPermissions = discord_js.GuildChannel.prototype;
     }
     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;
+/**
+ * The defaults a mock reads for a property the test gave none, made with `makers`: for `key` on a mock of `target`'s
+ * class, the default of the nearest class that has one, strict ones first.
+ */ function discordDefaults(makers) {
+    const { botMemberOf, createChatInputOptions, createMockChannel, createMockGuild, createMockMessage, createMockUser, heldChannelOf, isRawMember, isUnsetEveryone, madeAt, memberRoles, NEW_SERVER_EVERYONE_PERMISSIONS, ownedManager, readPlaceAs, readPlaceQuietly } = makers;
+    /**
+   * 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;
     }
-    return undefined;
+    /**
+   * 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;
+    }
+    /**
+   * A member's join or a client's ready time: under strict mocks when the mock was made, as Discord sends it, so time a
+   * test advances afterwards counts. Default mode stamps it at the first read and warns once.
+   */ function stampedAt(mock, name) {
+        if (strictMocks()) return madeAt(mock);
+        controller_decorator.warnOnce(mockLogger$1, `${name} here is the time it was first read; under useStrictMocks() it is the time the mock was made, so time a ` + 'test advances afterwards counts.');
+        return Date.now();
+    }
+    /**
+   * The server of a channel or thread made without one: the one its own guildId names, else one of its own. Its own
+   * value is read, not its default, which reads the guild in turn.
+   */ function guildFromOwnId(channel) {
+        const id = Object.getOwnPropertyDescriptor(channel, 'guildId')?.value;
+        return createMockGuild(typeof id === 'string' ? {
+            id
+        } : {});
+    }
+    /** The bot's message a component interaction was used on, in the interaction's channel, holding that component. */ function clickedMessage(interaction) {
+        const channel = readPlaceQuietly(()=>interaction.channel);
+        const bot = interaction.client?.user;
+        const { componentType: type } = interaction;
+        // A placeholder customId, for an interaction made without one, has no place in the component's data
+        const customId = typeof interaction.customId === 'string' ? interaction.customId : undefined;
+        const component = type === discord_js.ComponentType.Button ? {
+            type,
+            custom_id: customId,
+            style: discord_js.ButtonStyle.Primary
+        } : type === discord_js.ComponentType.StringSelect ? {
+            type,
+            custom_id: customId,
+            options: []
+        } : typeof type === 'number' ? {
+            type,
+            custom_id: customId
+        } : undefined;
+        return createMockMessage({
+            ...channel ? {
+                channel: channel
+            } : {},
+            ...bot instanceof discord_js.User ? {
+                author: bot
+            } : {},
+            components: component ? [
+                {
+                    type: discord_js.ComponentType.ActionRow,
+                    components: [
+                        component
+                    ]
+                }
+            ] : []
+        });
+    }
+    /**
+   * What a mock reads for a data property discord.js always sets, where the test gave none: a value in Discord's shape,
+   * such as `'en-US'` for a locale, `null` for what may be absent and `false` for a flag, or the property's own getter
+   * for one discord.js computes. The classes a mock descends from are read nearest first.
+   */ const DEFAULTS = new Map([
+        defaultsOf(discord_js.Guild, {
+            name: ()=>'Guild',
+            preferredLocale: ()=>discord_js.Locale.EnglishUS,
+            ownerId: nextSnowflake,
+            memberCount: ()=>1,
+            available: ()=>true,
+            large: ()=>false,
+            features: ()=>[],
+            description: ()=>null,
+            icon: ()=>null,
+            banner: ()=>null,
+            splash: ()=>null,
+            systemChannelId: ()=>null,
+            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
+        }),
+        defaultsOf(discord_js.ClientUser, {
+            username: ()=>'bot'
+        }),
+        defaultsOf(discord_js.User, {
+            username: ()=>'user',
+            bot: ()=>false,
+            globalName: ()=>null,
+            discriminator: ()=>'0',
+            avatar: ()=>null,
+            system: ()=>false,
+            flags: ()=>new discord_js.UserFlagsBitField(),
+            tag: REAL_GETTER,
+            displayName: REAL_GETTER,
+            defaultAvatarURL: REAL_GETTER,
+            createdTimestamp: REAL_GETTER,
+            createdAt: REAL_GETTER
+        }),
+        defaultsOf(discord_js.GuildMember, {
+            user: ()=>createMockUser(),
+            id: REAL_GETTER,
+            nickname: ()=>null,
+            avatar: ()=>null,
+            joinedTimestamp: (member)=>stampedAt(member, 'GuildMember.joinedTimestamp'),
+            joinedAt: REAL_GETTER,
+            partial: REAL_GETTER,
+            premiumSince: REAL_GETTER,
+            communicationDisabledUntil: REAL_GETTER,
+            premiumSinceTimestamp: ()=>null,
+            communicationDisabledUntilTimestamp: ()=>null,
+            pending: ()=>false,
+            flags: ()=>new discord_js.GuildMemberFlagsBitField().freeze(),
+            displayName: REAL_GETTER,
+            // The colour of its highest coloured role, as discord.js computes it from the roles in its cache
+            displayColor: REAL_GETTER,
+            displayHexColor: REAL_GETTER,
+            roles: (member)=>memberRoles(member, []),
+            permissions: REAL_GETTER
+        }),
+        // A server's emoji, sticker, scheduled event and AutoMod rule are named, and what discord.js formats from them
+        // computes: an emoji's mention and identifier, an event's and an invite's link
+        defaultsOf(discord_js.GuildEmoji, {
+            name: ()=>'emoji',
+            animated: ()=>false,
+            identifier: REAL_GETTER
+        }),
+        defaultsOf(discord_js.Sticker, {
+            name: ()=>'sticker'
+        }),
+        defaultsOf(discord_js.GuildScheduledEvent, {
+            name: ()=>'event',
+            url: REAL_GETTER
+        }),
+        defaultsOf(discord_js.AutoModerationRule, {
+            name: ()=>'rule'
+        }),
+        defaultsOf(discord_js.Invite, {
+            url: REAL_GETTER
+        }),
+        defaultsOf(discord_js.Role, {
+            name: ()=>'role',
+            // Above @everyone, which a server's role manager makes at position 0
+            position: ()=>1,
+            // Every role has a server; one made without is in one of its own, unless a guild given it takes it in
+            guild: ()=>createMockGuild(),
+            rawPosition: (role)=>role.position,
+            permissions: noPermissions,
+            hoist: ()=>false,
+            managed: ()=>false,
+            mentionable: ()=>false,
+            icon: ()=>null,
+            unicodeEmoji: ()=>null,
+            tags: ()=>null,
+            colors: ()=>({
+                    primaryColor: 0,
+                    secondaryColor: null,
+                    tertiaryColor: null
+                }),
+            hexColor: REAL_GETTER,
+            createdTimestamp: REAL_GETTER,
+            createdAt: REAL_GETTER
+        }),
+        // A message's text says which handler it is for, so it stays the test's to give, as a command's name does
+        defaultsOf(discord_js.Message, {
+            pinned: ()=>false,
+            tts: ()=>false,
+            type: ()=>discord_js.MessageType.Default,
+            system: ()=>false,
+            webhookId: ()=>null,
+            applicationId: ()=>null,
+            nonce: ()=>null,
+            position: ()=>null,
+            activity: ()=>null,
+            reference: ()=>null,
+            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: nextSnowflake,
+            commandGuildId: ()=>null
+        }),
+        defaultsOf(discord_js.AutocompleteInteraction, {
+            commandId: nextSnowflake,
+            commandGuildId: ()=>null,
+            options: ()=>createChatInputOptions()
+        }),
+        defaultsOf(discord_js.MessageReaction, {
+            users: (reaction)=>ownedManager(discord_js.ReactionUserManager.prototype, {
+                    reaction
+                })
+        }),
+        // The bot's message the component was used on, holding it, in the interaction's channel, as Discord always sends it;
+        // the component discord.js finds there by its customId
+        defaultsOf(discord_js.MessageComponentInteraction, {
+            message: clickedMessage,
+            component: REAL_GETTER
+        }),
+        // A modal submitted with no fields given has none
+        defaultsOf(discord_js.ModalSubmitInteraction, {
+            fields: ()=>createModalFields({}),
+            components: ()=>[]
+        }),
+        defaultsOf(discord_js.BaseInteraction, {
+            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
+            // 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,
+            nsfw: ()=>false,
+            topic: ()=>null,
+            rateLimitPerUser: ()=>0
+        }),
+        defaultsOf(discord_js.NewsChannel, {
+            type: ()=>discord_js.ChannelType.GuildAnnouncement,
+            nsfw: ()=>false,
+            topic: ()=>null
+        }),
+        defaultsOf(discord_js.VoiceChannel, {
+            type: ()=>discord_js.ChannelType.GuildVoice,
+            nsfw: ()=>false
+        }),
+        defaultsOf(discord_js.ForumChannel, {
+            type: ()=>discord_js.ChannelType.GuildForum,
+            nsfw: ()=>false,
+            topic: ()=>null
+        }),
+        defaultsOf(discord_js.MediaChannel, {
+            type: ()=>discord_js.ChannelType.GuildMedia,
+            nsfw: ()=>false,
+            topic: ()=>null
+        }),
+        defaultsOf(discord_js.StageChannel, {
+            type: ()=>discord_js.ChannelType.GuildStageVoice,
+            nsfw: ()=>false,
+            topic: ()=>null
+        }),
+        defaultsOf(discord_js.CategoryChannel, {
+            type: ()=>discord_js.ChannelType.GuildCategory
+        }),
+        defaultsOf(discord_js.DirectoryChannel, {
+            type: ()=>discord_js.ChannelType.GuildDirectory
+        }),
+        // A thread's server is its guild's, as discord.js sets it from the thread's guild
+        defaultsOf(discord_js.ThreadChannel, {
+            type: ()=>discord_js.ChannelType.PublicThread,
+            name: ()=>'thread',
+            guildId: guildIdOf
+        }),
+        defaultsOf(discord_js.DMChannel, {
+            type: ()=>discord_js.ChannelType.DM
+        }),
+        defaultsOf(discord_js.PartialGroupDMChannel, {
+            type: ()=>discord_js.ChannelType.GroupDM
+        }),
+        defaultsOf(discord_js.GuildChannel, {
+            name: ()=>'channel',
+            guildId: guildIdOf,
+            position: ()=>0,
+            rawPosition: ()=>0,
+            parentId: ()=>null
+        }),
+        defaultsOf(discord_js.BaseChannel, {
+            createdTimestamp: REAL_GETTER,
+            createdAt: REAL_GETTER
+        }),
+        defaultsOf(discord_js.Client, {
+            readyTimestamp: (client)=>stampedAt(client, 'Client.readyTimestamp'),
+            readyAt: REAL_GETTER,
+            uptime: REAL_GETTER,
+            token: ()=>null
+        }),
+        // What a member's roles show, computed from the roles in the cache as discord.js does
+        defaultsOf(discord_js.GuildMemberRoleManager, {
+            color: REAL_GETTER,
+            hoist: REAL_GETTER,
+            icon: REAL_GETTER
+        }),
+        defaultsOf(discord_js.BaseGuild, {
+            nameAcronym: REAL_GETTER
+        })
+    ]);
+    /**
+   * 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: guildFromOwnId,
+            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: guildFromOwnId,
+            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()
+        })
+    ]);
+    return (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;
+    };
 }
 
 /** Where a mock resolves unfurled media to, as Discord's media proxy would. */ const PROXY = 'https://images-ext-1.discordapp.net/external/mock';
@@ -1108,8 +1305,12 @@ const SKIP = new Set([
 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();
+// When each mock was made, which what Discord stamps when a structure arrives, such as a member's join, reads
+const madeTimes = new WeakMap();
+/** When `mock` was made: the time a value Discord stamps as it sends the structure reads. */ const madeAt = (mock)=>madeTimes.get(mock) ?? Date.now();
 function stubDeep(instance, externalStubs, onSet) {
     noteMockMade();
+    const made = Date.now();
     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();
@@ -1174,7 +1375,7 @@ function stubDeep(instance, externalStubs, onSet) {
             }
             // 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)=>quietly(target, key, ()=>protoValue.apply(proxy, args))) : methodStub(target, key, protoValue, ()=>proxy) : stubDeep({});
+            const stub = typeof protoValue === 'function' ? isRealMethod(target, key) ? createMockFn((...args)=>lacksServer(target, key, proxy) ? undefined : quietly(target, key, ()=>protoValue.apply(proxy, args))) : methodStub(target, key, protoValue, ()=>proxy) : autoStub();
             stubs.set(key, stub);
             return stub;
         },
@@ -1197,6 +1398,7 @@ function stubDeep(instance, externalStubs, onSet) {
         }
     });
     mockTargets.set(proxy, instance);
+    madeTimes.set(proxy, made);
     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,
@@ -1270,6 +1472,32 @@ const STRICT_REAL_METHODS = new Map([
         ])
     ]
 ]);
+// A channel's permission methods, each of which reads the channel's server
+const SERVER_PERMISSION_METHODS = new Set([
+    'permissionsFor',
+    'overwritesFor',
+    'memberPermissions',
+    'rolePermissions'
+]);
+// The stubs a mock makes for what a test never gave it, as opposed to anything a test passes or sets
+const autoStubs = new WeakSet();
+function autoStub() {
+    const stub = stubDeep({});
+    autoStubs.add(stub);
+    return stub;
+}
+/**
+ * Whether a channel's permission method has no server to read: in default mode a channel made without one holds the
+ * mock's own stub for it, so the method returns `undefined`, as a thread's does, and says so once. A server the test
+ * gave, of whatever class, is read as it is. Strict mocks give the channel one.
+ */ function lacksServer(target, key, channel) {
+    if (strictMocks() || !(target instanceof discord_js.GuildChannel) || !SERVER_PERMISSION_METHODS.has(key)) return false;
+    const guild = readPlaceQuietly(()=>channel.guild);
+    if (typeof guild !== 'object' || guild === null || !autoStubs.has(guild)) return false;
+    const name = Object.getPrototypeOf(target).constructor.name;
+    controller_decorator.warnPlaceholder(mockLogger, `${name}.${key}`, 'the mock gives the channel a server and computes it', `Give the channel a guild, such as createMockChannel(${name}, { guild }), or call useStrictMocks() to have the mock compute it now.`);
+    return true;
+}
 function isRealMethod(target, key) {
     for(let proto = Object.getPrototypeOf(target); proto !== null; proto = Object.getPrototypeOf(proto)){
         if (REAL_METHODS.get(proto)?.has(key) || strictMocks() && STRICT_REAL_METHODS.get(proto)?.has(key)) return true;
@@ -1414,28 +1642,68 @@ function clientOf(target) {
 // ---------------------------------------------------------------------------
 // methodStub — what an auto-stubbed discord.js method returns
 // ---------------------------------------------------------------------------
-// discord.js methods not declared `async` that still return a promise; `set*` setters are matched by name
+// discord.js methods not declared `async` that still return a promise; `set*` setters are matched by name.
+// mock-promise-methods.spec checks this list against discord.js's typings
 const PROMISE_METHODS = new Set([
+    'awaitMessageComponent',
+    'awaitMessages',
+    'awaitReactions',
     'ban',
+    'bulkBan',
     'clone',
+    'create',
     'createDM',
     'createInvite',
+    'createStageInstance',
+    'createWebhook',
+    'delete',
+    'deleteDM',
     'disableCommunicationUntil',
+    'disconnect',
     'edit',
     'fetch',
+    'fetchAuthor',
     'fetchFlags',
     'fetchInvites',
     'fetchMe',
     'fetchReply',
+    'fetchSubscribers',
+    'fetchUser',
+    'fetchVoters',
     'fetchWebhooks',
     'fetchWidget',
     'forward',
+    'kick',
     'pin',
+    'rawFetchGuildActiveThreads',
     'removeAttachments',
     'suppressEmbeds',
     'timeout',
+    'unban',
     'unpin'
 ]);
+// Methods that return a promise on one class only, as their name is synchronous on another: a role manager's set, and
+// a scheduled event's setStatus, where a client user's setStatus applies at once
+const PROMISE_METHODS_OF = [
+    [
+        discord_js.GuildEmojiRoleManager,
+        new Set([
+            'set'
+        ])
+    ],
+    [
+        discord_js.GuildMemberRoleManager,
+        new Set([
+            'set'
+        ])
+    ],
+    [
+        discord_js.GuildScheduledEvent,
+        new Set([
+            'setStatus'
+        ])
+    ]
+];
 // The client user's presence setters, which apply at once and return the presence
 const SYNC_SETTERS = new Set([
     'setActivity',
@@ -1460,27 +1728,129 @@ const SELF_METHODS = new Set([
     'disableCommunicationUntil',
     'edit',
     'fetch',
+    'kick',
     'pin',
     'timeout',
     'unpin'
 ]);
+// Collectors that resolve to what they collected: nothing, for a mock no one answers
+const COLLECTING_METHODS = new Set([
+    'awaitMessages',
+    'awaitReactions'
+]);
 // The DM channel of each user, made once, as Discord keeps one per user
 const dmChannels = new WeakMap();
-function dmChannelOf(user) {
+/**
+ * A user's one DM channel: its recipient is the user, and it is the user's `dmChannel`. Under strict mocks its client
+ * is the user's; default mode keeps a client of its own, and a read of it warns once where it isn't the user's.
+ */ function dmChannelOf(user) {
     let channel = dmChannels.get(user);
     if (!channel) {
-        channel = createMockChannel(discord_js.DMChannel);
-        channel.recipientId = user.id;
+        const made = createMockChannel(discord_js.DMChannel);
+        // Getters in discord.js, so set through the mock, which defines them
+        made.recipientId = user.id;
+        if (user instanceof discord_js.User) {
+            // Not enumerated, so a DM channel's own keys, and a user's, stay those a test may compare
+            const place = (target, key, value)=>Object.defineProperty(target, key, {
+                    value,
+                    writable: true,
+                    configurable: true
+                });
+            place(made, 'recipient', user);
+            place(user, 'dmChannel', made);
+            if (user.client instanceof discord_js.Client) {
+                if (strictMocks()) place(made, 'client', user.client);
+                else warnOnClientRead(made, user.client);
+            }
+        }
+        channel = made;
         dmChannels.set(user, channel);
     }
     return channel;
 }
+/**
+ * Has a read of a default-mode DM channel's `client`, its own where strict mocks give the user's, warn once, so a test
+ * that reads it hears of the difference and the mock's own reads, as a send through the channel makes, stay quiet.
+ */ function warnOnClientRead(channel, userClient) {
+    if (readPlaceQuietly(()=>channel.client) === userClient) return;
+    // The read is answered by the channel's stub, which warns by the mock's own instance
+    warnOnRead(mockTargets.get(channel) ?? channel, 'client', ()=>{
+        if (readingPlace > 0) return;
+        controller_decorator.warnOnce(mockLogger, "A mock user's DM channel here has a client of its own, not the user's; under useStrictMocks() it shares the user's " + 'client.');
+    });
+}
+// What default mode's user manager DMs do apart from discord.js's, warned of once each
+const USER_MANAGER_DM_WARNINGS = {
+    createDM: 'UserManager.createDM() here gives every user the same DM channel; under useStrictMocks() each user has their own, ' + 'as Discord keeps one per user.',
+    send: "UserManager.send() here resolves to a message that doesn't hold what was sent; under useStrictMocks() it sends " + "through the user's DM channel, as discord.js does."
+};
+/** A user made for a manager, on the manager's client, as discord.js makes one. */ function userOf(manager, id) {
+    const user = createMockUser(id ? {
+        id
+    } : {});
+    const client = manager.client;
+    if (client instanceof discord_js.Client) Object.defineProperty(user, 'client', {
+        value: client,
+        writable: true,
+        configurable: true
+    });
+    return user;
+}
 /** The guild a manager belongs to, when it is a mock guild's. */ const guildOf = (manager)=>{
     const guild = manager.guild;
     return guild instanceof discord_js.Guild ? guild : undefined;
 };
-// The item each manager fetches, creates and edits: with the id asked for, but for a ban or a thread member, and a
-// member or channel in the manager's guild
+// The class discord.js makes for each type of channel a server's channel manager creates; a text channel by default
+const CHANNEL_CLASSES = {
+    [discord_js.ChannelType.GuildText]: discord_js.TextChannel,
+    [discord_js.ChannelType.GuildVoice]: discord_js.VoiceChannel,
+    [discord_js.ChannelType.GuildCategory]: discord_js.CategoryChannel,
+    [discord_js.ChannelType.GuildAnnouncement]: discord_js.NewsChannel,
+    [discord_js.ChannelType.GuildStageVoice]: discord_js.StageChannel,
+    [discord_js.ChannelType.GuildDirectory]: discord_js.DirectoryChannel,
+    [discord_js.ChannelType.GuildForum]: discord_js.ForumChannel,
+    [discord_js.ChannelType.GuildMedia]: discord_js.MediaChannel
+};
+/**
+ * The class of a channel a server's channel manager makes for `type`: under strict mocks the one discord.js makes,
+ * while default mode keeps a text channel and warns once for another type.
+ */ function createdChannelClass(type) {
+    const Class = CHANNEL_CLASSES[type ?? discord_js.ChannelType.GuildText] ?? discord_js.TextChannel;
+    if (Class === discord_js.TextChannel || strictMocks()) return Class;
+    controller_decorator.warnOnce(mockLogger, 'GuildChannelManager.create() here makes a text channel whatever type its options name; under useStrictMocks() it ' + 'makes the channel discord.js makes for that type.');
+    return discord_js.TextChannel;
+}
+/** A thread a channel's thread manager makes: in that channel, as its parent, and in its server. */ function threadIn(id, manager) {
+    const channel = manager.channel;
+    if (!(channel instanceof discord_js.GuildChannel)) return createMockChannel(discord_js.ThreadChannel, id ? {
+        id
+    } : {});
+    const guild = channel.guild;
+    const thread = createMockChannel(discord_js.ThreadChannel, id ? {
+        id
+    } : {});
+    // Not enumerated, so a mock thread's own keys stay those of one made alone, as a test may compare
+    const place = (key, value)=>Object.defineProperty(thread, key, {
+            value,
+            writable: true,
+            configurable: true
+        });
+    place('parentId', channel.id);
+    if (!(guild instanceof discord_js.Guild)) return thread;
+    place('guild', guild);
+    place('guildId', guild.id);
+    // The parent is found through its server's channels, as discord.js finds it, by the thread's parentId. Strict mocks
+    // cache the channel there; default mode leaves the server's cache as it was and reads the channel itself
+    if (strictMocks()) cached(cacheOf(guild.channels), channel.id, ()=>channel);
+    Object.defineProperty(thread, 'parent', {
+        get: ()=>{
+            const parentId = thread.parentId ?? '';
+            return cacheOf(guild.channels)?.get(parentId) ?? (parentId === channel.id ? channel : null);
+        },
+        configurable: true
+    });
+    return thread;
+}
 const MANAGER_ITEMS = [
     [
         discord_js.UserManager,
@@ -1522,9 +1892,10 @@ const MANAGER_ITEMS = [
         ()=>createMockInteraction(discord_js.GuildBan)
     ],
     // A message fetched from a channel is in it, and another user's
+    // A message made in the channel is the one fetched by its id, as Discord has it
     [
         discord_js.GuildMessageManager,
-        (id, manager)=>createMockMessage({
+        (id, manager)=>madeIn(manager, id) ?? createMockMessage({
                 ...id ? {
                     id
                 } : {},
@@ -1533,7 +1904,7 @@ const MANAGER_ITEMS = [
     ],
     [
         discord_js.DMMessageManager,
-        (id, manager)=>createMockMessage({
+        (id, manager)=>madeIn(manager, id) ?? createMockMessage({
                 ...id ? {
                     id
                 } : {},
@@ -1542,15 +1913,11 @@ const MANAGER_ITEMS = [
     ],
     [
         discord_js.GuildTextThreadManager,
-        (id)=>createMockChannel(discord_js.ThreadChannel, id ? {
-                id
-            } : {})
+        threadIn
     ],
     [
         discord_js.GuildForumThreadManager,
-        (id)=>createMockChannel(discord_js.ThreadChannel, id ? {
-                id
-            } : {})
+        threadIn
     ],
     [
         discord_js.ThreadMemberManager,
@@ -1576,7 +1943,7 @@ const MANAGER_ITEMS = [
     ],
     [
         discord_js.GuildChannelManager,
-        (id, manager)=>createMockChannel(discord_js.TextChannel, {
+        (id, manager, options)=>createMockChannel(createdChannelClass(options?.type), {
                 ...id ? {
                     id
                 } : {},
@@ -1584,9 +1951,65 @@ const MANAGER_ITEMS = [
                     guild: guildOf(manager)
                 } : {}
             })
+    ],
+    [
+        discord_js.GuildEmojiManager,
+        (id, manager)=>itemInGuild(discord_js.GuildEmoji, {
+                id: id ?? nextSnowflake()
+            }, manager)
+    ],
+    [
+        discord_js.GuildStickerManager,
+        (id, manager)=>itemInGuild(discord_js.Sticker, {
+                id: id ?? nextSnowflake()
+            }, manager)
+    ],
+    [
+        discord_js.GuildScheduledEventManager,
+        (id, manager)=>itemInGuild(discord_js.GuildScheduledEvent, {
+                id: id ?? nextSnowflake()
+            }, manager)
+    ],
+    [
+        discord_js.AutoModerationRuleManager,
+        (id, manager)=>itemInGuild(discord_js.AutoModerationRule, {
+                id: id ?? nextSnowflake()
+            }, manager)
+    ],
+    // An invite is keyed by its code, as discord.js caches and fetches one
+    [
+        discord_js.GuildInviteManager,
+        (code, manager)=>itemInGuild(discord_js.Invite, {
+                code: code ?? BigInt(nextSnowflake()).toString(36)
+            }, manager)
     ]
 ];
-const returnsPromise = (key, method)=>method.constructor.name === 'AsyncFunction' || PROMISE_METHODS.has(key) || /^set[A-Z]/.test(key) && !SYNC_SETTERS.has(key);
+/** A mock of `Class` with `props`, in the manager's guild, by the guild and its id, when the manager has one. */ function itemInGuild(Class, props, manager) {
+    const guild = guildOf(manager);
+    return createMockInteraction(Class, {
+        ...props,
+        ...guild ? {
+            guild,
+            guildId: guild.id
+        } : {}
+    });
+}
+/**
+ * Names what a manager's create() or edit() made the `name` its options give, as discord.js does, under strict mocks;
+ * default mode keeps the name it has, with a warning once.
+ */ function withName(manager, method, item, options) {
+    const name = options?.name;
+    const current = item.name;
+    if (typeof name !== 'string' || current === name) return item;
+    if (strictMocks()) {
+        item.name = name;
+        return item;
+    }
+    const Manager = Object.getPrototypeOf(manager).constructor.name;
+    controller_decorator.warnOnce(mockLogger, `${Manager}.${method}() here leaves the item with the mock's name, not the name its options give, as discord.js names it; ` + 'in the next major version (5.0) the mock names it so. Call useStrictMocks() to have it named now.');
+    return item;
+}
+/** Whether a discord.js method on `target` returns a promise: an async one, or one the lists above name. */ const returnsPromise = (target, key, method)=>method.constructor.name === 'AsyncFunction' || PROMISE_METHODS.has(key) || PROMISE_METHODS_OF.some(([Class, keys])=>keys.has(key) && Class.prototype.isPrototypeOf(target)) || /^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)=>{
@@ -1614,18 +2037,58 @@ function fetchedIds(args) {
     }
     return undefined;
 }
+// How many messages discord.js's MessageManager.fetch() asks Discord for when its options give no limit
+const DEFAULT_FETCH_LIMIT = 50;
+/** Which of two messages is newer, by snowflake id, else by when the mock was made: negative when `a` is. */ function newerFirst(a, b) {
+    if (isSnowflake(a.id) && isSnowflake(b.id) && a.id !== b.id) return BigInt(b.id) > BigInt(a.id) ? 1 : -1;
+    return b.createdTimestamp - a.createdTimestamp;
+}
+/**
+ * A channel's messages as `messages.fetch(options)` lists them under strict mocks: those its cache holds, newest first,
+ * before, after or around the message `options` names, at most `limit` of them.
+ */ function recentMessages(manager, options) {
+    const { limit = DEFAULT_FETCH_LIMIT, before, after, around } = options ?? {};
+    const all = [
+        ...cacheOf(manager)?.values() ?? []
+    ];
+    const sorted = all.sort(newerFirst);
+    const at = (id)=>sorted.findIndex((message)=>message.id === id);
+    let window = sorted;
+    if (before !== undefined) window = at(before) === -1 ? [] : sorted.slice(at(before) + 1);
+    else if (after !== undefined) window = at(after) === -1 ? [] : sorted.slice(0, at(after)).slice(-limit);
+    else if (around !== undefined) window = at(around) === -1 ? [] : sorted.slice(Math.max(0, at(around) - Math.floor(limit / 2)));
+    return new discord_js.Collection(window.slice(0, limit).map((message)=>[
+            message.id,
+            message
+        ]));
+}
 /**
  * The mock function for a method found on a discord.js prototype. One that returns a promise in discord.js resolves:
- * `createDM` to the user's DM channel, `send` and its kin to a message, a manager's `fetch`, `create` and `edit` to its
- * item (a collection of each for a fetch of several, an empty one for a list fetch), a structure's own `edit`, `fetch`,
- * `delete`, `ban`, `pin`, `unpin`, `timeout`, `disableCommunicationUntil` and setters to the structure, and the rest to
- * `undefined`. Any other method returns `undefined`.
+ * `createDM` to the user's DM channel, `send` and its kin to a message, `awaitMessages` and `awaitReactions` to an
+ * empty collection, a manager's `fetch`, `create` and `edit` to its item (a collection of each for a fetch of several,
+ * an empty one for a list fetch), a structure's own `edit`, `fetch`, `delete`, `ban`, `kick`, `pin`, `unpin`, `timeout`,
+ * `disableCommunicationUntil` and setters to the structure, and the rest to `undefined`. Any other method returns
+ * `undefined`.
  */ function methodStub(target, key, method, receiver) {
-    if (!returnsPromise(key, method)) return createMockFn();
+    if (!returnsPromise(target, key, method)) return createMockFn();
     // A member's DMs go through its user, and a user's through its one DM channel, as discord.js sends them
     if (target instanceof discord_js.GuildMember && (key === 'createDM' || key === 'send')) {
         return createMockFn(async (...args)=>receiver().user[key](...args));
     }
+    // Under strict mocks a user manager's DMs go to the user named, its cached one or one made and cached, as discord.js
+    // resolves it; default mode keeps one DM channel for the manager and a send that resolves to an empty message
+    if (target instanceof discord_js.UserManager && (key === 'createDM' || key === 'send')) {
+        return createMockFn(async (user, ...args)=>{
+            if (!strictMocks()) {
+                controller_decorator.warnOnce(mockLogger, USER_MANAGER_DM_WARNINGS[key]);
+                return key === 'createDM' ? dmChannelOf(receiver()) : createMockMessage();
+            }
+            const named = user instanceof discord_js.GuildMember ? user.user : user;
+            const id = typeof named === 'string' ? named : named?.id;
+            const resolved = named instanceof discord_js.User ? named : cached(cacheOf(receiver()), id ?? nextSnowflake(), ()=>userOf(receiver(), id));
+            return key === 'createDM' ? resolved.createDM() : resolved.send(...args);
+        });
+    }
     if (key === 'createDM') return createMockFn(async ()=>dmChannelOf(receiver()));
     if (key === 'send' && target instanceof discord_js.User) {
         return createMockFn(async (...args)=>(await receiver().createDM()).send(...args));
@@ -1635,6 +2098,7 @@ function fetchedIds(args) {
         return createMockFn(async (options)=>sentMessage(sent(options, false), receiver()));
     }
     if (MESSAGE_METHODS.has(key)) return createMockFn(async ()=>createMockMessage());
+    if (COLLECTING_METHODS.has(key)) return createMockFn(async ()=>new discord_js.Collection());
     if (target instanceof discord_js.BaseManager) {
         const item = MANAGER_ITEMS.find(([Manager])=>Manager.prototype.isPrototypeOf(target))?.[1];
         // A fetch of one item finds it in the cache first, as discord.js does, and caches one it makes; a fetch of
@@ -1647,10 +2111,27 @@ function fetchedIds(args) {
                         id,
                         one(id)
                     ]));
-                return ids === undefined ? new discord_js.Collection() : one(ids);
+                if (ids !== undefined) return one(ids);
+                // Under strict mocks a channel's fetch() lists the messages it holds, as discord.js lists its recent ones;
+                // default mode resolves to none, and warns once for a channel that strict mocks would list messages of
+                const messages = target instanceof discord_js.GuildMessageManager || target instanceof discord_js.DMMessageManager;
+                if (messages && strictMocks()) return recentMessages(receiver(), args[0]);
+                if (messages) warnUnlisted(receiver());
+                return new discord_js.Collection();
+            });
+        }
+        // Under strict mocks an edit reaches the item named, the cached one or one made and cached under its id, as
+        // discord.js patches it; default mode resolves to a new item and warns once
+        if (item && key === 'edit') {
+            return createMockFn(async (named, options)=>{
+                const id = typeof named === 'string' ? named : named?.id;
+                if (id !== undefined && !strictMocks()) {
+                    controller_decorator.warnOnce(mockLogger, `${Object.getPrototypeOf(receiver()).constructor.name}.edit() here ` + 'resolves to a new item with an id of its own, not the item named; under useStrictMocks() it resolves to ' + 'the item with that id, the cached one or one made under it.');
+                }
+                const edited = id === undefined || !strictMocks() ? item(undefined, receiver()) : cached(cacheOf(receiver()), id, ()=>item(id, receiver()));
+                return withName(receiver(), 'edit', edited, options);
             });
         }
-        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)=>{
@@ -1659,11 +2140,23 @@ function fetchedIds(args) {
                 return typeof user === 'string' ? user : user?.id;
             });
         }
+        // An invite is made for the channel given, in its guild, and cached nowhere, as discord.js's create does
+        if (item && key === 'create' && target instanceof discord_js.GuildInviteManager) {
+            return createMockFn(async (channel)=>{
+                const invite = item(undefined, receiver());
+                const channelId = typeof channel === 'string' ? channel : channel?.id;
+                const found = channel instanceof discord_js.BaseChannel ? channel : channelId ? cacheOf(guildOf(receiver())?.channels)?.get(channelId) ?? null : null;
+                return Object.assign(invite, {
+                    channel: found,
+                    channelId: channelId ?? null
+                });
+            });
+        }
         // 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());
+            return createMockFn(async (options)=>{
+                const made = withName(receiver(), 'create', item(undefined, receiver(), options), options);
                 if (typeof made.id === 'string') cacheOf(receiver())?.set(made.id, made);
                 return made;
             });
@@ -1855,10 +2348,6 @@ 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, 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
@@ -1875,24 +2364,36 @@ const isSnowflake = (id)=>typeof id === 'string' && /^\d{1,20}$/.test(id);
             };
             controller_decorator.stampCall(call);
             log.push(call);
-            let undo;
+            let gated;
             try {
-                // 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);
+                // Before the behaviour, as discord.js checks the state before it sends an answer
+                if (gate) gated = gate(args, byTest);
             } catch (error) {
                 call.error = error;
                 return Promise.reject(error);
             }
             const failed = (error)=>{
-                undo?.();
+                gated?.settle?.();
+                gated?.undo?.();
                 call.error = error;
                 throw error;
             };
+            // Once the behaviour resolves, as discord.js changes the state once Discord has taken the answer
+            const landed = (value)=>{
+                gated?.settle?.();
+                try {
+                    gated?.land?.();
+                } catch (error) {
+                    call.error = error;
+                    throw error;
+                }
+                return value;
+            };
             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;
+                if (result instanceof Promise) return result.then(landed, failed);
+                return landed(result);
             } catch (error) {
                 return failed(error);
             }
@@ -1935,11 +2436,33 @@ const isSnowflake = (id)=>typeof id === 'string' && /^\d{1,20}$/.test(id);
     if (message !== undefined) error.message = message;
     return error;
 }
+// Why default mode runs an answer discord.js refuses, as the warning words it
+const SET_BY_TEST = 'a test set this answer or the one before it';
+/**
+ * Refuses an answer as discord.js does. Where `lenient` says why the mock ran it so far, such as a behaviour a test
+ * set, default mode warns and lets it run; strict mocks refuse it.
+ */ function refuseAnswer(method, error, lenient) {
+    if (lenient === undefined || strictMocks()) throw error;
+    controller_decorator.warnOnce(mockLogger, `${method}() here is refused by discord.js with "${error.message}", but the mock runs it, as ${lenient}. In the ` + 'next major version (5.0) the mock refuses it; call useStrictMocks() to have it refused now.');
+}
 /** 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);
+/** The names of a mock options resolver's entity options, for one given to an autocomplete. */ const optionEntities = new WeakMap();
+/** The resolvers whose entity options a warning has named. */ const warnedEntities = new WeakSet();
+/** Whether a mock options resolver belongs to an autocomplete, whose options Discord sends unresolved. */ const ownedByAutocomplete = (options)=>optionOwners.get(options)?.type === discord_js.InteractionType.ApplicationCommandAutocomplete;
+/**
+ * Records the interaction a mock options resolver belongs to. Given to an autocomplete, an entity option reads as its
+ * id under strict mocks, as Discord sends it; otherwise it keeps the object given, with a warning once per resolver.
+ */ const ownOptions = (interaction, options)=>{
+    if (typeof options !== 'object' || options === null) return;
+    optionOwners.set(options, interaction);
+    const entities = optionEntities.get(options);
+    if (!entities?.length || strictMocks() || warnedEntities.has(options) || !ownedByAutocomplete(options)) return;
+    warnedEntities.add(options);
+    const names = entities.map((name)=>`"${name}"`).join(', ');
+    const many = entities.length > 1;
+    mockLogger.warn(`The autocomplete option${many ? 's' : ''} ${names} ${many ? 'hold resolved objects' : 'holds a resolved object'} here, where Discord ` + `sends an autocomplete only ${many ? 'their ids' : 'its id'}, so a bot's handler gets the id and getUser() and the like return null. ` + `Call useStrictMocks(), which reads ${many ? 'them as their ids' : 'it as its id'}, as Discord sends ${many ? 'them' : 'it'}. A bare id string reads as ` + 'a string option.');
 };
 /** 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;
@@ -2006,7 +2529,31 @@ function createMockInteraction(Class, props) {
     if (repliable) {
         instance.replied = false;
         instance.deferred = false;
-        instance.ephemeral = false;
+        // Null until reply() or deferReply() decides it, as discord.js has it; default mode reads false until then, and a
+        // test reading it there is told once. A value the test sets is read as set
+        const strict = strictMocks();
+        let ephemeral = strict ? null : false;
+        let ephemeralDecided = false;
+        // Whether one of the mock's own first answers ran; flags a test sets without one leave ephemeral as discord.js would
+        let answeredByMock = false;
+        const answeredOutside = ()=>Boolean(instance.replied || instance.deferred) && !answeredByMock;
+        const decideEphemeral = (value, decided)=>{
+            ephemeral = value;
+            ephemeralDecided = decided;
+        };
+        Object.defineProperty(instance, 'ephemeral', {
+            get: ()=>{
+                // Quiet once a test answered the interaction itself: MeoCord then reads ephemeral only for truthiness, where false
+                // and null act alike
+                if (!ephemeralDecided && !strict && !answeredOutside()) {
+                    controller_decorator.warnPlaceholder(mockLogger, `${Object.getPrototypeOf(instance).constructor.name}.ephemeral`, 'it is null until reply() or deferReply() decides it, as discord.js has it', 'Reply or defer first, or call useStrictMocks() to read null now.');
+                }
+                return ephemeral;
+            },
+            set: (value)=>decideEphemeral(value, true),
+            enumerable: true,
+            configurable: true
+        });
         // 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.`);
@@ -2023,41 +2570,57 @@ function createMockInteraction(Class, props) {
         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;
+        // Whether default mode ran a launchActivity() or sendPremiumRequired() before any answer, which it doesn't count as one
+        let uncounted = false;
+        // A command answered without a message, as with a modal, has no original response, and Discord refuses one asked for
+        let noOriginal = 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);
+        // Read when answered, after a test's props are applied: a modal submitted from a command has no message
+        const onMessage = ()=>isComponent || instance.type === discord_js.InteractionType.ModalSubmit && Boolean(instance.message);
         const snapshot = ()=>{
             const saved = {
                 replied: instance.replied,
                 deferred: instance.deferred,
-                ephemeral: instance.ephemeral,
+                ephemeral,
+                ephemeralDecided,
+                answeredByMock,
                 original,
                 originalGone,
                 followUps: new Map(followUps),
                 answeredByTest,
-                modalAnswered
+                noOriginal
             };
             return ()=>{
                 Object.assign(instance, {
                     replied: saved.replied,
-                    deferred: saved.deferred,
-                    ephemeral: saved.ephemeral
+                    deferred: saved.deferred
                 });
-                ({ original, originalGone, answeredByTest, modalAnswered } = saved);
+                decideEphemeral(saved.ephemeral, saved.ephemeralDecided);
+                ({ original, originalGone, answeredByTest, answeredByMock, noOriginal } = 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.');
-        };
+        // Refused as discord.js does, leniently in default mode where this answer or the one before it ran a test's behaviour
+        const refuse = (method, error, byTest)=>refuseAnswer(method, error, byTest || answeredByTest ? SET_BY_TEST : undefined);
         const answered = ()=>instance.deferred || instance.replied;
+        // Default mode's launchActivity() and sendPremiumRequired(), which leave the interaction as it was, as before
+        const countedOnlyWhenStrict = (method)=>{
+            if (answered()) {
+                controller_decorator.warnOnce(mockLogger, `${method}() here runs though the interaction was answered; under useStrictMocks() this is refused with ` + 'InteractionAlreadyReplied, as discord.js refuses it.');
+                return;
+            }
+            uncounted = true;
+            controller_decorator.warnOnce(mockLogger, `${method}() here leaves the interaction unanswered, and getResponse() doesn't report it; under useStrictMocks() this ` + "is the interaction's first answer, as in discord.js: it marks the interaction replied, and an answer before or " + 'after it is refused.');
+        };
+        // What Discord answers here isn't known, so the refusal names the cause rather than a code
+        const refuseModalUpdate = ()=>{
+            const reason = 'update() needs the message a component opened this modal from, and this modal came from a command. Use ' + 'reply() or deferReply() instead.';
+            if (strictMocks()) throw new Error(reason);
+            controller_decorator.warnOnce(mockLogger, `${reason} The mock runs it; in the next major version (5.0) it refuses it. Call useStrictMocks() to have it refused now.`);
+        };
         /**
      * 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.
@@ -2070,32 +2633,92 @@ function createMockInteraction(Class, props) {
                 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();
+        // The changes answers make to the reply state, in order. One whose answer fails is undone once every change after
+        // it is undone too, so a later answer's change stands while it does, as on a bot
+        const changes = [];
+        const undoneInTurn = (undo)=>{
+            const change = {
+                undo,
+                failed: false
+            };
+            changes.push(change);
+            return ()=>{
+                change.failed = true;
+                while(changes.at(-1)?.failed)changes.pop().undo();
+            };
+        };
+        // The first answers called and not yet settled, oldest first, for default mode to warn where a bot would differ
+        const unsettled = [];
+        // Default mode warns once per interaction where code that doesn't await an answer would fail on a bot
+        let inFlightWarned = false;
+        const warnInFlight = (text)=>{
+            if (inFlightWarned) return;
+            inFlightWarned = true;
+            mockLogger.warn(text);
+        };
+        /**
+     * A first answer: refused once the interaction has one, else it replies or defers. Under strict mocks the change
+     * waits for the answer to land, as discord.js makes it once the request resolves, so one sent while another is in
+     * flight passes discord.js's check and Discord refuses it with 40060 if the other landed first. Default mode makes
+     * the change at once.
+     */ const first = (method, kind, then)=>(args, byTest)=>{
+                if (answered()) {
+                    if (unsettled.length > 0) {
+                        warnInFlight(`${method}() was called while ${unsettled[0]}() had not resolved; on a bot discord.js sends it, and Discord ` + `refuses it with 40060 ("Interaction has already been acknowledged") once the first lands. Await ` + `${unsettled[0]}() before answering again, or call useStrictMocks() to have the mock answer as Discord does.`);
+                    }
+                    refuse(method, alreadyReplied(), byTest);
+                }
+                // Read first: flags discord.js refuses throw before anything changes; reply() and deferReply() decide
+                // ephemeral, as discord.js's do, and update() and deferUpdate() leave it
+                const flagged = method === 'reply' || method === 'deferReply' ? hasEphemeralFlag(args[0]) : undefined;
+                const undo = snapshot();
+                instance[kind] = true;
+                if (flagged !== undefined) decideEphemeral(flagged, true);
+                answeredByTest = byTest;
+                answeredByMock = true;
+                try {
+                    then(args);
+                } catch (error) {
+                    undo();
                     throw error;
                 }
-                return undo;
+                if (strict) {
+                    const land = snapshot();
+                    undo();
+                    return {
+                        land: ()=>{
+                            if (answered()) throw createDiscordError(40060, 'Interaction has already been acknowledged.');
+                            land();
+                        }
+                    };
+                }
+                unsettled.push(method);
+                return {
+                    undo: undoneInTurn(undo),
+                    settle: ()=>void unsettled.splice(unsettled.indexOf(method), 1)
+                };
             };
-        /** A later answer: refused before the interaction has one. */ const later = (method, then)=>(args, byTest)=>{
-                if (!answered()) refuse(method, notYetReplied(method), byTest);
+        /**
+     * A later answer: refused before the interaction has one. One that `replies` marks the interaction replied, under
+     * strict mocks once it lands, as discord.js does once the request resolves; default mode marks it at once.
+     */ const later = (method, then, replies = false)=>(args, byTest)=>{
+                // A follow-up after an answer default mode doesn't count is sent, as it is once strict mocks count that answer
+                if (!answered() && !(method === 'followUp' && uncounted)) refuse(method, notYetReplied(method), byTest);
+                if (unsettled.length > 0) {
+                    warnInFlight(`${unsettled[0]}() had not resolved when ${method}() was called; on a bot this throws InteractionNotReplied. ` + `Await ${unsettled[0]}() first, or call useStrictMocks() to have the mock refuse it now.`);
+                }
                 const undo = snapshot();
                 try {
                     then(args);
+                    if (replies && !strict) instance.replied = true;
                 } catch (error) {
                     undo();
                     throw error;
                 }
-                return undo;
+                return {
+                    undo: undoneInTurn(undo),
+                    land: replies && strict ? ()=>void (instance.replied = true) : undefined
+                };
             };
         /** The id an edit, fetch or delete names, `undefined` for the original response. */ const targetId = (message)=>{
             if (message === undefined || message === '@original') return undefined;
@@ -2107,7 +2730,7 @@ function createMockInteraction(Class, props) {
                 if (held) followUps.set(id, built(held));
                 return held && built(held);
             }
-            if (originalGone || modalAnswered) return undefined;
+            if (originalGone || noOriginal) 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);
@@ -2146,7 +2769,6 @@ function createMockInteraction(Class, props) {
                 id: followUpMade
             }) : messageFrom(held, madeFor(held.id), ...answeredIn());
         }, later('followUp', ([options])=>{
-            instance.replied = true;
             // 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));
@@ -2160,7 +2782,7 @@ function createMockInteraction(Class, props) {
                 id
             });
             followUpMade = id;
-        }));
+        }, true));
         // 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 ()=>{
@@ -2175,11 +2797,9 @@ function createMockInteraction(Class, props) {
             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);
-        }));
+            if (id === undefined) original = made;
+            else followUps.set(id, made);
+        }, true));
         stubs.set('fetchReply', createMockFn(async (message)=>{
             const held = target(targetId(message));
             if (!held) throw unknownMessage();
@@ -2194,16 +2814,31 @@ function createMockInteraction(Class, props) {
             if (id === undefined) originalGone = true;
             else followUps.delete(id);
         }));
+        // A first answer that sends no message: the original response stays the message the interaction is on, if any
+        const sendsNoMessage = ()=>{
+            if (onMessage()) original = componentMessage();
+            else noOriginal = true;
+        };
         // showModal — the first response of a command or a component, like reply()
         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();
-            }));
+            answer('showModal', async ()=>undefined, first('showModal', 'replied', sendsNoMessage));
+        }
+        // An activity launched, or the upgrade button sent, is a first answer under strict mocks, as reply() is, on every
+        // repliable interaction. Default mode leaves the interaction unanswered and unreported, and warns once where they differ
+        for (const method of [
+            'launchActivity',
+            'sendPremiumRequired'
+        ]){
+            if (strict) answer(method, async ()=>undefined, first(method, 'replied', sendsNoMessage));
+            else stubs.set(method, recordedMock(method, async ()=>undefined, [], ()=>(countedOnlyWhenStrict(method), {})));
         }
         // deferUpdate / update — components, and modals submitted from a message's component
         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('update', async ()=>undefined, first('update', 'replied', ([options])=>{
+                // Discord updates only a message a component is on; a modal from a command has none
+                if (!onMessage()) refuseModalUpdate();
+                original = hold('update', ()=>edited(heldFrom(instance.message, false), options));
+            }));
             answer('deferUpdate', async ()=>undefined, first('deferUpdate', 'deferred', ()=>original = componentMessage()));
         }
     }
@@ -2213,14 +2848,58 @@ function createMockInteraction(Class, props) {
     // it before answering would decide the window was already closed.
     if (instance.type === discord_js.InteractionType.ApplicationCommandAutocomplete) {
         instance.responded = false;
-        stubs.set('respond', createMockFn(async (choices)=>{
-            if (instance.responded) throw discordjsError(discord_js.DiscordjsErrorCodes.InteractionAlreadyReplied);
+        const strict = strictMocks();
+        const log = [];
+        // getResponse reports each respond() under strict mocks; default mode reports none, as before
+        if (strict) Object.defineProperty(instance, RESPONSE_LOG, {
+            value: log
+        });
+        // Responds whose change stands, and what `responded` read before the first of them, for a failed one to undo
+        let standing = 0;
+        let before = false;
+        let respondsInFlight = 0;
+        let respondWarned = false;
+        // Under strict mocks responded is set once respond() lands, as discord.js sets it once the request resolves, and a
+        // second one sent while the first is in flight is refused by Discord with 40060; default mode sets it at once
+        const gate = (_args, byTest)=>{
+            // Default mode leaves a behaviour a test set to itself, as before: responded stays as it was
+            if (!strict && byTest) {
+                controller_decorator.warnOnce(mockLogger, 'respond() here runs a behaviour a test set and leaves responded as it was; under useStrictMocks() this marks the ' + 'autocomplete responded once it resolves, as discord.js does, and a second respond() is refused.');
+                return {};
+            }
+            if (instance.responded) {
+                if (respondsInFlight > 0 && !respondWarned) {
+                    respondWarned = true;
+                    mockLogger.warn('respond() was called while respond() had not resolved; on a bot discord.js sends it, and Discord refuses ' + 'it with 40060 ("Interaction has already been acknowledged") once the first lands. Await respond() ' + 'before responding again, or call useStrictMocks() to have the mock respond as Discord does.');
+                }
+                throw discordjsError(discord_js.DiscordjsErrorCodes.InteractionAlreadyReplied);
+            }
+            respondsInFlight++;
+            const settle = ()=>void respondsInFlight--;
+            if (strict) {
+                return {
+                    settle,
+                    land: ()=>{
+                        if (instance.responded) throw createDiscordError(40060, 'Interaction has already been acknowledged.');
+                        instance.responded = true;
+                    }
+                };
+            }
+            if (standing++ === 0) before = instance.responded;
+            instance.responded = true;
+            return {
+                settle,
+                undo: ()=>{
+                    if (--standing === 0) instance.responded = before;
+                }
+            };
+        };
+        stubs.set('respond', recordedMock('respond', async (choices)=>{
             // 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.`);
             }
-            instance.responded = true;
-        }));
+        }, log, gate));
     }
     // Applied last so an explicit prop wins over the type fields and the reply
     // state machine. defineProperty rather than assignment for the same reason the
@@ -2353,6 +3032,9 @@ function createMockInteraction(Class, props) {
                 configurable: true
             });
         }
+        // Default mode reads a guildId alone as a placeholder server with that id, as its warning says, answered in place of
+        // the mock's own stub, so where the interaction is still reads as given. Strict mocks read null, as discord.js does
+        if (strictPlace?.given === 'guildId' && !strictMocks() && unset('guild')) stubs.set('guild', guildPlaceholder(own('guildId')));
         // 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;
@@ -2394,6 +3076,11 @@ function createMockInteraction(Class, props) {
         // and in a server that user's member; each read live, so a targetId set later picks its user, and assignable
         if (discord_js.UserContextMenuCommandInteraction.prototype.isPrototypeOf(instance)) {
             if (unset('targetId')) instance.targetId = own('targetUser')?.id ?? nextSnowflake();
+            // Under strict mocks a target user given is the client's cached one, as discord.js resolves it, so its member is
+            // that user's; default mode keeps the member's own user, and a read of targetMember warns once
+            const givenTarget = own('targetUser');
+            const users = cacheOf(instance.client.users);
+            if (strictMocks() && typeof givenTarget === 'object' && givenTarget !== null) users?.set(givenTarget.id, givenTarget);
             const targetUser = ()=>{
                 const id = own('targetId');
                 return cached(cacheOf(instance.client.users), id, ()=>mockUser(id));
@@ -2411,7 +3098,15 @@ function createMockInteraction(Class, props) {
                 });
             if (unset('targetUser')) live('targetUser', targetUser);
             if (unset('targetMember')) {
-                live('targetMember', ()=>own('guildId') ? memberFor(own('guild'), targetUser(), true, own('guildId')) : null);
+                live('targetMember', ()=>{
+                    if (!own('guildId')) return null;
+                    const member = memberFor(own('guild'), targetUser(), true, own('guildId'));
+                    // Only the mock reads this for the test, so the warning comes at the test's read
+                    if (givenTarget && member.user !== givenTarget) {
+                        controller_decorator.warnOnce(mockLogger, "UserContextMenuCommandInteraction.targetMember here is the member of another user with the targetUser's " + "id; under useStrictMocks() the targetUser given is cached on the client, so targetMember is that user's member.");
+                    }
+                    return member;
+                });
             }
         }
         // A message context menu's target: the message given, else one made for its targetId. The message is the one
@@ -2741,6 +3436,10 @@ const HOLDS = [
         discord_js.RoleManager.prototype,
         discord_js.Role
     ],
+    [
+        discord_js.GuildMemberRoleManager.prototype,
+        discord_js.Role
+    ],
     [
         discord_js.GuildChannelManager.prototype,
         discord_js.GuildChannel
@@ -2796,18 +3495,46 @@ const HOLDS = [
     [
         discord_js.PresenceManager.prototype,
         discord_js.Presence
+    ],
+    [
+        discord_js.GuildEmojiManager.prototype,
+        discord_js.GuildEmoji
+    ],
+    [
+        discord_js.GuildStickerManager.prototype,
+        discord_js.Sticker
+    ],
+    [
+        discord_js.GuildScheduledEventManager.prototype,
+        discord_js.GuildScheduledEvent
+    ],
+    [
+        discord_js.AutoModerationRuleManager.prototype,
+        discord_js.AutoModerationRule
+    ],
+    [
+        discord_js.GuildInviteManager.prototype,
+        discord_js.Invite
     ]
 ];
+/** What a manager of `prototype` holds, as discord.js's resolve() checks an item against. */ const holdsOf = (prototype)=>HOLDS.find(([Manager])=>Manager === prototype || Object.prototype.isPrototypeOf.call(Manager, prototype))?.[1];
 /**
  * A manager whose `cache` is a real collection of `items`, by id, empty without them, and whose methods are stubs but
- * for `resolve` and `resolveId`, which read the cache. Its `client` is the one its guild or channel has.
- */ function managerWith(prototype, items) {
+ * for `resolve` and `resolveId`, which read the cache. Its `client` is the one its guild or channel has. `onCacheRead`,
+ * when given, runs on each read of `cache`, before it is returned.
+ */ function managerWith(prototype, items, onCacheRead) {
     const manager = Object.create(prototype);
     const cache = new discord_js.Collection((items ?? []).map((item)=>[
             String(item.id ?? item.user?.id),
             item
         ]));
-    Object.defineProperty(manager, 'cache', {
+    if (onCacheRead) {
+        let current = cache;
+        Object.defineProperty(manager, 'cache', {
+            get: ()=>(onCacheRead(), current),
+            set: (value)=>void (current = value)
+        });
+    } else Object.defineProperty(manager, 'cache', {
         value: cache,
         writable: true
     });
@@ -2816,7 +3543,7 @@ const HOLDS = [
         value: cache,
         writable: true
     });
-    const holds = HOLDS.find(([Manager])=>Manager === prototype || Object.prototype.isPrototypeOf.call(Manager, prototype))?.[1];
+    const holds = holdsOf(prototype);
     if (holds) Object.defineProperty(manager, 'holds', {
         value: holds
     });
@@ -2837,13 +3564,59 @@ const HOLDS = [
     });
     return stubDeep(manager);
 }
+// Set while the mock reads a manager's cache itself
+let readingOwnCache = 0;
+// The messages made in each channel, by its messages manager, for a fetch to find and strict mocks to cache
+const messagesMade = new WeakMap();
+const madeIn = (manager, id)=>id === undefined ? undefined : messagesMade.get(manager)?.get(id);
+// The message managers whose cache read has warned
+const uncachedWarned = new WeakSet();
+/**
+ * A channel's empty messages manager. Default mode caches none of the messages made in the channel, where strict mocks
+ * and discord.js cache each, so a test's first read of the cache warns once while one of them is missing from it.
+ */ function messageManager(prototype) {
+    const manager = managerWith(prototype, undefined, ()=>{
+        const made = messagesMade.get(manager);
+        if (readingOwnCache > 0 || !made || strictMocks() || uncachedWarned.has(manager)) return;
+        // Read as the mock's own, so this check doesn't call itself
+        const cache = cacheOf(manager);
+        if (![
+            ...made.values()
+        ].some((each)=>!cache?.has(each.id))) return;
+        uncachedWarned.add(manager);
+        mockLogger.warn(`${prototype.constructor.name}.cache here lacks messages made in its channel, where ` + 'discord.js caches each message as it arrives and each one the bot sends; in the next major version (5.0) the mock caches ' + 'them. Fetch the message, or call useStrictMocks() to have them cached now.');
+    });
+    return manager;
+}
+// The message managers whose fetch() with no id has warned
+const unlistedWarned = new WeakSet();
+/**
+ * Warns once for a channel whose messages.fetch() with no id resolves to none in default mode, though strict mocks
+ * would list messages there: those its cache holds, read as the mock's own, and those made or sent in it, which they
+ * cache.
+ */ function warnUnlisted(manager) {
+    if (unlistedWarned.has(manager)) return;
+    if (!cacheOf(manager)?.size && !messagesMade.get(manager)?.size) return;
+    unlistedWarned.add(manager);
+    mockLogger.warn(`${Object.getPrototypeOf(manager).constructor.name}.fetch() here resolves to no ` + "messages, though messages were made, sent or cached in its channel, where discord.js lists a channel's recent " + 'messages; under useStrictMocks() fetch() lists them.');
+}
+/** Notes a message made in a channel, and caches it there under strict mocks, as discord.js caches what arrives. */ function noteMadeIn(channel, message) {
+    if (!(channel instanceof discord_js.BaseChannel)) return;
+    const manager = Reflect.getOwnPropertyDescriptor(channel, 'messages')?.value;
+    const cache = manager && cacheOf(manager);
+    if (!manager || !cache) return;
+    if (!messagesMade.has(manager)) messagesMade.set(manager, new Map());
+    messagesMade.get(manager).set(message.id, message);
+    if (strictMocks()) cache.set(message.id, message);
+}
 /** 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.
+ * Creates a mock {@link Guild}, with its `members`, `channels`, `roles`, `bans`, `emojis`, `stickers`, `scheduledEvents`,
+ * `autoModerationRules` and `invites` managers ready to stub.
  *
  * Use it for the server a message or an interaction came from, with the members, roles and channels a handler looks
  * up in it.
@@ -2853,14 +3626,18 @@ const HOLDS = [
  *
  * @remarks
  * A manager's `fetch(id)` resolves to its cached item with that id, as discord.js looks there first, or to a new one it
- * caches under that id: a member or channel in this guild, a role with that id, or a ban. `members.fetch({ user: ids })`
- * resolves to a collection of each of those members, found or made the same way; `create()` and `edit()` resolve to a
- * mock of its item, and a list fetch to an empty collection. Members, roles and channels given are put in
- * their managers' caches, where dispatch looks first when it resolves a message's typed params; a member
- * {@link createMockMember} made without a server is in this one. Its `roles.everyone` is the role given with the
- * guild's id, or else an @everyone role of its own at position 0 with no permissions, in `roles.cache` as Discord has
- * it. The guild is named `'Guild'` and its `preferredLocale` is `'en-US'` unless given, so `t.forGuild(guild)`
- * translates as for a new English server.
+ * caches under that id: a member, channel, emoji, sticker, scheduled event or AutoMod rule in this guild, a role with
+ * that id, a ban, or an invite with that code. `members.fetch({ user: ids })` resolves to a collection of each of those
+ * members, found or made the same way; `create()` resolves to a mock of its item, a channel of the type its options
+ * name under `useStrictMocks()`, which it caches as discord.js does, but for an invite, made for the channel given and
+ * cached nowhere; `edit()` resolves under `useStrictMocks()` to the item with the id given, found or made the same way,
+ * and under `useStrictMocks()` either takes the `name` its options give. A list fetch resolves to an empty collection.
+ * Members, roles and channels given are put in their managers' caches, where dispatch looks first when it resolves a
+ * message's typed params; a member {@link createMockMember} made without a server is in this one. Its `roles.everyone`
+ * is the role given with the guild's id, or else an @everyone role of its own at position 0, in `roles.cache` as
+ * Discord has it. That role has no permissions in default mode; under `useStrictMocks()` it has the ones Discord
+ * gives @everyone in a new server. The guild is named `'Guild'` and its `preferredLocale` is `'en-US'` unless given,
+ * so `t.forGuild(guild)` translates as for a new English server.
  *
  * The mock makes a member for any id it's asked for, so a test of an id that isn't a member rejects the fetch, as
  * `guild.members.fetch.mockRejectedValue(createDiscordError(10007))`, or resolves a collection without that member.
@@ -2886,7 +3663,7 @@ const HOLDS = [
     instance.members = managerWith(discord_js.GuildMemberManager.prototype, overrides.members);
     instance.channels = managerWith(discord_js.GuildChannelManager.prototype, overrides.channels);
     instance.roles = guildRoleManager(instance.id, overrides.roles);
-    instance.bans = managerWith(discord_js.GuildBanManager.prototype, undefined);
+    for (const [key, Manager] of GUILD_MANAGERS)instance[key] = managerWith(Manager.prototype, undefined);
     const guild = stubDeep(instance);
     settleGuild(instance, guild);
     // A member made without a server of its own is in this one
@@ -2930,7 +3707,7 @@ const HOLDS = [
     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)) {
-        instance.messages = managerWith(discord_js.GuildMessageManager.prototype, undefined);
+        instance.messages = messageManager(discord_js.GuildMessageManager.prototype);
         instance.threads = managerWith(discord_js.GuildTextThreadManager.prototype, undefined);
     }
     // Forum and media channels hold posts, each a thread started with its first message
@@ -2940,15 +3717,15 @@ const HOLDS = [
     }
     // Voice and stage channels carry a text chat of their own, and a bitrate, which discord.js tells them apart by
     if (is(discord_js.BaseGuildVoiceChannel)) {
-        instance.messages = managerWith(discord_js.GuildMessageManager.prototype, undefined);
+        instance.messages = messageManager(discord_js.GuildMessageManager.prototype);
         instance.bitrate = 64000;
         instance.userLimit = 0;
     }
     if (is(discord_js.DMChannel)) {
-        instance.messages = managerWith(discord_js.DMMessageManager.prototype, undefined);
+        instance.messages = messageManager(discord_js.DMMessageManager.prototype);
     }
     if (is(discord_js.ThreadChannel)) {
-        instance.messages = managerWith(discord_js.GuildMessageManager.prototype, undefined);
+        instance.messages = messageManager(discord_js.GuildMessageManager.prototype);
         instance.members = managerWith(discord_js.ThreadMemberManager.prototype, undefined);
     }
     // A server's channel has its overwrites, none until a test puts some in the cache, which its permissions read
@@ -3053,6 +3830,7 @@ const CHANNEL_TYPE_GUARDS = [
                 id: entry
             }) : entry);
     const manager = Object.create(discord_js.GuildMemberRoleManager.prototype);
+    // Its member's server and client, as discord.js's constructor sets them, and what it holds, so resolve() reads it
     Object.defineProperties(manager, {
         cache: {
             get: cache
@@ -3060,6 +3838,15 @@ const CHANNEL_TYPE_GUARDS = [
         member: {
             value: member
         },
+        guild: {
+            get: ()=>member.guild
+        },
+        client: {
+            get: ()=>member.client
+        },
+        holds: {
+            value: holdsOf(discord_js.GuildMemberRoleManager.prototype)
+        },
         highest: {
             get: highest
         }
@@ -3384,7 +4171,7 @@ let placeReadsSeen;
             "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 placeholder server with that id, 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.'
         ]
@@ -3510,7 +4297,7 @@ let placeReadsSeen;
     guild.members = managerWith(discord_js.GuildMemberManager.prototype, undefined);
     guild.channels = managerWith(discord_js.GuildChannelManager.prototype, undefined);
     guild.roles = guildRoleManager(guild.id, undefined);
-    guild.bans = managerWith(discord_js.GuildBanManager.prototype, undefined);
+    for (const [key, Manager] of GUILD_MANAGERS)guild[key] = managerWith(Manager.prototype, undefined);
     const proxy = stubDeep(guild);
     settleGuild(guild, proxy);
     return proxy;
@@ -3532,12 +4319,39 @@ const botMembers = new WeakMap();
         return guildId ? cacheOf(guild.channels)?.get(channelId) : null;
     });
 }
+// A guild's managers beside members, channels and roles, each empty, of its discord.js class
+const GUILD_MANAGERS = [
+    [
+        'bans',
+        discord_js.GuildBanManager
+    ],
+    [
+        'emojis',
+        discord_js.GuildEmojiManager
+    ],
+    [
+        'stickers',
+        discord_js.GuildStickerManager
+    ],
+    [
+        'scheduledEvents',
+        discord_js.GuildScheduledEventManager
+    ],
+    [
+        'autoModerationRules',
+        discord_js.AutoModerationRuleManager
+    ],
+    [
+        'invites',
+        discord_js.GuildInviteManager
+    ]
+];
 /** 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',
         'channels',
         'roles',
-        'bans'
+        ...GUILD_MANAGERS.map(([key])=>key)
     ])instance[key].guild = guild;
 }
 /**
@@ -3586,9 +4400,38 @@ const botMembers = new WeakMap();
     };
 }
 /** A cache's collection, or undefined for a stub a test put in place of the manager. */ const cacheOf = (manager)=>{
-    const cache = manager?.cache;
-    return cache instanceof discord_js.Collection ? cache : undefined;
+    // The mock's own read, which a message cache's warning leaves to the test's reads
+    readingOwnCache++;
+    try {
+        const cache = manager?.cache;
+        return cache instanceof discord_js.Collection ? cache : undefined;
+    } finally{
+        readingOwnCache--;
+    }
 };
+// The managers of a server whose caches a placeholder one holds empty
+const PLACEHOLDER_GUILD_MANAGERS = [
+    'members',
+    'roles',
+    'channels',
+    'emojis',
+    'stickers',
+    'bans',
+    'invites',
+    'scheduledEvents',
+    'autoModerationRules'
+];
+/** A server default mode reads for a guildId alone: no `Guild`, so it answers no server checks, but with that id and empty caches. */ function guildPlaceholder(id) {
+    return stubDeep({
+        id,
+        ...Object.fromEntries(PLACEHOLDER_GUILD_MANAGERS.map((key)=>[
+                key,
+                stubDeep({
+                    cache: new discord_js.Collection()
+                })
+            ]))
+    });
+}
 /** The cached item under `id`, put there by `make` when the cache lacks it. */ function cached(cache, id, make) {
     const existing = cache?.get(id);
     if (existing !== undefined) return existing;
@@ -3616,19 +4459,22 @@ const botMembers = new WeakMap();
                 id,
                 cached(guildCaches.members, id, ()=>memberIn(guild, id, cached(userCache, id, ()=>mockUser(id))))
             ])) : null,
+        // Full mocks, as the gateway delivers them: a role of the server, and a channel with its managers and overwrites
         roles: new discord_js.Collection(guildCaches ? roles.map((id)=>[
                 id,
-                cached(guildCaches.roles, id, ()=>stubDeep(Object.assign(Object.create(discord_js.Role.prototype), {
+                cached(guildCaches.roles, id, ()=>createMockInteraction(discord_js.Role, {
                         id,
                         guild
-                    })))
+                    }))
             ]) : []),
         channels: new discord_js.Collection(channels.map((id)=>[
                 id,
-                cached(guildCaches ? guildCaches.channels : cacheOf(client.channels), id, ()=>stubDeep(Object.assign(Object.create(discord_js.TextChannel.prototype), {
+                cached(guildCaches ? guildCaches.channels : cacheOf(client.channels), id, ()=>createMockChannel(discord_js.TextChannel, guild ? {
                         id,
                         guild
-                    })))
+                    } : {
+                        id
+                    }))
             ]))
     };
     // Own values, so the prototype's getters, which read the raw mention data, are not reached
@@ -3911,6 +4757,7 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
     }));
     if (sentBy) warnOnSentReads(instance, stubs, sentBy);
     const message = stubDeep(instance, stubs);
+    if (channel) noteMadeIn(channel, message);
     return message;
 }
 /**
@@ -3959,7 +4806,8 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
  * 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;
+    // The mock's own read of where the message was sent
+    const by = client ?? readPlaceQuietly(()=>channel?.client);
     const inChannel = channel instanceof discord_js.BaseChannel;
     const dm = inChannel && channel.isDMBased();
     const strict = strictMocks();
@@ -4000,6 +4848,11 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
     if (typeof value === 'object' && value !== null) return discord_js.ApplicationCommandOptionType.Mentionable;
     return discord_js.ApplicationCommandOptionType.String;
 }
+/** The option types a user types into, which an autocomplete's focused option is one of. */ const TYPED = [
+    discord_js.ApplicationCommandOptionType.String,
+    discord_js.ApplicationCommandOptionType.Integer,
+    discord_js.ApplicationCommandOptionType.Number
+];
 /** The discord.js classes an entity option's value is an instance of, each read by its own getters. */ const ENTITY_CLASSES = [
     discord_js.User,
     discord_js.GuildMember,
@@ -4052,7 +4905,7 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
  * An entity option arrives as a snowflake in `value` *and* as the resolved object on
  * its own field, and code that reads only one of the two is exactly what this lets a
  * test catch — so both are set. A user option has its user, and in a server its member too.
- */ function toOptionData(name, value, memberOf) {
+ */ function toOptionData(name, value, memberOf, unresolved) {
     const type = optionTypeOf(value);
     const isEntity = typeof value === 'object' && value !== null;
     const option = {
@@ -4065,7 +4918,8 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
         // Read once the options are given to an interaction, which says whether it was made in a server
         if (memberOf) Object.defineProperty(option, 'member', {
             get: ()=>memberOf(name, value) ?? undefined,
-            enumerable: true
+            enumerable: true,
+            configurable: true
         });
     } else if (value instanceof discord_js.GuildMember) {
         option.user = value.user;
@@ -4074,6 +4928,25 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
     else if (value instanceof discord_js.BaseChannel) option.channel = value;
     else if (value instanceof discord_js.Attachment) option.attachment = value;
     else if (isEntity) option.user = value;
+    // An autocomplete's entity option is its id alone, as Discord sends it, when the options belong to one
+    if (unresolved) {
+        for (const field of [
+            'user',
+            'member',
+            'role',
+            'channel',
+            'attachment'
+        ]){
+            const descriptor = Object.getOwnPropertyDescriptor(option, field);
+            if (!descriptor) continue;
+            const read = descriptor.get ?? (()=>descriptor.value);
+            Object.defineProperty(option, field, {
+                get: ()=>unresolved() ? undefined : read(),
+                enumerable: true,
+                configurable: true
+            });
+        }
+    }
     return option;
 }
 /**
@@ -4099,8 +4972,8 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
 /**
  * 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, focused) {
-    const leaves = Object.entries(values).map(([name, value])=>name === focused ? focusedOptionData(name, value) : toOptionData(name, value, memberOf));
+ */ function buildOptionData(subcommandGroup, subcommand, values, memberOf, focused, unresolved) {
+    const leaves = Object.entries(values).map(([name, value])=>name === focused ? focusedOptionData(name, value) : toOptionData(name, value, memberOf, unresolved));
     if (focused !== null && !Object.hasOwn(values, focused)) leaves.push(focusedOptionData(focused, null));
     if (subcommand === null) return leaves;
     const sub = {
@@ -4135,7 +5008,8 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
  * entity option carries its id in `value` and the object itself, as the gateway sends it: a user option its `user`,
  * and in a server its `member` too. A user option's
  * `getMember()` is the user's member in the server of the interaction the options are given to, and `null` in a DM;
- * a member given resolves `getUser()` to its user. A getter throws discord.js's type error for an option of another
+ * a member given resolves `getUser()` to its user. Under `useStrictMocks()` a user option's `getMentionable()` is its
+ * member too where there is one, as discord.js reads it; default mode returns the user, with a warning once. A getter throws discord.js's type error for an option of another
  * type, as discord.js does, required or not. Only a user or member read as a role, or a role read as a user or member,
  * is `null`, or that error when required, as the option may be a mentionable one; a plain `{ id }` reads as any entity.
  * A whole number is an Integer option and a fraction a Number one, so
@@ -4143,7 +5017,13 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
  *
  * 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.
+ * `useStrictMocks()`; otherwise it stays the number, with a warning when read. Under `useStrictMocks()` `get()` and the
+ * typed getters read it by name from that same option, as discord.js does; one given no value takes the string,
+ * integer and number getters alike. Default mode reads what was given, `null` for no value, with a warning once.
+ *
+ * Given to an `AutocompleteInteraction`, a user, member, role, channel, mentionable or attachment option reads as
+ * Discord sends an autocomplete's options under `useStrictMocks()`: its id alone, in `data` and the handler's params,
+ * with the entity getters returning `null`. Otherwise it keeps the object given, with a warning once.
  *
  * @typeParam Cached - `any` by default, to match `createMockInteraction(ChatInputCommandInteraction)`; pass it when the
  *   interaction under test is cache-pinned.
@@ -4165,6 +5045,10 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
  * @see {@link ChatInputOptions}
  */ function createChatInputOptions(opts = {}) {
     const { subcommandGroup = null, subcommand = null, focused = null, ...values } = opts;
+    // The option the user is typing, as Discord sent it among the others, which every getter reads in discord.js
+    const focusedOption = ()=>base._hoistedOptions.find((each)=>each.focused);
+    // Default mode reads the focused option from what the test gave, and says once what discord.js reads instead
+    const warnFocused = (name)=>controller_decorator.warnOnce(mockLogger, `The focused option "${name}" is read here from what the test gave, where discord.js reads the option Discord sent: ` + "marked focused, its value a string ('' before anything is typed). In the next major version (5.0) the mock reads " + 'it so; call useStrictMocks() to have it read so now.');
     function resolveOrThrow(name, value, required) {
         {
             if (required === true) throw optionError(discord_js.DiscordjsErrorCodes.CommandInteractionOptionNotFound, name);
@@ -4181,14 +5065,36 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
     // As in discord.js, a subcommand is required unless told otherwise, and a group is not
     base.getSubcommandGroup = createMockFn((required = false)=>resolveSubEntry(subcommandGroup, discord_js.DiscordjsErrorCodes.CommandInteractionOptionNoSubcommandGroup, required));
     base.getSubcommand = createMockFn((required = true)=>resolveSubEntry(subcommand, discord_js.DiscordjsErrorCodes.CommandInteractionOptionNoSubcommand, required));
+    // Under strict mocks, options given to an autocomplete hold their entities as ids alone, as Discord sends them
+    const unresolved = ()=>strictMocks() && ownedByAutocomplete(resolver);
     // As discord.js reads an option by its type: another type throws its type error, required or not. A value whose
     // option may be of the getter's type, as a user may be a mentionable option's, reads as null if the getter doesn't
     // take it, and throws when required
     const readOption = (name, expected, takes, required)=>{
+        if (name === focused && strictMocks()) {
+            // discord.js reads the focused option as Discord sent it: a string, its own type kept. One given no value may be
+            // any type the user can type into, as the mock doesn't know which it was declared as
+            const option = focusedOption();
+            const types = values[name] === undefined || values[name] === null ? TYPED : [
+                option.type
+            ];
+            if (!types.some((type)=>expected.includes(type))) {
+                throw optionError(discord_js.DiscordjsErrorCodes.CommandInteractionOptionType, name, option.type, expected.join(', '));
+            }
+            return option.value;
+        }
         const value = values[name];
+        if (name === focused && (value === undefined || value === null)) warnFocused(name);
+        // Read through the option Discord sent, whose number warns where discord.js reads a string
+        if (name === focused && typeof value === 'number') void focusedOption().value;
         if (value === undefined || value === null) return resolveOrThrow(name, null, required);
         const typeError = ()=>optionError(discord_js.DiscordjsErrorCodes.CommandInteractionOptionType, name, optionTypeOf(value), expected.join(', '));
         if (!possibleTypesOf(value).some((type)=>expected.includes(type))) throw typeError();
+        // An entity in an autocomplete's options is its id alone, so a getter finds nothing, as in discord.js
+        if (typeof value === 'object' && unresolved()) {
+            if (required === true) throw optionError(discord_js.DiscordjsErrorCodes.CommandInteractionOptionEmpty, name, optionTypeOf(value));
+            return null;
+        }
         if (takes(value)) return value;
         if (required === true) throw typeError();
         return null;
@@ -4249,15 +5155,25 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
         ], plainOr(discord_js.User, discord_js.GuildMember));
         return value instanceof discord_js.User ? memberOf(name, value) : value;
     });
-    base.getMentionable = createMockFn((name, required)=>readOption(name, [
+    // A user's member in a server, as discord.js reads `member ?? user`; default mode keeps the user, with a warning
+    base.getMentionable = createMockFn((name, required)=>{
+        const value = readOption(name, [
             MENTIONABLE
-        ], plainOr(discord_js.User, discord_js.GuildMember, discord_js.Role), required));
+        ], plainOr(discord_js.User, discord_js.GuildMember, discord_js.Role), required);
+        if (!(value instanceof discord_js.User)) return value;
+        const member = memberOf(name, value);
+        if (member === null || strictMocks()) return member ?? value;
+        controller_decorator.warnOnce(mockLogger, `getMentionable('${name}') returns the user here, where discord.js returns the user's member in a server; in the next ` + 'major version (5.0) the mock returns the member. Call useStrictMocks() to have it returned now.');
+        return value;
+    });
     base.getAttachment = createMockFn((name, required)=>readOption(name, [
             ATTACHMENT
         ], plainOr(discord_js.Attachment), required));
     base.get = createMockFn((name, required)=>{
+        if (name === focused && strictMocks()) return focusedOption();
+        if (name === focused) warnFocused(name);
         const value = values[name];
-        return value === undefined || value === null ? resolveOrThrow(name, null, required) : toOptionData(name, value, memberOf);
+        return value === undefined || value === null ? resolveOrThrow(name, null, required) : toOptionData(name, value, memberOf, unresolved);
     });
     // A message option is a message context menu's own, never a slash command's
     base.getMessage = createMockFn((name, required)=>readOption(name, [
@@ -4266,21 +5182,216 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
     base.getFocused = createMockFn((getFull)=>{
         if (focused === null) throw optionError(discord_js.DiscordjsErrorCodes.AutocompleteInteractionOptionNoFocusedOption);
         // The one options.data holds, so the two agree
-        const option = base._hoistedOptions.find((each)=>each.focused);
+        const option = focusedOption();
         return getFull === 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, focused);
+    base.data = buildOptionData(subcommandGroup, subcommand, values, memberOf, focused, unresolved);
     // 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);
+    const entities = Object.entries(values).filter(([name, value])=>name !== focused && typeof value === 'object' && value !== null);
+    optionEntities.set(resolver, entities.map(([name])=>name));
     return resolver;
 }
+// What a mock reads for a property the test gave none, made with this module's factories and helpers. Built last, as it
+// reads them, and only read once a mock is made
+const discordDefault = discordDefaults({
+    botMemberOf,
+    createChatInputOptions,
+    createMockChannel,
+    createMockGuild,
+    createMockMessage,
+    createMockUser,
+    heldChannelOf,
+    isRawMember,
+    isUnsetEveryone,
+    madeAt,
+    memberRoles,
+    NEW_SERVER_EVERYONE_PERMISSIONS,
+    ownedManager,
+    readPlaceAs,
+    readPlaceQuietly
+});
+
+const logger = new controller_decorator.Logger('resolveRoute');
+/** Why an app import reads `undefined`, for its refusal. */ const CIRCULAR_IMPORT_HINT = ' An app import that reads undefined is often a circular import.';
+/** Why an app is an object, for its refusal. */ const MODULE_HINT = ' An object here is often a module namespace, as `import * as App` gives: pass the class it exports.';
+/** An app that isn't a class, as its refusal names it: the value, and its likely cause where there is one. */ function notAClass(app) {
+    const hint = app === undefined ? CIRCULAR_IMPORT_HINT : typeof app === 'object' && app !== null ? MODULE_HINT : '';
+    return {
+        name: controller_decorator.describeValue(app),
+        hint
+    };
+}
+/** Whether a message gives a route's `member`, `role` or `channel` flag, which dispatch refuses in a DM. */ const givesGuildFlag = (route, params)=>route.flags.some((flag)=>flag.type !== undefined && providers.isGuildType(flag.type) && Object.hasOwn(params, flag.flag));
+/** The options `@MeoCord` declares on an application class. */ function appOptionsOf(app) {
+    // An app that isn't a class at all, as a circular import gives, has no metadata to read
+    if (typeof app !== 'function') {
+        const { name, hint } = notAClass(app);
+        throw new TypeError(`${name} is not decorated with @MeoCord().${hint}`);
+    }
+    const options = Reflect.getMetadata(controller_decorator.META.appOptions, app);
+    if (!options) throw new TypeError(`${app.name || 'The given class'} is not decorated with @MeoCord().`);
+    return options;
+}
+/** The controllers `@MeoCord({ controllers })` registers on an application class. */ function controllersOf(app) {
+    return appOptionsOf(app).controllers ?? [];
+}
+/**
+ * Resolves which handler a component's `customId` or a message's content reaches, as dispatch routes it.
+ *
+ * Use it to check routing alone, in a plain unit test: it reads decorator metadata, with no client, config or
+ * container, and runs no guard. To run the handler it reaches, use {@link TestingModule.dispatch}.
+ *
+ * @remarks
+ * It routes across every controller the app registers, most specific pattern first: a component within its type, a
+ * message after the app's prefix, and never to a `@MessageHandler()` listener, which runs for every message.
+ *
+ * @param app - The application class decorated with `@MeoCord`.
+ * @param input - The component type and its `customId`, or the message's content with its prefix and the bot's id.
+ * @returns The handler that runs, with the params it captures, or `undefined` when no route handles the input.
+ * @throws TypeError for a message to an app whose prefix is a function, when no `prefix` is given.
+ *
+ * @example
+ * ```ts
+ * import { expect } from 'vitest'
+ *
+ * @Controller()
+ * class ProfileController {
+ *   @Command('profile/{uid}', CommandType.BUTTON)
+ *   async show(interaction: ButtonInteraction, { uid }: { uid: string }) {
+ *     await respond(interaction).send(`Profile ${uid}`)
+ *   }
+ * }
+ * @MeoCord({ controllers: [ProfileController], clientOptions: { intents: [] } })
+ * class App {}
+ * const route = resolveRoute(App, { type: CommandType.BUTTON, customId: 'profile/8000' })
+ * expect([route?.handler, route?.params]).toEqual([ProfileController.prototype.show, { uid: '8000' }])
+ * ```
+ *
+ * @group Testing
+ * @category Inspection
+ * @see {@link findRouteConflicts}
+ * @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);
+        const starts = providers.staticMessageStarts(app, messages, input);
+        const routes = providers.buildMessageRoutes(controllersOf(app), messages);
+        let matched = providers.matchMessageRoute(routes, input.content, starts);
+        const named = (route)=>`${route.controllerClass.name}.${String(route.method)}`;
+        // Without `dm`: under strict mocks, read as sent in a server, as dispatch routes such a message whatever the
+        // controllers' order; otherwise as from anywhere, warning where that answers differently
+        if (starts.inGuild === undefined) {
+            const inServer = providers.matchMessageRoute(routes, input.content, {
+                ...starts,
+                inGuild: true
+            });
+            if (strictMocks()) matched = inServer && providers.fitsScope(inServer.route.scope, true) ? inServer : undefined;
+            else if (matched && inServer && matched.route !== inServer.route && !providers.fitsScope(matched.route.scope, true)) {
+                controller_decorator.warnOnce(logger, `resolveRoute resolved a message without dm to ${named(matched.route)}, which works in a DM alone, where dispatch runs ` + `${named(inServer.route)} for a message sent in a server. Pass dm: true for a DM. Under useStrictMocks() it resolves to ` + `${named(inServer.route)}.`);
+            } else if (matched && !providers.fitsScope(matched.route.scope, true)) {
+                // Only a handler that works in a DM alone takes it, which dispatch runs in a DM only
+                controller_decorator.warnOnce(logger, `resolveRoute found only ${named(matched.route)}, which works in a DM alone, for a message without dm; dispatch runs it ` + 'only in a DM. Pass dm: true. Under useStrictMocks() this resolves to undefined.');
+            }
+        }
+        if (!matched) return undefined;
+        const { route, params } = matched;
+        // Dispatch never runs a route that does not work in a DM; one sent with a prefix or mention is told it works in a server only
+        if (starts.inGuild === false && (!providers.fitsScope(route.scope, false) || providers.takesGuildParam(route))) return undefined;
+        // Nor one with a required flag only a server has, or given one: refused under strict mocks, warned about otherwise
+        if (starts.inGuild === false && (providers.needsGuild(route) || givesGuildFlag(route, params))) {
+            if (strictMocks()) return undefined;
+            controller_decorator.warnOnce(logger, `resolveRoute resolved a DM to ${named(route)}, which dispatch answers "This command ` + 'works in a server only.": a member, role or channel flag is found only in a server. Under useStrictMocks() this ' + 'resolves to undefined.');
+        }
+        return {
+            controller: route.controllerClass,
+            method: route.method,
+            handler: route.controllerClass.prototype[route.method],
+            params
+        };
+    }
+    if (!controller_decorator.isCustomIdRouted(input.type)) {
+        throw new TypeError(`${input.type} commands are routed by name, not by customId.`);
+    }
+    const routes = eventSources.buildComponentRoutes(controllersOf(app));
+    const matched = eventSources.matchComponentRoute(routes, (type)=>type === input.type, input.customId);
+    if (!matched) return undefined;
+    const { route, params, text } = matched;
+    const method = route.meta.methodName;
+    const typed = Object.keys(route.types).length > 0;
+    // 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 && eventSources.readCustomId(other.pattern, other.meta.regex, input.customId)).map((other)=>other.pattern);
+    const resolved = {
+        controller: route.controllerClass,
+        method,
+        handler: route.controllerClass.prototype[method],
+        params: text,
+        ...typed && {
+            values: params
+        }
+    };
+    return alsoMatches.length > 0 ? readableOnly(resolved, {
+        alsoMatches
+    }) : resolved;
+}
+/**
+ * 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. 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 rank equally and can match the same `customId`, with its component type.
+ *
+ * @example
+ * ```ts
+ * import { expect } from 'vitest'
+ *
+ * @Controller()
+ * 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: [TicketController], clientOptions: { intents: [] } })
+ * class App {}
+ * expect(findRouteConflicts(App)).toHaveLength(1)
+ * ```
+ *
+ * @group Testing
+ * @category Inspection
+ * @see {@link resolveRoute}
+ */ function findRouteConflicts(app) {
+    return eventSources.findComponentRouteConflicts(eventSources.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;
+}
 
 /**
  * A compiled testing module, which runs handlers as the bot does and resolves the classes it built.
@@ -4346,7 +5457,13 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
    * ```
    */ async init(options = {}) {
         this.resolving ?? (this.resolving = providers.resolveProviders(this.container, this.providers, this.order).then(()=>{
+            // As the bot reads them, once every provided value is made and before the services that could list them
+            this.sources ?? (this.sources = eventSources.eventSources(this.container, this.providers, this.lifecycle, this.eventClasses, (text)=>new controller_decorator.Logger('TestingModule').warn(text)));
+            providers.listEventSources(this.container.get(providers.HandlerRegistry), this.sources);
+            providers.prepareLateThemes(this.container, this.sources.map(({ cls })=>cls));
             for (const service of this.services)this.container.get(service);
+            // After the providers and listed services, as the bot makes it, so a provided value it injects is made
+            if (this.app) providers.bindAppPresenter(this.container, this.app);
         }));
         await this.resolving;
         if (options.ready) {
@@ -4402,10 +5519,10 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
             // 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) ?? {}));
+                .map((unit)=>eventSources.lifecycleEntry(unit, this.container.get(unit.token) ?? {}));
             const failures = [];
-            await startupRoots.runShutdownSequence(this.container, entries, {
-                drainCalls: ()=>startupRoots.callsSettled(this.calls),
+            await eventSources.runShutdownSequence(this.container, entries, {
+                drainCalls: ()=>eventSources.callsSettled(this.calls),
                 readyPass: this.readyPass,
                 timeoutMs: this.shutdownTimeout,
                 hookFailed: (name, error)=>failures.push({
@@ -4434,10 +5551,9 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
                 error
             });
         // No warning for a hook whose dependency failed: the test sees the dependency's own error
-        // What close() shuts down is what was constructed, so the entries the runner records are not kept
-        await startupRoots.runReadyHooks(this.container, this.lifecycle, client, {
+        await eventSources.runReadyHooks(this.container, this.lifecycle, client, {
             primary
-        }, [], {
+        }, {
             resolveFailed: failed,
             hookFailed: failed
         }, {
@@ -4504,16 +5620,24 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
    *   command's or an autocomplete's options, or the handler's customId params with a modal's fields or
    *   a select menu's choices.
    *   An interaction's customId or command name must be one dispatch routes to the handler, ranking
-   *   every handler of the module as the bot does; a mock built without one is not checked. With a message alone, a patterned `@MessageHandler` gets the
-   *   params its pattern captures from the content, after the prefix of the module's `app`, with typed
-   *   params resolved as dispatch resolves them, from the message's guild caches first; a message
-   *   without content gets `{}`. A word that is not a value of its type, and a prefixed message that names
-   *   the command but leaves out a param, go through the handler's filters as a `MessageUsageError`, as
-   *   dispatch answers them.
+   *   every handler of the module as the bot does; a mock built without one is not checked. An autocomplete is
+   *   checked by its command path and its focused option: one dispatch gives to another `@Autocomplete` handler,
+   *   or to none, is refused under `useStrictMocks()`, and otherwise warned about once and run.
+   *   With a message alone, a patterned `@MessageHandler` gets the params its pattern captures from the content,
+   *   after the prefix of the module's `app`, with typed params resolved as dispatch resolves them, from the
+   *   message's guild caches first. A message whose `content` isn't a string, as a mock's without
+   *   `useStrictMocks()`, gets `{}`. Under strict mocks a message has empty `content`, and a patterned handler
+   *   rejects it, as dispatch runs no handler for a message with no text: give the mock the `content` the handler
+   *   takes. A word that is not a value of its type, and a prefixed message that names the command but leaves out
+   *   a param, go through the handler's filters as a `MessageUsageError`, as dispatch answers them.
+   *   An `@On` or `@Once` handler no route reaches runs as {@link emit} runs it, as an event with the arguments given,
+   *   under `useStrictMocks()`; without strict mocks it runs as its first argument's type, and `invoke` warns once
+   *   where that differs.
    * @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. Given fewer arguments than the handler
+   *   message the handler's route does not match, naming both, and under `useStrictMocks()` with such an
+   *   autocomplete. 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.
    *
@@ -4545,15 +5669,29 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
         const instance = this.container.get(controller);
         if (typeof instance[methodName] !== 'function') throw new Error(`${controller.name}.${methodName} is not a method.`);
         const [first] = args;
+        const event = eventHandlerOf(controller, methodName);
+        // As emit and the bot run it; without strict mocks it runs as before, as a test that passes that way could fail
+        if (event && strictMocks()) {
+            this.checkArgumentCount(controller, methodName, instance[methodName], first, args.length);
+            this.registerEventClients(args);
+            const { ran, error } = await this.track(this.runEventHandler(instance, methodName, args));
+            return error === undefined ? {
+                ran
+            } : {
+                ran,
+                error
+            };
+        }
         const interaction = first instanceof discord_js.BaseInteraction ? first : undefined;
         // The handler dispatch gives the customId to, among every handler of the module
-        const component = interaction && controller_decorator.hasCustomId(interaction) ? startupRoots.componentRouteFor(this.componentRoutes(), controller, methodName, interaction) : undefined;
-        const mismatch = component && 'mismatch' in component ? component.mismatch : interaction && startupRoots.commandMismatch(this.controllers, controller, methodName, interaction);
+        const component = interaction && controller_decorator.hasCustomId(interaction) ? eventSources.componentRouteFor(this.componentRoutes(), controller, methodName, interaction) : undefined;
+        const mismatch = component && 'mismatch' in component ? component.mismatch : interaction && eventSources.commandMismatch(this.controllers, controller, methodName, interaction);
         if (mismatch) throw new Error(mismatch);
+        if (interaction) this.checkAutocompleteRoute(controller, methodName, interaction);
         let hooks = {};
         let callArgs = args.length === 1 && interaction ? [
             interaction,
-            startupRoots.handlerInput(interaction, component && 'params' in component ? component.params : {}).params
+            eventSources.handlerInput(interaction, component && 'params' in component ? component.params : {}).params
         ] : args;
         if (args.length === 1 && first instanceof discord_js.Message) {
             const input = await providers.messageParamsFor(controller, methodName, first, this.messageOptions, this.controllers);
@@ -4568,10 +5706,7 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
             }
         }
         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;
-        if (presenter && client) controller_decorator.setPresenter(client, presenter);
+        if (event) this.warnEventRun(controller, methodName, event, first, callArgs.length !== args.length);
         this.registerClient(first);
         const { ran, error } = await this.track(providers.runHandler(this.container, instance, methodName, callArgs, {
             awaitObservers: true,
@@ -4585,6 +5720,36 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
         };
     }
     /**
+   * Warns once, without strict mocks, that `invoke` runs an event handler other than as the bot does: as the type its
+   * first argument gives, or with params it added. Only `invoke` warns, on the test's own call.
+   */ warnEventRun(controller, methodName, event, first, paramsAdded) {
+        const type = controller_decorator.inferContextType(first);
+        // invoke adds params only for an interaction or a message, whose type is never 'event'
+        if (type === 'event') return;
+        const key = `${controller.name}.${methodName}`;
+        if (this.warnedEventRuns.has(key)) return;
+        this.warnedEventRuns.add(key);
+        const call = `${controller_decorator.withArticle(type)} call${paramsAdded ? ' with its params added' : ''}`;
+        new controller_decorator.Logger('TestingModule').warn(`invoke runs ${key}, an @${event.once ? 'Once' : 'On'}('${event.event}') handler, as ${call}; the bot runs it as ` + 'an event with its arguments as given, and useStrictMocks() runs it so.');
+    }
+    /** Runs an `@On` or `@Once` handler as the bot and `emit` do: as an event, with its arguments as given. */ runEventHandler(instance, method, args) {
+        return providers.runHandler(this.container, instance, method, args, {
+            type: 'event',
+            awaitObservers: true
+        });
+    }
+    /**
+   * Refuses under strict mocks, and otherwise warns once, an autocomplete dispatch gives to another handler or to none.
+   * Without strict mocks the handler still runs, since a test that passes that way would fail.
+   */ checkAutocompleteRoute(controller, methodName, interaction) {
+        const mismatch = eventSources.autocompleteMismatch(this.controllers, controller, methodName, interaction);
+        if (!mismatch) return;
+        if (strictMocks()) throw new Error(mismatch);
+        if (this.warnedAutocompleteRoutes.has(mismatch)) return;
+        this.warnedAutocompleteRoutes.add(mismatch);
+        new controller_decorator.Logger('TestingModule').warn(`${mismatch} Under useStrictMocks(), invoke rejects it.`);
+    }
+    /**
    * 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) {
@@ -4603,34 +5768,70 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
         return call;
     }
     /**
-   * Makes this module the app of the input's client, as the bot is of its own, so `respond()` outside any call,
-   * as in a collector's callback on that client, answers in this module's theme.
+   * Makes this module the app of the input's client, as the bot is of its own: its answers are drawn by this
+   * module's presenter, in its theme and language, `respond()` outside any call included, as in a collector's callback
+   * on that client. A module without a presenter clears the client's under strict mocks, so the default draws; default
+   * mode leaves another module's in place and warns once.
    */ registerClient(input) {
         const client = input?.client;
         if (!client || typeof client !== 'object') return;
+        const presenter = providers.appPresenterOf(this.container);
+        if (presenter || strictMocks()) controller_decorator.setPresenter(client, presenter);
+        else if (controller_decorator.clientPresenter(client)) {
+            controller_decorator.warnOnce(new controller_decorator.Logger('TestingModule'), "A module without a presenter here answers with the presenter another module set on the same client; under " + "useStrictMocks() this module's own presenter, or the default, is used.");
+        }
         providers.registerClientTheme(client, this.container);
         controller_decorator.registerClientTranslator(client, this.container.isBound(controller_decorator.Translator) ? this.container.get(controller_decorator.Translator) : undefined);
     }
+    /**
+   * Makes this module the app of each event argument's client, as the bot is of its own, under strict mocks; default
+   * mode leaves the clients as they are and warns once where this module would draw answers otherwise.
+   */ registerEventClients(args) {
+        const withClient = args.filter((arg)=>typeof arg?.client === 'object');
+        if (withClient.length === 0) return;
+        if (strictMocks()) {
+            for (const arg of withClient)this.registerClient(arg);
+            return;
+        }
+        const ownTheme = providers.appTheme(this.container) !== controller_decorator.defaultTheme();
+        if (!providers.appPresenterOf(this.container) && !this.container.isBound(controller_decorator.Translator) && !ownTheme) return;
+        controller_decorator.warnOnce(new controller_decorator.Logger('TestingModule'), "emit() here leaves the client's presenter, theme and translator as they were, where the bot draws the answers to " + "an event with its app's; in the next major version (5.0) emit sets the module's on the client. Call " + 'useStrictMocks() to have it set them now.');
+    }
     /** The module's component routes, ranked as dispatch ranks them; throws, as the bot would, for two of one shape. */ componentRoutes() {
-        return this.builtComponentRoutes ?? (this.builtComponentRoutes = startupRoots.buildComponentRoutes(this.controllers));
+        return this.builtComponentRoutes ?? (this.builtComponentRoutes = eventSources.buildComponentRoutes(this.controllers));
     }
     /** The dispatcher the bot would build from this module's controllers and `app`. */ dispatcherOf() {
         if (this.dispatcher) return this.dispatcher;
         const logger = new controller_decorator.Logger('TestingModule');
         const warnUnanswered = this.appWarnUnanswered ?? process.env.NODE_ENV === 'development';
-        this.dispatcher = new startupRoots.Dispatcher({
+        const notices = {
+            cooldownNotice: (refusal)=>providers.claimCooldownNotice(this.container, refusal),
+            storeDownNotice: (who)=>providers.claimStoreDownNotice(this.container, who)
+        };
+        // Strict mocks log an answer MeoCord fails to build and end the call in that fault, as a bot does; default mode
+        // rethrows it from the fallback, so observers hear the call's own outcome, and an interaction's again as an error
+        const answer = eventSources.createFallback(logger, ()=>this.messageOptions, notices);
+        const rethrowing = eventSources.createFallback(logger, ()=>this.messageOptions, {
+            ...notices,
+            strict: true
+        });
+        const fallback = async (error, context)=>{
+            if (strictMocks()) return answer(error, context);
+            try {
+                return await rethrowing(error, context);
+            } catch (failure) {
+                controller_decorator.warnOnce(logger, "dispatch() here reports a call whose answer MeoCord couldn't build with the call's own outcome, and an " + "interaction's a second time as an error; under useStrictMocks() the call is reported once, as 'error'.");
+                throw failure;
+            }
+        };
+        this.dispatcher = new eventSources.Dispatcher({
             container: this.container,
             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,
-                cooldownNotice: (refusal)=>providers.claimCooldownNotice(this.container, refusal),
-                storeDownNotice: (who)=>providers.claimStoreDownNotice(this.container, who)
-            }),
+            fallback,
             // A mock's client is the one bot every mock client is, so a mention of it starts a command
             botUserId: (event)=>{
                 const id = event.client?.user?.id;
@@ -4648,6 +5849,8 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
         const dispatcher = this.dispatcherOf();
         const handlers = [];
         const unhandled = [];
+        // The fault each error's answer failed with, which the call ends in in that error's place
+        const unanswered = new Map();
         const record = {
             settled: (controller, method, { ran, error })=>handlers.push({
                     controller,
@@ -4657,7 +5860,8 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
                         error
                     }
                 }),
-            unhandled: (error)=>unhandled.push(error)
+            unhandled: (error)=>unhandled.push(error),
+            unanswered: (error, failure)=>unanswered.set(error, failure)
         };
         if (options) {
             noteReactionDispatch(input);
@@ -4666,18 +5870,19 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
                 action: options.action ?? enum_index.ReactionHandlerAction.ADD
             }, record));
         } else if (input instanceof discord_js.BaseInteraction) {
-            const presenter = providers.appPresenterOf(this.container);
-            if (presenter) controller_decorator.setPresenter(input.client, presenter);
             await this.track(dispatcher.interaction(input, record));
         } else if (input instanceof discord_js.Message) {
-            const presenter = providers.appPresenterOf(this.container);
-            if (presenter) controller_decorator.setPresenter(input.client, presenter);
             await this.track(dispatcher.message(input, record));
         } else {
             throw new TypeError('dispatch takes an interaction, a message, or a reaction with { user }.');
         }
-        // What the fallback answers as the user's own outcome, such as a usage reply or a refusal, is an outcome to assert on
-        const failures = unhandled.filter((error)=>!controller_decorator.isUserOutcome(error, options ? undefined : input));
+        // What the fallback answers as the user's own outcome, such as a usage reply or a refusal, is an outcome to assert on,
+        // unless its answer failed to build, which is the call's fault, as on a bot
+        const failures = unhandled.flatMap((error)=>unanswered.has(error) ? [
+                unanswered.get(error)
+            ] : controller_decorator.isUserOutcome(error, options ? undefined : input) ? [] : [
+                error
+            ]);
         if (failures.length === 1) throw failures[0];
         if (failures.length > 1) throw new AggregateError(failures, `${failures.length} errors were left to the fallback.`);
         const error = handlers.find((handler)=>handler.error !== undefined)?.error ?? unhandled[0];
@@ -4692,8 +5897,9 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
     /**
    * 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.
+   * As on the bot, every instance the module runs lifecycle hooks on, the cooldown store aside, receives
+   * it: the controllers and services, what they and the stages inject, and each provided class or value.
+   * 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
@@ -4717,22 +5923,21 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
    */ async emit(event, ...args) {
         this.warnIfClosed();
         await this.init();
+        this.registerEventClients(args);
         const calls = [];
-        for (const cls of this.eventClasses){
-            for (const handler of providers.getEventHandlers(cls.prototype)){
+        for (const [index, source] of (this.sources ?? []).entries()){
+            for (const handler of source.handlers){
                 if (handler.event !== event) continue;
                 if (handler.once) {
-                    const key = `${cls.name}.${handler.method}:${event}`;
+                    const key = `${index}.${handler.method}:${event}`;
                     if (this.firedOnce.has(key)) continue;
                     this.firedOnce.add(key);
                 }
                 // Resolved inside the call, so a class that cannot be resolved fails as its handler would
                 const run = async ()=>{
-                    const instance = this.container.get(cls);
-                    const { ran } = await providers.runHandler(this.container, instance, handler.method, args, {
-                        type: 'event',
-                        awaitObservers: true
-                    });
+                    const instance = source.resolve();
+                    if (!instance) return false;
+                    const { ran } = await this.runEventHandler(instance, handler.method, args);
                     return ran;
                 };
                 calls.push(this.track(run()));
@@ -4748,7 +5953,7 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
             ran: results.filter((result)=>result.status === 'fulfilled' && result.value).length
         };
     }
-    constructor(container, controllers = [], eventClasses = [], providers = new Map(), order = [], messageOptions = {}, lifecycle = [], /** The lifecycle units the container has constructed, which `close()` shuts down. */ constructed = new Set(), /** The `app`'s `warnUnanswered`, which dispatch follows as the bot does. */ appWarnUnanswered, /** The app's listed services, made at `init()` as the bot makes them before it logs in. */ services = [], /** How long `close()` waits for the `onShutdown` hooks, as the bot's `shutdownTimeout` does. */ shutdownTimeout = startupRoots.DEFAULT_SHUTDOWN_TIMEOUT_MS){
+    constructor(container, controllers = [], eventClasses = [], providers = new Map(), order = [], messageOptions = {}, lifecycle = [], /** The lifecycle units the container has constructed, which `close()` shuts down. */ constructed = new Set(), /** The `app`'s `warnUnanswered`, which dispatch follows as the bot does. */ appWarnUnanswered, /** The app's listed services, made at `init()` as the bot makes them before it logs in. */ services = [], /** How long `close()` waits for the `onShutdown` hooks, as the bot's `shutdownTimeout` does. */ shutdownTimeout = eventSources.DEFAULT_SHUTDOWN_TIMEOUT_MS, /** The `app`, whose presenter `init()` makes after the providers, as the bot does. */ app){
         this.container = container;
         this.controllers = controllers;
         this.eventClasses = eventClasses;
@@ -4760,10 +5965,13 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
         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.app = app;
+        /** The `onReady` hooks' pass, which `close()` waits for, less one whose `onReady` called `close()`. */ this.readyPass = new eventSources.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 `@On` and `@Once` handlers already warned about for running other than as an event, so each is named once. */ this.warnedEventRuns = new Set();
+        /** The autocomplete mismatches already warned about without strict mocks, so each handler and route warns once. */ this.warnedAutocompleteRoutes = new Set();
         /** The calls under way, each removed once it settles: what `close()` lets finish before the cooldown store stops. */ this.calls = new Set();
     }
 }
@@ -4773,6 +5981,10 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
         throw new AggregateError(failures.map(({ error })=>error), `${failures.length} ${hook} hooks threw: ${failures.map(({ name })=>name).join(', ')}.`);
     }
 }
+/** A method's `@On` or `@Once` handler, when no route also reaches it: a route's input decides how that one runs. */ function eventHandlerOf(controller, methodName) {
+    if (controller_decorator.getHandlerRoutes(controller.prototype).some((route)=>route.method === methodName)) return undefined;
+    return providers.getEventHandlers(controller.prototype).find((handler)=>handler.method === methodName);
+}
 /** The app's `messages` options, when the testing module is given an app. */ function messagesOf(app) {
     return app && Reflect.getMetadata(controller_decorator.META.appOptions, app)?.messages;
 }
@@ -4807,7 +6019,9 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
     /**
    * Replaces a provider with a test double.
    *
-   * The double needs only the members the test uses; misspelled member names are still rejected.
+   * The double needs only the members the test uses; misspelled member names are still rejected. A token MeoCord binds
+   * itself, such as `ShardContext` or `HandlerRegistry`, takes the double in place of MeoCord's own, so a test can stub
+   * cross-shard calls.
    *
    * @param token - The provider to replace.
    * @example
@@ -4970,7 +6184,7 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
    * @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);
+        const shutdownTimeout = this.options.shutdownTimeout === undefined ? undefined : eventSources.shutdownTimeoutProblem(this.options.shutdownTimeout);
         if (shutdownTimeout) throw new TypeError(`shutdownTimeout ${shutdownTimeout}.`);
         // With startupErrors: 'all', what the decorators kept on the classes this module runs
         const declared = controller_decorator.declaredErrorsOf([
@@ -4991,7 +6205,7 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
                 // 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));
+                container.bind(providers.HandlerRegistry).toConstantValue(new providers.HandlerRegistry(appClasses, messagesOf(this.options.app), translator, this.options.controllers ?? []));
                 // 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,
@@ -5004,6 +6218,17 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
                 // 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 })');
+                // The app's own providers checked as the bot checks them. A token the module binds itself above fails at its
+                // first call, so it is refused; another the bot binds before its providers is refused under strict mocks, and
+                // runs here in default mode with a warning
+                const i18n = this.options.app && Reflect.getMetadata(controller_decorator.META.appOptions, this.options.app)?.i18n;
+                const botBinds = providers.boundBeforeProviders(i18n !== undefined);
+                for (const token of providers$1.keys()){
+                    const refusal = providers.appProviderRefusal(`${this.options.app?.name}`, token, (own)=>botBinds.includes(own), new controller_decorator.Logger('TestingModule'));
+                    if (!refusal) continue;
+                    if (container.isBound(token) || strictMocks()) controller_decorator.startupError(refusal);
+                    else controller_decorator.warnOnce(new controller_decorator.Logger('TestingModule'), `${refusal.message} The testing module runs it; under useStrictMocks() compile() refuses it, as the bot does.`);
+                }
                 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
@@ -5041,7 +6266,17 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
                 }
                 // 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();
+                // What the walk below takes as classes, reported with what the walk finds; an entry refused here is left out of it
                 const services = this.wiring?.services ?? [];
+                if (this.options.app) providers.assertProvidedServices(this.options.app.name, services, providers$1, "@MeoCord({ providers }) or the testing module's providers");
+                for (const controller of this.options.controllers ?? []){
+                    if (!controller_decorator.isConstructor(controller)) controller_decorator.startupError(new Error(`the testing module's controllers takes classes, not ${controller_decorator.describeValue(controller)}.`));
+                }
+                const observers = [
+                    ...this.options.app ? providers.appObservers(this.options.app) : [],
+                    ...this.options.observers ?? []
+                ];
+                providers.assertObservers("the testing module's observers", observers);
                 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
@@ -5049,20 +6284,16 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
                 // 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 ?? [],
+                const startup = eventSources.startupClasses({
+                    controllers: (this.options.controllers ?? []).filter(controller_decorator.isConstructor),
                     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 ?? []
-                    ],
+                    observers,
                     stubs: [
                         ...this.guardOverrides.keys(),
                         ...this.interceptorOverrides.keys(),
@@ -5070,7 +6301,7 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
                     ]
                 });
                 const hasTranslator = i18n !== undefined || providers$1.has(controller_decorator.Translator);
-                startupRoots.assertStartupClasses(startup, {
+                eventSources.assertStartupClasses(startup, {
                     translator: hasTranslator
                 });
                 // Those of the stages, guards and other classes they reach
@@ -5079,7 +6310,7 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
                 providers.markStartupChecked(container, [
                     ...startup.classes,
                     ...providers.meocordClasses()
-                ], startupRoots.lateGuardCheck(providers$1, hasTranslator));
+                ], eventSources.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)) {
@@ -5106,8 +6337,7 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
                     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);
+                        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
@@ -5121,8 +6351,12 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
                     }
                     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);
+                // Before the controllers, so a class token that is provided is not also bound as itself. A test's provider of a
+                // token the module bound above, as HandlerRegistry or ShardContext, stands in for that binding
+                for (const provider of providers$1.values()){
+                    if (container.isBound(provider.provide)) container.unbind(provider.provide);
+                    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);
@@ -5150,20 +6384,13 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
                 // 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 ?? []);
+                eventSources.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);
+                const stageServices = eventSources.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
@@ -5187,39 +6414,34 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
                             cooldownStore: true
                         }
                     }));
+                // Recorded as the container makes each one, before anything can be made, 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;
+                    });
+                }
                 // 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, [
+                providers.prepareDirectCalls(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 ?? [], {
+                eventSources.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;
-                    });
-                }
+                eventSources.warnInheritedRoutes(this.options.controllers ?? []);
+                eventSources.warnOverlappingPatterns(this.options.controllers ?? []);
+                eventSources.warnHandlersOffControllers(this.options.controllers ?? [], startup.classes);
+                for (const warning of eventSources.perCallEventWarnings(startup, providers$1, appPresenterClass))new controller_decorator.Logger('TestingModule').warn(warning);
                 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);
+                ], appClasses, providers$1, order, messages, lifecycle, constructed, warnUnanswered, services, this.options.shutdownTimeout ?? eventSources.DEFAULT_SHUTDOWN_TIMEOUT_MS, this.options.app);
             });
         } catch (error) {
             if (controller_decorator.isRefusal(error) && !controller_decorator.isExplainedError(error)) {
@@ -5298,7 +6520,8 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
    * @param app - The class `@MeoCord` decorates.
    * @param options - Providers that replace the app's by token, extra controllers, and observers.
    * @returns The builder, whose `override*` methods still apply, for `compile()`.
-   * @throws TypeError when `app` is not a `@MeoCord` class.
+   * @throws TypeError when `app` is not a `@MeoCord` class. After {@link reportAllStartupErrors}, an app whose
+   *   `@MeoCord` was refused throws the error it was refused for instead.
    *
    * @example
    * ```ts
@@ -5338,8 +6561,19 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
    * expect(getResponse(interaction).calls[0].payload).toMatchObject({ content: '1 notes' })
    * ```
    */ static fromApp(app, options = {}) {
+        // An app that isn't a class at all, as a circular import gives, has no metadata to read
+        if (typeof app !== 'function') {
+            const { name, hint } = notAClass(app);
+            throw new TypeError(`${name} is not a @MeoCord app: fromApp takes the class @MeoCord decorates.${hint}`);
+        }
         const appOptions = Reflect.getMetadata(controller_decorator.META.appOptions, app);
-        if (!appOptions) throw new TypeError(`${app?.name ?? String(app)} is not a @MeoCord app: fromApp takes the class @MeoCord decorates.`);
+        if (!appOptions) {
+            // A refused @MeoCord stores no options, so its own errors, kept with startupErrors: 'all', say why
+            controller_decorator.collectStartupErrors(()=>controller_decorator.declaredErrorsOf([
+                    app
+                ]).forEach(controller_decorator.startupError));
+            throw new TypeError(`${app?.name ?? String(app)} is not a @MeoCord app: fromApp takes the class @MeoCord decorates.`);
+        }
         const controllers = [
             ...new Set([
                 ...appOptions.controllers,
@@ -5385,236 +6619,33 @@ providers.adviseInPlaceOfInjecting(TestingModule, 'make it with MeoCordTestingMo
     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().`);
-    return options;
-}
-/** The controllers `@MeoCord({ controllers })` registers on an application class. */ function controllersOf(app) {
-    return appOptionsOf(app).controllers ?? [];
-}
-/**
- * Resolves which handler a component's `customId` or a message's content reaches, as dispatch routes it.
- *
- * Use it to check routing alone, in a plain unit test: it reads decorator metadata, with no client, config or
- * container, and runs no guard. To run the handler it reaches, use {@link TestingModule.dispatch}.
- *
- * @remarks
- * It routes across every controller the app registers, most specific pattern first: a component within its type, a
- * message after the app's prefix, and never to a `@MessageHandler()` listener, which runs for every message.
- *
- * @param app - The application class decorated with `@MeoCord`.
- * @param input - The component type and its `customId`, or the message's content with its prefix and the bot's id.
- * @returns The handler that runs, with the params it captures, or `undefined` when no route handles the input.
- * @throws TypeError for a message to an app whose prefix is a function, when no `prefix` is given.
- *
- * @example
- * ```ts
- * import { expect } from 'vitest'
- *
- * @Controller()
- * class ProfileController {
- *   @Command('profile/{uid}', CommandType.BUTTON)
- *   async show(interaction: ButtonInteraction, { uid }: { uid: string }) {
- *     await respond(interaction).send(`Profile ${uid}`)
- *   }
- * }
- * @MeoCord({ controllers: [ProfileController], clientOptions: { intents: [] } })
- * class App {}
- * const route = resolveRoute(App, { type: CommandType.BUTTON, customId: 'profile/8000' })
- * expect([route?.handler, route?.params]).toEqual([ProfileController.prototype.show, { uid: '8000' }])
- * ```
- *
- * @group Testing
- * @category Inspection
- * @see {@link findRouteConflicts}
- * @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);
-        const starts = providers.staticMessageStarts(app, messages, input);
-        const matched = providers.matchMessageRoute(providers.buildMessageRoutes(controllersOf(app), messages), input.content, starts);
-        if (!matched) return undefined;
-        const { route, params } = matched;
-        // Dispatch answers a route that does not work in a DM with its usage, and never runs it
-        if (starts.inGuild === false && (!providers.fitsScope(route.scope, false) || providers.needsGuild(route))) return undefined;
-        return {
-            controller: route.controllerClass,
-            method: route.method,
-            handler: route.controllerClass.prototype[route.method],
-            params
-        };
-    }
-    if (!controller_decorator.isCustomIdRouted(input.type)) {
-        throw new TypeError(`${input.type} commands are routed by name, not by customId.`);
-    }
-    const routes = startupRoots.buildComponentRoutes(controllersOf(app));
-    const matched = startupRoots.matchComponentRoute(routes, (type)=>type === input.type, input.customId);
-    if (!matched) return undefined;
-    const { route, params, text } = matched;
-    const method = route.meta.methodName;
-    const typed = Object.keys(route.types).length > 0;
-    // 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],
-        params: text,
-        ...typed && {
-            values: params
-        }
-    };
-    return alsoMatches.length > 0 ? readableOnly(resolved, {
-        alsoMatches
-    }) : resolved;
-}
-/**
- * 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. 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 rank equally and can match the same `customId`, with its component type.
- *
- * @example
- * ```ts
- * import { expect } from 'vitest'
- *
- * @Controller()
- * 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: [TicketController], clientOptions: { intents: [] } })
- * class App {}
- * expect(findRouteConflicts(App)).toHaveLength(1)
- * ```
- *
- * @group Testing
- * @category Inspection
- * @see {@link resolveRoute}
- */ function findRouteConflicts(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;
-}
-
 /**
- * Builds the `fields` of a submitted form, as discord.js does when a user submits one.
- *
- * Use it for a mock `ModalSubmitInteraction`: discord.js keeps the `ModalSubmitFields` constructor private, so a test
- * cannot build one directly.
- *
- * @param values - Each field's value, keyed by its customId: a string for a text input, an array of strings for a
- *   select's chosen values, or an array of `Attachment`s for a file upload. An empty array is a select with nothing
- *   chosen.
- * @returns Fields that `getTextInputValue`, `getStringSelectValues`, `getUploadedFiles` and a handler's params all
- *   read.
- *
- * @example
- * ```ts
- * import { expect } from 'vitest'
- *
- * @Controller()
- * class FeedbackController {
- *   @Command('feedback/{topic}', CommandType.MODAL_SUBMIT)
- *   async submit(interaction: ModalSubmitInteraction, { topic, body }: { topic: string; body: string }) {
- *     await respond(interaction).send(`Thanks: ${topic}, ${body}`)
- *   }
- * }
- * const module = MeoCordTestingModule.create({ controllers: [FeedbackController] }).compile()
- * const fields = createModalFields({ body: 'It crashed' })
- * const interaction = createMockInteraction(ModalSubmitInteraction, { customId: 'feedback/bugs', fields })
- * await module.invoke(FeedbackController, 'submit', interaction)
- * expect(getResponse(interaction).calls[0].payload).toMatchObject({ content: 'Thanks: bugs, It crashed' })
- * ```
- *
- * @group Testing
- * @category Mocks
- * @see {@link createMockInteraction}
- */ function createModalFields(values) {
-    const component = (customId, value)=>{
-        if (!Array.isArray(value)) return {
-            type: discord_js.ComponentType.TextInput,
-            customId,
-            value
-        };
-        if (!value.some((item)=>item instanceof discord_js.Attachment)) return {
-            type: discord_js.ComponentType.StringSelect,
-            customId,
-            values: value
-        };
-        const attachments = new discord_js.Collection(value.map((file)=>[
-                file.id,
-                file
-            ]));
-        return {
-            type: discord_js.ComponentType.FileUpload,
-            customId,
-            values: [
-                ...attachments.keys()
-            ],
-            attachments
-        };
-    };
-    const components = Object.entries(values).map(([customId, value])=>({
-            type: discord_js.ComponentType.Label,
-            component: component(customId, value)
-        }));
-    const Fields = discord_js.ModalSubmitFields;
-    return new Fields(components);
-}
-
-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 = '') {
+ * Every message key of a catalog, and whether it is a plural. `reference` decides whether an object is a plural or a
+ * group, as the translator reads a translation by the default catalog's shapes; where it lacks a key, the object's own
+ * keys decide.
+ */ function leaves(catalog, prefix = '', reference = catalog) {
     return Object.entries(catalog).flatMap(([name, value])=>{
         const key = `${prefix}${name}`;
-        if (typeof value === 'string') return [
+        // A null message is one where it stands, which the checks below read as missing
+        if (typeof value === 'string' || value === null) return [
             {
                 key,
                 plural: false
             }
         ];
-        if (isPlural(value)) return [
+        const shape = typeof reference === 'object' && reference !== null && Object.hasOwn(reference, name) ? reference[name] : undefined;
+        const plural = typeof shape === 'object' && shape !== null ? controller_decorator.isPluralShape(shape) : controller_decorator.isPluralShape(value);
+        if (plural) return [
             {
                 key,
                 plural: true
             }
         ];
-        return leaves(value, `${key}.`);
+        return leaves(value, `${key}.`, shape);
     });
 }
 /** 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 !== '';
+/** A message the translator reads as missing: none, `null` or `''`, as tools export one untranslated. */ const isMissing = (value)=>value === undefined || value === null || 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);
 }
@@ -5629,7 +6660,7 @@ const isMeoCordKey = (key)=>key.startsWith('meocord.');
 /** A message as a report shows it: the text, or a plural's `other` form. */ const shown = (message)=>typeof message === 'string' ? message : String(message.other);
 /** The `{params}` a translation uses that the message it translates doesn't take; a plural's `{count}` is taken. */ function strayParams(translation, original) {
     const taken = placeholders(original);
-    if (isPlural(original)) taken.add('count');
+    if (controller_decorator.isPluralShape(original)) taken.add('count');
     return [
         ...placeholders(translation)
     ].filter((name)=>!taken.has(name));
@@ -5639,11 +6670,13 @@ 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, 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.
+ * Russian, a translation of another shape than the default's, a text for a plural or a group, or a plural for a text, and each
+ * `{param}` a translation uses that the message it translates doesn't take. An empty translation, `''` or `null`, 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 in the default catalog counts as
+ * a plural only when its every key is a plural category, so a group with an `other` key is a group, and a translation
+ * is read by the default catalog's shapes, as the translator reads it: one that keeps only a group's `other` message
+ * lacks the group's other messages.
  *
  * @remarks
  * MeoCord's own texts, a catalog's `meocord` group, fall back to English by design, so only a key MeoCord lacks, and
@@ -5690,12 +6723,12 @@ 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 || message === '') {
+            if (isMissing(message)) {
                 problems.push(`missing ${key}`);
                 continue;
             }
             // 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') {
+            if (plural !== controller_decorator.isPluralShape(message) || !plural && typeof message !== 'string') {
                 problems.push(`${key} should be a ${plural ? 'plural' : 'text'}, as the default is`);
                 continue;
             }
@@ -5708,9 +6741,11 @@ 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 || at(catalog, key) === '') problems.push(`missing ${key}`);
+            for (const key of MEOCORD_KEYS)if (isMissing(at(catalog, key))) problems.push(`missing ${key}`);
         }
-        for (const { key } of leaves(catalog)){
+        for (const { key } of leaves(catalog, '', defaultCatalog)){
+            // A message left out, as a null one is, that the default has is reported missing above, and is nothing extra
+            if (isMissing(at(catalog, key)) && at(defaultCatalog, key) !== undefined) continue;
             if (isMeoCordKey(key)) {
                 if (!MEOCORD_KEYS.has(key)) problems.push(`${key} is not one of MeoCord's texts`);
                 else {
@@ -5718,7 +6753,11 @@ const isMeoCordKey = (key)=>key.startsWith('meocord.');
                     const stray = strayParams(at(catalog, key), english);
                     for (const name of stray)problems.push(`${key} takes no {${name}}: MeoCord's English is "${shown(english)}"`);
                 }
-            } else if (!referenceKeys.has(key)) problems.push(`${key} is not in the default catalog`);
+            } else if (!referenceKeys.has(key)) {
+                // A text where the default has a group: the key is the default's, in another shape
+                const original = at(defaultCatalog, key);
+                problems.push(typeof original === 'object' && original !== null ? `${key} should be a group, as the default is` : `${key} is not in the default catalog`);
+            }
         }
         if (problems.length > 0) gaps.push(`  ${locale}: ${problems.join('; ')}`);
     }
@@ -6132,10 +7171,10 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
     });
 }
 /** Whether a store overrides `consumeMany`, as a store that counts a batch at once does. */ function overridesConsumeMany(store) {
-    return store.consumeMany !== controller_decorator.CooldownStore.prototype.consumeMany;
+    return !controller_decorator.isDefaultBatchMethod(store.consumeMany);
 }
 /** Whether a store overrides `peekMany`, as a store that can check a batch without recording it does. */ function overridesPeekMany(store) {
-    return store.peekMany !== controller_decorator.CooldownStore.prototype.peekMany;
+    return !controller_decorator.isDefaultBatchMethod(store.peekMany);
 }
 
 /**
@@ -6192,8 +7231,10 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
  * Reports what runs when a handler is dispatched, and the metadata declared on it, without running anything.
  *
  * Use it to check that decorators set a handler up as intended: its guards with their params, its interceptors,
- * filters and cooldowns, in the order dispatch applies them. To check what a handler does, run it with
- * {@link TestingModule.invoke}.
+ * filters and cooldowns, in the order dispatch applies them. Under `useStrictMocks()`, the guards, interceptors and
+ * observers are those dispatch runs for the handler's context types: a stage declared with `types` is listed only for
+ * a handler of one of them, and an autocomplete lists no interceptors. Default mode lists every one, with a warning
+ * once where dispatch runs fewer. To check what a handler does, run it with {@link TestingModule.invoke}.
  *
  * @param controller - The controller class declaring the handler.
  * @param methodName - The handler method's name.
@@ -6229,14 +7270,20 @@ 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);
+    const observers = options.app ? providers.appObservers(options.app) : [];
+    const stages = runStages(controller.prototype, methodName, {
+        guards,
+        interceptors,
+        observers
+    });
     const inspection = {
         controller,
         methodName,
         guards: Object.freeze([
-            ...guards
+            ...stages.guards
         ]),
         interceptors: Object.freeze([
-            ...interceptors
+            ...stages.interceptors
         ]),
         filters: Object.freeze(filters.flat()),
         cooldowns: Object.freeze(providers.handlerCooldowns(controller.prototype, methodName).map(({ seconds, uses, per, bypass, by })=>Object.freeze({
@@ -6247,31 +7294,99 @@ const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
                 by: by !== undefined
             }))),
         pattern: controller_decorator.getMessageHandlers(controller.prototype).find((handler)=>handler.method === methodName)?.pattern,
-        observers: Object.freeze(options.app ? providers.appObservers(options.app) : []),
+        observers: Object.freeze([
+            ...stages.observers
+        ]),
         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
+    const routes = Object.freeze(inheritedRoutesOf(controller.prototype, methodName, false));
+    const withEvents = Object.freeze(inheritedRoutesOf(controller.prototype, methodName, true));
     Object.defineProperty(inspection, 'inheritedRoutes', {
-        value: Object.freeze(inheritedRoutesOf(controller.prototype, methodName)),
+        get: ()=>{
+            if (strictMocks()) return withEvents;
+            if (withEvents.length > routes.length) {
+                controller_decorator.warnOnce(new controller_decorator.Logger('inspectHandler'), `inspectHandler() here leaves the @On and @Once events ${controller.name}.${methodName} inherits out of ` + 'inheritedRoutes, though the bot answers them; under useStrictMocks() it lists them.');
+            }
+            return routes;
+        },
         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) {
+/** The context types dispatch calls `methodName` with: one for each kind of route it answers. */ function handlerContextTypes(prototype, methodName) {
+    const answers = [
+        [
+            'interaction',
+            Object.values(controller_decorator.getCommandMap(prototype) ?? {}).some((metas)=>metas.some((meta)=>meta.methodName === methodName))
+        ],
+        [
+            'autocomplete',
+            controller_decorator.getAutocompleteHandlers(prototype).some((handler)=>handler.methodName === methodName)
+        ],
+        [
+            'message',
+            controller_decorator.getMessageHandlers(prototype).some((handler)=>handler.method === methodName)
+        ],
+        [
+            'reaction',
+            controller_decorator.getReactionHandlers(prototype).some((handler)=>handler.method === methodName)
+        ],
+        [
+            'event',
+            providers.getEventHandlers(prototype).some((handler)=>handler.method === methodName)
+        ]
+    ];
+    return answers.filter(([, answered])=>answered).map(([type])=>type);
+}
+/**
+ * The guards, interceptors and observers dispatch runs for the handler, by the same `appliesTo` it uses: those for one
+ * of its context types, and no interceptors for an autocomplete. Default mode lists every one, and warns once where
+ * that lists more; a method no route reaches lists every one in both modes.
+ */ function runStages(prototype, methodName, all) {
+    const types = handlerContextTypes(prototype, methodName);
+    if (types.length === 0) return all;
+    const forTypes = (entries, among)=>entries.filter((entry)=>among.some((type)=>providers.appliesTo(entry, type)));
+    const run = {
+        ...all,
+        guards: forTypes(all.guards, types),
+        // Autocomplete answers within three seconds and has no reply to shape, so it runs no interceptors
+        interceptors: forTypes(all.interceptors, types.filter((type)=>type !== 'autocomplete')),
+        observers: forTypes(all.observers, types)
+    };
+    if (strictMocks()) return run;
+    const handlerName = `${prototype.constructor.name}.${methodName}`;
+    const count = (stages)=>stages.guards.length + stages.interceptors.length + stages.observers.length;
+    if (count(run) < count(all)) {
+        controller_decorator.warnOnce(new controller_decorator.Logger('inspectHandler'), `inspectHandler() here lists the guards, interceptors and observers of every context type for ${handlerName}, ` + "where dispatch runs only those of its own; under useStrictMocks() it lists the ones dispatch runs.");
+    }
+    return all;
+}
+/**
+ * The routes `methodName` answers that the class declaring it last doesn't declare for it: those it inherits, its
+ * `@On` and `@Once` events among them when `events` is set.
+ */ function inheritedRoutesOf(prototype, methodName, events) {
+    const labels = (routes)=>routes.filter((route)=>route.method === methodName).map((route)=>route.label);
     const answered = [
-        ...new Set(controller_decorator.getHandlerRoutes(prototype).filter((route)=>route.method === methodName).map((route)=>route.label))
+        ...new Set(labels([
+            ...controller_decorator.getHandlerRoutes(prototype),
+            ...events ? providers.getEventHandlers(prototype).map(controller_decorator.eventRoute) : []
+        ]))
     ];
     // 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);
+        const own = labels([
+            ...controller_decorator.getDeclaredRoutes(at),
+            ...events ? controller_decorator.ownEventHandlers(at).map(controller_decorator.eventRoute) : []
+        ]);
         if (own.length > 0) return at === prototype ? answered.filter((label)=>!own.includes(label)) : answered;
     }
     return [];
 }
 
-// Themes createMockTheme made, which withTheme uses as they are
-const mocks = new WeakSet();
+// Themes createMockTheme made through either build of this version, which withTheme uses as they are
+const mocks = controller_decorator.shared('mockThemes', ()=>new WeakSet());
 function mockTheme(overrides, where) {
     if (overrides === undefined) return controller_decorator.defaultTheme();
     controller_decorator.assertValidTheme(overrides, where);