meocord 1.8.4-beta.1 → 2.0.0-beta.1

package/README.md

@@ -337,7 +337,21 @@ async ban(interaction: ChatInputCommandInteraction) { ... }
 
 ## Testing
 
-MeoCord ships a `meocord/testing` entry point with utilities for testing controllers in isolation — no real Discord connection required.
+MeoCord ships a `meocord/testing` entry point with utilities for testing controllers in isolation — no real Discord connection required. The framework repo runs tests with [Vitest](https://vitest.dev/); the mocks themselves are **framework-agnostic** and work with Vitest or Jest assertions (see below).
+
+### Running tests
+
+From the MeoCord repo root:
+
+```shell
+bun run test              # run once
+bun run test:watch        # watch mode
+bun run test:coverage     # coverage report
+bun run test:typecheck    # tsc -p tsconfig.test.json
+bun run lint              # eslint --fix + tsc
+```
+
+In your own bot project, add Vitest (or keep Jest) plus a `vitest.config.ts` with SWC if you use decorator metadata — see this repo's config for reference. Generated apps include `*.spec.ts` stubs but not a test runner config yet.
 
 ### `MeoCordTestingModule`
 
@@ -364,7 +378,7 @@ Creates a smart mock instance of any discord.js class. The full prototype chain
 
 **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`. All reply methods are still mock functions so call assertions work normally.
 
-> **Framework-agnostic** — the mocks returned here are plain mock functions that stamp `_isMockFunction` and expose `.mock.calls`, the exact contract both `jest` and `vitest` check. Use them with either framework's `expect(...).toHaveBeenCalledWith(...)` / `toHaveBeenCalledTimes(...)` — no jest or vitest import is required to produce them.
+> **Framework-agnostic** — the mocks returned here are plain mock functions that stamp `_isMockFunction` and expose `.mock.calls`, the exact contract both `jest` and `vitest` check. Use them with either framework's `expect(...).toHaveBeenCalledWith(...)` / `toHaveBeenCalledTimes(...)` — no jest or vitest import is required to produce them. For typed stubs in your own code, import `MockedFunction`, `createMockFn`, and `DeepMocked` from `meocord/testing`.
 
 ```typescript
 import { createMockInteraction } from 'meocord/testing'
@@ -429,8 +443,13 @@ All methods are mock functions — override any per test with `.mockReturnValue(
 Convenience wrappers for common discord.js classes. All methods are auto-stubbed as mock functions. Nested managers (`client.users`, `guild.members`, etc.) are independent nested stubs.
 
 ```typescript
-import { vi } from 'vitest'
-import { createMockUser, createMockClient, createMockGuild, createMockChannel } from 'meocord/testing'
+import {
+  createMockFn,
+  createMockUser,
+  createMockClient,
+  createMockGuild,
+  createMockChannel,
+} from 'meocord/testing'
 import { TextChannel } from 'discord.js'
 
 const user    = createMockUser()
@@ -438,8 +457,8 @@ const client  = createMockClient()
 const guild   = createMockGuild()
 const channel = createMockChannel(TextChannel)
 
-// override nested manager methods per test
-;(client.users as any).fetch = vi.fn(() => Promise.resolve(user))
+// override nested manager methods per test (createMockFn works with vitest and jest matchers)
+;(client.users as any).fetch = createMockFn(() => Promise.resolve(user))
 await (client.users as any).fetch('user-123')
 expect((client.users as any).fetch).toHaveBeenCalledWith('user-123')
 ```
@@ -486,8 +505,13 @@ const module = MeoCordTestingModule.create({
 ### Full example
 
 ```typescript
-import { vi, type MockedFunction } from 'vitest'
-import { MeoCordTestingModule, createMockInteraction, createChatInputOptions } from 'meocord/testing'
+import {
+  MeoCordTestingModule,
+  createMockFn,
+  createMockInteraction,
+  createChatInputOptions,
+  type MockedFunction,
+} from 'meocord/testing'
 import { ChatInputCommandInteraction } from 'discord.js'
 import { GreetingSlashController } from '@src/controllers/slash/greeting.slash.controller.js'
 import { GreetingService } from '@src/services/greeting.service.js'
@@ -498,7 +522,7 @@ describe('GreetingSlashController', () => {
   let greetingService: { buildGreeting: MockedFunction<GreetingService['buildGreeting']> }
 
   beforeEach(() => {
-    greetingService = { buildGreeting: vi.fn() }
+    greetingService = { buildGreeting: createMockFn() }
 
     const module = MeoCordTestingModule.create({
       controllers: [GreetingSlashController],
@@ -566,9 +590,10 @@ npx meocord start --prod
 1. Fork the repository
 2. Create a feature branch: `git checkout -b feat/your-feature`
 3. Commit with conventional commits: `git commit -m "feat: add X"`
-4. Push and open a pull request against `main`
+4. Run `bun run lint` and `bun run test` before pushing
+5. Push and open a pull request against `main`
 
-Include a description of what changed and why, and add tests for any new behaviour.
+Include a description of what changed and why, and add tests for any new behaviour. Use `fix:` / `feat:` / `docs:` prefixes so [semantic-release](https://semantic-release.gitbook.io/) can version correctly — `test:` commits do not trigger a release.
 
 ---
 

package/dist/cjs/testing/index.cjs

@@ -22,7 +22,13 @@ function isValueProvider(p) {
  * Builder returned by `MeoCordTestingModule.create()`.
  * Call `.compile()` to get the resolved `TestingModule`.
  */ class TestingModuleBuilder {
-    overrideProvider(token) {
+    /**
+   * A double covers the methods under test, not the whole class — and a class
+   * with any private member (a service holding a logger, say) can never be
+   * satisfied by an object literal at all. `Partial<T>` still rejects a
+   * misspelled method name, which is the check that actually earns its keep.
+   * Matches `overrideGuard`, which has always taken `Partial<GuardInterface>`.
+   */ overrideProvider(token) {
         return {
             useValue: (value)=>{
                 this.overrides.set(token, {
@@ -97,10 +103,12 @@ function isValueProvider(p) {
  *
  * @example
  * ```typescript
+ * import { MeoCordTestingModule, createMockFn } from 'meocord/testing'
+ *
  * const module = MeoCordTestingModule.create({
  *   controllers: [PingController],
  *   providers: [
- *     { provide: PingService, useValue: { handlePing: vi.fn().mockResolvedValue('pong') } },
+ *     { provide: PingService, useValue: { handlePing: createMockFn().mockResolvedValue('pong') } },
  *   ],
  * }).compile()
  *
@@ -126,6 +134,12 @@ function isValueProvider(p) {
 // `fn.mock.calls` — so a mock produced here is recognized by assertions in
 // either framework.
 // ---------------------------------------------------------------------------
+/**
+ * Type guard that recognises mocks produced by `createMockFn` as well as
+ * native `jest.fn()` / `vi.fn()` mocks — all stamp `_isMockFunction = true`.
+ */ function isMockFunction(fn) {
+    return typeof fn === 'function' && '_isMockFunction' in fn && fn._isMockFunction === true;
+}
 /**
  * Creates a framework-agnostic mock function. Callable; records calls on
  * `.mock.calls`; supports the mock-return/resolved/rejected/implementation
@@ -347,8 +361,17 @@ function stubDeep(instance, externalStubs) {
             stubs.set(key, stub);
             return stub;
         },
+        // defineProperty rather than assignment: many discord.js properties are
+        // prototype getters with no setter (targetUser, targetMessage, createdAt),
+        // and a plain write against one of those is a silent no-op. Defining an own
+        // data property shadows the accessor, which is what test setup means.
         set (target, prop, value) {
-            Reflect.set(target, prop, value, target);
+            Object.defineProperty(target, prop, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
             return true;
         }
     });
@@ -473,7 +496,7 @@ function findPrototypeMethod(instance, name) {
  * interaction.replied        // → true
  * await interaction.reply({}) // throws — already replied
  * ```
- */ function createMockInteraction(Class) {
+ */ function createMockInteraction(Class, props) {
     const instance = Object.create(Class.prototype);
     const stubs = new Map();
     // Set type fields so all prototype type-guard methods compute the right value
@@ -543,6 +566,19 @@ function findPrototypeMethod(instance, name) {
             }));
         }
     }
+    // Applied last so an explicit prop wins over the type fields and the reply
+    // state machine. defineProperty rather than assignment for the same reason the
+    // Proxy uses it: several of these shadow a getter-only prototype accessor.
+    if (props !== undefined) {
+        for (const [key, value] of Object.entries(props)){
+            Object.defineProperty(instance, key, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+        }
+    }
     return stubDeep(instance, stubs);
 }
 // ---------------------------------------------------------------------------
@@ -752,7 +788,9 @@ exports.TestingModuleBuilder = TestingModuleBuilder;
 exports.createChatInputOptions = createChatInputOptions;
 exports.createMockChannel = createMockChannel;
 exports.createMockClient = createMockClient;
+exports.createMockFn = createMockFn;
 exports.createMockGuild = createMockGuild;
 exports.createMockInteraction = createMockInteraction;
 exports.createMockMessage = createMockMessage;
 exports.createMockUser = createMockUser;
+exports.isMockFunction = isMockFunction;

package/dist/esm/package.json.js

@@ -1,4 +1,4 @@
-var version = "1.2.6";
+var version = "0.0.0-development";
 var packageJson = {
 	version: version};
 

package/dist/esm/testing/index.js

@@ -1,2 +1,3 @@
 export { MeoCordTestingModule, TestingModule, TestingModuleBuilder } from './meocord-testing-module.js';
 export { createChatInputOptions, createMockChannel, createMockClient, createMockGuild, createMockInteraction, createMockMessage, createMockUser } from './mock-interaction.js';
+export { createMockFn, isMockFunction } from './mock-fn.js';

package/dist/esm/testing/meocord-testing-module.js

@@ -19,7 +19,13 @@ function isValueProvider(p) {
  * Builder returned by `MeoCordTestingModule.create()`.
  * Call `.compile()` to get the resolved `TestingModule`.
  */ class TestingModuleBuilder {
-    overrideProvider(token) {
+    /**
+   * A double covers the methods under test, not the whole class — and a class
+   * with any private member (a service holding a logger, say) can never be
+   * satisfied by an object literal at all. `Partial<T>` still rejects a
+   * misspelled method name, which is the check that actually earns its keep.
+   * Matches `overrideGuard`, which has always taken `Partial<GuardInterface>`.
+   */ overrideProvider(token) {
         return {
             useValue: (value)=>{
                 this.overrides.set(token, {
@@ -94,10 +100,12 @@ function isValueProvider(p) {
  *
  * @example
  * ```typescript
+ * import { MeoCordTestingModule, createMockFn } from 'meocord/testing'
+ *
  * const module = MeoCordTestingModule.create({
  *   controllers: [PingController],
  *   providers: [
- *     { provide: PingService, useValue: { handlePing: vi.fn().mockResolvedValue('pong') } },
+ *     { provide: PingService, useValue: { handlePing: createMockFn().mockResolvedValue('pong') } },
  *   ],
  * }).compile()
  *

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

@@ -12,6 +12,12 @@
 // `fn.mock.calls` — so a mock produced here is recognized by assertions in
 // either framework.
 // ---------------------------------------------------------------------------
+/**
+ * Type guard that recognises mocks produced by `createMockFn` as well as
+ * native `jest.fn()` / `vi.fn()` mocks — all stamp `_isMockFunction = true`.
+ */ function isMockFunction(fn) {
+    return typeof fn === 'function' && '_isMockFunction' in fn && fn._isMockFunction === true;
+}
 /**
  * Creates a framework-agnostic mock function. Callable; records calls on
  * `.mock.calls`; supports the mock-return/resolved/rejected/implementation
@@ -187,4 +193,4 @@
     return mockFn;
 }
 
-export { createMockFn };
+export { createMockFn, isMockFunction };

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

@@ -48,8 +48,17 @@ function stubDeep(instance, externalStubs) {
             stubs.set(key, stub);
             return stub;
         },
+        // defineProperty rather than assignment: many discord.js properties are
+        // prototype getters with no setter (targetUser, targetMessage, createdAt),
+        // and a plain write against one of those is a silent no-op. Defining an own
+        // data property shadows the accessor, which is what test setup means.
         set (target, prop, value) {
-            Reflect.set(target, prop, value, target);
+            Object.defineProperty(target, prop, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
             return true;
         }
     });
@@ -174,7 +183,7 @@ function findPrototypeMethod(instance, name) {
  * interaction.replied        // → true
  * await interaction.reply({}) // throws — already replied
  * ```
- */ function createMockInteraction(Class) {
+ */ function createMockInteraction(Class, props) {
     const instance = Object.create(Class.prototype);
     const stubs = new Map();
     // Set type fields so all prototype type-guard methods compute the right value
@@ -244,6 +253,19 @@ function findPrototypeMethod(instance, name) {
             }));
         }
     }
+    // Applied last so an explicit prop wins over the type fields and the reply
+    // state machine. defineProperty rather than assignment for the same reason the
+    // Proxy uses it: several of these shadow a getter-only prototype accessor.
+    if (props !== undefined) {
+        for (const [key, value] of Object.entries(props)){
+            Object.defineProperty(instance, key, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+        }
+    }
     return stubDeep(instance, stubs);
 }
 // ---------------------------------------------------------------------------

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

@@ -1,4 +1,4 @@
-import { C as CommandType } from '../controller.enum-QA-IuReF.js';
+import { CommandType } from '../enum/index.js';
 import { SlashCommandBuilder, SlashCommandSubcommandsOnlyBuilder, ContextMenuCommandBuilder, ButtonInteraction, StringSelectMenuInteraction, ChatInputCommandInteraction, UserContextMenuCommandInteraction, MessageContextMenuCommandInteraction, ModalSubmitInteraction, OmitPartialGroupDMChannel, Message, MessageReaction, PartialMessageReaction, ClientOptions, ActivityOptions } from 'discord.js';
 import { ReactionHandlerOptions, GuardInterface } from '../interface/index.js';
 import { ServiceIdentifier } from 'inversify';

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

@@ -1,6 +1,6 @@
 import { User, PartialUser, BaseInteraction, Message, MessageReaction } from 'discord.js';
 import { Configuration } from 'webpack';
-import { R as ReactionHandlerAction } from '../controller.enum-QA-IuReF.js';
+import { ReactionHandlerAction } from '../enum/index.js';
 
 /**
  * MeoCord Framework

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

@@ -40,8 +40,15 @@ declare class TestingModuleBuilder {
     private readonly overrides;
     private readonly guardOverrides;
     constructor(options: TestingModuleOptions);
+    /**
+     * A double covers the methods under test, not the whole class — and a class
+     * with any private member (a service holding a logger, say) can never be
+     * satisfied by an object literal at all. `Partial<T>` still rejects a
+     * misspelled method name, which is the check that actually earns its keep.
+     * Matches `overrideGuard`, which has always taken `Partial<GuardInterface>`.
+     */
     overrideProvider<T>(token: ServiceIdentifier<T>): {
-        useValue: (value: T) => TestingModuleBuilder;
+        useValue: (value: Partial<T>) => TestingModuleBuilder;
     };
     overrideGuard(guard: new (...args: any[]) => GuardInterface): {
         useValue: (stub: Partial<GuardInterface>) => TestingModuleBuilder;
@@ -53,10 +60,12 @@ declare class TestingModuleBuilder {
  *
  * @example
  * ```typescript
+ * import { MeoCordTestingModule, createMockFn } from 'meocord/testing'
+ *
  * const module = MeoCordTestingModule.create({
  *   controllers: [PingController],
  *   providers: [
- *     { provide: PingService, useValue: { handlePing: vi.fn().mockResolvedValue('pong') } },
+ *     { provide: PingService, useValue: { handlePing: createMockFn().mockResolvedValue('pong') } },
  *   ],
  * }).compile()
  *
@@ -110,6 +119,26 @@ interface MockInstance<T extends (...args: any[]) => any = (...args: any[]) => a
  * Drop-in replacement for `jest.MockedFunction<T>` / vitest `MockedFunction<T>`.
  */
 type MockedFunction<T extends (...args: any[]) => any> = ((...args: Parameters<T>) => ReturnType<T>) & MockInstance<T>;
+/** Alias kept for parity with `jest.Mock` / vitest `Mock`. */
+type Mock<T extends (...args: any[]) => any = (...args: any[]) => any> = MockedFunction<T>;
+/**
+ * Type guard that recognises mocks produced by `createMockFn` as well as
+ * native `jest.fn()` / `vi.fn()` mocks — all stamp `_isMockFunction = true`.
+ */
+declare function isMockFunction(fn: unknown): fn is MockInstance;
+/**
+ * Creates a framework-agnostic mock function. Callable; records calls on
+ * `.mock.calls`; supports the mock-return/resolved/rejected/implementation
+ * API used by the testing utilities and by user assertions.
+ *
+ * @example
+ * const fn = createMockFn<(x: number) => number>((x) => x + 1)
+ * fn(2)                    // → 3
+ * fn.mockReturnValue(99)
+ * fn(2)                    // → 99
+ * fn.mock.calls             // → [[2], [2]]
+ */
+declare function createMockFn<T extends (...args: any[]) => any = (...args: any[]) => any>(impl?: T): MockedFunction<T>;
 
 /**
  * MeoCord Framework
@@ -121,10 +150,35 @@ type MockedFunction<T extends (...args: any[]) => any> = ((...args: Parameters<T
  * Recursively transforms all methods of T into MockedFunction and all
  * nested objects into DeepMocked. Depth cap at 5 prevents infinite recursion
  * on circular discord.js types (e.g. Guild ↔ GuildMember).
- * -readonly removes readonly modifiers so test setup can write any property.
+ *
+ * Intersected with `T` so the mock is accepted wherever the real class is
+ * expected. A mapped type alone can never be: it iterates `keyof T`, and the
+ * private members classes use as brands — discord.js stamps
+ * `private readonly _cacheType` on `BaseInteraction` — are not in `keyof T`.
+ * Without the intersection every call site has to launder the mock through
+ * `as unknown as T`, which defeats the point of typing it at all.
+ *
+ * The intersection is honest rather than a convenient lie: the object really is
+ * `Object.create(Class.prototype)`, so its prototype chain is the real one, and
+ * TypeScript `private` is erased at runtime.
+ *
+ * `readonly` survives from the `T` side, so properties the class declares
+ * readonly cannot be assigned after construction. Pass those to the factory as
+ * {@link MockProps} instead.
  */
 type DeepMocked<T, Depth extends number[] = []> = Depth['length'] extends 5 ? T : {
     -readonly [K in keyof T]: T[K] extends (...args: infer A) => infer R ? MockedFunction<(...args: A) => R> : T[K] extends object ? DeepMocked<T[K], [...Depth, 0]> : T[K];
+} & T;
+/**
+ * Property overrides accepted at construction by the mock factories.
+ *
+ * Setup belongs here rather than in a post-construction assignment: the returned
+ * mock is assignable to the real discord.js class, so anything that class declares
+ * `readonly` — `ModalSubmitInteraction#customId`, `#fields`, `MessageComponentInteraction#message`
+ * — cannot be written afterwards without a cast.
+ */
+type MockProps<T> = {
+    -readonly [K in keyof T]?: T[K] extends (...args: any[]) => any ? (...args: any[]) => any : T[K];
 };
 interface InteractionClass<T> {
     prototype: T;
@@ -157,7 +211,7 @@ interface InteractionClass<T> {
  * await interaction.reply({}) // throws — already replied
  * ```
  */
-declare function createMockInteraction<T extends object>(Class: InteractionClass<T>): DeepMocked<T>;
+declare function createMockInteraction<T extends object>(Class: InteractionClass<T>, props?: MockProps<T>): DeepMocked<T>;
 /** Creates a mock {@link User}. All methods are auto-stubbed as a mock fn. */
 declare const createMockUser: () => DeepMocked<User>;
 /**
@@ -220,5 +274,5 @@ interface ChatInputOptions {
  */
 declare function createChatInputOptions(opts?: ChatInputOptions): DeepMocked<CommandInteractionOptionResolver>;
 
-export { MeoCordTestingModule, TestingModule, TestingModuleBuilder, createChatInputOptions, createMockChannel, createMockClient, createMockGuild, createMockInteraction, createMockMessage, createMockUser };
-export type { ChatInputOptions, ClassProvider, DeepMocked, Provider, TestingModuleOptions, ValueProvider };
+export { MeoCordTestingModule, TestingModule, TestingModuleBuilder, createChatInputOptions, createMockChannel, createMockClient, createMockFn, createMockGuild, createMockInteraction, createMockMessage, createMockUser, isMockFunction };
+export type { ChatInputOptions, ClassProvider, DeepMocked, Mock, MockInstance, MockProps, MockResult, MockState, MockedFunction, Provider, TestingModuleOptions, ValueProvider };

package/package.json

@@ -1,8 +1,11 @@
 {
   "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": "1.8.4-beta.1",
+  "version": "2.0.0-beta.1",
   "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
   "scripts": {
     "lint": "eslint --fix . && tsc --noEmit && tsc --noEmit --project tsconfig.test.json",
     "build": "rm -rf ./dist && rollup -c",
@@ -72,13 +75,13 @@
   ],
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@swc/core": "1.15.43",
-    "chalk": "^5.6.2",
+    "@swc/core": "1.15.47",
+    "chalk": "^6.0.0",
     "cli-table3": "^0.6.5",
     "commander": "^15.0.0",
     "dayjs": "^1.11.21",
     "dotenv": "^17.4.2",
-    "inversify": "^8.1.1",
+    "inversify": "^8.2.3",
     "jiti": "^2.7.0",
     "lodash-es": "^4.18.1",
     "nodemon": "^3.1.14",
@@ -87,7 +90,7 @@
     "swc-loader": "^0.2.7",
     "terser-webpack-plugin": "^5.6.1",
     "tsconfig-paths-webpack-plugin": "^4.2.0",
-    "webpack": "^5.108.3",
+    "webpack": "^5.109.2",
     "webpack-node-externals": "^3.0.0"
   },
   "devDependencies": {
@@ -102,27 +105,27 @@
     "@semantic-release/release-notes-generator": "^14.1.1",
     "@types/lodash-es": "^4.17.12",
     "@types/webpack-node-externals": "^3.0.4",
-    "@typescript-eslint/parser": "^8.62.1",
-    "discord.js": "^14.26.4",
-    "eslint": "^10.6.0",
+    "@typescript-eslint/parser": "^8.67.0",
+    "discord.js": "^14.27.0",
+    "eslint": "^10.8.1",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-headers": "^1.3.4",
     "eslint-plugin-import-x": "^4.17.1",
     "eslint-plugin-prettier": "^5.5.6",
     "eslint-plugin-unused-imports": "^4.4.1",
-    "globals": "^17.7.0",
+    "globals": "^17.11.0",
     "husky": "^9.1.7",
-    "prettier": "^3.9.4",
-    "rollup": "^4.62.2",
+    "prettier": "^3.9.6",
+    "rollup": "^4.62.4",
     "rollup-plugin-copy": "^3.5.0",
-    "rollup-plugin-dts": "^6.4.1",
-    "semantic-release": "^25.0.5",
+    "rollup-plugin-dts": "^6.5.1",
+    "semantic-release": "^25.0.9",
     "ts-node": "^10.9.2",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.62.1",
-    "@vitest/coverage-istanbul": "^3.2.4",
-    "unplugin-swc": "^1.5.5",
-    "vitest": "^3.2.4"
+    "typescript-eslint": "^8.67.0",
+    "@vitest/coverage-istanbul": "^4.1.10",
+    "unplugin-swc": "^1.5.11",
+    "vitest": "^4.1.10"
   },
   "peerDependencies": {
     "discord.js": "^14.26.4",