meocord 4.2.1 → 4.2.3

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

@@ -1,10 +1,10 @@
 import { ServiceIdentifier, Container } from 'inversify';
-import { Client, Interaction, Message, MessageReaction, PartialMessageReaction, User, PartialUser, ClientEvents, Base, Locale, GuildMember, Role, GuildBasedChannel, Guild, APIMessageTopLevelComponent, JSONEncodable, APIEmbed, MessageFlagsResolvable, TextBasedChannel, BaseChannel, APIAuthorizingIntegrationOwnersMap, APIInteractionGuildMember, PermissionResolvable, APIUser, CacheType, CommandInteractionOptionResolver, ThreadChannel, AnyThreadChannel, ChatInputCommandInteraction, AutocompleteInteraction, MessageContextMenuCommandInteraction, UserContextMenuCommandInteraction, PrimaryEntryPointCommandInteraction, ContextMenuCommandInteraction, CommandInteraction, ButtonInteraction, StringSelectMenuInteraction, UserSelectMenuInteraction, RoleSelectMenuInteraction, MentionableSelectMenuInteraction, ChannelSelectMenuInteraction, MessageComponentInteraction, ModalSubmitInteraction, BaseInteraction, DMChannel, PartialGroupDMChannel, OmitPartialGroupDMChannel, Attachment, ModalSubmitFields, MessagePayload, InteractionReplyOptions, InteractionUpdateOptions, InteractionEditReplyOptions, MessageEditOptions, APIModalInteractionResponseCallbackData, ModalComponentData, InteractionDeferReplyOptions, InteractionDeferUpdateOptions, MessageResolvable, DiscordAPIError } from 'discord.js';
+import { Client, Interaction, Message, MessageReaction, PartialMessageReaction, User, PartialUser, ClientEvents, Base, Locale, GuildMember, Role, GuildBasedChannel, Guild, APIMessageTopLevelComponent, JSONEncodable, APIEmbed, MessageFlagsResolvable, TextBasedChannel, BaseChannel, APIAuthorizingIntegrationOwnersMap, APIInteractionGuildMember, PermissionResolvable, APIUser, CacheType, CommandInteractionOptionResolver, ThreadChannel, AnyThreadChannel, ChatInputCommandInteraction, AutocompleteInteraction, MessageContextMenuCommandInteraction, UserContextMenuCommandInteraction, PrimaryEntryPointCommandInteraction, ContextMenuCommandInteraction, CommandInteraction, ButtonInteraction, StringSelectMenuInteraction, UserSelectMenuInteraction, RoleSelectMenuInteraction, MentionableSelectMenuInteraction, ChannelSelectMenuInteraction, MessageComponentInteraction, ModalSubmitInteraction, BaseInteraction, DMChannel, PartialGroupDMChannel, OmitPartialGroupDMChannel, Attachment, ModalSubmitFields, MessagePayload, InteractionReplyOptions, InteractionUpdateOptions, InteractionEditReplyOptions, MessageEditOptions, APIModalInteractionResponseCallbackData, ModalComponentData, InteractionDeferReplyOptions, InteractionDeferUpdateOptions, MessageResolvable, LaunchActivityOptions, ApplicationCommandOptionChoiceData, DiscordAPIError } from 'discord.js';
 import { ReactionHandlerAction, CommandType } from '../enum/index.js';
-import { a8 as Provider, P as ProviderToken } from '../index-DKJclIi-.js';
+import { a8 as Provider, P as ProviderToken } from '../index-Brkd6QGL.js';
 import { CooldownStore, ExecutionContextType, ExecutionContext, CooldownScope, MetadataDecorator, ResponsePhase, ResponseCall } from '../common/index.js';
 import { DispatchObserver, GuardInterface, InterceptorInterface, ExceptionFilter, ThemeOverride, ThemeResolvers, ThemeResolver, MessageCommandOptions, MessagePrefix, RootTheme, DeepReadonly, MeoCordTheme } from '../interface/index.js';
-export { ao as ClassProvider, F as FactoryProvider, ap as ValueProvider } from '../index-DKJclIi-.js';
+export { ao as ClassProvider, F as FactoryProvider, ap as ValueProvider } from '../index-Brkd6QGL.js';
 import { ThemeCache } from '../common/index.js';
 import { Translator } from '../common/index.js';
 import '@rsbuild/core';
