meocord 4.2.1 → 4.2.2

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

@@ -1,11 +1,11 @@
 import 'reflect-metadata';
 import { createMockFn, usesRunnerMockFn } from './mock-fn.js';
-import { DataManager, RoleManager, Role, GuildChannel, GuildMember, User, BaseGuild, MessageMentions, ThreadChannel, Message, BaseGuildVoiceChannel, VoiceChannel, BaseChannel, MessageReaction, InteractionType, ComponentType, ApplicationCommandType, GuildMemberManager, GuildChannelManager, UserManager, ChannelManager, GuildManager, Guild, GuildBanManager, GuildBan, ThreadMemberManager, ThreadMember, GuildMessageManager, DMMessageManager, GuildTextThreadManager, GuildForumThreadManager, PermissionOverwriteManager, PermissionOverwrites, ReactionManager, ReactionUserManager, PresenceManager, Presence, CommandInteractionOptionResolver, ApplicationCommandOptionType, Client, ApplicationCommandManager, ClientUser, CDN, DiscordjsErrorCodes, AuthorizingIntegrationOwners, BaseInteraction, UserContextMenuCommandInteraction, MessageContextMenuCommandInteraction, Attachment, Locale, StringSelectMenuInteraction, UserSelectMenuInteraction, RoleSelectMenuInteraction, ChannelSelectMenuInteraction, MentionableSelectMenuInteraction, Collection, PermissionsBitField, Base, SnowflakeUtil, DiscordjsError, DMChannel, GuildMemberRoleManager, MessageFlagsBitField, BaseManager, TextChannel, Component, Embed, ActionRow, ApplicationCommand, NewsChannel, ForumChannel, MediaChannel, DiscordjsTypeError, MessageFlags } from 'discord.js';
+import { DataManager, RoleManager, Role, GuildChannel, GuildMember, User, BaseGuild, MessageMentions, ThreadChannel, Message, BaseGuildVoiceChannel, VoiceChannel, BaseChannel, MessageReaction, 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, placeholderValue } from './discord-defaults.js';
 import { Logger } from '../common/logger.js';
-import { warnOnce, warnPlaceholder } from '../common/deprecation.js';
+import { warnPlaceholder, warnOnce } from '../common/deprecation.js';
 import { embedsAsDiscordStores, asDiscordStores } from './discord-shape.js';
 import { nextSnowflake, MOCK_BOT_ID } from './snowflake.js';
 import { strictMocks, noteMockMade } from './strict-mocks.js';
@@ -501,8 +501,49 @@ 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
@@ -576,6 +617,18 @@ function fetchedIds(args) {
                 return typeof user === 'string' ? user : user?.id;
             });
         }
+        // An invite is made for the channel given, in its guild, and cached nowhere, as discord.js's create does
+        if (item && key === 'create' && target instanceof GuildInviteManager) {
+            return createMockFn(async (channel)=>{
+                const invite = item(undefined, receiver());
+                const channelId = typeof channel === 'string' ? channel : channel?.id;
+                const found = channel instanceof BaseChannel ? channel : channelId ? cacheOf(guildOf(receiver())?.channels)?.get(channelId) ?? null : null;
+                return Object.assign(invite, {
+                    channel: found,
+                    channelId: channelId ?? null
+                });
+            });
+        }
         // Every other manager here caches what its create() makes, as discord.js's does; check a manager's create when
         // adding it to MANAGER_ITEMS
         if (item && key === 'create') {
@@ -792,24 +845,36 @@ const isSnowflake = (id)=>typeof id === 'string' && /^\d{1,20}$/.test(id);
             };
             stampCall(call);
             log.push(call);
-            let undo;
+            let gated;
             try {
-                // Before the behaviour, as discord.js changes the state at once: a second answer made without awaiting is refused
-                if (gate) undo = gate(args, byTest);
+                // Before the behaviour, as discord.js checks the state before it sends an answer
+                if (gate) gated = gate(args, byTest);
             } catch (error) {
                 call.error = error;
                 return Promise.reject(error);
             }
             const failed = (error)=>{
-                undo?.();
+                gated?.settle?.();
+                gated?.undo?.();
                 call.error = error;
                 throw error;
             };
