simplify, remove reply option

decide not to support error handling for autocomplete
extract & refactor
2026-06-06 01:16:55 +00:00 · 2023-11-02 15:16:12 -05:00 · 2023-11-02 14:19:43 -05:00 · 2023-10-12 12:52:50 -05:00 · 2023-10-12 12:35:49 -05:00 · 2023-10-04 00:38:18 -05:00
87 changed files with 3875 additions and 2841 deletions
--- a/.github/workflows/continuous-integration.yml
+++ b/.github/workflows/continuous-integration.yml
@@ -23,7 +23,7 @@ jobs:
        uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3

      - name: Set up Node.js
-        uses: actions/setup-node@1a4442cacd436585916779262731d5b162bc6ec7 # v3
+        uses: actions/setup-node@64ed1c7eab4cce3362f8c340dee64e5eaeef8f7c # v3
        with:
          node-version: 17

--- a/.github/workflows/npm-publish-dev.yml
+++ b/.github/workflows/npm-publish-dev.yml
@@ -1,34 +0,0 @@
-name: Continuous Delivery
-
-on:
-  push:
-    branches:
-      - main
-    paths:
-      - 'src/**'
-      - 'package.json'
-
-jobs:
-  Publish:
-    name: Publishing Dev
-    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: 18
-          registry-url: 'https://registry.npmjs.org'
-
-      - name: Install Node.js dependencies
-        run: npm i && npm run build:dev
-
-      - name: Publish to npm
-        run: |
-          npm version premajor --preid "dev.$(git rev-parse --verify --short HEAD)" --git-tag-version=false
-          npm publish --tag dev
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
--- a/.github/workflows/npm-publish.yml
+++ b/.github/workflows/npm-publish.yml
@@ -11,7 +11,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3
-      - uses: actions/setup-node@1a4442cacd436585916779262731d5b162bc6ec7 # v3
+      - uses: actions/setup-node@5e21ff4d9bc1a8cf6de233a3057d20ec6b3fb69d # v3
        with:
          node-version: 17
      - run: yarn --immutable
--- a/.github/workflows/release-please.yml
+++ b/.github/workflows/release-please.yml
@@ -6,7 +6,7 @@ jobs:
    release-please:
      runs-on: ubuntu-latest
      steps:
-        - uses: google-github-actions/release-please-action@db8f2c60ee802b3748b512940dde88eabd7b7e01 # v3
+        - uses: google-github-actions/release-please-action@ca6063f4ed81b55db15b8c42d1b6f7925866342d # v3
          with:
            release-type: node
            package-name: release-please-action
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -20,7 +20,7 @@ jobs:
    steps:
    - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3
    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@1a4442cacd436585916779262731d5b162bc6ec7 # v3
+      uses: actions/setup-node@5e21ff4d9bc1a8cf6de233a3057d20ec6b3fb69d # v3
      with:
        node-version: ${{ matrix.node-version }}
        cache: 'npm'
--- a/.npmignore
+++ b/.npmignore
@@ -113,4 +113,3 @@ tsconfig-cjs.json
 tsconfig-esm.json

 renovate.json
-fortnite
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,69 +1,5 @@
 # Changelog

