meocord 4.2.1 → 4.2.3

package/dist/esm/testing/mock-interaction.js

@@ -1,15 +1,15 @@
 import 'reflect-metadata';
 import { createMockFn, usesRunnerMockFn } from './mock-fn.js';
-import { DataManager, RoleManager, Role, GuildChannel, GuildMember, User, BaseGuild, MessageMentions, ThreadChannel, Message, BaseGuildVoiceChannel, VoiceChannel, BaseChannel, MessageReaction, InteractionType, ComponentType, ApplicationCommandType, GuildMemberManager, GuildChannelManager, UserManager, ChannelManager, GuildManager, Guild, GuildBanManager, GuildBan, ThreadMemberManager, ThreadMember, GuildMessageManager, DMMessageManager, GuildTextThreadManager, GuildForumThreadManager, PermissionOverwriteManager, PermissionOverwrites, ReactionManager, ReactionUserManager, PresenceManager, Presence, CommandInteractionOptionResolver, ApplicationCommandOptionType, Client, ApplicationCommandManager, ClientUser, CDN, DiscordjsErrorCodes, AuthorizingIntegrationOwners, BaseInteraction, UserContextMenuCommandInteraction, MessageContextMenuCommandInteraction, Attachment, Locale, StringSelectMenuInteraction, UserSelectMenuInteraction, RoleSelectMenuInteraction, ChannelSelectMenuInteraction, MentionableSelectMenuInteraction, Collection, PermissionsBitField, Base, SnowflakeUtil, DiscordjsError, DMChannel, GuildMemberRoleManager, MessageFlagsBitField, BaseManager, TextChannel, Component, Embed, ActionRow, ApplicationCommand, NewsChannel, ForumChannel, MediaChannel, DiscordjsTypeError, MessageFlags } from 'discord.js';
+import { DataManager, RoleManager, Role, GuildChannel, GuildMember, User, BaseGuild, MessageMentions, ThreadChannel, Message, BaseGuildVoiceChannel, VoiceChannel, BaseChannel, MessageReaction, ChannelType, MediaChannel, ForumChannel, DirectoryChannel, StageChannel, NewsChannel, CategoryChannel, TextChannel, InteractionType, ComponentType, ApplicationCommandType, GuildMemberManager, GuildMemberRoleManager, GuildChannelManager, UserManager, ChannelManager, GuildManager, Guild, GuildBanManager, GuildBan, ThreadMemberManager, ThreadMember, GuildMessageManager, DMMessageManager, GuildTextThreadManager, GuildForumThreadManager, PermissionOverwriteManager, PermissionOverwrites, ReactionManager, ReactionUserManager, PresenceManager, Presence, GuildEmojiManager, GuildEmoji, GuildStickerManager, Sticker, GuildScheduledEventManager, GuildScheduledEvent, AutoModerationRuleManager, AutoModerationRule, GuildInviteManager, Invite, ApplicationCommandOptionType, CommandInteractionOptionResolver, Client, ApplicationCommandManager, ClientUser, CDN, AuthorizingIntegrationOwners, BaseInteraction, UserContextMenuCommandInteraction, MessageContextMenuCommandInteraction, Attachment, Locale, StringSelectMenuInteraction, UserSelectMenuInteraction, RoleSelectMenuInteraction, ChannelSelectMenuInteraction, MentionableSelectMenuInteraction, Collection, PermissionsBitField, Base, SnowflakeUtil, DMChannel, MessageFlagsBitField, BaseManager, Component, Embed, ActionRow, GuildEmojiRoleManager, ApplicationCommand, DiscordjsErrorCodes, DiscordjsTypeError, MessageFlags, DiscordjsError } from 'discord.js';
 import { createDiscordError } from './response.js';
 import { stampCall } from '../common/response/call-order.js';
-import { discordDefault, REAL_GETTER, placeholderValue } from './discord-defaults.js';
+import { discordDefaults, REAL_GETTER, placeholderValue } from './discord-defaults.js';
 import { Logger } from '../common/logger.js';