+            // Once the behaviour resolves, as discord.js changes the state once Discord has taken the answer
+            const landed = (value)=>{
+                gated?.settle?.();
+                try {
+                    gated?.land?.();
+                } catch (error) {
+                    call.error = error;
+                    throw error;
+                }
+                return value;
+            };
             try {
                 const result = Reflect.apply(behaviour, this, args);
                 // Recorded and passed on, so a rejection nobody awaits is unhandled in the test, as it is on a bot
-                if (result instanceof Promise) return result.then(undefined, failed);
-                return result;
+                if (result instanceof Promise) return result.then(landed, failed);
+                return landed(result);
             } catch (error) {
                 return failed(error);
             }
@@ -923,7 +988,31 @@ function createMockInteraction(Class, props) {
     if (repliable) {
         instance.replied = false;
         instance.deferred = false;
-        instance.ephemeral = false;
+        // Null until reply() or deferReply() decides it, as discord.js has it; default mode reads false until then, and a
+        // test reading it there is told once. A value the test sets is read as set
+        const strict = strictMocks();
+        let ephemeral = strict ? null : false;
+        let ephemeralDecided = false;
+        // Whether one of the mock's own first answers ran; flags a test sets without one leave ephemeral as discord.js would
+        let answeredByMock = false;
+        const answeredOutside = ()=>Boolean(instance.replied || instance.deferred) && !answeredByMock;
+        const decideEphemeral = (value, decided)=>{
+            ephemeral = value;
+            ephemeralDecided = decided;
+        };
+        Object.defineProperty(instance, 'ephemeral', {
+            get: ()=>{
+                // Quiet once a test answered the interaction itself: MeoCord then reads ephemeral only for truthiness, where false
+                // and null act alike
+                if (!ephemeralDecided && !strict && !answeredOutside()) {
+                    warnPlaceholder(mockLogger, `${Object.getPrototypeOf(instance).constructor.name}.ephemeral`, 'it is null until reply() or deferReply() decides it, as discord.js has it', 'Reply or defer first, or call useStrictMocks() to read null now.');
+                }
+                return ephemeral;
+            },
+            set: (value)=>decideEphemeral(value, true),
+            enumerable: true,
+            configurable: true
+        });
         // discord.js's errors, with their codes; a call before any answer keeps the message the mock has always given
         const alreadyReplied = ()=>discordjsError(DiscordjsErrorCodes.InteractionAlreadyReplied);
         const notYetReplied = (method)=>discordjsError(DiscordjsErrorCodes.InteractionNotReplied, `Cannot call ${method}() before replying or deferring.`);
@@ -949,7 +1038,9 @@ function createMockInteraction(Class, props) {
             const saved = {
                 replied: instance.replied,
                 deferred: instance.deferred,
-                ephemeral: instance.ephemeral,
+                ephemeral,
+                ephemeralDecided,
+                answeredByMock,
                 original,
                 originalGone,
                 followUps: new Map(followUps),
@@ -959,10 +1050,10 @@ function createMockInteraction(Class, props) {
             return ()=>{
                 Object.assign(instance, {
                     replied: saved.replied,
-                    deferred: saved.deferred,
-                    ephemeral: saved.ephemeral
+                    deferred: saved.deferred
                 });
-                ({ original, originalGone, answeredByTest, modalAnswered } = saved);
+                decideEphemeral(saved.ephemeral, saved.ephemeralDecided);
+                ({ original, originalGone, answeredByTest, answeredByMock, modalAnswered } = saved);
                 followUps.clear();
                 for (const [id, held] of saved.followUps)followUps.set(id, held);
             };
@@ -987,24 +1078,76 @@ function createMockInteraction(Class, props) {
                 return build;
             }
         };
-        /** A first answer: refused once the interaction has one, else it replies or defers. */ const first = (method, kind, then)=>(args, byTest)=>{
-                if (answered()) refuse(method, alreadyReplied(), byTest);
-                // Read first: flags discord.js refuses throw before anything changes
-                const ephemeral = method === 'reply' || method === 'deferReply' ? hasEphemeralFlag(args[0]) : undefined;
+        // The changes answers make to the reply state, in order. One whose answer fails is undone once every change after
+        // it is undone too, so a later answer's change stands while it does, as on a bot
+        const changes = [];
+        const undoneInTurn = (undo)=>{
+            const change = {
+                undo,
+                failed: false
+            };
+            changes.push(change);
+            return ()=>{
+                change.failed = true;
+                while(changes.at(-1)?.failed)changes.pop().undo();
+            };
+        };
+        // The first answers called and not yet settled, oldest first, for default mode to warn where a bot would differ
+        const unsettled = [];
+        // Default mode warns once per interaction where code that doesn't await an answer would fail on a bot
+        let inFlightWarned = false;
+        const warnInFlight = (text)=>{
+            if (inFlightWarned) return;
+            inFlightWarned = true;
+            mockLogger.warn(text);
+        };
+        /**
+     * A first answer: refused once the interaction has one, else it replies or defers. Under strict mocks the change
+     * waits for the answer to land, as discord.js makes it once the request resolves, so one sent while another is in
+     * flight passes discord.js's check and Discord refuses it with 40060 if the other landed first. Default mode makes
+     * the change at once.
+     */ const first = (method, kind, then)=>(args, byTest)=>{
+                if (answered()) {
+                    if (unsettled.length > 0) {
+                        warnInFlight(`${method}() was called while ${unsettled[0]}() had not resolved; on a bot discord.js sends it, and Discord ` + `refuses it with 40060 ("Interaction has already been acknowledged") once the first lands. Await ` + `${unsettled[0]}() before answering again, or call useStrictMocks() to have the mock answer as Discord does.`);
+                    }
+                    refuse(method, alreadyReplied(), byTest);
+                }
+                // Read first: flags discord.js refuses throw before anything changes; reply() and deferReply() decide
+                // ephemeral, as discord.js's do, and update() and deferUpdate() leave it
+                const flagged = method === 'reply' || method === 'deferReply' ? hasEphemeralFlag(args[0]) : undefined;
                 const undo = snapshot();
                 instance[kind] = true;
-                if (ephemeral) instance.ephemeral = true;
+                if (flagged !== undefined) decideEphemeral(flagged, true);
                 answeredByTest = byTest;
+                answeredByMock = true;
                 try {
                     then(args);
                 } catch (error) {
                     undo();
                     throw error;
                 }
-                return undo;
+                if (strict) {
+                    const land = snapshot();
+                    undo();
+                    return {
+                        land: ()=>{
+                            if (answered()) throw createDiscordError(40060, 'Interaction has already been acknowledged.');
+                            land();
+                        }
+                    };
+                }
+                unsettled.push(method);
+                return {
+                    undo: undoneInTurn(undo),
+                    settle: ()=>void unsettled.splice(unsettled.indexOf(method), 1)
+                };
             };
         /** A later answer: refused before the interaction has one. */ const later = (method, then)=>(args, byTest)=>{
                 if (!answered()) refuse(method, notYetReplied(method), byTest);
+                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);
@@ -1012,7 +1155,9 @@ function createMockInteraction(Class, props) {
                     undo();
                     throw error;
                 }
-                return undo;
+                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;
@@ -1130,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 discordjsError(DiscordjsErrorCodes.InteractionAlreadyReplied);
+            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;
         }));
     }
@@ -1713,6 +1877,26 @@ const HOLDS = [
     [
         PresenceManager.prototype,
         Presence
+    ],
+    [
+        GuildEmojiManager.prototype,
+        GuildEmoji
+    ],
+    [
+        GuildStickerManager.prototype,
+        Sticker
+    ],
+    [
+        GuildScheduledEventManager.prototype,
+        GuildScheduledEvent
+    ],
+    [
+        AutoModerationRuleManager.prototype,
+        AutoModerationRule
+    ],
+    [
+        GuildInviteManager.prototype,
+        Invite
     ]
 ];
 /**
@@ -1760,7 +1944,8 @@ const HOLDS = [
     return manager;
 }
 /**
- * Creates a mock {@link Guild}, with the `members`, `channels`, `roles` and `bans` managers ready to stub.
+ * Creates a mock {@link Guild}, with its `members`, `channels`, `roles`, `bans`, `emojis`, `stickers`, `scheduledEvents`,
+ * `autoModerationRules` and `invites` managers ready to stub.
  *
  * Use it for the server a message or an interaction came from, with the members, roles and channels a handler looks
  * up in it.
@@ -1770,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
@@ -1803,7 +1990,7 @@ const HOLDS = [
     instance.members = managerWith(GuildMemberManager.prototype, overrides.members);
     instance.channels = managerWith(GuildChannelManager.prototype, overrides.channels);
     instance.roles = guildRoleManager(instance.id, overrides.roles);
-    instance.bans = managerWith(GuildBanManager.prototype, undefined);
+    for (const [key, Manager] of GUILD_MANAGERS)instance[key] = managerWith(Manager.prototype, undefined);
     const guild = stubDeep(instance);
     settleGuild(instance, guild);
     // A member made without a server of its own is in this one
@@ -2427,7 +2614,7 @@ let placeReadsSeen;
     guild.members = managerWith(GuildMemberManager.prototype, undefined);
     guild.channels = managerWith(GuildChannelManager.prototype, undefined);
     guild.roles = guildRoleManager(guild.id, undefined);
-    guild.bans = managerWith(GuildBanManager.prototype, undefined);
+    for (const [key, Manager] of GUILD_MANAGERS)guild[key] = managerWith(Manager.prototype, undefined);
     const proxy = stubDeep(guild);
     settleGuild(guild, proxy);
     return proxy;
@@ -2449,12 +2636,39 @@ const botMembers = new WeakMap();
         return guildId ? cacheOf(guild.channels)?.get(channelId) : null;
     });
 }
+// A guild's managers beside members, channels and roles, each empty, of its discord.js class
+const GUILD_MANAGERS = [
+    [
+        'bans',
+        GuildBanManager
+    ],
+    [
+        'emojis',
+        GuildEmojiManager
+    ],
+    [
+        'stickers',
+        GuildStickerManager
+    ],
+    [
+        'scheduledEvents',
+        GuildScheduledEventManager
+    ],
+    [
+        'autoModerationRules',
+        AutoModerationRuleManager
+    ],
+    [
+        'invites',
+        GuildInviteManager
+    ]
+];
 /** Gives a guild's managers the guild, as discord.js's do, so what they fetch or make is in it. */ function homeManagers(instance, guild) {
     for (const key of [
         'members',
         'channels',
         'roles',
-        'bans'
+        ...GUILD_MANAGERS.map(([key])=>key)
     ])instance[key].guild = guild;
 }
 /**

package/dist/esm/testing/strict-mocks.js

@@ -19,8 +19,9 @@ const settings = shared('strictMocks', ()=>({
  * and `message.thread` is `null` when the channel caches no thread under the message's id. So do a message's
  * `editedAt`, a member's `presence`, a server's `verified` and `systemChannel` and a channel's `parent`, each `null` or
  * `false` until the test gives what it is computed from. A reaction's `me` is `false`, a message's
- * `mentions.repliedUser` and a modal's `message` are `null`, and a reaction has a whole message of its own, so
- * MeoCord's dispatcher fetches neither. No placeholder warning is logged.
+ * `mentions.repliedUser` and a modal's `message` are `null`, an interaction's `ephemeral` is `null` until `reply()` or
+ * `deferReply()` decides it, and a reaction has a whole message of its own, so MeoCord's dispatcher fetches neither. No
+ * placeholder warning is logged.
  *
  * @remarks
  * Those getters read what a server holds, so strict mocks also have it as Discord sends it: the bot's member is in the
@@ -33,8 +34,10 @@ const settings = shared('strictMocks', ()=>({
  * A message the bot sends is its `client.user`'s, and one it sends in a DM is in that DM. Give the bot's member a role
  * to let it do more, such as kick a member its role ranks above. A value the test sets on a mock wins over the computed
  * one. An interaction's answer that discord.js would refuse, such as a second `reply()` after one a test set with
- * `mockResolvedValue`, is refused too, where without it the mock runs it and warns. The next major version (5.0)
- * computes these values, and refuses those answers, without the call.
+ * `mockResolvedValue`, is refused too, where without it the mock runs it and warns. An answer marks the interaction
+ * `replied`, `deferred` or `responded` once it resolves, as discord.js does, so code that doesn't await one fails as it
+ * would on a bot, within one run of the test's code. The next major version (5.0) computes these values, and refuses
+ * those answers, without the call.
  *
  * `invoke` also refuses a call that gives a handler fewer arguments than it declares where it builds none, such as a
  * reaction handler given its reaction without its `ReactionEvent`; without strict mocks, it warns once and calls it.

package/dist/esm/util/value.util.js

@@ -1,6 +1,23 @@
 import { quoteForLog } from './user-text.util.js';
 
-/** Whether a value is a class, which a stage entry or a `@Catch` type must be: what `new` and `instanceof` take. */ const isConstructor = (value)=>typeof value === 'function';
+/** Whether `new` takes a value, as `instanceof` needs of its right side, such as a `@Catch` type. */ function isConstructible(value) {
+    if (typeof value !== 'function') return false;
+    try {
+        // Fails unless value can be new.target, which only a constructor can; none of value's constructor code runs
+        Reflect.construct(String, [], value);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+/**
+ * Whether a value is a class, which a stage entry or an app option must be: constructible, with an object prototype for
+ * the metadata MeoCord reads. An arrow function, a method, an async or a generator function is none.
+ */ function isConstructor(value) {
+    if (!isConstructible(value)) return false;
+    const prototype = value.prototype;
+    return typeof prototype === 'object' && prototype !== null;
+}
 /** A value as a refusal or a warning names it: a string quoted, `null` and `undefined` as written, else its kind. */ function describeValue(value) {
     if (value === null || value === undefined) return String(value);
     if (typeof value === 'string') return quoteForLog(value);
@@ -20,4 +37,4 @@ import { quoteForLog } from './user-text.util.js';
     });
 }
 
-export { describeValue, isConstructor, setOwn, withArticle };
+export { describeValue, isConstructible, isConstructor, setOwn, withArticle };

package/dist/types/common/index.d.cts

@@ -596,6 +596,9 @@ declare function useTheme(): ResolvedTheme;
  * Such a listener runs in its emitter's context, so without it a `useTheme()` inside reads the theme outside any call.
  * Timers and promises the handler starts keep its theme without it.
  *
+ * The theme is the binding call's whole theme, its server's and user's themes included, so every later call, whoever
+ * it is for, is answered in the starting member's theme.
+ *
  * @param fn - The function to run in the call's theme; `this` and its arguments are passed through.
  * @returns A function that runs `fn` in the theme `useTheme()` returns where `bindTheme` is called.
  *
@@ -605,7 +608,7 @@ declare function useTheme(): ResolvedTheme;
  * async poll(message: Message) {
  *   const collector = message.createMessageComponentCollector({ componentType: ComponentType.Button, time: 60_000 })
  *   collector.on('collect', bindTheme(async (click: ButtonInteraction) => {
- *     const { emojis } = useTheme() // the handler's theme, @UseTheme included
+ *     const { emojis } = useTheme() // the starting member's theme, @UseTheme included
  *     await click.reply(`${emojis.success} Picked`)
  *   }))
  * }

package/dist/types/common/index.d.ts

@@ -596,6 +596,9 @@ declare function useTheme(): ResolvedTheme;
  * Such a listener runs in its emitter's context, so without it a `useTheme()` inside reads the theme outside any call.
  * Timers and promises the handler starts keep its theme without it.
  *
+ * The theme is the binding call's whole theme, its server's and user's themes included, so every later call, whoever
+ * it is for, is answered in the starting member's theme.
+ *
  * @param fn - The function to run in the call's theme; `this` and its arguments are passed through.
  * @returns A function that runs `fn` in the theme `useTheme()` returns where `bindTheme` is called.
  *
@@ -605,7 +608,7 @@ declare function useTheme(): ResolvedTheme;
  * async poll(message: Message) {
  *   const collector = message.createMessageComponentCollector({ componentType: ComponentType.Button, time: 60_000 })
  *   collector.on('collect', bindTheme(async (click: ButtonInteraction) => {
- *     const { emojis } = useTheme() // the handler's theme, @UseTheme included
+ *     const { emojis } = useTheme() // the starting member's theme, @UseTheme included
  *     await click.reply(`${emojis.success} Picked`)
  *   }))
  * }

package/dist/types/testing/index.d.cts

@@ -684,7 +684,8 @@ declare class MeoCordTestingModule {
      * @param app - The class `@MeoCord` decorates.
      * @param options - Providers that replace the app's by token, extra controllers, and observers.
      * @returns The builder, whose `override*` methods still apply, for `compile()`.
-     * @throws TypeError when `app` is not a `@MeoCord` class.
+     * @throws TypeError when `app` is not a `@MeoCord` class. After {@link reportAllStartupErrors}, an app whose
+     *   `@MeoCord` was refused throws the error it was refused for instead.
      *
      * @example
      * ```ts
@@ -796,7 +797,8 @@ interface MockState<T extends (...args: any[]) => any = (...args: any[]) => any>
  * The mock API of a mock function: what it has recorded, and the methods that change what it does.
  *
  * Every mock from `meocord/testing` has it, with the names jest and Vitest use, so a test written for either runner
- * reads the same.
+ * reads the same. The values it takes and records aren't checked against the function it mocks; see
+ * {@link MockedFunction}.
  *
  * @group Testing
  * @category Mocks
@@ -838,9 +840,12 @@ interface MockInstance<T extends (...args: any[]) => any = (...args: any[]) => a
 /**
  * A mock function with the signature of `T`, and the mock API of {@link MockInstance}.
  *
- * It takes the place of jest's `MockedFunction<T>` and Vitest's `MockedFunction<T>`. The mock factories type each
- * method of a mock with it, so `interaction.reply.mockResolvedValue(...)` type-checks. For an overloaded method, such as
- * a manager's `fetch`, the mock API takes what any of its overloads takes or returns.
+ * It takes the place of jest's `MockedFunction<T>` and Vitest's `MockedFunction<T>`, and the mock factories type each
+ * method of a mock with it. Calling the mock is checked against `T`. The values its mock API takes and records are
+ * not, for a plain function as for an overloaded one: `mockReturnValue` and `mockResolvedValue` take any value,
+ * `mockImplementation` takes any function, and each of `mock.calls`' arguments and each of `mock.results`' values reads
+ * as `any`. So a partial fake, such as `guild.members.fetch.mockResolvedValue({ id })`, type-checks, and so does a
+ * value of the wrong type.
  *
  * @group Testing
  * @category Mocks
@@ -1103,7 +1108,10 @@ type NotRaw<T> = T extends {
  * 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
+ * every answer the interaction got. Under `useStrictMocks()` an answer marks the interaction `replied` or `deferred`
+ * once it resolves, as discord.js does after Discord takes it: an edit or follow-up made before then rejects with
+ * `InteractionNotReplied`, and a second answer sent while the first is in flight is refused with Discord's 40060. In
+ * default mode the mark is made at the call, with a warning where a bot would fail. Every method is a mock function, and one that returns a promise in discord.js
  * resolves. What the mock computes for itself, such as `memberPermissions` and `appPermissions`, calls none of them and
  * caches nothing, so a stub a test sets stays for its own code.
  *
@@ -1295,7 +1303,8 @@ interface MockGuildOverrides {
     channels?: readonly GuildBasedChannel[];
 }
 /**
- * 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.
@@ -1305,9 +1314,11 @@ interface MockGuildOverrides {
  *
  * @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
@@ -1616,8 +1627,9 @@ declare function createChatInputOptions<Cached extends CacheType = any>(opts?: C
  * and `message.thread` is `null` when the channel caches no thread under the message's id. So do a message's
  * `editedAt`, a member's `presence`, a server's `verified` and `systemChannel` and a channel's `parent`, each `null` or
  * `false` until the test gives what it is computed from. A reaction's `me` is `false`, a message's
- * `mentions.repliedUser` and a modal's `message` are `null`, and a reaction has a whole message of its own, so
- * MeoCord's dispatcher fetches neither. No placeholder warning is logged.
+ * `mentions.repliedUser` and a modal's `message` are `null`, an interaction's `ephemeral` is `null` until `reply()` or
+ * `deferReply()` decides it, and a reaction has a whole message of its own, so MeoCord's dispatcher fetches neither. No
+ * placeholder warning is logged.
  *
  * @remarks
  * Those getters read what a server holds, so strict mocks also have it as Discord sends it: the bot's member is in the
@@ -1630,8 +1642,10 @@ declare function createChatInputOptions<Cached extends CacheType = any>(opts?: C
  * A message the bot sends is its `client.user`'s, and one it sends in a DM is in that DM. Give the bot's member a role
  * to let it do more, such as kick a member its role ranks above. A value the test sets on a mock wins over the computed
  * one. An interaction's answer that discord.js would refuse, such as a second `reply()` after one a test set with
- * `mockResolvedValue`, is refused too, where without it the mock runs it and warns. The next major version (5.0)
- * computes these values, and refuses those answers, without the call.
+ * `mockResolvedValue`, is refused too, where without it the mock runs it and warns. An answer marks the interaction
+ * `replied`, `deferred` or `responded` once it resolves, as discord.js does, so code that doesn't await one fails as it
+ * would on a bot, within one run of the test's code. The next major version (5.0) computes these values, and refuses
+ * those answers, without the call.
  *
  * `invoke` also refuses a call that gives a handler fewer arguments than it declares where it builds none, such as a
  * reaction handler given its reaction without its `ReactionEvent`; without strict mocks, it warns once and calls it.