meocord 1.8.3 → 1.8.4-beta.1

package/README.md

@@ -124,7 +124,7 @@ export class App {}
 .
 ├── meocord.config.ts
 ├── eslint.config.ts
-├── jest.config.ts
+├── vitest.config.ts
 ├── tsconfig.json
 ├── tsconfig.eslint.json
 ├── tsconfig.test.json
@@ -360,9 +360,11 @@ const controller = module.get(GreetingSlashController)
 
 Creates a smart mock instance of any discord.js class. The full prototype chain is preserved so `instanceof` checks pass at every level.
 
-**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 `jest.fn()` and can be overridden per test.
+**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.
 
-**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 `jest.fn()` so call assertions work normally.
+**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.
 
 ```typescript
 import { createMockInteraction } from 'meocord/testing'
@@ -385,7 +387,7 @@ await interaction.reply({ content: 'hi' })
 interaction.replied   // → true
 await interaction.reply({ content: 'again' }) // → throws (already replied)
 
-// still jest.fn() — call assertions work normally
+// still a mock fn — call assertions work normally
 expect(interaction.reply).toHaveBeenCalledWith({ content: 'hi' })
 
 // direct property writes work normally
@@ -420,13 +422,14 @@ interaction.options.getString('duration')      // → null (wrong type)
 interaction.options.getNumber('x', true)       // → throws (absent + required)
 ```
 
-All methods are `jest.fn()` — override any per test with `.mockReturnValue()`.
+All methods are mock functions — override any per test with `.mockReturnValue()`.
 
 ### `createMockUser` / `createMockClient` / `createMockGuild` / `createMockChannel`
 
-Convenience wrappers for common discord.js classes. All methods are auto-stubbed as `jest.fn()`. Nested managers (`client.users`, `guild.members`, etc.) are independent nested stubs.
+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 { TextChannel } from 'discord.js'
 
@@ -436,14 +439,14 @@ const guild   = createMockGuild()
 const channel = createMockChannel(TextChannel)
 
 // override nested manager methods per test
-;(client.users as any).fetch = jest.fn(() => Promise.resolve(user))
+;(client.users as any).fetch = vi.fn(() => Promise.resolve(user))
 await (client.users as any).fetch('user-123')
 expect((client.users as any).fetch).toHaveBeenCalledWith('user-123')
 ```
 
 ### `createMockMessage`
 
-Creates a smart mock `Message`. Tracks a `deleted` boolean — `delete()`, `edit()`, `reply()`, `react()`, `pin()`, and `unpin()` throw if the message has already been deleted. `edit()` and `reply()` resolve to a new mock `Message` instance. All methods are `jest.fn()`.
+Creates a smart mock `Message`. Tracks a `deleted` boolean — `delete()`, `edit()`, `reply()`, `react()`, `pin()`, and `unpin()` throw if the message has already been deleted. `edit()` and `reply()` resolve to a new mock `Message` instance. All methods are mock functions.
 
 ```typescript
 import { createMockMessage } from 'meocord/testing'
@@ -458,9 +461,9 @@ await msg.edit({ content: 'x' }) // → throws (already deleted)
 
 // edit() and reply() resolve to a new Message mock
 const edited = await createMockMessage().edit({ content: 'updated' })
-edited.delete  // → jest.fn()
+edited.delete  // → a mock fn
 
-// still jest.fn() — assertions work
+// still a mock fn — assertions work
 expect(msg.delete).toHaveBeenCalledTimes(1)
 ```
 
@@ -483,7 +486,7 @@ const module = MeoCordTestingModule.create({
 ### Full example
 
 ```typescript
-import { jest } from '@jest/globals'
+import { vi, type MockedFunction } from 'vitest'
 import { MeoCordTestingModule, createMockInteraction, createChatInputOptions } from 'meocord/testing'
 import { ChatInputCommandInteraction } from 'discord.js'
 import { GreetingSlashController } from '@src/controllers/slash/greeting.slash.controller.js'