-## [3.3.4](https://github.com/sern-handler/handler/compare/v3.3.3...v3.3.4) (2024-03-18)
-
-
-### Bug Fixes
-
-* sern emitter err ([#358](https://github.com/sern-handler/handler/issues/358)) ([90e55df](https://github.com/sern-handler/handler/commit/90e55dfa1466c91e5da48922251309331921b1ef))
-
-## [3.3.3](https://github.com/sern-handler/handler/compare/v3.3.2...v3.3.3) (2024-02-25)
-
-
-### Bug Fixes
-
-* rm deprecated class modules, clean up, rm indirection ([#355](https://github.com/sern-handler/handler/issues/355)) ([48f9f6e](https://github.com/sern-handler/handler/commit/48f9f6ec16e650d574bd24dcbb0ed176933bfe17))
-* singleton init not being fired when inserting function ([07b11b3](https://github.com/sern-handler/handler/commit/07b11b357baac0c3c7055c022bc353995c80f766))
-* typings and cleanup ([#356](https://github.com/sern-handler/handler/issues/356)) ([ce8c4bf](https://github.com/sern-handler/handler/commit/ce8c4bf6492b9680fb1c1a530d3e0028f214ad2f))
-
-## [3.3.2](https://github.com/sern-handler/handler/compare/v3.3.1...v3.3.2) (2024-01-08)
-
-
-### Bug Fixes
-
-* presence feature not working on cjs applications ([#351](https://github.com/sern-handler/handler/issues/351)) ([4f23871](https://github.com/sern-handler/handler/commit/4f2387119acfde036d0d1626553e9050f55627d1))
-
-## [3.3.1](https://github.com/sern-handler/handler/compare/v3.3.0...v3.3.1) (2024-01-07)
-
-
-### Bug Fixes
-
-* crashing when slash command is used as text command ([#349](https://github.com/sern-handler/handler/issues/349)) ([a359f73](https://github.com/sern-handler/handler/commit/a359f73fa24127a4964d411c8c1c0dfea5edc0f1))
-
-
-### Reverts
-
-* the last commit ([655bb8d](https://github.com/sern-handler/handler/commit/655bb8d35815fe0ce9797d8b169310a07b284ae0))
-
-## [3.3.0](https://github.com/sern-handler/handler/compare/v3.2.1...v3.3.0) (2023-12-27)
-
-
-### Features
-
-* presence ([#345](https://github.com/sern-handler/handler/issues/345)) ([7458bef](https://github.com/sern-handler/handler/commit/7458befe8a5900480cd71900df02a8364837dc00))
-
-## [3.2.1](https://github.com/sern-handler/handler/compare/v3.2.0...v3.2.1) (2023-12-21)
-
-
-### Bug Fixes
-
-* logger swap failing ([daac37c](https://github.com/sern-handler/handler/commit/daac37c28858c42b21042bdcb8141239db634e7d))
-
-## [3.2.0](https://github.com/sern-handler/handler/compare/v3.1.1...v3.2.0) (2023-12-15)
-
-
-### Miscellaneous Chores
-
-* release 3.2.0 ([237c853](https://github.com/sern-handler/handler/commit/237c8537c66052309d7e13a7e6e0a4f7995c2558))
-
-## [3.1.1](https://github.com/sern-handler/handler/compare/v3.1.0...v3.1.1) (2023-11-06)
-
-
-### Bug Fixes
-
-* queuing events ([fd39858](https://github.com/sern-handler/handler/commit/fd39858636d3038abb6d91021b65c99c488a3d6e))
-* queuing events ([#332](https://github.com/sern-handler/handler/issues/332)) @Benzo-Fury ([#333](https://github.com/sern-handler/handler/issues/333)) ([fd39858](https://github.com/sern-handler/handler/commit/fd39858636d3038abb6d91021b65c99c488a3d6e))
-
 ## [3.1.0](https://github.com/sern-handler/handler/compare/v3.0.2...v3.1.0) (2023-09-04)


--- a/README.md
+++ b/README.md
@@ -19,16 +19,28 @@
 - Lightweight. Does a lot while being small.
 - Latest features. Support for discord.js v14 and all of its interactions.
 - Start quickly. Plug and play or customize to your liking.
+- Switch and customize how errors are handled, logging, and more.
 - works with [bun](https://bun.sh/) and [node](https://nodejs.org/en) out the box!
 - Use it with TypeScript or JavaScript. CommonJS and ESM supported.
 - Active and growing community, always here to help. [Join us](https://sern.dev/discord)
 - Unleash its full potential with a powerful CLI and awesome plugins.

 ## 📜 Installation
-[Start here!!](https://sern.dev/docs/guide/walkthrough/new-project)
+
+```sh
+npm install @sern/handler
+```
+
+```sh
+yarn add @sern/handler
+```
+
+```sh
+pnpm add @sern/handler
+```

 ## 👶 Basic Usage
-<details><summary>ping.ts</summary>
+<details open><summary>ping.ts</summary>

 ```ts
 export default commandModule({
@@ -42,7 +54,50 @@ export default commandModule({
 });
 ```
 </details>
+<details open><summary>modal.ts</summary>

+```ts
+export default commandModule({
+    type: CommandType.Modal,
+    //Installed a plugin to make sure modal fields pass a validation.
+    plugins : [
+        assertFields({
+            fields: { 
+                name: /^([^0-9]*)$/ 
+            },
+            failure: (errors, modal) => modal.reply('your submission did not pass the validations')
+        })
+    ],
+    execute : (modal) => {
+        modal.reply('thanks for the submission!');
+    }
+})
+```
+</details>
+<details open><summary>index.ts</summary>
+
+	
+```ts 
+import { Client, GatewayIntentBits } from 'discord.js';
+import { Sern, single } from '@sern/handler';
+
+//client has been declared previously
+//Version 3
+await makeDependencies({
+    build: root => root
+        .add({ '@sern/client': single(() => client)  })
+});
+
+//View docs for all options
+Sern.init({
+	defaultPrefix: '!', // removing defaultPrefix will shut down text commands
+	commands: 'src/commands',
+	// events: 'src/events' (optional),
+});
+
+client.login("YOUR_BOT_TOKEN_HERE");
+```
+</details>

 ## 🤖 Bots Using sern 
 - [Community Bot](https://github.com/sern-handler/sern-community), the community bot for our [discord server](https://sern.dev/discord).
@@ -52,8 +107,7 @@ export default commandModule({
 - [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.
 - [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.
+
 ## 💻 CLI

 It is **highly encouraged** to use the [command line interface](https://github.com/sern-handler/cli) for your project. Don't forget to view it.
--- a/1
+++ b/1
@@ -1 +0,0 @@
-
--- a/package.json
+++ b/package.json
@@ -1,23 +1,26 @@
 {
    "name": "@sern/handler",
    "packageManager": "yarn@3.5.0",
-    "version": "4.0.0",
+    "version": "3.1.0",
    "description": "A complete, customizable, typesafe, & reactive framework for discord bots.",
    "main": "./dist/index.js",
-    "module": "./dist/index.js",
+    "module": "./dist/index.mjs",
+    "types": "./dist/index.d.ts",
    "exports": {
        ".": {
-            "import": "./dist/index.js",
-            "require": "./dist/index.js"
+            "import": "./dist/index.mjs",
+            "require": "./dist/index.js",
+            "types": "./dist/index.d.ts"
        }
    },
    "scripts": {
-        "watch": "tsc --watch",
+        "watch": "tsup --watch",
+        "clean-modules": "rimraf node_modules/ && npm install",
        "lint": "eslint src/**/*.ts",
        "format": "eslint src/**/*.ts --fix",
-        "build:dev": "tsc",
-        "build:prod": "tsc",
-        "prepare": "tsc",
+        "build:dev": "tsup --metafile",
+        "build:prod": "tsup ",
+        "prepare": "npm run build:prod",
        "pretty": "prettier --write .",
        "tdd": "vitest",
        "test": "vitest --run",
@@ -35,23 +38,30 @@
    "author": "SernDevs",
    "license": "MIT",
    "dependencies": {
-        "@sern/ioc": "^1.1.0",
-        "callsites": "^3.1.0",
-        "cron": "^3.1.7",
-        "deepmerge": "^4.3.1",
+        "iti": "^0.6.0",
        "rxjs": "^7.8.0",
-        "ts-results-es": "^4.1.0"
+        "ts-results-es": "^4.0.0"
    },
    "devDependencies": {
        "@faker-js/faker": "^8.0.1",
-        "@types/node": "^20.0.0",
-        "@types/node-cron": "^3.0.11",
+        "@types/node": "^18.15.11",
        "@typescript-eslint/eslint-plugin": "5.58.0",
        "@typescript-eslint/parser": "5.59.1",
-        "discord.js": "^14.15.3",
+        "discord.js": "14.11.0",
+        "esbuild": "^0.17.0",
        "eslint": "8.39.0",
+        "prettier": "2.8.8",
+        "tsup": "^6.7.0",
        "typescript": "5.0.2",
-        "vitest": "^1.6.0"
+        "vitest": "latest"
+    },
+    "prettier": {
+        "semi": true,
+        "trailingComma": "all",
+        "singleQuote": true,
+        "printWidth": 100,
+        "tabWidth": 4,
+        "arrowParens": "avoid"
    },
    "eslintConfig": {
        "parser": "@typescript-eslint/parser",
@@ -85,14 +95,5 @@
        "type": "git",
        "url": "git+https://github.com/sern-handler/handler.git"
    },
-    "engines": {
-        "node": ">= 20.0.x"
-    },
-    "homepage": "https://sern.dev",
-    "overrides": {
-        "ws": "8.17.1"
-    },
-    "resolutions": {
-        "ws": "8.17.1"
-    }
+    "homepage": "https://sern.dev"
 }
--- a/src/core/_internal.ts
+++ b/src/core/_internal.ts
@@ -0,0 +1,10 @@
+export * as Id from './id';
+export * from './operators';
+export * from './predicates';
+export * as Files from './module-loading';
+export * from './functions';
+export type { VoidResult } from '../types/core-plugin';
+export { SernError } from './structures/enums';
+export { ModuleStore } from './structures/module-store';
+export * as DefaultServices from './structures/services';
+export { useContainerRaw } from './ioc/base'
--- a/src/core/contracts/disposable.ts
+++ b/src/core/contracts/disposable.ts
@@ -0,0 +1,9 @@
+import type { Awaitable } from '../../types/utility';
+
+/**
+ * Represents a Disposable contract.
+ * Let dependencies implement this to dispose and cleanup.
+ */
+export interface Disposable {
+    dispose(): Awaitable<unknown>;
+}
--- a/src/core/contracts/emitter.ts
+++ b/src/core/contracts/emitter.ts
@@ -0,0 +1,7 @@
+import type { AnyFunction } from '../../types/utility';
+
+export interface Emitter {
+    addListener(eventName: string | symbol, listener: AnyFunction): this;
+    removeListener(eventName: string | symbol, listener: AnyFunction): this;
+    emit(eventName: string | symbol, ...payload: any[]): boolean;
+}
--- a/src/core/contracts/error-handling.ts
+++ b/src/core/contracts/error-handling.ts
@@ -0,0 +1,26 @@
+import type { CommandModule,Processed, EventModule } from "../../types/core-modules";
+
+/**
+ * @since 2.0.0
+ */
+export interface ErrorHandling {
+    /**
+     * @deprecated
+     * Version 4 will remove this method
+     */
+    crash(err: Error): never;
+    /**
+     * A function that is called on every throw,
+     * If and only if the command is not handled properly
+     * @param error
+     */
+    updateAlive(error: Error): void;
+
+    /**
+     * This callback is called if a module  
+     * handles onError with type 'fail'
+     *
+     */
+    handleError(error: Error): void;
+
+}
--- a/src/core/contracts/index.ts
+++ b/src/core/contracts/index.ts
@@ -0,0 +1,7 @@
+export * from './error-handling';
+export * from './logging';
+export * from './module-manager';
+export * from './module-store';
+export * from './init';
+export * from './emitter';
+export * from './disposable'
--- a/src/core/contracts/init.ts
+++ b/src/core/contracts/init.ts
@@ -0,0 +1,9 @@
+import type { Awaitable } from '../../types/utility';
+
+/**
+ * Represents an initialization contract.
+ * Let dependencies implement this to initiate some logic.
+ */
+export interface Init {
+    init(): Awaitable<unknown>;
+}
--- a/src/core/contracts/logging.ts
+++ b/src/core/contracts/logging.ts
@@ -0,0 +1,11 @@
+/**
+ * @since 2.0.0
+ */
+export interface Logging<T = unknown> {
+    error(payload: LogPayload<T>): void;
+    warning(payload: LogPayload<T>): void;
+    info(payload: LogPayload<T>): void;
+    debug(payload: LogPayload<T>): void;
+}
+
+export type LogPayload<T = unknown> = { message: T };
--- a/src/core/contracts/module-manager.ts
+++ b/src/core/contracts/module-manager.ts
@@ -0,0 +1,32 @@
+import type {
+    CommandMeta,
+    CommandModule,
+    CommandModuleDefs,
+    Module,
+    OnError,
+} from '../../types/core-modules';
+import { CommandType } from '../structures';
+
+interface MetadataAccess {
+    getMetadata(m: Module): CommandMeta | undefined;
+    setMetadata(m: Module, c: CommandMeta): void;
+}
+
+interface OnErrorAccess {
+    getErrorCallback(m: Module): OnError;
+    setErrorCallback(m: Module, c: NonNullable<OnError>): void;
+}
+/**
+ * @since 2.0.0
+ * @internal - direct access to the module manager will be removed in version 4
+ */
+export interface ModuleManager extends MetadataAccess, OnErrorAccess {
+    get(id: string): string | undefined;
+
+    set(id: string, path: string): void;
+    getPublishableCommands(): Promise<CommandModule[]>;
+    getByNameCommandType<T extends CommandType>(
+        name: string,
+        commandType: T,
+    ): Promise<CommandModuleDefs[T]> | undefined;
+}
--- a/src/core/contracts/module-store.ts
+++ b/src/core/contracts/module-store.ts
@@ -0,0 +1,10 @@
+import type { CommandMeta, Module, OnError } from '../../types/core-modules';
+
+/**
+ * Represents a core module store that stores IDs mapped to file paths.
+ */
+export interface CoreModuleStore {
+    commands: Map<string, string>;
+    metadata: WeakMap<Module, CommandMeta>;
+    onError: WeakMap<Module, NonNullable<OnError>>;
+}
--- a/src/core/create-plugins.ts
+++ b/src/core/create-plugins.ts
@@ -0,0 +1,62 @@
+import { CommandType, EventType, PluginType } from './structures';
+import type { Plugin, PluginResult, EventArgs, CommandArgs } from '../types/core-plugin';
+import type { ClientEvents } from 'discord.js';
+
+export function makePlugin<V extends unknown[]>(
+    type: PluginType,
+    execute: (...args: any[]) => any,
+): Plugin<V> {
+    return {
+        type,
+        execute,
+    } as Plugin<V>;
+}
+/**
+ * @since 2.5.0
+ * @__PURE__
+ */
+export function EventInitPlugin<I extends EventType>(
+    execute: (...args: EventArgs<I, PluginType.Init>) => PluginResult,
+) {
+    return makePlugin(PluginType.Init, execute);
+}
+/**
+ * @since 2.5.0
+ * @__PURE__
+ */
+export function CommandInitPlugin<I extends CommandType>(
+    execute: (...args: CommandArgs<I, PluginType.Init>) => PluginResult,
+) {
+    return makePlugin(PluginType.Init, execute);
+}
+/**
+ * @since 2.5.0
+ * @__PURE__
+ */
+export function CommandControlPlugin<I extends CommandType>(
+    execute: (...args: CommandArgs<I, PluginType.Control>) => PluginResult,
+) {
+    return makePlugin(PluginType.Control, execute);
+}
+/**
+ * @since 2.5.0
+ * @__PURE__
+ */
+export function EventControlPlugin<I extends EventType>(
+    execute: (...args: EventArgs<I, PluginType.Control>) => PluginResult,
+) {
+    return makePlugin(PluginType.Control, execute);
+}
+
+/**
+ * @since 2.5.0
+ * @Experimental
+ * A specialized function for creating control plugins with discord.js ClientEvents.
+ * Will probably be moved one day!
+ */
+export function DiscordEventControlPlugin<T extends keyof ClientEvents>(
+    name: T,
+    execute: (...args: ClientEvents[T]) => PluginResult,
+) {
+    return makePlugin(PluginType.Control, execute);
+}
--- a/src/core/functions.ts
+++ b/src/core/functions.ts
@@ -1,45 +1,31 @@
-import type { Module, SernAutocompleteData, SernOptionsData } from '../types/core-modules';
-import type {
-    AnySelectMenuInteraction,
-    ButtonInteraction,
-    ChatInputCommandInteraction,
-    MessageContextMenuCommandInteraction,
-    ModalSubmitInteraction,
-    UserContextMenuCommandInteraction,
-    AutocompleteInteraction
-} from 'discord.js';
-import { ApplicationCommandOptionType, InteractionType } from 'discord.js';
-import { PluginType } from './structures/enums';
+import { Err, Ok } from 'ts-results-es';
+import { ApplicationCommandOptionType, AutocompleteInteraction } from 'discord.js';
+import type { SernAutocompleteData, SernOptionsData } from '../types/core-modules';
+import type { AnyCommandPlugin, AnyEventPlugin, Plugin } from '../types/core-plugin';
+import { PluginType } from './structures';
 import assert from 'assert';
-import type { Payload } from '../types/utility';

-/**
- * Removes the first character(s) _[depending on prefix length]_ of the message
- * @param msg
- * @param prefix The prefix to remove
- * @returns The message without the prefix
- * @example
- * message.content = '!ping';
- * console.log(fmt(message.content, '!'));
- * // [ 'ping' ]
- */
-export function fmt(msg: string, prefix?: string): string[] {
-    if(!prefix) throw Error("Unable to parse message without prefix");
-    return msg.slice(prefix.length).trim().split(/\s+/g);
-}
+//function wrappers for empty ok / err
+export const ok = /* @__PURE__*/ () => Ok.EMPTY;
+export const err = /* @__PURE__*/ () => Err.EMPTY;

-
-export function partitionPlugins<T,V>
-(arr: Array<{ type: PluginType }> = []): [T[], V[]] {
+export function partitionPlugins(
+    arr: (AnyEventPlugin | AnyCommandPlugin)[] = [],
+): [Plugin[], Plugin[]] {
    const controlPlugins = [];
    const initPlugins = [];
+
    for (const el of arr) {
        switch (el.type) {
-            case PluginType.Control: controlPlugins.push(el); break;
-            case PluginType.Init: initPlugins.push(el); break;
+            case PluginType.Control:
+                controlPlugins.push(el);
+                break;
+            case PluginType.Init:
+                initPlugins.push(el);
+                break;
        }
    }
-    return [controlPlugins, initPlugins] as [T[], V[]];
+    return [controlPlugins, initPlugins];
 }

 /**
@@ -54,73 +40,44 @@ export function treeSearch(
    if (options === undefined) return undefined;
    //clone to prevent mutation of original command module
    const _options = options.map(a => ({ ...a }));
-    const subcommands = new Set();
+    let subcommands = new Set();
    while (_options.length > 0) {
        const cur = _options.pop()!;
        switch (cur.type) {
-            case ApplicationCommandOptionType.Subcommand: {
+            case ApplicationCommandOptionType.Subcommand:
+                {
                    subcommands.add(cur.name);
                    for (const option of cur.options ?? []) _options.push(option);
-                } break;
-            case ApplicationCommandOptionType.SubcommandGroup: {
+                }
+                break;
+            case ApplicationCommandOptionType.SubcommandGroup:
+                {
                    for (const command of cur.options ?? []) _options.push(command);
-                } break;
-            default: {
-                if ('autocomplete' in cur && cur.autocomplete) {
-                    const choice = iAutocomplete.options.getFocused(true);
-                    assert( 'command' in cur, 'No `command` property found for option ' + cur.name);
-                    if (subcommands.size > 0) {
-                        const parent = iAutocomplete.options.getSubcommand();
-                        const parentAndOptionMatches =
-                            subcommands.has(parent) && cur.name === choice.name;
-                        if (parentAndOptionMatches) {
-                            return { ...cur, parent };
-                        }
-                    } else {
-                        if (cur.name === choice.name) {
-                            return { ...cur, parent: undefined };
+                }
+                break;
+            default:
+                {
+                    if ('autocomplete' in cur && cur.autocomplete) {
+                        const choice = iAutocomplete.options.getFocused(true);
+                        assert(
+                            'command' in cur,
+                            'No command property found for autocomplete option',
+                        );
+                        if (subcommands.size > 0) {
+                            const parent = iAutocomplete.options.getSubcommand();
+                            const parentAndOptionMatches =
+                                subcommands.has(parent) && cur.name === choice.name;
+                            if (parentAndOptionMatches) {
+                                return { ...cur, parent };
+                            }
+                        } else {
+                            if (cur.name === choice.name) {
+                                return { ...cur, parent: undefined };
+                            }
                        }
                    }
                }
-            } break;
+                break;
        }
    }
 }
-
-
-interface InteractionTypable {
-    type: InteractionType;
-}
-//discord.js pls fix ur typings or i will >:(
-type AnyMessageComponentInteraction = AnySelectMenuInteraction | ButtonInteraction;
-type AnyCommandInteraction =
-    | ChatInputCommandInteraction
-    | MessageContextMenuCommandInteraction
-    | UserContextMenuCommandInteraction;
-
-export function isMessageComponent(i: InteractionTypable): i is AnyMessageComponentInteraction {
-    return i.type === InteractionType.MessageComponent;
-}
-export function isCommand(i: InteractionTypable): i is AnyCommandInteraction {
-    return i.type === InteractionType.ApplicationCommand;
-}
-export function isAutocomplete(i: InteractionTypable): i is AutocompleteInteraction {
-    return i.type === InteractionType.ApplicationCommandAutocomplete;
-}
-
-export function isModal(i: InteractionTypable): i is ModalSubmitInteraction {
-    return i.type === InteractionType.ModalSubmit;
-}
-
-export function resultPayload<T extends 'success'|'warning'|'failure'>
-(type: T, module?: Module, reason?: unknown) {
-    return { type, module, reason } as Payload & { type : T };
-}
-
-export function pipe<T>(arg: unknown, firstFn: Function, ...fns: Function[]): T {
-  let result = firstFn(arg);
-  for (let fn of fns) {
-    result = fn(result);
-  }
-  return result;
-}
--- a/src/core/id.ts
+++ b/src/core/id.ts
@@ -1,33 +1,23 @@
-import { ApplicationCommandType, ComponentType, type Interaction, InteractionType } from 'discord.js';
-import { CommandType, EventType } from './structures/enums';
+import { ApplicationCommandType, ComponentType, Interaction, InteractionType } from 'discord.js';
+import { CommandType, EventType } from './structures';

-const parseParams = (event: { customId: string }, append: string) => {
-    const hasSlash = event.customId.indexOf('/')
-    if(hasSlash === -1) {
-        return { id:event.customId+append };
-    }
-    const baseid = event.customId.substring(0, hasSlash);
-    const params = event.customId.substring(hasSlash+1);
-    return { id: baseid+append, params }
-}
 /**
 * Construct unique ID for a given interaction object.
 * @param event The interaction object for which to create an ID.
- * @returns An array of unique string IDs based on the type and properties of the interaction object.
+ * @returns A unique string ID based on the type and properties of the interaction object.
 */
 export function reconstruct<T extends Interaction>(event: T) {
    switch (event.type) {
        case InteractionType.MessageComponent: {
-            const data = parseParams(event, `_C${event.componentType}`)
-            return [data];
+            return `${event.customId}_C${event.componentType}`;
        }
        case InteractionType.ApplicationCommand:
-        case InteractionType.ApplicationCommandAutocomplete: 
-            return [{ id: `${event.commandName}_A${event.commandType}` }, { id: `${event.commandName}_B` }];
+        case InteractionType.ApplicationCommandAutocomplete: {
+            return `${event.commandName}_A${event.commandType}`;
+        }
        //Modal interactions are classified as components for sern
        case InteractionType.ModalSubmit: {
-            const data = parseParams(event, '_M');
-            return [data];
+            return `${event.customId}_C1`;
        }
    }
 }
@@ -35,40 +25,39 @@ export function reconstruct<T extends Interaction>(event: T) {
 *
 * A magic number to represent any commandtype that is an ApplicationCommand.
 */
-const PUBLISHABLE = 0b000000001111;
+const appBitField = 0b000000001111;

-
-const TypeMap = new Map<number, number>([[CommandType.Text, 0],
-                                        [CommandType.Both, 0],
-                                        [CommandType.Slash, ApplicationCommandType.ChatInput],
-                                        [CommandType.CtxUser, ApplicationCommandType.User],
-                                        [CommandType.CtxMsg, ApplicationCommandType.Message],
-                                        [CommandType.Button, ComponentType.Button],
-                                        [CommandType.StringSelect, ComponentType.StringSelect],
-                                        [CommandType.Modal, InteractionType.ModalSubmit],
-                                        [CommandType.UserSelect, ComponentType.UserSelect],
-                                        [CommandType.MentionableSelect, ComponentType.MentionableSelect],
-                                        [CommandType.RoleSelect, ComponentType.RoleSelect],
-                                        [CommandType.ChannelSelect, ComponentType.ChannelSelect]]);
+// Each index represents the exponent of a CommandType.
+// Every CommandType is a power of two.
+export const CommandTypeDiscordApi = [
+    1, // CommandType.Text
+    ApplicationCommandType.ChatInput,
+    ApplicationCommandType.User,
+    ApplicationCommandType.Message,
+    ComponentType.Button,
+    ComponentType.StringSelect,
+    1, //  CommandType.Modal
+    ComponentType.UserSelect,
+    ComponentType.RoleSelect,
+    ComponentType.MentionableSelect,
+    ComponentType.ChannelSelect,
+];
+/*
+ * Generates a number based on CommandType.
+ * This corresponds to an ApplicationCommandType or ComponentType
+ * TextCommands are 0 as they aren't either or.
+ */
+function apiType(t: CommandType | EventType) {
+    if (t === CommandType.Both || t === CommandType.Modal) return 1;
+    return CommandTypeDiscordApi[Math.log2(t)];
+}

 /*
 * Generates an id based on name and CommandType.
 * A is for any ApplicationCommand. C is for any ComponentCommand
- * Then, another number fetched from TypeMap
+ * Then, another number generated by apiType function is appended
 */
 export function create(name: string, type: CommandType | EventType) {
-    if(type == CommandType.Text) {
-        return `${name}_T`;
-    }
-    if(type == CommandType.Both) {
-        return `${name}_B`;
-    }
-    if(type == CommandType.Modal) {
-        return `${name}_M`;
-    }
-    const am = (PUBLISHABLE & type) !== 0 ? 'A' : 'C';
-    return `${name}_${am}${TypeMap.get(type)!}`
+    const am = (appBitField & type) !== 0 ? 'A' : 'C';
+    return name + '_' + am + apiType(type);
 }
-
-
-
--- a/src/core/index.ts
+++ b/src/core/index.ts
@@ -0,0 +1,4 @@
+export * from './contracts';
+export * from './create-plugins';
+export * from './structures';
+export * from './ioc';
--- a/src/core/interfaces.ts
+++ b/src/core/interfaces.ts
@@ -1,55 +0,0 @@
-import type { AnyFunction } from '../types/utility';
-
-
-/**
- * Represents an initialization contract.
- * Let dependencies implement this to initiate some logic.
- */
-export interface Init {
-    init(): unknown;
-}
-
-/**
- * Represents a Disposable contract.
- * Let dependencies implement this to dispose and cleanup.
- */
-export interface Disposable {
-    dispose(): unknown;
-}
-
-
-export interface Emitter {
-    addListener(eventName: string | symbol, listener: AnyFunction): this;
-    removeListener(eventName: string | symbol, listener: AnyFunction): this;
-    emit(eventName: string | symbol, ...payload: any[]): boolean;
-}
-
-
-/**
- * @since 2.0.0
- */
-export interface ErrorHandling {
-    /**
-     * @deprecated
-     * Version 4 will remove this method
-     */
-    crash(err: Error): never;
-    /**
-     * A function that is called on every throw.
-     * @param error
-     */
-    updateAlive(error: Error): void;
-
-}
-
-/**
- * @since 2.0.0
- */
-export interface Logging<T = unknown> {
-    error(payload: LogPayload<T>): void;
-    warning(payload: LogPayload<T>): void;
-    info(payload: LogPayload<T>): void;
-    debug(payload: LogPayload<T>): void;
-}
-
-export type LogPayload<T = unknown> = { message: T };
--- a/src/core/ioc.ts
+++ b/src/core/ioc.ts
@@ -1,163 +0,0 @@
-import { Service as $Service, Services as $Services } from '@sern/ioc/global'
-import { Container } from '@sern/ioc';
-import * as Contracts from './interfaces';
-import * as  __Services from './structures/default-services';
-import type { Logging } from './interfaces';
-import { __init_container, useContainerRaw } from '@sern/ioc/global';
-import { EventEmitter } from 'node:events';
-import { Client } from 'discord.js';
-import { Module } from '../types/core-modules';
-import { UnpackFunction } from '../types/utility';
-
-export function disposeAll(logger: Logging|undefined) {
-   useContainerRaw() 
-        ?.disposeAll()
-        .then(() => logger?.info({ message: 'Cleaning container and crashing' }));
-}
-
-type Insertable = | ((container: Dependencies) => object)
-                  | object
-
-const dependencyBuilder = (container: Container) => {
-    return {
-        /**
-          * Insert a dependency into your container.
-          * Supply the correct key and dependency
-          */
-        add(key: keyof Dependencies, v: Insertable) {
-            if(typeof v !== 'function') {
-                container.addSingleton(key, v)
-            } else {
-                //@ts-ignore
-                container.addWiredSingleton(key, (cntr) => v(cntr))
-            }
-        },
-        /**
-          * @param key the key of the dependency
-          * @param v The dependency to swap out.
-          * Swap out a preexisting dependency.
-          */
-        swap(key: keyof Dependencies, v: Insertable) {
-            if(typeof v !== 'function') {
-                container.swap(key, v);
-            } else {
-                container.swap(key, v(container.deps()));
-            }
-        },
-   };
-};
-
-type ValidDependencyConfig =
-    (c: ReturnType<typeof dependencyBuilder>) => any
-
-/**
-  * makeDependencies constructs a dependency injection container for sern handler to use.
-  * This is required to start the handler, and is to be called before Sern.init.
-  * @example
-  * ```ts
-  * await makeDependencies(({ add }) => {
-  *     add('@sern/client', new Client({ intents, partials }) 
-  * })
-  * ```
-  */
-export async function makeDependencies (conf: ValidDependencyConfig) {
-    const container = await __init_container({ autowire: false });
-    //We only include logger if it does not exist 
-    const includeLogger = !container.hasKey('@sern/logger');
-
-    if(includeLogger) {
-        container.addSingleton('@sern/logger', new __Services.DefaultLogging);
-    }
-    container.addSingleton('@sern/errors', new __Services.DefaultErrorHandling);
-    container.addSingleton('@sern/modules', new Map);
-    container.addSingleton('@sern/emitter', new EventEmitter)
-    container.addSingleton('@sern/scheduler', new __Services.TaskScheduler)
-    conf(dependencyBuilder(container));
-    await container.ready();
-}
-
-
-/**
- * The Service api, which allows users to access dependencies in places IOC cannot reach. 
- * To obtain intellisense, ensure a .d.ts file exists in the root of compilation.
- * Our scaffolding tool takes care of this.
- * Note: this method only works AFTER your container has been initiated
- * @since 3.0.0
- * @example
- * ```ts
- * const client = Service('@sern/client');
- * ```
- * @param key a key that corresponds to a dependency registered.
- * @throws if container is absent or not present
- */
-export function Service<const T extends keyof Dependencies>(key: T) {
-    return $Service(key) as Dependencies[T]
-}
-/**
- * @since 3.0.0
- * The plural version of {@link Service}
- * @throws if container is absent or not present
- * @returns array of dependencies, in the same order of keys provided
- *
- */
-export function Services<const T extends (keyof Dependencies)[]>(...keys: [...T]) {
-    return $Services<T, IntoDependencies<T>>(...keys)
-}
-
-/**
- * @deprecated
- * Creates a singleton object.
- * @param cb
- */
-export function single<T>(cb: () => T) { 
-    console.log('The `single` function is deprecated and has no effect')
-    return cb(); 
-}
-
-/**
- * @deprecated
- * @since 2.0.0
- * Creates a transient object
- * @param cb
- */
-export function transient<T>(cb: () => () => T) { 
-    console.log('The `transient` function is deprecated and has no effect')
-    return cb()(); 
-}
-
-export type DependencyFromKey<T extends keyof Dependencies> = Dependencies[T];
-
-
-
-export type IntoDependencies<Tuple extends [...any[]]> = {
-    [Index in keyof Tuple]: UnpackFunction<NonNullable<DependencyFromKey<Tuple[Index]>>>; //Unpack and make NonNullable
-} & { length: Tuple['length'] };
-
-export interface CoreDependencies {
-    /**
-      * discord.js client.
-      */
-    '@sern/client':  Client;
-    /**
-      * sern emitter listens to events that happen throughout
-      * the handler. some include module.register, module.activate.
-      */
-    '@sern/emitter': Contracts.Emitter;
-    /**
-      * An error handler which is the final step before 
-      * the sern process actually crashes.
-      */
-    '@sern/errors':  Contracts.ErrorHandling;
-    /**
-      * Optional logger. Performs ... logging
-      */
-    '@sern/logger'?: Contracts.Logging;
-    /**
-      * Readonly module store. sern stores these 
-      * by module.meta.id -> Module
-      */
-    '@sern/modules': Map<string, Module>;
-
-    '@sern/scheduler': __Services.TaskScheduler
-}
-
--- a/src/core/ioc/base.ts
+++ b/src/core/ioc/base.ts
@@ -0,0 +1,36 @@
+import * as assert from 'assert';
+import { composeRoot, useContainer } from './dependency-injection';
+import type { DependencyConfiguration } from '../../types/ioc';
+import { CoreContainer } from './container';
+
+//SIDE EFFECT: GLOBAL DI
+let containerSubject: CoreContainer<Partial<Dependencies>>;
+
+/**
+ * @deprecated
+ * Returns the underlying data structure holding all dependencies.
+ * Exposes methods from iti
+ * Use the Service API. The container should be readonly
+ */
+export function useContainerRaw() {
+    assert.ok(
+        containerSubject && containerSubject.isReady(),
+        "Could not find container or container wasn't ready. Did you call makeDependencies?",
+    );
+    return containerSubject;
+}
+
+/**
+ * @since 2.0.0
+ * @param conf a configuration for creating your project dependencies
+ */
+export async function makeDependencies<const T extends Dependencies>(
+    conf: DependencyConfiguration,
+) {
+    //Until there are more optional dependencies, just check if the logger exists
+    //SIDE EFFECT
+    containerSubject = new CoreContainer();
+    await composeRoot(containerSubject, conf);
+
+    return useContainer<T>();
+}
--- a/src/core/ioc/container.ts
+++ b/src/core/ioc/container.ts
@@ -0,0 +1,60 @@
+import { Container } from 'iti';
+import { Disposable, SernEmitter } from '../';
+import * as assert from 'node:assert';
+import { Subject } from 'rxjs';
+import { DefaultServices, ModuleStore } from '../_internal';
+import * as Hooks from './hooks'
+
+
+/**
+ * A semi-generic container that provides error handling, emitter, and module store. 
+ * For the handler to operate correctly, The only user provided dependency needs to be @sern/client
+ */
+export class CoreContainer<T extends Partial<Dependencies>> extends Container<T, {}> {
+    private ready$ = new Subject<void>();
+    constructor() {
+        super();
+        assert.ok(!this.isReady(), 'Listening for dispose & init should occur prior to sern being ready.');
+
+        const { unsubscribe } = Hooks.createInitListener(this);
+        this.ready$
+            .subscribe({ complete: unsubscribe });
+
+        (this as Container<{}, {}>)
+            .add({
+                '@sern/errors': () => new DefaultServices.DefaultErrorHandling(),
+                '@sern/emitter': () => new SernEmitter(),
+                '@sern/store': () => new ModuleStore(),
+            })
+            .add(ctx => {
+                return {
+                    '@sern/modules': () =>
+                        new DefaultServices.DefaultModuleManager(ctx['@sern/store']),
+                };
+            });
+    }
+
+
+    isReady() {
+
+        return this.ready$.closed;
+    }
+    override async disposeAll() {
+        
+        const otherDisposables = Object
+            .entries(this._context)
+            .flatMap(([key, value]) => 
+                'dispose' in value
+                    ? [key]
+                    : []);
+
+        for(const key of otherDisposables) {
+            this.addDisposer({ [key]: (dep: Disposable) => dep.dispose() } as never);
+        }
+        await super.disposeAll() 
+    }
+    ready() {
+        this.ready$.complete();
+        this.ready$.unsubscribe();
+    }
+}
--- a/src/core/ioc/dependency-injection.ts
+++ b/src/core/ioc/dependency-injection.ts
@@ -0,0 +1,80 @@
+import type { CoreDependencies, DependencyConfiguration, IntoDependencies } from '../../types/ioc';
+import { DefaultServices } from '../_internal';
+import { useContainerRaw } from './base';
+import { CoreContainer } from './container';
+
+/**
+ * @__PURE__
+ * @since 2.0.0.
+ * Creates a singleton object.
+ * @param cb
+ */
+export function single<T>(cb: () => T) {
+    return cb;
+}
+
+/**
+ * @__PURE__
+ * @since 2.0.0
+ * Creates a transient object
+ * @param cb
+ */
+export function transient<T>(cb: () => () => T) {
+    return cb;
+}
+/**
+ * The new Service api, a cleaner alternative to useContainer
+ * To obtain intellisense, ensure a .d.ts file exists in the root of compilation.
+ * Usually our scaffolding tool takes care of this.
+ * @since 3.0.0
+ * @example
+ * ```ts
+ * const client = Service('@sern/client');
+ * ```
+ * @param key a key that corresponds to a dependency registered.
+ *
+ */
+export function Service<const T extends keyof Dependencies>(key: T) {
+    return useContainerRaw().get(key)!;
+}
+/**
+ * @since 3.0.0
+ * The plural version of {@link Service}
+ * @returns array of dependencies, in the same order of keys provided
+ */
+export function Services<const T extends (keyof Dependencies)[]>(...keys: [...T]) {
+    const container = useContainerRaw();
+    return keys.map(k => container.get(k)!) as IntoDependencies<T>;
+}
+
+/**
+ * Given the user's conf, check for any excluded dependency keys.
+ * Then, call conf.build to get the rest of the users' dependencies.
+ * Finally, update the containerSubject with the new container state
+ * @param conf
+ */
+export async function composeRoot(
+    container: CoreContainer<Partial<Dependencies>>,
+    conf: DependencyConfiguration,
+) {
+    //container should have no client or logger yet.
+    const hasLogger = conf.exclude?.has('@sern/logger');
+    if (!hasLogger) {
+        container.upsert({
+            '@sern/logger': () => new DefaultServices.DefaultLogging(),
+        });
+    }
+    //Build the container based on the callback provided by the user
+    conf.build(container as CoreContainer<Omit<CoreDependencies, '@sern/client'>>);
+    
+    if (!hasLogger) {
+        container.get('@sern/logger')?.info({ message: 'All dependencies loaded successfully.' });
+    }
+
+    container.ready();
+}
+
+export function useContainer<const T extends Dependencies>() {
+    return <V extends (keyof T)[]>(...keys: [...V]) =>
+        keys.map(key => useContainerRaw().get(key as keyof Dependencies)) as IntoDependencies<V>;
+}
--- a/src/core/ioc/hooks.ts
+++ b/src/core/ioc/hooks.ts
@@ -0,0 +1,40 @@
+import type { CoreContainer } from "./container"
+
+interface HookEvent { 
+    key : PropertyKey
+    newContainer: any
+}
+type HookName = 'init';
+
+export const createInitListener = (coreContainer : CoreContainer<any>) => {
+    const initCalled = new Set<PropertyKey>();
+    const hasCallableMethod = createPredicate(initCalled);
+    const unsubscribe = coreContainer.on('containerUpserted', async (event) => {
+       
+        if(isNotHookable(event)) {
+            return;
+        }
+
+        if(hasCallableMethod('init', event)) {
+            await event.newContainer?.init();
+            initCalled.add(event.key);
+        }
+
+    });
+    return { unsubscribe };
+}
+
+const isNotHookable = (hk: HookEvent) => {
+    return typeof hk.newContainer !== 'object' 
+        || Array.isArray(hk.newContainer) 
+        || hk.newContainer === null;
+}
+
+const createPredicate = <T extends HookEvent>(called: Set<PropertyKey>) => {
+    return (hookName: HookName, event: T) => {
+        const hasMethod = Reflect.has(event.newContainer!, hookName);
+        const beenCalledOnce = !called.has(event.key)
+
+        return hasMethod && beenCalledOnce
+    }
+}
--- a/src/core/ioc/index.ts
+++ b/src/core/ioc/index.ts
@@ -0,0 +1,2 @@
+export { makeDependencies } from './base';
+export { Service, Services, single, transient } from './dependency-injection';
--- a/src/core/module-loading.ts
+++ b/src/core/module-loading.ts
@@ -1,26 +1,13 @@
-import path from 'node:path';
-import { existsSync } from 'node:fs';
-import { readdir } from 'fs/promises';
-import assert from 'node:assert';
-import * as Id from './id'
-import { Module } from '../types/core-modules';
-
-export const parseCallsite = (site: string) => {
-    const pathobj = path.posix.parse(site.replace(/file:\\?/, "")
-                                   .split(path.sep)
-                                   .join(path.posix.sep))
-    return { name: pathobj.name,
-             absPath : path.posix.format(pathobj) }
-}
-
-export const shouldHandle = (pth: string, filenam: string) => {
-    const file_name = filenam+path.extname(pth);
-    let newPath = path.join(path.dirname(pth), file_name)
-                      .replace(/file:\\?/, "");
-    return { exists: existsSync(newPath),
-             path: 'file://'+newPath };
-}
+import { Result } from 'ts-results-es';
+import { type Observable, from, mergeMap, ObservableInput } from 'rxjs';
+import { readdir, stat } from 'fs/promises';
+import { basename, extname, join, resolve, parse } from 'path';
+import assert from 'assert';
+import { createRequire } from 'node:module';
+import type { ImportPayload, Wrapper } from '../types/core';
+import type { Module, OnError } from '../types/core-modules';

+export type ModuleResult<T> = Promise<ImportPayload<T>>;

 /**
 * Import any module based on the absolute path.
@@ -28,6 +15,7 @@ export const shouldHandle = (pth: string, filenam: string) => {
 * commonjs, javascript :
 * ```js
 * exports = commandModule({ })
+ *
 * //or
 * exports.default = commandModule({ })
 * ```
@@ -37,34 +25,107 @@ export const shouldHandle = (pth: string, filenam: string) => {
 export async function importModule<T>(absPath: string) {
    let fileModule = await import(absPath);

-    let commandModule: Module = fileModule.default;
+    let commandModule = fileModule.default, 
+        onError = fileModule.onError;

-    assert(commandModule , `No default export @ ${absPath}`);
-    if ('default' in commandModule) {
-        commandModule = commandModule.default as Module;
+    assert(commandModule , `Found no export @ ${absPath}. Forgot to ignore with "!"? (!${basename(absPath)})?`);
+    if ('default' in commandModule ) {
+        commandModule = commandModule.default;
    }
-    const p = path.parse(absPath)
-    commandModule.name ??= p.name; commandModule.description ??= "...";
-    commandModule.meta = {
-        id: Id.create(commandModule.name, commandModule.type),
-        absPath,
+    return Result
+        .wrap(() => ({ module: commandModule.getInstance(), onError }))
+        .unwrapOr({ module: commandModule, onError }) as T;
+}
+interface FileExtras { 
+    onError : OnError
+}
+
+export async function defaultModuleLoader<T extends Module>(absPath: string): ModuleResult<T> {
+    let { onError, module } = await importModule<{ module: T } & FileExtras>(absPath);
+    assert(module, `Found an undefined module: ${absPath}`);
+    return { module, absPath, onError };
+}
+
+export const fmtFileName = (fileName: string) => parse(fileName).name;
+
+/**
+ * a directory string is converted into a stream of modules.
+ * starts the stream of modules that sern needs to process on init
+ * @returns {Observable<{ mod: Module; absPath: string; }[]>} data from command files
+ * @param commandDir
+ */
+export function buildModuleStream<T extends Module>(
+    input: ObservableInput<string>,
+): Observable<ImportPayload<T>> {
+    return from(input)
+        .pipe(mergeMap(defaultModuleLoader<T>));
+}
+
+export const getFullPathTree = (dir: string) => readPaths(resolve(dir));
+
+export const filename = (path: string) => fmtFileName(basename(path));
+
+const isSkippable = (filename: string) => {
+    //empty string is for non extension files (directories)
+    const validExtensions = ['.js', '.cjs', '.mts', '.mjs', '.cts', '.ts', ''];
+    return filename[0] === '!' || !validExtensions.includes(extname(filename));
+};
+async function deriveFileInfo(dir: string, file: string) {
+    const fullPath = join(dir, file);
+    return {
+        fullPath,
+        fileStats: await stat(fullPath),
+        base: basename(file),
    };
-    return { module: commandModule as T };
 }
-
-
-export async function* readRecursive(dir: string): AsyncGenerator<string> {
-    const files = await readdir(dir, { withFileTypes: true });
-    for (const file of files) {
-        const fullPath = path.posix.join(dir, file.name);
-        if (file.isDirectory()) {
-            if (!file.name.startsWith('!')) {
-                yield* readRecursive(fullPath);
+async function* readPaths(dir: string): AsyncGenerator<string> {
+    try {
+        const files = await readdir(dir);
+        for (const file of files) {
+            const { fullPath, fileStats, base } = await deriveFileInfo(dir, file);
+            if (fileStats.isDirectory()) {
+                //Todo: refactor so that i dont repeat myself for files (line 71)
+                if (!isSkippable(base)) {
+                    yield* readPaths(fullPath);
+                }
+            } else {
+                if (!isSkippable(base)) {
+                    yield 'file:///' + fullPath;
+                }
            }
-        } else if (!file.name.startsWith('!')) {
-            yield "file:///"+path.resolve(fullPath);
        }
+    } catch (err) {
+        throw err;
    }
 }

+const requir = createRequire(import.meta.url);

+export function loadConfig(wrapper: Wrapper | 'file'): Wrapper {
+    if (wrapper !== 'file') {
+        return wrapper;
+    }
+    console.log('Experimental loading of sern.config.json');
+    const config = requir(resolve('sern.config.json')); 
+
+    const makePath = (dir: PropertyKey) =>
+        config.language === 'typescript'
+            ? join('dist', config.paths[dir]!)
+            : join(config.paths[dir]!);
+ 
+    console.log('Loading config: ', config);
+    const commandsPath = makePath('commands');
+ 
+    console.log('Commands path is set to', commandsPath);
+    let eventsPath: string | undefined;
+    if (config.paths.events) {
+        eventsPath = makePath('events');
+        console.log('Events path is set to', eventsPath);
+    }
+    return {
+        defaultPrefix: config.defaultPrefix,
+        commands: commandsPath,
+        events: eventsPath,
+    };
+    
+}
--- a/src/core/modules.ts
+++ b/src/core/modules.ts
@@ -1,51 +1,112 @@
-import type { ClientEvents } from 'discord.js';
-import { EventType } from '../core/structures/enums';
+import { ClientEvents } from 'discord.js';
+import { CommandType, EventType, PluginType } from '../core/structures';
 import type {
+    AnyCommandPlugin,
+    AnyEventPlugin,
+    CommandArgs,
+    ControlPlugin,
+    EventArgs,
+    InitPlugin,
+} from '../types/core-plugin';
+import type {
+    CommandModule,
+    EventModule,
    InputCommand,
    InputEvent,
    Module,
-    ScheduledTask,
 } from '../types/core-modules';
-import { partitionPlugins } from './functions'
+import { partitionPlugins } from './_internal';
 import type { Awaitable } from '../types/utility';

 /**
 * @since 1.0.0 The wrapper function to define command modules for sern
 * @param mod
 */
-export function commandModule(mod: InputCommand): Module {
+export function commandModule(mod: InputCommand): CommandModule {
    const [onEvent, plugins] = partitionPlugins(mod.plugins);
-    return { ...mod,
-             onEvent,
-             plugins,
-             locals: {} } as Module;
+    return {
+        ...mod,
+        onEvent,
+        plugins,
+    } as CommandModule;
 }
-
 /**
 * @since 1.0.0
 * The wrapper function to define event modules for sern
 * @param mod
 */
-export function eventModule(mod: InputEvent): Module {
+export function eventModule(mod: InputEvent): EventModule {
    const [onEvent, plugins] = partitionPlugins(mod.plugins);
-    if(onEvent.length !== 0) throw Error("Event modules cannot have ControlPlugins");
-    return { ...mod,
-             plugins,
-             locals: {} } as Module;
+    return {
+        ...mod,
+        plugins,
+        onEvent,
+    } as EventModule;
 }

 /** Create event modules from discord.js client events,
 * This is an {@link eventModule} for discord events,
 * where typings can be very bad.
+ * @Experimental
 * @param mod
 */
 export function discordEvent<T extends keyof ClientEvents>(mod: {
    name: T;
-    once?: boolean;
+    plugins?: AnyEventPlugin[];
    execute: (...args: ClientEvents[T]) => Awaitable<unknown>;
 }) {
-    return eventModule({ type: EventType.Discord, ...mod, });
+    return eventModule({
+        type: EventType.Discord,
+        ...mod,
+    });
 }

-export function scheduledTask(ism: ScheduledTask) { return ism }
+function prepareClassPlugins(c: Module) {
+    const [onEvent, initPlugins] = partitionPlugins(c.plugins);
+    c.plugins = initPlugins as InitPlugin[];
+    c.onEvent = onEvent as ControlPlugin[];
+}
+//
+// Class modules:
+// Can be refactored.
+// Both implement singleton, could I make them inherit a singleton parent class?
+/**
+ * @Experimental
+ * Will be refactored / changed in future
+ */
+export abstract class CommandExecutable<const Type extends CommandType = CommandType> {
+    abstract type: Type;
+    plugins: AnyCommandPlugin[] = [];
+    private static _instance: CommandModule;

+    static getInstance() {
+        if (!CommandExecutable._instance) {
+            //@ts-ignore
+            CommandExecutable._instance = new this();
+            prepareClassPlugins(CommandExecutable._instance);
+        }
+        return CommandExecutable._instance;
+    }
+
+    abstract execute(...args: CommandArgs<Type, PluginType.Control>): Awaitable<unknown>;
+}
+
+/**
+ * @Experimental
+ * Will be refactored in future
+ */
+export abstract class EventExecutable<Type extends EventType> {
+    abstract type: Type;
+    plugins: AnyEventPlugin[] = [];
+
+    private static _instance: EventModule;
+    static getInstance() {
+        if (!EventExecutable._instance) {
+            //@ts-ignore
+            EventExecutable._instance = new this();
+            prepareClassPlugins(EventExecutable._instance);
+        }
+        return EventExecutable._instance;
+    }
+    abstract execute(...args: EventArgs<Type, PluginType.Control>): Awaitable<unknown>;
+}
--- a/src/core/operators.ts
+++ b/src/core/operators.ts
@@ -0,0 +1,86 @@
+/**
+ * This file holds sern's rxjs operators used for processing data.
+ * Each function should be modular and testable, not bound to discord / sern
+ * and independent of each other.
+ */
+import {
+    concatMap,
+    defaultIfEmpty,
+    EMPTY,
+    every,
+    fromEvent,
+    map,
+    Observable,
+    of,
+    OperatorFunction,
+    pipe,
+    share,
+} from 'rxjs';
+import { Emitter, ErrorHandling, Logging } from './contracts';
+import util from 'node:util';
+import type { PluginResult, VoidResult } from '../types/core-plugin';
+import type { Result } from 'ts-results-es'
+/**
+ * if {src} is true, mapTo V, else ignore
+ * @param item
+ */
+export function filterMapTo<V>(item: () => V): OperatorFunction<boolean, V> {
+    return concatMap(shouldKeep => (shouldKeep ? of(item()) : EMPTY));
+}
+
+/**
+ * Calls any plugin with {args}.
+ * @param args if an array, its spread and plugin called.
+ */
+export function callPlugin(args: unknown): OperatorFunction<
+    {
+        execute: (...args: unknown[]) => PluginResult;
+    },
+    VoidResult
+> {
+    return concatMap(async plugin => {
+        if (Array.isArray(args)) {
+            return plugin.execute(...args);
+        }
+        return plugin.execute(args);
+    });
+}
+
+export const arrayifySource = map(src => (Array.isArray(src) ? (src as unknown[]) : [src]));
+
+/**
+ * Checks if the stream of results is all ok.
+ */
+export const everyPluginOk: OperatorFunction<VoidResult, boolean> = pipe(
+    every(result => result.isOk()),
+    defaultIfEmpty(true),
+);
+
+export const sharedEventStream = <T>(e: Emitter, eventName: string) => {
+    return (fromEvent(e, eventName) as Observable<T>).pipe(share());
+};
+
+export function handleError<C>(crashHandler: ErrorHandling, logging?: Logging) {
+    return (pload: unknown, caught: Observable<C>) => {
+        // This is done to fit the ErrorHandling contract
+        const err = pload instanceof Error ? pload : Error(util.inspect(pload, { colors: true }));
+        //formatted payload
+        logging?.error({ message: util.inspect(pload) });
+        crashHandler.updateAlive(err);
+        return caught;
+    };
+}
+// Temporary until i get rxjs operators working on ts-results-es
+export const filterTap = <K, R>(onErr: (e: R) => void): OperatorFunction<Result<K, R>, K> => 
+    pipe(
+        concatMap(result => {
+            if(result.isOk()) {
+                return of(result.value)
+            }
+            onErr(result.error);
+            return EMPTY
+
+        })
+    )
+
+
--- a/src/core/plugin.ts
+++ b/src/core/plugin.ts
@@ -1,45 +0,0 @@
-import { CommandType, PluginType } from './structures/enums';
-import type { Plugin, PluginResult, CommandArgs, InitArgs } from '../types/core-plugin';
-import { Err, Ok } from 'ts-results-es';
-
-export function makePlugin<V extends unknown[]>(
-    type: PluginType,
-    execute: (...args: any[]) => any,
-): Plugin<V> {
-    return { type, execute } as Plugin<V>;
-}
-/**
- * @since 2.5.0
- */
-export function EventInitPlugin(execute: (args: InitArgs) => PluginResult) {
-    return makePlugin(PluginType.Init, execute);
-}
-/**
- * @since 2.5.0
- */
-export function CommandInitPlugin<I extends CommandType>(
-    execute: (args: InitArgs) => PluginResult
-) {
-    return makePlugin(PluginType.Init, execute);
-}
-/**
- * @since 2.5.0
- */
-export function CommandControlPlugin<I extends CommandType>(
-    execute: (...args: CommandArgs<I>) => PluginResult,
-) {
-    return makePlugin(PluginType.Control, execute);
-}
-
-
-/**
- * @since 1.0.0
- * The object passed into every plugin to control a command's behavior
- */
-export const controller = {
-    next: (val?: Record<string,unknown>) => Ok(val),
-    stop: (val?: string) => Err(val),
-};
-
-
-export type Controller = typeof controller;
--- a/src/core/predicates.ts
+++ b/src/core/predicates.ts
@@ -0,0 +1,34 @@
+import type {
+    AnySelectMenuInteraction,
+    AutocompleteInteraction,
+    ButtonInteraction,
+    ChatInputCommandInteraction,
+    MessageContextMenuCommandInteraction,
+    ModalSubmitInteraction,
+    UserContextMenuCommandInteraction,
+} from 'discord.js';
+import { InteractionType } from 'discord.js';
+
+interface InteractionTypable {
+    type: InteractionType;
+}
+//discord.js pls fix ur typings or i will >:(
+type AnyMessageComponentInteraction = AnySelectMenuInteraction | ButtonInteraction;
+type AnyCommandInteraction =
+    | ChatInputCommandInteraction
+    | MessageContextMenuCommandInteraction
+    | UserContextMenuCommandInteraction;
+
+export function isMessageComponent(i: InteractionTypable): i is AnyMessageComponentInteraction {
+    return i.type === InteractionType.MessageComponent;
+}
+export function isCommand(i: InteractionTypable): i is AnyCommandInteraction {
+    return i.type === InteractionType.ApplicationCommand;
+}
+export function isAutocomplete(i: InteractionTypable): i is AutocompleteInteraction {
+    return i.type === InteractionType.ApplicationCommandAutocomplete;
+}
+
+export function isModal(i: InteractionTypable): i is ModalSubmitInteraction {
+    return i.type === InteractionType.ModalSubmit;
+}
--- a/src/core/presences.ts
+++ b/src/core/presences.ts
@@ -1,66 +0,0 @@
-import type { ActivitiesOptions } from "discord.js";
-import type { IntoDependencies } from "./ioc";
-import type { Emitter } from "./interfaces";
-
-type Status = 'online' | 'idle' | 'invisible' | 'dnd'
-type PresenceReduce = (previous: Presence.Result) => Presence.Result;
-
-
-
-export const Presence = {
-    /**
-     * A small wrapper to provide type inference.
-     * Create a Presence module which **MUST** be put in a file called presence.(language-extension)
-     * adjacent to the file where **Sern.init** is CALLED.
-     */
-    module : <T extends (keyof Dependencies)[]>(conf: Presence.Config<T>) => conf,
-    /**
-     * Create a Presence body which can be either: 
-     * - once, the presence is activated only once.
-     * - repeated, per cycle or event, the presence can be changed.
-     */
-    of : (root: Omit<Presence.Result, 'repeat' | 'onRepeat'>) => {
-        return { 
-            /**
-             * @example
-             * Presence
-             *     .of({ activities: [{ name: "deez nuts" }] }) //starts presence with "deez nuts".
-             *     .repeated(prev => { 
-             *         return {
-             *             afk: true,
-             *             activities: prev.activities?.map(s => ({ ...s, name: s.name+"s" }))
-             *         };
-             *     }, 10000)) //every 10 s, the callback sets the presence to the value returned.
-             */
-            repeated: (onRepeat: PresenceReduce, repeat: number | [Emitter, string]) => {
-                return { repeat, onRepeat, ...root }
-            },
-            /**
-             * @example
-             * ```ts
-             * Presence.of({
-             *    activities: [{ name: "Chilling out" }]
-             * }).once() // Sets the presence once, with what's provided in '.of()'
-             *  ```
-             */
-            once: () => root
-        };
-    }
-}
-export declare namespace Presence {
-    export type Config<T extends (keyof Dependencies)[]> = {
-        inject?: [...T]
-        execute: (...v: IntoDependencies<T>) => Presence.Result;
-
-    }
-
-    export interface Result { 
-        status?: Status;
-        afk?: boolean;
-        activities?: ActivitiesOptions[];
-        shardId?: number[];
-        repeat?: number | [Emitter, string];
-        onRepeat?: (previous: Result) => Result; 
-    }
-}
-
--- a/src/core/structures/command-error.ts
+++ b/src/core/structures/command-error.ts
@@ -0,0 +1,6 @@
+import type { Logging } from "../contracts";
+
+export interface Response { 
+    type: 'fail' | 'handled';
+    log?: { type: keyof Logging; message: unknown }
+}
--- a/src/core/structures/context.ts
+++ b/src/core/structures/context.ts
@@ -1,4 +1,4 @@
-import type {
+import {
    BaseInteraction,
    ChatInputCommandInteraction,
    Client,
@@ -11,9 +11,7 @@ import type {
 import { CoreContext } from '../structures/core-context';
 import { Result, Ok, Err } from 'ts-results-es';
 import * as assert from 'assert';
-import type { ReplyOptions } from '../../types/utility';
-import { fmt } from '../functions'
-import { SernError } from './enums';
+import { ReplyOptions } from '../../types/utility';


 /**
@@ -22,24 +20,16 @@ import { SernError } from './enums';
 * Message and ChatInputCommandInteraction
 */
 export class Context extends CoreContext<Message, ChatInputCommandInteraction> {
-    
+    /*
+     * @Experimental
+     */
    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) {
+    protected constructor(protected ctx: Result<Message, ChatInputCommandInteraction>) {
        super(ctx);
    }
-    public get prefix() {
-        return this.__prefix;
-    }
+
    public get id(): Snowflake {
        return safeUnwrap(this.ctx
                            .map(m => m.id)
@@ -47,7 +37,9 @@ export class Context extends CoreContext<Message, ChatInputCommandInteraction> {
    }

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

    public get channelId(): Snowflake {
@@ -96,15 +88,6 @@ export class Context extends CoreContext<Message, ChatInputCommandInteraction> {
                            .mapErr(i => i.member));
    }

-    get message(): Message {
-        return this.ctx.expect(SernError.MismatchEvent);
-    }
-
-    get interaction(): ChatInputCommandInteraction {
-        return this.ctx.expectErr(SernError.MismatchEvent);
-    }
-
-
    public get client(): Client {
        return safeUnwrap(this.ctx
                            .map(m => m.client)
@@ -122,16 +105,17 @@ export class Context extends CoreContext<Message, ChatInputCommandInteraction> {
            this.ctx
                .map(m => m.reply(content as MessageReplyOptions))
                .mapErr(i =>
-                    i.reply(content as InteractionReplyOptions).then(() => i.fetchReply())),
+                    i.reply(content as InteractionReplyOptions).then(() => i.fetchReply()),
+                ),
        );
    }

-    static wrap(wrappable: BaseInteraction | Message, prefix?: string): Context {
+    static override wrap(wrappable: BaseInteraction | Message): Context {
        if ('interaction' in wrappable) {
-            return new Context(Ok(wrappable), prefix);
+            return new Context(Ok(wrappable));
        }
-        assert.ok(wrappable.isChatInputCommand(), "Context created with bad interaction.");
-        return new Context(Err(wrappable), prefix);
+        assert.ok(wrappable.isChatInputCommand());
+        return new Context(Err(wrappable));
    }
 }

--- a/src/core/structures/core-context.ts
+++ b/src/core/structures/core-context.ts
@@ -1,4 +1,5 @@
 import { Result as Either } from 'ts-results-es';
+import { SernError } from '../_internal';
 import * as assert from 'node:assert';

 /**
@@ -6,8 +7,15 @@ import * as assert from 'node:assert';
 */
 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");
+        assert.ok(typeof ctx === 'object' && ctx != null);
    }
+    get message(): M {
+        return this.ctx.expect(SernError.MismatchEvent);
+    }
+    get interaction(): I {
+        return this.ctx.expectErr(SernError.MismatchEvent);
+    }
+
    public isMessage(): this is CoreContext<M, never> {
        return this.ctx.isOk();
    }
@@ -15,4 +23,10 @@ export abstract class CoreContext<M, I> {
    public isSlash(): this is CoreContext<never, I> {
        return !this.isMessage();
    }
+    //todo: add agnostic options resolver for Context
+    abstract get options(): unknown;
+
+    static wrap(_: unknown): unknown {
+        throw Error('You need to override this method; cannot wrap an abstract class');
+    }
 }
--- a/src/core/structures/default-services.ts
+++ b/src/core/structures/default-services.ts
@@ -1,89 +0,0 @@
-import { ScheduledTask } from '../../types/core-modules';
-import type { LogPayload, Logging, ErrorHandling, Disposable } from '../interfaces';
-import { CronJob } from 'cron';
-
-/**
- * @internal
- * @since 2.0.0
- * Version 4.0.0 will internalize this api. Please refrain from using the defaults!
- */
-export class DefaultErrorHandling implements ErrorHandling {
-    crash(err: Error): never {
-        throw err;
-    }
-    updateAlive(err: Error) {
-        throw err;
-    }
-}
-
-
-/**
- * @internal
- * @since 2.0.0
- * Version 4.0.0 will internalize this api. Please refrain from using ModuleStore!
- */
-export class DefaultLogging implements Logging {
-    private date() { return new Date() } 
-    debug(payload: LogPayload): void {
-        console.debug(`DEBUG: ${this.date().toISOString()} -> ${payload.message}`);
-    }
-
-    error(payload: LogPayload): void {
-        console.error(`ERROR: ${this.date().toISOString()} -> ${payload.message}`);
-    }
-
-    info(payload: LogPayload): void {
-        console.info(`INFO: ${this.date().toISOString()} -> ${payload.message}`);
-    }
-
-    warning(payload: LogPayload): void {
-        console.warn(`WARN: ${this.date().toISOString()} -> ${payload.message}`);
-    }
-}
-
-
-export class TaskScheduler implements Disposable {
-    private __tasks: Map<string, CronJob<any, any>> = new Map();
-
-    schedule(uuid: string, task: ScheduledTask, deps: Dependencies) {
-        if (this.__tasks.has(uuid)) {
-            throw Error("while scheduling a task \
-                         found another task of same name. Not scheduling " +
-                         uuid + "again."  );
-        }
-        try {
-            const onTick = async function(this: CronJob) {
-                task.execute({ id: uuid,
-                               lastTimeExecution: this.lastExecution,
-                               nextTimeExecution: this.nextDate().toJSDate() }, { deps })
-           }
-           const job = CronJob.from({ cronTime: task.trigger, onTick, timeZone: task.timezone });
-           job.start();
-           this.__tasks.set(uuid, job);
-        } catch (error) {
-           throw Error(`while scheduling a task ${uuid} ` +  error);
-        }
-    }
-  
-    kill(taskName: string): boolean {
-        const job = this.__tasks.get(taskName);
-        if (job) {
-            job.stop();
-            this.__tasks.delete(taskName);
-            return true;
-        }
-        return false;
-    }
-  
-    get tasks(): string[] {
-        return Array.from(this.__tasks.keys());
-    }
-
-    dispose() {
-        this.__tasks.forEach((_, id) => {
-            this.kill(id);
-            this.__tasks.delete(id);
-        })
-    }
-    
-}
--- a/src/core/structures/enums.ts
+++ b/src/core/structures/enums.ts
@@ -48,16 +48,16 @@ export enum EventType {
    /**
     * The EventType for handling discord events
     */
-    Discord,
+    Discord = 1,
    /**
     * The EventType for handling sern events
     */
-    Sern,
+    Sern = 2,
    /**
     * The EventType for handling external events.
     * Could be for example, `process` events, database events
     */
-    External,
+    External = 3,
 }

 /**
@@ -85,12 +85,20 @@ export enum PluginType {
    Control = 2,
 }
 /**
- * @deprecated - Use strings 'success' | 'failure' | 'warning'
 * @enum { string }
 */
 export enum PayloadType {
+    /**
+     * The PayloadType for a SernEmitter success event
+     */
    Success = 'success',
+    /**
+     * The PayloadType for a SernEmitter failure event
+     */
    Failure = 'failure',
+    /**
+     * The PayloadType for a SernEmitter warning event
+     */
    Warning = 'warning',
 }

--- a/src/core/structures/index.ts
+++ b/src/core/structures/index.ts
@@ -0,0 +1,6 @@
+export { CommandType, PluginType, PayloadType, EventType } from './enums';
+export * from './context';
+export * from './sern-emitter';
+export * from './services';
+export * from './module-store';
+export * as CommandError from './command-error';
--- a/src/core/structures/module-store.ts
+++ b/src/core/structures/module-store.ts
@@ -0,0 +1,13 @@
+import { CommandMeta, Module, OnError } from '../../types/core-modules';
+import { CoreModuleStore } from '../contracts';
+
+/*
+ * @internal
+ * Version 4.0.0 will internalize this api. Please refrain from using ModuleStore!
+ * For interacting with modules, use the ModuleManager instead.
+ */
+export class ModuleStore implements CoreModuleStore {
+    onError = new WeakMap<Module, NonNullable<OnError>>();
+    metadata = new WeakMap<Module, CommandMeta>();
+    commands = new Map<string, string>();
+}
--- a/src/core/structures/sern-emitter.ts
+++ b/src/core/structures/sern-emitter.ts
@@ -0,0 +1,89 @@
+import { EventEmitter } from 'node:events';
+import { PayloadType } from '../../core/structures';
+import { Module } from '../../types/core-modules';
+import { SernEventsMapping, Payload } from '../../types/utility';
+
+/**
+ * @since 1.0.0
+ */
+export class SernEmitter extends EventEmitter {
+    constructor() {
+        super({ captureRejections: true });
+    }
+    /**
+     * Listening to sern events with on. This event stays on until a crash or a normal exit
+     * @param eventName
+     * @param listener what to do with the data
+     */
+    public override on<T extends keyof SernEventsMapping>(
+        eventName: T,
+        listener: (...args: SernEventsMapping[T][]) => void,
+    ): this {
+        return super.on(eventName, listener);
+    }
+    /**
+     * Listening to sern events with on. This event stays on until a crash or a normal exit
+     * @param eventName
+     * @param listener what to do with the data
+     */
+    public override once<T extends keyof SernEventsMapping>(
+        eventName: T,
+        listener: (...args: SernEventsMapping[T][]) => void,
+    ): this {
+        return super.once(eventName, listener);
+    }
+    /**
+     * Listening to sern events with on. This event stays on until a crash or a normal exit
+     * @param eventName
+     * @param args the arguments for emitting the eventName
+     */
+    public override emit<T extends keyof SernEventsMapping>(
+        eventName: T,
+        ...args: SernEventsMapping[T]
+    ): boolean {
+        return super.emit(eventName, ...args);
+    }
+    private static payload<T extends Payload>(
+        type: PayloadType,
+        module?: Module,
+        reason?: unknown,
+    ) {
+        return { type, module, reason } as T;
+    }
+
+    /**
+     * Creates a compliant SernEmitter failure payload
+     * @param module
+     * @param reason
+     */
+    static failure(module?: Module, reason?: unknown) {
+        //The generic cast Payload & { type : PayloadType.* } coerces the type to be a failure payload
+        // same goes to the other methods below
+        return SernEmitter.payload<Payload & { type: PayloadType.Failure }>(
+            PayloadType.Failure,
+            module,
+            reason,
+        );
+    }
+    /**
+     * Creates a compliant SernEmitter module success payload
+     * @param module
+     */
+    static success(module: Module) {
+        return SernEmitter.payload<Payload & { type: PayloadType.Success }>(
+            PayloadType.Success,
+            module,
+        );
+    }
+    /**
+     * Creates a compliant SernEmitter module warning payload
+     * @param reason
+     */
+    static warning(reason: unknown) {
+        return SernEmitter.payload<Payload & { type: PayloadType.Warning }>(
+            PayloadType.Warning,
+            undefined,
+            reason,
+        );
+    }
+}
--- a/src/core/structures/services/error-handling.ts
+++ b/src/core/structures/services/error-handling.ts
@@ -0,0 +1,21 @@
+import { ErrorHandling } from '../../contracts';
+
+/**
+ * @internal
+ * @since 2.0.0
+ * Version 4.0.0 will internalize this api. Please refrain from using the defaults!
+ */
+export class DefaultErrorHandling implements ErrorHandling {
+    crash(err: Error): never {
+        throw err;
+    }
+
+    #keepAlive = 5;
+
+    updateAlive(err: Error) {
+        this.#keepAlive--;
+        if (this.#keepAlive === 0) {
+            throw err;
+        }
+    }
+}
--- a/src/core/structures/services/index.ts
+++ b/src/core/structures/services/index.ts
@@ -0,0 +1,3 @@
+export * from './error-handling';
+export * from './logger';
+export * from './module-manager';
--- a/src/core/structures/services/logger.ts
+++ b/src/core/structures/services/logger.ts
@@ -0,0 +1,25 @@
+import { LogPayload, Logging } from '../../contracts';
+
+/**
+ * @internal
+ * @since 2.0.0
+ * Version 4.0.0 will internalize this api. Please refrain from using ModuleStore!
+ */
+export class DefaultLogging implements Logging {
+    private date = () => new Date();
+    debug(payload: LogPayload): void {
+        console.debug(`DEBUG: ${this.date().toISOString()} -> ${payload.message}`);
+    }
+
+    error(payload: LogPayload): void {
+        console.error(`ERROR: ${this.date().toISOString()} -> ${payload.message}`);
+    }
+
+    info(payload: LogPayload): void {
+        console.info(`INFO: ${this.date().toISOString()} -> ${payload.message}`);
+    }
+
+    warning(payload: LogPayload): void {
+        console.warn(`WARN: ${this.date().toISOString()} -> ${payload.message}`);
+    }
+}
--- a/src/core/structures/services/module-manager.ts
+++ b/src/core/structures/services/module-manager.ts
@@ -0,0 +1,58 @@
+import * as Id from '../../../core/id';
+import { CoreModuleStore, ModuleManager } from '../../contracts';
+import { Files } from '../../_internal';
+import { CommandMeta, CommandModule, CommandModuleDefs, Module, OnError } from '../../../types/core-modules';
+import { CommandType } from '../enums';
+/**
+ * @internal
+ * @since 2.0.0
+ * Version 4.0.0 will internalize this api. Please refrain from using DefaultModuleManager!
+ */
+export class DefaultModuleManager implements ModuleManager {
+    constructor(private moduleStore: CoreModuleStore) {}
+
+
+    getErrorCallback(m: Module): OnError {
+        return this.moduleStore.onError.get(m);
+    }
+    setErrorCallback(m: Module, c: NonNullable<OnError>): void {
+        this.moduleStore.onError.set(m, c);
+    }
+
+    getByNameCommandType<T extends CommandType>(name: string, commandType: T) {
+        const id = this.get(Id.create(name, commandType));
+        if (!id) {
+            return undefined;
+        }
+        return Files.importModule<CommandModuleDefs[T]>(id);
+    }
+
+    setMetadata(m: Module, c: CommandMeta): void {
+        this.moduleStore.metadata.set(m, c);
+    }
+
+    getMetadata(m: Module): CommandMeta {
+        const maybeModule = this.moduleStore.metadata.get(m);
+        if (!maybeModule) {
+            throw Error('Could not find metadata in store for ' + m);
+        }
+        return maybeModule;
+    }
+
+    get(id: string) {
+        return this.moduleStore.commands.get(id);
+    }
+    set(id: string, path: string): void {
+        this.moduleStore.commands.set(id, path);
+    }
+    //not tested
+    getPublishableCommands(): Promise<CommandModule[]> {
+        const entries = this.moduleStore.commands.entries();
+        const publishable = 0b000000110;
+        return Promise.all(
+            Array.from(entries)
+                .filter(([id]) => !(Number.parseInt(id.at(-1)!) & publishable))
+                .map(([, path]) => Files.importModule<CommandModule>(path)),
+        );
+    }
+}
--- a/src/handlers/_internal.ts
+++ b/src/handlers/_internal.ts
@@ -0,0 +1,2 @@
+export * from './dispatchers';
+export * from './event-utils';
--- a/src/handlers/dispatchers.ts
+++ b/src/handlers/dispatchers.ts
@@ -0,0 +1,107 @@
+import { EventEmitter } from 'node:events';
+import * as assert from 'node:assert';
+import { concatMap, from, fromEvent, map, OperatorFunction, pipe } from 'rxjs';
+import {
+    arrayifySource,
+    callPlugin,
+    isAutocomplete,
+    treeSearch,
+    SernError,
+} from '../core/_internal';
+import { createResultResolver } from './event-utils';
+import { BaseInteraction, Message } from 'discord.js';
+import { CommandType, Context } from '../core';
+import type { AnyFunction, Args } from '../types/utility';
+import type { CommandModule, Module, OnError, Processed } from '../types/core-modules';
+
+//TODO: refactor dispatchers so that it implements a strategy for each different type of payload?
+export function dispatchMessage(module: Processed<CommandModule>, args: [Context, Args]) {
+    return {
+        module,
+        args,
+    };
+}
+
+export function contextArgs(wrappable: Message | BaseInteraction, messageArgs?: string[]) {
+    const ctx = Context.wrap(wrappable);
+    const args = ctx.isMessage() ? ['text', messageArgs!] : ['slash', ctx.options];
+    return [ctx, args] as [Context, Args];
+}
+
+function interactionArg<T extends BaseInteraction>(interaction: T) {
+    return [interaction] as [T];
+}
+
+function intoPayload(module: Processed<Module>, onError: AnyFunction|undefined) {
+    return pipe(
+        arrayifySource,
+        map(args => ({ module, args, onError })),
+    );
+}
+
+const createResult = createResultResolver<
+    Processed<Module>,
+    { module: Processed<Module>; args: unknown[], onError: AnyFunction|undefined },
+    unknown[]
+>({
+    createStream: ({ module, args }) => from(module.onEvent).pipe(callPlugin(args)),
+    onNext: ({ args }) => args,
+});
+/**
+ * Creates an observable from { source }
+ * @param module
+ * @param source
+ */
+export function eventDispatcher(module: Processed<Module>, onError: OnError, source: unknown) {
+    assert.ok(source instanceof EventEmitter, `${source} is not an EventEmitter`);
+
+    const execute: OperatorFunction<unknown[], unknown> = concatMap(async args =>
+        module.execute(...args),
+    );
+    return fromEvent(source, module.name).pipe(
+        intoPayload(module, onError),
+        concatMap(createResult),
+        execute,
+    );
+}
+
+export function createDispatcher(payload: {
+    module: Processed<CommandModule>;
+    event: BaseInteraction;
+    onError:  OnError
+}) {
+    assert.ok(
+        CommandType.Text !== payload.module.type,
+        SernError.MismatchEvent + 'Found text command in interaction stream',
+    );
+    switch (payload.module.type) {
+        case CommandType.Slash:
+        case CommandType.Both: {
+            if (isAutocomplete(payload.event)) {
+                const option = treeSearch(payload.event, payload.module.options);
+                assert.ok(
+                    option,
+                    Error(SernError.NotSupportedInteraction + ` There is no autocomplete tag for this option`),
+                );
+                const { command } = option;
+             	return {
+                    ...payload,
+             	    module: command as Processed<Module>, //autocomplete is not a true "module" warning cast!
+             	    args: [payload.event],
+                    onError: undefined
+             	};
+            }
+            return { 
+                args: contextArgs(payload.event),
+                ...payload,
+                onError: payload.onError
+            }; 
+        }
+        default:
+            return {
+                args: interactionArg(payload.event),
+                ...payload,
+                onError: payload.onError
+            }
+    }
+}
--- a/src/handlers/event-utils.ts
+++ b/src/handlers/event-utils.ts
@@ -1,125 +1,62 @@
-import type { Interaction, Message, BaseInteraction } from 'discord.js';
-import util from 'node:util';
+import { Interaction, Message } from 'discord.js';
 import {
-    EMPTY, type Observable, concatMap, filter,
-    throwError, fromEvent, map, type OperatorFunction,
-    catchError, finalize, pipe, from, take, share, of,
+    EMPTY,
+    Observable,
+    concatMap,
+    filter,
+    from,
+    of,
+    throwError,
+    tap,
+    MonoTypeOperatorFunction,
+    catchError,
+    finalize,
 } from 'rxjs';
-import * as Id from '../core/id'
-import type { Emitter, ErrorHandling, Logging } from '../core/interfaces';
-import { SernError } from '../core/structures/enums'
+import {
+    Files,
+    Id,
+    callPlugin,
+    everyPluginOk,
+    filterMapTo,
+    handleError,
+    SernError,
+    VoidResult,
+    useContainerRaw,
+} from '../core/_internal';
+import { CommandError, Emitter, ErrorHandling, Logging, ModuleManager } from '../core';
+import { contextArgs, createDispatcher } from './dispatchers';
+import { ObservableInput, pipe } from 'rxjs';
+import { SernEmitter } from '../core';
 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 { inspect } from 'node:util'
-import { disposeAll } from '../core/ioc';
-import { resultPayload, isAutocomplete, treeSearch, fmt } from '../core/functions'
-import merge from 'deepmerge'
+import type { AnyFunction, Awaitable } from '../types/utility';
+import type { ControlPlugin } from '../types/core-plugin';
+import type { AnyModule, CommandModule, Module, OnError, Processed } from '../types/core-modules';
+import type { ImportPayload } from '../types/core';
+import assert from 'node:assert';

-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
+            filter(pred),
+            concatMap(makeModule));
 }

+/**
+ * Removes the first character(s) _[depending on prefix length]_ of the message
+ * @param msg
+ * @param prefix The prefix to remove
+ * @returns The message without the prefix
+ * @example
+ * message.content = '!ping';
+ * console.log(fmt(message, '!'));
+ * // [ 'ping' ]
+ */
+export function fmt(msg: string, prefix: string): string[] {
+    return msg.slice(prefix.length).trim().split(/\s+/g);
+}

 /**
 *
@@ -130,141 +67,222 @@ function createGenericHandler<Source, Narrowed extends Source, Output>(
 */
 export function createInteractionHandler<T extends Interaction>(
    source: Observable<Interaction>,
-    deps: Dependencies,
-    defaultPrefix?: string
+    mg: ModuleManager,
 ) {
-    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 fullPath = mg.get(Id.reconstruct(event));
+            if(!fullPath) {
+                return Err.EMPTY
            }
-            const [{module, params}] = modules;
-            return Ok(createDispatcher({ 
-                module: module as Processed<CommandModule>, 
-                event, defaultPrefix, deps, params 
-            }));
-    });
+            return Files
+                .defaultModuleLoader<Processed<CommandModule>>(fullPath)
+                .then(payload =>
+                   Ok(createDispatcher({ 
+                       module: payload.module,
+                       onError: payload.onError,
+                       event,
+                      })));
+        },
+    );
 }

 export function createMessageHandler(
    source: Observable<Message>,
    defaultPrefix: string,
-    deps: Dependencies,
+    mg: ModuleManager,
 ) {
-    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');
+        const [prefix, ...rest] = fmt(event.content, defaultPrefix);
+        const fullPath = mg.get(`${prefix}_A1`);
+
+        if(!fullPath) {
+            return Err('Possibly undefined behavior: could not find a static id to resolve')
        }
-        return Ok({ args: [Context.wrap(event, defaultPrefix)], module, deps })
+        return Files
+            .defaultModuleLoader<Processed<CommandModule>>(fullPath)
+            .then(payload => {
+                const args = contextArgs(event, rest);
+                return Ok({ args, ...payload });
+            });
+    });
+}
+/**
+ * IMPURE SIDE EFFECT
+ * This function assigns remaining, incomplete data to each imported module.
+ */
+function assignDefaults<T extends Module>(
+    moduleManager: ModuleManager,
+): MonoTypeOperatorFunction<ImportPayload<T>> {
+    return tap(({ module, absPath }) => {
+        module.name ??= Files.filename(absPath);
+        module.description ??= '...';
+        moduleManager.setMetadata(module, {
+            isClass: module.constructor.name === 'Function',
+            fullPath: absPath,
+            id: Id.create(module.name, module.type),
+        });
    });
 }

+export function buildModules<T extends AnyModule>(
+    input: ObservableInput<string>,
+    moduleManager: ModuleManager,
+) {
+    return Files.buildModuleStream<Processed<T>>(input).pipe(assignDefaults(moduleManager));
+}

+
+interface ExecutePayload {
+    module: Processed<Module>;
+    task: () => Awaitable<unknown>;
+    onError: AnyFunction|undefined 
+    args: unknown[]
+}
 /**
 * 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 => { 
+export function executeModule(
+    emitter: Emitter,
+    logger: Logging|undefined,
+    errHandler: ErrorHandling,
+    {
+        module,
+        task,
+        onError,
+        args
+    }: ExecutePayload,
+) {
+    const onError$ = (err_msg: unknown) => {
+        if(!onError) {
+            return throwError(() => SernEmitter.failure(module, err));
+        }
+        //Could be promise
+        const err = onError(err_msg) as CommandError.Response
+        if(!err) {
+            const failure = SernEmitter.failure(module, "onError: returned undefined/null");
+            return throwError(() => failure);
+        }
+        if(err.log) {
+           const { type, message } = err.log;
+           logger?.[type]({ message });
+        };
+        if(err.type === 'fail') {
+
+        } else {
+            
+        }
+        return EMPTY;
+    }
+    return of(module).pipe(
+        //converting the task into a promise so rxjs can resolve the Awaitable properly
+        concatMap(() => Result.wrapAsync(async () => task())),
+        concatMap(result => {
            if (result.isOk()) {
-                emitter.emit('module.activate', resultPayload('success', module));
+                emitter.emit('module.activate', SernEmitter.success(module));
                return EMPTY;
-            }
-            return throwError(() => resultPayload('failure', module, result.error));
-        }))
-};
+            } 
+            return onError$(result.error);
+        }),
+    );
+}

 /**
 * A higher order function that
- * - calls all control plugins.
- * - any failures results to { config.onStop } being called
+ * - creates a stream of {@link VoidResult} { config.createStream }
+ * - any failures results to { config.onFailure } being called
 * - if all results are ok, the stream is converted to { config.onNext }
- * config.onNext will be returned if everything is okay.
+ * emit config.onSuccess Observable
 * @param config
- * @returns function which calls all plugins and returns onNext or fail 
+ * @returns receiver function for flattening a stream of data
 */
-export function createResultResolver<Output>(config: {
-    onStop?: (module: Module, err?: string) => unknown;
-    onNext: (args: ExecutePayload, map: Record<string, unknown>) => Output;
+export function createResultResolver<
+    T extends { execute: (...args: any[]) => any; onEvent: ControlPlugin[] },
+    Args extends { module: T; onError: unknown, [key: string]: unknown },
+    Output,
+>(config: {
+    onStop?: (module: T) => unknown;
+    onNext: (args: Args) => Output;
+    createStream: (args: Args) => Observable<VoidResult>;
 }) {
-    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));
-        }
+    return (args: Args) => {
+        const task$ = config.createStream(args);
+        return task$.pipe(
+            tap(result => {
+                result.isErr() && config.onStop?.(args.module);
+            }),
+            everyPluginOk,
+            filterMapTo(() => config.onNext(args)),
+        );
    };
-};
-
-function isObject(item: unknown) {
-    return (item && typeof item === 'object' && !Array.isArray(item));
 }

-//_module is frozen, preventing from mutations
-export async function callInitPlugins(_module: Module, deps: Dependencies, emit?: boolean) {
-    let module = _module;
-    const emitter = deps['@sern/emitter'];
-    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(emit) {
-                emitter?.emit('module.register',
-                              resultPayload('failure', module, result.error ?? SernError.PluginFailure));
-            }
-            throw Error(result.error ?? SernError.PluginFailure);
-        }
-    }
-    return module
-}
-
-export async function callPlugins({ args, module, deps, params }: ExecutePayload) {
-    let state = {};
-    for(const plugin of module.onEvent??[]) {
-        const result = await plugin.execute(...args, { state, deps, params, type: module.type });
-        if(result.isErr()) {
-            return result;
-        }
-        if(isObject(result.value)) {
-            state = merge(state, result.value!);
-        }
-    }
-    return Ok(state);
-}
 /**
- * Creates an executable task ( execute the command ) if all control plugins are successful
+ * Calls a module's init plugins and checks for Err. If so, call { onStop } and
+ * ignore the module
+ */
+export function callInitPlugins<T extends Processed<AnyModule>>(sernEmitter: Emitter) {
+    return concatMap(
+        createResultResolver({
+            createStream: args => from(args.module.plugins).pipe(callPlugin(args)),
+            onStop: (module: T) => {
+                sernEmitter.emit(
+                    'module.register',
+                    SernEmitter.failure(module, SernError.PluginFailure),
+                );
+            },
+            onNext: ({ module, onError }) => {
+                sernEmitter.emit('module.register', SernEmitter.success(module));
+                return { module, onError: onError as OnError };
+            },
+        }),
+    );
+}
+
+/**
+ * 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>) => ({
+export function makeModuleExecutor<
+    M extends Processed<Module>,
+    Args extends { 
+        module: M;
+        args: unknown[];
+        onError: AnyFunction|undefined 
+    },
+>(onStop: (m: M) => unknown) {
+    const onNext = ({ args, module, onError }: Args) => ({
+        task: () => module.execute(...args),
        module,
-        args: [...args, { state, deps, params, type: module.type }],
-        deps
+        onError,
+        args
    });
-    return createResultResolver({ onStop, onNext });
+    return concatMap(
+        createResultResolver({
+            onStop,
+            createStream: ({ args, module }) => 
+                from(module.onEvent)
+                    .pipe(callPlugin(args)),
+            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);
-         }))
+export const handleCrash = (err: ErrorHandling, log?: Logging) =>
+    pipe(
+        catchError(handleError(err, log)),
+        finalize(() => {
+            log?.info({
+                message: 'A stream closed or reached end of lifetime',
+            });
+            useContainerRaw()
+                ?.disposeAll()
+                .then(() => log?.info({ message: 'Cleaning container and crashing' }));
+        }),
+    );
--- a/src/handlers/interaction-event.ts
+++ b/src/handlers/interaction-event.ts
@@ -0,0 +1,33 @@
+import { Interaction } from 'discord.js';
+import { concatMap, merge } from 'rxjs';
+import { SernEmitter } from '../core';
+import {
+    isAutocomplete,
+    isCommand,
+    isMessageComponent,
+    isModal,
+    sharedEventStream,
+    SernError,
+    filterTap,
+} from '../core/_internal';
+import { createInteractionHandler, executeModule, makeModuleExecutor } from './_internal';
+import type { DependencyList } from '../types/ioc';
+
+export function interactionHandler([emitter, err, log, modules, client]: DependencyList) {
+    const interactionStream$ = sharedEventStream<Interaction>(client, 'interactionCreate');
+    const handle = createInteractionHandler(interactionStream$, modules);
+
+    const interactionHandler$ = merge(
+        handle(isMessageComponent),
+        handle(isAutocomplete),
+        handle(isCommand),
+        handle(isModal),
+    );
+    return interactionHandler$
+        .pipe(
+            filterTap(e => emitter.emit('warning', SernEmitter.warning(e))),
+            makeModuleExecutor(module => 
+                emitter.emit('module.activate', SernEmitter.failure(module, SernError.PluginFailure))),
+            concatMap(payload => executeModule(emitter, log, err, payload)),
+    );
+}
--- a/src/handlers/interaction.ts
+++ b/src/handlers/interaction.ts
@@ -1,30 +0,0 @@
-import type { Interaction } from 'discord.js';
-import { mergeMap, merge, concatMap, EMPTY } from 'rxjs';
-import { createInteractionHandler, executeModule, intoTask, sharedEventStream, filterTap, handleCrash } from './event-utils';
-import { SernError } from '../core/structures/enums'
-import { isAutocomplete, isCommand, isMessageComponent, isModal, resultPayload } from '../core/functions'
-import { UnpackedDependencies } from '../types/utility';
-
-export default 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);
-
-    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"));
-}
--- a/src/handlers/message-event.ts
+++ b/src/handlers/message-event.ts
@@ -0,0 +1,47 @@
+import { concatMap, EMPTY } from 'rxjs';
+import type { Message } from 'discord.js';
+import { SernEmitter } from '../core';
+import { sharedEventStream, SernError, filterTap } from '../core/_internal';
+import { createMessageHandler, executeModule, makeModuleExecutor } from './_internal';
+import type { DependencyList } from '../types/ioc';
+
+/**
+ * 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 hasPrefix(prefix: string, content: string) {
+    const prefixInContent = content.slice(0, prefix.length);
+    return (
+        prefixInContent.localeCompare(prefix, undefined, {
+            sensitivity: 'accent',
+        }) === 0
+    );
+}
+
+export function messageHandler(
+    [emitter, err, log, modules, client]: DependencyList,
+    defaultPrefix: string | undefined,
+) {
+    if (!defaultPrefix) {
+        log?.debug({
+            message: 'No prefix found. message handler shutting down',
+        });
+        return EMPTY;
+    }
+    const messageStream$ = sharedEventStream<Message>(client, 'messageCreate');
+    const handle = createMessageHandler(messageStream$, defaultPrefix, modules);
+
+    const msgCommands$ = handle(isNonBot(defaultPrefix));
+
+    return msgCommands$.pipe(
+        filterTap((e) => emitter.emit('warning', SernEmitter.warning(e))),
+        makeModuleExecutor(module => {
+            emitter.emit('module.activate', SernEmitter.failure(module, SernError.PluginFailure));
+        }),
+        concatMap(payload => executeModule(emitter, log, err, payload)),
+    );
+}
--- a/src/handlers/message.ts
+++ b/src/handlers/message.ts
@@ -1,50 +0,0 @@
-import { EMPTY, mergeMap, concatMap } from 'rxjs';
-import type { Message } from 'discord.js';
-import { createMessageHandler, executeModule, intoTask, sharedEventStream, filterTap, handleCrash} 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';
-
-/**
- * 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 hasPrefix(prefix: string, content: string) {
-    const prefixInContent = content.slice(0, prefix.length);
-    return prefixInContent.localeCompare(prefix, undefined, { sensitivity: 'accent' }) === 0;
-}
-
-export default 
-function (deps: UnpackedDependencies, defaultPrefix?: string) {
-    const {"@sern/emitter": emitter,  
-           '@sern/logger': log, 
-           '@sern/client': client} = deps
-
-    if (!defaultPrefix) {
-        log?.debug({ message: 'No prefix found. message handler shutting down' });
-        return EMPTY;
-    }
-    const messageStream$ = sharedEventStream<Message>(client as unknown as Emitter, 'messageCreate');
-    const handle = createMessageHandler(messageStream$, defaultPrefix, deps);
-
-    const msgCommands$ = handle(isNonBot(defaultPrefix));
-
-    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")
-    )
-}
--- a/src/handlers/presence.ts
+++ b/src/handlers/presence.ts
@@ -1,40 +0,0 @@
-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));
-        }
-        return of(s).pipe(take(1));
-    })
-};
-
-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))));
-}
--- a/src/handlers/ready-event.ts
+++ b/src/handlers/ready-event.ts
@@ -0,0 +1,47 @@
+import { ObservableInput, concat, first, fromEvent, ignoreElements, pipe } from 'rxjs';
+import { CommandType } from '../core/structures';
+import { SernError } from '../core/_internal';
+import { Result } from 'ts-results-es';
+import { ModuleManager } from '../core/contracts';
+import { buildModules, callInitPlugins } from './_internal';
+import * as assert from 'node:assert';
+import * as util from 'node:util';
+import type { DependencyList } from '../types/ioc';
+import type { AnyModule, Processed } from '../types/core-modules';
+
+export function startReadyEvent(
+    [sEmitter, , , moduleManager, client]: DependencyList,
+    allPaths: ObservableInput<string>,
+) {
+    const ready$ = fromEvent(client!, 'ready').pipe(once());
+
+    return concat(ready$, buildModules<AnyModule>(allPaths, moduleManager))
+        .pipe(callInitPlugins(sEmitter))
+        .subscribe(({ module }) => {
+            register(moduleManager, module)
+                .expect(SernError.InvalidModuleType + ' ' + util.inspect(module));
+        });
+}
+
+const once = () => pipe(
+    first(),
+    ignoreElements()
+)
+
+
+function register<T extends Processed<AnyModule>>(
+    manager: ModuleManager,
+    module: T,
+): Result<void, void> {
+    const { id, fullPath } = manager.getMetadata(module)!;
+
+    const validModuleType = module.type >= 0 && module.type <= 1 << 10;
+    assert.ok(
+        validModuleType,
+        `Found ${module.name} at ${fullPath}, which does not have a valid type`,
+    );
+    if (module.type === CommandType.Both || module.type === CommandType.Text) {
+        module.alias?.forEach(a => manager.set(`${a}_A1`, fullPath));
+    }
+    return Result.wrap(() => manager.set(id, fullPath));
+}
--- a/src/handlers/ready.ts
+++ b/src/handlers/ready.ts
@@ -1,32 +0,0 @@
-import * as Files from '../core/module-loading'
-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 { callInitPlugins } from './event-utils';
-
-export default async function(dir: string, deps : UnpackedDependencies) {
-    const { '@sern/client': client,
-            '@sern/logger': log,
-            '@sern/emitter': sEmitter,
-            '@sern/modules': commands } = deps;
-    log?.info({ message: "Waiting on discord client to be ready..." })
-    await once(client, "ready");
-    log?.info({ message: "Client signaled ready, registering modules" });
-
-    // 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 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 +0,0 @@
-import * as Files from '../core/module-loading'
-import { UnpackedDependencies } 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) => {
-    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)
-    }
-}
--- a/src/handlers/user-defined-events.ts
+++ b/src/handlers/user-defined-events.ts
@@ -1,33 +1,36 @@
-import { EventType,  SernError } from '../core/structures/enums';
-import { callInitPlugins, eventDispatcher, handleCrash } from './event-utils'
-import { EventModule,  Module  } from '../types/core-modules';
-import * as Files from '../core/module-loading'
-import type { UnpackedDependencies } from '../types/utility';
-import { from, map, mergeAll } from 'rxjs';
+import { ObservableInput, map, mergeAll } from 'rxjs';
+import { EventType } from '../core/structures';
+import { SernError } from '../core/_internal';
+import { buildModules, callInitPlugins, handleCrash, eventDispatcher } from './_internal';
+import { Service } from '../core/ioc';
+import type { DependencyList } from '../types/ioc';
+import type { EventModule, OnError, Processed } from '../types/core-modules';

-const intoDispatcher = (deps: UnpackedDependencies) => 
-    (module : EventModule) => {
-        switch (module.type) {
+export function eventsHandler(
+    [emitter, err, log, moduleManager, client]: DependencyList,
+    allPaths: ObservableInput<string>,
+) {
+    //code smell
+    const intoDispatcher = (e: { module: Processed<EventModule>, onError: OnError }) => {
+        switch (e.module.type) {
            case EventType.Sern:
-                return eventDispatcher(deps, module,  deps['@sern/emitter']);
+                return eventDispatcher(e.module, e.onError, emitter);
            case EventType.Discord:
-                return eventDispatcher(deps, module,  deps['@sern/client']);
+                return eventDispatcher(e.module, e.onError, client);
            case EventType.External:
-                return eventDispatcher(deps, module,  deps[module.emitter]);
-            default: throw Error(SernError.InvalidModuleType + ' while creating event handler');
+                return eventDispatcher(e.module, e.onError, Service(e.module.emitter));
+            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);
-    }
-    from(eventModules)
-        .pipe(map(intoDispatcher(deps)),
-               mergeAll(), // all eventListeners are turned on
-               handleCrash(deps, "event modules"))
-            .subscribe();
+    };
+    buildModules<EventModule>(allPaths, moduleManager)
+        .pipe(
+            callInitPlugins(emitter),
+            map(intoDispatcher),
+            /**
+             * Where all events are turned on
+             */
+            mergeAll(),
+            handleCrash(err, log))
+        .subscribe();
 }
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,7 +1,6 @@
 export * as Sern from './sern';
-
+export * from './core';
 export type {
-    Module,
    CommandModule,
    EventModule,
    BothCommand,
@@ -25,48 +24,33 @@ export type {
    SernOptionsData,
    SernSubCommandData,
    SernSubCommandGroupData,
-    SDT,
-    ScheduledTask
 } from './types/core-modules';

 export type {
+    Controller,
    PluginResult,
    InitPlugin,
    ControlPlugin,
    Plugin,
-    AnyPlugin,
+    AnyEventPlugin,
+    AnyCommandPlugin,
 } from './types/core-plugin';

+export type { Wrapper } from './types/core';

-export type { Payload, SernEventsMapping } from './types/utility';
+export type { Args, SlashOptions, Payload, SernEventsMapping } from './types/utility';
+
+export type { Singleton, Transient, CoreDependencies, Initializable } from './types/ioc';

 export {
    commandModule,
    eventModule,
    discordEvent,
-    scheduledTask
+    EventExecutable,
+    CommandExecutable,
 } from './core/modules';

-export * from './core/presences'
-export * from './core/interfaces'
-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;
-}
+export {
+    useContainerRaw
+} from './core/_internal'
+export { controller } from './sern';
--- a/src/sern.ts
+++ b/src/sern.ts
@@ -1,27 +1,16 @@
-//side effect: global container
-import { useContainerRaw } from '@sern/ioc/global';
-
-import callsites from 'callsites';
-import * as  Files from './core/module-loading';
+import { handleCrash } from './handlers/_internal';
+import { err, ok, Files } from './core/_internal';
 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 { presenceHandler } from './handlers/presence';
-import { UnpackedDependencies } from './types/utility';
-import type { Presence} from './core/presences';
-import { registerTasks } from './handlers/tasks';
+import { Services } from './core/ioc';
+import { Wrapper } from './types/core';
+import { eventsHandler } from './handlers/user-defined-events';
+import { startReadyEvent } from './handlers/ready-event';
+import { messageHandler } from './handlers/message-event';
+import { interactionHandler } from './handlers/interaction-event';

-interface Wrapper {
-    commands: string;
-    defaultPrefix?: string;
-    events?: string;
-    tasks?: string;
-}
 /**
 * @since 1.0.0
- * @param maybeWrapper Options to pass into sern.
+ * @param wrapper Options to pass into sern.
 * Function to start the handler up
 * @example
 * ```ts title="src/index.ts"
@@ -32,40 +21,46 @@ interface Wrapper {
 * ```
 */

-export function init(maybeWrapper: Wrapper = { commands: "./dist/commands" }) {
+export function init(maybeWrapper: Wrapper | 'file') {
    const startTime = performance.now();
-    const deps = useContainerRaw().deps<UnpackedDependencies>();
-    
-    if (maybeWrapper.events !== undefined) {
-        eventsHandler(deps, maybeWrapper.events)
-            .then(() => {
-                deps['@sern/logger']?.info({ message: "Events registered" });
-            });
-    } else {
-        deps['@sern/logger']?.info({ message: "No events registered" });
+    const wrapper = Files.loadConfig(maybeWrapper);
+    const dependencies = useDependencies();
+    const logger = dependencies[2],
+        errorHandler = dependencies[1];
+
+    if (wrapper.events !== undefined) {
+        eventsHandler(dependencies, Files.getFullPathTree(wrapper.events));
    }
-
-    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
-    ready(maybeWrapper.commands, deps)
-        .then(() => {
-            const time = ((performance.now() - startTime) / 1000).toFixed(2);
-            deps['@sern/logger']?.info({ message: `sern: registered in ${time} s` });
-            if(presencePath.exists) {
-                const setPresence = async (p: Presence.Result) => {
-                    return deps['@sern/client'].user?.setPresence(p);
-                }
-                presenceHandler(presencePath.path, setPresence).subscribe();
-            }
-            if(maybeWrapper.tasks) {
-                registerTasks(maybeWrapper.tasks, deps);
-            }
-        })
-        .catch(err => { throw err });
+    startReadyEvent(dependencies, Files.getFullPathTree(wrapper.commands)).add(() => {
+        const time = ((performance.now() - startTime) / 1000).toFixed(2);
+        dependencies[0].emit('modulesLoaded');
+        logger?.info({
+            message: `sern: registered all modules in ${time} s`,
+        });
+    });

-    const messages$ = messageHandler(deps, maybeWrapper.defaultPrefix);
-    const interactions$ = interactionHandler(deps, maybeWrapper.defaultPrefix);
+    const messages$ = messageHandler(dependencies, wrapper.defaultPrefix);
+    const interactions$ = interactionHandler(dependencies);
    // listening to the message stream and interaction stream
-    merge(messages$, interactions$).subscribe();
+    merge(messages$, interactions$).pipe(handleCrash(errorHandler, logger)).subscribe();
 }
+
+function useDependencies() {
+    return Services(
+        '@sern/emitter',
+        '@sern/errors',
+        '@sern/logger',
+        '@sern/modules',
+        '@sern/client',
+    );
+}
+
+/**
+ * @since 1.0.0
+ * The object passed into every plugin to control a command's behavior
+ */
+export const controller = {
+    next: ok,
+    stop: err,
+};
--- a/src/types/core-modules.ts
+++ b/src/types/core-modules.ts
@@ -14,20 +14,19 @@ import type {
    StringSelectMenuInteraction,
    UserContextMenuCommandInteraction,
    UserSelectMenuInteraction,
-    ChatInputCommandInteraction,
 } from 'discord.js';
-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 { CommandType, Context, EventType } from '../../src/core';
+import { AnyCommandPlugin, AnyEventPlugin, ControlPlugin, InitPlugin } from './core-plugin';
+import { Awaitable, Args, SlashOptions, SernEventsMapping, AnyFunction } from './utility';

-//state, deps, type (very original)
-export type SDT = {
-    state: Record<string,unknown>;
-    deps: Dependencies;
-    type: CommandType,
-    params?: string
-};
+export type OnError = AnyFunction|undefined
+
+
+export interface CommandMeta {
+    fullPath: string;
+    id: string;
+    isClass: boolean;
+}

 export type Processed<T> = T & { name: string; description: string };

@@ -37,11 +36,6 @@ export interface Module {
    onEvent: ControlPlugin[];
    plugins: InitPlugin[];
    description?: string;
-    meta: {
-        id: string;
-        absPath: string;
-    }
-    locals: Record<string,unknown>
    execute(...args: any[]): Awaitable<any>;
 }

@@ -51,7 +45,6 @@ export interface SernEventCommand<T extends keyof SernEventsMapping = keyof Sern
    type: EventType.Sern;
    execute(...args: SernEventsMapping[T]): Awaitable<unknown>;
 }
-
 export interface ExternalEventCommand extends Module {
    name?: string;
    emitter: keyof Dependencies;
@@ -59,54 +52,54 @@ export interface ExternalEventCommand extends Module {
    execute(...args: unknown[]): Awaitable<unknown>;
 }

-
 export interface ContextMenuUser extends Module {
    type: CommandType.CtxUser;
-    execute: (ctx: UserContextMenuCommandInteraction, tbd: SDT) => Awaitable<unknown>;
+    execute: (ctx: UserContextMenuCommandInteraction) => Awaitable<unknown>;
 }

 export interface ContextMenuMsg extends Module {
    type: CommandType.CtxMsg;
-    execute: (ctx: MessageContextMenuCommandInteraction, tbd: SDT) => Awaitable<unknown>;
+    execute: (ctx: MessageContextMenuCommandInteraction) => Awaitable<unknown>;
 }

 export interface ButtonCommand extends Module {
    type: CommandType.Button;
-    execute: (ctx: ButtonInteraction, tbd: SDT) => Awaitable<unknown>;
+    execute: (ctx: ButtonInteraction) => Awaitable<unknown>;
 }

 export interface StringSelectCommand extends Module {
    type: CommandType.StringSelect;
-    execute: (ctx: StringSelectMenuInteraction, tbd: SDT) => Awaitable<unknown>;
+    execute: (ctx: StringSelectMenuInteraction) => Awaitable<unknown>;
 }

 export interface ChannelSelectCommand extends Module {
    type: CommandType.ChannelSelect;
-    execute: (ctx: ChannelSelectMenuInteraction, tbd: SDT) => Awaitable<unknown>;
+    execute: (ctx: ChannelSelectMenuInteraction) => Awaitable<unknown>;
 }

 export interface RoleSelectCommand extends Module {
    type: CommandType.RoleSelect;
-    execute: (ctx: RoleSelectMenuInteraction, tbd: SDT) => Awaitable<unknown>;
+    execute: (ctx: RoleSelectMenuInteraction) => Awaitable<unknown>;
 }

 export interface MentionableSelectCommand extends Module {
    type: CommandType.MentionableSelect;
-    execute: (ctx: MentionableSelectMenuInteraction, tbd: SDT) => Awaitable<unknown>;
+    execute: (ctx: MentionableSelectMenuInteraction) => Awaitable<unknown>;
 }

 export interface UserSelectCommand extends Module {
    type: CommandType.UserSelect;
-    execute: (ctx: UserSelectMenuInteraction, tbd: SDT) => Awaitable<unknown>;
+    execute: (ctx: UserSelectMenuInteraction) => Awaitable<unknown>;
 }

 export interface ModalSubmitCommand extends Module {
    type: CommandType.Modal;
-    execute: (ctx: ModalSubmitInteraction, tbd: SDT) => Awaitable<unknown>;
+    execute: (ctx: ModalSubmitInteraction) => Awaitable<unknown>;
 }

-export interface AutocompleteCommand {
-    onEvent?: ControlPlugin[];
+export interface AutocompleteCommand
+    extends Omit<Module, 'name' | 'type' | 'plugins' | 'description'> {
+    onEvent: ControlPlugin[];
    execute: (ctx: AutocompleteInteraction) => Awaitable<unknown>;
 }

@@ -118,24 +111,26 @@ export interface DiscordEventCommand<T extends keyof ClientEvents = keyof Client
 }
 export interface TextCommand extends Module {
    type: CommandType.Text;
-    execute: (ctx: Context & { get options(): string[] }, tbd: SDT) => Awaitable<unknown>;
+    alias?: string[];
+    execute: (ctx: Context, args: ['text', string[]]) => Awaitable<unknown>;
 }

 export interface SlashCommand extends Module {
    type: CommandType.Slash;
    description: string;
    options?: SernOptionsData[];
-    execute: (ctx: Context  & { get options(): ChatInputCommandInteraction['options']}, tbd: SDT) => Awaitable<unknown>;
+    execute: (ctx: Context, args: ['slash', SlashOptions]) => Awaitable<unknown>;
 }

 export interface BothCommand extends Module {
    type: CommandType.Both;
+    alias?: string[];
    description: string;
    options?: SernOptionsData[];
-    execute: (ctx: Context, tbd: SDT) => Awaitable<unknown>;
+    execute: (ctx: Context, args: Args) => Awaitable<unknown>;
 }

-export type EventModule = DiscordEventCommand | SernEventCommand | ExternalEventCommand;  
+export type EventModule = DiscordEventCommand | SernEventCommand | ExternalEventCommand;
 export type CommandModule =
    | TextCommand
    | SlashCommand
@@ -150,6 +145,7 @@ export type CommandModule =
    | RoleSelectCommand
    | ModalSubmitCommand;

+export type AnyModule = CommandModule | EventModule;
 //https://stackoverflow.com/questions/64092736/alternative-to-switch-statement-for-typescript-discriminated-union
 // Explicit Module Definitions for mapping
 export interface CommandModuleDefs {
@@ -184,22 +180,19 @@ export interface SernAutocompleteData
 }

 type CommandModuleNoPlugins = {
-    [T in CommandType]: Omit<CommandModuleDefs[T], 'plugins' | 'onEvent' | 'meta' | 'locals'>;
+    [T in CommandType]: Omit<CommandModuleDefs[T], 'plugins' | 'onEvent'>;
 };
 type EventModulesNoPlugins = {
-    [T in EventType]: Omit<EventModuleDefs[T], 'plugins' | 'onEvent' | 'meta' | 'locals'> ;
+    [T in EventType]: Omit<EventModuleDefs[T], 'plugins' | 'onEvent'>;
 };

 export type InputEvent = {
-    [T in EventType]: EventModulesNoPlugins[T] & {
-        once?: boolean;
-        plugins?: InitPlugin[] 
-    };
+    [T in EventType]: EventModulesNoPlugins[T] & { plugins?: AnyEventPlugin[] };
 }[EventType];

 export type InputCommand = {
    [T in CommandType]: CommandModuleNoPlugins[T] & {
-        plugins?: Plugin[];
+        plugins?: AnyCommandPlugin[];
    };
 }[CommandType];

@@ -222,37 +215,3 @@ export interface SernSubCommandGroupData extends BaseApplicationCommandOptionsDa
    type: ApplicationCommandOptionType.SubcommandGroup;
    options?: SernSubCommandData[];
 }
-
-
-export interface ScheduledTaskContext {
-     
-    /**
-     * the uuid of the current task being run
-     */
-    id: string;
-    /**
-     * the last time this task was executed. If this is the first time, it is null.
-     */
-    lastTimeExecution: Date | null;
-    /**
-      * The next time this task will be executed.
-      */
-    nextTimeExecution: Date | null;
-}
-
-//name subject to change
-interface TaskAttrs {
-    /**
-     * An object of dependencies configured in `makeDependencies`
-     */
-    deps: UnpackedDependencies
-}
-
-export interface ScheduledTask {
-    name?: string;
-    trigger: string | Date;
-    timezone?: string;
-    execute(tasks: ScheduledTaskContext, sdt: TaskAttrs): Awaitable<void>
-}
-
-
--- a/src/types/core-plugin.ts
+++ b/src/types/core-plugin.ts
@@ -11,18 +11,34 @@
 * Plugins are reminiscent of middleware in express.
 */

-import type { Result } from 'ts-results-es';
+import type { Err, Ok, Result } from 'ts-results-es';
 import type {
+    BothCommand,
+    ButtonCommand,
+    ChannelSelectCommand,
+    CommandModule,
+    ContextMenuMsg,
+    ContextMenuUser,
+    DiscordEventCommand,
+    EventModule,
+    ExternalEventCommand,
+    MentionableSelectCommand,
+    ModalSubmitCommand,
    Module,
    Processed,
-    SDT,
+    RoleSelectCommand,
+    SernEventCommand,
+    SlashCommand,
+    StringSelectCommand,
+    TextCommand,
+    UserSelectCommand,
 } from './core-modules';
-import type { Awaitable } from './utility';
-import type { CommandType, PluginType } from '../core/structures/enums'
-import type { Context } from '../core/structures/context'
-import type {
+import { Args, Awaitable, Payload, SlashOptions } from './utility';
+import { CommandType, Context, EventType, PluginType } from '../core';
+import {
    ButtonInteraction,
    ChannelSelectMenuInteraction,
+    ClientEvents,
    MentionableSelectMenuInteraction,
    MessageContextMenuCommandInteraction,
    ModalSubmitInteraction,
@@ -32,40 +48,106 @@ import type {
    UserSelectMenuInteraction,
 } from 'discord.js';

-export type PluginResult = Awaitable<Result<Record<string,unknown>|undefined, string|undefined>>;
-export interface InitArgs<T extends Processed<Module> = Processed<Module>> {
+export type PluginResult = Awaitable<VoidResult>;
+export type VoidResult = Result<void, void>;
+
+export interface InitArgs<T extends Processed<Module>> {
    module: T;
    absPath: string;
-    deps: Dependencies
+}
+export interface Controller {
+    next: () => Ok<void>;
+    stop: () => Err<void>;
 }
 export interface Plugin<Args extends any[] = any[]> {
    type: PluginType;
    execute: (...args: Args) => PluginResult;
 }

-export interface InitPlugin<Args extends any[] = any[]> extends Plugin<Args> {
+export interface InitPlugin<Args extends any[] = any[]> {
    type: PluginType.Init;
    execute: (...args: Args) => PluginResult;
 }
-export interface ControlPlugin<Args extends any[] = any[]> extends Plugin<Args> {
+export interface ControlPlugin<Args extends any[] = any[]> {
    type: PluginType.Control;
+    execute: (...args: Args) => PluginResult;
 }

-export type AnyPlugin = ControlPlugin | InitPlugin<[InitArgs<Processed<Module>>]>;
+export type AnyCommandPlugin = ControlPlugin | InitPlugin<[InitArgs<Processed<CommandModule>>]>;
+export type AnyEventPlugin = ControlPlugin | InitPlugin<[InitArgs<Processed<EventModule>>]>;

-export type CommandArgs<I extends CommandType = CommandType> = CommandArgsMatrix[I]
+export type CommandArgs<
+    I extends CommandType = CommandType,
+    J extends PluginType = PluginType,
+> = CommandArgsMatrix[I][J];
+
+export type EventArgs<
+    I extends EventType = EventType,
+    J extends PluginType = PluginType,
+> = EventArgsMatrix[I][J];

 interface CommandArgsMatrix {
-    [CommandType.Text]: [Context, SDT];
-    [CommandType.Slash]: [Context, SDT];
-    [CommandType.Both]: [Context, SDT];
-    [CommandType.CtxMsg]: [MessageContextMenuCommandInteraction, SDT];
-    [CommandType.CtxUser]: [UserContextMenuCommandInteraction, SDT];
-    [CommandType.Button]: [ButtonInteraction, SDT];
-    [CommandType.StringSelect]: [StringSelectMenuInteraction, SDT];
-    [CommandType.RoleSelect]: [RoleSelectMenuInteraction, SDT];
-    [CommandType.ChannelSelect]: [ChannelSelectMenuInteraction, SDT];
-    [CommandType.MentionableSelect]: [MentionableSelectMenuInteraction, SDT];
-    [CommandType.UserSelect]: [UserSelectMenuInteraction, SDT];
-    [CommandType.Modal]: [ModalSubmitInteraction, SDT];
+    [CommandType.Text]: {
+        [PluginType.Control]: [Context, ['text', string[]]];
+        [PluginType.Init]: [InitArgs<Processed<TextCommand>>];
+    };
+    [CommandType.Slash]: {
+        [PluginType.Control]: [Context, ['slash', /* library coupled */ SlashOptions]];
+        [PluginType.Init]: [InitArgs<Processed<SlashCommand>>];
+    };
+    [CommandType.Both]: {
+        [PluginType.Control]: [Context, Args];
+        [PluginType.Init]: [InitArgs<Processed<BothCommand>>];
+    };
+    [CommandType.CtxMsg]: {
+        [PluginType.Control]: [/* library coupled */ MessageContextMenuCommandInteraction];
+        [PluginType.Init]: [InitArgs<Processed<ContextMenuMsg>>];
+    };
+    [CommandType.CtxUser]: {
+        [PluginType.Control]: [/* library coupled */ UserContextMenuCommandInteraction];
+        [PluginType.Init]: [InitArgs<Processed<ContextMenuUser>>];
+    };
+    [CommandType.Button]: {
+        [PluginType.Control]: [/* library coupled */ ButtonInteraction];
+        [PluginType.Init]: [InitArgs<Processed<ButtonCommand>>];
+    };
+    [CommandType.StringSelect]: {
+        [PluginType.Control]: [/* library coupled */ StringSelectMenuInteraction];
+        [PluginType.Init]: [InitArgs<Processed<StringSelectCommand>>];
+    };
+    [CommandType.RoleSelect]: {
+        [PluginType.Control]: [/* library coupled */ RoleSelectMenuInteraction];
+        [PluginType.Init]: [InitArgs<Processed<RoleSelectCommand>>];
+    };
+    [CommandType.ChannelSelect]: {
+        [PluginType.Control]: [/* library coupled */ ChannelSelectMenuInteraction];
+        [PluginType.Init]: [InitArgs<Processed<ChannelSelectCommand>>];
+    };
+    [CommandType.MentionableSelect]: {
+        [PluginType.Control]: [/* library coupled */ MentionableSelectMenuInteraction];
+        [PluginType.Init]: [InitArgs<Processed<MentionableSelectCommand>>];
+    };
+    [CommandType.UserSelect]: {
+        [PluginType.Control]: [/* library coupled */ UserSelectMenuInteraction];
+        [PluginType.Init]: [InitArgs<Processed<UserSelectCommand>>];
+    };
+    [CommandType.Modal]: {
+        [PluginType.Control]: [/* library coupled */ ModalSubmitInteraction];
+        [PluginType.Init]: [InitArgs<Processed<ModalSubmitCommand>>];
+    };
+}
+
+interface EventArgsMatrix {
+    [EventType.Discord]: {
+        [PluginType.Control]: /* library coupled */ ClientEvents[keyof ClientEvents];
+        [PluginType.Init]: [InitArgs<Processed<DiscordEventCommand>>];
+    };
+    [EventType.Sern]: {
+        [PluginType.Control]: [Payload];
+        [PluginType.Init]: [InitArgs<Processed<SernEventCommand>>];
+    };
+    [EventType.External]: {
+        [PluginType.Control]: unknown[];
+        [PluginType.Init]: [InitArgs<Processed<ExternalEventCommand>>];
+    };
 }
--- a/src/types/core.ts
+++ b/src/types/core.ts
@@ -0,0 +1,25 @@
+import { OnError } from "./core-modules";
+
+export interface ImportPayload<T> {
+    module: T;
+    absPath: string;
+    onError:  OnError
+    [key: string]: unknown;
+}
+
+export interface Wrapper {
+    commands: string;
+    defaultPrefix?: string;
+    events?: string;
+    /**
+     * Overload to enable mode in case developer does not use a .env file.
+     * @deprecated - https://github.com/sern-handler/handler/pull/325
+     */
+    mode?: string
+    /*
+     * @deprecated
+     */
+    containerConfig?: {
+        get: (...keys: (keyof Dependencies)[]) => unknown[];
+    };
+}
--- a/src/types/dependencies.d.ts
+++ b/src/types/dependencies.d.ts
@@ -4,24 +4,9 @@

 /* eslint-disable @typescript-eslint/consistent-type-imports */

-import { CoreDependencies } from '../core/ioc';
+import { CoreDependencies } from './ioc';

 declare global {
-   /**
-      * discord.js client. 
-      *   '@sern/client':  Client
-      * sern emitter listens to events that happen throughout
-      * the handler. some include module.register, module.activate.
-      *   '@sern/emitter': Contracts.Emitter;
-      * An error handler which is the final step before 
-      * the sern process actually crashes.
-         '@sern/errors':  Contracts.ErrorHandling;
-      * Optional logger. Performs ... logging
-      *  '@sern/logger'?: Contracts.Logging;
-      * Readonly module store. sern stores these 
-      * by module.meta.id -> Module
-      *  '@sern/modules': Map<string, Module>;
-      */
    interface Dependencies extends CoreDependencies {}
-}

+}
--- a/src/types/ioc.ts
+++ b/src/types/ioc.ts
@@ -0,0 +1,48 @@
+import { Container, UnpackFunction } from 'iti';
+import * as Contracts from '../core/contracts';
+/**
+  * Type to annotate that something is a singleton. 
+  * T is created once and lazily.
+  */
+export type Singleton<T> = () => T;
+/**
+  * Type to annotate that something is transient. 
+  * Every time this is called, a new object is created
+  */
+export type Transient<T> = () => () => T;
+/**
+  * Type to annotate that something is initializable. 
+  * If T has an init method, this will be called.
+  */
+export type Initializable<T extends Contracts.Init> = T
+
+export type DependencyList = [
+    Contracts.Emitter,
+    Contracts.ErrorHandling,
+    Contracts.Logging | undefined,
+    Contracts.ModuleManager,
+    Contracts.Emitter,
+];
+
+export interface CoreDependencies {
+    '@sern/client': () => Contracts.Emitter;
+    '@sern/logger'?: () => Contracts.Logging;
+    '@sern/emitter': () => Contracts.Emitter;
+    '@sern/store': () => Contracts.CoreModuleStore;
+    '@sern/modules': () => Contracts.ModuleManager;
+    '@sern/errors': () => Contracts.ErrorHandling;
+}
+
+export type DependencyFromKey<T extends keyof Dependencies> = Dependencies[T];
+
+export type IntoDependencies<Tuple extends [...any[]]> = {
+    [Index in keyof Tuple]: UnpackFunction<NonNullable<DependencyFromKey<Tuple[Index]>>>; //Unpack and make NonNullable
+} & { length: Tuple['length'] };
+
+export interface DependencyConfiguration {
+    //@deprecated. Loggers will always be included in the future
+    exclude?: Set<'@sern/logger'>;
+    build: (
+        root: Container<Omit<CoreDependencies, '@sern/client'>, {}>,
+    ) => Container<Dependencies, {}>;
+}
--- a/src/types/utility.ts
+++ b/src/types/utility.ts
@@ -1,27 +1,33 @@
-import type { InteractionReplyOptions, MessageReplyOptions } from 'discord.js';
-import type { Module } from './core-modules';
-import type { Result } from 'ts-results-es';
+import type { CommandInteractionOptionResolver, InteractionReplyOptions, MessageReplyOptions } from 'discord.js';
+import type { PayloadType } from '../core';
+import type { AnyModule } from './core-modules';

 export type Awaitable<T> = PromiseLike<T> | T;

-export type VoidResult = Result<void, void>;
-export type AnyFunction = (...args: any[]) => unknown;
+export type AnyFunction = (...args: unknown[]) => unknown;
+
+// Thanks to @kelsny
+type ParseType<T> = {
+    [K in keyof T]: T[K] extends unknown ? [k: K, args: T[K]] : never;
+}[keyof T];
+
+export type SlashOptions = Omit<CommandInteractionOptionResolver, 'getMessage' | 'getFocused'>;
+
+export type Args = ParseType<{ text: string[]; slash: SlashOptions }>;

 export interface SernEventsMapping {
    'module.register': [Payload];
    'module.activate': [Payload];
-    error: [{ type: 'failure'; module?: Module; reason: string | Error }];
+    error: [Payload];
    warning: [Payload];
    modulesLoaded: [never?];
 }

 export type Payload =
-    | { type: 'success'; module: Module }
-    | { type: 'failure'; module?: Module; reason: string | Error }
-    | { type: 'warning'; module: undefined; reason: string };
+    | { type: PayloadType.Success; module: AnyModule }
+    | { type: PayloadType.Failure; module?: AnyModule; reason: string | Error }
+    | { type: PayloadType.Warning; reason: string };
+
+

-export type UnpackFunction<T> = T extends (...args: any) => infer U ? U : T
-export type UnpackedDependencies = {
-    [K in keyof Dependencies]: UnpackFunction<Dependencies[K]>
-}
 export type ReplyOptions = string | Omit<InteractionReplyOptions, 'fetchReply'> | MessageReplyOptions;
--- a/test/core/contracts.test.ts
+++ b/test/core/contracts.test.ts
@@ -1,11 +1,16 @@
 import { assertType, describe, it } from 'vitest';

-import * as  __Services  from '../../src/core/structures/default-services';
-import * as Contracts from '../../src/core/interfaces';
+import { ModuleStore } from '../../src';
+import * as DefaultContracts from '../../src/core/structures/services';
+import * as Contracts from '../../src/core/contracts/index.js';

 describe('default contracts', () => {
    it('should satisfy contracts', () => {
-        assertType<Contracts.Logging>(new __Services.DefaultLogging());
-        assertType<Contracts.ErrorHandling>(new __Services.DefaultErrorHandling());
+        assertType<Contracts.Logging>(new DefaultContracts.DefaultLogging());
+        assertType<Contracts.ErrorHandling>(new DefaultContracts.DefaultErrorHandling());
+        assertType<Contracts.ModuleManager>(
+            new DefaultContracts.DefaultModuleManager(new ModuleStore()),
+        );
+        assertType<Contracts.CoreModuleStore>(new ModuleStore());
    });
 });
--- a/test/core/create-plugin.test.ts
+++ b/test/core/create-plugin.test.ts
@@ -2,12 +2,17 @@ import { describe, it, expect } from 'vitest';
 import {
    CommandControlPlugin,
    CommandInitPlugin,
+    EventControlPlugin,
    EventInitPlugin,
-} from '../../src';
+} from '../../src/core/create-plugins';
 import { PluginType, controller } from '../../src';

 describe('create-plugins', () => {
    it('should make proper control plugins', () => {
+        const pl = EventControlPlugin(() => controller.next());
+        expect(pl).to.have.all.keys(['type', 'execute']);
+        expect(pl.type).toBe(PluginType.Control);
+        expect(pl.execute).an('function');
        const pl2 = CommandControlPlugin(() => controller.next());
        expect(pl2).to.have.all.keys(['type', 'execute']);
        expect(pl2.type).toBe(PluginType.Control);
--- a/test/core/functions.test.ts
+++ b/test/core/functions.test.ts
@@ -1,13 +1,11 @@
-//@ts-nocheck
-
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { PluginType, SernOptionsData, controller } from '../../src/index';
 import { partitionPlugins, treeSearch } from '../../src/core/functions';
 import { faker } from '@faker-js/faker';
 import { ApplicationCommandOptionType, AutocompleteInteraction } from 'discord.js';

-vi.mock('discord.js', async (importOriginal) => {
-    const mod = await importOriginal()
+vi.mock('discord.js', () => {
+    const Collection = Map;
    const ModalSubmitInteraction = class {
        customId;
        type = 5;
@@ -38,11 +36,35 @@ vi.mock('discord.js', async (importOriginal) => {
    };

    return {
-        Collection: mod.Collection,
-        ComponentType: mod.ComponentType,
-        InteractionType: mod.InteractionType,
-        ApplicationCommandOptionType: mod.ApplicationCommandOptionType,
-        ApplicationCommandType: mod.ApplicationCommandType, 
+        Collection,
+        ComponentType: {
+            Button: 2,
+        },
+        InteractionType: {
+            Ping: 1,
+            ApplicationCommand: 2,
+            MessageComponent: 3,
+            ApplicationCommandAutocomplete: 4,
+            ModalSubmit: 5,
+        },
+        ApplicationCommandOptionType: {
+            Subcommand: 1,
+            SubcommandGroup: 2,
+            String: 3,
+            Integer: 4,
+            Boolean: 5,
+            User: 6,
+            Channel: 7,
+            Role: 8,
+            Mentionable: 9,
+            Number: 10,
+            Attachment: 11,
+        },
+        ApplicationCommandType: {
+            ChatInput: 1,
+            User: 2,
+            Message: 3,
+        },
        ModalSubmitInteraction,
        ButtonInteraction,
        AutocompleteInteraction,
--- a/test/core/id.test.ts
+++ b/test/core/id.test.ts
@@ -1,135 +0,0 @@
-//@ts-nocheck
-import { expect, test, vi } from 'vitest'
-import { CommandType } from '../../src/core/structures/enums';
-
-import * as Id from '../../src/core/id'
-import { ButtonInteraction, ModalSubmitInteraction } from 'discord.js';
-vi.mock('discord.js', async (importOriginal) => {
-    const mod = await importOriginal()
-    const ModalSubmitInteraction = class {
-        customId;
-        type = 5;
-        isModalSubmit = vi.fn();
-        constructor(customId) {
-            this.customId = customId;
-        }
-    };
-    const ButtonInteraction = class {
-        customId;
-        type = 3;
-        componentType = 2;
-        isButton = vi.fn();
-        constructor(customId) {
-            this.customId = customId;
-        }
-    };
-    const AutocompleteInteraction = class {
-        type = 4;
-        option: string;
-        constructor(s: string) {
-            this.option = s;
-        }
-        options = {
-            getFocused: vi.fn(),
-            getSubcommand: vi.fn(),
-        };
-    };
-
-    return {
-        Collection: mod.Collection,
-        ComponentType: mod.ComponentType,
-        InteractionType: mod.InteractionType,
-        ApplicationCommandOptionType: mod.ApplicationCommandOptionType,
-        ApplicationCommandType: mod.ApplicationCommandType, 
-        ModalSubmitInteraction,
-        ButtonInteraction,
-        AutocompleteInteraction,
-    };
-});
-test('id -> Text', () => {
-    expect(Id.create("ping", CommandType.Text)).toBe("ping_T")
-})
-
-test('id -> Both', () => {
-    expect(Id.create("ping", CommandType.Both)).toBe("ping_B")
-})
-
-test('id -> CtxMsg', () => {
-    expect(Id.create("ping", CommandType.CtxMsg)).toBe("ping_A3")
-})
-test('id -> CtxUsr', () => {
-    expect(Id.create("ping", CommandType.CtxUser)).toBe("ping_A2")
-})
-test('id -> Modal', () => {
-    expect(Id.create("my-modal", CommandType.Modal)).toBe("my-modal_M");
-})
-
-test('id -> Button', () => {
-    expect(Id.create("my-button", CommandType.Button)).toBe("my-button_C2");
-})
-
-test('id -> Slash', () => {
-    expect(Id.create("myslash", CommandType.Slash)).toBe("myslash_A1");
-})
-
-test('id -> StringSelect', () => {
-    expect(Id.create("mystringselect", CommandType.StringSelect)).toBe("mystringselect_C3");
-})
-
-test('id -> UserSelect', () => {
-    expect(Id.create("myuserselect", CommandType.UserSelect)).toBe("myuserselect_C5");
-})
-
-test('id -> RoleSelect', () => {
-    expect(Id.create("myroleselect", CommandType.RoleSelect)).toBe("myroleselect_C6");
-})
-
-test('id -> MentionSelect', () => {
-    expect(Id.create("mymentionselect", CommandType.MentionableSelect)).toBe("mymentionselect_C7");
-})
-
-test('id -> ChannelSelect', () => {
-    const modal = Id.create("mychannelselect", CommandType.ChannelSelect)
-    expect(modal).toBe("mychannelselect_C8");
-})
-
-test('id reconstruct button', () => {
-    const idload = Id.reconstruct(new ButtonInteraction("btn"))
-    expect(idload[0].id).toBe("btn_C2")
-})
-
-test('id reconstruct button with params', () => {
-    const idload = Id.reconstruct(new ButtonInteraction("btn/asdf"))
-    expect(idload[0].id).toBe("btn_C2")
-    expect(idload[0].params).toBe("asdf")
-})
-test('id reconstruct modal with params', () => {
-    const idload = Id.reconstruct(new ModalSubmitInteraction("btn/asdf"))
-    expect(idload[0].id).toBe("btn_M")
-    expect(idload[0].params).toBe("asdf")
-})
-test('id reconstruct modal', () => {
-    const idload = Id.reconstruct(new ModalSubmitInteraction("btn"))
-    expect(idload[0].id).toBe("btn_M")
-    expect(idload[0].params).toBe(undefined)
-})
-test('id reconstruct button with empty params', () => {
-    const idload = Id.reconstruct(new ButtonInteraction("btn/"))
-    expect(idload[0].id).toBe("btn_C2")
-    expect(idload[0].params).toBe("")
-})
-test('id reconstruct with multiple slashes', () => {
-    const idload = Id.reconstruct(new ButtonInteraction("btn//"))
-    expect(idload[0].id).toBe("btn_C2")
-    expect(idload[0].params).toBe("/")
-})
-
-
-test('id reconstruct button', () => {
-    const idload = Id.reconstruct(new ButtonInteraction("btn"))
-    expect(idload[0].id).toBe("btn_C2")
-    expect(idload[0].params).toBe(undefined)
-})
-
-
-
--- a/test/core/ioc.test.ts
+++ b/test/core/ioc.test.ts
@@ -0,0 +1,86 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { CoreContainer } from '../../src/core/ioc/container';
+import { EventEmitter } from 'events';
+import { DefaultLogging, Disposable, Init, Logging } from '../../src/core';
+import { CoreDependencies } from '../../src/types/ioc';
+
+describe('ioc container', () => {
+    let container: CoreContainer<{}> = new CoreContainer();
+    let dependency: Logging & Init & Disposable;
+    beforeEach(() => {
+        dependency = {
+            init: vi.fn(),
+            error(): void {},
+            warning(): void {},
+            info(): void {},
+            debug(): void {},
+            dispose: vi.fn()
+        };
+        container = new CoreContainer();
+    });
+    const wait = (seconds: number) =>  new Promise((resolve) => setTimeout(resolve, seconds));
+    class DB implements Init, Disposable {
+      public connected = false
+      constructor() {}
+      async init() {
+        this.connected = true
+        await wait(10)
+      }
+      async dispose() {
+        await wait(20)
+        this.connected = false
+      }
+    }
+    it('should be ready after calling container.ready()', () => {
+        container.ready();
+        expect(container.isReady()).toBe(true);
+    });
+    it('should container all core dependencies', async () => {
+        const keys = [
+            '@sern/modules',
+            '@sern/emitter',
+            '@sern/logger',
+            '@sern/errors',
+        ] satisfies (keyof CoreDependencies)[];
+        container.add({
+            '@sern/logger': () => new DefaultLogging(),
+            '@sern/client': () => new EventEmitter(),
+        });
+        for (const k of keys) {
+            //@ts-expect-error typings for iti are strict
+            expect(() => container.get(k)).not.toThrow();
+        }
+    });
+    it('should init modules', () => {
+        container.upsert({ '@sern/logger': dependency });
+        container.ready();
+        expect(dependency.init).to.toHaveBeenCalledOnce();
+    });
+    it('should dispose modules', async () => {
+        
+        container.upsert({ '@sern/logger': dependency })
+
+        container.ready();
+        // We need to access the dependency at least once to be able to dispose of it.
+        container.get('@sern/logger' as never);
+        await container.disposeAll();
+        expect(dependency.dispose).toHaveBeenCalledOnce();
+    });
+
+    it('should init and dispose', async () => {
+        container.add({ db: new DB() })
+        container.ready()
+        const db = container.get('db' as never) as DB
+        expect(db.connected).toBeTruthy()
+
+        await container.disposeAll();
+
+        expect(db.connected).toBeFalsy()
+    })
+
+    it('should not lazy module', () => {
+        container.upsert({ '@sern/logger': () => dependency });
+        container.ready();
+        expect(dependency.init).toHaveBeenCalledTimes(0);
+    });
+});
--- a/test/core/module-loading.test.ts
+++ b/test/core/module-loading.test.ts
@@ -1,64 +1,22 @@
 import { describe, it, expect } from 'vitest'
-import path from 'node:path'
+import { faker } from '@faker-js/faker'
 import * as Files from '../../src/core/module-loading'
-import { Module } from '../../src/types/core-modules'
-import { AssertionError } from 'node:assert'
-//TODO: mock fs?
 describe('module-loading', () => {
-    it('should get the filename of the commandmodule (linux, esm)', () => {
-        const fname = "///home/pooba/Projects/sern/halibu/dist/commands/ping.js"
-        const callsiteinfo = Files.parseCallsite(fname)
-        expect(callsiteinfo.name).toBe("ping")
+    it('should properly extract filename from file, nested once', () => {
+        const extension = faker.system.fileExt()
+        const name = faker.system.fileName({ extensionCount: 0 })
+        const filename = Files.fmtFileName(name+'.'+extension);
+        expect(filename).toBe(name)
    })
-    it('should get filename of commandmodule (linux, cjs)', () => {
-        const fname = "file:///home/pooba/Projects/sern/halibu/dist/commands/ping.js"
-        const callsiteinfo = Files.parseCallsite(fname)
-        expect(callsiteinfo.name).toBe("ping")
-
-    })
-    it('should get the filename of the commandmodule (windows, cjs)', () => {
-        //this test case is impossible on linux.
-        if(process.platform == 'win32') {
-            const fname = "C:\\pooba\\Projects\\sern\\halibu\\dist\\commands\\ping.js"
-            const callsiteinfo = Files.parseCallsite(fname)
-            expect(callsiteinfo.name).toEqual("ping");
-        }
-    })
-    it('should get filename of commandmodule (windows, esm)', () => {
-        //this test case is impossible on linux.
-        if(process.platform == 'win32') {
-            const fname = "file:///C:\\pooba\\Projects\\sern\\halibu\\dist\\commands\\ping.js"
-            const callsiteinfo = Files.parseCallsite(fname)
-            expect(callsiteinfo.name).toEqual("ping");
-        }
-        
-    })
-
-    it('should import a commandModule properly', async () => {
-        const { module } = await Files.importModule<Module>(path.resolve("test", 'mockules', "module.ts"));
-        expect(module.name).toBe('module')
-    })
-    it('should throw when failed commandModule import', async () => {
-        try {
-            await Files.importModule(path.resolve('test', 'mockules', 'failed.ts'))
-        } catch(e) {
-            expect(e instanceof AssertionError)
-        }
-    })
-    it('should throw when failed commandModule import', async () => {
-        try {
-            await Files.importModule(path.resolve('test', 'mockules', 'failed.ts'))
-        } catch(e) {
-            expect(e instanceof AssertionError)
-        }
-    })
-
-    it('reads all modules in mockules', async () => {
-        const ps = [] as string[]
-        for await (const fpath of Files.readRecursive(path.resolve('test', 'mockules'))) {
-            ps.push(fpath)
-        }
-        expect(ps.length === 4)
-    })
-
+    
+//    todo: handle commands with multiple extensions
+//    it('should properly extract filename from file, nested multiple', () => {
+//        const extension = faker.system.fileExt()
+//        const extension2 = faker.system.fileExt()
+//        const name = faker.system.fileName({ extensionCount: 0 })
+//        const filename = Files.fmtFileName(name+'.'+extension+'.'+extension2);
+//        console.log(filename, name)
+//        expect(filename).toBe(name)
+//
+//    })
 }) 
--- a/test/core/presence.test.ts
+++ b/test/core/presence.test.ts
@@ -1,57 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { Presence } from '../../src';
-
-
-// Example test suite for the module function
-describe('module function', () => {
-  it('should return a valid configuration', () => {
-    const config = Presence.module({
-      inject: ['dependency1', 'dependency2'],
-      execute: vi.fn(),
-    });
-
-    expect(config).toBeDefined();
-    expect(config.inject).toEqual(['dependency1', 'dependency2']);
-    expect(typeof config.execute).toBe('function');
-  });
-});
-
-
-describe('of function', () => {
-  it('should return a valid presence configuration without repeat and onRepeat', () => {
-    const presenceConfig = Presence.of({
-      status: 'online',
-      afk: false,
-      activities: [{ name: 'Test Activity' }],
-      shardId: [1, 2, 3],
-    }).once();
-
-    expect(presenceConfig).toBeDefined();
-    //@ts-ignore Maybe fix?
-    expect(presenceConfig.repeat).toBeUndefined();
-    //@ts-ignore Maybe fix?
-    expect(presenceConfig.onRepeat).toBeUndefined();
-    expect(presenceConfig).toMatchObject({
-      status: 'online',
-      afk: false,
-      activities: [{ name: 'Test Activity' }],
-      shardId: [1, 2, 3],
-    });
-  });
-
-  it('should return a valid presence configuration with repeat and onRepeat', () => {
-    const onRepeatCallback = vi.fn();
-    const presenceConfig = Presence.of({
-      status: 'idle',
-      activities: [{ name: 'Another Test Activity' }],
-    }).repeated(onRepeatCallback, 5000);
-
-    expect(presenceConfig).toBeDefined();
-    expect(presenceConfig.repeat).toBe(5000);
-    expect(presenceConfig.onRepeat).toBe(onRepeatCallback);
-    expect(presenceConfig).toMatchObject({
-      status: 'idle',
-      activities: [{ name: 'Another Test Activity' }],
-    });
-  });
-})
--- a/test/core/services.test.ts
+++ b/test/core/services.test.ts
@@ -0,0 +1,77 @@
+import { SpyInstance, afterAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { CoreContainer } from '../../src/core/ioc/container';
+import { DefaultLogging } from '../../src/core';
+import { faker } from '@faker-js/faker';
+import { commandModule } from '../../src';
+import * as Id from '../../src/core/id';
+import { CommandMeta } from '../../src/types/core-modules';
+
+describe('services', () => {
+    //@ts-ignore
+    let container: CoreContainer<Dependencies>;
+    let consoleMock: SpyInstance;
+    beforeEach(() => {
+        container = new CoreContainer();
+        container.add({ '@sern/logger': () => new DefaultLogging() });
+        container.ready();
+        consoleMock = vi.spyOn(container.get('@sern/logger'), 'error').mockImplementation(() => {});
+    });
+
+    afterAll(() => {
+        consoleMock.mockReset();
+    });
+    it('module-store.ts', async () => {
+        function createRandomCommandModules() {
+            return commandModule({
+                type: faker.number.int({ min: 1 << 0, max: 1 << 10 }),
+                description: faker.string.alpha(),
+                name: faker.string.alpha(),
+                execute: () => {},
+            });
+        }
+
+        const modules = faker.helpers.multiple(createRandomCommandModules, {
+            count: 40,
+        });
+
+        const paths = faker.helpers
+            .multiple(faker.system.directoryPath, { count: 40 })
+            .map((path, i) => `${path}/${modules[i]}.js`);
+
+        const metadata: CommandMeta[] = modules.map((cm, i) => ({
+            id: Id.create(cm.name!, cm.type),
+            isClass: false,
+            fullPath: `${paths[i]}/${cm.name}.js`,
+        }));
+        const moduleManager = container.get('@sern/modules');
+        let i = 0;
+        for (const m of modules) {
+            moduleManager.set(Id.create(m.name!, m.type), paths[i]);
+            moduleManager.setMetadata(m, metadata[i]);
+            i++;
+        }
+        for (const m of modules) {
+            expect(moduleManager.getMetadata(m), 'module references do not exist').toBeDefined();
+        }
+    });
+
+    //todo add more
+    it('error-handling', () => {
+        const errorHandler = container.get('@sern/errors');
+        const lifetime = errorHandler.keepAlive;
+        for (let i = 0; i < lifetime; i++) {
+            if (i == lifetime - 1) {
+                expect(() => errorHandler.updateAlive(new Error('poo'))).toThrowError();
+            } else {
+                expect(() => errorHandler.updateAlive(new Error('poo'))).not.toThrowError();
+            }
+        }
+    });
+    //todo add more, spy on every instance?
+    it('logger', () => {
+        container.get('@sern/logger').error({ message: 'error' });
+
+        expect(consoleMock).toHaveBeenCalledOnce();
+        expect(consoleMock).toHaveBeenLastCalledWith({ message: 'error' });
+    });
+});
--- a/test/handlers.test.ts
+++ b/test/handlers.test.ts
@@ -1,151 +0,0 @@
-//@ts-nocheck
-import { beforeEach, describe, expect, vi, it, test } from 'vitest';
-import { callInitPlugins, eventDispatcher } from '../src/handlers/event-utils';
-
-import { Client, ChatInputCommandInteraction } 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';
-
-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 {
-        '@sern/client': new Client(),
-        '@sern/emitter': new EventEmitter()
-   }
-}
- 
-describe('eventDispatcher standard', () => {
-    let m: Processed<Module>;
-    let ee: EventEmitter;
-    beforeEach(() => {
-        ee = new EventEmitter();
-        m = createRandomModule();
-    });
-
-    it('should throw', () => {
-        expect(() => eventDispatcher(mockDeps(), m,  'not event emitter')).toThrowError();
-    });
-
-    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 () => {
-
-    const expectedObject = { 
-        "plugin/abc": faker.person.jobArea(),
-        "plugin2/abc": faker.git.branch(),
-        "plugin3/cheese": faker.person.jobArea()
-    }
-    
-    const plugin = CommandControlPlugin<CommandType.Slash>((ctx,sdt) => {
-        return controller.next({ "plugin/abc": expectedObject['plugin/abc'] });
-    });
-    const plugin2 = CommandControlPlugin<CommandType.Slash>((ctx,sdt) => {
-        return controller.next({ "plugin2/abc": expectedObject['plugin2/abc'] });
-    });
-    const plugin3 = CommandControlPlugin<CommandType.Slash>((ctx,sdt) => {
-        return controller.next({ "plugin3/cheese": expectedObject['plugin3/cheese'] });
-    });
-    
-})
-
-
--- a/test/handlers/dispatchers.test.ts
+++ b/test/handlers/dispatchers.test.ts
@@ -0,0 +1,45 @@
+import { beforeEach, describe, expect, vi, it } from 'vitest';
+import { createResultResolver, eventDispatcher } from '../../src/handlers/_internal';
+import { faker } from '@faker-js/faker';
+import { Module } from '../../src/core/types/modules';
+import { Processed } from '../../src/handlers/types';
+import { CommandType } from '../../src/core';
+import { EventEmitter } from 'events';
+
+function createRandomModule(): Processed<Module> {
+    return {
+        type: faker.number.int({
+            min: CommandType.Text,
+            max: CommandType.ChannelSelect,
+        }),
+        description: faker.string.alpha(),
+        name: faker.string.alpha(),
+        onEvent: [],
+        plugins: [],
+        execute: vi.fn(),
+    };
+}
+
+describe('eventDispatcher standard', () => {
+    let m: Processed<Module>;
+    let ee: EventEmitter;
+    beforeEach(() => {
+        ee = new EventEmitter();
+        m = createRandomModule();
+    });
+
+    it('should throw', () => {
+        expect(() => eventDispatcher(m, 'not event emitter')).toThrowError();
+    });
+    it("Shouldn't throw", () => {
+        expect(() => eventDispatcher(m, ee)).not.toThrowError();
+    });
+
+    it('Should be called once', () => {
+        const s = eventDispatcher(m, ee);
+        s.subscribe();
+        ee.emit(m.name, faker.string.alpha());
+
+        expect(m.execute).toHaveBeenCalledOnce();
+    });
+});
--- a/test/handlers/id.test.ts
+++ b/test/handlers/id.test.ts
@@ -0,0 +1,72 @@
+import { describe, expect, it, vi } from 'vitest';
+import * as Id from '../../src/core/id';
+import { faker } from '@faker-js/faker';
+import { CommandModule, CommandType, commandModule } from '../../src';
+import { CommandTypeDiscordApi } from '../../src/core/id';
+
+function createRandomCommandModules() {
+    const randomCommandType = [
+        CommandType.Text,
+        CommandType.Both,
+        CommandType.CtxMsg,
+        CommandType.CtxUser,
+        CommandType.Modal,
+        CommandType.ChannelSelect,
+        CommandType.RoleSelect,
+        CommandType.UserSelect,
+        CommandType.StringSelect,
+        CommandType.Button,
+    ];
+    return commandModule({
+        type: faker.helpers.uniqueArray(randomCommandType, 1)[0],
+        description: faker.string.alpha(),
+        name: faker.string.alpha(),
+        execute: () => {},
+    });
+}
+function createMetadata(c: CommandModule) {
+    return {
+        fullPath: faker.system.filePath(),
+        id: Id.create(c.name, c.type),
+        isClass: Boolean(Math.floor(Math.random())),
+    };
+}
+const appBitField = 0b000000001111;
+
+describe('id resolution', () => {
+    it('should resolve application commands correctly', () => {
+        const modules = faker.helpers.multiple(createRandomCommandModules, {
+            count: 20,
+        });
+        const metadata = modules.map(createMetadata);
+        metadata.forEach((meta, idx) => {
+            const associatedModule = modules[idx];
+            const am = (appBitField & associatedModule.type) !== 0 ? 'A' : 'C';
+            let uid = 0;
+            if (
+                associatedModule.type === CommandType.Both ||
+                associatedModule.type === CommandType.Modal
+            ) {
+                uid = 1;
+            } else {
+                uid = CommandTypeDiscordApi[Math.log2(associatedModule.type)];
+            }
+            expect(meta.id).toBe(associatedModule.name + '_' + am + uid);
+        });
+    });
+
+    it('maps commands type to discord components or application commands', () => {
+        expect(CommandTypeDiscordApi[Math.log2(CommandType.Text)]).toBe(1);
+
+        expect(CommandTypeDiscordApi[1]).toBe(1);
+        expect(CommandTypeDiscordApi[Math.log2(CommandType.CtxUser)]).toBe(2);
+        expect(CommandTypeDiscordApi[Math.log2(CommandType.CtxMsg)]).toBe(3);
+        expect(CommandTypeDiscordApi[Math.log2(CommandType.Button)]).toBe(2);
+        expect(CommandTypeDiscordApi[Math.log2(CommandType.StringSelect)]).toBe(3);
+        expect(CommandTypeDiscordApi[Math.log2(CommandType.UserSelect)]).toBe(5);
+        expect(CommandTypeDiscordApi[Math.log2(CommandType.RoleSelect)]).toBe(6);
+        expect(CommandTypeDiscordApi[Math.log2(CommandType.MentionableSelect)]).toBe(7);
+        expect(CommandTypeDiscordApi[Math.log2(CommandType.ChannelSelect)]).toBe(8);
+        expect(CommandTypeDiscordApi[6]).toBe(1);
+    });
+});
--- a/test/mockules/!ignd.ts
+++ b/test/mockules/!ignd.ts
--- a/test/mockules/!ignored/ignored.ts
+++ b/test/mockules/!ignored/ignored.ts
--- a/test/mockules/failed.ts
+++ b/test/mockules/failed.ts
--- a/test/mockules/module.ts
+++ b/test/mockules/module.ts
@@ -1,6 +0,0 @@
-import { CommandType, commandModule } from '../../src/'
-export default commandModule({ 
-    type: CommandType.Both,
-    description: "",
-    execute: (Ctx, args) => {}
-})
--- a/test/mockules/ug/pass.ts
+++ b/test/mockules/ug/pass.ts
@@ -1,6 +0,0 @@
-import { CommandType, commandModule } from '../../../src/'
-export default commandModule({ 
-    type: CommandType.Both,
-    description: "",
-    execute: (Ctx, args) => {}
-})
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -4,17 +4,15 @@
        "strict": true,
        "esModuleInterop": true,
        "strictNullChecks": true,
-        "moduleResolution": "node16",
+        "moduleResolution": "node",
        "skipLibCheck": true,
        "declaration": true,
        "preserveSymlinks": true,
        "allowSyntheticDefaultImports": true,
        "forceConsistentCasingInFileNames": true,
        "isolatedModules": true,
-        "outDir": "dist",
-        "module": "node16",
-        "target": "esnext",
-        "sourceMap": true
+        "module": "esnext",
+        "target": "esnext"
    },
    "exclude": ["node_modules", "dist"],
    "include": ["./src", "./src/**/*.d.ts"]
--- a/tsup.config.js
+++ b/tsup.config.js
@@ -0,0 +1,24 @@
+import { defineConfig } from 'tsup';
+const shared = {
+    entry: ['src/index.ts'],
+    external: ['discord.js', 'iti'],
+    platform: 'node',
+    clean: true,
+    sourcemap: true,
+    treeshake: {
+        moduleSideEffects: false,
+        correctVarValueBeforeDeclaration: true, //need this to treeshake esm discord.js empty import
+        annotations: true,
+    },
+};
+export default defineConfig([
+    {
+        format: ['esm', 'cjs'],
+        target: 'node18',
+        tsconfig: './tsconfig.json',
+        outDir: './dist',
+        minify: false,
+        dts: true,
+        ...shared,
+    },
+ ]);
--- a/yarn.lock
+++ b/yarn.lock
Author	SHA1	Message	Date
jacob	922567ff7b	simplify, remove reply option	2023-11-02 15:16:12 -05:00
jacob	17eb701b5f	decide not to support error handling for autocomplete	2023-11-02 14:19:43 -05:00
jacob	2b07bcc661	extract & refactor	2023-10-12 12:52:50 -05:00
jacob	a2b7158d24	Merge branch 'main' into feat/errors	2023-10-12 12:35:49 -05:00
Jacob Nguyen	56a74ab32a	naive onError handling, not tested	2023-10-04 00:38:18 -05:00
Jacob Nguyen	f2218d02d4	progress on error handling	2023-10-02 22:01:15 -05:00
Jacob Nguyen	e954e2a399	fix merge	2023-10-02 11:07:13 -05:00
jacob	f3ed5354eb	add command error builder	2023-09-28 19:42:36 -05:00
Jacob Nguyen	b1263c1c05	update error handling contract and wire more	2023-09-10 23:52:31 -05:00
Jacob Nguyen	0fbabea428	seems to work	2023-09-10 00:36:32 -05:00
Jacob Nguyen	fa66ff7471	wiring	2023-09-09 12:27:07 -05:00
Jacob Nguyen	c7ee2736b8	type alias	2023-09-09 11:39:04 -05:00
Jacob Nguyen	4591471e7e	update onError to be record	2023-09-09 11:32:11 -05:00
Jacob Nguyen	374a12bb92	fix error callbacks not being stored	2023-09-09 01:08:56 -05:00
Jacob Nguyen	cafca503f9	wiring onError callback through module loader and resolver	2023-09-08 23:11:46 -05:00
Jacob Nguyen	59e7927816	Merge branch 'main' into feat/errors	2023-09-08 14:19:21 -05:00
jacob	a4848743c2	progress on better error handling	2023-08-29 18:09:31 -05:00