meocord 4.1.0 → 4.1.1

package/dist/cjs/testing/index.cjs

@@ -2,11 +2,11 @@
 
 require('reflect-metadata');
 var inversify = require('inversify');
-var providers = require('../_shared/providers-BSL8vml4.cjs');
+var providers = require('../_shared/providers-BMMLp2SN.cjs');
 var discord_js = require('discord.js');
 var enum_index = require('../enum/index.cjs');
-var controller_decorator = require('../_shared/controller.decorator-Ds7dj8uZ.cjs');
-var startupRoots = require('../_shared/startup-roots-H1ssJOrz.cjs');
+var controller_decorator = require('../_shared/controller.decorator-BywwkU9O.cjs');
+var startupRoots = require('../_shared/startup-roots-lFc69AxC.cjs');
 var node_crypto = require('node:crypto');
 require('node:async_hooks');
 require('crypto');
@@ -21,17 +21,13 @@ require('dayjs/plugin/utc.js');
 require('dayjs/plugin/timezone.js');
 require('module');
 require('chalk');
-require('../_shared/translate-error-Zwll3hC2.cjs');
+require('../_shared/translate-error-BnM8FbSH.cjs');
 
 // Framework-agnostic mock function, so `meocord/testing` depends on neither jest nor vitest.
 // Both detect it through `_isMockFunction` and read `fn.mock.calls` in their assertions.
+// Each call signature of `T`, up to four, as a union: `Parameters` and `ReturnType` read only an overloaded function's
+// last signature, such as the list form of a manager's `fetch`
 /**
- * One call's outcome, as a mock function records it: the value it returned, or the error it threw.
- *
- * @group Testing
- * @category Mocks
- * @see {@link MockState}
- */ /**
  * Tells whether a value is a mock function: one from `meocord/testing`, `jest.fn()` or `vi.fn()`.
  *
  * Use it in a helper that takes mocks and real functions alike, such as one that sets a default on every mock method.
@@ -296,17 +292,18 @@ const VISIBLE = new Set([
         ...state?.history ?? []
     ];
     const sent = calls.some((call)=>VISIBLE.has(call.method) && !('error' in call));
+    // Each call recorded what its method received, as that method takes it
     if (state) return {
         state: state.state,
         sent,
-        calls
+        calls: calls
     };
     const answered = interaction.isRepliable() ? interaction.replied : false;
     const deferred = interaction.isRepliable() ? interaction.deferred : false;
     return {
         state: answered ? 'replied' : deferred ? 'deferred' : 'unanswered',
         sent: log ? sent : answered,
-        calls
+        calls: calls
     };
 }
 /**
@@ -340,6 +337,7 @@ const VISIBLE = new Set([
     }, code, 400, 'POST', 'https://discord.com/api/v10/interactions', {});
 }
 
+/** A permission set with none, frozen as discord.js freezes the ones it gives. */ const noPermissions = ()=>new discord_js.PermissionsBitField().freeze();
 /** A property discord.js computes from the others: its own getter runs, reading the mock's values. */ const REAL_GETTER = Symbol('real getter');
 const snowflake = ()=>discord_js.SnowflakeUtil.generate().toString();
 /** A class and its defaults, typed together so a default that stops fitting its property fails to compile. */ const defaultsOf = (Class, defaults)=>[
@@ -383,6 +381,7 @@ const snowflake = ()=>discord_js.SnowflakeUtil.generate().toString();
         system: ()=>false,
         tag: REAL_GETTER,
         displayName: REAL_GETTER,
+        defaultAvatarURL: REAL_GETTER,
         createdTimestamp: REAL_GETTER,
         createdAt: REAL_GETTER
     }),
@@ -391,7 +390,12 @@ const snowflake = ()=>discord_js.SnowflakeUtil.generate().toString();
         id: REAL_GETTER,
         nickname: ()=>null,
         avatar: ()=>null,
-        joinedTimestamp: ()=>null,
+        // In the server since the mock was made, as a member Discord sends always is
+        joinedTimestamp: ()=>Date.now(),
+        joinedAt: REAL_GETTER,
+        partial: REAL_GETTER,
+        premiumSince: REAL_GETTER,
+        communicationDisabledUntil: REAL_GETTER,
         premiumSinceTimestamp: ()=>null,
         communicationDisabledUntilTimestamp: ()=>null,
         pending: ()=>false,
