meocord 4.2.0 → 4.2.2

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

@@ -1,14 +1,15 @@
 import 'reflect-metadata';
-import { createMockFn } 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, CommandInteractionOptionResolver, ApplicationCommandOptionType, Client, ApplicationCommandManager, ClientUser, CDN, AuthorizingIntegrationOwners, BaseInteraction, UserContextMenuCommandInteraction, Locale, StringSelectMenuInteraction, UserSelectMenuInteraction, RoleSelectMenuInteraction, ChannelSelectMenuInteraction, MentionableSelectMenuInteraction, Collection, MessageFlagsBitField, PermissionsBitField, Base, SnowflakeUtil, DMChannel, GuildMemberRoleManager, TextChannel, Component, Embed, Attachment, BaseManager, ApplicationCommand, NewsChannel, ForumChannel, MediaChannel, DiscordjsErrorCodes, DiscordjsTypeError } from 'discord.js';
+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, GuildEmojiManager, GuildEmoji, GuildStickerManager, Sticker, GuildScheduledEventManager, GuildScheduledEvent, AutoModerationRuleManager, AutoModerationRule, GuildInviteManager, Invite, 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 { createDiscordError } from './response.js';
 import { stampCall } from '../common/response/call-order.js';
-import { discordDefault, REAL_GETTER } from './discord-defaults.js';
+import { discordDefault, 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 { noteMockMade, strictMocks } from './strict-mocks.js';
+import { strictMocks, noteMockMade } from './strict-mocks.js';
+import { sharedName } from '../util/shared-state.util.js';
 
 // ---------------------------------------------------------------------------
 // stubDeep — Proxy that answers each property it lacks: a mock fn for a method, a default, or a nested stub
@@ -20,9 +21,15 @@ const SKIP = new Set([
     'toJSON',
     'then'
 ]);
+// Each mock's own instance, which the proxy's traps receive as their target
+const mockTargets = new WeakMap();
+// Warnings a read answered by the stub logs first, by the mock's instance and the property
+const stubReadWarnings = new WeakMap();
 function stubDeep(instance, externalStubs, onSet) {
     noteMockMade();
     const stubs = externalStubs ?? new Map();
+    // Placeholders read so far, by the value strict mocks give: a read of a kept one still warns, once
+    const placeholders = new Map();
     const proxy = new Proxy(instance, {
         get (target, prop) {
             // Always pass through symbols
@@ -36,12 +43,17 @@ function stubDeep(instance, externalStubs, onSet) {
             if (Object.prototype.hasOwnProperty.call(target, key)) {
                 return Reflect.get(target, prop, target);
             }
+            stubReadWarnings.get(target)?.get(key)?.();
             // Skip passthrough props — return prototype value as-is
             if (SKIP.has(key)) {
                 return Reflect.get(target, prop, target);
             }
             // Return cached stub
-            if (stubs.has(key)) return stubs.get(key);
+            if (stubs.has(key)) {
+                const kept = placeholders.get(key);
+                if (kept !== undefined) warnPlaceholderRead(target, key, kept);
+                return stubs.get(key);
+            }
             // A value discord.js always gives, in its shape, rather than a stub: kept once read, or its getter run live
             const known = discordDefault(target, key);
             if (known === REAL_GETTER) {
@@ -55,6 +67,12 @@ function stubDeep(instance, externalStubs, onSet) {
                 stubs.set(key, value);
                 return value;
             }
+            // A value strict mocks read as discord.js gives it, which is a placeholder otherwise
+            const strictValue = strictMocks() ? undefined : placeholderValue(target, key);
+            if (strictValue !== undefined) {
+                placeholders.set(key, strictValue);
+                warnPlaceholderRead(target, key, strictValue);
+            }
             // Walk the prototype chain to check if it's a function
             let proto = Object.getPrototypeOf(target);
             let protoValue;
@@ -65,7 +83,7 @@ function stubDeep(instance, externalStubs, onSet) {
                     if (desc.get && isPlaceholder(proto, key)) {
                         // Strict mocks run discord.js's getter, read live; otherwise the placeholder, with a warning once
                         if (strictMocks()) return Reflect.get(target, prop, proxy);
-                        warnBooleanPlaceholder(target, key);
+                        warnPlaceholderRead(target, key, 'false');
                     }
                     break;
                 }
@@ -73,7 +91,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)=>protoValue.apply(proxy, args)) : methodStub(target, key, protoValue, ()=>proxy) : stubDeep({});
+            const stub = typeof protoValue === 'function' ? isRealMethod(target, key) ? createMockFn((...args)=>quietly(target, key, ()=>protoValue.apply(proxy, args))) : methodStub(target, key, protoValue, ()=>proxy) : stubDeep({});
             stubs.set(key, stub);
             return stub;
         },
@@ -82,7 +100,10 @@ function stubDeep(instance, externalStubs, onSet) {
         // and a plain write against one of those throws. Defining an own
         // data property shadows the accessor, which is what test setup means.
         set (target, prop, value) {
-            Object.defineProperty(target, prop, {
+            // An own accessor with a setter, such as a context menu's target, takes the value itself
+            const setter = Object.getOwnPropertyDescriptor(target, prop)?.set;
+            if (setter) setter.call(target, value);
+            else Object.defineProperty(target, prop, {
                 value,
                 writable: true,
                 enumerable: true,
@@ -92,6 +113,7 @@ function stubDeep(instance, externalStubs, onSet) {
             return true;
         }
     });
+    mockTargets.set(proxy, instance);
     return proxy;
 }
 // discord.js methods that read only what the mock holds, so they run for real: looking items up in a manager's cache,
@@ -224,7 +246,8 @@ const PLACEHOLDER_BOOLEANS = new Map([
     [
         BaseGuildVoiceChannel.prototype,
         new Set([
-            'joinable'
+            'joinable',
+            'full'
         ])
     ],
     [
@@ -259,11 +282,42 @@ const PLACEHOLDER_BOOLEANS = new Map([
     return false;
 }
 const mockLogger = new Logger('Mocks');
-function warnBooleanPlaceholder(target, key) {
+// Mock reactions, and their messages, that MeoCord's dispatcher reads `partial` on
+const dispatchedReactions = new WeakSet();
+let quiet = 0;
+/**
+ * Runs a real method, keeping quiet about the placeholders `mentions.has()` reads: a placeholder `repliedUser` matches
+ * no user, so its answer is discord.js's either way.
+ */ function quietly(target, key, run) {
+    if (!(target instanceof MessageMentions && key === 'has')) return run();
+    quiet++;
+    try {
+        return run();
+    } finally{
+        quiet--;
+    }
+}
+/**
+ * Marks a mock reaction and its message as read by MeoCord's dispatcher, so a placeholder `partial` it reads warns
+ * that MeoCord read it, and fetched for it.
+ */ function noteReactionDispatch(reaction) {
+    const target = mockTargets.get(reaction);
+    if (!target) return;
+    dispatchedReactions.add(target);
+    const message = mockTargets.get(reaction.message ?? {});
+    if (message) dispatchedReactions.add(message);
+}
+function warnPlaceholderRead(target, key, strictValue) {
+    if (quiet > 0) return;
     const name = Object.getPrototypeOf(target).constructor.name;
+    if (key === 'partial' && dispatchedReactions.has(target)) {
+        const fetched = target instanceof MessageReaction ? 'the reaction' : "the reaction's message";
+        warnPlaceholder(mockLogger, `${name}.${key}`, 'the mock computes it as discord.js does', `MeoCord's dispatcher read it while dispatching the reaction, and fetched ${fetched} since the placeholder is truthy. ` + 'Set reaction.partial = false and reaction.message.partial = false on the mock, or call useStrictMocks() to have the mock compute them now.');
+        return;
+    }
     // The class name in camel case, a leading acronym included: dmChannel, guildMember
     const variable = name.replace(/^[A-Z]+(?=[A-Z][a-z])|^[A-Z]/, (start)=>start.toLowerCase());
-    warnPlaceholder(mockLogger, `${name}.${key}`, 'the mock computes it as discord.js does', `Set it on the mock, such as ${variable}.${key} = false, to test either way, or call useStrictMocks() to have the mock compute it now.`);
+    warnPlaceholder(mockLogger, `${name}.${key}`, 'the mock computes it as discord.js does', `Set it on the mock, such as ${variable}.${key} = ${strictValue}, to test either way, or call useStrictMocks() to have the mock compute it now.`);
 }
 // The client of a structure made without one: the one its guild has, else one of its own, made once
 const ownClients = new WeakMap();
@@ -371,25 +425,37 @@ const MANAGER_ITEMS = [
     ],
     [
         RoleManager,
-        (id)=>createMockInteraction(Role, id ? {
-                id
-            } : {})
+        (id, manager)=>createMockInteraction(Role, {
+                ...id ? {
+                    id
+                } : {},
+                ...guildOf(manager) ? {
+                    guild: guildOf(manager)
+                } : {}
+            })
     ],
     [
         GuildBanManager,
         ()=>createMockInteraction(GuildBan)
     ],
+    // A message fetched from a channel is in it, and another user's
     [
         GuildMessageManager,
-        (id)=>createMockMessage(id ? {
-                id
-            } : {})
+        (id, manager)=>createMockMessage({
+                ...id ? {
+                    id
+                } : {},
+                ...channelOfManager(manager)
+            })
     ],
     [
         DMMessageManager,
-        (id)=>createMockMessage(id ? {
-                id
-            } : {})
+        (id, manager)=>createMockMessage({
+                ...id ? {
+                    id
+                } : {},
+                ...channelOfManager(manager)
+            })
     ],
     [
         GuildTextThreadManager,
@@ -407,6 +473,12 @@ const MANAGER_ITEMS = [
         ThreadMemberManager,
         ()=>createMockInteraction(ThreadMember)
     ],
+    [
+        ReactionUserManager,
+        (id)=>createMockUser(id ? {
+                id
+            } : {})
+    ],
     [
         ApplicationCommandManager,
         (id)=>createMockInteraction(ApplicationCommand, id ? {
@@ -429,11 +501,58 @@ 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)
     ]
 ];
+/** 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
+        } : {}
+    });
+}
 const returnsPromise = (key, method)=>method.constructor.name === 'AsyncFunction' || PROMISE_METHODS.has(key) || /^set[A-Z]/.test(key) && !SYNC_SETTERS.has(key);
 // The ids a fetch asks for: an id, a discord.js object, or options naming one or several, such as `{ user: id }` or
 // `{ user: [ids] }`; undefined for a fetch of a list
+/** The channel a message manager belongs to, as `createMockMessage` takes it. */ const channelOfManager = (manager)=>{
+    const channel = manager.channel;
+    return channel instanceof BaseChannel ? {
+        channel: channel
+    } : {};
+};
 function fetchedIds(args) {
     const idOf = (value)=>typeof value === 'string' ? value : value instanceof Base ? value.id : undefined;
     const [first] = args;
@@ -469,6 +588,10 @@ function fetchedIds(args) {
     if (key === 'send' && target instanceof User) {
         return createMockFn(async (...args)=>(await receiver().createDM()).send(...args));
     }
+    // A channel's send resolves to the message it sent there
+    if (key === 'send' && target instanceof BaseChannel) {
+        return createMockFn(async (options)=>sentMessage(sent(options, false), receiver()));
+    }
     if (MESSAGE_METHODS.has(key)) return createMockFn(async ()=>createMockMessage());
     if (target instanceof BaseManager) {
         const item = MANAGER_ITEMS.find(([Manager])=>Manager.prototype.isPrototypeOf(target))?.[1];
@@ -485,7 +608,36 @@ function fetchedIds(args) {
                 return ids === undefined ? new Collection() : one(ids);
             });
         }
-        if (item && (key === 'create' || key === 'edit')) return createMockFn(async ()=>item(undefined, receiver()));
+        if (item && key === 'edit') return createMockFn(async ()=>item(undefined, receiver()));
+        // A ban resolves to the member, user or id it was given, as discord.js's does, and caches nothing
+        if (key === 'create' && target instanceof GuildBanManager) {
+            return createMockFn(async (user)=>{
+                if (user instanceof GuildMember) return user;
+                if (user instanceof User) return receiver().guild.members.resolve(user) ?? user;
+                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());
+                if (typeof made.id === 'string') cacheOf(receiver())?.set(made.id, made);
+                return made;
+            });
+        }
     } else if (target instanceof Base && (SELF_METHODS.has(key) || /^set[A-Z]/.test(key))) {
         return createMockFn(async ()=>receiver());
     }
@@ -645,14 +797,46 @@ const isSnowflake = (id)=>typeof id === 'string' && /^\d{1,20}$/.test(id);
         });
     }
 }
-/** Where a mock interaction keeps every answer it got, through respond() or discord.js directly, in order. */ const RESPONSE_LOG = Symbol('response log');
+/**
+ * Gives a user, server or channel mock its creation time. Under strict mocks, a generated id gives the time the mock
+ * was made, as a message's. Otherwise it gives that id's own time, a fixed day in 2025, with a warning once when read.
+ * An id the test gives decides it in both modes, and a value the test sets replaces it.
+ */ function defineMadeTime(mock, generatedId) {
+    if (strictMocks()) return defineCreatedTime(mock, generatedId);
+    const own = (key)=>Object.prototype.hasOwnProperty.call(mock, key);
+    const name = Object.getPrototypeOf(mock).constructor.name;
+    if (!own('createdTimestamp')) {
+        Object.defineProperty(mock, 'createdTimestamp', {
+            get () {
+                if (this.id === generatedId) {
+                    warnOnce(mockLogger, `${name}.createdTimestamp reads the time of its generated id here, a fixed day in 2025; in the next major version (5.0) ` + 'it is the time the mock was made. Give the mock an id or a createdTimestamp, or call useStrictMocks() to have it read the time the mock was made now.');
+                }
+                return isSnowflake(this.id) ? SnowflakeUtil.timestampFrom(this.id) : null;
+            },
+            configurable: true
+        });
+    }
+    if (!own('createdAt')) {
+        Object.defineProperty(mock, 'createdAt', {
+            get () {
+                return this.createdTimestamp === null ? null : new Date(this.createdTimestamp);
+            },
+            configurable: true
+        });
+    }
+}
+/**
+ * Where a mock interaction keeps every answer it got, through respond() or discord.js directly, in order, under a key
+ * both builds of this meocord version read.
+ */ const RESPONSE_LOG = Symbol.for(sharedName('responseLog'));
 /**
  * A mock of an answer method, `impl` its behaviour, that records each call in `log` as it is made, with what it sent
  * and, once it settles, what it rejected with. The record wraps every behaviour the mock is given, its own and any a
- * test sets, so the mock stays the plain mock function a runner's matchers read, bun's included. `withResponse` is how
- * a call asks discord.js for the message back, not part of what it sends, so it is left out.
- */ function recordedMock(method, impl, log) {
-    const record = (behaviour)=>function(...args) {
+ * test sets, so the mock stays the plain mock function a runner's matchers read, bun's included, and `gate` keeps the
+ * reply state whichever behaviour runs. `withResponse` is how a call asks discord.js for the message back, not part of
+ * what it sends, so it is left out.
+ */ function recordedMock(method, impl, log, gate) {
+    const record = (behaviour, byTest = true)=>function(...args) {
             const [payload] = args;
             const sent = payload && typeof payload === 'object' && 'withResponse' in payload ? Object.fromEntries(Object.entries(payload).filter(([key])=>key !== 'withResponse')) : payload;
             const call = {
@@ -661,22 +845,41 @@ const isSnowflake = (id)=>typeof id === 'string' && /^\d{1,20}$/.test(id);
             };
             stampCall(call);
             log.push(call);
+            let gated;
             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, (error)=>{
-                        call.error = error;
-                        throw error;
-                    });
-                }
-                return result;
+                // 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)=>{
+                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(landed, failed);
+                return landed(result);
+            } catch (error) {
+                return failed(error);
             }
         };
-    const mock = createMockFn(record(impl));
+    const mock = createMockFn(record(impl, false));
     const always = mock.mockImplementation.bind(mock);
     const once = mock.mockImplementationOnce.bind(mock);
     // Each way a test sets a behaviour goes through the record, a runner's own extras included where it has them
@@ -709,16 +912,26 @@ const isSnowflake = (id)=>typeof id === 'string' && /^\d{1,20}$/.test(id);
     return mock;
 }
 /** The interaction a mock options resolver was given to, for the server a user option's member is in. */ const optionOwners = new WeakMap();
+/** An error as discord.js throws it, with its code, and with `message` in place of discord.js's own text when given. */ function discordjsError(code, message) {
+    const error = new DiscordjsError(code);
+    if (message !== undefined) error.message = message;
+    return error;
+}
 /** An error as discord.js's options resolver throws it: a `TypeError` with discord.js's code and message. */ const optionError = (code, ...args)=>new DiscordjsTypeError(code, ...args);
 // In discord.js's error codes, though missing from its typings
 const INVALID_CHANNEL_TYPE = 'CommandInteractionOptionInvalidChannelType';
 /** Records the interaction a mock options resolver belongs to. */ const ownOptions = (interaction, options)=>{
     if (typeof options === 'object' && options !== null) optionOwners.set(options, interaction);
 };
-/** A mock user that is a person, with an id of its own unless given one. */ const mockUser = (id = nextSnowflake())=>stubDeep(Object.assign(Object.create(User.prototype), {
-        id,
+/** A mock user that is a person, with an id of its own unless given one. */ const mockUser = (id)=>{
+    const generatedId = id === undefined ? nextSnowflake() : undefined;
+    const user = Object.assign(Object.create(User.prototype), {
+        id: id ?? generatedId,
         bot: false
-    }));
+    });
+    defineMadeTime(user, generatedId);
+    return stubDeep(user);
+};
 function createMockInteraction(Class, props) {
     const instance = Object.create(Class.prototype);
     const stubs = new Map();
@@ -738,14 +951,36 @@ function createMockInteraction(Class, props) {
     // mock lacks: a guildId is a guild, a guild object with it a cached one, neither a DM. A member
     // not given is the user's on an interaction, and the auto-stub elsewhere, so only one set to null or undefined fails.
     const own = (key)=>Object.prototype.hasOwnProperty.call(instance, key) ? instance[key] : undefined;
+    let strictPlace;
     const hasMember = ()=>!Object.prototype.hasOwnProperty.call(instance, 'member') || Boolean(instance.member);
     const guildChecks = {
         inGuild: ()=>Boolean(own('guildId') && hasMember()),
         inCachedGuild: ()=>Boolean(own('guildId') && own('guild') && hasMember()),
         inRawGuild: ()=>Boolean(own('guildId') && !own('guild') && hasMember())
     };
+    // What each answers where strict mocks place the mock: the place's guildId and guild for those the test left out, and
+    // a member wherever there is a guildId, unless the test gave one
+    const given = new Set(Object.keys(props ?? {}));
+    const strictChecks = (place)=>{
+        const pick = (key, placed)=>given.has(key) || placed === undefined ? own(key) : placed;
+        const guildId = pick('guildId', place.guildId);
+        const guild = place.raw ? null : pick('guild', place.guild);
+        const member = given.has('member') ? Boolean(own('member')) : Boolean(guildId);
+        return {
+            inGuild: Boolean(guildId && member),
+            inCachedGuild: Boolean(guildId && guild && member),
+            inRawGuild: Boolean(guildId && !guild && member)
+        };
+    };
+    // Each reads where the mock is as its own, and in default mode warns once, by its own name, where strict mocks answer
+    // otherwise or refuse the mock
     for (const [name, check] of Object.entries(guildChecks)){
-        if (findPrototypeMethod(instance, name) !== null) stubs.set(name, createMockFn(check));
+        if (findPrototypeMethod(instance, name) === null) continue;
+        stubs.set(name, createMockFn(()=>{
+            const answer = readPlaceQuietly(check);
+            if (strictPlace && !strictMocks() && (strictPlace.refused || strictChecks(strictPlace)[name] !== answer)) placeWarners.get(instance)?.warn(`${name}()`);
+            return answer;
+        }));
     }
     // Set up reply state machine for repliable interactions
     const isRepliableMethod = findPrototypeMethod(instance, 'isRepliable');
@@ -753,84 +988,285 @@ function createMockInteraction(Class, props) {
     if (repliable) {
         instance.replied = false;
         instance.deferred = false;
-        instance.ephemeral = false;
-        const alreadyReplied = ()=>new Error('The reply to this interaction has already been sent or deferred.');
-        const notYetReplied = (method)=>new Error(`Cannot call ${method}() before replying or deferring.`);
+        // 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.`);
         // Only `flags` is read: discord.js deprecates the `ephemeral: true` reply option, and honouring it here would let
-        // a test pass against a deprecated call.
+        // a test pass against a deprecated call. Read as discord.js reads them, so a flag it refuses throws here too.
         const hasEphemeralFlag = (options)=>{
-            if (!options) return false;
-            const { flags } = options;
-            if (typeof flags === 'number') return (flags & 64) !== 0;
-            if (typeof flags === 'bigint') return (flags & 64n) !== 0n;
-            return false;
+            const flags = options?.flags;
+            if (typeof options !== 'object' || flags === null || flags === undefined) return false;
+            return new MessageFlagsBitField(flags).has(MessageFlags.Ephemeral);
         };
+        const built = (held)=>typeof held === 'function' ? held() : held;
+        let original;
+        let originalGone = false;
+        const followUps = new Map();
+        // Whether the last answer ran a behaviour a test set, after which a second answer runs with a warning by default
+        let answeredByTest = false;
+        // A command answered with a modal has no original response, and Discord refuses one asked for
+        let modalAnswered = false;
+        const isComponent = instance.type === InteractionType.MessageComponent;
+        // The original response of a component, or of a modal submitted from one, is the message it's on
+        const componentMessage = ()=>heldFrom(instance.message);
+        const snapshot = ()=>{
+            const saved = {
+                replied: instance.replied,
+                deferred: instance.deferred,
+                ephemeral,
+                ephemeralDecided,
+                answeredByMock,
+                original,
+                originalGone,
+                followUps: new Map(followUps),
+                answeredByTest,
+                modalAnswered
+            };
+            return ()=>{
+                Object.assign(instance, {
+                    replied: saved.replied,
+                    deferred: saved.deferred
+                });
+                decideEphemeral(saved.ephemeral, saved.ephemeralDecided);
+                ({ original, originalGone, answeredByTest, answeredByMock, modalAnswered } = saved);
+                followUps.clear();
+                for (const [id, held] of saved.followUps)followUps.set(id, held);
+            };
+        };
+        /**
+     * Refuses an answer as discord.js does. Where the refusal turns on a behaviour a test set, this answer's or the
+     * one before it, which ran without one, default mode warns and lets it run; strict mocks refuse it.
+     */ const refuse = (method, error, byTest)=>{
+            if (!(byTest || answeredByTest) || strictMocks()) throw error;
+            warnOnce(mockLogger, `${method}() here is refused by discord.js with "${error.message}", but the mock runs it, as a test set this ` + 'answer or the one before it. In the next major version (5.0) the mock refuses it; call useStrictMocks() to ' + 'have it refused now.');
+        };
+        const answered = ()=>instance.deferred || instance.replied;
+        /**
+     * What an answer sends, built now, as discord.js builds it when sending. One it refuses to build is refused under
+     * strict mocks; default mode warns and holds it to build when first read.
+     */ const hold = (method, build)=>{
+            try {
+                return build();
+            } catch (error) {
+                if (strictMocks()) throw error;
+                warnOnce(mockLogger, `${method}() here sends what discord.js refuses to build: "${error.message}". The mock sends it and ` + 'builds it when read; in the next major version (5.0) it rejects, as discord.js does. Call useStrictMocks() to ' + 'have it rejected now.');
+                return build;
+            }
+        };
+        // 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;
+                }
+                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);
+                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);
+                } catch (error) {
+                    undo();
+                    throw error;
+                }
+                return {
+                    undo: undoneInTurn(undo)
+                };
+            };
+        /** The id an edit, fetch or delete names, `undefined` for the original response. */ const targetId = (message)=>{
+            if (message === undefined || message === '@original') return undefined;
+            return typeof message === 'string' ? message : message.id ?? undefined;
+        };
+        /** The message an edit, fetch or delete reaches, or why Discord refuses it: it is gone or never was. */ const target = (id)=>{
+            if (id !== undefined) {
+                const held = followUps.get(id);
+                if (held) followUps.set(id, built(held));
+                return held && built(held);
+            }
+            if (originalGone || modalAnswered) return undefined;
+            // Answered without one of the mock's calls, as after a 40060 or a test setting `replied`: the original is there
+            if (!original && answered()) original = componentMessage();
+            if (original) original = built(original);
+            // An answer's message gets its id when first read, as it would be built then without strict mocks
+            if (original?.id === '') original = {
+                ...original,
+                id: nextSnowflake()
+            };
+            return original;
+        };
+        const unknownMessage = ()=>createDiscordError(10008, 'Unknown Message');
+        // Where its answers are sent, read as the mock's own, so a placement warning stays the test's
+        const answeredIn = ()=>readPlaceQuietly(()=>[
+                    instance.channel,
+                    instance.client
+                ]);
+        // What each answer's message made for itself, by its id, so every read of it has the same author and place
+        const madePlaces = new Map();
+        const madeFor = (id)=>madePlaces.get(id) ?? madePlaces.set(id, {}).get(id);
+        // Each call's message, read by its behaviour right after the gate made it
+        let made;
+        let followUpMade;
         // Every answer the interaction gets, through respond() or discord.js directly, in order, for getResponse
         const log = [];
         Object.defineProperty(instance, RESPONSE_LOG, {
             value: log
         });
-        const answer = (method, impl)=>stubs.set(method, recordedMock(method, impl, log));
-        answer('reply', async (...args)=>{
-            if (instance.deferred || instance.replied) throw alreadyReplied();
+        const answer = (method, impl, gate)=>stubs.set(method, recordedMock(method, impl, log, gate));
+        answer('reply', async ()=>undefined, first('reply', 'replied', ([options])=>original = hold('reply', ()=>sent(options, false))));
+        answer('deferReply', async ()=>undefined, first('deferReply', 'deferred', ()=>original = sent(undefined)));
+        answer('followUp', // The follow-up as sent, which an edit, fetch or delete reaches by its id
+        async ()=>{
+            const held = followUps.get(followUpMade);
+            // One held to build when read resolves to its id alone, as building it now would refuse it
+            return typeof held === 'function' ? createMockMessage({
+                id: followUpMade
+            }) : messageFrom(held, madeFor(held.id), ...answeredIn());
+        }, later('followUp', ([options])=>{
             instance.replied = true;
-            if (hasEphemeralFlag(args[0])) instance.ephemeral = true;
-        });
-        answer('deferReply', async (...args)=>{
-            if (instance.deferred || instance.replied) throw alreadyReplied();
-            instance.deferred = true;
-            if (hasEphemeralFlag(args[0])) instance.ephemeral = true;
-        });
-        answer('followUp', async ()=>{
-            if (!instance.deferred && !instance.replied) throw notYetReplied('followUp');
-            instance.replied = true;
-            return createMockMessage();
-        });
-        // The interaction's own message as Discord holds it: the message a component is on, or the original response.
-        // An edit replaces it in the shape Discord stores, with ids and resolved media, stamped with when it was edited,
-        // and fetchReply() reads that back, so code comparing the two sees what it would against Discord.
-        let held;
-        const current = ()=>held ?? (held = heldFrom(instance.message));
-        // A command answered with a modal has no original response, and Discord refuses one asked for
-        let modalAnswered = false;
-        const unknownMessage = ()=>createDiscordError(10008, 'Unknown Message');
-        answer('editReply', async (options)=>{
-            if (!instance.deferred && !instance.replied) throw notYetReplied('editReply');
-            if (modalAnswered) throw unknownMessage();
-            instance.replied = true;
-            held = edited(current(), options);
-            // The response has the message as Discord answers the edit, before its uploaded files have loaded again
-            return messageFrom({
+            // Held as it is when sent, as Discord stores it, so a later change to what was passed isn't seen; its id taken
+            // once built, so one that fails to build under strict mocks takes none
+            const held = hold('followUp', ()=>sent(options, false));
+            const id = nextSnowflake();
+            made = undefined;
+            followUps.set(id, typeof held === 'function' ? ()=>({
+                    ...held(),
+                    id
+                }) : {
                 ...held,
-                components: held.returned ?? held.components
+                id
             });
-        });
-        stubs.set('fetchReply', createMockFn(async ()=>{
-            if (modalAnswered) throw unknownMessage();
-            return messageFrom(current());
+            followUpMade = id;
+        }));
+        // An edit replaces the message in the shape Discord stores, with ids and resolved media, stamped with when it was
+        // edited, and fetchReply() reads that back, so code comparing the two sees what it would against Discord
+        answer('editReply', async ()=>{
+            if (!made) throw unknownMessage();
+            // The response has the message as Discord answers the edit, before its uploaded files have loaded again
+            return messageFrom({
+                ...made,
+                components: made.returned ?? made.components
+            }, madeFor(made.id), ...answeredIn());
+        }, later('editReply', ([options])=>{
+            const id = targetId(options?.message);
+            const held = target(id);
+            made = held && edited(held, options);
+            if (!made) return;
+            if (id === undefined) {
+                original = made;
+                instance.replied = true;
+            } else followUps.set(id, made);
+        }));
+        stubs.set('fetchReply', createMockFn(async (message)=>{
+            const held = target(targetId(message));
+            if (!held) throw unknownMessage();
+            return messageFrom(held, madeFor(held.id), ...answeredIn());
         }));
         answer('deleteReply', async ()=>{
-            if (!instance.deferred && !instance.replied) throw notYetReplied('deleteReply');
-            if (modalAnswered) throw unknownMessage();
-        });
+            if (!made) throw unknownMessage();
+        }, later('deleteReply', ([message])=>{
+            const id = targetId(message);
+            made = target(id);
+            if (!made) return;
+            if (id === undefined) originalGone = true;
+            else followUps.delete(id);
+        }));
         // showModal — the first response of a command or a component, like reply()
-        if (instance.type === InteractionType.ApplicationCommand || instance.type === InteractionType.MessageComponent) {
-            answer('showModal', async ()=>{
-                if (instance.deferred || instance.replied) throw alreadyReplied();
-                instance.replied = true;
+        if (instance.type === InteractionType.ApplicationCommand || isComponent) {
+            answer('showModal', async ()=>undefined, first('showModal', 'replied', ()=>{
                 modalAnswered = instance.type === InteractionType.ApplicationCommand;
-            });
+                if (isComponent) original = componentMessage();
+            }));
         }
         // deferUpdate / update — components, and modals submitted from a message's component
-        if (instance.type === InteractionType.MessageComponent || instance.type === InteractionType.ModalSubmit) {
-            answer('update', async ()=>{
-                if (instance.deferred || instance.replied) throw alreadyReplied();
-                instance.replied = true;
-            });
-            answer('deferUpdate', async ()=>{
-                if (instance.deferred || instance.replied) throw alreadyReplied();
-                instance.deferred = true;
-            });
+        if (isComponent || instance.type === InteractionType.ModalSubmit) {
+            answer('update', async ()=>undefined, first('update', 'replied', ([options])=>original = hold('update', ()=>edited(heldFrom(instance.message, false), options))));
+            answer('deferUpdate', async ()=>undefined, first('deferUpdate', 'deferred', ()=>original = componentMessage()));
         }
     }
     // Autocomplete is not repliable, but it has a response of its own: Discord accepts
@@ -839,12 +1275,31 @@ function createMockInteraction(Class, props) {
     // it before answering would decide the window was already closed.
     if (instance.type === InteractionType.ApplicationCommandAutocomplete) {
         instance.responded = 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
+        let respondsInFlight = 0;
+        let respondWarned = false;
         stubs.set('respond', createMockFn(async (choices)=>{
-            if (instance.responded) throw new Error('The reply to this interaction has already been sent or deferred.');
+            if (instance.responded) {
+                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);
+            }
             // 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.`);
             }
+            respondsInFlight++;
+            if (!strictMocks()) instance.responded = true;
+            try {
+                await undefined;
+            } finally{
+                respondsInFlight--;
+            }
+            if (!strictMocks()) return;
+            if (instance.responded) throw createDiscordError(40060, 'Interaction has already been acknowledged.');
             instance.responded = true;
         }));
     }
@@ -869,6 +1324,34 @@ function createMockInteraction(Class, props) {
         const unset = (key)=>!Object.prototype.hasOwnProperty.call(instance, key);
         const generatedId = unset('id') ? instance.id = nextSnowflake() : undefined;
         defineCreatedTime(instance, generatedId);
+        // Strict mocks place it where its message, guild or member is, and a guildId alone in a server the bot isn't in
+        // Read as the mock's own, so a message's placement warning stays the test's
+        strictPlace = readPlaceQuietly(()=>strictPlaceOf(own));
+        if (strictPlace && strictMocks()) {
+            if (strictPlace.refused) throw new Error(strictPlace.refused);
+            const set = (key, value)=>Object.defineProperty(instance, key, {
+                    value,
+                    writable: true,
+                    enumerable: true,
+                    configurable: true
+                });
+            if (strictPlace.channel && unset('channel')) set('channel', strictPlace.channel);
+            if (strictPlace.guildId !== undefined && unset('guildId')) set('guildId', strictPlace.guildId);
+            if (strictPlace.guild !== undefined && unset('guild')) set('guild', strictPlace.guild);
+            if (strictPlace.raw) {
+                const user = own('user');
+                const rawUser = user && {
+                    id: user.id,
+                    username: user.username,
+                    global_name: user.globalName ?? null,
+                    discriminator: user.discriminator,
+                    avatar: user.avatar ?? null
+                };
+                set('member', createMockRawMember(rawUser ? {
+                    user: rawUser
+                } : {}));
+            }
+        }
         // A raw member is from a server the bot isn't in: no cached guild, and its user the interaction's, as discord.js reads it
         const raw = own('member');
         // Given with a guild, a raw-shaped member is kept as the cached server's member it was before raw members
@@ -951,12 +1434,13 @@ function createMockInteraction(Class, props) {
                 configurable: true
             });
         }
-        // The channel it came from, as the gateway caches it for an interaction: one of its server's, or the user's DM
+        // The channel it came from, as the gateway caches it for an interaction: its server's cached one, looked up on each
+        // read so a channel the test caches later is the one read, or the user's DM
         let channel;
         if (unset('channel')) {
             Object.defineProperty(instance, 'channel', {
                 get: ()=>{
-                    if (channel === undefined) {
+                    if (channel === undefined || own('guildId') && own('guild') instanceof Guild) {
                         channel = channelFor(own('guild'), own('guildId'), own('channelId'), own('user'));
                         cacheChannel(channel, own('guild'), own('client'));
                     }
@@ -1011,7 +1495,73 @@ function createMockInteraction(Class, props) {
                 live('targetMember', ()=>own('guildId') ? memberFor(own('guild'), targetUser(), true, own('guildId')) : null);
             }
         }
+        // A message context menu's target: the message given, else one made for its targetId. The message is the one
+        // source: targetId reads its id, and setting either one moves the other with it
+        if (MessageContextMenuCommandInteraction.prototype.isPrototypeOf(instance)) {
+            let given = own('targetMessage');
+            let explicitId = own('targetId');
+            if (given && given.id === undefined) given.id = nextSnowflake();
+            if (given && explicitId !== undefined && explicitId !== given.id) {
+                const conflict = `The targetMessage given is message ${given.id}, but the mock's targetId is ${explicitId}: give the same id, or leave one of them out.`;
+                if (strictMocks()) throw new Error(conflict);
+                warnOnce(mockLogger, `${conflict} The mock reads targetMessage's id; under useStrictMocks(), as in the next major version (5.0), it refuses the pair.`);
+                explicitId = undefined;
+            }
+            const generated = given || explicitId !== undefined ? undefined : nextSnowflake();
+            let made;
+            const accessor = (key, get, set)=>Object.defineProperty(instance, key, {
+                    get,
+                    set,
+                    enumerable: true,
+                    configurable: true
+                });
+            const targetId = ()=>explicitId ?? given?.id ?? generated;
+            accessor('targetId', targetId, (value)=>{
+                explicitId = value;
+                given = undefined;
+            });
+            // In the channel the menu was used in, and its server, as the message a menu is used on is: its channel is the
+            // menu's, read live, so making the message makes and caches no channel. Read as the mock's own, so a placement
+            // warning stays the test's
+            const makeTarget = ()=>readPlaceQuietly(()=>{
+                    const [guild, guildId] = [
+                        own('guild'),
+                        own('guildId') ?? null
+                    ];
+                    const message = messageMock({
+                        id: targetId(),
+                        guild: guildId && guild instanceof Guild ? guild : null,
+                        client: instance.client
+                    }, undefined, {}, {
+                        channelId: own('channelId'),
+                        guildId,
+                        channel: ()=>readPlaceQuietly(()=>instance.channel)
+                    });
+                    // Where strict mocks place the menu elsewhere, its target's place warns as the menu's does, by the target's name
+                    const warner = placeWarners.get(instance);
+                    const target = mockTargets.get(message) ?? message;
+                    for (const key of warner?.keys ?? [])warnOnRead(target, key, ()=>readingPlace > 0 ? void placeReadsSeen?.add(key) : warner.warn(`targetMessage.${key}`));
+                    return message;
+                });
+            accessor('targetMessage', ()=>given ?? (made?.id === targetId() ? made : made = makeTarget()), (value)=>{
+                given = value;
+                if (given && given.id === undefined) given.id = nextSnowflake();
+                explicitId = undefined;
+            });
+        }
+    }
+    // A user has an id of its own, as Discord sends one, and was created when the mock was made under strict mocks
+    if (User.prototype.isPrototypeOf(instance) && !Object.prototype.hasOwnProperty.call(instance, 'id')) {
+        const generatedId = instance.id = nextSnowflake();
+        defineMadeTime(instance, generatedId);
+    }
+    // A role too, created when the mock was made in both modes
+    if (Role.prototype.isPrototypeOf(instance) && !Object.prototype.hasOwnProperty.call(instance, 'id')) {
+        const generatedId = instance.id = nextSnowflake();
+        defineCreatedTime(instance, generatedId);
     }
+    // An attachment too, from the same count as every mock's
+    if (Attachment.prototype.isPrototypeOf(instance) && !Object.prototype.hasOwnProperty.call(instance, 'id')) instance.id = nextSnowflake();
     // Discord sends the user's locale with every interaction, and the server's preferred one with one made in a server
     if (BaseInteraction.prototype.isPrototypeOf(instance)) {
         if (own('locale') === undefined) instance.locale = Locale.EnglishUS;
@@ -1035,6 +1585,32 @@ function createMockInteraction(Class, props) {
         }
         for (const kind of choices)if (!Object.prototype.hasOwnProperty.call(instance, kind)) instance[kind] = new Collection();
     }
+    // In default mode, where strict mocks place it elsewhere, reading where it is warns
+    if (strictPlace && !strictMocks()) warnOnPlaceReads(instance, strictPlace, new Set(Object.keys(props ?? {})));
+    // A message whose place the mock made moves to where the test placed the interaction under strict mocks, and is then
+    // one the test placed; in default mode it stays, and reading its place warns
+    const message = own('message');
+    const placed = [
+        'channel',
+        'guild',
+        'guildId'
+    ].some((key)=>Object.keys(props ?? {}).includes(key));
+    if (BaseInteraction.prototype.isPrototypeOf(instance) && placed && typeof message === 'object' && message !== null && placeWasMade(message)) {
+        if (strictMocks()) {
+            const guild = own('guild');
+            const channel = instance.channel;
+            Object.assign(message, {
+                guild: guild ?? null,
+                guildId: own('guildId') ?? null,
+                ...channel && {
+                    channel,
+                    channelId: channel.id
+                }
+            });
+            if (guild) memberFor(guild, message.author, true);
+            placesMade.delete(mockTargets.get(message) ?? message);
+        } else warnOnMadePlaceReads(mockTargets.get(message) ?? message);
+    }
     // Options assigned after creation, directly or through Object.assign, belong to it as those given do
     return stubDeep(instance, stubs, (prop, value)=>{
         if (prop === 'options') ownOptions(instance, value);
@@ -1046,8 +1622,15 @@ function createMockInteraction(Class, props) {
 /**
  * A mock function that answers property access with another one, so `cache.store.flush()` works
  * on a double whose shape is an interface with nothing at runtime to read it from.
- */ function stubCallable() {
+ */ function stubCallable(member) {
     const fn = createMockFn();
+    // jest's mock reads `_protoImpl` from itself whenever it's called, so the prototype below must not answer it
+    if (usesRunnerMockFn()) Object.defineProperty(fn, '_protoImpl', {
+        value: undefined,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    });
     // Any property beyond the mock's own API is a nested mock, made on first read and kept on the function, out of its
     // keys. Its prototype makes them rather than a Proxy around it, so it stays the plain mock function matchers read
     const inherited = Object.getPrototypeOf(fn);
@@ -1056,7 +1639,9 @@ function createMockInteraction(Class, props) {
             if (typeof prop === 'symbol' || prop in proto) return Reflect.get(proto, prop, receiver);
             // Never thenable — otherwise awaiting a mock hangs on itself
             if (prop === 'then') return undefined;
-            const nested = stubCallable();
+            // jest's matchers take a function whose `calls` has `all` and `count` for a jasmine spy, read before `mock.calls`
+            if (member === 'calls' && (prop === 'all' || prop === 'count')) return undefined;
+            const nested = stubCallable(prop);
             Object.defineProperty(receiver, prop, {
                 value: nested,
                 writable: true,
@@ -1121,6 +1706,7 @@ function createMockInteraction(Class, props) {
             if (key === 'then') return undefined;
             // An explicitly supplied prop wins over the auto-stub.
             if (Object.prototype.hasOwnProperty.call(instance, key)) return Reflect.get(instance, prop, instance);
+            // The double itself is no function a matcher reads, so a `calls` member here keeps its `all` and `count`
             if (!stubs.has(key)) stubs.set(key, stubCallable());
             return stubs.get(key);
         },
@@ -1160,11 +1746,12 @@ function createMockInteraction(Class, props) {
  * @group Testing
  * @category Mocks
  * @see {@link createMockInteraction}
- */ const createMockUser = (props = {})=>createMockInteraction(User, {
-        id: nextSnowflake(),
+ */ function createMockUser(props = {}) {
+    return createMockInteraction(User, {
         bot: false,
         ...props
     });
+}
 /**
  * Creates a mock {@link Client}, with `users`, `channels`, `guilds` and `application.commands` ready to stub.
  *
@@ -1278,6 +1865,38 @@ const HOLDS = [
     [
         PermissionOverwriteManager.prototype,
         PermissionOverwrites
+    ],
+    [
+        ReactionManager.prototype,
+        MessageReaction
+    ],
+    [
+        ReactionUserManager.prototype,
+        User
+    ],
+    [
+        PresenceManager.prototype,
+        Presence
+    ],
+    [
+        GuildEmojiManager.prototype,
+        GuildEmoji
+    ],
+    [
+        GuildStickerManager.prototype,
+        Sticker
+    ],
+    [
+        GuildScheduledEventManager.prototype,
+        GuildScheduledEvent
+    ],
+    [
+        AutoModerationRuleManager.prototype,
+        AutoModerationRule
+    ],
+    [
+        GuildInviteManager.prototype,
+        Invite
     ]
 ];
 /**
@@ -1293,6 +1912,11 @@ const HOLDS = [
         value: cache,
         writable: true
     });
+    // The same collection where discord.js's own methods read it past a subclass's `cache`, as `super.cache` does
+    Object.defineProperty(manager, '_cache', {
+        value: cache,
+        writable: true
+    });
     const holds = HOLDS.find(([Manager])=>Manager === prototype || Object.prototype.isPrototypeOf.call(Manager, prototype))?.[1];
     if (holds) Object.defineProperty(manager, 'holds', {
         value: holds
@@ -1300,16 +1924,28 @@ const HOLDS = [
     let own;
     Object.defineProperty(manager, 'client', {
         get: ()=>{
-            const owner = manager.guild ?? manager.channel ?? manager.thread;
+            const owner = manager.guild ?? manager.channel ?? manager.thread ?? manager.message;
             return owner instanceof Base ? owner.client : own ?? (own = createMockClient());
         },
-        set: (value)=>own = value,
+        // A client the test sets is the one read from then on, as on any other mock
+        set: (value)=>Object.defineProperty(manager, 'client', {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            }),
         configurable: true
     });
     return stubDeep(manager);
 }
+/** An empty manager of `prototype` that `owner` names its own, such as `{ message }` for a message's reactions. */ function ownedManager(prototype, owner) {
+    const manager = managerWith(prototype, undefined);
+    Object.assign(manager, owner);
+    return manager;
+}
 /**
- * Creates a mock {@link Guild}, with the `members`, `channels`, `roles` and `bans` managers ready to stub.
+ * 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.
@@ -1319,9 +1955,11 @@ 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
+ * 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()` and `edit()` resolve to a mock of its item, which `create()` caches
+ * as discord.js does, but for an invite, made for the channel given and cached nowhere; 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 with no permissions, in `roles.cache` as Discord has
@@ -1344,14 +1982,15 @@ const HOLDS = [
  * @see {@link createMockMessage}
  */ function createMockGuild(overrides = {}) {
     const instance = Object.create(Guild.prototype);
-    instance.id = nextSnowflake();
-    if (overrides.id !== undefined) instance.id = overrides.id;
+    const generatedId = overrides.id === undefined ? nextSnowflake() : undefined;
+    instance.id = overrides.id ?? generatedId;
+    defineMadeTime(instance, generatedId);
     if (overrides.name !== undefined) instance.name = overrides.name;
     if (overrides.preferredLocale !== undefined) instance.preferredLocale = overrides.preferredLocale;
     instance.members = managerWith(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
@@ -1390,7 +2029,8 @@ const HOLDS = [
  * @see {@link createMockGuild}
  */ function createMockChannel(Class, props = {}) {
     const instance = Object.create(Class.prototype);
-    instance.id = nextSnowflake();
+    const generatedId = props.id === undefined ? nextSnowflake() : undefined;
+    instance.id = generatedId;
     const is = (Base)=>Base.prototype.isPrototypeOf(Class.prototype) || Class === Base;
     // Text and announcement channels: messages, and threads made in the channel
     if (is(TextChannel) || is(NewsChannel)) {
@@ -1418,6 +2058,7 @@ const HOLDS = [
     // A server's channel has its overwrites, none until a test puts some in the cache, which its permissions read
     if (is(GuildChannel) && !is(ThreadChannel)) instance.permissionOverwrites = managerWith(PermissionOverwriteManager.prototype, undefined);
     Object.assign(instance, props);
+    defineMadeTime(instance, generatedId);
     const stubs = new Map();
     const channel = stubDeep(instance, stubs);
     // Each manager knows its channel, as discord.js's do, and a thread's members their thread
@@ -1543,16 +2184,24 @@ const CHANNEL_TYPE_GUARDS = [
     return stubDeep(manager);
 }
 /** The permissions Discord gives a server's @everyone role in a server made today. */ const NEW_SERVER_EVERYONE_PERMISSIONS = 2248473465835073n;
+// The @everyone roles default mode made with no permissions, where strict mocks give a new server's
+const madeEveryones = new WeakSet();
+/** Whether `role` is an @everyone role default mode made, whose permissions the test hasn't set. */ const isUnsetEveryone = (role)=>madeEveryones.has(role) && !Object.prototype.hasOwnProperty.call(role, 'permissions');
 // A server's @everyone role, which has the server's id and ranks lowest, at position 0; with strict mocks, the
 // permissions Discord gives it in a new server
-const everyoneRole = (guildId)=>createMockInteraction(Role, {
+function everyoneRole(guildId) {
+    const strict = strictMocks();
+    const role = createMockInteraction(Role, {
         id: guildId,
         name: '@everyone',
         position: 0,
-        ...strictMocks() ? {
+        ...strict ? {
             permissions: new PermissionsBitField(NEW_SERVER_EVERYONE_PERMISSIONS).freeze()
         } : {}
     });
+    if (!strict) madeEveryones.add(role);
+    return role;
+}
 /**
  * A guild's role manager with `roles` in its cache, and the guild's @everyone role: the one given with the guild's id,
  * or a role of its own at position 0, as every server has one.
@@ -1652,8 +2301,9 @@ const everyoneRole = (guildId)=>createMockInteraction(Role, {
  * highest, by position, then the lower id. `permissions` are computed as discord.js computes them: every permission for
  * the server's owner, and otherwise its roles' permissions combined, @everyone's included, so a member with no roles has
  * @everyone's alone. The member is put in its guild's member cache, so an interaction or a message from its user in that
- * server has it as its `member`, and `memberPermissions` are its permissions. A DM sent to the member goes through its
- * user's `send()` and the user's one DM channel.
+ * server has it as its `member`, and `memberPermissions` are its permissions, with the interaction's channel's
+ * overwrites applied under `useStrictMocks()`. A DM sent to the member goes through its user's `send()` and the user's
+ * one DM channel.
  *
  * @param overrides - The member's user, server, roles and nickname; see {@link MockMemberOverrides}.
  * @returns The mock member.
@@ -1700,6 +2350,218 @@ const everyoneRole = (guildId)=>createMockInteraction(Role, {
     return guild ? cached(cacheOf(guild.channels), channelId, make) : make();
 }
 /** A server's id as a refusal names it, or a DM. */ const placeName = (guildId)=>guildId === null ? 'a DM' : `server ${guildId}`;
+/**
+ * Where strict mocks place an interaction: in its message's channel and server, in a guild's or a member's server, and
+ * with a guildId alone in a server the bot isn't in. Undefined where a channel given, or nothing, places it.
+ */ // Mock messages whose channel and server the mock made, as neither was given
+const placesMade = new WeakSet();
+// Messages whose place reads already warn, so a message reused for several interactions is wrapped once
+const madePlaceWarned = new WeakSet();
+/**
+ * Has a message whose place the mock made warn once per key when its place is read, in default mode, where strict mocks
+ * move it to the interaction it was given to. A read made while reading another of these, or by the mock, stays quiet.
+ */ function warnOnMadePlaceReads(message) {
+    if (madePlaceWarned.has(message)) return;
+    madePlaceWarned.add(message);
+    for (const key of [
+        'guild',
+        'guildId',
+        'channel',
+        'channelId',
+        'member'
+    ]){
+        const descriptor = Object.getOwnPropertyDescriptor(message, key);
+        if (!descriptor) continue;
+        let value = descriptor.value;
+        Object.defineProperty(message, key, {
+            get: ()=>{
+                if (readingPlace === 0) {
+                    warnOnce(mockLogger, `Message.${key} reads the place createMockMessage() made for this message here, though the interaction it was ` + "given to is placed elsewhere; in the next major version (5.0) the message moves to the interaction's place. " + 'Give the message a channel or guild, or call useStrictMocks() to move it now.');
+                }
+                readingPlace++;
+                try {
+                    return descriptor.get ? descriptor.get.call(message) : value;
+                } finally{
+                    readingPlace--;
+                }
+            },
+            set: (next)=>{
+                if (descriptor.set) descriptor.set.call(message, next);
+                else value = next;
+            },
+            enumerable: true,
+            configurable: true
+        });
+    }
+}
+// The DM channel each message the bot sent in a DM in default mode was sent in, where strict mocks place it
+const sentInDm = new WeakMap();
+/** Whether a message is one whose channel and server the mock made, which a test placing an interaction overrides. */ const placeWasMade = (message)=>placesMade.has(mockTargets.get(message) ?? message);
+function strictPlaceOf(own) {
+    const message = own('message');
+    const channel = own('channel');
+    const guild = own('guild');
+    const guildId = own('guildId');
+    const member = own('member');
+    // A message whose place the mock made has none a test meant, so where the test placed the interaction wins
+    const placed = channel !== undefined || guild !== undefined || guildId !== undefined;
+    if (typeof message === 'object' && message !== null && typeof message.channelId === 'string' && !(placed && placeWasMade(message))) {
+        // One the bot sent in a DM is in that DM, as strict mocks place it, though default mode reads a server for it
+        const dm = sentInDm.get(mockTargets.get(message) ?? message);
+        const channelId = dm ? dm.id : message.channelId;
+        const at = dm ? null : message.guildId ?? null;
+        const refused = channel && channel.id !== channelId ? `The message given is in channel ${channelId}, but the mock's channel is ${channel.id}: give the message's channel, or leave one of them out.` : guild !== undefined && (guild?.id ?? null) !== at ? `The message given is in ${placeName(at)}, but the mock's guild is ${placeName(guild?.id ?? null)}: give the message's guild, or leave one of them out.` : guildId !== undefined && guildId !== at ? `The message given is in ${placeName(at)}, but the mock's guildId is ${placeName(guildId)}: give the message's guildId, or leave one of them out.` : undefined;
+        return {
+            given: 'message',
+            channel: dm ?? message.channel,
+            guildId: at,
+            guild: dm ? null : message.guild ?? null,
+            refused
+        };
+    }
+    if (guild instanceof Guild && guildId === undefined) return {
+        given: 'guild',
+        guildId: guild.id
+    };
+    if (member instanceof GuildMember && member.guild instanceof Guild && guild === undefined && guildId === undefined) {
+        return {
+            given: 'member',
+            guild: member.guild,
+            guildId: member.guild.id
+        };
+    }
+    if (typeof guildId === 'string' && guild === undefined && channel === undefined && !(member instanceof GuildMember) && !isRawMember(member)) {
+        return {
+            given: 'guildId',
+            raw: true
+        };
+    }
+    return undefined;
+}
+// Set while one of the reads below runs, so what it reads in turn doesn't warn again
+let readingPlace = 0;
+/** Runs `read` as the mock's own read of where a mock is, which warns about no placement. */ function readPlaceQuietly(read) {
+    readingPlace++;
+    try {
+        return read();
+    } finally{
+        readingPlace--;
+    }
+}
+// Each interaction's strict place and its warning, by the read it names, for the mock's own reads that warn as the test's
+const placeWarners = new WeakMap();
+// The place keys a read of the mock's own read while it runs, so it warns by its own name where one would warn
+let placeReadsSeen;
+/**
+ * Runs `read`, a value of `mock`'s own that reads where the mock is, quietly; in default mode it warns once, as `key`,
+ * where one of those reads would warn, since strict mocks place the mock otherwise, unless `differs` says the value is
+ * the same in that place.
+ */ function readPlaceAs(mock, key, read, differs = ()=>true) {
+    const outer = placeReadsSeen;
+    const seen = placeReadsSeen = new Set();
+    try {
+        return readPlaceQuietly(read);
+    } finally{
+        placeReadsSeen = outer;
+        const warner = placeWarners.get(mockTargets.get(mock) ?? mock);
+        if (seen.size > 0 && warner && differs(warner.place)) warner.warn(key);
+    }
+}
+/** What reading `key`, where strict mocks place an interaction otherwise, warns: what it reads now, and in 5.0. */ function placeWarning(name, key, place) {
+    if (place.refused) {
+        return `${name}.${key} reads where the mock's channel, guild or guildId put it, not where its message is; under useStrictMocks(), as in the next major version (5.0), the mock is refused: ${place.refused}`;
+    }
+    const why = {
+        message: [
+            'a place other than its message\'s',
+            "the mock is in its message's channel and server",
+            "Give it the message's channel, or call useStrictMocks() to place it there now."
+        ],
+        guild: [
+            "a DM's value, though the mock was given a guild",
+            'the mock is in that guild',
+            'Give its guildId or one of its channels too, or call useStrictMocks() to place it there now.'
+        ],
+        member: [
+            "a DM's value, though the mock was given a member of a server",
+            "the mock is in the member's server",
+            "Give the member's guild too, or call useStrictMocks() to place it there now."
+        ],
+        guildId: [
+            'a server the bot is in, though the mock was given only a guildId',
+            "a guildId alone is a server the bot isn't in: guild and channel are null, and the member is a raw one",
+            'Give a guild too, or call useStrictMocks() to read it so now.'
+        ]
+    }[place.given];
+    return `${name}.${key} reads ${why[0]} here; in the next major version (5.0) ${why[1]}. ${why[2]}`;
+}
+/** Has a read of `instance`'s `key` call `warn` first, and what that read reads in turn stay quiet. */ function warnOnRead(instance, key, warn) {
+    const descriptor = Object.getOwnPropertyDescriptor(instance, key);
+    // One the mock answers with a stub stays unset, as the mock's own checks read it, and warns as the stub is read
+    if (!descriptor) {
+        if (!stubReadWarnings.has(instance)) stubReadWarnings.set(instance, new Map());
+        stubReadWarnings.get(instance).set(key, warn);
+        return;
+    }
+    const read = ()=>descriptor.get ? descriptor.get.call(instance) : descriptor.value;
+    Object.defineProperty(instance, key, {
+        get: ()=>{
+            warn();
+            readingPlace++;
+            try {
+                return read();
+            } finally{
+                readingPlace--;
+            }
+        },
+        set: (next)=>Object.defineProperty(instance, key, {
+                value: next,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            }),
+        enumerable: true,
+        configurable: true
+    });
+}
+/**
+ * Has each of an interaction's `guildId`, `guild`, `channelId`, `channel` and `member` that strict mocks read otherwise
+ * warn once when read, unless the test gave it.
+ */ function warnOnPlaceReads(instance, place, given) {
+    const value = (key)=>{
+        const descriptor = Object.getOwnPropertyDescriptor(instance, key);
+        return descriptor?.get ? undefined : descriptor?.value;
+    };
+    const keys = place.refused ? [
+        'guildId',
+        'guild',
+        'channelId',
+        'channel'
+    ] : place.raw ? [
+        'guild',
+        'channel',
+        'member'
+    ] : place.guildId !== value('guildId') ? [
+        'guildId',
+        'guild',
+        'channelId',
+        'channel',
+        'member'
+    ] : place.channel && place.channel.id !== value('channelId') ? [
+        'channelId',
+        'channel'
+    ] : [];
+    const name = Object.getPrototypeOf(instance).constructor.name;
+    placeWarners.set(instance, {
+        place,
+        keys,
+        warn: (read)=>warnOnce(mockLogger, placeWarning(name, read, place))
+    });
+    for (const key of keys.filter((each)=>!given.has(each))){
+        // A read the mock makes stays quiet, noted for a read of the mock's own to warn by its name
+        warnOnRead(instance, key, ()=>readingPlace > 0 ? void placeReadsSeen?.add(key) : warnOnce(mockLogger, placeWarning(name, key, place)));
+    }
+}
 /**
  * Where a channel a test gives puts the mock made in it, read from the channel as discord.js reads it: no server for a
  * DM channel, else the server the channel names. A server channel that names none is put in `fallback`'s, and named
@@ -1744,23 +2606,69 @@ const everyoneRole = (guildId)=>createMockInteraction(Role, {
         cached(cacheOf(manager), id, ()=>channel);
     }
 }
-/** The guild a mock message carries: a guild with the same stubbed managers as createMockGuild. */ function createMockGuildForMessage(id = nextSnowflake()) {
+/** The guild a mock message carries: a guild with the same stubbed managers as createMockGuild. */ function createMockGuildForMessage(id) {
     const guild = Object.create(Guild.prototype);
-    guild.id = id;
+    const generatedId = id === undefined ? nextSnowflake() : undefined;
+    guild.id = id ?? generatedId;
+    defineMadeTime(guild, generatedId);
     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;
 }
+// Each settled guild's bot member as `members.me` reads it, without caching one made for the read
+const botMembers = new WeakMap();
+/** The bot's member in `guild` for the mock's own reads: the one `members.me` reads, made without caching it there. */ function botMemberOf(guild) {
+    return botMembers.get(guild)?.() ?? guild.members.me;
+}
+/**
+ * The channel an interaction's `channel` reads, for the mock's own reads: `null` in a DM, else one set on it or its
+ * server's cached one, without making or caching one. Undefined where `channel` would make one, which has no overwrites.
+ */ function heldChannelOf(interaction, guild) {
+    const target = mockTargets.get(interaction) ?? interaction;
+    return readPlaceQuietly(()=>{
+        const set = Object.getOwnPropertyDescriptor(target, 'channel');
+        if (set && 'value' in set) return set.value;
+        const { guildId, channelId } = target;
+        return guildId ? cacheOf(guild.channels)?.get(channelId) : null;
+    });
+}
+// 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;
 }
 /**
@@ -1776,11 +2684,13 @@ const everyoneRole = (guildId)=>createMockInteraction(Role, {
         configurable: true
     });
     const members = instance.members;
+    const botMember = (keep)=>{
+        const { user } = guild.client;
+        return keep ? cached(cacheOf(members), user.id, ()=>memberIn(guild, user.id, user)) : cacheOf(members)?.get(user.id) ?? memberIn(guild, user.id, user);
+    };
+    botMembers.set(guild, ()=>botMember(false));
     Object.defineProperty(members, 'me', {
-        get: ()=>{
-            const { user } = guild.client;
-            return cached(cacheOf(members), user.id, ()=>memberIn(guild, user.id, user));
-        },
+        get: ()=>botMember(true),
         configurable: true
     });
     for (const key of [
@@ -1854,8 +2764,11 @@ const everyoneRole = (guildId)=>createMockInteraction(Role, {
     };
     // Own values, so the prototype's getters, which read the raw mention data, are not reached
     const instance = Object.create(MessageMentions.prototype);
+    const parsedUsers = new Collection(mentioned.users);
     for (const [key, value] of Object.entries({
         ...mentioned,
+        parsedUsers,
+        crosspostedChannels: new Collection(),
         everyone: false,
         client,
         guild: guild ?? null
@@ -1868,11 +2781,14 @@ const everyoneRole = (guildId)=>createMockInteraction(Role, {
     return stubDeep(instance);
 }
 /** A value as its API JSON: a builder or discord.js structure through `toJSON()`, anything else as it is. */ const jsonOf = (value)=>value && typeof value.toJSON === 'function' ? value.toJSON() : value;
-/** The message a reply method starts from: the one a component is on, as it was, or an empty original response. */ function heldFrom(message) {
+/**
+ * The message a reply method starts from: the one a component is on, as it was, or an empty original response. Without
+ * `allocate`, one with no id of its own gets `''`, for its holder to give it one when first read.
+ */ function heldFrom(message, allocate = true) {
     // Read only what the message really has: a mock's unset fields are stubs
     const from = message ?? {};
     return {
-        id: typeof from.id === 'string' ? from.id : nextSnowflake(),
+        id: typeof from.id === 'string' ? from.id : allocate ? nextSnowflake() : '',
         content: typeof from.content === 'string' ? from.content : undefined,
         components: Array.isArray(from.components) ? from.components.map(jsonOf) : [],
         embeds: Array.isArray(from.embeds) ? from.embeds.map(jsonOf) : [],
@@ -1880,6 +2796,15 @@ const everyoneRole = (guildId)=>createMockInteraction(Role, {
         editedTimestamp: typeof from.editedTimestamp === 'number' ? from.editedTimestamp : null
     };
 }
+/** A message as an answer sends it: a new one, with what the answer gave, never edited. */ const sent = (options, allocate = true)=>{
+    // Its id taken only once it builds, so a payload that fails to build takes none
+    const held = edited(heldFrom(undefined, false), options);
+    return {
+        ...held,
+        id: allocate ? nextSnowflake() : '',
+        editedTimestamp: null
+    };
+};
 /** A held message after an edit: what the edit sets replaced in Discord's shape, and a later edit stamp. */ function edited(held, options) {
     const edit = typeof options === 'string' ? {
         content: options
@@ -1908,29 +2833,28 @@ const everyoneRole = (guildId)=>createMockInteraction(Role, {
         editedTimestamp: Math.max(Date.now(), (held.editedTimestamp ?? 0) + 1)
     };
 }
-/** A mock message showing a held message. */ function messageFrom(held) {
-    return createMockMessage({
+/** A mock message showing a held message, one the bot sent in `channel` by `client`, with what `made` keeps. */ function messageFrom(held, made, channel, client) {
+    return sentMessage(held, channel, client, {
         id: held.id,
-        ...held.content !== undefined && {
-            content: held.content
-        },
-        components: held.components,
-        embeds: held.embeds,
-        ...held.flags !== undefined && {
-            flags: held.flags
-        },
         editedTimestamp: held.editedTimestamp
-    });
+    }, made);
 }
 /**
- * A component or embed as a message holds it: a discord.js instance as it is; anything else as
- * its API JSON at the time of the call, behind `toJSON()`.
- */ function asHeld(value) {
+ * A component or embed as a message holds it: a discord.js instance as it is, anything else as the discord.js class
+ * built from its API JSON at the time of the call, as discord.js builds it, an unknown type as a plain `Component`.
+ */ function asHeld(value, kind) {
     if (value instanceof Component || value instanceof Embed) return value;
-    const json = structuredClone(typeof value.toJSON === 'function' ? value.toJSON() : value);
-    return {
-        toJSON: ()=>json
-    };
+    // A copy, since discord.js's classes keep what they are given, one level deep
+    const json = structuredClone(jsonOf(value));
+    if (kind === 'embed') return new Embed(json);
+    // An action row builds each child with discord.js's own createComponent, which it doesn't export
+    const row = new ActionRow({
+        type: ComponentType.ActionRow,
+        components: [
+            json
+        ]
+    });
+    return row.components[0];
 }
 /**
  * Creates a mock {@link Message} that tracks whether it has been deleted.
@@ -1939,12 +2863,14 @@ const everyoneRole = (guildId)=>createMockInteraction(Role, {
  * `@MessageHandler` does not skip it.
  *
  * @remarks
- * `delete()`, `edit()`, `reply()`, `react()`, `pin()` and `unpin()` throw once the message is deleted, and `edit()`
- * and `reply()` resolve to a new mock message. Without overrides the message is empty, in a server, from a new
- * person who is its `member`; with `guild: null` it is a direct message. Give `author` to send several messages as
- * one user, such as to reach a per-user cooldown. An author given, and the users, roles and channels the content
- * mentions, are cached as the gateway delivers them. It is typed as discord.js emits a message, never in a group DM,
- * so it fits `messageCreate` and the other message events.
+ * `delete()`, `edit()`, `reply()`, `react()`, `pin()` and `unpin()` throw once the message is deleted. `edit()` changes
+ * this message and resolves to it, and `reply()` resolves to the reply, sent in this message's channel and holding what
+ * was sent, as a channel's `send()` does. Under `useStrictMocks()` a message the bot sends is its `client.user`'s, and
+ * one sent in a DM is in that DM. Without overrides the message is empty, in a server, from a new person who is its
+ * `member`; with `guild: null` it is a direct message. Give `author` to send several messages as one user, such as to
+ * reach a per-user cooldown. An author given, and the users, roles and channels the content mentions, are cached as the
+ * gateway delivers them. It is typed as discord.js emits a message, never in a group DM, so it fits `messageCreate` and
+ * the other message events.
  *
  * @param overrides - The message's content, components and the rest; see {@link MockMessageOverrides}.
  *
@@ -1967,11 +2893,18 @@ const everyoneRole = (guildId)=>createMockInteraction(Role, {
  * @see {@link MockMessageOverrides}
  * @see {@link createMockGuild}
  */ function createMockMessage(overrides = {}) {
+    return messageMock(overrides);
+}
+function messageMock(overrides = {}, sentBy, made = {}, at) {
+    var _made, _made1, _made2;
     const instance = Object.create(Message.prototype);
     const stubs = new Map();
+    const unplaced = overrides.channel === undefined && overrides.guild === undefined;
+    // A message the bot sent is placed where it was sent, even where default mode reads a server of its own for a DM
+    if (unplaced && !sentBy) placesMade.add(instance);
     instance.deleted = false;
     // Constructor-assigned — set as prototype-based stubs; a user rather than a bot, as dispatch handles only those
-    instance.author = overrides.author ?? mockUser();
+    instance.author = overrides.author ?? (_made = made).author ?? (_made.author = mockUser());
     // Getters on the prototype, which the proxy would answer with a stub object: own properties shadow them
     // A channel given says where the message was sent, unless its guild is given too
     const place = overrides.channel ? placeOf(overrides.channel, overrides.guild === undefined ? undefined : overrides.guild?.id ?? null, ()=>{
@@ -1981,22 +2914,37 @@ const everyoneRole = (guildId)=>createMockInteraction(Role, {
             guild
         };
     }) : undefined;
-    const guild = overrides.guild !== undefined ? overrides.guild : place?.guildId !== undefined ? place.guildId === null ? null : place.guild ?? createMockGuildForMessage(place.guildId) : createMockGuildForMessage();
-    const channel = overrides.channel ?? channelFor(guild, guild?.id ?? null, nextSnowflake(), instance.author);
-    Object.defineProperty(instance, 'channel', {
+    const guild = overrides.guild !== undefined ? overrides.guild : place?.guildId !== undefined ? place.guildId === null ? null : place.guild ?? createMockGuildForMessage(place.guildId) : unplaced ? (_made1 = made).guild ?? (_made1.guild = createMockGuildForMessage()) : createMockGuildForMessage();
+    const madeChannel = ()=>channelFor(guild, guild?.id ?? null, nextSnowflake(), instance.author);
+    const channel = at ? undefined : overrides.channel ?? (unplaced ? (_made2 = made).channel ?? (_made2.channel = madeChannel()) : madeChannel());
+    if (channel) Object.defineProperty(instance, 'channel', {
         value: channel,
-        writable: true
+        writable: true,
+        configurable: true
     });
+    else {
+        Object.defineProperty(instance, 'channel', {
+            get: at.channel,
+            set: (value)=>Object.defineProperty(instance, 'channel', {
+                    value,
+                    writable: true,
+                    configurable: true
+                }),
+            configurable: true
+        });
+    }
     Object.defineProperty(instance, 'guild', {
         value: guild,
-        writable: true
+        writable: true,
+        configurable: true
     });
     // The author as a member of the message's server; a direct message has none. A given author's member is the one
     // the server caches, as the gateway resolves it, so every message from that author has the same member
-    // The author's member, cached as the gateway caches it with the message; `member` reads the cache, as discord.js does
+    // The author's member, cached as the gateway caches it with the message; `member` reads the cache, as discord.js
+    // does, without calling the manager's resolve a test may stub
     if (guild) memberFor(guild, instance.author, true);
     Object.defineProperty(instance, 'member', {
-        get: ()=>guild ? guild.members.resolve(instance.author) : null,
+        get: ()=>instance.guild ? cacheOf(instance.guild.members)?.get(instance.author.id) ?? null : null,
         set: (value)=>Object.defineProperty(instance, 'member', {
                 value,
                 writable: true,
@@ -2007,8 +2955,8 @@ const everyoneRole = (guildId)=>createMockInteraction(Role, {
         configurable: true
     });
     // In a server's text channel, the ids matching the objects; with no guild, a DM
-    instance.channelId = channel.id;
-    instance.guildId = guild?.id ?? null;
+    instance.channelId = channel?.id ?? at.channelId;
+    instance.guildId = at ? at.guildId : guild?.id ?? null;
     // The thread its channel caches under its id, as discord.js reads it; until 5.0, a placeholder thread otherwise
     let placeholderThread;
     Object.defineProperty(instance, 'thread', {
@@ -2038,7 +2986,7 @@ const everyoneRole = (guildId)=>createMockInteraction(Role, {
         configurable: true
     });
     if (guild instanceof Guild) cached(cacheOf(client.guilds), guild.id, ()=>guild);
-    cacheChannel(channel, guild, client);
+    if (channel) cacheChannel(channel, guild, client);
     const userCache = cacheOf(client.users);
     for (const user of [
         ...overrides.users ?? [],
@@ -2048,8 +2996,8 @@ const everyoneRole = (guildId)=>createMockInteraction(Role, {
     instance.mentions = mentionsOf(overrides.content, client, guild);
     // Data a message always has, real rather than stubbed, so code reading it sees an empty message
     instance.flags = new MessageFlagsBitField(overrides.flags);
-    instance.components = (overrides.components ?? []).map(asHeld);
-    instance.embeds = (overrides.embeds ?? []).map(asHeld);
+    instance.components = (overrides.components ?? []).map((component)=>asHeld(component, 'component'));
+    instance.embeds = (overrides.embeds ?? []).map((embed)=>asHeld(embed, 'embed'));
     instance.attachments = new Collection();
     instance.editedTimestamp = overrides.editedTimestamp ?? null;
     const generatedId = overrides.id === undefined ? nextSnowflake() : undefined;
@@ -2062,14 +3010,27 @@ const everyoneRole = (guildId)=>createMockInteraction(Role, {
         if (instance.deleted) throw alreadyDeleted();
         instance.deleted = true;
     }));
-    stubs.set('edit', createMockFn(async ()=>{
+    // An edit changes this message, as Discord edits it in place, and resolves to it
+    stubs.set('edit', createMockFn(async (options)=>{
         if (instance.deleted) throw alreadyDeleted();
-        return createMockMessage();
+        const held = edited(heldFrom(undefined, false), options);
+        const edit = typeof options === 'string' ? {
+            content: options
+        } : options ?? {};
+        if (edit.content !== undefined) instance.content = held.content;
+        if (edit.components !== undefined) instance.components = held.components.map((component)=>asHeld(component, 'component'));
+        if (edit.embeds !== undefined) instance.embeds = held.embeds.map((embed)=>asHeld(embed, 'embed'));
+        if (edit.flags !== undefined) instance.flags = new MessageFlagsBitField(held.flags);
+        instance.editedTimestamp = Math.max(Date.now(), (instance.editedTimestamp ?? 0) + 1);
+        return message;
     }));
-    stubs.set('reply', createMockFn(async ()=>{
+    stubs.set('reply', createMockFn(async (options)=>{
         if (instance.deleted) throw alreadyDeleted();
-        return createMockMessage();
+        return sentMessage(sent(options, false), instance.channel, instance.client);
     }));
+    // Crossposting publishes this message, and forwarding sends one in the channel it is forwarded to
+    stubs.set('crosspost', createMockFn(async ()=>message));
+    stubs.set('forward', createMockFn(async (channel)=>sentMessage(sent(undefined, false), channel, instance.client)));
     stubs.set('react', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
     }));
@@ -2079,7 +3040,85 @@ const everyoneRole = (guildId)=>createMockInteraction(Role, {
     stubs.set('unpin', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
     }));
-    return stubDeep(instance, stubs);
+    if (sentBy) warnOnSentReads(instance, stubs, sentBy);
+    const message = stubDeep(instance, stubs);
+    return message;
+}
+/**
+ * Has a message the bot sent warn once where strict mocks read it otherwise: its author, the bot's `client.user` under
+ * strict mocks, and, for one sent in a DM, the server it reads as being in.
+ */ function warnOnSentReads(instance, stubs, sentBy) {
+    // A read made while reading another of these, as `member` reads `author`, warns only for the outer one
+    let reading = 0;
+    const read = (key, warning)=>{
+        const descriptor = Object.getOwnPropertyDescriptor(instance, key);
+        Object.defineProperty(instance, key, {
+            get: ()=>{
+                if (reading === 0) warnOnce(mockLogger, warning);
+                reading++;
+                try {
+                    return descriptor?.get ? descriptor.get.call(instance) : descriptor?.value;
+                } finally{
+                    reading--;
+                }
+            },
+            set: (next)=>Object.defineProperty(instance, key, {
+                    value: next,
+                    writable: true,
+                    enumerable: true,
+                    configurable: true
+                }),
+            enumerable: true,
+            configurable: true
+        });
+    };
+    if (sentBy.bot) {
+        read('author', "Message.author reads a user here, though the bot sent this message; in the next major version (5.0) it is the bot's " + "client.user, as Discord sends it. Call useStrictMocks() to read client.user now.");
+    }
+    if (!sentBy.dm) return;
+    const inDm = (what)=>`Message.${what} reads a server here, though this message was sent in a DM; in the next major version (5.0) it reads ` + "as a DM's, with no server. Call useStrictMocks() to read it so now.";
+    const inGuild = Boolean(instance.guildId);
+    for (const key of [
+        'guild',
+        'guildId',
+        'member'
+    ])read(key, inDm(key));
+    stubs.set('inGuild', createMockFn(()=>(warnOnce(mockLogger, inDm('inGuild()')), inGuild)));
+}
+/**
+ * A message the bot sent, as Discord returns it: in the channel it was sent in and that channel's server, holding what
+ * was sent. Under strict mocks it is the bot's `client.user`'s, and one sent in a DM is in that DM; default mode places
+ * a DM send in a server of its own and keeps another author, with a warning when read.
+ */ function sentMessage(held, channel, client, fields = {}, made) {
+    const by = client ?? channel?.client;
+    const inChannel = channel instanceof BaseChannel;
+    const dm = inChannel && channel.isDMBased();
+    const strict = strictMocks();
+    const message = messageMock({
+        ...held.content !== undefined && {
+            content: held.content
+        },
+        components: held.components,
+        embeds: held.embeds,
+        ...held.flags !== undefined && {
+            flags: held.flags
+        },
+        ...inChannel && (!dm || strict) && {
+            channel: channel
+        },
+        ...by && {
+            client: by
+        },
+        ...strict && by?.user && {
+            author: by.user
+        },
+        ...fields
+    }, strict ? undefined : {
+        bot: Boolean(by?.user),
+        dm
+    }, made);
+    if (dm && !strict) sentInDm.set(mockTargets.get(message) ?? message, channel);
+    return message;
 }
 /** The option type Discord would have sent for a given JavaScript value. */ function optionTypeOf(value) {
     if (typeof value === 'boolean') return ApplicationCommandOptionType.Boolean;
@@ -2168,11 +3207,32 @@ const everyoneRole = (guildId)=>createMockInteraction(Role, {
     else if (isEntity) option.user = value;
     return option;
 }
+/**
+ * The option an autocomplete's user is typing, as Discord sends it: its value a string, `''` before anything is typed.
+ * A number given for it is its digits under strict mocks; otherwise it stays a number, with a warning when read.
+ */ function focusedOptionData(name, value) {
+    const option = toOptionData(name, value ?? '');
+    option.focused = true;
+    if (typeof value === 'number') {
+        if (strictMocks()) option.value = String(value);
+        else {
+            Object.defineProperty(option, 'value', {
+                get: ()=>{
+                    warnOnce(mockLogger, `The focused option "${name}" reads the number ${value} here, where Discord sends a string; in the next major version (5.0) ` + `the mock gives it as one. Give it as a string, such as '${value}', or call useStrictMocks() to have the mock give it now.`);
+                    return value;
+                },
+                enumerable: true
+            });
+        }
+    }
+    return option;
+}
 /**
  * Nests the supplied options under the subcommand path they were invoked through,
  * matching the shape Discord sends rather than a flat list.
- */ function buildOptionData(subcommandGroup, subcommand, values, memberOf) {
-    const leaves = Object.entries(values).map(([name, value])=>toOptionData(name, value, memberOf));
+ */ function buildOptionData(subcommandGroup, subcommand, values, memberOf, focused) {
+    const leaves = Object.entries(values).map(([name, value])=>name === focused ? focusedOptionData(name, value) : toOptionData(name, value, memberOf));
+    if (focused !== null && !Object.hasOwn(values, focused)) leaves.push(focusedOptionData(focused, null));
     if (subcommand === null) return leaves;
     const sub = {
         name: subcommand,
@@ -2212,6 +3272,10 @@ const everyoneRole = (guildId)=>createMockInteraction(Role, {
  * A whole number is an Integer option and a fraction a Number one, so
  * `getInteger()` reads only a whole number, and `getNumber()` reads either.
  *
+ * The `focused` option reads as Discord sends it, through `getFocused()`, `getFocused(true)` and `data` alike: a
+ * string, `''` when no value is given, and marked `focused` in `data`. A number given for it is its digits under
+ * `useStrictMocks()`; otherwise it stays the number, with a warning when read.
+ *
  * @typeParam Cached - `any` by default, to match `createMockInteraction(ChatInputCommandInteraction)`; pass it when the
  *   interaction under test is cache-pinned.
  *
@@ -2332,17 +3396,21 @@ const everyoneRole = (guildId)=>createMockInteraction(Role, {
         ], ()=>false, required));
     base.getFocused = createMockFn((getFull)=>{
         if (focused === null) throw optionError(DiscordjsErrorCodes.AutocompleteInteractionOptionNoFocusedOption);
-        const option = toOptionData(focused, values[focused] ?? null, memberOf);
+        // The one options.data holds, so the two agree
+        const option = base._hoistedOptions.find((each)=>each.focused);
         return getFull === true ? {
-            ...option,
-            focused: true
+            ...option
         } : option.value;
     });
     // `data` is what the framework reads to build a handler's params, so it is materialised here rather than
     // auto-stubbed, or every params assertion would see an empty record.
-    base.data = buildOptionData(subcommandGroup, subcommand, values, memberOf);
+    base.data = buildOptionData(subcommandGroup, subcommand, values, memberOf, focused);
+    // The fields discord.js's constructor sets from it, which its toString() reads
+    base._group = subcommandGroup;
+    base._subcommand = subcommand;
+    base._hoistedOptions = subcommand === null ? base.data : (subcommandGroup === null ? base.data[0] : base.data[0].options[0]).options;
     const resolver = stubDeep(base);
     return resolver;
 }
 
-export { RESPONSE_LOG, createChatInputOptions, createMock, createMockChannel, createMockClient, createMockGuild, createMockInteraction, createMockMember, createMockMessage, createMockRawMember, createMockUser, isRawMember, memberRoles };
+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 };