@@ -216,6 +216,8 @@ declare class TestingModule {
     private readonly services;
     /** How long `close()` waits for the `onShutdown` hooks, as the bot's `shutdownTimeout` does. */
     private readonly shutdownTimeout;
+    /** The `app`, whose presenter `init()` makes after the providers, as the bot does. */
+    private readonly app?;
     constructor(container: Container, controllers?: readonly (new (...args: any[]) => unknown)[], eventClasses?: readonly (new (...args: any[]) => unknown)[], providers?: ProviderMap, order?: readonly unknown[], messageOptions?: MessageCommandOptions, lifecycle?: readonly LifecycleUnit[], 
     /** The lifecycle units the container has constructed, which `close()` shuts down. */
     constructed?: ReadonlySet<unknown>, 
@@ -224,8 +226,12 @@ declare class TestingModule {
     /** The app's listed services, made at `init()` as the bot makes them before it logs in. */
     services?: readonly (new (...args: any[]) => unknown)[], 
     /** How long `close()` waits for the `onShutdown` hooks, as the bot's `shutdownTimeout` does. */
-    shutdownTimeout?: number);
+    shutdownTimeout?: number, 
+    /** The `app`, whose presenter `init()` makes after the providers, as the bot does. */
+    app?: object | undefined);
     private resolving?;
+    /** The instances whose `@On` and `@Once` handlers `emit` runs, read at `init()`. */
+    private sources?;
     private readying?;
     private closing?;
     /** The `onReady` hooks' pass, which `close()` waits for, less one whose `onReady` called `close()`. */
@@ -358,16 +364,24 @@ declare class TestingModule {
      *   command's or an autocomplete's options, or the handler's customId params with a modal's fields or
      *   a select menu's choices.
      *   An interaction's customId or command name must be one dispatch routes to the handler, ranking
-     *   every handler of the module as the bot does; a mock built without one is not checked. With a message alone, a patterned `@MessageHandler` gets the
-     *   params its pattern captures from the content, after the prefix of the module's `app`, with typed
-     *   params resolved as dispatch resolves them, from the message's guild caches first; a message
-     *   without content gets `{}`. A word that is not a value of its type, and a prefixed message that names
-     *   the command but leaves out a param, go through the handler's filters as a `MessageUsageError`, as
-     *   dispatch answers them.
+     *   every handler of the module as the bot does; a mock built without one is not checked. An autocomplete is
+     *   checked by its command path and its focused option: one dispatch gives to another `@Autocomplete` handler,
+     *   or to none, is refused under `useStrictMocks()`, and otherwise warned about once and run.
+     *   With a message alone, a patterned `@MessageHandler` gets the params its pattern captures from the content,
+     *   after the prefix of the module's `app`, with typed params resolved as dispatch resolves them, from the
+     *   message's guild caches first. A message whose `content` isn't a string, as a mock's without
+     *   `useStrictMocks()`, gets `{}`. Under strict mocks a message has empty `content`, and a patterned handler
+     *   rejects it, as dispatch runs no handler for a message with no text: give the mock the `content` the handler
+     *   takes. A word that is not a value of its type, and a prefixed message that names the command but leaves out
+     *   a param, go through the handler's filters as a `MessageUsageError`, as dispatch answers them.
+     *   An `@On` or `@Once` handler no route reaches runs as {@link emit} runs it, as an event with the arguments given,
+     *   under `useStrictMocks()`; without strict mocks it runs as its first argument's type, and `invoke` warns once
+     *   where that differs.
      * @returns Whether the handler ran, and the error a filter handled, if any. Rejects with an error no
      *   filter handles, or with the error a filter throws: the built-in fallback, which answers such
      *   errors in the bot, does not run here. Rejects before running anything with an interaction or a
-     *   message the handler's route does not match, naming both. Given fewer arguments than the handler
+     *   message the handler's route does not match, naming both, and under `useStrictMocks()` with such an
+     *   autocomplete. Given fewer arguments than the handler
      *   declares, with a first that is neither an interaction nor a message, such as a reaction without its
      *   `ReactionEvent`, it rejects under `useStrictMocks()`, and otherwise warns once and runs the handler.
      *
@@ -394,6 +408,22 @@ declare class TestingModule {
     invoke<C extends new (...args: any[]) => unknown, M extends HandlerName<C>>(controller: C, methodName: M, ...args: HandlerArgs<C, M>): Promise<InvocationResult>;
     /** The handlers already warned about for being given fewer arguments than they take, so each is named once. */
     private readonly warnedArgumentCounts;
+    /** The `@On` and `@Once` handlers already warned about for running other than as an event, so each is named once. */
+    private readonly warnedEventRuns;
+    /**
+     * Warns once, without strict mocks, that `invoke` runs an event handler other than as the bot does: as the type its
+     * first argument gives, or with params it added. Only `invoke` warns, on the test's own call.
+     */
+    private warnEventRun;
+    /** Runs an `@On` or `@Once` handler as the bot and `emit` do: as an event, with its arguments as given. */
+    private runEventHandler;
+    /** The autocomplete mismatches already warned about without strict mocks, so each handler and route warns once. */
+    private readonly warnedAutocompleteRoutes;
+    /**
+     * Refuses under strict mocks, and otherwise warns once, an autocomplete dispatch gives to another handler or to none.
+     * Without strict mocks the handler still runs, since a test that passes that way would fail.
+     */
+    private checkAutocompleteRoute;
     /**
      * Refuses under `useStrictMocks()`, or warns once otherwise, a call that gives a handler fewer arguments than it
      * declares when `invoke` builds none for it, as for a reaction given without its `ReactionEvent`.
@@ -404,10 +434,17 @@ declare class TestingModule {
     /** Counts `call` as under way until it settles. */
     private track;
     /**
-     * Makes this module the app of the input's client, as the bot is of its own, so `respond()` outside any call,
-     * as in a collector's callback on that client, answers in this module's theme.
+     * Makes this module the app of the input's client, as the bot is of its own: its answers are drawn by this
+     * module's presenter, in its theme and language, `respond()` outside any call included, as in a collector's callback
+     * on that client. A module without a presenter clears the client's under strict mocks, so the default draws; default
+     * mode leaves another module's in place and warns once.
      */
     private registerClient;
+    /**
+     * Makes this module the app of each event argument's client, as the bot is of its own, under strict mocks; default
+     * mode leaves the clients as they are and warns once where this module would draw answers otherwise.
+     */
+    private registerEventClients;
     private builtComponentRoutes?;
     /** The module's component routes, ranked as dispatch ranks them; throws, as the bot would, for two of one shape. */
     private componentRoutes;
@@ -451,8 +488,9 @@ declare class TestingModule {
     /**
      * Emits a client event to the module's `@On` and `@Once` handlers, through the pipeline the app runs
      * them in up to its event fallback: the global guards of the module's `app`, then each handler's own.
-     * Handlers on the module's controllers, class providers and their dependencies all receive it. A
-     * `@Once` handler handles only the first event, as it would on a client.
+     * As on the bot, every instance the module runs lifecycle hooks on, the cooldown store aside, receives
+     * it: the controllers and services, what they and the stages inject, and each provided class or value.
+     * A `@Once` handler handles only the first event, as it would on a client.
      *
      * The bot's event fallback doesn't run here. On a bot, a guard's `GuardDeniedError` is logged and the
      * event skipped, and a handler's `UserError` is logged and, when the event carries a message, answered
@@ -519,7 +557,9 @@ declare class TestingModuleBuilder {
     /**
      * Replaces a provider with a test double.
      *
-     * The double needs only the members the test uses; misspelled member names are still rejected.
+     * The double needs only the members the test uses; misspelled member names are still rejected. A token MeoCord binds
+     * itself, such as `ShardContext` or `HandlerRegistry`, takes the double in place of MeoCord's own, so a test can stub
+     * cross-shard calls.
      *
      * @param token - The provider to replace.
      * @example
@@ -684,7 +724,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
@@ -746,9 +787,9 @@ type Implementation<T> = {
  * @see {@link MockState}
  */
 interface MockResult<T = unknown> {
-    /** `'return'` when the call returned, `'throw'` when it threw. */
-    type: 'return' | 'throw';
-    /** What the call returned, or the error it threw. */
+    /** `'return'` when the call returned, `'throw'` when it threw, `'incomplete'` while it is still running. */
+    type: 'return' | 'throw' | 'incomplete';
+    /** What the call returned, or the error it threw; `undefined` while it is incomplete. */
     value: T;
 }
 /**
@@ -796,7 +837,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 +880,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,9 +1148,14 @@ 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
- * 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.
+ * every answer the interaction got; under `useStrictMocks()`, `launchActivity()`, `sendPremiumRequired()` and an
+ * autocomplete's `respond()` count as answers too. Under `useStrictMocks()` an answer marks the interaction `replied`,
+ * `deferred` or, for an autocomplete, `responded` 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.
  *
  * An answer keeps that order whatever it is set to do: one a test gives a value with `mockResolvedValue` replies or
  * defers as a real one would, and one that rejects changes nothing. `fetchReply()` reads back what `reply()` or
@@ -1295,7 +1345,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,14 +1356,18 @@ 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
- * their managers' caches, where dispatch looks first when it resolves a message's typed params; a member
- * {@link createMockMember} made without a server is in this one. Its `roles.everyone` is the role given with the
- * guild's id, or else an @everyone role of its own at position 0 with no permissions, in `roles.cache` as Discord has
- * it. The guild is named `'Guild'` and its `preferredLocale` is `'en-US'` unless given, so `t.forGuild(guild)`
- * translates as for a new English server.
+ * caches under that id: a member, channel, emoji, sticker, scheduled event or AutoMod rule in this guild, a role with
+ * that id, a ban, or an invite with that code. `members.fetch({ user: ids })` resolves to a collection of each of those
+ * members, found or made the same way; `create()` resolves to a mock of its item, a channel of the type its options
+ * name under `useStrictMocks()`, which it caches as discord.js does, but for an invite, made for the channel given and
+ * cached nowhere; `edit()` resolves under `useStrictMocks()` to the item with the id given, found or made the same way,
+ * and under `useStrictMocks()` either takes the `name` its options give. A list fetch resolves to an empty collection.
+ * Members, roles and channels given are put in their managers' caches, where dispatch looks first when it resolves a
+ * message's typed params; a member {@link createMockMember} made without a server is in this one. Its `roles.everyone`
+ * is the role given with the guild's id, or else an @everyone role of its own at position 0, in `roles.cache` as
+ * Discord has it. That role has no permissions in default mode; under `useStrictMocks()` it has the ones Discord
+ * gives @everyone in a new server. The guild is named `'Guild'` and its `preferredLocale` is `'en-US'` unless given,
+ * so `t.forGuild(guild)` translates as for a new English server.
  *
  * The mock makes a member for any id it's asked for, so a test of an id that isn't a member rejects the fetch, as
  * `guild.members.fetch.mockRejectedValue(createDiscordError(10007))`, or resolves a collection without that member.
@@ -1575,7 +1630,8 @@ interface ChatInputOptions {
  * entity option carries its id in `value` and the object itself, as the gateway sends it: a user option its `user`,
  * and in a server its `member` too. A user option's
  * `getMember()` is the user's member in the server of the interaction the options are given to, and `null` in a DM;
- * a member given resolves `getUser()` to its user. A getter throws discord.js's type error for an option of another
+ * a member given resolves `getUser()` to its user. Under `useStrictMocks()` a user option's `getMentionable()` is its
+ * member too where there is one, as discord.js reads it; default mode returns the user, with a warning once. A getter throws discord.js's type error for an option of another
  * type, as discord.js does, required or not. Only a user or member read as a role, or a role read as a user or member,
  * is `null`, or that error when required, as the option may be a mentionable one; a plain `{ id }` reads as any entity.
  * A whole number is an Integer option and a fraction a Number one, so
@@ -1583,7 +1639,13 @@ interface ChatInputOptions {
  *
  * The `focused` option reads as Discord sends it, through `getFocused()`, `getFocused(true)` and `data` alike: a
  * string, `''` when no value is given, and marked `focused` in `data`. A number given for it is its digits under
- * `useStrictMocks()`; otherwise it stays the number, with a warning when read.
+ * `useStrictMocks()`; otherwise it stays the number, with a warning when read. Under `useStrictMocks()` `get()` and the
+ * typed getters read it by name from that same option, as discord.js does; one given no value takes the string,
+ * integer and number getters alike. Default mode reads what was given, `null` for no value, with a warning once.
+ *
+ * Given to an `AutocompleteInteraction`, a user, member, role, channel, mentionable or attachment option reads as
+ * Discord sends an autocomplete's options under `useStrictMocks()`: its id alone, in `data` and the handler's params,
+ * with the entity getters returning `null`. Otherwise it keeps the object given, with a warning once.
  *
  * @typeParam Cached - `any` by default, to match `createMockInteraction(ChatInputCommandInteraction)`; pass it when the
  *   interaction under test is cache-pinned.
@@ -1616,8 +1678,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,11 +1693,14 @@ 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.
+ * It refuses an autocomplete that dispatch gives to another `@Autocomplete` handler, or to none, the same way.
  *
  * `compile()` also refuses an `overrideGuard`, `overrideInterceptor` or `overrideFilter` stub without the stage's
  * method, `canActivate`, `intercept` or `catch`; without strict mocks, it warns and builds the module.
@@ -1701,9 +1767,14 @@ interface MessageToResolve {
     botId?: string;
     /**
      * Whether the message is a direct message, where `mention: 'only'` does not apply, and a handler that works only in
-     * a server, by its scope or a `member`, `role` or `channel` param in its pattern, is not reached, as dispatch answers
-     * it with its usage. A flag of those types is refused only when the message gives it, which this does not read.
-     * Without it the message may be from anywhere, and a mention alone starts what it starts in a server.
+     * a server, by its scope or a `member`, `role` or `channel` param in its pattern, is not reached, as dispatch never
+     * runs it: it answers "This command works in a server only." to a message sent with a prefix or a mention, and
+     * nothing to one without, which may be chat. Under `useStrictMocks()` a handler with a required flag of those types,
+     * or one the message gives, is not reached either, as dispatch refuses it the same way; default mode resolves it,
+     * with a warning. Without it, a mention alone starts what it starts in a server, and a handler of any scope may
+     * answer, with a warning where one that works only in a DM does. Under `useStrictMocks()`, the message is read as
+     * sent in a server, as dispatch reads one: such a handler is passed over for one that works there, or resolves to
+     * `undefined`.
      */
     dm?: boolean;
 }
@@ -1875,11 +1946,13 @@ declare function createModalFields(values: Record<string, string | string[] | At
  *
  * Use it in a test for a team that wants no fallback in production. It reports the messages a locale lacks, the
  * messages the default catalog doesn't have, the plural forms a language needs but a plural lacks, such as `few` for
- * Russian, a translation of another shape than the default's, a text for a plural or a plural for a text, and each
- * `{param}` a translation uses that the message it translates doesn't take. An empty translation, `''`, counts as
- * lacking, as the translator reads it as missing. It reads the catalogs' own strings, so it checks the params of a
- * catalog from a plain variable or a JSON file too, which the compiler can't. An object counts as a plural only when
- * its every key is a plural category, so a group with an `other` key is a group.
+ * Russian, a translation of another shape than the default's, a text for a plural or a group, or a plural for a text, and each
+ * `{param}` a translation uses that the message it translates doesn't take. An empty translation, `''` or `null`, counts
+ * as lacking, as the translator reads it as missing. It reads the catalogs' own strings, so it checks the params of a
+ * catalog from a plain variable or a JSON file too, which the compiler can't. An object in the default catalog counts as
+ * a plural only when its every key is a plural category, so a group with an `other` key is a group, and a translation
+ * is read by the default catalog's shapes, as the translator reads it: one that keeps only a group's `other` message
+ * lacks the group's other messages.
  *
  * @remarks
  * MeoCord's own texts, a catalog's `meocord` group, fall back to English by design, so only a key MeoCord lacks, and
@@ -2068,9 +2141,15 @@ interface HandlerInspection {
     readonly controller: new (...args: any[]) => unknown;
     /** The handler method's name. */
     readonly methodName: string;
-    /** The guards that run before the handler, in order: global guards, class guards, then method guards. */
+    /**
+     * The guards that run before the handler, in order: global guards, class guards, then method guards. Under
+     * `useStrictMocks()`, only those for the handler's context types.
+     */
     readonly guards: readonly InspectedGuard[];
-    /** The interceptors around the handler, outermost first: global, class, then method interceptors. */
+    /**
+     * The interceptors around the handler, outermost first: global, class, then method interceptors. Under
+     * `useStrictMocks()`, only those for the handler's context types, and none for an autocomplete.
+     */
     readonly interceptors: readonly InspectedInterceptor[];
     /**
      * The exception filters for the handler, in the order they are tried: the method's, then the
@@ -2083,11 +2162,16 @@ interface HandlerInspection {
     readonly pattern: string | undefined;
     /**
      * The routes the handler answers because a class its controller extends declares them, such as `slash "ping"`:
-     * those its own class doesn't declare for it. Empty for a handler that declares all it answers. A test reads it;
-     * `toEqual` doesn't compare it, so an assertion on the other fields holds either way.
+     * those its own class doesn't declare for it. Empty for a handler that declares all it answers. Under
+     * `useStrictMocks()` it names an inherited `@On` or `@Once` event too, such as `event "guildCreate"`; default mode
+     * leaves events out, with a warning once where it would name one. A test reads it; `toEqual` doesn't compare it, so
+     * an assertion on the other fields holds either way.
      */
     readonly inheritedRoutes: readonly string[];
-    /** The `app`'s observers, in the order they are told about the call; empty without an `app`. */
+    /**
+     * The `app`'s observers, in the order they are told about the call; empty without an `app`. Under `useStrictMocks()`,
+     * only those whose `types` include the handler's.
+     */
     readonly observers: readonly (new (...args: any[]) => DispatchObserver)[];
     /**
      * Reads a metadata value as `ExecutionContext.get` does: the method's value, else the controller's.
@@ -2155,8 +2239,10 @@ interface InspectHandlerOptions {
  * Reports what runs when a handler is dispatched, and the metadata declared on it, without running anything.
  *
  * Use it to check that decorators set a handler up as intended: its guards with their params, its interceptors,
- * filters and cooldowns, in the order dispatch applies them. To check what a handler does, run it with
- * {@link TestingModule.invoke}.
+ * filters and cooldowns, in the order dispatch applies them. Under `useStrictMocks()`, the guards, interceptors and
+ * observers are those dispatch runs for the handler's context types: a stage declared with `types` is listed only for
+ * a handler of one of them, and an autocomplete lists no interceptors. Default mode lists every one, with a warning
+ * once where dispatch runs fewer. To check what a handler does, run it with {@link TestingModule.invoke}.
  *
  * @param controller - The controller class declaring the handler.
  * @param methodName - The handler method's name.
@@ -2201,7 +2287,8 @@ interface ResponseReport {
     /**
      * Every answer call the interaction got, through `respond()` or discord.js directly, in order: the payload it sent,
      * without `withResponse`, and the `error` of one Discord refused. Checking a call's `method` types its `payload` as
-     * that method takes it: the options of a reply, an edit or a deferral, the modal shown, or the message deleted.
+     * that method takes it: the options of a reply, an edit or a deferral, the modal shown, the message deleted, or an
+     * autocomplete's choices.
      */
     calls: readonly ((ResponseCall & {
         method: 'reply' | 'followUp';
@@ -2227,15 +2314,25 @@ interface ResponseReport {
     }) | (ResponseCall & {
         method: 'deleteReply';
         payload?: MessageResolvable | '@original';
+    }) | (ResponseCall & {
+        method: 'launchActivity';
+        payload?: Omit<LaunchActivityOptions, 'withResponse'>;
+    }) | (ResponseCall & {
+        method: 'sendPremiumRequired';
+        payload?: undefined;
+    }) | (ResponseCall & {
+        method: 'respond';
+        payload?: readonly ApplicationCommandOptionChoiceData[];
     }))[];
 }
 /**
  * Reports how an interaction was answered: where its answer stands, and every answer call it got, in order.
  *
  * Use it after `invoke` or `dispatch` to check what the member sees. A mock interaction records each `reply`,
- * `deferReply`, `editReply`, `followUp`, `deleteReply`, `update`, `deferUpdate` and `showModal`, whether the handler
- * made it through `respond()` or with discord.js directly, so both are reported, each once. For a message or a
- * reaction, read the mock's own methods.
+ * `deferReply`, `editReply`, `followUp`, `deleteReply`, `update`, `deferUpdate` and `showModal`, and under
+ * `useStrictMocks()` each `launchActivity`, `sendPremiumRequired` and autocomplete `respond` too, whether the handler made
+ * it through `respond()` or with discord.js directly, so both are reported, each once. For a message or a reaction, read
+ * the mock's own methods.
  *
  * @param interaction - The interaction a handler answered.
  * @returns The state, whether anything the member can see was sent, and the calls, in order.

package/dist/types/{theme-resolvers-CyEz9pnv.d.cts → theme-resolvers-AtgeaYqF.d.cts}

@@ -1,4 +1,4 @@
-import './index-Dlf0ZZtS.cjs';
+import './index-CqXImwF_.cjs';
 
 /**
  * An app's cache of the themes `@MeoCord({ themeFor })` looked up, by server and by user.

package/dist/types/{theme-resolvers-DA204O-q.d.ts → theme-resolvers-BgqysV8d.d.ts}

@@ -1,4 +1,4 @@
-import './index-DKJclIi-.js';
+import './index-Brkd6QGL.js';
 
 /**
  * An app's cache of the themes `@MeoCord({ themeFor })` looked up, by server and by user.

package/dist/types/{translator-Bg7hwxDF.d.cts → translator-D8aydlCE.d.ts}

@@ -1,5 +1,15 @@
 import { Locale, Interaction, Guild } from 'discord.js';
-import { aq as MeoCordMessages } from './index-Dlf0ZZtS.cjs';
+import { aq as MeoCordMessages } from './index-Brkd6QGL.js';
+
+/** Each character of a string, as a union; tail-recursive, so a long string stays within the compiler's depth. */
+type Chars<S extends string, Found = never> = S extends `${infer First}${infer Rest}` ? Chars<Rest, Found | First> : Found;
+/** A character `\w` matches without the `u` flag: ASCII letters, digits and `_`. */
+type WordChar = Chars<'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_'>;
+/**
+ * Whether a string is one or more word characters, as a `{name}` takes them in a message or a customId pattern. It
+ * reads 16 at a time, so a name up to 16,000 characters long stays within the compiler's 1,000 steps of tail recursion.
+ */
+type IsWord<S extends string> = S extends `${infer A}${infer B}${infer C}${infer D}${infer E}${infer F}${infer G}${infer H}${infer I}${infer J}${infer K}${infer L}${infer M}${infer N}${infer O}${infer P}${infer Rest}` ? [A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P] extends [WordChar] ? Rest extends '' ? true : IsWord<Rest> : false : S extends `${WordChar}${infer Rest}` ? Rest extends '' ? true : IsWord<Rest> : false;
 
 /**
  * The plural categories `Intl.PluralRules` selects between.
@@ -61,15 +71,6 @@ type LocalizationKey<C> = {
 }[StringMessageKey<C>];
 /** The message at a key. */
 type MessageAt<C, K extends string> = K extends `${infer Head}.${infer Rest}` ? Head extends keyof C ? MessageAt<C[Head], Rest> : never : K extends keyof C ? C[K] : never;
-/** Each character of a string, as a union; tail-recursive, so a long string stays within the compiler's depth. */
-type Chars<S extends string, Found = never> = S extends `${infer First}${infer Rest}` ? Chars<Rest, Found | First> : Found;
-/** A character `\w` matches without the `u` flag: ASCII letters, digits and `_`. */
-type WordChar = Chars<'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_'>;
-/**
- * Whether a string is one or more word characters. It reads 16 at a time, so a name up to 16,000 characters long stays
- * within the compiler's 1,000 steps of tail recursion.
- */
-type IsWord<S extends string> = S extends `${infer A}${infer B}${infer C}${infer D}${infer E}${infer F}${infer G}${infer H}${infer I}${infer J}${infer K}${infer L}${infer M}${infer N}${infer O}${infer P}${infer Rest}` ? [A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P] extends [WordChar] ? Rest extends '' ? true : IsWord<Rest> : false : S extends `${WordChar}${infer Rest}` ? Rest extends '' ? true : IsWord<Rest> : false;
 /**
  * The `{param}` names of a message, read from the left as translating reads them: `{{` is a brace written as text, and
  * `{` then word characters then `}` is a param. Where the braces hold anything else, reading resumes after the `{`.
@@ -367,4 +368,4 @@ declare abstract class Translator<C = CatalogShape> {
 declare function createTranslator<const Locales extends Readonly<Record<string, CatalogShape>>, const Default extends keyof Locales & `${Locale}`>(options: TranslatorOptions<Locales, Default>): Translator<Locales[Default]>;
 
 export { Translator as T, createTranslator as g, defineCatalog as h };
-export type { CatalogDefinition as C, LocaleCatalog as L, MessageKey as M, PluralCategory as P, StringMessageKey as S, CatalogShape as a, LocalizationKey as b, MessageParams as c, PluralMessage as d, Translate as e, TranslatorOptions as f };
+export type { CatalogDefinition as C, IsWord as I, LocaleCatalog as L, MessageKey as M, PluralCategory as P, StringMessageKey as S, CatalogShape as a, LocalizationKey as b, MessageParams as c, PluralMessage as d, Translate as e, TranslatorOptions as f };

package/dist/types/{translator-CeP4bCzp.d.ts → translator-iJhDlgwL.d.cts}

@@ -1,5 +1,15 @@
 import { Locale, Interaction, Guild } from 'discord.js';
-import { aq as MeoCordMessages } from './index-DKJclIi-.js';
+import { aq as MeoCordMessages } from './index-CqXImwF_.cjs';
+
+/** Each character of a string, as a union; tail-recursive, so a long string stays within the compiler's depth. */
+type Chars<S extends string, Found = never> = S extends `${infer First}${infer Rest}` ? Chars<Rest, Found | First> : Found;
+/** A character `\w` matches without the `u` flag: ASCII letters, digits and `_`. */
+type WordChar = Chars<'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_'>;
+/**
+ * Whether a string is one or more word characters, as a `{name}` takes them in a message or a customId pattern. It
+ * reads 16 at a time, so a name up to 16,000 characters long stays within the compiler's 1,000 steps of tail recursion.
+ */
+type IsWord<S extends string> = S extends `${infer A}${infer B}${infer C}${infer D}${infer E}${infer F}${infer G}${infer H}${infer I}${infer J}${infer K}${infer L}${infer M}${infer N}${infer O}${infer P}${infer Rest}` ? [A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P] extends [WordChar] ? Rest extends '' ? true : IsWord<Rest> : false : S extends `${WordChar}${infer Rest}` ? Rest extends '' ? true : IsWord<Rest> : false;
 
 /**
  * The plural categories `Intl.PluralRules` selects between.
@@ -61,15 +71,6 @@ type LocalizationKey<C> = {
 }[StringMessageKey<C>];
 /** The message at a key. */
 type MessageAt<C, K extends string> = K extends `${infer Head}.${infer Rest}` ? Head extends keyof C ? MessageAt<C[Head], Rest> : never : K extends keyof C ? C[K] : never;
-/** Each character of a string, as a union; tail-recursive, so a long string stays within the compiler's depth. */
-type Chars<S extends string, Found = never> = S extends `${infer First}${infer Rest}` ? Chars<Rest, Found | First> : Found;
-/** A character `\w` matches without the `u` flag: ASCII letters, digits and `_`. */
-type WordChar = Chars<'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_'>;
-/**
- * Whether a string is one or more word characters. It reads 16 at a time, so a name up to 16,000 characters long stays
- * within the compiler's 1,000 steps of tail recursion.
- */
-type IsWord<S extends string> = S extends `${infer A}${infer B}${infer C}${infer D}${infer E}${infer F}${infer G}${infer H}${infer I}${infer J}${infer K}${infer L}${infer M}${infer N}${infer O}${infer P}${infer Rest}` ? [A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P] extends [WordChar] ? Rest extends '' ? true : IsWord<Rest> : false : S extends `${WordChar}${infer Rest}` ? Rest extends '' ? true : IsWord<Rest> : false;
 /**
  * The `{param}` names of a message, read from the left as translating reads them: `{{` is a brace written as text, and
  * `{` then word characters then `}` is a param. Where the braces hold anything else, reading resumes after the `{`.
@@ -367,4 +368,4 @@ declare abstract class Translator<C = CatalogShape> {
 declare function createTranslator<const Locales extends Readonly<Record<string, CatalogShape>>, const Default extends keyof Locales & `${Locale}`>(options: TranslatorOptions<Locales, Default>): Translator<Locales[Default]>;
 
 export { Translator as T, createTranslator as g, defineCatalog as h };
-export type { CatalogDefinition as C, LocaleCatalog as L, MessageKey as M, PluralCategory as P, StringMessageKey as S, CatalogShape as a, LocalizationKey as b, MessageParams as c, PluralMessage as d, Translate as e, TranslatorOptions as f };
+export type { CatalogDefinition as C, IsWord as I, LocaleCatalog as L, MessageKey as M, PluralCategory as P, StringMessageKey as S, CatalogShape as a, LocalizationKey as b, MessageParams as c, PluralMessage as d, Translate as e, TranslatorOptions as f };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "meocord",
   "description": "Decorator-based framework for Discord bots on discord.js, with dependency injection, guards, a CLI and a testing toolkit.",
-  "version": "4.2.1",
+  "version": "4.2.3",
   "type": "module",
   "engines": {
     "node": ">=22.13"
@@ -24,7 +24,8 @@
     "bench:messages": "bun scripts/bench-messages.ts",
     "bench:theme": "bun scripts/bench-theme.ts",
     "changeset": "changeset",
-    "release:version": "changeset version && bun scripts/check-jsdoc-examples.ts --fix && bun scripts/release-notes.ts && prettier --write CHANGELOG.md",
+    "release:version": "bun run notes:check && changeset version && bun scripts/check-jsdoc-examples.ts --fix && bun scripts/release-notes.ts && prettier --write CHANGELOG.md",
+    "notes:check": "bun scripts/release-notes.ts --check",
     "notices": "bun scripts/third-party-notices.ts",
     "notices:check": "bun scripts/third-party-notices.ts --check",
     "check:jsdoc-examples": "bun scripts/check-jsdoc-examples.ts",
@@ -196,6 +197,8 @@
     "discord.js",
     "typescript",
     "bot-framework",
+    "discord-bot-framework",
+    "discord-framework",
     "decorator",
     "dependency-injection",
     "inversify",