@@ -404,7 +408,24 @@ const snowflake = ()=>discord_js.SnowflakeUtil.generate().toString();
         name: ()=>'role',
         // Above @everyone, which a server's role manager makes at position 0
         position: ()=>1,
-        permissions: ()=>new discord_js.PermissionsBitField().freeze()
+        // Every role has a server; one made without is in one of its own, unless a guild given it takes it in
+        guild: ()=>createMockGuild(),
+        rawPosition: (role)=>role.position,
+        permissions: noPermissions,
+        hoist: ()=>false,
+        managed: ()=>false,
+        mentionable: ()=>false,
+        icon: ()=>null,
+        unicodeEmoji: ()=>null,
+        tags: ()=>null,
+        colors: ()=>({
+                primaryColor: 0,
+                secondaryColor: null,
+                tertiaryColor: null
+            }),
+        hexColor: REAL_GETTER,
+        createdTimestamp: REAL_GETTER,
+        createdAt: REAL_GETTER
     }),
     // A message's text says which handler it is for, so it stays the test's to give, as a command's name does
     defaultsOf(discord_js.Message, {
@@ -417,6 +438,10 @@ const snowflake = ()=>discord_js.SnowflakeUtil.generate().toString();
         nonce: ()=>null,
         position: ()=>null,
         activity: ()=>null,
+        reference: ()=>null,
+        poll: ()=>null,
+        interactionMetadata: ()=>null,
+        stickers: ()=>new discord_js.Collection(),
         url: REAL_GETTER
     }),
     // A command's name and a component's customId say which handler a call is for, so they stay the test's to give
@@ -434,7 +459,13 @@ const snowflake = ()=>discord_js.SnowflakeUtil.generate().toString();
         version: ()=>1,
         context: ()=>null,
         // What Discord sends with an interaction in a server, the member's permissions there; typed for a cached one
-        memberPermissions: (interaction)=>interaction.guildId && interaction.member instanceof discord_js.GuildMember ? interaction.member.permissions : null
+        memberPermissions: (interaction)=>interaction.guildId && interaction.member instanceof discord_js.GuildMember ? interaction.member.permissions : null,
+        // The bot's permissions where the interaction was made: its member's in the channel, or none outside a server
+        appPermissions: (interaction)=>{
+            const { guild, channel } = interaction;
+            const me = guild instanceof discord_js.Guild ? guild.members.me : null;
+            return (me && channel instanceof discord_js.GuildChannel ? channel.permissionsFor(me) : null) ?? noPermissions();
+        }
     }),
     defaultsOf(discord_js.TextChannel, {
         type: ()=>discord_js.ChannelType.GuildText,
@@ -481,8 +512,12 @@ const snowflake = ()=>discord_js.SnowflakeUtil.generate().toString();
     }),
     defaultsOf(discord_js.Client, {
         readyTimestamp: ()=>Date.now(),
+        readyAt: REAL_GETTER,
         uptime: REAL_GETTER,
         token: ()=>null
+    }),
+    defaultsOf(discord_js.BaseGuild, {
+        nameAcronym: REAL_GETTER
     })
 ]);
 /** The default a mock of `target`'s class has for `key`, read from the nearest class that has one. */ function discordDefault(target, key) {
@@ -670,11 +705,14 @@ function stubDeep(instance, externalStubs, onSet) {
                 const desc = Object.getOwnPropertyDescriptor(proto, key);
                 if (desc !== undefined) {
                     protoValue = desc.value;
+                    if (desc.get && PLACEHOLDER_BOOLEANS.get(proto)?.has(key)) warnBooleanPlaceholder(target, key);
                     break;
                 }
                 proto = Object.getPrototypeOf(proto);
             }
-            const stub = typeof protoValue === 'function' ? methodStub(target, key, protoValue, ()=>proxy) : stubDeep({});
+            // A client the mock's structures share: its guild's, or one of its own
+            if (key === 'client' && target instanceof discord_js.Base) return clientOf(target);
+            const stub = typeof protoValue === 'function' ? isRealMethod(target, key) ? createMockFn((...args)=>protoValue.apply(proxy, args)) : methodStub(target, key, protoValue, ()=>proxy) : stubDeep({});
             stubs.set(key, stub);
             return stub;
         },
@@ -695,6 +733,164 @@ function stubDeep(instance, externalStubs, onSet) {
     });
     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,