-import { warnOnce, warnPlaceholder } from '../common/deprecation.js';
+import { warnPlaceholder, warnOnce } from '../common/deprecation.js';
 import { embedsAsDiscordStores, asDiscordStores } from './discord-shape.js';
 import { nextSnowflake, MOCK_BOT_ID } from './snowflake.js';
 import { strictMocks, noteMockMade } from './strict-mocks.js';
-import { sharedName } from '../util/shared-state.util.js';
+import { RESPONSE_LOG } from './response-log.js';
 
 // ---------------------------------------------------------------------------
 // stubDeep — Proxy that answers each property it lacks: a mock fn for a method, a default, or a nested stub
@@ -25,8 +25,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();
@@ -91,7 +95,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 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;
         },
@@ -114,6 +118,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,
@@ -187,6 +192,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 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;
+    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;
@@ -331,28 +362,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 = [
+    [
+        GuildEmojiRoleManager,
+        new Set([
+            'set'
+        ])
+    ],
+    [
+        GuildMemberRoleManager,
+        new Set([
+            'set'
+        ])
+    ],
+    [
+        GuildScheduledEvent,
+        new Set([
+            'setStatus'
+        ])
+    ]
+];
 // The client user's presence setters, which apply at once and return the presence
 const SYNC_SETTERS = new Set([
     'setActivity',
@@ -377,27 +448,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(DMChannel);
-        channel.recipientId = user.id;
+        const made = createMockChannel(DMChannel);
+        // Getters in discord.js, so set through the mock, which defines them
+        made.recipientId = user.id;
+        if (user instanceof 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 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;
+        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 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 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 = {
+    [ChannelType.GuildText]: TextChannel,
+    [ChannelType.GuildVoice]: VoiceChannel,
+    [ChannelType.GuildCategory]: CategoryChannel,
+    [ChannelType.GuildAnnouncement]: NewsChannel,
+    [ChannelType.GuildStageVoice]: StageChannel,
+    [ChannelType.GuildDirectory]: DirectoryChannel,
+    [ChannelType.GuildForum]: ForumChannel,
+    [ChannelType.GuildMedia]: 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 ?? ChannelType.GuildText] ?? TextChannel;
+    if (Class === TextChannel || strictMocks()) return Class;
+    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 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 GuildChannel)) return createMockChannel(ThreadChannel, id ? {
+        id
+    } : {});
+    const guild = channel.guild;
+    const thread = createMockChannel(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 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 = [
     [
         UserManager,
@@ -439,9 +612,10 @@ const MANAGER_ITEMS = [
         ()=>createMockInteraction(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
     [
         GuildMessageManager,
-        (id, manager)=>createMockMessage({
+        (id, manager)=>madeIn(manager, id) ?? createMockMessage({
                 ...id ? {
                     id
                 } : {},
@@ -450,7 +624,7 @@ const MANAGER_ITEMS = [
     ],
     [
         DMMessageManager,
-        (id, manager)=>createMockMessage({
+        (id, manager)=>madeIn(manager, id) ?? createMockMessage({
                 ...id ? {
                     id
                 } : {},
@@ -459,15 +633,11 @@ const MANAGER_ITEMS = [
     ],
     [
         GuildTextThreadManager,
-        (id)=>createMockChannel(ThreadChannel, id ? {
-                id
-            } : {})
+        threadIn
     ],
     [
         GuildForumThreadManager,
-        (id)=>createMockChannel(ThreadChannel, id ? {
-                id
-            } : {})
+        threadIn
     ],
     [
         ThreadMemberManager,
@@ -493,7 +663,7 @@ const MANAGER_ITEMS = [
     ],
     [
         GuildChannelManager,
-        (id, manager)=>createMockChannel(TextChannel, {
+        (id, manager, options)=>createMockChannel(createdChannelClass(options?.type), {
                 ...id ? {
                     id
                 } : {},
@@ -501,9 +671,65 @@ const MANAGER_ITEMS = [
                     guild: guildOf(manager)
                 } : {}
             })
+    ],
+    [
+        GuildEmojiManager,
+        (id, manager)=>itemInGuild(GuildEmoji, {
+                id: id ?? nextSnowflake()
+            }, manager)
+    ],
+    [
+        GuildStickerManager,
+        (id, manager)=>itemInGuild(Sticker, {
+                id: id ?? nextSnowflake()
+            }, manager)
+    ],
+    [
+        GuildScheduledEventManager,
+        (id, manager)=>itemInGuild(GuildScheduledEvent, {
+                id: id ?? nextSnowflake()
+            }, manager)
+    ],
+    [
+        AutoModerationRuleManager,
+        (id, manager)=>itemInGuild(AutoModerationRule, {
+                id: id ?? nextSnowflake()
+            }, manager)
+    ],
+    // An invite is keyed by its code, as discord.js caches and fetches one
+    [
+        GuildInviteManager,
+        (code, manager)=>itemInGuild(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;
+    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)=>{
@@ -531,18 +757,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 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 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 UserManager && (key === 'createDM' || key === 'send')) {
+        return createMockFn(async (user, ...args)=>{
+            if (!strictMocks()) {
+                warnOnce(mockLogger, USER_MANAGER_DM_WARNINGS[key]);
+                return key === 'createDM' ? dmChannelOf(receiver()) : createMockMessage();
+            }
+            const named = user instanceof GuildMember ? user.user : user;
+            const id = typeof named === 'string' ? named : named?.id;
+            const resolved = named instanceof 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 User) {
         return createMockFn(async (...args)=>(await receiver().createDM()).send(...args));
@@ -552,6 +818,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 Collection());
     if (target instanceof 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
@@ -564,10 +831,27 @@ function fetchedIds(args) {
                         id,
                         one(id)
                     ]));
-                return ids === undefined ? new 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 GuildMessageManager || target instanceof DMMessageManager;
+                if (messages && strictMocks()) return recentMessages(receiver(), args[0]);
+                if (messages) warnUnlisted(receiver());
+                return new 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()) {
+                    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 GuildBanManager) {
             return createMockFn(async (user)=>{
@@ -576,11 +860,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 GuildInviteManager) {
+            return createMockFn(async (channel)=>{
+                const invite = item(undefined, receiver());
+                const channelId = typeof channel === 'string' ? channel : channel?.id;
+                const found = channel instanceof 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;
             });
@@ -772,10 +1068,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(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
@@ -792,24 +1084,36 @@ const isSnowflake = (id)=>typeof id === 'string' && /^\d{1,20}$/.test(id);
             };
             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);
             }
@@ -852,11 +1156,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;
+    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 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 === 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;
@@ -923,7 +1249,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()) {
+                    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(DiscordjsErrorCodes.InteractionAlreadyReplied);
         const notYetReplied = (method)=>discordjsError(DiscordjsErrorCodes.InteractionNotReplied, `Cannot call ${method}() before replying or deferring.`);
@@ -940,41 +1290,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 === 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 === 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;
-            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()) {
+                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;
+            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);
+            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.
@@ -987,32 +1353,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;
+        // 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 (ephemeral) instance.ephemeral = 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;
@@ -1024,7 +1450,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);
@@ -1063,7 +1489,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));
@@ -1077,7 +1502,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 ()=>{
@@ -1092,11 +1517,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();
@@ -1111,16 +1534,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 === InteractionType.ApplicationCommand || isComponent) {
-            answer('showModal', async ()=>undefined, first('showModal', 'replied', ()=>{
-                modalAnswered = instance.type === 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 === 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()));
         }
     }
@@ -1130,14 +1568,58 @@ function createMockInteraction(Class, props) {
     // it before answering would decide the window was already closed.
     if (instance.type === InteractionType.ApplicationCommandAutocomplete) {
         instance.responded = false;
-        stubs.set('respond', createMockFn(async (choices)=>{
-            if (instance.responded) throw discordjsError(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) {
+                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(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
@@ -1270,6 +1752,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;
@@ -1311,6 +1796,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 (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));
@@ -1328,7 +1818,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) {
+                        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
@@ -1658,6 +2156,10 @@ const HOLDS = [
         RoleManager.prototype,
         Role
     ],
+    [
+        GuildMemberRoleManager.prototype,
+        Role
+    ],
     [
         GuildChannelManager.prototype,
         GuildChannel
@@ -1713,18 +2215,46 @@ const HOLDS = [
     [
         PresenceManager.prototype,
         Presence
+    ],
+    [
+        GuildEmojiManager.prototype,
+        GuildEmoji
+    ],
+    [
+        GuildStickerManager.prototype,
+        Sticker
+    ],
+    [
+        GuildScheduledEventManager.prototype,
+        GuildScheduledEvent
+    ],
+    [
+        AutoModerationRuleManager.prototype,
+        AutoModerationRule
+    ],
+    [
+        GuildInviteManager.prototype,
+        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 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
     });
@@ -1733,7 +2263,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
     });
@@ -1754,13 +2284,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 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.
@@ -1770,14 +2346,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.
@@ -1803,7 +2383,7 @@ const HOLDS = [
     instance.members = managerWith(GuildMemberManager.prototype, overrides.members);
     instance.channels = managerWith(GuildChannelManager.prototype, overrides.channels);
     instance.roles = guildRoleManager(instance.id, overrides.roles);
-    instance.bans = managerWith(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
@@ -1847,7 +2427,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(TextChannel) || is(NewsChannel)) {
-        instance.messages = managerWith(GuildMessageManager.prototype, undefined);
+        instance.messages = messageManager(GuildMessageManager.prototype);
         instance.threads = managerWith(GuildTextThreadManager.prototype, undefined);
     }
     // Forum and media channels hold posts, each a thread started with its first message
@@ -1857,15 +2437,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(BaseGuildVoiceChannel)) {
-        instance.messages = managerWith(GuildMessageManager.prototype, undefined);
+        instance.messages = messageManager(GuildMessageManager.prototype);
         instance.bitrate = 64000;
         instance.userLimit = 0;
     }
     if (is(DMChannel)) {
-        instance.messages = managerWith(DMMessageManager.prototype, undefined);
+        instance.messages = messageManager(DMMessageManager.prototype);
     }
     if (is(ThreadChannel)) {
-        instance.messages = managerWith(GuildMessageManager.prototype, undefined);
+        instance.messages = messageManager(GuildMessageManager.prototype);
         instance.members = managerWith(ThreadMemberManager.prototype, undefined);
     }
     // A server's channel has its overwrites, none until a test puts some in the cache, which its permissions read
@@ -1970,6 +2550,7 @@ const CHANNEL_TYPE_GUARDS = [
                 id: entry
             }) : entry);
     const manager = Object.create(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
@@ -1977,6 +2558,15 @@ const CHANNEL_TYPE_GUARDS = [
         member: {
             value: member
         },
+        guild: {
+            get: ()=>member.guild
+        },
+        client: {
+            get: ()=>member.client
+        },
+        holds: {
+            value: holdsOf(GuildMemberRoleManager.prototype)
+        },
         highest: {
             get: highest
         }
@@ -2301,7 +2891,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.'
         ]
@@ -2427,7 +3017,7 @@ let placeReadsSeen;
     guild.members = managerWith(GuildMemberManager.prototype, undefined);
     guild.channels = managerWith(GuildChannelManager.prototype, undefined);
     guild.roles = guildRoleManager(guild.id, undefined);
-    guild.bans = managerWith(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;
@@ -2449,12 +3039,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',
+        GuildBanManager
+    ],
+    [
+        'emojis',
+        GuildEmojiManager
+    ],
+    [
+        'stickers',
+        GuildStickerManager
+    ],
+    [
+        'scheduledEvents',
+        GuildScheduledEventManager
+    ],
+    [
+        'autoModerationRules',
+        AutoModerationRuleManager
+    ],
+    [
+        'invites',
+        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;
 }
 /**
@@ -2503,9 +3120,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 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 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 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;
@@ -2533,19 +3179,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 Collection(guildCaches ? roles.map((id)=>[
                 id,
-                cached(guildCaches.roles, id, ()=>stubDeep(Object.assign(Object.create(Role.prototype), {
+                cached(guildCaches.roles, id, ()=>createMockInteraction(Role, {
                         id,
                         guild
-                    })))
+                    }))
             ]) : []),
         channels: new Collection(channels.map((id)=>[
                 id,
-                cached(guildCaches ? guildCaches.channels : cacheOf(client.channels), id, ()=>stubDeep(Object.assign(Object.create(TextChannel.prototype), {
+                cached(guildCaches ? guildCaches.channels : cacheOf(client.channels), id, ()=>createMockChannel(TextChannel, guild ? {
                         id,
                         guild
-                    })))
+                    } : {
+                        id
+                    }))
             ]))
     };
     // Own values, so the prototype's getters, which read the raw mention data, are not reached
@@ -2828,6 +3477,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;
 }
 /**
@@ -2876,7 +3526,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 BaseChannel;
     const dm = inChannel && channel.isDMBased();
     const strict = strictMocks();
@@ -2917,6 +3568,11 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
     if (typeof value === 'object' && value !== null) return ApplicationCommandOptionType.Mentionable;
     return ApplicationCommandOptionType.String;
 }
+/** The option types a user types into, which an autocomplete's focused option is one of. */ const TYPED = [
+    ApplicationCommandOptionType.String,
+    ApplicationCommandOptionType.Integer,
+    ApplicationCommandOptionType.Number
+];
 /** The discord.js classes an entity option's value is an instance of, each read by its own getters. */ const ENTITY_CLASSES = [
     User,
     GuildMember,
@@ -2969,7 +3625,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 = {
@@ -2982,7 +3638,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 GuildMember) {
         option.user = value.user;
@@ -2991,6 +3648,25 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
     else if (value instanceof BaseChannel) option.channel = value;
     else if (value instanceof 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;
 }
 /**
@@ -3016,8 +3692,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 = {
@@ -3052,7 +3728,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
@@ -3060,7 +3737,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.
@@ -3082,6 +3765,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)=>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(DiscordjsErrorCodes.CommandInteractionOptionNotFound, name);
@@ -3098,14 +3785,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, DiscordjsErrorCodes.CommandInteractionOptionNoSubcommandGroup, required));
     base.getSubcommand = createMockFn((required = true)=>resolveSubEntry(subcommand, 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(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(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(DiscordjsErrorCodes.CommandInteractionOptionEmpty, name, optionTypeOf(value));
+            return null;
+        }
         if (takes(value)) return value;
         if (required === true) throw typeError();
         return null;
@@ -3166,15 +3875,25 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
         ], plainOr(User, GuildMember));
         return value instanceof 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(User, GuildMember, Role), required));
+        ], plainOr(User, GuildMember, Role), required);
+        if (!(value instanceof User)) return value;
+        const member = memberOf(name, value);
+        if (member === null || strictMocks()) return member ?? value;
+        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(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, [
@@ -3183,20 +3902,41 @@ function messageMock(overrides = {}, sentBy, made = {}, at) {
     base.getFocused = createMockFn((getFull)=>{
         if (focused === null) throw optionError(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
+});
 
-export { NEW_SERVER_EVERYONE_PERMISSIONS, RESPONSE_LOG, botMemberOf, createChatInputOptions, createMock, createMockChannel, createMockClient, createMockGuild, createMockInteraction, createMockMember, createMockMessage, createMockRawMember, createMockUser, heldChannelOf, isRawMember, isUnsetEveryone, memberRoles, noteReactionDispatch, ownedManager, readPlaceAs };
+export { NEW_SERVER_EVERYONE_PERMISSIONS, botMemberOf, createChatInputOptions, createMock, createMockChannel, createMockClient, createMockGuild, createMockInteraction, createMockMember, createMockMessage, createMockRawMember, createMockUser, heldChannelOf, isRawMember, isUnsetEveryone, madeAt, memberRoles, noteReactionDispatch, ownedManager, readPlaceAs, readPlaceQuietly, returnsPromise };