chore(main): release 4.2.1 (#383 )

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
fix: context-interactions error (#382 )
2026-06-06 01:16:55 +00:00 · 2025-01-24 16:38:33 -06:00 · 2025-01-24 10:37:51 -06:00 · 2025-01-18 12:00:13 -06:00 · 2025-01-18 11:47:51 -06:00 · 2025-01-13 18:59:14 -06:00
33 changed files with 1544 additions and 1257 deletions
--- a/.github/workflows/continuous-integration.yml
+++ b/.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
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,54 @@
 # Changelog

+## [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)
+
+
+### Bug Fixes
+
+* async presence ([#369](https://github.com/sern-handler/handler/issues/369)) ([eabfb81](https://github.com/sern-handler/handler/commit/eabfb81819b53a4656d8eac6e21cfb488b724a42))
+* fix eventModule typing for Discord events ([#368](https://github.com/sern-handler/handler/issues/368)) ([1789ccb](https://github.com/sern-handler/handler/commit/1789ccb2f22f502f87538fecdb07106ff7110434))
+
+## [4.0.2](https://github.com/sern-handler/handler/compare/v4.0.1...v4.0.2) (2024-08-13)
+
+
+### Bug Fixes
+
+* type issue ([2106cdc](https://github.com/sern-handler/handler/commit/2106cdc1d033f88b6ee4ccca6754fe7a595a9328))
+
 ## [4.0.1](https://github.com/sern-handler/handler/compare/v4.0.0...v4.0.1) (2024-07-19)


--- a/2
+++ b/2
@@ -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
--- a/README.md
+++ b/README.md
@@ -49,7 +49,7 @@ export default commandModule({
 - [Vinci](https://github.com/SrIzan10/vinci), the bot for Mara Turing.
 - [Bask](https://github.com/baskbotml/bask), Listen your favorite artists on Discord.
 - [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.
 - [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.
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
    "name": "@sern/handler",
    "packageManager": "yarn@3.5.0",
-    "version": "4.0.1",
+    "version": "4.2.1",
    "description": "A complete, customizable, typesafe, & reactive framework for discord bots.",
    "main": "./dist/index.js",
    "module": "./dist/index.js",
@@ -38,9 +38,7 @@
        "@sern/ioc": "^1.1.0",
        "callsites": "^3.1.0",
        "cron": "^3.1.7",
-        "deepmerge": "^4.3.1",
-        "rxjs": "^7.8.0",
-        "ts-results-es": "^4.1.0"
+        "deepmerge": "^4.3.1"
    },
    "devDependencies": {
        "@faker-js/faker": "^8.0.1",
--- a/src/core/functions.ts
+++ b/src/core/functions.ts
@@ -11,7 +11,22 @@ import type {
 import { ApplicationCommandOptionType, InteractionType } from 'discord.js';
 import { PluginType } from './structures/enums';
 import assert from 'assert';
-import type { Payload } from '../types/utility';
+import type { Payload, UnpackedDependencies } from '../types/utility';
+
+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
@@ -104,6 +119,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;
 }
--- a/src/core/ioc.ts
+++ b/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();
--- a/src/core/modules.ts
+++ b/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
- * @param mod
+ * Creates a command module with standardized structure and plugin support.
+ * 
+ * @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,12 +52,35 @@ 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
- * @param mod
+ * @template T - Event name from ClientEvents
+ * @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(mod: InputEvent): Module {
+export function eventModule<T extends keyof ClientEvents = keyof ClientEvents>(mod: InputEvent<T>): Module {
    const [onEvent, plugins] = partitionPlugins(mod.plugins);
    if(onEvent.length !== 0) throw Error("Event modules cannot have ControlPlugins");
    return { ...mod,
@@ -35,8 +89,9 @@ export function eventModule(mod: InputEvent): Module {
 }

 /** Create event modules from discord.js client events,
- * This is an {@link eventModule} for discord events,
- * where typings can be very bad.
+ * This was an {@link eventModule} for discord events,
+ * where typings were bad.
+ * @deprecated Use {@link eventModule} instead
 * @param mod
 */
 export function discordEvent<T extends keyof ClientEvents>(mod: {
@@ -47,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 
+}

--- a/src/core/plugin.ts
+++ b/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 'ts-results-es';
+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),
 };

--- a/src/core/presences.ts
+++ b/src/core/presences.ts
@@ -1,11 +1,10 @@
 import type { ActivitiesOptions } from "discord.js";
 import type { IntoDependencies } from "./ioc";
 import type { Emitter } from "./interfaces";
+import { Awaitable } from "../types/utility";

 type Status = 'online' | 'idle' | 'invisible' | 'dnd'
-type PresenceReduce = (previous: Presence.Result) => Presence.Result;
-
-
+type PresenceReduce = (previous: Presence.Result) => Awaitable<Presence.Result>;

 export const Presence = {
    /**
@@ -50,7 +49,7 @@ export const Presence = {
 export declare namespace Presence {
    export type Config<T extends (keyof Dependencies)[]> = {
        inject?: [...T]
-        execute: (...v: IntoDependencies<T>) => Presence.Result;
+        execute: (...v: IntoDependencies<T>) => Awaitable<Presence.Result>;

    }

@@ -60,7 +59,7 @@ export declare namespace Presence {
        activities?: ActivitiesOptions[];
        shardId?: number[];
        repeat?: number | [Emitter, string];
-        onRepeat?: (previous: Result) => Result; 
+        onRepeat?: PresenceReduce 
    }
 }

--- a/src/core/structures/context.ts
+++ b/src/core/structures/context.ts
@@ -8,8 +8,7 @@ import type {
    Snowflake,
    User,
 } from 'discord.js';
-import { CoreContext } from '../structures/core-context';
-import { Result, Ok, Err } from 'ts-results-es';
+import { Result, Ok, Err, val } from './result';
 import * as assert from 'assert';
 import type { ReplyOptions } from '../../types/utility';
 import { fmt } from '../functions'
@@ -21,39 +20,32 @@ import { SernError } from './enums';
 * Provides values shared between
 * Message and ChatInputCommandInteraction
 */
-export class Context extends CoreContext<Message, ChatInputCommandInteraction> {
+export class Context {
    
    get options() {
        if(this.isMessage()) {
            const [, ...rest] = fmt(this.message.content, this.prefix);
            return rest;
-        } else {
-            return this.interaction.options;
-        }
+        } 
+        return this.interaction.options;
    }
    

    protected constructor(protected ctx: Result<Message, ChatInputCommandInteraction>,
-                          private __prefix?: string) {
-        super(ctx);
-    }
+                          private __prefix?: string) { }
    public get prefix() {
        return this.__prefix;
    }
    public get id(): Snowflake {
-        return safeUnwrap(this.ctx
-                            .map(m => m.id)
-                            .mapErr(i => i.id));
+        return val(this.ctx).id
    }

    public get channel() {
-        return safeUnwrap(this.ctx.map(m => m.channel).mapErr(i => i.channel));
+        return val(this.ctx).channel;
    }

    public get channelId(): Snowflake {
-        return safeUnwrap(this.ctx
-                            .map(m => m.channelId)
-                            .mapErr(i => i.channelId));
+        return val(this.ctx).channelId;
    }
    
    /**
@@ -61,9 +53,11 @@ export class Context extends CoreContext<Message, ChatInputCommandInteraction> {
     * else, interaction.user
     */
    public get user(): User {
-        return safeUnwrap(this.ctx
-                            .map(m => m.author)
-                            .mapErr(i => i.user));
+        if(this.ctx.ok) {
+            return this.ctx.value.author;
+        } 
+        return this.ctx.error.user;
+        
    }

    public get userId(): Snowflake {
@@ -71,59 +65,60 @@ export class Context extends CoreContext<Message, ChatInputCommandInteraction> {
    }

    public get createdTimestamp(): number {
-        return safeUnwrap(this.ctx 
-                            .map(m => m.createdTimestamp)
-                            .mapErr(i => i.createdTimestamp));
+        return val(this.ctx).createdTimestamp;
    }

    public get guild() {
-        return safeUnwrap(this.ctx
-                            .map(m => m.guild)
-                            .mapErr(i => i.guild));
+        return val(this.ctx).guild;
    }

    public get guildId() {
-        return safeUnwrap(this.ctx
-                            .map(m => m.guildId)
-                            .mapErr(i => i.guildId));
+        return val(this.ctx).guildId;
    }
    /*
     * interactions can return APIGuildMember if the guild it is emitted from is not cached
     */
    public get member() {
-        return safeUnwrap(this.ctx
-                            .map(m => m.member)
-                            .mapErr(i => i.member));
+        return val(this.ctx).member;
    }

    get message(): Message {
-        return this.ctx.expect(SernError.MismatchEvent);
+        if(this.ctx.ok) {
+            return this.ctx.value;
+        }
+        throw Error(SernError.MismatchEvent);
+    }
+    public isMessage(): this is Context & { ctx: Result<Message, never> } {
+        return this.ctx.ok;
+    }
+
+    public isSlash(): this is Context & { ctx: Result<never, ChatInputCommandInteraction> } {
+        return !this.isMessage();
    }

    get interaction(): ChatInputCommandInteraction {
-        return this.ctx.expectErr(SernError.MismatchEvent);
+        if(!this.ctx.ok) {
+            return this.ctx.error;
+        }
+        throw Error(SernError.MismatchEvent);
    }


    public get client(): Client {
-        return safeUnwrap(this.ctx
-                            .map(m => m.client)
-                            .mapErr(i => i.client));
+        return val(this.ctx).client;
    }

    public get inGuild(): boolean {
-        return safeUnwrap(this.ctx
-                            .map(m => m.inGuild())
-                            .mapErr(i => i.inGuild()));
+        return val(this.ctx).inGuild()
    }

    public async reply(content: ReplyOptions) {
-        return safeUnwrap(
-            this.ctx
-                .map(m => m.reply(content as MessageReplyOptions))
-                .mapErr(i =>
-                    i.reply(content as InteractionReplyOptions).then(() => i.fetchReply())),
-        );
+        if(this.ctx.ok) {
+            return this.ctx.value.reply(content as MessageReplyOptions)
+        } 
+        interface FetchReply { fetchReply: true };
+        return this.ctx.error.reply(content as InteractionReplyOptions & FetchReply)
+       
    }

    static wrap(wrappable: BaseInteraction | Message, prefix?: string): Context {
@@ -134,10 +129,3 @@ export class Context extends CoreContext<Message, ChatInputCommandInteraction> {
        return new Context(Err(wrappable), prefix);
    }
 }
-
-function safeUnwrap<T>(res: Result<T, T>) {
-    if(res.isOk()) {
-        return res.expect("Tried unwrapping message field: " + res)
-    } 
-    return res.expectErr("Tried unwrapping interaction field" + res)
-}
--- a/src/core/structures/core-context.ts
+++ b/src/core/structures/core-context.ts
@@ -1,18 +0,0 @@
-import { Result as Either } from 'ts-results-es';
-import * as assert from 'node:assert';
-
-/**
- * @since 3.0.0
- */
-export abstract class CoreContext<M, I> {
-    protected constructor(protected ctx: Either<M, I>) {
-        assert.ok(typeof ctx === 'object' && ctx != null, "Context was nonobject or null");
-    }
-    public isMessage(): this is CoreContext<M, never> {
-        return this.ctx.isOk();
-    }
-
-    public isSlash(): this is CoreContext<never, I> {
-        return !this.isMessage();
-    }
-}
--- a/src/core/structures/result.ts
+++ b/src/core/structures/result.ts
@@ -0,0 +1,20 @@
+export type Result<Ok, Err> =
+  | { ok: true; value: Ok }
+  | { ok: false; error: Err };
+
+export const Ok = <Ok>(value: Ok) => ({ ok: true, value } as const);
+export const Err = <Err>(error: Err) => ({ ok: false, error } as const);
+
+export const val = <O, E>(r: Result<O, E>) => r.ok ? r.value : r.error;
+export const EMPTY_ERR = Err(undefined);
+
+/**
+ * Wrap an async operation that may throw an Error (`try-catch` style) into checked exception style
+ * @param op The operation function
+ */
+export async function wrapAsync<T, E = unknown>(op: () => Promise<T>): Promise<Result<T, E>> {
+    try { return op()
+            .then(Ok)
+            .catch(Err); } 
+    catch (e) { return Promise.resolve(Err(e as E)); }
+}
--- a/src/handlers/event-utils.ts
+++ b/src/handlers/event-utils.ts
@@ -1,218 +1,18 @@
-import type { Interaction, Message, BaseInteraction } from 'discord.js';
-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 type { Emitter, Logging } from '../core/interfaces';
 import { SernError } from '../core/structures/enums'
-import { Err, Ok, Result } from 'ts-results-es';
-import type { UnpackedDependencies } from '../types/utility';
-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 { Ok, wrapAsync} from '../core/structures/result';
+import type {  Module } from '../types/core-modules';
 import { inspect } from 'node:util'
-import { disposeAll } from '../core/ioc';
-import { resultPayload, isAutocomplete, treeSearch, fmt } from '../core/functions'
+import { resultPayload } 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.isOk()) {
-            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 Err.EMPTY;
-            }
-            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(Result.wrapAsync(async () => module.execute(...args)))
-        .pipe(concatMap(result => { 
-            if (result.isOk()) {
-                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.isOk()) {
-            return onNext(payload, task.value) as Output;
-        } else {
-            onStop?.(payload.module, String(task.error));
-        }
-    };
-};

 function isObject(item: unknown) {
    return (item && typeof item === 'object' && !Array.isArray(item));
@@ -225,22 +25,45 @@ export async function callInitPlugins(_module: Module, deps: Dependencies, emit?
    for(const plugin of module.plugins ?? []) {
        const result = await plugin.execute({ module, absPath: module.meta.absPath, deps });
        if (!result) throw Error("Plugin did not return anything. " + inspect(plugin, false, Infinity, true));
-        if(result.isErr()) {
+        if(!result.ok) {
            if(emit) {
                emitter?.emit('module.register',
                              resultPayload('failure', module, result.error ?? SernError.PluginFailure));
            }
-            throw Error(result.error ?? SernError.PluginFailure);
+            throw Error((result.error ?? SernError.PluginFailure) +
+                        'on module ' + module.name + " " + module.meta.absPath);
        }
    }
    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 });
-        if(result.isErr()) {
+        const result = await plugin.execute(...args);
+        if(!result.ok) {
            return result;
        }
        if(isObject(result.value)) {
@@ -249,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);
-         }))
--- a/src/handlers/interaction.ts
+++ b/src/handlers/interaction.ts
@@ -1,30 +1,68 @@
-import type { Interaction } from 'discord.js';
-import { mergeMap, merge, concatMap, EMPTY } from 'rxjs';
-import { createInteractionHandler, executeModule, intoTask, sharedEventStream, filterTap, handleCrash } from './event-utils';
+import type { Module } from '../types/core-modules'
+import {  callPlugins, executeModule } from './event-utils';
 import { SernError } from '../core/structures/enums'
-import { isAutocomplete, isCommand, isMessageComponent, isModal, resultPayload } from '../core/functions'
-import { UnpackedDependencies } from '../types/utility';
+import { createSDT, isAutocomplete, isCommand, isContextCommand, isMessageComponent, isModal, resultPayload, treeSearch } from '../core/functions'
+import type { UnpackedDependencies } from '../types/utility';
+import * as Id from '../core/id'
+import { Context } from '../core/structures/context';

-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
-    const interactionStream$ = sharedEventStream<Interaction>(client, 'interactionCreate');
-    const handle = createInteractionHandler(interactionStream$, deps, defaultPrefix);
+            '@sern/modules': moduleManager,
+            '@sern/logger': log,
+            '@sern/emitter': reporter } = deps

-    const interactionHandler$ = merge(handle(isMessageComponent),
-                                      handle(isAutocomplete),
-                                      handle(isCommand),
-                                      handle(isModal));
-    return interactionHandler$
-        .pipe(filterTap(e => emitter.emit('warning', resultPayload('warning', undefined, e))),
-              concatMap(intoTask(module => {
-                emitter.emit('module.activate', resultPayload('failure', module, SernError.PluginFailure))
-              })),
-              mergeMap(payload => {
-                  if(payload)
-                    return executeModule(emitter, payload)
-                  return EMPTY;
-              }),
-              handleCrash(deps, "interaction handling"));
+    client.on('interactionCreate', async (event) => {
+
+        //returns array of possible ids
+        const possibleIds = Id.reconstruct(event);
+
+        let modules = possibleIds
+            .map(({ id, params }) => ({ module: moduleManager.get(id)!, params }))
+            .filter(({ module }) => module !== undefined);
+
+        if(modules.length == 0) {
+            return;
+        }
+        const { module, params } = modules.at(0)!;
+        let payload;
+        // handles autocomplete
+        if(isAutocomplete(event)) {
+            //@ts-ignore stfu
+            const { command } = treeSearch(event, module.options);
+            payload= { module: command as Module, //autocomplete is not a true "module" warning cast!
+                       args: [event, createSDT(command, 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);
+    });
 }
--- a/src/handlers/message.ts
+++ b/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 { UnpackedDependencies } from '../types/utility';
-import type { Emitter } from '../core/interfaces';
+import { createSDT, fmt, resultPayload } from '../core/functions'
+import type { UnpackedDependencies } from '../types/utility';
+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) {
-    return (msg: Message): msg is Message => !msg.author.bot && hasPrefix(prefix, msg.content);
+function isBotOrNoPrefix(msg: Message, prefix: string) {
+    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 
-function (deps: UnpackedDependencies, defaultPrefix?: string) {
+export function messageHandler (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');
-    const handle = createMessageHandler(messageStream$, defaultPrefix, deps);
+    client.on('messageCreate', async message => {
+        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) {
+            throw Error('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(
-        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")
-    )
+        executeModule(emitter, log, payload)
+    })
+    
 }
--- a/src/handlers/presence.ts
+++ b/src/handlers/presence.ts
@@ -1,40 +1,99 @@
-import { concatMap, from, interval, of, map, scan, startWith, fromEvent, take } 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>) => {
-    return conf.then(s => {
-        if('repeat' in s) {
-            const { onRepeat, repeat } = s;
-            assert(repeat !== undefined, "repeat option is undefined");
-            assert(onRepeat !== undefined, "onRepeat callback is undefined, but repeat exists");
-            const src$ = typeof repeat === 'number' 
-                ? interval(repeat)
-                : fromEvent(...repeat);
-                return src$.pipe(scan(onRepeat, s), 
-                                 startWith(s));
+const parseConfig = async (conf: Promise<Presence.Result>, setPresence: SetPresence) => {
+    const result = await conf;
+    
+    if ('repeat' in result) {
+        const { onRepeat, repeat } = result;
+        // Validate configuration
+        if (repeat === undefined) {
+            throw new Error("repeat option is undefined");
        }
-        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) => {
-    const presence = Files
-        .importModule<Presence.Config<(keyof Dependencies)[]>>(path)
-        .then(({ module }) => {
-            //fetch services with the order preserved, passing it to the execute fn 
-            const fetchedServices = Services(...module.inject ?? []);
-            return async () => module.execute(...fetchedServices);
-        })
-    const module$ = from(presence);
-    return module$.pipe(
-        //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))));
+export const presenceHandler = async (path: string, setPresence: SetPresence) => {
+    const presence = await 
+        Files.importModule<Presence.Config<(keyof Dependencies)[]>>(path)
+             .then(({ module }) => {
+                //fetch services with the order preserved, passing it to the execute fn 
+                const fetchedServices = Services(...module.inject ?? []);
+                return async () => module.execute(...fetchedServices);
+             })
+     
+    return parseConfig(presence(), setPresence);
+       
 }
--- a/src/handlers/ready.ts
+++ b/src/handlers/ready.ts
@@ -3,10 +3,10 @@ import { once } from 'node:events';
 import { resultPayload } from '../core/functions';
 import { CommandType } from '../core/structures/enums';
 import { Module } from '../types/core-modules';
-import { UnpackedDependencies } from '../types/utility';
+import type { UnpackedDependencies, Wrapper } from '../types/utility';
 import { callInitPlugins } from './event-utils';

-export default async function(dir: string, deps : UnpackedDependencies) {
+export default async function(dirs: string | string[], deps : UnpackedDependencies) {
    const { '@sern/client': client,
            '@sern/logger': log,
            '@sern/emitter': sEmitter,
@@ -17,16 +17,21 @@ export default async function(dir: string, deps : UnpackedDependencies) {

    // https://observablehq.com/@ehouais/multiple-promises-as-an-async-generator
    // possibly optimize to concurrently import modules
-    for await (const path of Files.readRecursive(dir)) {
-        let { module } = await Files.importModule<Module>(path);
-        const validType = module.type >= CommandType.Text && module.type <= CommandType.ChannelSelect;
-        if(!validType) {
-            throw Error(`Found ${module.name} at ${module.meta.absPath}, which has incorrect \`type\``);
+
+    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 validType = module.type >= CommandType.Text && module.type <= CommandType.ChannelSelect;
+            if(!validType) {
+                throw Error(`Found ${module.name} at ${module.meta.absPath}, which has incorrect \`type\``);
+            }
+            const resultModule = await callInitPlugins(module, deps, true);
+            // FREEZE! no more writing!!
+            commands.set(resultModule.meta.id, Object.freeze(resultModule));
+            sEmitter.emit('module.register', resultPayload('success', resultModule));
        }
-        const resultModule = await callInitPlugins(module, deps, true);
-        // FREEZE! no more writing!!
-        commands.set(resultModule.meta.id, Object.freeze(resultModule));
-        sEmitter.emit('module.register', resultPayload('success', resultModule));
    }
    sEmitter.emit('modulesLoaded');
 }
--- a/src/handlers/tasks.ts
+++ b/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);
-        //module.name is assigned by Files.importModule<>
-        // the id created for the task is unique
-        const uuid = module.name+"/"+relative(tasksPath,fileURLToPath(f))
-        taskManager.schedule(uuid, module, deps)
+
+    const directories = Array.isArray(tasksDirs) ? tasksDirs : [tasksDirs];
+
+    for (const dir of directories) {
+        for await (const path of Files.readRecursive(dir)) {
+            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)
+        }
    }
 }
--- a/src/handlers/user-defined-events.ts
+++ b/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 { EventModule,  Module  } from '../types/core-modules';
+import { callInitPlugins } from './event-utils'
+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');
        }
-};
-
-export default async function(deps: UnpackedDependencies, eventDir: string) {
-    const eventModules: EventModule[] = [];
-    for await (const path of Files.readRecursive(eventDir)) {
-        let { module } = await Files.importModule<Module>(path);
-        await callInitPlugins(module, deps)
-        eventModules.push(module as EventModule);
+        if(!source && typeof source !== 'object') {
+            throw Error(`${source} cannot be constructed into an event listener`)
+        }
+        
+        if(!('addListener' in source && 'removeListener' in source)) {
+            throw Error('source must implement Emitter')
+        }
+        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();
 }
+
--- a/src/index.ts
+++ b/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;
-}
--- a/src/sern.ts
+++ b/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 });
-
-    const messages$ = messageHandler(deps, maybeWrapper.defaultPrefix);
-    const interactions$ = interactionHandler(deps, maybeWrapper.defaultPrefix);
-    // listening to the message stream and interaction stream
-    merge(messages$, interactions$).subscribe();
+    interactionHandler(deps, maybeWrapper.defaultPrefix);
+    messageHandler(deps, maybeWrapper.defaultPrefix)
 }
--- a/src/types/core-modules.ts
+++ b/src/types/core-modules.ts
@@ -19,14 +19,97 @@ 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 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 };
@@ -41,7 +124,75 @@ 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>;
 }

@@ -167,9 +318,9 @@ export interface CommandModuleDefs {
    [CommandType.Modal]: ModalSubmitCommand;
 }

-export interface EventModuleDefs {
+export interface EventModuleDefs<T extends keyof ClientEvents = keyof ClientEvents> {
    [EventType.Sern]: SernEventCommand;
-    [EventType.Discord]: DiscordEventCommand;
+    [EventType.Discord]: DiscordEventCommand<T>;
    [EventType.External]: ExternalEventCommand;
 }

@@ -186,12 +337,12 @@ export interface SernAutocompleteData
 type CommandModuleNoPlugins = {
    [T in CommandType]: Omit<CommandModuleDefs[T], 'plugins' | 'onEvent' | 'meta' | 'locals'>;
 };
-type EventModulesNoPlugins = {
-    [T in EventType]: Omit<EventModuleDefs[T], 'plugins' | 'onEvent' | 'meta' | 'locals'> ;
+type EventModulesNoPlugins<K extends keyof ClientEvents = keyof ClientEvents> = {
+    [T in EventType]: Omit<EventModuleDefs<K>[T], 'plugins' | 'onEvent' | 'meta' | 'locals'> ;
 };

-export type InputEvent = {
-    [T in EventType]: EventModulesNoPlugins[T] & {
+export type InputEvent<K extends keyof ClientEvents = keyof ClientEvents> = {
+    [T in EventType]: EventModulesNoPlugins<K>[T] & {
        once?: boolean;
        plugins?: InitPlugin[] 
    };
--- a/src/types/core-plugin.ts
+++ b/src/types/core-plugin.ts
@@ -11,7 +11,6 @@
 * Plugins are reminiscent of middleware in express.
 */

-import type { Result } from 'ts-results-es';
 import type {
    Module,
    Processed,
@@ -23,6 +22,7 @@ import type { Context } from '../core/structures/context'
 import type {
    ButtonInteraction,
    ChannelSelectMenuInteraction,
+    ChatInputCommandInteraction,
    MentionableSelectMenuInteraction,
    MessageContextMenuCommandInteraction,
    ModalSubmitInteraction,
@@ -31,6 +31,7 @@ import type {
    UserContextMenuCommandInteraction,
    UserSelectMenuInteraction,
 } from 'discord.js';
+import { Result } from '../core/structures/result';

 export type PluginResult = Awaitable<Result<Record<string,unknown>|undefined, string|undefined>>;
 export interface InitArgs<T extends Processed<Module> = Processed<Module>> {
@@ -56,8 +57,8 @@ export type AnyPlugin = ControlPlugin | InitPlugin<[InitArgs<Processed<Module>>]
 export type CommandArgs<I extends CommandType = CommandType> = CommandArgsMatrix[I]

 interface CommandArgsMatrix {
-    [CommandType.Text]: [Context, SDT];
-    [CommandType.Slash]: [Context, SDT];
+    [CommandType.Text]: [Context & { get options(): string[]}, SDT];
+    [CommandType.Slash]: [Context  & { get options(): ChatInputCommandInteraction['options']}, SDT];
    [CommandType.Both]: [Context, SDT];
    [CommandType.CtxMsg]: [MessageContextMenuCommandInteraction, SDT];
    [CommandType.CtxUser]: [UserContextMenuCommandInteraction, SDT];
--- a/src/types/utility.ts
+++ b/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 'ts-results-es';

 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[];
+}
--- a/test/core/functions.test.ts
+++ b/test/core/functions.test.ts
@@ -6,49 +6,6 @@ import { partitionPlugins, treeSearch } from '../../src/core/functions';
 import { faker } from '@faker-js/faker';
 import { ApplicationCommandOptionType, AutocompleteInteraction } 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,
-    };
-});
-
 describe('functions', () => {
    afterEach(() => {
        vi.clearAllMocks();
--- a/test/core/id.test.ts
+++ b/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")
 })
--- a/test/core/presence.test.ts
+++ b/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();
+    })
+
 })
--- a/test/handlers.test.ts
+++ b/test/handlers.test.ts
@@ -1,83 +1,14 @@
 //@ts-nocheck
-import { beforeEach, describe, expect, vi, it, test } from 'vitest';
-import { callInitPlugins, eventDispatcher } from '../src/handlers/event-utils';
+import { beforeEach, describe, expect, it, test } from 'vitest';
+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, CommandInitPlugin, CommandType, controller } from '../src';
+import { CommandControlPlugin, 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,47 +17,30 @@ function mockDeps() {
   }
 }
 
-describe('eventDispatcher standard', () => {
-    let m: Processed<Module>;
-    let ee: EventEmitter;
-    beforeEach(() => {
-        ee = new EventEmitter();
-        m = createRandomModule();
-    });
+describe('calling init plugins', async () => {
+   let deps;
+   beforeEach(() => {
+       deps = mockDeps()
+   });

-    it('should throw', () => {
-        expect(() => eventDispatcher(mockDeps(), m,  'not event emitter')).toThrowError();
-    });
+   test ('call init plugins', async () => {
+       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('call control plugin ', async () => {
-    const plugin = CommandControlPlugin<CommandType.Slash>((ctx,sdt) => {
-        return controller.next();
-    });
-    const res = await plugin.execute(new ChatInputCommandInteraction(), {})
-    expect(res.isOk()).toBe(true)
-})
+

 test('form sdt', async () => {

--- a/test/setup/setup-tests.ts
+++ b/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', {  })
+})
+
+
--- a/test/setup/util.ts
+++ b/test/setup/util.ts
@@ -0,0 +1,30 @@
+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(),
+    };
+}
--- a/vitest.config.ts
+++ b/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'],
+  },
+})
--- a/yarn.lock
+++ b/yarn.lock
Author	SHA1	Message	Date
github-actions[bot]	97fa2a2d78	chore(main): release 4.2.1 (#383 ) Some checks failed Continuous Delivery / Publishing Dev (push) Has been cancelled Details NPM / Publish / test-and-publish (push) Has been cancelled Details Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	2025-01-24 16:38:33 -06:00
Jacob Nguyen	a52ad270d8	fix: context-interactions error (#382 ) Some checks are pending Continuous Delivery / Publishing Dev (push) Waiting to run Details NPM / Publish / test-and-publish (push) Waiting to run Details	2025-01-24 10:37:51 -06:00
github-actions[bot]	3f703c17b8	chore(main): release 4.2.0 (#380 ) Some checks failed Continuous Delivery / Publishing Dev (push) Has been cancelled Details NPM / Publish / test-and-publish (push) Has been cancelled Details Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	2025-01-18 12:00:13 -06:00
Jacob Nguyen	f9e7eaf92d	feat: 4.2.0 load multiple directories & `handleModuleErrors` (#378 ) * error-handling-draft * feat: array based module loading (#379) Co-authored-by: Jacob Nguyen <76754747+jacoobes@users.noreply.github.com> * Update utility.ts * Update sern.ts * describesemanticsbetter --------- Co-authored-by: Duro <davidwright13503@gmail.com>	2025-01-18 11:47:51 -06:00
github-actions[bot]	52e145600d	chore(main): release 4.1.1 (#377 ) Some checks failed Continuous Delivery / Publishing Dev (push) Has been cancelled Details NPM / Publish / test-and-publish (push) Has been cancelled Details * chore(main): release 4.1.1 * Update CHANGELOG.md --------- Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Jacob Nguyen <76754747+jacoobes@users.noreply.github.com>	2025-01-13 18:59:14 -06:00
Jacob Nguyen	59d08ef207	fix: remove rxjs (#376 ) Some checks are pending Continuous Delivery / Publishing Dev (push) Waiting to run Details NPM / Publish / test-and-publish (push) Waiting to run Details * firstcommit * removerxjs * document-task * documentation+clean * fixregres * fix+regress * fix+regres+errorhandling	2025-01-13 10:33:53 -06:00
Jacob Nguyen	7deb79e907	Delete .github/workflows/continuous-integration.yml Some checks failed NPM / Publish / test-and-publish (push) Has been cancelled Details	2025-01-11 13:59:20 -06:00
Jacob Nguyen	f2d4b5bda1	cleanup-tests Some checks failed NPM / Publish / test-and-publish (push) Has been cancelled Details	2025-01-07 17:33:33 -06:00
Glitch	a575b3ed74	update license year (#375 ) Some checks failed NPM / Publish / test-and-publish (push) Waiting to run Details Continuous Delivery / Publishing Dev (push) Has been cancelled Details	2025-01-06 17:16:31 -06:00
github-actions[bot]	2042559b4d	chore(main): release 4.1.0 (#374 ) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	2025-01-06 17:02:24 -06:00
Jacob Nguyen	220a60ecf8	feat: moduleinfo-in-eventplugins (#373 )	2025-01-06 17:00:02 -06:00
Glitch	55715d5659	fix: update github username (#371 ) Some checks failed NPM / Publish / test-and-publish (push) Has been cancelled Details	2024-11-18 16:34:27 -06:00
github-actions[bot]	d0c3b7469e	chore(main): release 4.0.3 (#370 ) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	2024-10-06 11:53:30 -05:00
Jacob Nguyen	eabfb81819	fix: async presence (#369 ) * fix: async presence * fixes to typings	2024-10-06 11:51:07 -05:00
Duro	1789ccb2f2	fix: fix eventModule typing for Discord events (#368 )	2024-08-19 11:18:13 -05:00
github-actions[bot]	25c5891ade	chore(main): release 4.0.2 (#367 ) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	2024-08-12 21:30:44 -05:00
jacob	2106cdc1d0	fix: type issue	2024-08-12 21:28:22 -05:00
Jacob Nguyen	61e82fdc7b	refactor: remove ts-results-es (#366 ) * remove tsresultses * remove test since it uses external api * opt in for simpler * add more debug information Signed-off-by: Jacob Nguyen <76754747+jacoobes@users.noreply.github.com> * add more debug information Signed-off-by: Jacob Nguyen <76754747+jacoobes@users.noreply.github.com> * clean up if else --------- Signed-off-by: Jacob Nguyen <76754747+jacoobes@users.noreply.github.com>	2024-08-11 11:07:44 -05:00
xxDeveloper	3755b95b1a	chore: Update LICENSE year (#365 )	2024-08-06 10:56:25 -05:00