+// ranking roles, a member's or role's permissions in a channel, and whom a message mentions
+const REAL_METHODS = new Map([
+    [
+        discord_js.DataManager.prototype,
+        new Set([
+            'resolve',
+            'resolveId'
+        ])
+    ],
+    [
+        discord_js.RoleManager.prototype,
+        new Set([
+            'comparePositions'
+        ])
+    ],
+    [
+        discord_js.Role.prototype,
+        new Set([
+            'comparePositionTo',
+            'permissionsIn'
+        ])
+    ],
+    [
+        discord_js.GuildChannel.prototype,
+        new Set([
+            'permissionsFor',
+            'overwritesFor',
+            'memberPermissions',
+            'rolePermissions'
+        ])
+    ],
+    [
+        discord_js.GuildMember.prototype,
+        new Set([
+            'permissionsIn',
+            'isCommunicationDisabled'
+        ])
+    ],
+    [
+        discord_js.User.prototype,
+        new Set([
+            'avatarURL',
+            'displayAvatarURL',
+            'bannerURL'
+        ])
+    ],
+    [
+        discord_js.BaseGuild.prototype,
+        new Set([
+            'iconURL',
+            'bannerURL',
+            'splashURL'
+        ])
+    ],
+    [
+        discord_js.MessageMentions.prototype,
+        new Set([
+            'has'
+        ])
+    ]
+]);
+function isRealMethod(target, key) {
+    for(let proto = Object.getPrototypeOf(target); proto !== null; proto = Object.getPrototypeOf(proto)){
+        if (REAL_METHODS.get(proto)?.has(key)) return true;
+    }
+    return false;
+}
+// discord.js's computed booleans a mock reads as a placeholder, which is truthy: 5.0 computes them, and until then a
+// test that reads one is told so once
+const PLACEHOLDER_BOOLEANS = new Map([
+    [
+        discord_js.Message.prototype,
+        new Set([
+            'editable',
+            'deletable',
+            'pinnable',
+            'crosspostable',
+            'bulkDeletable',
+            'hasThread',
+            'partial'
+        ])
+    ],
+    [
+        discord_js.GuildMember.prototype,
+        new Set([
+            'manageable',
+            'kickable',
+            'bannable',
+            'moderatable'
+        ])
+    ],
+    [
+        discord_js.Role.prototype,
+        new Set([
+            'editable'
+        ])
+    ],
+    [
+        discord_js.GuildChannel.prototype,
+        new Set([
+            'viewable',
+            'manageable',
+            'deletable'
+        ])
+    ],
+    [
+        discord_js.ThreadChannel.prototype,
+        new Set([
+            'joinable',
+            'joined',
+            'sendable',
+            'unarchivable',
+            'editable',
+            'manageable',
+            'viewable'
+        ])
+    ],
+    [
+        discord_js.BaseGuildVoiceChannel.prototype,
+        new Set([
+            'joinable'
+        ])
+    ],
+    [
+        discord_js.User.prototype,
+        new Set([
+            'partial'
+        ])
+    ],
+    [
+        discord_js.BaseChannel.prototype,
+        new Set([
+            'partial'
+        ])
+    ],
+    [
+        discord_js.MessageReaction.prototype,
+        new Set([
+            'partial'
+        ])
+    ]
+]);
+const mockLogger = new controller_decorator.Logger('Mocks');
+function warnBooleanPlaceholder(target, key) {
+    const name = Object.getPrototypeOf(target).constructor.name;
+    const variable = name.charAt(0).toLowerCase() + name.slice(1);
+    controller_decorator.warnPlaceholder(mockLogger, `${name}.${key}`, 'the mock computes it as discord.js does', `Set it on the mock, such as ${variable}.${key} = false, to test either way.`);
+}
+// The client of a structure made without one: the one its guild has, else one of its own, made once
+const ownClients = new WeakMap();
+function clientOf(target) {
+    const guild = Object.getOwnPropertyDescriptor(target, 'guild')?.value;
+    if (guild instanceof discord_js.Guild) return guild.client;
+    let client = ownClients.get(target);
+    if (client === undefined) ownClients.set(target, client = createMockClient());
+    return client;
+}
 // ---------------------------------------------------------------------------
 // methodStub — what an auto-stubbed discord.js method returns
 // ---------------------------------------------------------------------------
