chore(main): release 4.2.6 (#403)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

.github/workflows/continuous-integration.yml

@@ -1,50 +0,0 @@
-name: Continuous Integration
-
-on:
-  # Trigger the workflow on push or pull request or custom
-  push:
-    branches: [main]
-    paths:
-      - '*.ts'
-  pull_request_target:
-    branches:
-      main
-    paths:
-      - '*ts'
-  workflow_dispatch:
-
-jobs:
-  Prettier:
-    name: Run Prettier
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Check out Git repository
-        uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3
-
-      - name: Set up Node.js
-        uses: actions/setup-node@1a4442cacd436585916779262731d5b162bc6ec7 # v3
-        with:
-          node-version: 17
-
-      - name: Install pnpm
-        run: npm i -g yarn
-
-      # Prettier must be in `package.json`
-      - name: Install Node.js dependencies
-        run:  yarn --immutable
-
-      - name: Run Prettier
-        run: yarn pretty
-
-      - name: Create Pull Request
-        id: cpr
-        uses: peter-evans/create-pull-request@38e0b6e68b4c852a5500a94740f0e535e0d7ba54 # v4
-        with:
-          commit-message: "style: pretty please"
-          branch: prettier
-          delete-branch: true
-          branch-suffix: short-commit-hash
-          title: "style: pretty please"
-          body: "pretty pretty prettier"
-          reviewers: EvolutionX-10

.github/workflows/npm-publish.yml

@@ -13,9 +13,9 @@ jobs:
       - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3
       - uses: actions/setup-node@1a4442cacd436585916779262731d5b162bc6ec7 # v3
         with:
-          node-version: 17
+          node-version: 18
-      - run: yarn --immutable
+      - run: npm i
-      - run: yarn build:prod
+      - run: npm run build:prod
       - uses: JS-DevTools/npm-publish@0f451a94170d1699fd50710966d48fb26194d939 # v1
         with:
           token: ${{ secrets.NPM_TOKEN }}

.github/workflows/test.yml

@@ -24,6 +24,5 @@ jobs:
       with:
         node-version: ${{ matrix.node-version }}
         cache: 'npm'
-    - run: npm install -g yarn
+    - run: npm install
-    - run: yarn install
+    - run: npm run test
-    - run: yarn test

.yarnrc.yml

@@ -1,5 +0,0 @@
-enableGlobalCache: true
-
-nodeLinker: node-modules
-
-yarnPath: .yarn/releases/yarn-3.5.1.cjs

CHANGELOG.md

@@ -1,5 +1,74 @@
 # Changelog
 
+## [4.2.6](https://github.com/sern-handler/handler/compare/v4.2.5...v4.2.6) (2025-09-22)
+
+
+### Miscellaneous Chores
+
+* release 4.2.6 ([#402](https://github.com/sern-handler/handler/issues/402)) ([0eecb08](https://github.com/sern-handler/handler/commit/0eecb08e87e26102030ccf6ef38ddd81051ec373))
+
+## [4.2.5](https://github.com/sern-handler/handler/compare/v4.2.4...v4.2.5) (2025-08-31)
+
+
+### Bug Fixes
+
+* make message module warn rather than throwing ([#399](https://github.com/sern-handler/handler/issues/399)) ([797442e](https://github.com/sern-handler/handler/commit/797442ece3999bf2cb6b5ba0688ce0177e72a22f))
+
+## [4.2.4](https://github.com/sern-handler/handler/compare/v4.2.3...v4.2.4) (2025-03-06)
+
+
+### Bug Fixes
+
+* flat autocomplete ([#395](https://github.com/sern-handler/handler/issues/395)) ([89d7409](https://github.com/sern-handler/handler/commit/89d74095363befddc3222b9e5c89c35e7c6457b9))
+
+## [4.2.3](https://github.com/sern-handler/handler/compare/v4.2.2...v4.2.3) (2025-03-04)
+
+
+### Bug Fixes
+
+* autocomplete sdt.module not present ([#393](https://github.com/sern-handler/handler/issues/393)) ([2414992](https://github.com/sern-handler/handler/commit/2414992b73a40065464b20f2d53826c78fcd3a5f))
+
+## [4.2.2](https://github.com/sern-handler/handler/compare/v4.2.1...v4.2.2) (2025-02-03)
+
+
+### Bug Fixes
+
+* faster autocomplete lookup ([#387](https://github.com/sern-handler/handler/issues/387)) ([974c30f](https://github.com/sern-handler/handler/commit/974c30fa6cccaae7b1c2c3246ffa9eecb6bc7bf9))
+
+## [4.2.1](https://github.com/sern-handler/handler/compare/v4.2.0...v4.2.1) (2025-01-24)
+
+
+### Bug Fixes
+
+* context-interactions error ([#382](https://github.com/sern-handler/handler/issues/382)) ([a52ad27](https://github.com/sern-handler/handler/commit/a52ad270d843e92db5bf2049d07527eed59d428c))
+
+## [4.2.0](https://github.com/sern-handler/handler/compare/v4.1.1...v4.2.0) (2025-01-18)
+
+
+### Features
+
+* 4.2.0 load multiple directories & `handleModuleErrors` ([#378](https://github.com/sern-handler/handler/issues/378)) ([f9e7eaf](https://github.com/sern-handler/handler/commit/f9e7eaf92d22b76d3d02a1bbe8324ca6813f48f8))
+
+## [4.1.1](https://github.com/sern-handler/handler/compare/v4.1.0...v4.1.1) (2025-01-13)
+
+
+### Bug Fixes
+
+* remove rxjs ([#376](https://github.com/sern-handler/handler/issues/376)) ([59d08ef](https://github.com/sern-handler/handler/commit/59d08ef207c486ce1cf0aba267e6f862838e0dfb))
+* This puts the light back into lightweight (\- 4.1 MB)
+
+## [4.1.0](https://github.com/sern-handler/handler/compare/v4.0.3...v4.1.0) (2025-01-06)
+
+
+### Features
+
+* moduleinfo-in-eventplugins ([#373](https://github.com/sern-handler/handler/issues/373)) ([220a60e](https://github.com/sern-handler/handler/commit/220a60ecf853df8d288de2533c669562a430c3f9))
+
+
+### Bug Fixes
+
+* update github username ([#371](https://github.com/sern-handler/handler/issues/371)) ([55715d5](https://github.com/sern-handler/handler/commit/55715d565990fe686159f3c1eda3754d1262c72c))
+
 ## [4.0.3](https://github.com/sern-handler/handler/compare/v4.0.2...v4.0.3) (2024-10-06)
 
 

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 sern
+Copyright (c) 2025 sern
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -7,6 +7,7 @@
 
 <div align="center" styles="margin-top: 10px">
   <img src="https://img.shields.io/badge/open-source-brightgreen" />
+  <img src="https://img.shields.io/badge/built_with-sern-pink?labelColor=%230C3478&color=%23ed5087&link=https%3A%2F%2Fsern.dev"/>
   <a href="https://www.npmjs.com/package/@sern/handler"><img src="https://img.shields.io/npm/v/@sern/handler?maxAge=3600" alt="NPM version" /></a>
   <a href="https://www.npmjs.com/package/@sern/handler"><img src="https://img.shields.io/npm/dt/@sern/handler?maxAge=3600" alt="NPM downloads" /></a>
   <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/license-MIT-brightgreen" alt="License MIT" /></a>
@@ -19,7 +20,7 @@
 - Lightweight. Does a lot while being small.
 - Latest features. Support for discord.js v14 and all of its interactions.
 - Start quickly. Plug and play or customize to your liking.
-- works with [bun](https://bun.sh/) and [node](https://nodejs.org/en) out the box!
+- Works with [bun](https://bun.sh/) and [node](https://nodejs.org/en) out the box!
 - Use it with TypeScript or JavaScript. CommonJS and ESM supported.
 - Active and growing community, always here to help. [Join us](https://sern.dev/discord)
 - Unleash its full potential with a powerful CLI and awesome plugins.
@@ -43,20 +44,29 @@ export default commandModule({
 ```
 </details>
 
+# Show off your sern Discord Bot!
+
+## Badge
+- Copy this and add it to your [README.md](https://img.shields.io/badge/built_with-sern-pink?labelColor=%230C3478&color=%23ed5087&link=https%3A%2F%2Fsern.dev)
+<img src="https://img.shields.io/badge/built_with-sern-pink?labelColor=%230C3478&color=%23ed5087&link=https%3A%2F%2Fsern.dev">
 
 ## 🤖 Bots Using sern 
-- [Community Bot](https://github.com/sern-handler/sern-community), the community bot for our [discord server](https://sern.dev/discord).
+- [Community Bot](https://github.com/sern-handler/sern-community) - The community bot for our [Discord server](https://sern.dev/discord).
-- [Vinci](https://github.com/SrIzan10/vinci), the bot for Mara Turing.
+- [Vinci](https://github.com/SrIzan10/vinci) - The bot for Mara Turing.
-- [Bask](https://github.com/baskbotml/bask), Listen your favorite artists on Discord.
+- [Bask](https://github.com/baskbotml/bask) - Listen to your favorite artists on Discord.
-- [Murayama](https://github.com/murayamabot/murayama), :pepega:
+- [Murayama](https://github.com/murayamabot/murayama) - :pepega:
-- [Protector (WIP)](https://github.com/needhamgary/Protector), Just a simple bot to help enhance a private minecraft server.
+- [Protector](https://github.com/GlitchApotamus/Protector) - Just a simple bot to help enhance a private Minecraft server.
-- [SmokinWeed 💨](https://github.com/Peter-MJ-Parker/sern-bud), A fun bot for a small - but growing - server.
+- [SmokinWeed 💨](https://github.com/Peter-MJ-Parker/sern-bud) - A fun bot for a small, but growing server.
-- [Man Nomic](https://github.com/jacoobes/man-nomic), A simple information bot to provide information to the nomic-ai discord community.
+- [Man Nomic](https://github.com/jacoobes/man-nomic) - A simple information bot to provide information to the nomic-ai Discord community.
-- [Linear-Discord](https://github.com/sern-handler/linear-discord) Display and manage a linear dashboard.
+- [Linear-Discord](https://github.com/sern-handler/linear-discord) - Display and manage a linear dashboard.
+- [ZenithBot](https://github.com/CodeCraftersHaven/ZenithBot) - A versatile bot coded in TypeScript, designed to enhance server management and user interaction through its robust features.
+
 ## 💻 CLI
 
 It is **highly encouraged** to use the [command line interface](https://github.com/sern-handler/cli) for your project. Don't forget to view it.
 
+
+
 ## 🔗 Links
 
 - [Official Documentation and Guide](https://sern.dev)

package.json

@@ -1,7 +1,7 @@
 {
     "name": "@sern/handler",
     "packageManager": "yarn@3.5.0",
-    "version": "4.0.3",
+    "version": "4.2.6",
     "description": "A complete, customizable, typesafe, & reactive framework for discord bots.",
     "main": "./dist/index.js",
     "module": "./dist/index.js",
@@ -20,6 +20,7 @@
         "prepare": "tsc",
         "pretty": "prettier --write .",
         "tdd": "vitest",
+        "benchmark": "vitest bench",
         "test": "vitest --run",
         "analyze-imports": "npx depcruise src --include-only \"^src\" --output-type dot | dot -T svg > dependency-graph.svg"
     },
@@ -35,11 +36,10 @@
     "author": "SernDevs",
     "license": "MIT",
     "dependencies": {
-        "@sern/ioc": "^1.1.0",
+        "@sern/ioc": "^1.1.2",
         "callsites": "^3.1.0",
         "cron": "^3.1.7",
-        "deepmerge": "^4.3.1",
+        "deepmerge": "^4.3.1"
-        "rxjs": "^7.8.0"
     },
     "devDependencies": {
         "@faker-js/faker": "^8.0.1",
@@ -47,7 +47,7 @@
         "@types/node-cron": "^3.0.11",
         "@typescript-eslint/eslint-plugin": "5.58.0",
         "@typescript-eslint/parser": "5.59.1",
-        "discord.js": "^14.15.3",
+        "discord.js": "^14.22.1",
         "eslint": "8.39.0",
         "typescript": "5.0.2",
         "vitest": "^1.6.0"

src/core/functions.ts

@@ -6,12 +6,27 @@ import type {
     MessageContextMenuCommandInteraction,
     ModalSubmitInteraction,
     UserContextMenuCommandInteraction,
-    AutocompleteInteraction
+    AutocompleteInteraction,
 } from 'discord.js';
 import { ApplicationCommandOptionType, InteractionType } from 'discord.js';
 import { PluginType } from './structures/enums';
-import assert from 'assert';
+import type { Payload, UnpackedDependencies } from '../types/utility';
-import type { Payload } from '../types/utility';
+import path from 'node:path'
+
+export const createSDT = (module: Module, deps: UnpackedDependencies, params: string|undefined) => {
+    return {
+        state: {},
+        deps,
+        params, 
+        type: module.type,
+        module: {
+            name: module.name,
+            description: module.description,
+            locals: module.locals,
+            meta: module.meta
+        }
+    }
+}
 
 /**
  * Removes the first character(s) _[depending on prefix length]_ of the message
@@ -42,51 +57,31 @@ export function partitionPlugins<T,V>
     return [controlPlugins, initPlugins] as [T[], V[]];
 }
 
-/**
+export const createLookupTable = (options: SernOptionsData[]): Map<string, SernAutocompleteData> => {
- * Uses an iterative DFS to check if an autocomplete node exists on the option tree
+    const table = new Map<string, SernAutocompleteData>();
- * @param iAutocomplete
+    _createLookupTable(table, options, "<parent>");
- * @param options
+    return table;
- */
+}
-export function treeSearch(
+
-    iAutocomplete: AutocompleteInteraction,
+const _createLookupTable = (table: Map<string, SernAutocompleteData>, options: SernOptionsData[], parent: string) => {
-    options: SernOptionsData[] | undefined,
+    for (const opt of options) {
-): SernAutocompleteData & { parent?: string } | undefined {
+        const name = path.posix.join(parent, opt.name)
-    if (options === undefined) return undefined;
+        switch(opt.type) {
-    //clone to prevent mutation of original command module
-    const _options = options.map(a => ({ ...a }));
-    const subcommands = new Set();
-    while (_options.length > 0) {
-        const cur = _options.pop()!;
-        switch (cur.type) {
             case ApplicationCommandOptionType.Subcommand: {
-                    subcommands.add(cur.name);
+                    _createLookupTable(table, opt.options ?? [], name);
-                    for (const option of cur.options ?? []) _options.push(option);
+            } break;
-                } break;
             case ApplicationCommandOptionType.SubcommandGroup: {
-                    for (const command of cur.options ?? []) _options.push(command);
+                    _createLookupTable(table, opt.options ?? [], name);
-                } break;
+            } break;
             default: {
-                if ('autocomplete' in cur && cur.autocomplete) {
+                if(Reflect.get(opt, 'autocomplete') === true) {
-                    const choice = iAutocomplete.options.getFocused(true);
+                    table.set(name, opt as SernAutocompleteData)
-                    assert( 'command' in cur, 'No `command` property found for option ' + cur.name);
-                    if (subcommands.size > 0) {
-                        const parent = iAutocomplete.options.getSubcommand();
-                        const parentAndOptionMatches =
-                            subcommands.has(parent) && cur.name === choice.name;
-                        if (parentAndOptionMatches) {
-                            return { ...cur, parent };
-                        }
-                    } else {
-                        if (cur.name === choice.name) {
-                            return { ...cur, parent: undefined };
-                        }
-                    }
                 }
             } break;
         }
-    }
+    } 
-}
 
+}
 
 interface InteractionTypable {
     type: InteractionType;
@@ -104,6 +99,9 @@ export function isMessageComponent(i: InteractionTypable): i is AnyMessageCompon
 export function isCommand(i: InteractionTypable): i is AnyCommandInteraction {
     return i.type === InteractionType.ApplicationCommand;
 }
+export function isContextCommand(i: AnyCommandInteraction): i is MessageContextMenuCommandInteraction | UserContextMenuCommandInteraction {
+    return i.isContextMenuCommand();
+}
 export function isAutocomplete(i: InteractionTypable): i is AutocompleteInteraction {
     return i.type === InteractionType.ApplicationCommandAutocomplete;
 }

src/core/ioc.ts

@@ -70,7 +70,7 @@ export async function makeDependencies (conf: ValidDependencyConfig) {
     }
     container.addSingleton('@sern/errors', new __Services.DefaultErrorHandling);
     container.addSingleton('@sern/modules', new Map);
-    container.addSingleton('@sern/emitter', new EventEmitter)
+    container.addSingleton('@sern/emitter', new EventEmitter({ captureRejections: true }))
     container.addSingleton('@sern/scheduler', new __Services.TaskScheduler)
     conf(dependencyBuilder(container));
     await container.ready();

src/core/modules.ts

@@ -10,8 +10,39 @@ import { partitionPlugins } from './functions'
 import type { Awaitable } from '../types/utility';
 
 /**
- * @since 1.0.0 The wrapper function to define command modules for sern
+ * Creates a command module with standardized structure and plugin support.
- * @param mod
+ * 
+ * @since 1.0.0
+ * @param {InputCommand} mod - Command module configuration
+ * @returns {Module} Processed command module ready for registration
+ * 
+ * @example
+ * // Basic slash command
+ * export default commandModule({
+ *   type: CommandType.Slash,
+ *   description: "Ping command",
+ *   execute: async (ctx) => {
+ *     await ctx.reply("Pong! 🏓");
+ *   }
+ * });
+ * 
+ * @example
+ * // Command with component interaction
+ * export default commandModule({
+ *   type: CommandType.Slash,
+ *   description: "Interactive command",
+ *   execute: async (ctx) => {
+ *     const button = new ButtonBuilder({
+ *       customId: "btn/someData",
+ *       label: "Click me",
+ *       style: ButtonStyle.Primary
+ *     });
+ *     await ctx.reply({
+ *       content: "Interactive message",
+ *       components: [new ActionRowBuilder().addComponents(button)]
+ *     });
+ *   }
+ * });
  */
 export function commandModule(mod: InputCommand): Module {
     const [onEvent, plugins] = partitionPlugins(mod.plugins);
@@ -21,10 +52,33 @@ export function commandModule(mod: InputCommand): Module {
              locals: {} } as Module;
 }
 
+
 /**
+ * Creates an event module for handling Discord.js or custom events.
+ * 
  * @since 1.0.0
- * The wrapper function to define event modules for sern
+ * @template T - Event name from ClientEvents
- * @param mod
+ * @param {InputEvent<T>} mod - Event module configuration
+ * @returns {Module} Processed event module ready for registration
+ * @throws {Error} If ControlPlugins are used in event modules
+ * 
+ * @example
+ * // Discord event listener
+ * export default eventModule({
+ *   type: EventType.Discord,
+ *   execute: async (message) => {
+ *     console.log(`${message.author.tag}: ${message.content}`);
+ *   }
+ * });
+ * 
+ * @example
+ * // Custom sern event
+ * export default eventModule({
+ *   type: EventType.Sern,
+ *   execute: async (eventData) => {
+ *     // Handle sern-specific event
+ *   }
+ * });
  */
 export function eventModule<T extends keyof ClientEvents = keyof ClientEvents>(mod: InputEvent<T>): Module {
     const [onEvent, plugins] = partitionPlugins(mod.plugins);
@@ -48,5 +102,34 @@ export function discordEvent<T extends keyof ClientEvents>(mod: {
     return eventModule({ type: EventType.Discord, ...mod, });
 }
 
-export function scheduledTask(ism: ScheduledTask) { return ism }
+/**
+ * Creates a scheduled task that can be executed at specified intervals using cron patterns
+ * 
+ * @param {ScheduledTask} ism - The scheduled task configuration object
+ * @param {string} ism.trigger - A cron pattern that determines when the task should execute
+ *                              Format: "* * * * *" (minute hour day month day-of-week)
+ * @param {Function} ism.execute - The function to execute when the task is triggered
+ * @param {Object} ism.execute.context - The execution context passed to the task
+ * 
+ * @returns {ScheduledTask} The configured scheduled task
+ * 
+ * @example
+ * // Create a task that runs every minute
+ * export default scheduledTask({
+ *   trigger: "* * * * *",
+ *   execute: (context) => {
+ *     console.log("Task executed!");
+ *   }
+ * });
+ * 
+ * @remarks
+ * - Tasks must be placed in the 'tasks' directory specified in your config
+ * - The file name serves as a unique identifier for the task
+ * - Tasks can be cancelled using deps['@sern/scheduler'].kill(uuid)
+ * 
+ * @see {@link https://crontab.guru/} for testing and creating cron patterns
+ */
+export function scheduledTask(ism: ScheduledTask): ScheduledTask { 
+    return ism 
+}
 

src/core/plugin.ts

@@ -1,6 +1,7 @@
 import { CommandType, PluginType } from './structures/enums';
 import type { Plugin, PluginResult, CommandArgs, InitArgs } from '../types/core-plugin';
 import { Err, Ok } from './structures/result';
+import type { Dictionary } from '../types/utility';
 
 export function makePlugin<V extends unknown[]>(
     type: PluginType,
@@ -14,16 +15,107 @@ export function makePlugin<V extends unknown[]>(
 export function EventInitPlugin(execute: (args: InitArgs) => PluginResult) {
     return makePlugin(PluginType.Init, execute);
 }
+
 /**
+ * Creates an initialization plugin for command preprocessing and modification
+ * 
  * @since 2.5.0
+ * @template I - Extends CommandType to enforce type safety for command modules
+ * 
+ * @param {function} execute - Function to execute during command initialization
+ * @param {InitArgs<T>} execute.args - The initialization arguments
+ * @param {T} execute.args.module - The command module being initialized
+ * @param {string} execute.args.absPath - The absolute path to the module file
+ * @param {Dependencies} execute.args.deps - Dependency injection container
+ * 
+ * @returns {Plugin} A plugin that runs during command initialization
+ * 
+ * @example
+ * // Plugin to update command description
+ * export const updateDescription = (description: string) => {
+ *   return CommandInitPlugin(({ deps }) => {
+ *     if(description.length > 100) {
+ *       deps.logger?.info({ message: "Invalid description" })
+ *       return controller.stop("From updateDescription: description is invalid");
+ *     }
+ *     module.description = description;
+ *     return controller.next();
+ *   });
+ * };
+ * 
+ * @example
+ * // Plugin to store registration date in module locals
+ * export const dateRegistered = () => {
+ *   return CommandInitPlugin(({ module }) => {
+ *     module.locals.registered = Date.now()
+ *     return controller.next();
+ *   });
+ * };
+ * 
+ * @remarks
+ * - Init plugins can modify how commands are loaded and perform preprocessing
+ * - The module.locals object can be used to store custom plugin-specific data
+ * - Be careful when modifying module fields as multiple plugins may interact with them
+ * - Use controller.next() to continue to the next plugin
+ * - Use controller.stop(reason) to halt plugin execution
  */
 export function CommandInitPlugin<I extends CommandType>(
     execute: (args: InitArgs) => PluginResult
-) {
+): Plugin {
     return makePlugin(PluginType.Init, execute);
 }
+
 /**
+ * Creates a control plugin for command preprocessing, filtering, and state management
+ * 
  * @since 2.5.0
+ * @template I - Extends CommandType to enforce type safety for command modules
+ * 
+ * @param {function} execute - Function to execute during command control flow
+ * @param {CommandArgs<I>} execute.args - The command arguments array
+ * @param {Context} execute.args[0] - The discord context (e.g., guild, channel, user info, interaction)
+ * @param {SDT} execute.args[1] - The State, Dependencies, Params, Module, and Type object
+ * 
+ * @returns {Plugin} A plugin that runs during command execution flow
+ * 
+ * @example
+ * // Plugin to restrict command to specific guild
+ * export const inGuild = (guildId: string) => {
+ *   return CommandControlPlugin((ctx, sdt) => {
+ *     if(ctx.guild.id !== guildId) {
+ *       return controller.stop();
+ *     }
+ *     return controller.next();
+ *   });
+ * };
+ * 
+ * @example
+ * // Plugins passing state through the chain
+ * const plugin1 = CommandControlPlugin((ctx, sdt) => {
+ *   return controller.next({ 'plugin1/data': 'from plugin1' });
+ * });
+ * 
+ * const plugin2 = CommandControlPlugin((ctx, sdt) => {
+ *   return controller.next({ 'plugin2/data': ctx.user.id });
+ * });
+ * 
+ * export default commandModule({
+ *   type: CommandType.Slash,
+ *   plugins: [plugin1, plugin2],
+ *   execute: (ctx, sdt) => {
+ *     console.log(sdt.state); // Access accumulated state
+ *   }
+ * });
+ * 
+ * @remarks
+ * - Control plugins are executed in order when a discord.js event is emitted
+ * - Use controller.next() to continue to next plugin or controller.stop() to halt execution
+ * - State can be passed between plugins using controller.next({ key: value })
+ * - State keys should be namespaced to avoid collisions (e.g., 'plugin-name/key')
+ * - Final accumulated state is passed to the command's execute function
+ * - All plugins must succeed for the command to execute
+ * - Plugins have access to dependencies through the sdt.deps object
+ * - Useful for implementing preconditions, filters, and command preprocessing
  */
 export function CommandControlPlugin<I extends CommandType>(
     execute: (...args: CommandArgs<I>) => PluginResult,
@@ -37,7 +129,7 @@ export function CommandControlPlugin<I extends CommandType>(
  * The object passed into every plugin to control a command's behavior
  */
 export const controller = {
-    next: (val?: Record<string,unknown>) => Ok(val),
+    next: (val?: Dictionary) => Ok(val),
     stop: (val?: string) => Err(val),
 };
 

src/handlers/event-utils.ts

@@ -1,219 +1,18 @@
-import type { Interaction, Message, BaseInteraction } from 'discord.js';
+import type { Emitter, Logging } from '../core/interfaces';
-import util from 'node:util';
-import {
-    EMPTY, type Observable, concatMap, filter,
-    throwError, fromEvent, map, type OperatorFunction,
-    catchError, finalize, pipe, from, take, share, of,
-} from 'rxjs';
-import * as Id from '../core/id'
-import type { Emitter, ErrorHandling, Logging } from '../core/interfaces';
 import { SernError } from '../core/structures/enums'
-import { EMPTY_ERR, Err, Ok, Result,  wrapAsync } from '../core/structures/result';
+import { Ok, wrapAsync} from '../core/structures/result';
-import type { UnpackedDependencies } from '../types/utility';
+import type {  Module } from '../types/core-modules';
-import type { CommandModule, Module, Processed } from '../types/core-modules';
-import * as assert from 'node:assert';
-import { Context } from '../core/structures/context';
-import { CommandType } from '../core/structures/enums'
 import { inspect } from 'node:util'
-import { disposeAll } from '../core/ioc';
+import { resultPayload } from '../core/functions'
-import { resultPayload, isAutocomplete, treeSearch, fmt } from '../core/functions'
-
 import merge from 'deepmerge'
 
-function handleError<C>(crashHandler: ErrorHandling, emitter: Emitter, logging?: Logging) {
-    return (pload: unknown, caught: Observable<C>) => {
-        // This is done to fit the ErrorHandling contract
-        if(!emitter.emit('error', pload)) {
-            const err = pload instanceof Error ? pload : Error(util.inspect(pload, { colors: true }));
-            logging?.error({ message: util.inspect(pload) });
-            crashHandler.updateAlive(err);
-        }
-        return caught;
-    };
-}
-const arrayify= <T>(src: T) => 
-    Array.isArray(src) ? src : [src];
 
 interface ExecutePayload {
     module: Module;
     args: unknown[];
-    deps: Dependencies;
-    params?: string;
     [key: string]: unknown
 }
 
-export const filterTap = <K, R>(onErr: (e: R) => void): OperatorFunction<Result<K, R>, K> => 
-    concatMap(result => {
-        if(result.ok){
-            return of(result.value)
-        }
-        onErr(result.error);
-        return EMPTY;
-    })
-
-export const sharedEventStream = <T>(e: Emitter, eventName: string) => 
-    (fromEvent(e, eventName) as Observable<T>).pipe(share());
-
-function intoPayload(module: Module, deps: Dependencies) {
-    return pipe(map(arrayify),
-                map(args => ({ module, args, deps })),
-                map(p => p.args));
-}
-/**
- * Creates an observable from { source }
- * @param module
- * @param source
- */
-export function eventDispatcher(deps: Dependencies, module: Module, source: unknown) {
-    assert.ok(source && typeof source === 'object',
-              `${source} cannot be constructed into an event listener`);
-    const execute: OperatorFunction<unknown[]|undefined, unknown> =
-        concatMap(async args => {
-            if(args) return Reflect.apply(module.execute, null, args);
-        });
-
-    //@ts-ignore
-    let ev = fromEvent(source ,module.name!);
-    //@ts-ignore
-    if(module['once']) {
-        ev = ev.pipe(take(1))
-    }
-    return ev.pipe(intoPayload(module, deps),
-                   execute);
-}
-
-interface DispatchPayload { 
-    module: Processed<CommandModule>;
-    event: BaseInteraction; 
-    defaultPrefix?: string;
-    deps: Dependencies;
-    params?: string
-};
-export function createDispatcher({ module, event, defaultPrefix, deps, params }: DispatchPayload): ExecutePayload {
-    assert.ok(CommandType.Text !== module.type,
-        SernError.MismatchEvent + 'Found text command in interaction stream');
-
-    if(isAutocomplete(event)) {
-        assert.ok(module.type === CommandType.Slash 
-               || module.type === CommandType.Both, "Autocomplete option on non command interaction");
-        const option = treeSearch(event, module.options);
-        assert.ok(option, SernError.NotSupportedInteraction + ` There is no autocomplete tag for ` + inspect(module));
-        const { command } = option;
-        return { module: command as Processed<Module>, //autocomplete is not a true "module" warning cast!
-                 args: [event],
-                 deps };
-    }
-    switch (module.type) {
-        case CommandType.Slash:
-        case CommandType.Both: {
-            return { module, args: [Context.wrap(event, defaultPrefix)], deps };
-        }
-        default: return { module, args: [event], deps, params };
-    }
-}
-function createGenericHandler<Source, Narrowed extends Source, Output>(
-    source: Observable<Source>,
-    makeModule: (event: Narrowed) => Promise<Output>,
-) {
-    return (pred: (i: Source) => i is Narrowed) => 
-        source.pipe(
-            filter(pred), // only handle this stream if it passes pred
-            concatMap(makeModule)); // create a payload, preparing to execute
-}
-
-
-/**
- *
- * Creates an RxJS observable that filters and maps incoming interactions to their respective modules.
- * @param i An RxJS observable of interactions.
- * @param mg The module manager instance used to retrieve the module path for each interaction.
- * @returns A handler to create a RxJS observable of dispatchers that take incoming interactions and execute their corresponding modules.
- */
-export function createInteractionHandler<T extends Interaction>(
-    source: Observable<Interaction>,
-    deps: Dependencies,
-    defaultPrefix?: string
-) {
-    const mg = deps['@sern/modules'];
-    return createGenericHandler<Interaction, T, Result<ReturnType<typeof createDispatcher>, void>>(
-        source,
-        async event => {
-            const possibleIds = Id.reconstruct(event);
-            let modules = possibleIds
-                .map(({ id, params }) => ({ module: mg.get(id), params }))
-                .filter(({ module }) => module !== undefined);
-            if(modules.length == 0) {
-                return EMPTY_ERR;
-            }
-            const [{module, params}] = modules;
-            return Ok(createDispatcher({ 
-                module: module as Processed<CommandModule>, 
-                event, defaultPrefix, deps, params 
-            }));
-    });
-}
-
-export function createMessageHandler(
-    source: Observable<Message>,
-    defaultPrefix: string,
-    deps: Dependencies,
-) {
-    const mg = deps['@sern/modules'];
-    return createGenericHandler(source, async event => {
-        const [prefix] = fmt(event.content, defaultPrefix);
-        let module= mg.get(`${prefix}_T`) ?? mg.get(`${prefix}_B`) as Module;
-        if(!module) {
-            return Err('Possibly undefined behavior: could not find a static id to resolve');
-        }
-        return Ok({ args: [Context.wrap(event, defaultPrefix)], module, deps })
-    });
-}
-
-
-/**
- * Wraps the task in a Result as a try / catch.
- * if the task is ok, an event is emitted and the stream becomes empty
- * if the task is an error, throw an error down the stream which will be handled by catchError
- * thank u kingomes
- * @param emitter reference to SernEmitter that will emit a successful execution of module
- * @param module the module that will be executed with task
- * @param task the deferred execution which will be called
- */
-export function executeModule(emitter: Emitter, { module, args }: ExecutePayload) {
-    return from(wrapAsync(async () => module.execute(...args)))
-        .pipe(concatMap(result => { 
-            if (result.ok){
-                emitter.emit('module.activate', resultPayload('success', module));
-                return EMPTY;
-            }
-            return throwError(() => resultPayload('failure', module, result.error));
-        }))
-};
-
-/**
- * A higher order function that
- * - calls all control plugins.
- * - any failures results to { config.onStop } being called
- * - if all results are ok, the stream is converted to { config.onNext }
- * config.onNext will be returned if everything is okay.
- * @param config
- * @returns function which calls all plugins and returns onNext or fail 
- */
-export function createResultResolver<Output>(config: {
-    onStop?: (module: Module, err?: string) => unknown;
-    onNext: (args: ExecutePayload, map: Record<string, unknown>) => Output;
-}) {
-    const { onStop, onNext } = config;
-    return async (payload: ExecutePayload) => {
-        const task = await callPlugins(payload);
-        if (!task) throw Error("Plugin did not return anything.");
-        if(!task.ok) {
-            onStop?.(payload.module, String(task.error));
-        } else {
-            return onNext(payload, task.value) as Output;
-        }
-    };
-};
 
 function isObject(item: unknown) {
     return (item && typeof item === 'object' && !Array.isArray(item));
@@ -238,10 +37,32 @@ export async function callInitPlugins(_module: Module, deps: Dependencies, emit?
     return module
 }
 
-export async function callPlugins({ args, module, deps, params }: ExecutePayload) {
+export function executeModule(emitter: Emitter, logger: Logging|undefined, { module, args } : ExecutePayload) {
+    
+    const moduleCalled = wrapAsync(async () => {
+        return module.execute(...args);
+    })
+    moduleCalled 
+        .then((res) => {
+            if(res.ok) {
+                emitter.emit('module.activate', resultPayload('success', module))    
+            } else {
+                if(!emitter.emit('error', resultPayload('failure', module, res.error))) {
+                    // node crashes here.
+                    logger?.error({ 'message': res.error })
+                }
+            }
+        })
+        .catch(err => { 
+            throw err 
+        })
+};
+
+
+export async function callPlugins({ args, module }: ExecutePayload) {
     let state = {};
     for(const plugin of module.onEvent??[]) {
-        const result = await plugin.execute(...args, { state, deps, params, type: module.type });
+        const result = await plugin.execute(...args);
         if(!result.ok) {
             return result;
         }
@@ -251,22 +72,3 @@ export async function callPlugins({ args, module, deps, params }: ExecutePayload
     }
     return Ok(state);
 }
-/**
- * Creates an executable task ( execute the command ) if all control plugins are successful
- * @param onStop emits a failure response to the SernEmitter
- */
-export function intoTask(onStop: (m: Module) => unknown) {
-    const onNext = ({ args, module, deps, params }: ExecutePayload, state: Record<string, unknown>) => ({
-        module,
-        args: [...args, { state, deps, params, type: module.type }],
-        deps
-    });
-    return createResultResolver({ onStop, onNext });
-}
-
-export const handleCrash = ({ "@sern/errors": err, '@sern/emitter': sem, '@sern/logger': log } : UnpackedDependencies, metadata: string) => 
-    pipe(catchError(handleError(err, sem, log)),
-         finalize(() => {
-            log?.info({ message: 'A stream closed: ' + metadata  });
-            disposeAll(log);
-         }))

src/handlers/interaction.ts

@@ -1,30 +1,74 @@
-import type { Interaction } from 'discord.js';
+import type { Module, SernAutocompleteData } from '../types/core-modules'
-import { mergeMap, merge, concatMap, EMPTY } from 'rxjs';
+import {  callPlugins, executeModule } from './event-utils';
-import { createInteractionHandler, executeModule, intoTask, sharedEventStream, filterTap, handleCrash } from './event-utils';
 import { SernError } from '../core/structures/enums'
-import { isAutocomplete, isCommand, isMessageComponent, isModal, resultPayload } from '../core/functions'
+import { createSDT, isAutocomplete, isCommand, isContextCommand, isMessageComponent, isModal, resultPayload } from '../core/functions'
-import { UnpackedDependencies } from '../types/utility';
+import type { UnpackedDependencies } from '../types/utility';
+import * as Id from '../core/id'
+import { Context } from '../core/structures/context';
+import path from 'node:path';
 
-export default function interactionHandler(deps: UnpackedDependencies, defaultPrefix?: string) {
+
+
+export function interactionHandler(deps: UnpackedDependencies, defaultPrefix?: string) {
     //i wish javascript had clojure destructuring 
     const { '@sern/client': client,
-            '@sern/emitter': emitter } = deps
+            '@sern/modules': moduleManager,
-    const interactionStream$ = sharedEventStream<Interaction>(client, 'interactionCreate');
+            '@sern/logger': log,
-    const handle = createInteractionHandler(interactionStream$, deps, defaultPrefix);
+            '@sern/emitter': reporter } = deps
 
-    const interactionHandler$ = merge(handle(isMessageComponent),
+    client.on('interactionCreate', async (event) => {
-                                      handle(isAutocomplete),
+
-                                      handle(isCommand),
+        //returns array of possible ids
-                                      handle(isModal));
+        const possibleIds = Id.reconstruct(event);
-    return interactionHandler$
+
-        .pipe(filterTap(e => emitter.emit('warning', resultPayload('warning', undefined, e))),
+        let modules = possibleIds
-              concatMap(intoTask(module => {
+            .map(({ id, params }) => ({ module: moduleManager.get(id)!, params }))
-                emitter.emit('module.activate', resultPayload('failure', module, SernError.PluginFailure))
+            .filter(({ module }) => module !== undefined);
-              })),
+
-              mergeMap(payload => {
+        if(modules.length == 0) {
-                  if(payload)
+            return;
-                    return executeModule(emitter, payload)
+        }
-                  return EMPTY;
+        const { module, params } = modules.at(0)!;
-              }),
+        let payload;
-              handleCrash(deps, "interaction handling"));
+        // handles autocomplete
+        if(isAutocomplete(event)) {
+            const lookupTable = module.locals['@sern/lookup-table'] as Map<string, SernAutocompleteData>
+            const subCommandGroup = event.options.getSubcommandGroup(false) ?? "",
+                  subCommand = event.options.getSubcommand(false) ?? "",
+                  option = event.options.getFocused(true),
+                  fullPath = path.posix.join("<parent>", subCommandGroup, subCommand, option.name)
+                  
+            const resolvedModule = (lookupTable.get(fullPath)!.command) as Module
+            payload= { module: resolvedModule , //autocomplete is not a true "module" warning cast!
+                       args: [event, createSDT(module, deps, params)] };
+            // either CommandTypes Slash |  ContextMessage | ContextUesr
+        } else if(isCommand(event)) {
+            const sdt = createSDT(module, deps, params)
+            // handle CommandType.CtxUser || CommandType.CtxMsg
+            if(isContextCommand(event)) {
+                payload= { module, args: [event, sdt] };
+            } else {
+                // handle CommandType.Slash || CommandType.Both
+                payload= { module, args: [Context.wrap(event, defaultPrefix), sdt] };
+            }
+            // handles modals or components
+        } else if (isModal(event) || isMessageComponent(event)) {
+            payload= { module, args: [event, createSDT(module, deps, params)] }
+        } else {
+            throw Error("Unknown interaction while handling in interactionCreate event " + event)
+        }
+        const result = await callPlugins(payload)
+        if(!result.ok) {
+            reporter.emit('module.activate', resultPayload('failure', module, result.error ?? SernError.PluginFailure))
+            return
+        }
+        if(payload.args.length !== 2) {
+            throw Error ('Invalid payload')
+        }
+        //@ts-ignore assigning final state from plugin
+        payload.args[1].state = result.value
+
+        // note: do not await this. will be blocking if long task (ie waiting for modal input)
+        executeModule(reporter, log, payload);
+    });
 }

src/handlers/message.ts

@@ -1,17 +1,17 @@
-import { EMPTY, mergeMap, concatMap } from 'rxjs';
 import type { Message } from 'discord.js';
-import { createMessageHandler, executeModule, intoTask, sharedEventStream, filterTap, handleCrash} from './event-utils';
+import { callPlugins, executeModule } from './event-utils';
 import { SernError } from '../core/structures/enums'
-import { resultPayload } from '../core/functions'
+import { createSDT, fmt, resultPayload } from '../core/functions'
-import { UnpackedDependencies } from '../types/utility';
+import type { UnpackedDependencies } from '../types/utility';
-import type { Emitter } from '../core/interfaces';
+import type { Module } from '../types/core-modules';
+import { Context } from '../core/structures/context';
 
 /**
  * Ignores messages from any person / bot except itself
  * @param prefix
  */
-function isNonBot(prefix: string) {
+function isBotOrNoPrefix(msg: Message, prefix: string) {
-    return (msg: Message): msg is Message => !msg.author.bot && hasPrefix(prefix, msg.content);
+    return msg.author.bot || !hasPrefix(prefix, msg.content);
 }
 
 function hasPrefix(prefix: string, content: string) {
@@ -19,32 +19,36 @@ function hasPrefix(prefix: string, content: string) {
     return prefixInContent.localeCompare(prefix, undefined, { sensitivity: 'accent' }) === 0;
 }
 
-export default 
+export function messageHandler (deps: UnpackedDependencies, defaultPrefix?: string) {
-function (deps: UnpackedDependencies, defaultPrefix?: string) {
     const {"@sern/emitter": emitter,  
            '@sern/logger': log, 
+           '@sern/modules': mg,
            '@sern/client': client} = deps
 
     if (!defaultPrefix) {
         log?.debug({ message: 'No prefix found. message handler shutting down' });
-        return EMPTY;
+        return;
     }
-    const messageStream$ = sharedEventStream<Message>(client as unknown as Emitter, 'messageCreate');
+    client.on('messageCreate', async message => {
-    const handle = createMessageHandler(messageStream$, defaultPrefix, deps);
+        if(isBotOrNoPrefix(message, defaultPrefix)) {
+           return 
+        }
+        const [prefix] = fmt(message.content, defaultPrefix);
+        let module = mg.get(`${prefix}_T`) ?? mg.get(`${prefix}_B`) as Module;
+        if(!module) {
+            log?.warning({ message: 'Possibly undefined behavior: could not find a static id to resolve' });
+        }
+        const payload = { module, args: [Context.wrap(message, defaultPrefix), createSDT(module, deps, undefined)] }
+        const result = await callPlugins(payload)
+        if (!result.ok) {
+            emitter.emit('module.activate', resultPayload('failure', module, result.error ?? SernError.PluginFailure))
+            return
+        }
 
-    const msgCommands$ = handle(isNonBot(defaultPrefix));
+        //@ts-ignore
+        payload.args[1].state = result.value
 
-    return msgCommands$.pipe(
+        executeModule(emitter, log, payload)
-        filterTap(e => emitter.emit('warning', resultPayload('warning', undefined, e))),
+    })
-        concatMap(intoTask(module => {
+    
-            const result = resultPayload('failure', module, SernError.PluginFailure);
-            emitter.emit('module.activate', result);
-        })),
-        mergeMap(payload => {
-            if(payload)
-                return executeModule(emitter, payload)
-            return EMPTY;
-        }),
-        handleCrash(deps, "message handling")
-    )
 }

src/handlers/presence.ts

@@ -1,40 +1,99 @@
-import { concatMap, from, interval, of, map, scan, startWith, fromEvent, take, mergeScan } from "rxjs"
 import { Presence  } from "../core/presences";
 import { Services } from "../core/ioc";
-import assert from "node:assert";
 import * as Files from "../core/module-loading";
 type SetPresence = (conf: Presence.Result) => Promise<unknown>
 
-const parseConfig = async (conf: Promise<Presence.Result>) => {
+const parseConfig = async (conf: Promise<Presence.Result>, setPresence: SetPresence) => {
-    return conf.then(s => {
+    const result = await conf;
-        if('repeat' in s) {
+    
-            const { onRepeat, repeat } = s;
+    if ('repeat' in result) {
-            assert(repeat !== undefined, "repeat option is undefined");
+        const { onRepeat, repeat } = result;
-            assert(onRepeat !== undefined, "onRepeat callback is undefined, but repeat exists");
+        // Validate configuration
-            const src$ = typeof repeat === 'number' 
+        if (repeat === undefined) {
-                ? interval(repeat)
+            throw new Error("repeat option is undefined");
-                : fromEvent(...repeat);
-                return src$.pipe(mergeScan(async (args) => onRepeat(args), s), 
-                                 startWith(s));
         }
-        return of(s).pipe(take(1));
+        if (onRepeat === undefined) {
-    })
+            throw new Error("onRepeat callback is undefined, but repeat exists");
+        }
+        // Initial state
+        let currentState = result;
+        const processState = async (state: typeof currentState) => {
+            try {
+                const result = onRepeat(state);
+                // If it's a promise, await it, otherwise use the value directly
+                return result instanceof Promise ? await result : result;
+            } catch (error) {
+                // TODO process error
+                //console.error(error);
+                return state; // Return previous state on error
+            }
+        };
+        // Handle numeric interval
+        if (typeof repeat === 'number') {
+            // Return a promise that never resolves (or resolves on cleanup)
+            return new Promise((resolve) => {
+                // Immediately return initial state
+                processState(currentState);
+                
+                // Set up interval
+                let isProcessing = false;
+                const intervalId = setInterval(() => {
+                    // Skip if previous operation is still running
+                    if (isProcessing) return;
+                    isProcessing = true;
+
+                    processState(currentState)
+                        .then(newState => { 
+                            currentState = newState; 
+                            return setPresence(currentState)
+                        })
+                        .catch(console.error)
+                        .finally(() => {
+                            isProcessing = false;
+                        });
+                }, repeat);
+
+                // Optional: Return cleanup function
+                return () => clearInterval(intervalId);
+            });
+        }
+        // Handle event-based repeat
+        else {
+            const handler = async () => {
+                currentState = await onRepeat(currentState);
+                await setPresence(currentState);
+            }; 
+            let has_registered = false;
+            return new Promise((resolve) => {
+                const [target, eventName] = repeat;
+                
+                // Immediately return initial state
+                processState(currentState);
+
+                // Set up event listener
+                if(!has_registered) {
+                    target.addListener(eventName, handler);
+                    has_registered=true;
+                }
+                // Optional: Return cleanup function
+                return () => target.removeListener(eventName, handler);
+            });
+        }
+    }
+    
+    // No repeat configuration, just return the result
+    return setPresence(result);
 };
 
-export const presenceHandler = (path: string, setPresence: SetPresence) => {
+export const presenceHandler = async (path: string, setPresence: SetPresence) => {
-    const presence = Files
+    const presence = await 
-        .importModule<Presence.Config<(keyof Dependencies)[]>>(path)
+        Files.importModule<Presence.Config<(keyof Dependencies)[]>>(path)
-        .then(({ module }) => {
+             .then(({ module }) => {
-            //fetch services with the order preserved, passing it to the execute fn 
+                //fetch services with the order preserved, passing it to the execute fn 
-            const fetchedServices = Services(...module.inject ?? []);
+                const fetchedServices = Services(...module.inject ?? []);
-            return async () => module.execute(...fetchedServices);
+                return async () => module.execute(...fetchedServices);
-        })
+             })
-    const module$ = from(presence);
+     
-    return module$.pipe(
+    return parseConfig(presence(), setPresence);
-        //compose:
+       
-        //call the execute function, passing that result into parseConfig.
-        //concatMap resolves the promise, and passes it to the next concatMap.
-        concatMap(fn => parseConfig(fn())),
-        // subscribe to the observable parseConfig yields, and set the presence.
-        concatMap(conf => conf.pipe(map(setPresence))));
 }

src/handlers/ready.ts

@@ -1,32 +1,58 @@
-import * as Files from '../core/module-loading'
+import * as Files from "../core/module-loading";
-import { once } from 'node:events';
+import { once } from "node:events";
-import { resultPayload } from '../core/functions';
+import { createLookupTable, resultPayload } from "../core/functions";
-import { CommandType } from '../core/structures/enums';
+import { CommandType } from "../core/structures/enums";
-import { Module } from '../types/core-modules';
+import { Module, SernOptionsData } from "../types/core-modules";
-import { UnpackedDependencies } from '../types/utility';
+import type { UnpackedDependencies, Wrapper } from "../types/utility";
-import { callInitPlugins } from './event-utils';
+import { callInitPlugins } from "./event-utils";
+import { SernAutocompleteData } from "..";
+import { Events } from "discord.js";
 
-export default async function(dir: string, deps : UnpackedDependencies) {
+export default async function (
-    const { '@sern/client': client,
+  dirs: string | string[],
-            '@sern/logger': log,
+  deps: UnpackedDependencies,
-            '@sern/emitter': sEmitter,
+) {
-            '@sern/modules': commands } = deps;
+  const {
-    log?.info({ message: "Waiting on discord client to be ready..." })
+    "@sern/client": client,
-    await once(client, "ready");
+    "@sern/logger": log,
-    log?.info({ message: "Client signaled ready, registering modules" });
+    "@sern/emitter": sEmitter,
+    "@sern/modules": commands,
+  } = deps;
+  log?.info({ message: "Waiting on discord client to be ready..." });
+  await once(client, Events.ClientReady);
+  log?.info({ message: "Client signaled ready, registering modules" });
 
-    // https://observablehq.com/@ehouais/multiple-promises-as-an-async-generator
+  // https://observablehq.com/@ehouais/multiple-promises-as-an-async-generator
-    // possibly optimize to concurrently import modules
+  // possibly optimize to concurrently import modules
+
+  const directories = Array.isArray(dirs) ? dirs : [dirs];
+
+  for (const dir of directories) {
     for await (const path of Files.readRecursive(dir)) {
-        let { module } = await Files.importModule<Module>(path);
+      const { module } = await Files.importModule<Module>(path);
-        const validType = module.type >= CommandType.Text && module.type <= CommandType.ChannelSelect;
+      const validType =
-        if(!validType) {
+        module.type >= CommandType.Text &&
-            throw Error(`Found ${module.name} at ${module.meta.absPath}, which has incorrect \`type\``);
+        module.type <= CommandType.ChannelSelect;
-        }
+      if (!validType) {
-        const resultModule = await callInitPlugins(module, deps, true);
+        throw Error(
-        // FREEZE! no more writing!!
+          `Found ${module.name} at ${module.meta.absPath}, which has incorrect \`type\``,
-        commands.set(resultModule.meta.id, Object.freeze(resultModule));
+        );
-        sEmitter.emit('module.register', resultPayload('success', resultModule));
+      }
+      const resultModule = await callInitPlugins(module, deps, true);
+
+      if (
+        module.type === CommandType.Both ||
+        module.type === CommandType.Slash
+      ) {
+        const options = (Reflect.get(module, "options") ??
+          []) as SernOptionsData[];
+        const lookupTable = createLookupTable(options);
+        module.locals["@sern/lookup-table"] = lookupTable;
+      }
+      // FREEZE! no more writing!!
+      commands.set(resultModule.meta.id, Object.freeze(resultModule));
+      sEmitter.emit("module.register", resultPayload("success", resultModule));
     }
-    sEmitter.emit('modulesLoaded');
+  }
+  sEmitter.emit("modulesLoaded");
 }

src/handlers/tasks.ts

@@ -1,16 +1,21 @@
 import * as Files from '../core/module-loading'
-import { UnpackedDependencies } from "../types/utility";
+import { UnpackedDependencies, Wrapper } from "../types/utility";
 import type { ScheduledTask } from "../types/core-modules";
 import { relative } from "path";
 import { fileURLToPath } from "url";
 
-export const registerTasks = async (tasksPath: string, deps: UnpackedDependencies) => {
+export const registerTasks = async (tasksDirs: string | string[], deps: UnpackedDependencies) => {
     const taskManager = deps['@sern/scheduler']
-    for await (const f of Files.readRecursive(tasksPath)) {
+
-        let { module } = await Files.importModule<ScheduledTask>(f);
+    const directories = Array.isArray(tasksDirs) ? tasksDirs : [tasksDirs];
-        //module.name is assigned by Files.importModule<>
+
-        // the id created for the task is unique
+    for (const dir of directories) {
-        const uuid = module.name+"/"+relative(tasksPath,fileURLToPath(f))
+        for await (const path of Files.readRecursive(dir)) {
-        taskManager.schedule(uuid, module, deps)
+            let { module } = await Files.importModule<ScheduledTask>(path);
+            //module.name is assigned by Files.importModule<>
+            // the id created for the task is unique
+            const uuid = module.name+"/"+relative(dir,fileURLToPath(path))
+            taskManager.schedule(uuid, module, deps)
+        }
     }
 }

src/handlers/user-defined-events.ts

@@ -1,33 +1,62 @@
 import { EventType,  SernError } from '../core/structures/enums';
-import { callInitPlugins, eventDispatcher, handleCrash } from './event-utils'
+import { callInitPlugins } from './event-utils'
-import { EventModule,  Module  } from '../types/core-modules';
+import { EventModule  } from '../types/core-modules';
 import * as Files from '../core/module-loading'
 import type { UnpackedDependencies } from '../types/utility';
-import { from, map, mergeAll } from 'rxjs';
+import type { Emitter } from '../core/interfaces';
+import { inspect } from 'util'
+import { resultPayload } from '../core/functions';
+import type { Wrapper } from '../'
+
+export default async function(deps: UnpackedDependencies, wrapper: Wrapper) {
+    const eventModules: EventModule[] = [];
+    const eventDirs = Array.isArray(wrapper.events!) ? wrapper.events! : [wrapper.events!];
+    
+    for (const dir of eventDirs) {
+        for await (const path of Files.readRecursive(dir)) {
+            let { module } = await Files.importModule<EventModule>(path);
+            await callInitPlugins(module, deps)
+            eventModules.push(module);
+        }
+    }
+
+    const logger = deps['@sern/logger'], report = deps['@sern/emitter'];
+    for (const module of eventModules) {
+        let source: Emitter;
 
-const intoDispatcher = (deps: UnpackedDependencies) => 
-    (module : EventModule) => {
         switch (module.type) {
             case EventType.Sern:
-                return eventDispatcher(deps, module,  deps['@sern/emitter']);
+                source=deps['@sern/emitter'];
+                break
             case EventType.Discord:
-                return eventDispatcher(deps, module,  deps['@sern/client']);
+                source=deps['@sern/client'];
+                break
             case EventType.External:
-                return eventDispatcher(deps, module,  deps[module.emitter]);
+                source=deps[module.emitter] as Emitter;
+                break   
             default: throw Error(SernError.InvalidModuleType + ' while creating event handler');
         }
-};
+        if(!source && typeof source !== 'object') {
-
+            throw Error(`${source} cannot be constructed into an event listener`)
-export default async function(deps: UnpackedDependencies, eventDir: string) {
+        }
-    const eventModules: EventModule[] = [];
+        
-    for await (const path of Files.readRecursive(eventDir)) {
+        if(!('addListener' in source && 'removeListener' in source)) {
-        let { module } = await Files.importModule<Module>(path);
+            throw Error('source must implement Emitter')
-        await callInitPlugins(module, deps)
+        }
-        eventModules.push(module as EventModule);
+        const execute = async (...args: any[]) => {
+            try {
+                if(args) {
+                    if('once' in module) { source.removeListener(String(module.name!), execute); }
+                    await Reflect.apply(module.execute, null, args);
+                }
+            } catch(e) {
+                const err = e instanceof Error ? e : Error(inspect(e, { colors: true }));
+                if(!report.emit('error', resultPayload('failure', module, err))) {
+                    logger?.error({ message: inspect(err) });
+                }
+            }
+       }
+       source.addListener(String(module.name!), execute)
     }
-    from(eventModules)
-        .pipe(map(intoDispatcher(deps)),
-               mergeAll(), // all eventListeners are turned on
-               handleCrash(deps, "event modules"))
-            .subscribe();
 }
+

src/index.ts

@@ -38,7 +38,7 @@ export type {
 } from './types/core-plugin';
 
 
-export type { Payload, SernEventsMapping } from './types/utility';
+export type { Payload, SernEventsMapping, Wrapper } from './types/utility';
 
 export {
     commandModule,
@@ -53,20 +53,3 @@ export * from './core/plugin';
 export { CommandType, PluginType, PayloadType, EventType } from './core/structures/enums';
 export { Context } from './core/structures/context';
 export { type CoreDependencies, makeDependencies, single, transient, Service, Services } from './core/ioc';
-
-
-import type { Container } from '@sern/ioc';
-
-/**
-  * @deprecated This old signature will be incompatible with future versions of sern >= 4.0.0. See {@link makeDependencies}
-  * @example
-  * ```ts
-  *  To switch your old code:
-     await makeDependencies(({ add }) => { 
-            add('@sern/client', new Client())
-     })
-  *  ```
-  */
-export interface DependencyConfiguration {
-    build: (root: Container) => Container;
-}

src/sern.ts

@@ -1,24 +1,21 @@
 //side effect: global container
 import { useContainerRaw } from '@sern/ioc/global';
+// set asynchronous capturing of errors
+import events from 'node:events'
+events.captureRejections = true;
 
 import callsites from 'callsites';
 import * as  Files from './core/module-loading';
-import { merge } from 'rxjs';
 import eventsHandler from './handlers/user-defined-events';
 import ready  from './handlers/ready';
-import messageHandler from './handlers/message';
+import { interactionHandler } from './handlers/interaction';
-import interactionHandler from './handlers/interaction';
+import { messageHandler } from './handlers/message'
 import { presenceHandler } from './handlers/presence';
-import { UnpackedDependencies } from './types/utility';
+import type { Payload, UnpackedDependencies, Wrapper } from './types/utility';
 import type { Presence} from './core/presences';
 import { registerTasks } from './handlers/tasks';
 
-interface Wrapper {
+
-    commands: string;
-    defaultPrefix?: string;
-    events?: string;
-    tasks?: string;
-}
 /**
  * @since 1.0.0
  * @param maybeWrapper Options to pass into sern.
@@ -35,9 +32,8 @@ interface Wrapper {
 export function init(maybeWrapper: Wrapper = { commands: "./dist/commands" }) {
     const startTime = performance.now();
     const deps = useContainerRaw().deps<UnpackedDependencies>();
-    
     if (maybeWrapper.events !== undefined) {
-        eventsHandler(deps, maybeWrapper.events)
+        eventsHandler(deps, maybeWrapper)
             .then(() => {
                 deps['@sern/logger']?.info({ message: "Events registered" });
             });
@@ -45,6 +41,22 @@ export function init(maybeWrapper: Wrapper = { commands: "./dist/commands" }) {
         deps['@sern/logger']?.info({ message: "No events registered" });
     }
 
+    // autohandle errors that occur in modules.
+    // convenient for rapid iteration
+    if(maybeWrapper.handleModuleErrors) {
+        if(!deps['@sern/logger']) {
+            throw Error('A logger is required to handleModuleErrors.\n A default logger is already supplied!');
+        }
+        deps['@sern/logger']?.info({ 'message': 'handleModuleErrors enabled' })
+        deps['@sern/emitter'].addListener('error', (payload: Payload) => {
+            if(payload.type === 'failure') {
+                deps['@sern/logger']?.error({ message: payload.reason })
+            } else {
+                deps['@sern/logger']?.warning({ message: "error event should only have payloads of 'failure'" });
+            }
+        })
+    }
+
     const initCallsite = callsites()[1].getFileName();
     const presencePath = Files.shouldHandle(initCallsite!, "presence");
     //Ready event: load all modules and when finished, time should be taken and logged
@@ -56,16 +68,13 @@ export function init(maybeWrapper: Wrapper = { commands: "./dist/commands" }) {
                 const setPresence = async (p: Presence.Result) => {
                     return deps['@sern/client'].user?.setPresence(p);
                 }
-                presenceHandler(presencePath.path, setPresence).subscribe();
+                presenceHandler(presencePath.path, setPresence);
             }
             if(maybeWrapper.tasks) {
                 registerTasks(maybeWrapper.tasks, deps);
             }
         })
         .catch(err => { throw err });
-
+    interactionHandler(deps, maybeWrapper.defaultPrefix);
-    const messages$ = messageHandler(deps, maybeWrapper.defaultPrefix);
+    messageHandler(deps, maybeWrapper.defaultPrefix)
-    const interactions$ = interactionHandler(deps, maybeWrapper.defaultPrefix);
-    // listening to the message stream and interaction stream
-    merge(messages$, interactions$).subscribe();
 }

src/types/core-modules.ts

@@ -19,18 +19,105 @@ import type {
 import type { CommandType, EventType } from '../core/structures/enums';
 import { Context } from '../core/structures/context'
 import { ControlPlugin, InitPlugin, Plugin } from './core-plugin';
-import { Awaitable, SernEventsMapping, UnpackedDependencies } from './utility';
+import { Awaitable, SernEventsMapping, UnpackedDependencies, Dictionary } from './utility';
 
-//state, deps, type (very original)
+/**
+ * SDT (State, Dependencies, Type) interface represents the core data structure
+ * passed through the plugin pipeline to command modules.
+ * 
+ * @interface SDT
+ * @template TState - Type parameter for the state object's structure
+ * @template TDeps - Type parameter for dependencies interface
+ * 
+ * @property {Record<string, unknown>} state - Accumulated state data passed between plugins
+ * @property {TDeps} deps - Instance of application dependencies
+ * @property {CommandType} type - Command type identifier
+ * @property {string} [params] - Optional parameters passed to the command
+ * 
+ * @example
+ * // Example of a plugin using SDT
+ * const loggingPlugin = CommandControlPlugin((ctx, sdt: SDT) => {
+ *     console.log(`User ${ctx.user.id} executed command`);
+ *     return controller.next({ 'logging/timestamp': Date.now() });
+ * });
+ * 
+ * @example
+ * // Example of state accumulation through multiple plugins
+ * const plugin1 = CommandControlPlugin((ctx, sdt: SDT) => {
+ *     return controller.next({ 'plugin1/data': 'value1' });
+ * });
+ * 
+ * const plugin2 = CommandControlPlugin((ctx, sdt: SDT) => {
+ *     // Access previous state
+ *     const prevData = sdt.state['plugin1/data'];
+ *     return controller.next({ 'plugin2/data': 'value2' });
+ * });
+ * 
+ * @remarks
+ * - State is immutable and accumulated through the plugin chain
+ * - Keys in state should be namespaced to avoid collisions
+ * - Dependencies are injected and available throughout the pipeline
+ * - Type information helps plugins make type-safe decisions
+ * 
+ * @see {@link CommandControlPlugin} for plugin implementation
+ * @see {@link CommandType} for available command types
+ * @see {@link Dependencies} for [dependency injection](https://sern.dev/v4/reference/dependencies/) interface
+ */
 export type SDT = {
-    state: Record<string,unknown>;
+    /**
+     * Accumulated state passed between plugins in the pipeline.
+     * Each plugin can add to or modify this state using controller.next().
+     * 
+     * @type {Record<string, unknown>}
+     * @example
+     * // Good: Namespaced state key
+     * { 'myPlugin/userData': { id: '123', name: 'User' } }
+     * 
+     * // Avoid: Non-namespaced keys that might collide
+     * { userData: { id: '123' } }
+     */
+    state: Record<string, unknown>;
+
+    /**
+     * Application dependencies available to plugins and command modules.
+     * Typically includes services, configurations, and utilities.
+     * 
+     * @type {Dependencies}
+     */
     deps: Dependencies;
-    type: CommandType,
+
-    params?: string
+    /**
+     * Identifies the type of command being processed.
+     * Used by plugins to apply type-specific logic.
+     * 
+     * @type {CommandType}
+     */
+    type: CommandType;
+
+    /**
+     * Optional parameters passed to the command.
+     * May contain additional configuration or runtime data.
+     * 
+     * @type {string}
+     * @optional
+     */
+    params?: string;
+
+    /**
+     * A copy of the current module that the plugin is running in.
+     */
+    module: { name: string; 
+                  description: string;
+                  meta: Dictionary; 
+                  locals: Dictionary; }
 };
 
 export type Processed<T> = T & { name: string; description: string };
 
+
+/**
+ * @since 1.0.0
+ */
 export interface Module {
     type: CommandType | EventType;
     name?: string;
@@ -41,17 +128,90 @@ export interface Module {
         id: string;
         absPath: string;
     }
-    locals: Record<string,unknown>
+
+    /**
+     * Custom data storage object for module-specific information.
+     * Plugins and module code can use this to store and retrieve metadata,
+     * configuration, or any other module-specific information.
+     * 
+     * @type {Dictionary}
+     * @description A key-value store that allows plugins and module code to persist
+     * data at the module level. This is especially useful for InitPlugins that need
+     * to attach metadata or configuration to modules.
+     * 
+     * @example
+     * // In a plugin
+     * module.locals.registrationDate = Date.now();
+     * module.locals.version = "1.0.0";
+     * module.locals.permissions = ["ADMIN", "MODERATE"];
+     * 
+     * @example
+     * // In module execution
+     * console.log(`Command registered on: ${new Date(module.locals.registrationDate)}`);
+     * 
+     * @example
+     * // Storing localization data
+     * module.locals.translations = {
+     *   en: "Hello",
+     *   es: "Hola",
+     *   fr: "Bonjour"
+     * };
+     * 
+     * @example
+     * // Storing command metadata
+     * module.locals.metadata = {
+     *   category: "admin",
+     *   cooldown: 5000,
+     *   requiresPermissions: true
+     * };
+     * 
+     * @remarks
+     * - The locals object is initialized as an empty object ({}) by default
+     * - Keys should be namespaced to avoid collisions between plugins
+     * - Values can be of any type
+     * - Data persists for the lifetime of the module
+     * - Commonly used by InitPlugins during module initialization
+     * 
+     * @best-practices
+     * 1. Namespace your keys to avoid conflicts:
+     *    ```typescript
+     *    module.locals['myPlugin:data'] = value;
+     *    ```
+     * 
+     * 2. Document the data structure you're storing:
+     *    ```typescript
+     *    interface MyPluginData {
+     *      version: string;
+     *      timestamp: number;
+     *    }
+     *    module.locals['myPlugin:data'] = {
+     *      version: '1.0.0',
+     *      timestamp: Date.now()
+     *    } as MyPluginData;
+     *    ```
+     * 
+     * 3. Use type-safe accessors when possible:
+     *    ```typescript
+     *    const getPluginData = (module: Module): MyPluginData => 
+     *      module.locals['myPlugin:data'];
+     *    ```
+     */
+    locals: Dictionary;
     execute(...args: any[]): Awaitable<any>;
 }
 
+/**
+ * @since 1.0.0
+ */
 export interface SernEventCommand<T extends keyof SernEventsMapping = keyof SernEventsMapping>
     extends Module {
     name?: T;
     type: EventType.Sern;
     execute(...args: SernEventsMapping[T]): Awaitable<unknown>;
 }
-
+/**
+ * @since 1.0.0
+ */
 export interface ExternalEventCommand extends Module {
     name?: string;
     emitter: keyof Dependencies;
@@ -59,83 +219,121 @@ export interface ExternalEventCommand extends Module {
     execute(...args: unknown[]): Awaitable<unknown>;
 }
 
-
+/**
+ * @since 1.0.0
+ */
 export interface ContextMenuUser extends Module {
     type: CommandType.CtxUser;
     execute: (ctx: UserContextMenuCommandInteraction, tbd: SDT) => Awaitable<unknown>;
 }
-
+/**
+ * @since 1.0.0
+ */
 export interface ContextMenuMsg extends Module {
     type: CommandType.CtxMsg;
     execute: (ctx: MessageContextMenuCommandInteraction, tbd: SDT) => Awaitable<unknown>;
 }
-
+/**
+ * @since 1.0.0
+ */
 export interface ButtonCommand extends Module {
     type: CommandType.Button;
     execute: (ctx: ButtonInteraction, tbd: SDT) => Awaitable<unknown>;
 }
-
+/**
+ * @since 1.0.0
+ */
 export interface StringSelectCommand extends Module {
     type: CommandType.StringSelect;
     execute: (ctx: StringSelectMenuInteraction, tbd: SDT) => Awaitable<unknown>;
 }
-
+/**
+ * @since 1.0.0
+ */
 export interface ChannelSelectCommand extends Module {
     type: CommandType.ChannelSelect;
     execute: (ctx: ChannelSelectMenuInteraction, tbd: SDT) => Awaitable<unknown>;
 }
-
+/**
+ * @since 1.0.0
+ */
 export interface RoleSelectCommand extends Module {
     type: CommandType.RoleSelect;
     execute: (ctx: RoleSelectMenuInteraction, tbd: SDT) => Awaitable<unknown>;
 }
-
+/**
+ * @since 1.0.0
+ */
 export interface MentionableSelectCommand extends Module {
     type: CommandType.MentionableSelect;
     execute: (ctx: MentionableSelectMenuInteraction, tbd: SDT) => Awaitable<unknown>;
 }
-
+/**
+ * @since 1.0.0
+ */
 export interface UserSelectCommand extends Module {
     type: CommandType.UserSelect;
     execute: (ctx: UserSelectMenuInteraction, tbd: SDT) => Awaitable<unknown>;
 }
-
+/**
+ * @since 1.0.0
+ */
 export interface ModalSubmitCommand extends Module {
     type: CommandType.Modal;
     execute: (ctx: ModalSubmitInteraction, tbd: SDT) => Awaitable<unknown>;
 }
-
+/**
+ * @since 1.0.0
+ */
 export interface AutocompleteCommand {
     onEvent?: ControlPlugin[];
     execute: (ctx: AutocompleteInteraction, tbd: SDT) => Awaitable<unknown>;
 }
-
+/**
+ * @since 1.0.0
+ */
 export interface DiscordEventCommand<T extends keyof ClientEvents = keyof ClientEvents>
     extends Module {
     name?: T;
     type: EventType.Discord;
     execute(...args: ClientEvents[T]): Awaitable<unknown>;
 }
+/**
+ * @since 1.0.0
+ * @see @link {commandModule} to create a text command
+ */
 export interface TextCommand extends Module {
     type: CommandType.Text;
     execute: (ctx: Context & { get options(): string[] }, tbd: SDT) => Awaitable<unknown>;
 }
-
+/**
+ * @since 1.0.0
+ * @see @link {commandModule} to create a slash command
+ */
 export interface SlashCommand extends Module {
     type: CommandType.Slash;
     description: string;
     options?: SernOptionsData[];
     execute: (ctx: Context  & { get options(): ChatInputCommandInteraction['options']}, tbd: SDT) => Awaitable<unknown>;
 }
-
+/**
+ * @since 1.0.0
+ * @see @link {commandModule} to create a both command
+ */
 export interface BothCommand extends Module {
     type: CommandType.Both;
     description: string;
     options?: SernOptionsData[];
     execute: (ctx: Context, tbd: SDT) => Awaitable<unknown>;
 }
-
+/**
+ * @since 1.0.0
+ */
 export type EventModule = DiscordEventCommand | SernEventCommand | ExternalEventCommand;  
+
+/**
+ * @since 1.0.0
+ */
 export type CommandModule =
     | TextCommand
     | SlashCommand
@@ -204,6 +402,7 @@ export type InputCommand = {
 }[CommandType];
 
 /**
+ * @see @link {https://sern.dev/v4/reference/autocomplete/}
  * Type that replaces autocomplete with {@link SernAutocompleteData}
  */
 export type SernOptionsData =
@@ -223,7 +422,9 @@ export interface SernSubCommandGroupData extends BaseApplicationCommandOptionsDa
     options?: SernSubCommandData[];
 }
 
-
+/**
+ * @since 4.0.0
+ */
 export interface ScheduledTaskContext {
      
     /**
@@ -247,7 +448,9 @@ interface TaskAttrs {
      */
     deps: UnpackedDependencies
 }
-
+/**
+ * @since 4.0.0
+ */
 export interface ScheduledTask {
     name?: string;
     trigger: string | Date;

src/types/utility.ts

@@ -1,10 +1,9 @@
 import type { InteractionReplyOptions, MessageReplyOptions } from 'discord.js';
 import type { Module } from './core-modules';
-import type { Result } from '../core/structures/result';
 
 export type Awaitable<T> = PromiseLike<T> | T;
+export type Dictionary = Record<string, unknown>
 
-export type VoidResult = Result<void, void>;
 export type AnyFunction = (...args: any[]) => unknown;
 
 export interface SernEventsMapping {
@@ -25,3 +24,67 @@ export type UnpackedDependencies = {
     [K in keyof Dependencies]: UnpackFunction<Dependencies[K]>
 }
 export type ReplyOptions = string | Omit<InteractionReplyOptions, 'fetchReply'> | MessageReplyOptions;
+
+
+/**
+ * @interface Wrapper
+ * @description Configuration interface for the sern framework. This interface defines
+ * the structure for configuring essential framework features including command handling,
+ * event management, and task scheduling.
+ */
+export interface Wrapper {
+    /**
+     * @property {string|string[]} commands
+     * @description Specifies the directory path where command modules are located.
+     * This is a required property that tells sern where to find and load command files.
+     * The path should be relative to the project root. If given an array, each directory is loaded in order
+     * they were declared. Order of modules in each directory is not guaranteed
+     *
+     * @example
+     * commands: ["./dist/commands"]
+     */
+    commands: string | string[];
+    /**
+     * @property {boolean} [handleModuleErrors]
+     * @description Optional flag to enable automatic error handling for modules.
+     * When enabled, sern will automatically catch and handle errors that occur
+     * during module execution, preventing crashes and providing error logging.
+     * 
+     * @default false
+     */
+    handleModuleErrors?: boolean;
+    /**
+     * @property {string} [defaultPrefix]
+     * @description Optional prefix for text commands. This prefix will be used
+     * to identify text commands in messages. If not specified, text commands {@link CommandType.Text}
+     * will be disabled.
+     * 
+     * @example
+     * defaultPrefix: "?"
+     */
+    defaultPrefix?: string;
+    /**
+     * @property {string|string[]} [events]
+     * @description Optional directory path where event modules are located.
+     * If provided, Sern will automatically register and handle events from
+     * modules in this directory. The path should be relative to the project root.
+     * If given an array, each directory is loaded in order they were declared. 
+     * Order of modules in each directory is not guaranteed.
+     * 
+     * @example
+     * events: ["./dist/events"]
+     */
+    events?: string | string[];
+    /**
+     * @property {string|string[]} [tasks]
+     * @description Optional directory path where scheduled task modules are located.
+     * If provided, Sern will automatically register and handle scheduled tasks
+     * from modules in this directory. The path should be relative to the project root.
+     * If given an array, each directory is loaded in order they were declared. 
+     * Order of modules in each directory is not guaranteed.
+     * 
+     * @example
+     * tasks: ["./dist/tasks"]
+     */
+    tasks?: string | string[];
+}

test/autocomp.bench.ts

@@ -0,0 +1,84 @@
+import { describe } from 'node:test'
+import { bench } from 'vitest'
+import { SernAutocompleteData, SernOptionsData } from '../src'
+import { createRandomChoice } from './setup/util'
+import { ApplicationCommandOptionType, AutocompleteFocusedOption, AutocompleteInteraction } from 'discord.js'
+import { createLookupTable } from '../src/core/functions'
+import assert from 'node:assert'
+
+/**
+ * Uses an iterative DFS to check if an autocomplete node exists on the option tree
+ * This is the old internal method that sern used to resolve autocomplete
+ * @param iAutocomplete
+ * @param options
+ */
+function treeSearch(
+    choice: AutocompleteFocusedOption,
+    parent: string|undefined,
+    options: SernOptionsData[] | undefined,
+): SernAutocompleteData & { parent?: string } | undefined {
+    if (options === undefined) return undefined;
+    //clone to prevent mutation of original command module
+    const _options = options.map(a => ({ ...a }));
+    const subcommands = new Set();
+    while (_options.length > 0) {
+        const cur = _options.pop()!;
+        switch (cur.type) {
+            case ApplicationCommandOptionType.Subcommand: {
+                    subcommands.add(cur.name);
+                    for (const option of cur.options ?? []) _options.push(option);
+                } break;
+            case ApplicationCommandOptionType.SubcommandGroup: {
+                    for (const command of cur.options ?? []) _options.push(command);
+                } break;
+            default: {
+                if ('autocomplete' in cur && cur.autocomplete) {
+                    assert( 'command' in cur, 'No `command` property found for option ' + cur.name);
+                    if (subcommands.size > 0) {
+                        const parentAndOptionMatches =
+                            subcommands.has(parent) && cur.name === choice.name;
+                        if (parentAndOptionMatches) {
+                            return { ...cur, parent };
+                        }
+                    } else {
+                        if (cur.name === choice.name) {
+                            return { ...cur, parent: undefined };
+                        }
+                    }
+                }
+            } break;
+        }
+    }
+}
+
+const options: SernOptionsData[] = [
+    createRandomChoice(),
+    createRandomChoice(),
+    createRandomChoice(),
+    {
+        type: ApplicationCommandOptionType.String,
+        name: 'autocomplete',
+        description: 'here',
+        autocomplete: true,
+        command: { onEvent: [], execute: () => {} },
+    },
+]
+
+
+const table =  createLookupTable(options)
+
+
+describe('autocomplete lookup', () => {
+
+    bench('lookup table', () => {
+         table.get('<parent>/autocomplete')
+    }, { time: 500 })   
+
+
+    bench('naive treeSearch', () => {
+        treeSearch({ focused: true, 
+                     name: 'autocomplete',
+                     value: 'autocomplete',
+                     type: ApplicationCommandOptionType.String }, undefined, options)
+    }, { time: 500 })
+})

test/core/functions.test.ts

@@ -1,72 +1,17 @@
 //@ts-nocheck
-
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { PluginType, SernOptionsData, controller } from '../../src/index';
-import { partitionPlugins, treeSearch } from '../../src/core/functions';
+import { createLookupTable, partitionPlugins, treeSearch } from '../../src/core/functions';
 import { faker } from '@faker-js/faker';
 import { ApplicationCommandOptionType, AutocompleteInteraction } from 'discord.js';
-
+import { createRandomChoice, createRandomPlugins } from '../setup/util';
-vi.mock('discord.js', async (importOriginal) => {
-    const mod = await importOriginal()
-    const ModalSubmitInteraction = class {
-        customId;
-        type = 5;
-        isModalSubmit = vi.fn();
-        constructor(customId) {
-            this.customId = customId;
-        }
-    };
-    const ButtonInteraction = class {
-        customId;
-        type = 3;
-        componentType = 2;
-        isButton = vi.fn();
-        constructor(customId) {
-            this.customId = customId;
-        }
-    };
-    const AutocompleteInteraction = class {
-        type = 4;
-        option: string;
-        constructor(s: string) {
-            this.option = s;
-        }
-        options = {
-            getFocused: vi.fn(),
-            getSubcommand: vi.fn(),
-        };
-    };
-
-    return {
-        Collection: mod.Collection,
-        ComponentType: mod.ComponentType,
-        InteractionType: mod.InteractionType,
-        ApplicationCommandOptionType: mod.ApplicationCommandOptionType,
-        ApplicationCommandType: mod.ApplicationCommandType, 
-        ModalSubmitInteraction,
-        ButtonInteraction,
-        AutocompleteInteraction,
-    };
-});
 
 describe('functions', () => {
     afterEach(() => {
         vi.clearAllMocks();
     });
-    function createRandomPlugins(len: number) {
+    
-        const random = () => Math.floor(Math.random() * 2) + 1; // 1 or 2, plugin enum
+    
-        return Array.from({ length: len }, () => ({
-            type: random(),
-            execute: () => (random() === 1 ? controller.next() : controller.stop()),
-        }));
-    }
-    function createRandomChoice() {
-        return {
-            type: faker.number.int({ min: 1, max: 11 }),
-            name: faker.word.noun(),
-            description: faker.word.adjective(),
-        };
-    }
     it('should partition plugins correctly', () => {
         const plugins = createRandomPlugins(100);
         const [onEvent, init] = partitionPlugins(plugins);
@@ -75,308 +20,275 @@ describe('functions', () => {
         for (const el of init) expect(el.type).to.equal(PluginType.Init);
     });
 
-    it('should tree search options tree depth 1', () => {
+    describe('autocomplete', ( ) => {
-        //@ts-expect-error mocking
+        
-        let autocmpInteraction = new AutocompleteInteraction('autocomplete');
+        it('should tree search options tree depth 1', () => {
-        const options: SernOptionsData[] = [
+            const options: SernOptionsData[] = [
-            createRandomChoice(),
+                createRandomChoice(),
-            createRandomChoice(),
+                {
-            createRandomChoice(),
+                    type: ApplicationCommandOptionType.String,
-            {
+                    name: 'autocomplete',
-                type: ApplicationCommandOptionType.String,
+                    description: 'here',
-                name: 'autocomplete',
+                    autocomplete: true,
-                description: 'here',
+                    command: { onEvent: [], execute: vi.fn() },
-                autocomplete: true,
+                },
-                command: { onEvent: [], execute: vi.fn() },
+            ];
-            },
+            const table = createLookupTable(options)
-        ];
+            const result = table.get('<parent>/autocomplete')
-        autocmpInteraction.options.getFocused.mockReturnValue({
+            expect(result == undefined).to.be.false;
-            name: 'autocomplete',
+            expect(result.name).to.be.eq('autocomplete');
-            value: faker.string.alpha(),
+            expect(result.command).to.be.not.undefined;
-            focused: true,
+        }),
-        });
+            it('should tree search depth 2', () => {
-        const result = treeSearch(autocmpInteraction, options);
+                const subcommandName = faker.string.alpha();
-        expect(result == undefined).to.be.false;
+                const options: SernOptionsData[] = [
-        expect(result.name).to.be.eq('autocomplete');
+                    {
-        expect(result.command).to.be.not.undefined;
+                        type: ApplicationCommandOptionType.Subcommand,
-    }),
+                        name: subcommandName,
-        it('should tree search depth 2', () => {
+                        description: faker.string.alpha(),
-            //@ts-expect-error mocking
+                        options: [
-            let autocmpInteraction = new AutocompleteInteraction('nested');
+                            createRandomChoice(),
+                            createRandomChoice(),
+                            createRandomChoice(),
+                            {
+                                type: ApplicationCommandOptionType.String,
+                                name: 'nested',
+                                description: faker.string.alpha(),
+                                autocomplete: true,
+                                command: {
+                                    onEvent: [],
+                                    execute: () => {},
+                                },
+                            },
+                        ],
+                    },
+                ];
+                const table = createLookupTable(options)
+                const result = table.get(`<parent>/${subcommandName}/nested`)
+                expect(result == undefined).to.be.false;
+                expect(result.name).to.be.eq('nested');
+                expect(result.command).to.be.not.undefined;
+            });
+
+        it('should tree search depth n > 2', () => {
+            const subgroupName = faker.string.alpha()
             const subcommandName = faker.string.alpha();
             const options: SernOptionsData[] = [
                 {
-                    type: ApplicationCommandOptionType.Subcommand,
+                    type: ApplicationCommandOptionType.SubcommandGroup,
-                    name: subcommandName,
+                    name: subgroupName,
                     description: faker.string.alpha(),
                     options: [
-                        createRandomChoice(),
-                        createRandomChoice(),
-                        createRandomChoice(),
                         {
-                            type: ApplicationCommandOptionType.String,
+                            type: ApplicationCommandOptionType.Subcommand,
-                            name: 'nested',
+                            name: subcommandName,
                             description: faker.string.alpha(),
-                            autocomplete: true,
+                            options: [
-                            command: {
+                                createRandomChoice(),
-                                onEvent: [],
+                                createRandomChoice(),
-                                execute: () => {},
+                                {
-                            },
+                                    type: ApplicationCommandOptionType.String,
+                                    name: 'nested',
+                                    description: faker.string.alpha(),
+                                    autocomplete: true,
+                                    command: {
+                                        onEvent: [],
+                                        execute: () => {},
+                                    },
+                                },
+                                createRandomChoice(),
+                            ],
                         },
                     ],
                 },
             ];
-            autocmpInteraction.options.getSubcommand.mockReturnValue(subcommandName);
+            const table = createLookupTable(options)
-            autocmpInteraction.options.getFocused.mockReturnValue({
+            const result = table.get(`<parent>/${subgroupName}/${subcommandName}/nested`)
-                name: 'nested',
-                value: faker.string.alpha(),
-                focused: true,
-            });
-            const result = treeSearch(autocmpInteraction, options);
             expect(result == undefined).to.be.false;
             expect(result.name).to.be.eq('nested');
             expect(result.command).to.be.not.undefined;
         });
 
-    it('should tree search depth n > 2', () => {
+        it('should correctly resolve suboption of the same name given two subcommands ', () => {
-        //@ts-expect-error mocking
+            const subcommandName = faker.string.alpha();
-        let autocmpInteraction = new AutocompleteInteraction('nested');
+            const groupname = faker.string.alpha()
-        const subcommandName = faker.string.alpha();
+            const options: SernOptionsData[] = [
-        const options: SernOptionsData[] = [
+                {
-            {
+                    type: ApplicationCommandOptionType.SubcommandGroup,
-                type: ApplicationCommandOptionType.SubcommandGroup,
+                    name: groupname,
-                name: faker.string.alpha(),
+                    description: faker.string.alpha(),
-                description: faker.string.alpha(),
+                    options: [
-                options: [
+                        {
-                    {
+                            type: ApplicationCommandOptionType.Subcommand,
-                        type: ApplicationCommandOptionType.Subcommand,
+                            name: subcommandName,
-                        name: subcommandName,
+                            description: faker.string.alpha(),
-                        description: faker.string.alpha(),
+                            options: [
-                        options: [
+                                createRandomChoice(),
-                            createRandomChoice(),
+                                createRandomChoice(),
-                            createRandomChoice(),
+                                {
-                            {
+                                    type: ApplicationCommandOptionType.String,
-                                type: ApplicationCommandOptionType.String,
+                                    name: 'nested',
-                                name: 'nested',
+                                    description: faker.string.alpha(),
-                                description: faker.string.alpha(),
+                                    autocomplete: true,
-                                autocomplete: true,
+                                    command: {
-                                command: {
+                                        onEvent: [],
-                                    onEvent: [],
+                                        execute: () => {},
-                                    execute: () => {},
+                                    },
                                 },
-                            },
+                            ],
-                            createRandomChoice(),
+                        },
-                        ],
+                        {
-                    },
+                            type: ApplicationCommandOptionType.Subcommand,
-                ],
+                            name: subcommandName + 'a',
-            },
+                            description: faker.string.alpha(),
-        ];
+                            options: [
-        autocmpInteraction.options.getSubcommand.mockReturnValue(subcommandName);
+                                createRandomChoice(),
-        autocmpInteraction.options.getFocused.mockReturnValue({
+                                {
-            name: 'nested',
+                                    type: ApplicationCommandOptionType.String,
-            value: faker.string.alpha(),
+                                    name: 'nested',
-            focused: true,
+                                    description: faker.string.alpha(),
+                                    autocomplete: true,
+                                    command: {
+                                        onEvent: [],
+                                        execute: () => {},
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ];
+            const table = createLookupTable(options)
+            const result = table.get(`<parent>/${groupname}/${subcommandName}/nested`);
+            expect(result).toBeTruthy();
+            expect(result.name).to.be.eq('nested');
+            expect(result.command).to.be.not.undefined;
         });
-        const result = treeSearch(autocmpInteraction, options);
+        it('two subcommands with an option of the same name', () => {
-        expect(result == undefined).to.be.false;
+            const groupName = faker.string.alpha()
-        expect(result.name).to.be.eq('nested');
+            const subcommandName = faker.string.alpha();
-        expect(result.command).to.be.not.undefined;
+            const options: SernOptionsData[] = [
-    });
+                {
-    it('should correctly resolve suboption of the same name given two subcommands ', () => {
+                    type: ApplicationCommandOptionType.SubcommandGroup,
-        let autocmpInteraction = new AutocompleteInteraction('nested');
+                    name: groupName,
-        const subcommandName = faker.string.alpha();
+                    description: faker.string.alpha(),
-        const options: SernOptionsData[] = [
+                    options: [
-            {
+                        {
-                type: ApplicationCommandOptionType.SubcommandGroup,
+                            type: ApplicationCommandOptionType.Subcommand,
-                name: faker.string.alpha(),
+                            name: subcommandName,
-                description: faker.string.alpha(),
+                            description: faker.string.alpha(),
-                options: [
+                            options: [
-                    {
+                                createRandomChoice(),
-                        type: ApplicationCommandOptionType.Subcommand,
+                                createRandomChoice(),
-                        name: subcommandName,
+                                {
-                        description: faker.string.alpha(),
+                                    type: ApplicationCommandOptionType.String,
-                        options: [
+                                    name: 'nested',
-                            createRandomChoice(),
+                                    description: faker.string.alpha(),
-                            createRandomChoice(),
+                                    autocomplete: true,
-                            {
+                                    command: {
-                                type: ApplicationCommandOptionType.String,
+                                        onEvent: [],
-                                name: 'nested',
+                                        execute: () => {},
-                                description: faker.string.alpha(),
+                                    },
-                                autocomplete: true,
-                                command: {
-                                    onEvent: [],
-                                    execute: () => {},
                                 },
-                            },
+                            ],
-                        ],
+                        },
-                    },
+                        {
-                    {
+                            type: ApplicationCommandOptionType.Subcommand,
-                        type: ApplicationCommandOptionType.Subcommand,
+                            name: subcommandName + 'anothera',
-                        name: subcommandName + 'a',
+                            description: faker.string.alpha(),
-                        description: faker.string.alpha(),
+                            options: [
-                        options: [
+                                createRandomChoice(),
-                            createRandomChoice(),
+                                {
-                            {
+                                    type: ApplicationCommandOptionType.String,
-                                type: ApplicationCommandOptionType.String,
+                                    name: 'nested',
-                                name: 'nested',
+                                    description: faker.string.alpha(),
-                                description: faker.string.alpha(),
+                                    autocomplete: true,
-                                autocomplete: true,
+                                    command: {
-                                command: {
+                                        onEvent: [],
-                                    onEvent: [],
+                                        execute: () => {},
-                                    execute: () => {},
+                                    },
                                 },
-                            },
+                            ],
-                        ],
+                        },
-                    },
+                    ],
-                ],
+                },
-            },
+            ];
-        ];
+            
-        autocmpInteraction.options.getSubcommand.mockReturnValue(subcommandName);
+            const table = createLookupTable(options)
-        autocmpInteraction.options.getFocused.mockReturnValue({
+            const result = table.get(`<parent>/${groupName}/${subcommandName}/nested`);
-            name: 'nested',
+            expect(result).toBeTruthy();
-            value: faker.string.alpha(),
+            expect(result.name).to.be.eq('nested');
-            focused: true,
+            expect(result.command).to.be.not.undefined;
-        });
+
-        const result = treeSearch(autocmpInteraction, options);
-        expect(result).toBeTruthy();
-        expect(result.name).to.be.eq('nested');
-        expect(result.command).to.be.not.undefined;
-    });
-    it('two subcommands with an option of the same name', () => {
-        let autocmpInteraction = new AutocompleteInteraction('nested');
-        const subcommandName = faker.string.alpha();
-        const options: SernOptionsData[] = [
-            {
-                type: ApplicationCommandOptionType.SubcommandGroup,
-                name: faker.string.alpha(),
-                description: faker.string.alpha(),
-                options: [
-                    {
-                        type: ApplicationCommandOptionType.Subcommand,
-                        name: subcommandName,
-                        description: faker.string.alpha(),
-                        options: [
-                            createRandomChoice(),
-                            createRandomChoice(),
-                            {
-                                type: ApplicationCommandOptionType.String,
-                                name: 'nested',
-                                description: faker.string.alpha(),
-                                autocomplete: true,
-                                command: {
-                                    onEvent: [],
-                                    execute: () => {},
-                                },
-                            },
-                        ],
-                    },
-                    {
-                        type: ApplicationCommandOptionType.Subcommand,
-                        name: subcommandName + 'a',
-                        description: faker.string.alpha(),
-                        options: [
-                            createRandomChoice(),
-                            {
-                                type: ApplicationCommandOptionType.String,
-                                name: 'nested',
-                                description: faker.string.alpha(),
-                                autocomplete: true,
-                                command: {
-                                    onEvent: [],
-                                    execute: () => {},
-                                },
-                            },
-                        ],
-                    },
-                ],
-            },
-        ];
-        autocmpInteraction.options.getSubcommand.mockReturnValue(subcommandName);
-        autocmpInteraction.options.getFocused.mockReturnValue({
-            name: 'nested',
-            value: faker.string.alpha(),
-            focused: true,
-        });
-        const result = treeSearch(autocmpInteraction, options);
-        expect(result).toBeTruthy();
-        expect(result.name).to.be.eq('nested');
-        expect(result.command).to.be.not.undefined;
 
-        let autocmpInteraction2 = new AutocompleteInteraction('nested');
-        autocmpInteraction2.options.getSubcommand.mockReturnValue(subcommandName + 'a');
-        autocmpInteraction2.options.getFocused.mockReturnValue({
-            name: 'nested',
-            value: faker.string.alpha(),
-            focused: true,
         });
-        const result2 = treeSearch(autocmpInteraction2, options);
-        expect(result2).toBeTruthy();
-        expect(result2?.name).toEqual('nested');
-    });
 
-    it('simulates autocomplete typing and resolution', () => {
+        it('simulates autocomplete typing and resolution', () => {
-        const subcommandName = faker.string.alpha();
+            const subcommandGroupName = faker.string.alpha()
-        const optionName = faker.word.noun();
+            const subcommandName = faker.string.alpha();
-        const options: SernOptionsData[] = [
+            const optionName = faker.word.noun();
-            {
+            const options: SernOptionsData[] = [
-                type: ApplicationCommandOptionType.SubcommandGroup,
+                {
-                name: faker.string.alpha(),
+                    type: ApplicationCommandOptionType.SubcommandGroup,
-                description: faker.string.alpha(),
+                    name: subcommandGroupName,
-                options: [
+                    description: faker.string.alpha(),
-                    {
+                    options: [
-                        type: ApplicationCommandOptionType.Subcommand,
+                        {
-                        name: subcommandName,
+                            type: ApplicationCommandOptionType.Subcommand,
-                        description: faker.string.alpha(),
+                            name: subcommandName,
-                        options: [
+                            description: faker.string.alpha(),
-                            createRandomChoice(),
+                            options: [
-                            createRandomChoice(),
+                                createRandomChoice(),
-                            {
+                                createRandomChoice(),
-                                type: ApplicationCommandOptionType.String,
+                                {
-                                name: optionName,
+                                    type: ApplicationCommandOptionType.String,
-                                description: faker.string.alpha(),
+                                    name: optionName,
-                                autocomplete: true,
+                                    description: faker.string.alpha(),
-                                command: {
+                                    autocomplete: true,
-                                    onEvent: [],
+                                    command: {
-                                    execute: vi.fn(),
+                                        onEvent: [],
+                                        execute: vi.fn(),
+                                    },
                                 },
-                            },
+                            ],
-                        ],
+                        },
-                    },
+                        {
-                    {
+                            type: ApplicationCommandOptionType.Subcommand,
-                        type: ApplicationCommandOptionType.Subcommand,
+                            name: subcommandName + 'a',
-                        name: subcommandName + 'a',
+                            description: faker.string.alpha(),
-                        description: faker.string.alpha(),
+                            options: [
-                        options: [
+                                createRandomChoice(),
-                            createRandomChoice(),
+                                {
-                            {
+                                    type: ApplicationCommandOptionType.String,
-                                type: ApplicationCommandOptionType.String,
+                                    name: optionName,
-                                name: optionName,
+                                    description: faker.string.alpha(),
-                                description: faker.string.alpha(),
+                                    autocomplete: true,
-                                autocomplete: true,
+                                    command: {
-                                command: {
+                                        onEvent: [],
-                                    onEvent: [],
+                                        execute: vi.fn(),
-                                    execute: vi.fn(),
+                                    },
                                 },
-                            },
+                            ],
-                        ],
+                        },
-                    },
+                    ],
-                ],
+                },
-            },
+            ];
-        ];
+            let accumulator = '';
-        let accumulator = '';
+            let result: unknown;
-        let result: unknown;
+            const table = createLookupTable(options)
-        for (const char of optionName) {
+            for (const char of optionName) {
-            accumulator += char;
+                accumulator += char;
+
+                const focusedValue = {
+                    name: accumulator,
+                    value: faker.string.alpha(),
+                    focused: true,
+                };
+                result = table.get(`<parent>/${subcommandGroupName}/${subcommandName}/${focusedValue.name}` );
+            }
+            expect(result).toBeTruthy();
+        });
+    })
+
 
-            const autocomplete = new AutocompleteInteraction(accumulator);
-            autocomplete.options.getSubcommand.mockReturnValue(subcommandName);
-            autocomplete.options.getFocused.mockReturnValue({
-                name: accumulator,
-                value: faker.string.alpha(),
-                focused: true,
-            });
-            result = treeSearch(autocomplete, options);
-        }
-        expect(result).toBeTruthy();
-    });
 });

test/core/id.test.ts

@@ -4,48 +4,7 @@ import { CommandType } from '../../src/core/structures/enums';
 
 import * as Id from '../../src/core/id'
 import { ButtonInteraction, ModalSubmitInteraction } from 'discord.js';
-vi.mock('discord.js', async (importOriginal) => {
-    const mod = await importOriginal()
-    const ModalSubmitInteraction = class {
-        customId;
-        type = 5;
-        isModalSubmit = vi.fn();
-        constructor(customId) {
-            this.customId = customId;
-        }
-    };
-    const ButtonInteraction = class {
-        customId;
-        type = 3;
-        componentType = 2;
-        isButton = vi.fn();
-        constructor(customId) {
-            this.customId = customId;
-        }
-    };
-    const AutocompleteInteraction = class {
-        type = 4;
-        option: string;
-        constructor(s: string) {
-            this.option = s;
-        }
-        options = {
-            getFocused: vi.fn(),
-            getSubcommand: vi.fn(),
-        };
-    };
 
-    return {
-        Collection: mod.Collection,
-        ComponentType: mod.ComponentType,
-        InteractionType: mod.InteractionType,
-        ApplicationCommandOptionType: mod.ApplicationCommandOptionType,
-        ApplicationCommandType: mod.ApplicationCommandType, 
-        ModalSubmitInteraction,
-        ButtonInteraction,
-        AutocompleteInteraction,
-    };
-});
 test('id -> Text', () => {
     expect(Id.create("ping", CommandType.Text)).toBe("ping_T")
 })

test/core/presence.test.ts

@@ -1,6 +1,7 @@
-import { describe, expect, it, vi } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { Presence } from '../../src';
-
+import * as Files from '../../src/core/module-loading'
+import { presenceHandler } from '../../src/handlers/presence'
 
 // Example test suite for the module function
 describe('module function', () => {
@@ -54,4 +55,38 @@ describe('of function', () => {
       activities: [{ name: 'Another Test Activity' }],
     });
   });
+
+
+})
+
+
+describe('Presence module execution', () => {
+    const mockExecuteResult = Presence.of({
+        status: 'online',
+    }).once();
+  
+    const mockModule = Presence.module({ 
+        inject: [ '@sern/client'],
+        execute: vi.fn().mockReturnValue(mockExecuteResult)
+    })
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Mock Files.importModule
+        vi.spyOn(Files, 'importModule').mockResolvedValue({
+          module: mockModule
+        });
+
+
+        
+    }); 
+    it('should set presence once.', async () => {
+        const setPresenceMock = vi.fn();
+        const mockPath = '/path/to/presence/config';
+    
+        await presenceHandler(mockPath, setPresenceMock);
+
+        expect(Files.importModule).toHaveBeenCalledWith(mockPath);
+        expect(setPresenceMock).toHaveBeenCalledOnce();
+    })
+
 })

test/handlers.test.ts

@@ -1,83 +1,14 @@
 //@ts-nocheck
-import { beforeEach, describe, expect, vi, it, test } from 'vitest';
+import { beforeEach, describe, expect, it, test } from 'vitest';
-import { callInitPlugins, eventDispatcher } from '../src/handlers/event-utils';
+import { callInitPlugins } from '../src/handlers/event-utils';
 
-import { Client, ChatInputCommandInteraction } from 'discord.js'
+import { Client } from 'discord.js'
 import { faker } from '@faker-js/faker';
-import { Module } from '../src/types/core-modules';
-import { Processed } from '../src/types/core-modules';
 import { EventEmitter } from 'events';
-import { EventType } from '../src/core/structures/enums';
+import { CommandControlPlugin, CommandType, controller } from '../src';
-import { CommandControlPlugin, CommandInitPlugin, CommandType, controller } from '../src';
+import { createRandomModule, createRandomInitPlugin } from './setup/util';
 
-vi.mock('discord.js', async (importOriginal) => {
-    const mod = await importOriginal()
-    const ModalSubmitInteraction = class {
-        customId;
-        type = 5;
-        isModalSubmit = vi.fn();
-        constructor(customId) {
-            this.customId = customId;
-        }
-    };
-    const ButtonInteraction = class {
-        customId;
-        type = 3;
-        componentType = 2;
-        isButton = vi.fn();
-        constructor(customId) {
-            this.customId = customId;
-        }
-    };
-    const AutocompleteInteraction = class {
-        type = 4;
-        option: string;
-        constructor(s: string) {
-            this.option = s;
-        }
-        options = {
-            getFocused: vi.fn(),
-            getSubcommand: vi.fn(),
-        };
-    };
 
-    return {
-        Client : vi.fn(),
-        Collection: mod.Collection,
-        ComponentType: mod.ComponentType,
-        InteractionType: mod.InteractionType,
-        ApplicationCommandOptionType: mod.ApplicationCommandOptionType,
-        ApplicationCommandType: mod.ApplicationCommandType, 
-        ModalSubmitInteraction,
-        ButtonInteraction,
-        AutocompleteInteraction,
-        ChatInputCommandInteraction: vi.fn()
-    };
-});
-
-function createRandomPlugin (s: 'go', mut?: Partial<Module>) {
-    return CommandInitPlugin(({ module }) => {
-        if(mut) {
-            Object.entries(mut).forEach(([k, v]) => {
-                module[k] = v
-            })
-        }
-        return  s == 'go'
-            ? controller.next()
-            : controller.stop()
-    })
-}
-function createRandomModule(plugins: any[]): Processed<Module> {
-    return {
-        type: EventType.Discord,
-        meta: { id:"", absPath: "" },
-        description: faker.string.alpha(),
-        plugins, 
-        name: "cheese",
-        onEvent: [],
-        execute: vi.fn(),
-    };
-}
 
 function mockDeps() {
    return {
@@ -86,39 +17,29 @@ function mockDeps() {
    }
 }
  
-describe('eventDispatcher standard', () => {
+describe('calling init plugins', async () => {
-    let m: Processed<Module>;
+   let deps;
-    let ee: EventEmitter;
+   beforeEach(() => {
-    beforeEach(() => {
+       deps = mockDeps()
-        ee = new EventEmitter();
+   });
-        m = createRandomModule();
-    });
 
-    it('should throw', () => {
+   test ('call init plugins', async () => {
-        expect(() => eventDispatcher(mockDeps(), m,  'not event emitter')).toThrowError();
+       const plugins = createRandomInitPlugin('go', { name: "abc" })
-    });
+       const mod = createRandomModule([plugins])
+       const s = await callInitPlugins(mod, deps, false)
+       expect("abc").equal(s.name)
+   })
+   test('init plugins replace array', async () => {
+       const plugins = createRandomInitPlugin('go', { opts: [] })
+       const plugins2 = createRandomInitPlugin('go', { opts: ['a'] })
+       const mod = createRandomModule([plugins, plugins2])
+       const s = await callInitPlugins(mod, deps, false)
+       expect(['a']).deep.equal(s.opts)
+   })
 
-    it("Shouldn't throw", () => {
-        expect(() => eventDispatcher(mockDeps(), m, ee)).not.toThrowError();
-    });
-});
-
-test ('call init plugins', async () => {
-    const deps = mockDeps()
-    const plugins = createRandomPlugin('go', { name: "abc" })
-    const mod = createRandomModule([plugins])
-    const s = await callInitPlugins(mod, deps, false)
-    expect("abc").equal(s.name)
 })
 
-test('init plugins replace array', async () => {
+
-    const deps = mockDeps()
-    const plugins = createRandomPlugin('go', { opts: [] })
-    const plugins2 = createRandomPlugin('go', { opts: ['a'] })
-    const mod = createRandomModule([plugins, plugins2])
-    const s = await callInitPlugins(mod, deps, false)
-    expect(['a']).deep.equal(s.opts)
-})
 
 
 test('form sdt', async () => {

test/setup/setup-tests.ts

@@ -0,0 +1,54 @@
+import { vi } from 'vitest'
+import { makeDependencies } from '../../src';
+import { Client } from 'discord.js';
+
+vi.mock('discord.js', async (importOriginal) => {
+    const mod = await importOriginal()
+    const ModalSubmitInteraction = class {
+        customId;
+        type = 5;
+        isModalSubmit = vi.fn();
+        constructor(customId) {
+            this.customId = customId;
+        }
+    };
+    const ButtonInteraction = class {
+        customId;
+        type = 3;
+        componentType = 2;
+        isButton = vi.fn();
+        constructor(customId) {
+            this.customId = customId;
+        }
+    };
+    const AutocompleteInteraction = class {
+        type = 4;
+        option: string;
+        constructor(s: string) {
+            this.option = s;
+        }
+        options = {
+            getFocused: vi.fn(),
+            getSubcommand: vi.fn(),
+        };
+    };
+
+    return {
+        Client : vi.fn(),
+        Collection: mod.Collection,
+        ComponentType: mod.ComponentType,
+        InteractionType: mod.InteractionType,
+        ApplicationCommandOptionType: mod.ApplicationCommandOptionType,
+        ApplicationCommandType: mod.ApplicationCommandType, 
+        ModalSubmitInteraction,
+        ButtonInteraction,
+        AutocompleteInteraction,
+        ChatInputCommandInteraction: vi.fn()
+    };
+});
+
+await makeDependencies(({ add }) => {
+    add('@sern/client', {  })
+})
+
+

test/setup/util.ts

@@ -0,0 +1,48 @@
+import { faker } from "@faker-js/faker"
+import { CommandInitPlugin, CommandType, Module, controller } from "../../src"
+import { Processed } from "../../src/types/core-modules"
+import { vi } from 'vitest'
+
+export function createRandomInitPlugin (s: 'go', mut?: Partial<Module>) {
+    return CommandInitPlugin(({ module }) => {
+        if(mut) {
+            Object.entries(mut).forEach(([k, v]) => {
+                module[k] = v
+            })
+        }
+        return  s == 'go'
+            ? controller.next()
+            : controller.stop()
+    })
+}
+
+export function createRandomModule(plugins: any[]): Processed<Module> {
+    return {
+        type: CommandType.Both,
+        meta: { id:"", absPath: "" },
+        description: faker.string.alpha(),
+        plugins, 
+        name: "cheese",
+        onEvent: [],
+        locals: {},
+        execute: vi.fn(),
+    };
+}
+
+
+export function createRandomChoice() {
+        return {
+            type: faker.number.int({ min: 1, max: 11 }),
+            name: faker.word.noun(),
+            description: faker.word.adjective(),
+        };
+    }
+
+
+export function createRandomPlugins(len: number) {
+        const random = () => Math.floor(Math.random() * 2) + 1; // 1 or 2, plugin enum
+        return Array.from({ length: len }, () => ({
+            type: random(),
+            execute: () => (random() === 1 ? controller.next() : controller.stop()),
+        }));
+    }

vitest.config.ts

@@ -0,0 +1,8 @@
+// vitest.config.ts or vitest.config.js
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    setupFiles: ['./test/setup/setup-tests.ts'],
+  },
+})