meocord 4.1.0-beta.0 → 4.1.0-beta.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # meocord
 
+## 4.1.0-beta.1
+
+### Minor Changes
+
+- [#120](https://github.com/meocord/meocord/pull/120) [`9d435d9`](https://github.com/meocord/meocord/commit/9d435d9da2bc62eab012ea2b80df2c1e001a926e) Thanks [@l7aromeo](https://github.com/l7aromeo)! - `createMockMessage()` takes an `id`, `content`, `components`, `embeds` and `flags`, so a test can put controls on the message a button sits on, such as to check what `@Defer` locks; components and embeds may be API JSON, builders or discord.js instances.
+
+### Patch Changes
+
+- [#118](https://github.com/meocord/meocord/pull/118) [`5c636aa`](https://github.com/meocord/meocord/commit/5c636aa930224aef9b4670a5e16b234a3f57397d) Thanks [@l7aromeo](https://github.com/l7aromeo)! - Tools that read the installed version with `require('meocord/package.json')` no longer fail with `ERR_PACKAGE_PATH_NOT_EXPORTED`.
+
+- [#121](https://github.com/meocord/meocord/pull/121) [`c6990c2`](https://github.com/meocord/meocord/commit/c6990c250f7694ca5adb9963e89f151b7ed5dc4b) Thanks [@l7aromeo](https://github.com/l7aromeo)! - `inGuild()`, `inCachedGuild()` and `inRawGuild()` on a mock answer from its `guildId` and `guild`, so a mock created without a `guildId` is a DM and a guard that requires a guild returns `false`, not `undefined`.
+
 ## 4.1.0-beta.0
 
 ### Minor Changes

package/README.md

@@ -1524,6 +1524,8 @@ Creates a smart mock instance of any discord.js class. The full prototype chain
 
 **Type guards run real logic** — `isButton()`, `isRepliable()`, `isChatInputCommand()`, etc. are backed by the actual discord.js prototype methods. The right fields (`type`, `componentType`, `commandType`) are set based on the class you pass in, so no manual `.mockReturnValue(true)` setup is needed. All type guard methods are still mock functions and can be overridden per test.
 
+**Guild checks read the mock's data** — `inGuild()`, `inCachedGuild()` and `inRawGuild()` answer from the `guildId` and `guild` the mock is given, as discord.js does: a `guildId` means a guild, a `guildId` with a `guild` (such as `createMockGuild()`) a cached one, and a mock created without a `guildId` is a DM, where all three return `false`. A `member` set to `null` or `undefined` makes all three `false` too.
+
 **Reply state machine** — for repliable interactions, `replied` and `deferred` start as `false`. Calling `reply()` or `deferReply()` twice throws, just like a real interaction. `followUp()`, `editReply()`, and `deleteReply()` throw if called before any reply. The ephemeral flag is tracked on `interaction.ephemeral`, read from `flags` only — the deprecated `ephemeral: true` reply option is not honoured. All reply methods are still mock functions so call assertions work normally.
 
 Autocomplete interactions are not repliable but get the equivalent for their own single-shot response: `responded` starts as `false`, `respond()` sets it, and a second call throws.
@@ -1547,6 +1549,10 @@ interaction.isChatInputCommand() // → true
 interaction.isRepliable() // → true
 interaction.isButton() // → false
 
+// created without a guildId, the mock is a DM
+interaction.inGuild() // → false
+interaction.inCachedGuild() // → false
+
 // reply state machine
 interaction.replied // → false
 await interaction.reply({ content: 'hi' })
@@ -1691,6 +1697,23 @@ edited.delete // → a mock fn
 expect(msg.delete).toHaveBeenCalledTimes(1)
 ```
 
+Without arguments the message is empty. Give it an `id`, `content`, `components`, `embeds` and `flags` to test code that reads them, such as a button on a message whose controls `@Defer` locks. Components and embeds may be API JSON, builders or discord.js instances, and `flags` a number, flag names or a `MessageFlagsBitField`:
+
+```typescript
+const message = createMockMessage({
+  components: [
+    new ActionRowBuilder<ButtonBuilder>().addComponents(
+      new ButtonBuilder().setCustomId('card/refresh').setLabel('Refresh').setStyle(ButtonStyle.Primary),
+    ),
+  ],
+  embeds: [{ title: 'Card' }],
+  flags: MessageFlags.Ephemeral,
+})
+const interaction = createMockInteraction(ButtonInteraction, { customId: 'card/refresh', message })
+```
+
+API JSON and builders are kept as their JSON behind `toJSON()`, which is what `respond()` and `@Defer` read; discord.js instances are kept as they are.
+
 </details>
 
 <details>

package/dist/cjs/testing/index.cjs

@@ -634,7 +634,9 @@ function findPrototypeMethod(instance, name) {
 /**
  * Creates a mock instance of a discord.js class, keeping its prototype so `instanceof` holds.
  *
- * Type guards such as `isButton()` run the real discord.js logic. Replies behave like a real
+ * Type guards such as `isButton()` run the real discord.js logic. `inGuild()`, `inCachedGuild()`
+ * and `inRawGuild()` answer from the mock's own `guildId` and `guild`, so a mock created without
+ * a `guildId` is a DM. Replies behave like a real
  * interaction: `reply()` or `deferReply()` twice throws, and `followUp()`, `editReply()` and
  * `deleteReply()` throw before a reply. Every method is a mock function you can override.
  *
@@ -667,6 +669,19 @@ function findPrototypeMethod(instance, name) {
             stubs.set(name, createMockFn().mockImplementation(()=>method.call(instance)));
         }
     }
+    // Guild checks read the mock's own data, since discord.js resolves `guild` through a client the
+    // mock lacks: a guildId is a guild, a guild object with it a cached one, neither a DM. A member
+    // not given is the auto-stub, so only one set to null or undefined fails the check.
+    const own = (key)=>Object.prototype.hasOwnProperty.call(instance, key) ? instance[key] : undefined;
+    const hasMember = ()=>!Object.prototype.hasOwnProperty.call(instance, 'member') || Boolean(instance.member);
+    const guildChecks = {
+        inGuild: ()=>Boolean(own('guildId') && hasMember()),
+        inCachedGuild: ()=>Boolean(own('guildId') && own('guild') && hasMember()),
+        inRawGuild: ()=>Boolean(own('guildId') && !own('guild') && hasMember())
+    };
+    for (const [name, check] of Object.entries(guildChecks)){
+        if (findPrototypeMethod(instance, name) !== null) stubs.set(name, createMockFn().mockImplementation(check));
+    }
     // Set up reply state machine for repliable interactions
     const isRepliableMethod = findPrototypeMethod(instance, 'isRepliable');
     const repliable = isRepliableMethod !== null && isRepliableMethod.call(instance);
@@ -900,6 +915,16 @@ function findPrototypeMethod(instance, name) {
     guild.bans = stubDeep(Object.create(discord_js.GuildBanManager.prototype));
     return stubDeep(guild);
 }
+/**
+ * A component or embed as a message holds it: a discord.js instance as it is; anything else as
+ * its API JSON at the time of the call, behind `toJSON()`.
+ */ function asHeld(value) {
+    if (value instanceof discord_js.Component || value instanceof discord_js.Embed) return value;
+    const json = structuredClone(typeof value.toJSON === 'function' ? value.toJSON() : value);
+    return {
+        toJSON: ()=>json
+    };
+}
 /**
  * Creates a mock {@link Message} that tracks whether it has been deleted.
  *
@@ -908,13 +933,30 @@ function findPrototypeMethod(instance, name) {
  * `msg.author.send` and `msg.guild.members.fetch` are ready to use, and every method is a mock
  * function you can override per test.
  *
+ * Without overrides the message is empty: no flags, components, embeds or attachments. Components
+ * and embeds given as API JSON or builders keep that JSON behind `toJSON()`, which is what
+ * `respond()` and `@Defer` read, such as when `@Defer` locks the controls of the message a button
+ * sits on; discord.js instances are kept as they are.
+ *
+ * @param overrides - The message's id, content, components, embeds and flags.
+ * @returns The mock message.
+ *
  * @example
  * ```ts
- * const message = createMockMessage()
+ * const message = createMockMessage({
+ *   components: [
+ *     new ActionRowBuilder<ButtonBuilder>().addComponents(
+ *       new ButtonBuilder().setCustomId('card/refresh').setLabel('Refresh').setStyle(ButtonStyle.Primary),
+ *     ),
+ *   ],
+ *   embeds: [{ title: 'Card' }],
+ * })
+ * const interaction = createMockInteraction(ButtonInteraction, { customId: 'card/refresh', message })
+ *
  * await message.delete()
  * message.deleted // true
  * ```
- */ function createMockMessage() {
+ */ function createMockMessage(overrides = {}) {
     const instance = Object.create(discord_js.Message.prototype);
     const stubs = new Map();
     instance.deleted = false;
@@ -942,10 +984,12 @@ function findPrototypeMethod(instance, name) {
     // MessageMentions — constructor-assigned, has methods like .has(), .members
     instance.mentions = stubDeep(Object.create(discord_js.MessageMentions.prototype));
     // Data a message always has, real rather than stubbed, so code reading it sees an empty message
-    instance.flags = new discord_js.MessageFlagsBitField();
-    instance.components = [];
-    instance.embeds = [];
+    instance.flags = new discord_js.MessageFlagsBitField(overrides.flags);
+    instance.components = (overrides.components ?? []).map(asHeld);
+    instance.embeds = (overrides.embeds ?? []).map(asHeld);
     instance.attachments = new discord_js.Collection();
+    if (overrides.id !== undefined) instance.id = overrides.id;
+    if (overrides.content !== undefined) instance.content = overrides.content;
     const alreadyDeleted = ()=>new Error('This message has already been deleted.');
     stubs.set('delete', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();

package/dist/esm/package.json.js

@@ -1,4 +1,4 @@
-var version = "4.1.0-beta.0";
+var version = "4.1.0-beta.1";
 var packageJson = {
 	version: version};
 

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

@@ -1,6 +1,6 @@
 import 'reflect-metadata';
 import { createMockFn } from './mock-fn.js';
-import { InteractionType, ComponentType, ApplicationCommandType, CommandInteractionOptionResolver, GuildMessageManager, ThreadManager, DMMessageManager, MessageManager, ThreadMemberManager, Client, ApplicationCommandManager, UserManager, ChannelManager, GuildManager, ClientUser, Guild, GuildMemberManager, GuildChannelManager, RoleManager, GuildBanManager, AuthorizingIntegrationOwners, Message, User, GuildMember, TextChannel, ThreadChannel, MessageMentions, MessageFlagsBitField, Collection, ApplicationCommandOptionType, Role, BaseChannel, Attachment } from 'discord.js';
+import { InteractionType, ComponentType, ApplicationCommandType, CommandInteractionOptionResolver, GuildMessageManager, ThreadManager, DMMessageManager, MessageManager, ThreadMemberManager, Client, ApplicationCommandManager, UserManager, ChannelManager, GuildManager, ClientUser, Guild, GuildMemberManager, GuildChannelManager, RoleManager, GuildBanManager, AuthorizingIntegrationOwners, Message, User, GuildMember, TextChannel, ThreadChannel, MessageMentions, MessageFlagsBitField, Collection, ApplicationCommandOptionType, Component, Embed, Role, BaseChannel, Attachment } from 'discord.js';
 
 // ---------------------------------------------------------------------------
 // stubDeep — Proxy that auto-creates a mock fn on any property access
@@ -163,7 +163,9 @@ function findPrototypeMethod(instance, name) {
 /**
  * Creates a mock instance of a discord.js class, keeping its prototype so `instanceof` holds.
  *
- * Type guards such as `isButton()` run the real discord.js logic. Replies behave like a real
+ * Type guards such as `isButton()` run the real discord.js logic. `inGuild()`, `inCachedGuild()`
+ * and `inRawGuild()` answer from the mock's own `guildId` and `guild`, so a mock created without
+ * a `guildId` is a DM. Replies behave like a real
  * interaction: `reply()` or `deferReply()` twice throws, and `followUp()`, `editReply()` and
  * `deleteReply()` throw before a reply. Every method is a mock function you can override.
  *
@@ -196,6 +198,19 @@ function findPrototypeMethod(instance, name) {
             stubs.set(name, createMockFn().mockImplementation(()=>method.call(instance)));
         }
     }
+    // Guild checks read the mock's own data, since discord.js resolves `guild` through a client the
+    // mock lacks: a guildId is a guild, a guild object with it a cached one, neither a DM. A member
+    // not given is the auto-stub, so only one set to null or undefined fails the check.
+    const own = (key)=>Object.prototype.hasOwnProperty.call(instance, key) ? instance[key] : undefined;
+    const hasMember = ()=>!Object.prototype.hasOwnProperty.call(instance, 'member') || Boolean(instance.member);
+    const guildChecks = {
+        inGuild: ()=>Boolean(own('guildId') && hasMember()),
+        inCachedGuild: ()=>Boolean(own('guildId') && own('guild') && hasMember()),
+        inRawGuild: ()=>Boolean(own('guildId') && !own('guild') && hasMember())
+    };
+    for (const [name, check] of Object.entries(guildChecks)){
+        if (findPrototypeMethod(instance, name) !== null) stubs.set(name, createMockFn().mockImplementation(check));
+    }
     // Set up reply state machine for repliable interactions
     const isRepliableMethod = findPrototypeMethod(instance, 'isRepliable');
     const repliable = isRepliableMethod !== null && isRepliableMethod.call(instance);
@@ -429,6 +444,16 @@ function findPrototypeMethod(instance, name) {
     guild.bans = stubDeep(Object.create(GuildBanManager.prototype));
     return stubDeep(guild);
 }
+/**
+ * A component or embed as a message holds it: a discord.js instance as it is; anything else as
+ * its API JSON at the time of the call, behind `toJSON()`.
+ */ function asHeld(value) {
+    if (value instanceof Component || value instanceof Embed) return value;
+    const json = structuredClone(typeof value.toJSON === 'function' ? value.toJSON() : value);
+    return {
+        toJSON: ()=>json
+    };
+}
 /**
  * Creates a mock {@link Message} that tracks whether it has been deleted.
  *
@@ -437,13 +462,30 @@ function findPrototypeMethod(instance, name) {
  * `msg.author.send` and `msg.guild.members.fetch` are ready to use, and every method is a mock
  * function you can override per test.
  *
+ * Without overrides the message is empty: no flags, components, embeds or attachments. Components
+ * and embeds given as API JSON or builders keep that JSON behind `toJSON()`, which is what
+ * `respond()` and `@Defer` read, such as when `@Defer` locks the controls of the message a button
+ * sits on; discord.js instances are kept as they are.
+ *
+ * @param overrides - The message's id, content, components, embeds and flags.
+ * @returns The mock message.
+ *
  * @example
  * ```ts
- * const message = createMockMessage()
+ * const message = createMockMessage({
+ *   components: [
+ *     new ActionRowBuilder<ButtonBuilder>().addComponents(
+ *       new ButtonBuilder().setCustomId('card/refresh').setLabel('Refresh').setStyle(ButtonStyle.Primary),
+ *     ),
+ *   ],
+ *   embeds: [{ title: 'Card' }],
+ * })
+ * const interaction = createMockInteraction(ButtonInteraction, { customId: 'card/refresh', message })
+ *
  * await message.delete()
  * message.deleted // true
  * ```
- */ function createMockMessage() {
+ */ function createMockMessage(overrides = {}) {
     const instance = Object.create(Message.prototype);
     const stubs = new Map();
     instance.deleted = false;
@@ -471,10 +513,12 @@ function findPrototypeMethod(instance, name) {
     // MessageMentions — constructor-assigned, has methods like .has(), .members
     instance.mentions = stubDeep(Object.create(MessageMentions.prototype));
     // Data a message always has, real rather than stubbed, so code reading it sees an empty message
-    instance.flags = new MessageFlagsBitField();
-    instance.components = [];
-    instance.embeds = [];
+    instance.flags = new MessageFlagsBitField(overrides.flags);
+    instance.components = (overrides.components ?? []).map(asHeld);
+    instance.embeds = (overrides.embeds ?? []).map(asHeld);
     instance.attachments = new Collection();
+    if (overrides.id !== undefined) instance.id = overrides.id;
+    if (overrides.content !== undefined) instance.content = overrides.content;
     const alreadyDeleted = ()=>new Error('This message has already been deleted.');
     stubs.set('delete', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();

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

@@ -1,5 +1,5 @@
 import { ServiceIdentifier, Container } from 'inversify';
-import { ClientEvents, APIAuthorizingIntegrationOwnersMap, CacheType, CommandInteractionOptionResolver, Channel, Client, Guild, Message, User, ModalSubmitFields, DiscordAPIError, Interaction } from 'discord.js';
+import { ClientEvents, APIMessageTopLevelComponent, JSONEncodable, APIEmbed, MessageFlagsResolvable, APIAuthorizingIntegrationOwnersMap, CacheType, CommandInteractionOptionResolver, Channel, Client, Guild, Message, User, ModalSubmitFields, DiscordAPIError, Interaction } from 'discord.js';
 import { GuardInterface, InterceptorInterface, ExceptionFilter } from '../interface/index.cjs';
 import { CommandType } from '../enum/index.cjs';
 import { Translator } from '../common/index.cjs';
@@ -306,7 +306,9 @@ interface InteractionClass<T> {
 /**
  * Creates a mock instance of a discord.js class, keeping its prototype so `instanceof` holds.
  *
- * Type guards such as `isButton()` run the real discord.js logic. Replies behave like a real
+ * Type guards such as `isButton()` run the real discord.js logic. `inGuild()`, `inCachedGuild()`
+ * and `inRawGuild()` answer from the mock's own `guildId` and `guild`, so a mock created without
+ * a `guildId` is a DM. Replies behave like a real
  * interaction: `reply()` or `deferReply()` twice throws, and `followUp()`, `editReply()` and
  * `deleteReply()` throw before a reply. Every method is a mock function you can override.
  *
@@ -359,6 +361,22 @@ declare function createMockGuild(): DeepMocked<Guild>;
  * @param Class - The discord.js channel class to mock.
  */
 declare function createMockChannel<T extends Channel>(Class: InteractionClass<T>): DeepMocked<T>;
+/**
+ * What {@link createMockMessage} builds a message with. Components and embeds may be API JSON,
+ * builders or discord.js instances.
+ */
+interface MockMessageOverrides {
+    /** The message's id. */
+    id?: string;
+    /** The message's text. */
+    content?: string;
+    /** Its top-level components: action rows, or Components V2 such as a container. */
+    components?: readonly (APIMessageTopLevelComponent | JSONEncodable<APIMessageTopLevelComponent>)[];
+    /** Its embeds. */
+    embeds?: readonly (APIEmbed | JSONEncodable<APIEmbed>)[];
+    /** Its flags: a number, flag names or a `MessageFlagsBitField`. */
+    flags?: MessageFlagsResolvable;
+}
 /**
  * Creates a mock {@link Message} that tracks whether it has been deleted.
  *
@@ -367,14 +385,31 @@ declare function createMockChannel<T extends Channel>(Class: InteractionClass<T>
  * `msg.author.send` and `msg.guild.members.fetch` are ready to use, and every method is a mock
  * function you can override per test.
  *
+ * Without overrides the message is empty: no flags, components, embeds or attachments. Components
+ * and embeds given as API JSON or builders keep that JSON behind `toJSON()`, which is what
+ * `respond()` and `@Defer` read, such as when `@Defer` locks the controls of the message a button
+ * sits on; discord.js instances are kept as they are.
+ *
+ * @param overrides - The message's id, content, components, embeds and flags.
+ * @returns The mock message.
+ *
  * @example
  * ```ts
- * const message = createMockMessage()
+ * const message = createMockMessage({
+ *   components: [
+ *     new ActionRowBuilder<ButtonBuilder>().addComponents(
+ *       new ButtonBuilder().setCustomId('card/refresh').setLabel('Refresh').setStyle(ButtonStyle.Primary),
+ *     ),
+ *   ],
+ *   embeds: [{ title: 'Card' }],
+ * })
+ * const interaction = createMockInteraction(ButtonInteraction, { customId: 'card/refresh', message })
+ *
  * await message.delete()
  * message.deleted // true
  * ```
  */
-declare function createMockMessage(): DeepMocked<Message> & {
+declare function createMockMessage(overrides?: MockMessageOverrides): DeepMocked<Message> & {
     deleted: boolean;
 };
 interface ChatInputOptions {
@@ -664,4 +699,4 @@ declare function getResponse(interaction: Interaction): ResponseReport;
 declare function createDiscordError(code: number, message?: string): DiscordAPIError;
 
 export { MeoCordTestingModule, TestingModule, TestingModuleBuilder, createChatInputOptions, createDiscordError, createExecutionContext, createMock, createMockChannel, createMockClient, createMockFn, createMockGuild, createMockInteraction, createMockMessage, createMockUser, createModalFields, expectCompleteCatalog, findRouteConflicts, getResponse, inspectHandler, isMockFunction, resolveRoute };
-export type { ChatInputOptions, ClassProvider, ComponentCommandType, DeepMocked, EmitResult, ExecutionContextOptions, HandlerInspection, HandlerName, InspectHandlerOptions, InspectedCooldown, InspectedFilter, InspectedGuard, InspectedInterceptor, InvocationResult, Mock, MockInstance, MockProps, MockResult, MockState, MockedFunction, Provider, ResolvedRoute, ResponseReport, RouteConflict, TestingModuleOptions, ValueProvider };
+export type { ChatInputOptions, ClassProvider, ComponentCommandType, DeepMocked, EmitResult, ExecutionContextOptions, HandlerInspection, HandlerName, InspectHandlerOptions, InspectedCooldown, InspectedFilter, InspectedGuard, InspectedInterceptor, InvocationResult, Mock, MockInstance, MockMessageOverrides, MockProps, MockResult, MockState, MockedFunction, Provider, ResolvedRoute, ResponseReport, RouteConflict, TestingModuleOptions, ValueProvider };

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

@@ -1,5 +1,5 @@
 import { ServiceIdentifier, Container } from 'inversify';
-import { ClientEvents, APIAuthorizingIntegrationOwnersMap, CacheType, CommandInteractionOptionResolver, Channel, Client, Guild, Message, User, ModalSubmitFields, DiscordAPIError, Interaction } from 'discord.js';
+import { ClientEvents, APIMessageTopLevelComponent, JSONEncodable, APIEmbed, MessageFlagsResolvable, APIAuthorizingIntegrationOwnersMap, CacheType, CommandInteractionOptionResolver, Channel, Client, Guild, Message, User, ModalSubmitFields, DiscordAPIError, Interaction } from 'discord.js';
 import { GuardInterface, InterceptorInterface, ExceptionFilter } from '../interface/index.js';
 import { CommandType } from '../enum/index.js';
 import { Translator } from '../common/index.js';
@@ -306,7 +306,9 @@ interface InteractionClass<T> {
 /**
  * Creates a mock instance of a discord.js class, keeping its prototype so `instanceof` holds.
  *
- * Type guards such as `isButton()` run the real discord.js logic. Replies behave like a real
+ * Type guards such as `isButton()` run the real discord.js logic. `inGuild()`, `inCachedGuild()`
+ * and `inRawGuild()` answer from the mock's own `guildId` and `guild`, so a mock created without
+ * a `guildId` is a DM. Replies behave like a real
  * interaction: `reply()` or `deferReply()` twice throws, and `followUp()`, `editReply()` and
  * `deleteReply()` throw before a reply. Every method is a mock function you can override.
  *
@@ -359,6 +361,22 @@ declare function createMockGuild(): DeepMocked<Guild>;
  * @param Class - The discord.js channel class to mock.
  */
 declare function createMockChannel<T extends Channel>(Class: InteractionClass<T>): DeepMocked<T>;
+/**
+ * What {@link createMockMessage} builds a message with. Components and embeds may be API JSON,
+ * builders or discord.js instances.
+ */
+interface MockMessageOverrides {
+    /** The message's id. */
+    id?: string;
+    /** The message's text. */
+    content?: string;
+    /** Its top-level components: action rows, or Components V2 such as a container. */
+    components?: readonly (APIMessageTopLevelComponent | JSONEncodable<APIMessageTopLevelComponent>)[];
+    /** Its embeds. */
+    embeds?: readonly (APIEmbed | JSONEncodable<APIEmbed>)[];
+    /** Its flags: a number, flag names or a `MessageFlagsBitField`. */
+    flags?: MessageFlagsResolvable;
+}
 /**
  * Creates a mock {@link Message} that tracks whether it has been deleted.
  *
@@ -367,14 +385,31 @@ declare function createMockChannel<T extends Channel>(Class: InteractionClass<T>
  * `msg.author.send` and `msg.guild.members.fetch` are ready to use, and every method is a mock
  * function you can override per test.
  *
+ * Without overrides the message is empty: no flags, components, embeds or attachments. Components
+ * and embeds given as API JSON or builders keep that JSON behind `toJSON()`, which is what
+ * `respond()` and `@Defer` read, such as when `@Defer` locks the controls of the message a button
+ * sits on; discord.js instances are kept as they are.
+ *
+ * @param overrides - The message's id, content, components, embeds and flags.
+ * @returns The mock message.
+ *
  * @example
  * ```ts
- * const message = createMockMessage()
+ * const message = createMockMessage({
+ *   components: [
+ *     new ActionRowBuilder<ButtonBuilder>().addComponents(
+ *       new ButtonBuilder().setCustomId('card/refresh').setLabel('Refresh').setStyle(ButtonStyle.Primary),
+ *     ),
+ *   ],
+ *   embeds: [{ title: 'Card' }],
+ * })
+ * const interaction = createMockInteraction(ButtonInteraction, { customId: 'card/refresh', message })
+ *
  * await message.delete()
  * message.deleted // true
  * ```
  */
-declare function createMockMessage(): DeepMocked<Message> & {
+declare function createMockMessage(overrides?: MockMessageOverrides): DeepMocked<Message> & {
     deleted: boolean;
 };
 interface ChatInputOptions {
@@ -664,4 +699,4 @@ declare function getResponse(interaction: Interaction): ResponseReport;
 declare function createDiscordError(code: number, message?: string): DiscordAPIError;
 
 export { MeoCordTestingModule, TestingModule, TestingModuleBuilder, createChatInputOptions, createDiscordError, createExecutionContext, createMock, createMockChannel, createMockClient, createMockFn, createMockGuild, createMockInteraction, createMockMessage, createMockUser, createModalFields, expectCompleteCatalog, findRouteConflicts, getResponse, inspectHandler, isMockFunction, resolveRoute };
-export type { ChatInputOptions, ClassProvider, ComponentCommandType, DeepMocked, EmitResult, ExecutionContextOptions, HandlerInspection, HandlerName, InspectHandlerOptions, InspectedCooldown, InspectedFilter, InspectedGuard, InspectedInterceptor, InvocationResult, Mock, MockInstance, MockProps, MockResult, MockState, MockedFunction, Provider, ResolvedRoute, ResponseReport, RouteConflict, TestingModuleOptions, ValueProvider };
+export type { ChatInputOptions, ClassProvider, ComponentCommandType, DeepMocked, EmitResult, ExecutionContextOptions, HandlerInspection, HandlerName, InspectHandlerOptions, InspectedCooldown, InspectedFilter, InspectedGuard, InspectedInterceptor, InvocationResult, Mock, MockInstance, MockMessageOverrides, MockProps, MockResult, MockState, MockedFunction, Provider, ResolvedRoute, ResponseReport, RouteConflict, TestingModuleOptions, ValueProvider };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "meocord",
   "description": "Decorator-based Discord bot framework built on discord.js. Brings NestJS-style controllers, dependency injection, guards, and testing utilities to bot development — with a full CLI and TypeScript-first design.",
-  "version": "4.1.0-beta.0",
+  "version": "4.1.0-beta.1",
   "type": "module",
   "engines": {
     "node": ">=22.13"
@@ -106,7 +106,8 @@
         "types": "./meocord.eslint.d.cts",
         "default": "./meocord.eslint.cjs"
       }
-    }
+    },
+    "./package.json": "./package.json"
   },
   "files": [
     "dist/**/*",