@@ -853,9 +1049,9 @@ const MANAGER_ITEMS = [
     ]
 ];
 const returnsPromise = (key, method)=>method.constructor.name === 'AsyncFunction' || PROMISE_METHODS.has(key) || /^set[A-Z]/.test(key) && !SYNC_SETTERS.has(key);
-// The id of the one item a fetch asks for: an id, a discord.js object, or options naming one, such as `{ user: id }`;
-// undefined for a fetch of a list
-function fetchedId(args) {
+// 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
+function fetchedIds(args) {
     const idOf = (value)=>typeof value === 'string' ? value : value instanceof discord_js.Base ? value.id : undefined;
     const [first] = args;
     if (typeof first !== 'object' || first === null || first instanceof discord_js.Base) return idOf(first);
@@ -867,7 +1063,9 @@ function fetchedId(args) {
         'thread',
         'id'
     ]){
-        const id = idOf(first[key]);
+        const value = first[key];
+        if (Array.isArray(value)) return value.map(idOf).filter((id)=>id !== undefined);
+        const id = idOf(value);
         if (id !== undefined) return id;
     }
     return undefined;
@@ -875,9 +1073,9 @@ function fetchedId(args) {
 /**
  * The mock function for a method found on a discord.js prototype. One that returns a promise in discord.js resolves:
  * `createDM` to the user's DM channel, `send` and its kin to a message, a manager's `fetch`, `create` and `edit` to its
- * item (an empty collection for a list fetch), a structure's own `edit`, `fetch`, `delete`, `ban`, `pin`, `unpin`,
- * `timeout`, `disableCommunicationUntil` and setters to the structure, and the rest to `undefined`. Any other method
- * returns `undefined`.
+ * item (a collection of each for a fetch of several, an empty one for a list fetch), a structure's own `edit`, `fetch`,
+ * `delete`, `ban`, `pin`, `unpin`, `timeout`, `disableCommunicationUntil` and setters to the structure, and the rest to
+ * `undefined`. Any other method returns `undefined`.
  */ function methodStub(target, key, method, receiver) {
     if (!returnsPromise(key, method)) return createMockFn();
     // A member's DMs go through its user, and a user's through its one DM channel, as discord.js sends them
@@ -891,12 +1089,17 @@ function fetchedId(args) {
     if (MESSAGE_METHODS.has(key)) return createMockFn(async ()=>createMockMessage());
     if (target instanceof discord_js.BaseManager) {
         const item = MANAGER_ITEMS.find(([Manager])=>Manager.prototype.isPrototypeOf(target))?.[1];
-        // A fetch of one item finds it in the cache first, as discord.js does, and caches one it makes
+        // A fetch of one item finds it in the cache first, as discord.js does, and caches one it makes; a fetch of
+        // several does so for each
         if (item && key === 'fetch') {
             return createMockFn(async (...args)=>{
-                const id = fetchedId(args);
-                if (id === undefined) return new discord_js.Collection();
-                return cached(cacheOf(receiver()), id, ()=>item(id, receiver()));
+                const ids = fetchedIds(args);
+                const one = (id)=>cached(cacheOf(receiver()), id, ()=>item(id, receiver()));
+                if (Array.isArray(ids)) return new discord_js.Collection(ids.map((id)=>[
+                        id,
+                        one(id)
+                    ]));
+                return ids === undefined ? new discord_js.Collection() : one(ids);
             });
         }
         if (item && (key === 'create' || key === 'edit')) return createMockFn(async ()=>item(undefined, receiver()));
@@ -1112,54 +1315,7 @@ const INVALID_CHANNEL_TYPE = 'CommandInteractionOptionInvalidChannelType';
         id,
         bot: false
     }));
-// ---------------------------------------------------------------------------
-// createMockInteraction
-// ---------------------------------------------------------------------------
-/**
- * Creates a mock instance of a discord.js class, such as an interaction, keeping its prototype so `instanceof` holds.
- *
- * Use it for the interaction a test hands to `invoke` or `dispatch`. For a user, a message, a guild, a channel or a
- * client, the dedicated factories fill in what discord.js would; for a type with no class, use {@link createMock}.
- *
- * @remarks
- * Type guards such as `isButton()` run the real discord.js logic. An interaction gets an `id`, a `channelId` and a
- * `user` of its own unless given, and its `locale` is `'en-US'`; without a `guildId` it is a DM, and with one its
- * `member` is its user: for a `user` given, when the test gives the `guild`, the guild's cached member for that user,
- * so a message and an interaction from one user in that server share it, and `memberPermissions` are that member's
- * permissions (`null` in a DM). A user is a person, `bot: false`, and a member has the server's @everyone role and the
- * roles {@link createMockMember} gave it; with a `guildId` but no `guild`, a server the bot isn't in, that @everyone role
- * has the `guildId`. A DM sent to a member goes through its user's `send()` and the user's one DM channel. Its
- * `channel` is a text channel of its server, the one its guild caches under `channelId`, or the user's DM channel. A
- * `channel` given sets what the test leaves out of `channelId`, `guildId` and `guild`, as discord.js reads them from
- * it: a DM channel is no server, and a server's channel its server; one in another server than the `guildId` given is
- * refused, naming both. A select menu has picked nothing unless given: its
- * `values` are the ids of the `users` and `members`, `roles` or `channels` given, the collections of what it picks,
- * each empty unless given. Other data Discord always sends reads as
- * Discord sends it, such as `false` for a flag and `null` for what may be absent; what picks the handler, `commandName`
- * or `customId`, is the test's to give. Replies follow Discord's order, so a second `reply()` rejects, and
- * {@link getResponse} reports every answer the interaction got. Every method is a mock function, and one that returns a
- * promise in discord.js resolves.
- *
- * @param Class - The discord.js class to mock.
- * @param props - Values for properties the class declares `readonly`; see {@link MockProps}.
- *
- * @example
- * ```ts
- * import { expect } from 'vitest'
- *
- * const interaction = createMockInteraction(ButtonInteraction, { customId: 'ticket/42/close' })
- * expect(interaction.isButton()).toBe(true)
- * await interaction.reply({ content: 'Closed.' })
- * expect(interaction.replied).toBe(true)
- * await expect(interaction.reply({ content: 'Again.' })).rejects.toThrow()
- * ```
- *
- * @group Testing
- * @category Mocks
- * @see {@link MockProps}
- * @see {@link createChatInputOptions}
- * @see {@link https://meocord.dev/docs/4.1/mocks | Mocks}
- */ function createMockInteraction(Class, props) {
+function createMockInteraction(Class, props) {
     const instance = Object.create(Class.prototype);
     const stubs = new Map();
     // Set type fields so all prototype type-guard methods compute the right value
@@ -1323,6 +1479,9 @@ const INVALID_CHANNEL_TYPE = 'CommandInteractionOptionInvalidChannelType';
             writable: true,
             configurable: true
         });
+        // The client caches the guild the interaction came from
+        const guildGiven = own('guild');
+        if (guildGiven instanceof discord_js.Guild) cached(cacheOf(instance.client.guilds), guildGiven.id, ()=>guildGiven);
         cacheOf(instance.client?.users)?.set(instance.user.id, instance.user);
         // A channel given says where the interaction was made, for what the test leaves unset, as discord.js reads it
         const given = own('channel');
@@ -1393,6 +1552,30 @@ const INVALID_CHANNEL_TYPE = 'CommandInteractionOptionInvalidChannelType';
                 configurable: true
             });
         }