@@ -492,10 +495,10 @@ import { RateLimiterGuard } from '@src/guards/rate-limiter.guard.js'
 
 describe('GreetingSlashController', () => {
   let controller: GreetingSlashController
-  let greetingService: { buildGreeting: jest.MockedFunction<GreetingService['buildGreeting']> }
+  let greetingService: { buildGreeting: MockedFunction<GreetingService['buildGreeting']> }
 
   beforeEach(() => {
-    greetingService = { buildGreeting: jest.fn() }
+    greetingService = { buildGreeting: vi.fn() }
 
     const module = MeoCordTestingModule.create({
       controllers: [GreetingSlashController],
@@ -508,7 +511,7 @@ describe('GreetingSlashController', () => {
   })
 
   it('replies with a greeting for the provided name', async () => {
-    jest.mocked(greetingService.buildGreeting).mockResolvedValue('Hello, Alice!')
+    greetingService.buildGreeting.mockResolvedValue('Hello, Alice!')
 
     const interaction = createMockInteraction(ChatInputCommandInteraction)
     interaction.options = createChatInputOptions({ name: 'Alice' })

package/dist/cjs/testing/index.cjs

@@ -3,7 +3,6 @@
 require('reflect-metadata');
 var inversify = require('inversify');
 var metadataKey_enum = require('../_shared/metadata-key.enum-BzzvGUId.cjs');
-var globals = require('@jest/globals');
 var discord_js = require('discord.js');
 
 function isValueProvider(p) {
@@ -101,7 +100,7 @@ function isValueProvider(p) {
  * const module = MeoCordTestingModule.create({
  *   controllers: [PingController],
  *   providers: [
- *     { provide: PingService, useValue: { handlePing: jest.fn().mockResolvedValue('pong') } },
+ *     { provide: PingService, useValue: { handlePing: vi.fn().mockResolvedValue('pong') } },
  *   ],
  * }).compile()
  *
@@ -113,8 +112,197 @@ function isValueProvider(p) {
     }
 }
 
+/**
+ * MeoCord Framework
+ * Copyright (c) 2025 Ukasyah Rahmatullah Zada
+ * SPDX-License-Identifier: MIT
+ */ // ---------------------------------------------------------------------------
+// Framework-agnostic mock function
+//
+// A minimal mock-fn implementation used internally by the testing utilities so
+// that `meocord/testing` does not depend on jest OR vitest. Both jest and
+// vitest detect a mock via the `_isMockFunction` flag, and both
+// `expect(fn).toHaveBeenCalledWith(...)` / `toHaveBeenCalledTimes(...)` read
+// `fn.mock.calls` — so a mock produced here is recognized by assertions in
+// either framework.
+// ---------------------------------------------------------------------------
+/**
+ * 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]]
+ */ function createMockFn(impl) {
+    let currentImpl = impl;
+    let returnOnce = [];
+    let returnValue = {
+        set: false,
+        value: undefined
+    };
+    let resolvedOnce = [];
+    let resolvedValue = {
+        set: false,
+        value: undefined
+    };
+    let rejectedOnce = [];
+    let rejectedValue = {
+        set: false,
+        value: undefined
+    };
+    const implOnce = [];
+    let name = 'vi.fn';
+    const calls = [];
+    const results = [];
+    const instances = [];
+    const mockFn = function(...args) {
+        calls.push(args);
+        instances.push(this);
+        let type = 'return';
+        let value;
+        try {
+            if (implOnce.length > 0) {
+                value = implOnce.shift().apply(this, args);
+            } else if (returnOnce.length > 0) {
+                value = returnOnce.shift();
+            } else if (returnValue.set) {
+                value = returnValue.value;
+            } else if (resolvedOnce.length > 0) {
+                value = Promise.resolve(resolvedOnce.shift());
+            } else if (resolvedValue.set) {
+                value = Promise.resolve(resolvedValue.value);
+            } else if (rejectedOnce.length > 0) {
+                value = Promise.reject(rejectedOnce.shift());
+            } else if (rejectedValue.set) {
+                value = Promise.reject(rejectedValue.value);
+            } else if (currentImpl !== undefined) {
+                value = currentImpl.apply(this, args);
+            } else {
+                value = undefined;
+            }
+            return value;
+        } catch (err) {
+            type = 'throw';
+            value = err;
+            throw err;
+        } finally{
+            results.push({
+                type,
+                value
+            });
+        }
+    };
+    // Stamp the marker both jest and vitest check via isMockFunction.
+    Object.defineProperty(mockFn, '_isMockFunction', {
+        value: true,
+        enumerable: false
+    });
+    const mock = {
+        get calls () {
+            return calls;
+        },
+        get results () {
+            return results;
+        },
+        get instances () {
+            return instances;
+        },
+        get lastCall () {
+            return calls.length > 0 ? calls[calls.length - 1] : undefined;
+        }
+    };
+    Object.defineProperty(mockFn, 'mock', {
+        value: mock,
+        enumerable: false
+    });
+    mockFn.mockReturnValue = (v)=>{
+        returnValue = {
+            set: true,
+            value: v
+        };
+        return mockFn;
+    };
+    mockFn.mockReturnValueOnce = (v)=>{
+        returnOnce.push(v);
+        return mockFn;
+    };
+    mockFn.mockResolvedValue = (v)=>{
+        resolvedValue = {
+            set: true,
+            value: v
+        };
+        return mockFn;
+    };
+    mockFn.mockResolvedValueOnce = (v)=>{
+        resolvedOnce.push(v);
+        return mockFn;
+    };
+    mockFn.mockRejectedValue = (v)=>{
+        rejectedValue = {
+            set: true,
+            value: v
+        };
+        return mockFn;
+    };
+    mockFn.mockRejectedValueOnce = (v)=>{
+        rejectedOnce.push(v);
+        return mockFn;
+    };
+    mockFn.mockImplementation = (fn)=>{
+        currentImpl = fn;
+        return mockFn;
+    };
+    mockFn.mockImplementationOnce = (fn)=>{
+        implOnce.push(fn);
+        return mockFn;
+    };
+    mockFn.mockClear = ()=>{
+        calls.length = 0;
+        results.length = 0;
+        instances.length = 0;
+        return mockFn;
+    };
+    mockFn.mockReset = ()=>{
+        calls.length = 0;
+        results.length = 0;
+        instances.length = 0;
+        returnOnce = [];
+        returnValue = {
+            set: false,
+            value: undefined
+        };
+        resolvedOnce = [];
+        resolvedValue = {
+            set: false,
+            value: undefined
+        };
+        rejectedOnce = [];
+        rejectedValue = {
+            set: false,
+            value: undefined
+        };
+        implOnce.length = 0;
+        currentImpl = impl;
+        return mockFn;
+    };
+    mockFn.mockRestore = ()=>{
+        mockFn.mockReset();
+        return mockFn;
+    };
+    mockFn.getMockName = ()=>name;
+    mockFn.mockName = (n)=>{
+        name = n;
+        return mockFn;
+    };
+    return mockFn;
+}
+
 // ---------------------------------------------------------------------------
-// stubDeep — Proxy that auto-creates jest.fn() on any property access
+// stubDeep — Proxy that auto-creates a mock fn on any property access
 // ---------------------------------------------------------------------------
 const SKIP = new Set([
     'constructor',
@@ -132,7 +320,7 @@ function stubDeep(instance, externalStubs) {
                 return Reflect.get(target, prop, target);
             }
             const key = prop;
-            // 'then' must be undefined — prevents jest treating the mock as a Promise
+            // 'then' must be undefined — prevents frameworks treating the mock as a Promise
             if (key === 'then') return undefined;
             // Own property writes take precedence (e.g. interaction.guildId = 'abc')
             if (Object.prototype.hasOwnProperty.call(target, key)) {
@@ -155,7 +343,7 @@ function stubDeep(instance, externalStubs) {
                 }
                 proto = Object.getPrototypeOf(proto);
             }
-            const stub = typeof protoValue === 'function' ? globals.jest.fn() : stubDeep({});
+            const stub = typeof protoValue === 'function' ? createMockFn() : stubDeep({});
             stubs.set(key, stub);
             return stub;
         },
@@ -225,7 +413,7 @@ const CLASS_TYPE_FIELDS = {
     }
 };
 // All known pure type-guard methods on BaseInteraction and its subclasses.
-// These are wired as jest.fn() wrapping the real prototype logic so they return
+// These are wired as a mock fn wrapping the real prototype logic so they return
 // correct values by default and can still be overridden per test.
 const TYPE_GUARD_METHODS = [
     'isCommand',
@@ -265,14 +453,14 @@ function findPrototypeMethod(instance, name) {
  *
  * **Type guards** (`isButton()`, `isRepliable()`, etc.) run the real discord.js
  * prototype logic — no manual `.mockReturnValue(true)` setup needed. They are
- * still `jest.fn()` so you can override them per test.
+ * still mock functions so you can override them per test.
  *
  * **Reply state machine** — `replied` and `deferred` start as `false`. Calling
  * `reply()` or `deferReply()` twice throws, just like a real interaction would.
  * `followUp()`, `editReply()`, and `deleteReply()` throw if called before any
- * reply. These are still `jest.fn()` so call assertions work normally.
+ * reply. These are still mock functions so call assertions work normally.
  *
- * All other methods are auto-stubbed as `jest.fn()` via Proxy.
+ * All other methods are auto-stubbed as a mock fn via Proxy.
  *
  * @example
  * ```ts
@@ -295,12 +483,12 @@ function findPrototypeMethod(instance, name) {
             instance[key] = value;
         }
     }
-    // Wire each type guard as jest.fn() calling the real prototype implementation.
+    // Wire each type guard as a mock fn calling the real prototype implementation.
     // Correct by default; overridable per test via .mockReturnValue().
     for (const name of TYPE_GUARD_METHODS){
         const method = findPrototypeMethod(instance, name);
         if (method !== null) {
-            stubs.set(name, globals.jest.fn().mockImplementation(()=>method.call(instance)));
+            stubs.set(name, createMockFn().mockImplementation(()=>method.call(instance)));
         }
     }
     // Set up reply state machine for repliable interactions
@@ -320,36 +508,36 @@ function findPrototypeMethod(instance, name) {
             if (typeof flags === 'bigint') return (flags & 64n) !== 0n;
             return false;
         };
-        stubs.set('reply', globals.jest.fn(async (...args)=>{
+        stubs.set('reply', createMockFn(async (...args)=>{
             if (instance.deferred || instance.replied) throw alreadyReplied();
             instance.replied = true;
             if (hasEphemeralFlag(args[0])) instance.ephemeral = true;
         }));
-        stubs.set('deferReply', globals.jest.fn(async (...args)=>{
+        stubs.set('deferReply', createMockFn(async (...args)=>{
             if (instance.deferred || instance.replied) throw alreadyReplied();
             instance.deferred = true;
             if (hasEphemeralFlag(args[0])) instance.ephemeral = true;
         }));
-        stubs.set('followUp', globals.jest.fn(async ()=>{
+        stubs.set('followUp', createMockFn(async ()=>{
             if (!instance.deferred && !instance.replied) throw notYetReplied('followUp');
             instance.replied = true;
             return createMockMessage();
         }));
-        stubs.set('editReply', globals.jest.fn(async ()=>{
+        stubs.set('editReply', createMockFn(async ()=>{
             if (!instance.deferred && !instance.replied) throw notYetReplied('editReply');
             instance.replied = true;
             return createMockMessage();
         }));
-        stubs.set('deleteReply', globals.jest.fn(async ()=>{
+        stubs.set('deleteReply', createMockFn(async ()=>{
             if (!instance.deferred && !instance.replied) throw notYetReplied('deleteReply');
         }));
         // deferUpdate / update — MessageComponentInteraction only (type === MessageComponent)
         if (instance.type === discord_js.InteractionType.MessageComponent) {
-            stubs.set('update', globals.jest.fn(async ()=>{
+            stubs.set('update', createMockFn(async ()=>{
                 if (instance.deferred || instance.replied) throw alreadyReplied();
                 instance.replied = true;
             }));
-            stubs.set('deferUpdate', globals.jest.fn(async ()=>{
+            stubs.set('deferUpdate', createMockFn(async ()=>{
                 if (instance.deferred || instance.replied) throw alreadyReplied();
                 instance.deferred = true;
             }));
@@ -360,18 +548,18 @@ function findPrototypeMethod(instance, name) {
 // ---------------------------------------------------------------------------
 // Convenience wrappers for common discord.js classes
 // ---------------------------------------------------------------------------
-/** Creates a mock {@link User}. All methods are auto-stubbed as `jest.fn()`. */ const createMockUser = ()=>createMockInteraction(discord_js.User);
+/** Creates a mock {@link User}. All methods are auto-stubbed as a mock fn. */ const createMockUser = ()=>createMockInteraction(discord_js.User);
 /**
  * Creates a mock {@link Client}.
  *
  * Manager methods that are constructor-assigned (not on the prototype) are
- * pre-initialized as `jest.fn()` so they work out of the box without manual
+ * pre-initialized as a mock fn so they work out of the box without manual
  * setup: `users.fetch`, `channels.fetch`, `guilds.fetch`, and
  * `application.commands.fetch`.
  */ function createMockClient() {
     const instance = Object.create(discord_js.Client.prototype);
     // Manager properties are constructor-assigned — pre-initialize as prototype-based
-    // stubs so ALL manager methods (not just fetch) are auto-stubbed as jest.fn().
+    // stubs so ALL manager methods (not just fetch) are auto-stubbed as a mock fn.
     const appInstance = Object.create(null);
     appInstance.commands = stubDeep(Object.create(discord_js.ApplicationCommandManager.prototype));
     instance.users = stubDeep(Object.create(discord_js.UserManager.prototype));
@@ -386,7 +574,7 @@ function findPrototypeMethod(instance, name) {
  *
  * Manager properties are constructor-assigned in discord.js. This factory
  * pre-initializes each as a prototype-based stub so all methods are
- * auto-stubbed as `jest.fn()`.
+ * auto-stubbed as a mock fn.
  *
  * Pre-initialized: `members`, `channels`, `roles`, `bans`.
  */ function createMockGuild() {
@@ -402,7 +590,7 @@ function findPrototypeMethod(instance, name) {
  *
  * Manager properties that are constructor-assigned in discord.js are
  * pre-initialized as prototype-based stubs so all methods are auto-stubbed
- * as `jest.fn()`:
+ * as a mock fn:
  * - Guild text channels (`TextChannel`, `NewsChannel`): `messages`, `threads`
  * - `DMChannel`: `messages`
  * - `ThreadChannel`: `messages`, `members`
@@ -437,7 +625,7 @@ function findPrototypeMethod(instance, name) {
  * `msg.channel.send`, `msg.guild.members.fetch`, `msg.thread.fetch`,
  * and `msg.mentions.has` all work out of the box.
  *
- * All methods remain `jest.fn()` — overridable per test.
+ * All methods remain mock functions — overridable per test.
  *
  * Note: `createMockInteraction`'s `followUp()` and `editReply()` stubs return
  * a `createMockMessage()` by default, matching the official return types.
@@ -460,7 +648,7 @@ function createMockMessage() {
     // Constructor-assigned — set as prototype-based stubs
     instance.author = stubDeep(Object.create(discord_js.User.prototype));
     // Getters on the prototype — the proxy sees them as functions and returns
-    // jest.fn(), which is wrong. Pre-initialize as own properties to shadow
+    // a mock fn, which is wrong. Pre-initialize as own properties to shadow
     // the prototype getters.
     Object.defineProperty(instance, 'member', {
         value: stubDeep(Object.create(discord_js.GuildMember.prototype)),
@@ -481,25 +669,25 @@ function createMockMessage() {
     // MessageMentions — constructor-assigned, has methods like .has(), .members
     instance.mentions = stubDeep(Object.create(discord_js.MessageMentions.prototype));
     const alreadyDeleted = ()=>new Error('This message has already been deleted.');
-    stubs.set('delete', globals.jest.fn(async ()=>{
+    stubs.set('delete', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
         instance.deleted = true;
     }));
-    stubs.set('edit', globals.jest.fn(async ()=>{
+    stubs.set('edit', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
         return createMockMessage();
     }));
-    stubs.set('reply', globals.jest.fn(async ()=>{
+    stubs.set('reply', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
         return createMockMessage();
     }));
-    stubs.set('react', globals.jest.fn(async ()=>{
+    stubs.set('react', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
     }));
-    stubs.set('pin', globals.jest.fn(async ()=>{
+    stubs.set('pin', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
     }));
-    stubs.set('unpin', globals.jest.fn(async ()=>{
+    stubs.set('unpin', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
     }));
     return stubDeep(instance, stubs);
@@ -509,7 +697,7 @@ function createMockMessage() {
  * `CommandInteractionOptionResolver` works: declare what options the command
  * was invoked with, and the resolver finds them by name.
  *
- * All explicit methods are `jest.fn()` — override per test with `.mockReturnValue()`.
+ * All explicit methods are mock functions — override per test with `.mockReturnValue()`.
  * Methods not listed (e.g. `getAttachment`) are auto-stubbed by the Proxy.
  *
  * @example
@@ -541,20 +729,20 @@ function createMockMessage() {
     }
     const isObjectOption = (v)=>typeof v === 'object' && v !== null && 'id' in v;
     // Use a real prototype instance so unlisted methods (e.g. getAttachment)
-    // are found on the prototype chain and auto-stubbed as jest.fn()
+    // are found on the prototype chain and auto-stubbed as a mock fn
     const base = Object.create(discord_js.CommandInteractionOptionResolver.prototype);
-    base.getSubcommandGroup = globals.jest.fn((required)=>resolveSubEntry(subcommandGroup, 'subcommand group', required));
-    base.getSubcommand = globals.jest.fn((required)=>resolveSubEntry(subcommand, 'subcommand', required));
-    base.getString = globals.jest.fn((name, required)=>resolveOrThrow(name, typeof values[name] === 'string' ? values[name] : null, required));
-    base.getNumber = globals.jest.fn((name, required)=>resolveOrThrow(name, typeof values[name] === 'number' ? values[name] : null, required));
-    base.getInteger = globals.jest.fn((name, required)=>resolveOrThrow(name, typeof values[name] === 'number' ? values[name] : null, required));
-    base.getBoolean = globals.jest.fn((name, required)=>resolveOrThrow(name, typeof values[name] === 'boolean' ? values[name] : null, required));
+    base.getSubcommandGroup = createMockFn((required)=>resolveSubEntry(subcommandGroup, 'subcommand group', required));
+    base.getSubcommand = createMockFn((required)=>resolveSubEntry(subcommand, 'subcommand', required));
+    base.getString = createMockFn((name, required)=>resolveOrThrow(name, typeof values[name] === 'string' ? values[name] : null, required));
+    base.getNumber = createMockFn((name, required)=>resolveOrThrow(name, typeof values[name] === 'number' ? values[name] : null, required));
+    base.getInteger = createMockFn((name, required)=>resolveOrThrow(name, typeof values[name] === 'number' ? values[name] : null, required));
+    base.getBoolean = createMockFn((name, required)=>resolveOrThrow(name, typeof values[name] === 'boolean' ? values[name] : null, required));
     const getObjectOption = (name, required)=>resolveOrThrow(name, isObjectOption(values[name]) ? values[name] : null, required);
-    base.getUser = globals.jest.fn(getObjectOption);
-    base.getRole = globals.jest.fn(getObjectOption);
-    base.getChannel = globals.jest.fn(getObjectOption);
-    base.getMember = globals.jest.fn(getObjectOption);
-    base.getMentionable = globals.jest.fn(getObjectOption);
+    base.getUser = createMockFn(getObjectOption);
+    base.getRole = createMockFn(getObjectOption);
+    base.getChannel = createMockFn(getObjectOption);
+    base.getMember = createMockFn(getObjectOption);
+    base.getMentionable = createMockFn(getObjectOption);
     return stubDeep(base);
 }
 

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

@@ -97,7 +97,7 @@ function isValueProvider(p) {
  * const module = MeoCordTestingModule.create({
  *   controllers: [PingController],
  *   providers: [
- *     { provide: PingService, useValue: { handlePing: jest.fn().mockResolvedValue('pong') } },
+ *     { provide: PingService, useValue: { handlePing: vi.fn().mockResolvedValue('pong') } },
  *   ],
  * }).compile()
  *

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

@@ -0,0 +1,190 @@
+/**
+ * MeoCord Framework
+ * Copyright (c) 2025 Ukasyah Rahmatullah Zada
+ * SPDX-License-Identifier: MIT
+ */ // ---------------------------------------------------------------------------
+// Framework-agnostic mock function
+//
+// A minimal mock-fn implementation used internally by the testing utilities so
+// that `meocord/testing` does not depend on jest OR vitest. Both jest and
+// vitest detect a mock via the `_isMockFunction` flag, and both
+// `expect(fn).toHaveBeenCalledWith(...)` / `toHaveBeenCalledTimes(...)` read
+// `fn.mock.calls` — so a mock produced here is recognized by assertions in
+// either framework.
+// ---------------------------------------------------------------------------
+/**
+ * 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]]
+ */ function createMockFn(impl) {
+    let currentImpl = impl;
+    let returnOnce = [];
+    let returnValue = {
+        set: false,
+        value: undefined
+    };
+    let resolvedOnce = [];
+    let resolvedValue = {
+        set: false,
+        value: undefined
+    };
+    let rejectedOnce = [];
+    let rejectedValue = {
+        set: false,
+        value: undefined
+    };
+    const implOnce = [];
+    let name = 'vi.fn';
+    const calls = [];
+    const results = [];
+    const instances = [];
+    const mockFn = function(...args) {
+        calls.push(args);
+        instances.push(this);
+        let type = 'return';
+        let value;
+        try {
+            if (implOnce.length > 0) {
+                value = implOnce.shift().apply(this, args);
+            } else if (returnOnce.length > 0) {
+                value = returnOnce.shift();
+            } else if (returnValue.set) {
+                value = returnValue.value;
+            } else if (resolvedOnce.length > 0) {
+                value = Promise.resolve(resolvedOnce.shift());
+            } else if (resolvedValue.set) {
+                value = Promise.resolve(resolvedValue.value);
+            } else if (rejectedOnce.length > 0) {
+                value = Promise.reject(rejectedOnce.shift());
+            } else if (rejectedValue.set) {
+                value = Promise.reject(rejectedValue.value);
+            } else if (currentImpl !== undefined) {
+                value = currentImpl.apply(this, args);
+            } else {
+                value = undefined;
+            }
+            return value;
+        } catch (err) {
+            type = 'throw';
+            value = err;
+            throw err;
+        } finally{
+            results.push({
+                type,
+                value
+            });
+        }
+    };
+    // Stamp the marker both jest and vitest check via isMockFunction.
+    Object.defineProperty(mockFn, '_isMockFunction', {
+        value: true,
+        enumerable: false
+    });
+    const mock = {
+        get calls () {
+            return calls;
+        },
+        get results () {
+            return results;
+        },
+        get instances () {
+            return instances;
+        },
+        get lastCall () {
+            return calls.length > 0 ? calls[calls.length - 1] : undefined;
+        }
+    };
+    Object.defineProperty(mockFn, 'mock', {
+        value: mock,
+        enumerable: false
+    });
+    mockFn.mockReturnValue = (v)=>{
+        returnValue = {
+            set: true,
+            value: v
+        };
+        return mockFn;
+    };
+    mockFn.mockReturnValueOnce = (v)=>{
+        returnOnce.push(v);
+        return mockFn;
+    };
+    mockFn.mockResolvedValue = (v)=>{
+        resolvedValue = {
+            set: true,
+            value: v
+        };
+        return mockFn;
+    };
+    mockFn.mockResolvedValueOnce = (v)=>{
+        resolvedOnce.push(v);
+        return mockFn;
+    };
+    mockFn.mockRejectedValue = (v)=>{
+        rejectedValue = {
+            set: true,
+            value: v
+        };
+        return mockFn;
+    };
+    mockFn.mockRejectedValueOnce = (v)=>{
+        rejectedOnce.push(v);
+        return mockFn;
+    };
+    mockFn.mockImplementation = (fn)=>{
+        currentImpl = fn;
+        return mockFn;
+    };
+    mockFn.mockImplementationOnce = (fn)=>{
+        implOnce.push(fn);
+        return mockFn;
+    };
+    mockFn.mockClear = ()=>{
+        calls.length = 0;
+        results.length = 0;
+        instances.length = 0;
+        return mockFn;
+    };
+    mockFn.mockReset = ()=>{
+        calls.length = 0;
+        results.length = 0;
+        instances.length = 0;
+        returnOnce = [];
+        returnValue = {
+            set: false,
+            value: undefined
+        };
+        resolvedOnce = [];
+        resolvedValue = {
+            set: false,
+            value: undefined
+        };
+        rejectedOnce = [];
+        rejectedValue = {
+            set: false,
+            value: undefined
+        };
+        implOnce.length = 0;
+        currentImpl = impl;
+        return mockFn;
+    };
+    mockFn.mockRestore = ()=>{
+        mockFn.mockReset();
+        return mockFn;
+    };
+    mockFn.getMockName = ()=>name;
+    mockFn.mockName = (n)=>{
+        name = n;
+        return mockFn;
+    };
+    return mockFn;
+}
+
+export { createMockFn };

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

@@ -1,9 +1,9 @@
 import 'reflect-metadata';
-import { jest } from '@jest/globals';
+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, Message, User, GuildMember, TextChannel, ThreadChannel, MessageMentions } from 'discord.js';
 
 // ---------------------------------------------------------------------------
-// stubDeep — Proxy that auto-creates jest.fn() on any property access
+// stubDeep — Proxy that auto-creates a mock fn on any property access
 // ---------------------------------------------------------------------------
 const SKIP = new Set([
     'constructor',
@@ -21,7 +21,7 @@ function stubDeep(instance, externalStubs) {
                 return Reflect.get(target, prop, target);
             }
             const key = prop;
-            // 'then' must be undefined — prevents jest treating the mock as a Promise
+            // 'then' must be undefined — prevents frameworks treating the mock as a Promise
             if (key === 'then') return undefined;
             // Own property writes take precedence (e.g. interaction.guildId = 'abc')
             if (Object.prototype.hasOwnProperty.call(target, key)) {
@@ -44,7 +44,7 @@ function stubDeep(instance, externalStubs) {
                 }
                 proto = Object.getPrototypeOf(proto);
             }
-            const stub = typeof protoValue === 'function' ? jest.fn() : stubDeep({});
+            const stub = typeof protoValue === 'function' ? createMockFn() : stubDeep({});
             stubs.set(key, stub);
             return stub;
         },
@@ -114,7 +114,7 @@ const CLASS_TYPE_FIELDS = {
     }
 };
 // All known pure type-guard methods on BaseInteraction and its subclasses.
-// These are wired as jest.fn() wrapping the real prototype logic so they return
+// These are wired as a mock fn wrapping the real prototype logic so they return
 // correct values by default and can still be overridden per test.
 const TYPE_GUARD_METHODS = [
     'isCommand',
@@ -154,14 +154,14 @@ function findPrototypeMethod(instance, name) {
  *
  * **Type guards** (`isButton()`, `isRepliable()`, etc.) run the real discord.js
  * prototype logic — no manual `.mockReturnValue(true)` setup needed. They are
- * still `jest.fn()` so you can override them per test.
+ * still mock functions so you can override them per test.
  *
  * **Reply state machine** — `replied` and `deferred` start as `false`. Calling
  * `reply()` or `deferReply()` twice throws, just like a real interaction would.
  * `followUp()`, `editReply()`, and `deleteReply()` throw if called before any
- * reply. These are still `jest.fn()` so call assertions work normally.
+ * reply. These are still mock functions so call assertions work normally.
  *
- * All other methods are auto-stubbed as `jest.fn()` via Proxy.
+ * All other methods are auto-stubbed as a mock fn via Proxy.
  *
  * @example
  * ```ts
@@ -184,12 +184,12 @@ function findPrototypeMethod(instance, name) {
             instance[key] = value;
         }
     }
-    // Wire each type guard as jest.fn() calling the real prototype implementation.
+    // Wire each type guard as a mock fn calling the real prototype implementation.
     // Correct by default; overridable per test via .mockReturnValue().
     for (const name of TYPE_GUARD_METHODS){
         const method = findPrototypeMethod(instance, name);
         if (method !== null) {
-            stubs.set(name, jest.fn().mockImplementation(()=>method.call(instance)));
+            stubs.set(name, createMockFn().mockImplementation(()=>method.call(instance)));
         }
     }
     // Set up reply state machine for repliable interactions
@@ -209,36 +209,36 @@ function findPrototypeMethod(instance, name) {
             if (typeof flags === 'bigint') return (flags & 64n) !== 0n;
             return false;
         };
-        stubs.set('reply', jest.fn(async (...args)=>{
+        stubs.set('reply', createMockFn(async (...args)=>{
             if (instance.deferred || instance.replied) throw alreadyReplied();
             instance.replied = true;
             if (hasEphemeralFlag(args[0])) instance.ephemeral = true;
         }));
-        stubs.set('deferReply', jest.fn(async (...args)=>{
+        stubs.set('deferReply', createMockFn(async (...args)=>{
             if (instance.deferred || instance.replied) throw alreadyReplied();
             instance.deferred = true;
             if (hasEphemeralFlag(args[0])) instance.ephemeral = true;
         }));
-        stubs.set('followUp', jest.fn(async ()=>{
+        stubs.set('followUp', createMockFn(async ()=>{
             if (!instance.deferred && !instance.replied) throw notYetReplied('followUp');
             instance.replied = true;
             return createMockMessage();
         }));
-        stubs.set('editReply', jest.fn(async ()=>{
+        stubs.set('editReply', createMockFn(async ()=>{
             if (!instance.deferred && !instance.replied) throw notYetReplied('editReply');
             instance.replied = true;
             return createMockMessage();
         }));
-        stubs.set('deleteReply', jest.fn(async ()=>{
+        stubs.set('deleteReply', createMockFn(async ()=>{
             if (!instance.deferred && !instance.replied) throw notYetReplied('deleteReply');
         }));
         // deferUpdate / update — MessageComponentInteraction only (type === MessageComponent)
         if (instance.type === InteractionType.MessageComponent) {
-            stubs.set('update', jest.fn(async ()=>{
+            stubs.set('update', createMockFn(async ()=>{
                 if (instance.deferred || instance.replied) throw alreadyReplied();
                 instance.replied = true;
             }));
-            stubs.set('deferUpdate', jest.fn(async ()=>{
+            stubs.set('deferUpdate', createMockFn(async ()=>{
                 if (instance.deferred || instance.replied) throw alreadyReplied();
                 instance.deferred = true;
             }));
@@ -249,18 +249,18 @@ function findPrototypeMethod(instance, name) {
 // ---------------------------------------------------------------------------
 // Convenience wrappers for common discord.js classes
 // ---------------------------------------------------------------------------
-/** Creates a mock {@link User}. All methods are auto-stubbed as `jest.fn()`. */ const createMockUser = ()=>createMockInteraction(User);
+/** Creates a mock {@link User}. All methods are auto-stubbed as a mock fn. */ const createMockUser = ()=>createMockInteraction(User);
 /**
  * Creates a mock {@link Client}.
  *
  * Manager methods that are constructor-assigned (not on the prototype) are
- * pre-initialized as `jest.fn()` so they work out of the box without manual
+ * pre-initialized as a mock fn so they work out of the box without manual
  * setup: `users.fetch`, `channels.fetch`, `guilds.fetch`, and
  * `application.commands.fetch`.
  */ function createMockClient() {
     const instance = Object.create(Client.prototype);
     // Manager properties are constructor-assigned — pre-initialize as prototype-based
-    // stubs so ALL manager methods (not just fetch) are auto-stubbed as jest.fn().
+    // stubs so ALL manager methods (not just fetch) are auto-stubbed as a mock fn.
     const appInstance = Object.create(null);
     appInstance.commands = stubDeep(Object.create(ApplicationCommandManager.prototype));
     instance.users = stubDeep(Object.create(UserManager.prototype));
@@ -275,7 +275,7 @@ function findPrototypeMethod(instance, name) {
  *
  * Manager properties are constructor-assigned in discord.js. This factory
  * pre-initializes each as a prototype-based stub so all methods are
- * auto-stubbed as `jest.fn()`.
+ * auto-stubbed as a mock fn.
  *
  * Pre-initialized: `members`, `channels`, `roles`, `bans`.
  */ function createMockGuild() {
@@ -291,7 +291,7 @@ function findPrototypeMethod(instance, name) {
  *
  * Manager properties that are constructor-assigned in discord.js are
  * pre-initialized as prototype-based stubs so all methods are auto-stubbed
- * as `jest.fn()`:
+ * as a mock fn:
  * - Guild text channels (`TextChannel`, `NewsChannel`): `messages`, `threads`
  * - `DMChannel`: `messages`
  * - `ThreadChannel`: `messages`, `members`
@@ -326,7 +326,7 @@ function findPrototypeMethod(instance, name) {
  * `msg.channel.send`, `msg.guild.members.fetch`, `msg.thread.fetch`,
  * and `msg.mentions.has` all work out of the box.
  *
- * All methods remain `jest.fn()` — overridable per test.
+ * All methods remain mock functions — overridable per test.
  *
  * Note: `createMockInteraction`'s `followUp()` and `editReply()` stubs return
  * a `createMockMessage()` by default, matching the official return types.
@@ -349,7 +349,7 @@ function createMockMessage() {
     // Constructor-assigned — set as prototype-based stubs
     instance.author = stubDeep(Object.create(User.prototype));
     // Getters on the prototype — the proxy sees them as functions and returns
-    // jest.fn(), which is wrong. Pre-initialize as own properties to shadow
+    // a mock fn, which is wrong. Pre-initialize as own properties to shadow
     // the prototype getters.
     Object.defineProperty(instance, 'member', {
         value: stubDeep(Object.create(GuildMember.prototype)),
@@ -370,25 +370,25 @@ function createMockMessage() {
     // MessageMentions — constructor-assigned, has methods like .has(), .members
     instance.mentions = stubDeep(Object.create(MessageMentions.prototype));
     const alreadyDeleted = ()=>new Error('This message has already been deleted.');
-    stubs.set('delete', jest.fn(async ()=>{
+    stubs.set('delete', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
         instance.deleted = true;
     }));
-    stubs.set('edit', jest.fn(async ()=>{
+    stubs.set('edit', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
         return createMockMessage();
     }));
-    stubs.set('reply', jest.fn(async ()=>{
+    stubs.set('reply', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
         return createMockMessage();
     }));
-    stubs.set('react', jest.fn(async ()=>{
+    stubs.set('react', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
     }));
-    stubs.set('pin', jest.fn(async ()=>{
+    stubs.set('pin', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
     }));
-    stubs.set('unpin', jest.fn(async ()=>{
+    stubs.set('unpin', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
     }));
     return stubDeep(instance, stubs);
@@ -398,7 +398,7 @@ function createMockMessage() {
  * `CommandInteractionOptionResolver` works: declare what options the command
  * was invoked with, and the resolver finds them by name.
  *
- * All explicit methods are `jest.fn()` — override per test with `.mockReturnValue()`.
+ * All explicit methods are mock functions — override per test with `.mockReturnValue()`.
  * Methods not listed (e.g. `getAttachment`) are auto-stubbed by the Proxy.
  *
  * @example
@@ -430,20 +430,20 @@ function createMockMessage() {
     }
     const isObjectOption = (v)=>typeof v === 'object' && v !== null && 'id' in v;
     // Use a real prototype instance so unlisted methods (e.g. getAttachment)
-    // are found on the prototype chain and auto-stubbed as jest.fn()
+    // are found on the prototype chain and auto-stubbed as a mock fn
     const base = Object.create(CommandInteractionOptionResolver.prototype);
-    base.getSubcommandGroup = jest.fn((required)=>resolveSubEntry(subcommandGroup, 'subcommand group', required));
-    base.getSubcommand = jest.fn((required)=>resolveSubEntry(subcommand, 'subcommand', required));
-    base.getString = jest.fn((name, required)=>resolveOrThrow(name, typeof values[name] === 'string' ? values[name] : null, required));
-    base.getNumber = jest.fn((name, required)=>resolveOrThrow(name, typeof values[name] === 'number' ? values[name] : null, required));
-    base.getInteger = jest.fn((name, required)=>resolveOrThrow(name, typeof values[name] === 'number' ? values[name] : null, required));
-    base.getBoolean = jest.fn((name, required)=>resolveOrThrow(name, typeof values[name] === 'boolean' ? values[name] : null, required));
+    base.getSubcommandGroup = createMockFn((required)=>resolveSubEntry(subcommandGroup, 'subcommand group', required));
+    base.getSubcommand = createMockFn((required)=>resolveSubEntry(subcommand, 'subcommand', required));
+    base.getString = createMockFn((name, required)=>resolveOrThrow(name, typeof values[name] === 'string' ? values[name] : null, required));
+    base.getNumber = createMockFn((name, required)=>resolveOrThrow(name, typeof values[name] === 'number' ? values[name] : null, required));
+    base.getInteger = createMockFn((name, required)=>resolveOrThrow(name, typeof values[name] === 'number' ? values[name] : null, required));
+    base.getBoolean = createMockFn((name, required)=>resolveOrThrow(name, typeof values[name] === 'boolean' ? values[name] : null, required));
     const getObjectOption = (name, required)=>resolveOrThrow(name, isObjectOption(values[name]) ? values[name] : null, required);
-    base.getUser = jest.fn(getObjectOption);
-    base.getRole = jest.fn(getObjectOption);
-    base.getChannel = jest.fn(getObjectOption);
-    base.getMember = jest.fn(getObjectOption);
-    base.getMentionable = jest.fn(getObjectOption);
+    base.getUser = createMockFn(getObjectOption);
+    base.getRole = createMockFn(getObjectOption);
+    base.getChannel = createMockFn(getObjectOption);
+    base.getMember = createMockFn(getObjectOption);
+    base.getMentionable = createMockFn(getObjectOption);
     return stubDeep(base);
 }
 

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

@@ -1,6 +1,5 @@
 import { ServiceIdentifier, Container } from 'inversify';
 import { GuardInterface } from '../interface/index.js';
-import { jest } from '@jest/globals';
 import { CommandInteractionOptionResolver, Channel, Client, Guild, Message, User } from 'discord.js';
 import 'webpack';
 import '../controller.enum-QA-IuReF.js';
@@ -57,7 +56,7 @@ declare class TestingModuleBuilder {
  * const module = MeoCordTestingModule.create({
  *   controllers: [PingController],
  *   providers: [
- *     { provide: PingService, useValue: { handlePing: jest.fn().mockResolvedValue('pong') } },
+ *     { provide: PingService, useValue: { handlePing: vi.fn().mockResolvedValue('pong') } },
  *   ],
  * }).compile()
  *
@@ -68,6 +67,50 @@ declare class MeoCordTestingModule {
     static create(options: TestingModuleOptions): TestingModuleBuilder;
 }
 
+/**
+ * MeoCord Framework
+ * Copyright (c) 2025 Ukasyah Rahmatullah Zada
+ * SPDX-License-Identifier: MIT
+ */
+interface MockResult<T = unknown> {
+    type: 'return' | 'throw';
+    value: T;
+}
+interface MockState<T extends (...args: any[]) => any = (...args: any[]) => any> {
+    /** Arguments from each call, in order. */
+    readonly calls: Parameters<T>[];
+    /** Return / throw result from each call, in order. */
+    readonly results: MockResult<ReturnType<T>>[];
+    /** The `this` value recorded for each call. */
+    readonly instances: any[];
+    /** Arguments from the most recent call, or undefined if never called. */
+    readonly lastCall?: Parameters<T>;
+}
+interface MockInstance<T extends (...args: any[]) => any = (...args: any[]) => any> {
+    /** Marker both jest and vitest check via `isMockFunction`. Do not remove. */
+    readonly _isMockFunction: true;
+    readonly mock: MockState<T>;
+    mockReturnValue(value: ReturnType<T>): MockedFunction<T>;
+    mockReturnValueOnce(value: ReturnType<T>): MockedFunction<T>;
+    mockResolvedValue(value: Awaited<ReturnType<T>>): MockedFunction<T>;
+    mockResolvedValueOnce(value: Awaited<ReturnType<T>>): MockedFunction<T>;
+    mockRejectedValue(value: unknown): MockedFunction<T>;
+    mockRejectedValueOnce(value: unknown): MockedFunction<T>;
+    mockImplementation(fn: T): MockedFunction<T>;
+    mockImplementationOnce(fn: T): MockedFunction<T>;
+    mockClear(): MockedFunction<T>;
+    mockReset(): MockedFunction<T>;
+    mockRestore(): MockedFunction<T>;
+    getMockName(): string;
+    mockName(name: string): MockedFunction<T>;
+}
+/**
+ * A callable that mirrors the signature of `T` and exposes the mock API
+ * (`mockReturnValue`, `mockResolvedValue`, `mockImplementation`, `.mock`, …).
+ * Drop-in replacement for `jest.MockedFunction<T>` / vitest `MockedFunction<T>`.
+ */
+type MockedFunction<T extends (...args: any[]) => any> = ((...args: Parameters<T>) => ReturnType<T>) & MockInstance<T>;
+
 /**
  * MeoCord Framework
  * Copyright (c) 2025 Ukasyah Rahmatullah Zada
@@ -75,13 +118,13 @@ declare class MeoCordTestingModule {
  */
 
 /**
- * Recursively transforms all methods of T into jest.MockedFunction and all
+ * 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.
  */
 type DeepMocked<T, Depth extends number[] = []> = Depth['length'] extends 5 ? T : {
-    -readonly [K in keyof T]: T[K] extends (...args: infer A) => infer R ? jest.MockedFunction<(...args: A) => R> : T[K] extends object ? DeepMocked<T[K], [...Depth, 0]> : T[K];
+    -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];
 };
 interface InteractionClass<T> {
     prototype: T;
@@ -93,14 +136,14 @@ interface InteractionClass<T> {
  *
  * **Type guards** (`isButton()`, `isRepliable()`, etc.) run the real discord.js
  * prototype logic — no manual `.mockReturnValue(true)` setup needed. They are
- * still `jest.fn()` so you can override them per test.
+ * still mock functions so you can override them per test.
  *
  * **Reply state machine** — `replied` and `deferred` start as `false`. Calling
  * `reply()` or `deferReply()` twice throws, just like a real interaction would.
  * `followUp()`, `editReply()`, and `deleteReply()` throw if called before any
- * reply. These are still `jest.fn()` so call assertions work normally.
+ * reply. These are still mock functions so call assertions work normally.
  *
- * All other methods are auto-stubbed as `jest.fn()` via Proxy.
+ * All other methods are auto-stubbed as a mock fn via Proxy.
  *
  * @example
  * ```ts
@@ -115,13 +158,13 @@ interface InteractionClass<T> {
  * ```
  */
 declare function createMockInteraction<T extends object>(Class: InteractionClass<T>): DeepMocked<T>;
-/** Creates a mock {@link User}. All methods are auto-stubbed as `jest.fn()`. */
+/** Creates a mock {@link User}. All methods are auto-stubbed as a mock fn. */
 declare const createMockUser: () => DeepMocked<User>;
 /**
  * Creates a mock {@link Client}.
  *
  * Manager methods that are constructor-assigned (not on the prototype) are
- * pre-initialized as `jest.fn()` so they work out of the box without manual
+ * pre-initialized as a mock fn so they work out of the box without manual
  * setup: `users.fetch`, `channels.fetch`, `guilds.fetch`, and
  * `application.commands.fetch`.
  */
@@ -131,7 +174,7 @@ declare function createMockClient(): DeepMocked<Client>;
  *
  * Manager properties are constructor-assigned in discord.js. This factory
  * pre-initializes each as a prototype-based stub so all methods are
- * auto-stubbed as `jest.fn()`.
+ * auto-stubbed as a mock fn.
  *
  * Pre-initialized: `members`, `channels`, `roles`, `bans`.
  */
@@ -141,7 +184,7 @@ declare function createMockGuild(): DeepMocked<Guild>;
  *
  * Manager properties that are constructor-assigned in discord.js are
  * pre-initialized as prototype-based stubs so all methods are auto-stubbed
- * as `jest.fn()`:
+ * as a mock fn:
  * - Guild text channels (`TextChannel`, `NewsChannel`): `messages`, `threads`
  * - `DMChannel`: `messages`
  * - `ThreadChannel`: `messages`, `members`
@@ -160,7 +203,7 @@ interface ChatInputOptions {
  * `CommandInteractionOptionResolver` works: declare what options the command
  * was invoked with, and the resolver finds them by name.
  *
- * All explicit methods are `jest.fn()` — override per test with `.mockReturnValue()`.
+ * All explicit methods are mock functions — override per test with `.mockReturnValue()`.
  * Methods not listed (e.g. `getAttachment`) are auto-stubbed by the Proxy.
  *
  * @example

package/meocord.eslint.cjs

@@ -83,7 +83,7 @@ const specConfig = {
 }
 
 module.exports = [
-  { ignores: ['docs/*', 'build/*', 'lib/*', 'dist/*', 'meocord.config.ts', 'jest.config.ts'] },
+  { ignores: ['docs/*', 'build/*', 'lib/*', 'dist/*', 'meocord.config.ts', 'vitest.config.ts'] },
   ...recommendedTypeScriptConfigs,
   specConfig,
   eslintConfigPrettier,

package/meocord.eslint.mjs

@@ -83,7 +83,7 @@ const specConfig = {
 }
 
 export default [
-  { ignores: ['docs/*', 'build/*', 'lib/*', 'dist/*', 'meocord.config.ts', 'jest.config.ts'] },
+  { ignores: ['docs/*', 'build/*', 'lib/*', 'dist/*', 'meocord.config.ts', 'vitest.config.ts'] },
   ...recommendedTypeScriptConfigs,
   specConfig,
   eslintConfigPrettier,

package/package.json

@@ -1,16 +1,16 @@
 {
   "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.3",
+  "version": "1.8.4-beta.1",
   "type": "module",
   "scripts": {
     "lint": "eslint --fix . && tsc --noEmit && tsc --noEmit --project tsconfig.test.json",
     "build": "rm -rf ./dist && rollup -c",
     "prepare": "husky",
-    "test": "node --experimental-vm-modules node_modules/.bin/jest",
-    "test:watch": "node --experimental-vm-modules node_modules/.bin/jest --watch",
-    "test:coverage": "node --experimental-vm-modules node_modules/.bin/jest --coverage",
-    "test:typecheck": "bunx tsc --noEmit --project tsconfig.test.json"
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:typecheck": "tsc --noEmit --project tsconfig.test.json"
   },
   "bin": "./dist/esm/bin/meocord.js",
   "repository": {
@@ -71,7 +71,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@clack/prompts": "^1.6.0",
+    "@clack/prompts": "^1.7.0",
     "@swc/core": "1.15.43",
     "chalk": "^5.6.2",
     "cli-table3": "^0.6.5",
@@ -87,7 +87,7 @@
     "swc-loader": "^0.2.7",
     "terser-webpack-plugin": "^5.6.1",
     "tsconfig-paths-webpack-plugin": "^4.2.0",
-    "webpack": "^5.108.0",
+    "webpack": "^5.108.3",
     "webpack-node-externals": "^3.0.0"
   },
   "devDependencies": {
@@ -98,31 +98,31 @@
     "@rollup/plugin-swc": "^0.4.1",
     "@semantic-release/commit-analyzer": "^13.0.1",
     "@semantic-release/exec": "^7.1.0",
-    "@semantic-release/github": "^12.0.8",
+    "@semantic-release/github": "^12.0.9",
     "@semantic-release/release-notes-generator": "^14.1.1",
-    "@swc/jest": "^0.2.39",
-    "@types/jest": "30.0.0",
     "@types/lodash-es": "^4.17.12",
     "@types/webpack-node-externals": "^3.0.4",
-    "@typescript-eslint/parser": "^8.62.0",
+    "@typescript-eslint/parser": "^8.62.1",
     "discord.js": "^14.26.4",
-    "eslint": "^10.5.0",
+    "eslint": "^10.6.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-headers": "^1.3.4",
-    "eslint-plugin-import-x": "^4.17.0",
+    "eslint-plugin-import-x": "^4.17.1",
     "eslint-plugin-prettier": "^5.5.6",
     "eslint-plugin-unused-imports": "^4.4.1",
     "globals": "^17.7.0",
     "husky": "^9.1.7",
-    "jest": "30.4.2",
-    "prettier": "^3.8.4",
+    "prettier": "^3.9.4",
     "rollup": "^4.62.2",
     "rollup-plugin-copy": "^3.5.0",
     "rollup-plugin-dts": "^6.4.1",
     "semantic-release": "^25.0.5",
     "ts-node": "^10.9.2",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.62.0"
+    "typescript-eslint": "^8.62.1",
+    "@vitest/coverage-istanbul": "^3.2.4",
+    "unplugin-swc": "^1.5.5",
+    "vitest": "^3.2.4"
   },
   "peerDependencies": {
     "discord.js": "^14.26.4",