+        // A user context menu's target: the user with its targetId, the client's cached one or one made and cached there,
+        // and in a server that user's member; each read live, so a targetId set later picks its user, and assignable
+        if (discord_js.UserContextMenuCommandInteraction.prototype.isPrototypeOf(instance)) {
+            if (unset('targetId')) instance.targetId = own('targetUser')?.id ?? nextSnowflake();
+            const targetUser = ()=>{
+                const id = own('targetId');
+                return cached(cacheOf(instance.client.users), id, ()=>mockUser(id));
+            };
+            const live = (key, read)=>Object.defineProperty(instance, key, {
+                    get: read,
+                    set: (value)=>Object.defineProperty(instance, key, {
+                            value,
+                            writable: true,
+                            enumerable: true,
+                            configurable: true
+                        }),
+                    enumerable: true,
+                    configurable: true
+                });
+            if (unset('targetUser')) live('targetUser', targetUser);
+            if (unset('targetMember')) {
+                live('targetMember', ()=>own('guildId') ? memberFor(own('guild'), targetUser(), true, own('guildId')) : null);
+            }
+        }
     }
     // Discord sends the user's locale with every interaction, and the server's preferred one with one made in a server
     if (discord_js.BaseInteraction.prototype.isPrototypeOf(instance)) {
@@ -1569,7 +1752,7 @@ const INVALID_CHANNEL_TYPE = 'CommandInteractionOptionInvalidChannelType';
  * import { expect } from 'vitest'
  *
  * const client = createMockClient()
- * const botId = client.user!.id
+ * const botId = client.user.id
  * const message = createMockMessage({ content: `<@${botId}> help`, client })
  * expect(message.mentions.users.has(botId)).toBe(true)
  * ```
@@ -1586,15 +1769,90 @@ const INVALID_CHANNEL_TYPE = 'CommandInteractionOptionInvalidChannelType';
     // Real caches, empty until something is put in them, as a client that has just logged in
     instance.users = managerWith(discord_js.UserManager.prototype, undefined);
     instance.channels = managerWith(discord_js.ChannelManager.prototype, undefined);
-    instance.guilds = stubDeep(Object.create(discord_js.GuildManager.prototype));
+    instance.guilds = managerWith(discord_js.GuildManager.prototype, undefined);
     instance.user = stubDeep(Object.assign(Object.create(discord_js.ClientUser.prototype), {
         id: MOCK_BOT_ID,
         bot: true
     }));
     instance.application = stubDeep(appInstance);
-    return stubDeep(instance);
+    // Discord's CDN routes, which avatar and icon URLs are built from; nothing is requested
+    instance.rest = stubDeep(Object.assign(Object.create(null), {
+        cdn: new discord_js.CDN()
+    }));
+    // A client a test is given is a logged-in one
+    instance.isReady = createMockFn(()=>true);
+    const client = stubDeep(instance);
+    for (const key of [
+        'users',
+        'channels',
+        'guilds'
+    ])instance[key].client = client;
+    Object.defineProperty(instance.user, 'client', {
+        value: client,
+        writable: true,
+        configurable: true
+    });
+    return client;
 }
-/** A manager whose `cache` is a real collection of `items`, by id, empty without them, and whose methods are stubs. */ function managerWith(prototype, items) {
+// What each manager holds, which discord.js's resolve() checks an item against
+const HOLDS = [
+    [
+        discord_js.GuildMemberManager.prototype,
+        discord_js.GuildMember
+    ],
+    [
+        discord_js.RoleManager.prototype,
+        discord_js.Role
+    ],
+    [
+        discord_js.GuildChannelManager.prototype,
+        discord_js.GuildChannel
+    ],
+    [
+        discord_js.UserManager.prototype,
+        discord_js.User
+    ],
+    [
+        discord_js.ChannelManager.prototype,
+        discord_js.BaseChannel
+    ],
+    [
+        discord_js.GuildManager.prototype,
+        discord_js.Guild
+    ],
+    [
+        discord_js.GuildBanManager.prototype,
+        discord_js.GuildBan
+    ],
+    [
+        discord_js.ThreadMemberManager.prototype,
+        discord_js.ThreadMember
+    ],
+    [
+        discord_js.GuildMessageManager.prototype,
+        discord_js.Message
+    ],
+    [
+        discord_js.DMMessageManager.prototype,
+        discord_js.Message
+    ],
+    [
+        discord_js.GuildTextThreadManager.prototype,
+        discord_js.ThreadChannel
+    ],
+    [
+        discord_js.GuildForumThreadManager.prototype,
+        discord_js.ThreadChannel
+    ],
+    [
+        discord_js.PermissionOverwriteManager.prototype,
+        discord_js.PermissionOverwrites
+    ]
+];
+/**
+ * A manager whose `cache` is a real collection of `items`, by id, empty without them, and whose methods are stubs but
+ * for `resolve` and `resolveId`, which read the cache. Its `client` is the one its guild or channel has.
+ */ function managerWith(prototype, items) {
     const manager = Object.create(prototype);
     const cache = new discord_js.Collection((items ?? []).map((item)=>[
             String(item.id ?? item.user?.id),
@@ -1604,6 +1862,19 @@ const INVALID_CHANNEL_TYPE = 'CommandInteractionOptionInvalidChannelType';
         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
+    });
+    let own;
+    Object.defineProperty(manager, 'client', {
+        get: ()=>{
+            const owner = manager.guild ?? manager.channel ?? manager.thread;
+            return owner instanceof discord_js.Base ? owner.client : own ?? (own = createMockClient());
+        },
+        set: (value)=>own = value,
+        configurable: true
+    });
     return stubDeep(manager);
 }
 /**
@@ -1617,14 +1888,18 @@ const INVALID_CHANNEL_TYPE = 'CommandInteractionOptionInvalidChannelType';
  *
  * @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; `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 or channel in this guild, a role with that id, or a ban. `members.fetch({ user: ids })`
+ * resolves to a collection of each of those members, found or made the same way; `create()` and `edit()` resolve to a
+ * mock of its item, and a list fetch to an empty collection. Members, roles and channels given are put in
  * their managers' caches, where dispatch looks first when it resolves a message's typed params; a member
  * {@link createMockMember} made without a server is in this one. Its `roles.everyone` is the role given with the
  * guild's id, or else an @everyone role of its own at position 0 with no permissions, in `roles.cache` as Discord has
  * it. The guild is named `'Guild'` and its `preferredLocale` is `'en-US'` unless given, so `t.forGuild(guild)`
  * translates as for a new English server.
  *
+ * The mock makes a member for any id it's asked for, so a test of an id that isn't a member rejects the fetch, as
+ * `guild.members.fetch.mockRejectedValue(createDiscordError(10007))`, or resolves a collection without that member.
+ *
  * @example
  * ```ts
  * const target = createMock<GuildMember>({ id: '111111111111111111' })
@@ -1647,7 +1922,7 @@ const INVALID_CHANNEL_TYPE = 'CommandInteractionOptionInvalidChannelType';
     instance.roles = guildRoleManager(instance.id, overrides.roles);
     instance.bans = managerWith(discord_js.GuildBanManager.prototype, undefined);
     const guild = stubDeep(instance);
-    homeManagers(instance, guild);
+    settleGuild(instance, guild);
     // A member made without a server of its own is in this one
     for (const member of overrides.members ?? []){
         if (!unhomedMembers.delete(member)) continue;
@@ -1664,7 +1939,8 @@ const INVALID_CHANNEL_TYPE = 'CommandInteractionOptionInvalidChannelType';
  * The managers the class has are ready to stub: `messages`, `threads` on text, announcement, forum and media channels,
  * and `members` on threads, each with a real, empty `cache` and the channel as its `channel`, or `thread`. A subclass gets the managers of the class it extends.
  * Type guards such as `isTextBased()`, `isDMBased()` and `isThread()` run discord.js's own logic, so each answers what
- * the channel is.
+ * the channel is. A thread is typed as discord.js types every thread it gives, a public or a private one, so it fits
+ * an interaction's `channel`, a guild's channels and the `threadCreate` event.
  *
  * @param Class - The discord.js channel class to mock.
  * @param props - Values for the channel's properties, such as its `id`, `name` or `topic`; see {@link MockProps}.
@@ -1708,13 +1984,16 @@ const INVALID_CHANNEL_TYPE = 'CommandInteractionOptionInvalidChannelType';
         instance.messages = managerWith(discord_js.GuildMessageManager.prototype, undefined);
         instance.members = managerWith(discord_js.ThreadMemberManager.prototype, undefined);
     }
+    // A server's channel has its overwrites, none until a test puts some in the cache, which its permissions read
+    if (is(discord_js.GuildChannel) && !is(discord_js.ThreadChannel)) instance.permissionOverwrites = managerWith(discord_js.PermissionOverwriteManager.prototype, undefined);
     Object.assign(instance, props);
     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
     for (const key of [
         'messages',
-        'threads'
+        'threads',
+        'permissionOverwrites'
     ])if (instance[key]) instance[key].channel = channel;
     if (is(discord_js.ThreadChannel) && instance.members) instance.members.thread = channel;
     // Type guards run discord.js's own logic, which reads the channel's type and the managers it has
@@ -1974,7 +2253,7 @@ const CHANNEL_TYPE_GUARDS = [
     guild.roles = guildRoleManager(guild.id, undefined);
     guild.bans = managerWith(discord_js.GuildBanManager.prototype, undefined);
     const proxy = stubDeep(guild);
-    homeManagers(guild, proxy);
+    settleGuild(guild, proxy);
     return proxy;
 }
 /** 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) {
@@ -1985,6 +2264,35 @@ const CHANNEL_TYPE_GUARDS = [
         'bans'
     ])instance[key].guild = guild;
 }
+/**
+ * Makes `guild` whole, as discord.js's guilds are: its managers and the roles and channels in its caches belong to it,
+ * it has a client of its own until one is given, and `members.me` is the bot's member, the cached one or one with
+ * @everyone, made and cached once on first read.
+ */ function settleGuild(instance, guild) {
+    homeManagers(instance, guild);
+    let client;
+    Object.defineProperty(instance, 'client', {
+        get: ()=>client ?? (client = createMockClient()),
+        set: (value)=>client = value,
+        configurable: true
+    });
+    const members = instance.members;
+    Object.defineProperty(members, 'me', {
+        get: ()=>{
+            const { user } = guild.client;
+            return cached(cacheOf(members), user.id, ()=>memberIn(guild, user.id, user));
+        },
+        configurable: true
+    });
+    for (const key of [
+        'roles',
+        'channels'
+    ]){
+        for (const item of cacheOf(instance[key])?.values() ?? []){
+            if (!Object.prototype.hasOwnProperty.call(item, 'guild')) item.guild = guild;
+        }
+    }
+}
 /** The ids each kind of mention in `content` names, in order and once each. */ function mentionedIds(content) {
     const ids = (pattern)=>[
             ...new Set([
@@ -2047,11 +2355,15 @@ const CHANNEL_TYPE_GUARDS = [
     const instance = Object.create(discord_js.MessageMentions.prototype);
     for (const [key, value] of Object.entries({
         ...mentioned,
-        everyone: false
-    }))Object.defineProperty(instance, key, {
-        value,
-        writable: true
-    });
+        everyone: false,
+        client,
+        guild: guild ?? null
+    })){
+        Object.defineProperty(instance, key, {
+            value,
+            writable: true
+        });
+    }
     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;
@@ -2130,7 +2442,8 @@ const CHANNEL_TYPE_GUARDS = [
  * 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.
+ * 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}.
  *
@@ -2179,33 +2492,55 @@ const CHANNEL_TYPE_GUARDS = [
     });
     // 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
-    const author = overrides.author;
-    const member = guild ? memberFor(guild, instance.author, author !== undefined) : null;
+    // The author's member, cached as the gateway caches it with the message; `member` reads the cache, as discord.js does
+    if (guild) memberFor(guild, instance.author, true);
     Object.defineProperty(instance, 'member', {
-        value: member,
-        writable: true
+        get: ()=>guild ? guild.members.resolve(instance.author) : null,
+        set: (value)=>Object.defineProperty(instance, 'member', {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            }),
+        enumerable: true,
+        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;
+    // 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', {
-        value: stubDeep(Object.create(discord_js.ThreadChannel.prototype)),
-        writable: true
+        get: ()=>{
+            const found = cacheOf(instance.channel.threads)?.get(instance.id);
+            if (found) return found;
+            controller_decorator.warnPlaceholder(mockLogger, 'Message.thread', 'it is null unless the channel caches a thread under the message id, as discord.js reads it', 'Cache one with message.channel.threads.cache.set(message.id, thread).');
+            return placeholderThread ?? (placeholderThread = stubDeep(Object.create(discord_js.ThreadChannel.prototype)));
+        },
+        set: (value)=>Object.defineProperty(instance, 'thread', {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            }),
+        enumerable: true,
+        configurable: true
     });
-    // Assigned once by discord.js's Base constructor, so an own value, as it is on a real message
+    // Assigned once by discord.js's Base constructor, so an own value, as it is on a real message; a guild the message
+    // made for itself has the same client, which caches the guild
     const client = overrides.client ?? createMockClient();
+    if (guild && overrides.guild === undefined) guild.client = client;
     Object.defineProperty(instance, 'client', {
         value: client,
         writable: true,
         configurable: true
     });
+    if (guild instanceof discord_js.Guild) cached(cacheOf(client.guilds), guild.id, ()=>guild);
     cacheChannel(channel, guild, client);
     const userCache = cacheOf(client.users);
     for (const user of [
         ...overrides.users ?? [],
-        ...author ? [
-            author
-        ] : []
+        instance.author
     ])userCache?.set(user.id, user);
     // MessageMentions — constructor-assigned; what the content mentions, cached as the gateway delivers it
     instance.mentions = mentionsOf(overrides.content, client, guild);