chore(main): release 3.3.1 (#350)

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

.eslintrc

@@ -1,11 +0,0 @@
-{
-    "parser": "@typescript-eslint/parser",
-    "extends": ["plugin:@typescript-eslint/recommended"],
-    "parserOptions": { "ecmaVersion": "latest", "sourceType": "script" },
-    "rules": {
-        "@typescript-eslint/no-non-null-assertion": "off",
-        "quotes": [2, "single", { "avoidEscape": true, "allowTemplateLiterals": true }],
-        "semi": ["error", "always"],
-        "@typescript-eslint/no-empty-interface": 0
-    }
-}

.github/FUNDING.yml

@@ -0,0 +1 @@
+open_collective: sern

.github/SECURITY.md

@@ -6,13 +6,43 @@ Project is currently under heavy development but you can try out our [npm packag
 
 | Version | Supported          |
 | ------- | ------------------ |
-| 0.1.0 @ dev | :white_check_mark: |
+| 2.6.1   | YES                |
+| 2.6.0   | YES                |
+| 2.5.3   | YES                |
+| 2.5.2   | YES                |
+| 2.5.1   | YES                |
+| 2.5.0   | YES                |
+| 2.1.1   | NO                 |
+| 2.1.0   | NO                 |
+| 2.0.0   | NO                 |
+| 1.2.1   | NO                 |
+| 1.2.0   | NO                 |
+| 1.1.0   | NO                 |
+1.0.1 | NO
+1.0.0 | NO
+1.1.9 @ beta | NO
+1.1.8 @ beta | NO
+1.1.7 @ beta | NO
+1.1.6 @ beta | NO
+1.1.5 @ beta | NO
+1.1.4 @ beta | NO
+1.1.3 @ beta | NO
+1.1.2 @ beta | NO
+1.1.1 @ beta | NO
+1.1.0 @ beta | NO
+1.0.4 @ beta | NO
+1.0.3 @ beta | NO
+1.0.2 @ beta | NO
+1.0.1 @ beta | NO
+1.0.0 @ beta | NO
+0.0.1 @ dev | NO (TRY IT)
 
-* Dev versions might include bugs, use it with your own risk.
+
+* Dev versions might include bugs and not supported use stable versions.
 
 ## Reporting a Vulnerability
 
-You can report a vulnerability by opening an issue on the [project's GitHub](https://github.com/SernHandler/Sern/issues) repository.
+You can report a vulnerability by opening an issue on the [project's GitHub](https://github.com/sern-handler/handler/issues) repository.
 
 Please provide as much information as possible when reporting a vulnerability. We are looking information for, the affected version, and the steps to reproduce the vulnerability.
 

.github/workflows/codeql-analysis.yml

@@ -1,37 +0,0 @@
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-  schedule:
-    - cron: '37 20 * * 4'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'javascript' ]
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v3
-
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v2
-      with:
-        languages: ${{ matrix.language }}
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v2
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v2

.github/workflows/continuous-integration.yml

@@ -3,11 +3,14 @@ name: Continuous Integration
 on:
   # Trigger the workflow on push or pull request or custom
   push:
-    branches:
+    branches: [main]
-      main
+    paths:
+      - '*.ts'
   pull_request_target:
     branches:
       main
+    paths:
+      - '*ts'
   workflow_dispatch:
 
 jobs:
@@ -17,23 +20,26 @@ jobs:
 
     steps:
       - name: Check out Git repository
-        uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b # tag=v3
+        uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3
 
       - name: Set up Node.js
-        uses: actions/setup-node@2fddd8803e2f5c9604345a0b591c3020ee971a93 # tag=v3
+        uses: actions/setup-node@1a4442cacd436585916779262731d5b162bc6ec7 # v3
         with:
           node-version: 17
 
+      - name: Install pnpm
+        run: npm i -g yarn
+
       # Prettier must be in `package.json`
       - name: Install Node.js dependencies
-        run: npm i -g prettier && npm i
+        run:  yarn --immutable
 
       - name: Run Prettier
-        run: prettier --write .
+        run: yarn pretty
 
       - name: Create Pull Request
         id: cpr
-        uses: peter-evans/create-pull-request@v4
+        uses: peter-evans/create-pull-request@38e0b6e68b4c852a5500a94740f0e535e0d7ba54 # v4
         with:
           commit-message: "style: pretty please"
           branch: prettier

.github/workflows/dependency-review.yml

@@ -15,6 +15,6 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: 'Checkout Repository'
-        uses: actions/checkout@v3
+        uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3
       - name: 'Dependency Review'
-        uses: actions/dependency-review-action@v2
+        uses: actions/dependency-review-action@0efb1d1d84fc9633afcdaad14c485cbbc90ef46c # v2

.github/workflows/npm-publish.yml

@@ -1,30 +1,22 @@
 name: NPM / Publish
 
 on:
-  release:
+  workflow_dispatch:
-    types: [created]
+  # We only publish if the version of sern handler is different. workflow automatically cancels if verson is the same
-
+  push:
+    branches:
+      - 'main'
 jobs:
-  build:
+  test-and-publish:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3
-      - uses: actions/setup-node@v3
+      - uses: actions/setup-node@1a4442cacd436585916779262731d5b162bc6ec7 # v3
         with:
-          node-version: 16
+          node-version: 17
-      - run: npm ci
+      - run: yarn --immutable
-      - run: npm test
+      - run: yarn build:prod
-
+      - uses: JS-DevTools/npm-publish@0f451a94170d1699fd50710966d48fb26194d939 # v1
-  publish-npm:
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
         with:
-          node-version: 16
+          token: ${{ secrets.NPM_TOKEN }}
-          registry-url: https://registry.npmjs.org/
+          access: "public"
-      - run: npm ci
-      - run: npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

.github/workflows/release-please.yml

@@ -6,7 +6,7 @@ jobs:
     release-please:
       runs-on: ubuntu-latest
       steps:
-        - uses: google-github-actions/release-please-action@v3
+        - uses: google-github-actions/release-please-action@db8f2c60ee802b3748b512940dde88eabd7b7e01 # v3
           with:
             release-type: node
             package-name: release-please-action

.github/workflows/test.yml

@@ -0,0 +1,29 @@
+# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
+
+name: Node.js CI
+
+on:
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [18.x, 19.x, 20.x]
+        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+
+    steps:
+    - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@1a4442cacd436585916779262731d5b162bc6ec7 # v3
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+    - run: npm install -g yarn
+    - run: yarn install
+    - run: yarn test

.gitignore

@@ -87,3 +87,13 @@ dist
 
 # IntelliJ IDEA Config file
 .idea/
+
+# Yarn files
+.yarn/install-state.gz
+.yarn/build-state.yml
+
+.yalc
+
+yalc.lock
+
+*.svg

.npmignore

@@ -8,6 +8,7 @@ logs
 npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
+.yarn
 # Runtime data
 pids
 *.pid
@@ -52,6 +53,7 @@ typings/
 .node_repl_history
 
 # Output of 'npm pack'
+
 *.tgz
 
 # Yarn Integrity file
@@ -79,9 +81,7 @@ typings/
 # FuseBox cache
 .fusebox/
 
-# TypeScript build output
+test
-dist
-
 # VisualStudio Config file
 .vs
 
@@ -108,6 +108,8 @@ tsup.config.js
 
 tsconfig-base.json
 
-tsconfig.cjs.json
+tsconfig-cjs.json
 
-tsconfig.esm.json
+tsconfig-esm.json
+
+renovate.json

.prettierrc

@@ -1,8 +0,0 @@
-{
-    "semi": true,
-    "trailingComma": "all",
-    "singleQuote": true,
-    "printWidth": 100,
-    "tabWidth": 4,
-    "arrowParens": "avoid"
-}

.yarnrc.yml

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

CHANGELOG.md

@@ -1,5 +1,190 @@
 # Changelog
 
+## [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)
+
+
+### Features
+
+* add guaranteed `channelId` and `userId` getters to `Context` ([#320](https://github.com/sern-handler/handler/issues/320)) ([50253ca](https://github.com/sern-handler/handler/commit/50253ca322e7d6dbd2313139c0187a1028f71109))
+* dispose hooks (deprecate useContainerRaw) ([#323](https://github.com/sern-handler/handler/issues/323)) ([26ccd11](https://github.com/sern-handler/handler/commit/26ccd118ff8cbcde94158a4d09fc0df18da9f254))
+
+## [3.0.2](https://github.com/sern-handler/handler/compare/v3.0.1...v3.0.2) (2023-08-06)
+
+
+### Bug Fixes
+
+* invalid id for cts, mts, cjs, mjs files, node paths ([#318](https://github.com/sern-handler/handler/issues/318)) ([a7f5ea2](https://github.com/sern-handler/handler/commit/a7f5ea269fb344e221d10dbdc26a1611ffc8138f))
+
+## [3.0.1](https://github.com/sern-handler/handler/compare/v3.0.0...v3.0.1) (2023-08-05)
+
+
+### Bug Fixes
+
+* collectors ([4134460](https://github.com/sern-handler/handler/commit/41344608c677b6069c46412f5f16e4337182ca7d))
+
+## [3.0.0](https://github.com/sern-handler/handler/compare/v2.6.3...v3.0.0) (2023-07-29)
+
+
+### ⚠ BREAKING CHANGES
+
+* v3 ([#294](https://github.com/sern-handler/handler/issues/294))
+
+### Features
+
+* v3 ([#294](https://github.com/sern-handler/handler/issues/294)) ([7798e36](https://github.com/sern-handler/handler/commit/7798e36458c7f555d2bcb8a5857a6db47b7211da))
+
+
+### Miscellaneous Chores
+
+* release 3.0.0 ([70cca0d](https://github.com/sern-handler/handler/commit/70cca0dbb01e70b47a8c899b1fc4f43dee5ed8ed))
+
+## [2.6.3](https://github.com/sern-handler/handler/compare/v2.6.2...v2.6.3) (2023-06-17)
+
+
+### Bug Fixes
+
+* autocomplete nested option and merge main ([5fdc1ed](https://github.com/sern-handler/handler/commit/5fdc1eda7f4fcc1f94af7eca661660c0edeb3251))
+
+## [2.6.2](https://github.com/sern-handler/handler/compare/v2.6.1...v2.6.2) (2023-04-15)
+
+
+### Miscellaneous Chores
+
+* release 2.6.2 ([c1f6906](https://github.com/sern-handler/handler/commit/c1f690633c55ba41db1e035b7c16f9e19c70b385))
+
+## [2.6.1](https://github.com/sern-handler/handler/compare/v2.6.0...v2.6.1) (2023-03-17)
+
+
+### Miscellaneous Chores
+
+* release 2.6.1 ([f9609ce](https://github.com/sern-handler/handler/commit/f9609ce6cd777fa0eb595d8c48d57905bbce5966))
+
+## [2.6.0](https://github.com/sern-handler/handler/compare/v2.5.3...v2.6.0) (2023-03-09)
+
+
+### Features
+
+* adding pure annotation for better tree shaking ([d20d015](https://github.com/sern-handler/handler/commit/d20d01524b872549da501e21feec147ab204f397))
+
+## [2.5.3](https://github.com/sern-handler/handler/compare/v2.5.2...v2.5.3) (2023-02-16)
+
+
+### Miscellaneous Chores
+
+* release 2.5.3 ([ce9a083](https://github.com/sern-handler/handler/commit/ce9a0831a6e47dd38648f34653f0bd89b1d2e48e))
+
+## [2.5.2](https://github.com/sern-handler/handler/compare/v2.5.1...v2.5.2) (2023-02-16)
+
+
+### Reverts
+
+* version ([facee79](https://github.com/sern-handler/handler/commit/facee79c904ad663d3c57ce56fb825419fcc12f9))
+
+## [2.5.1](https://github.com/sern-handler/handler/compare/v2.5.0...v2.5.1) (2023-02-12)
+
+
+### Features
+
+* Adding my bot to readme ([#210](https://github.com/sern-handler/handler/issues/210)) ([96f4281](https://github.com/sern-handler/handler/commit/96f42811218e4898a47e75a8138ccd452ae2c5c2))
+* Adding the WIP to my bot ([86fa531](https://github.com/sern-handler/handler/commit/86fa531eb620d2ac649bad6decb29d5c55a25445))
+
+
+### Bug Fixes
+
+* autocomplete ([1860b89](https://github.com/sern-handler/handler/commit/1860b898f3a231840e2a8b781e007ef9d6f587a4))
+
+
+### Miscellaneous Chores
+
+* release 2.5.1 ([c78936a](https://github.com/sern-handler/handler/commit/c78936a22574da4af71826f5b5f72f354a4eb06a))
+
+## [2.5.0](https://github.com/sern-handler/handler/compare/v2.1.1...v2.5.0) (2023-01-30)
+
+
+### ⚠ BREAKING CHANGES
+
+* simpler plugins ([#193](https://github.com/sern-handler/handler/issues/193))
+
+### Features
+
+* simpler plugins ([#193](https://github.com/sern-handler/handler/issues/193)) ([33f1446](https://github.com/sern-handler/handler/commit/33f14467ec413e003a82503c8a77cb42a6194281))
+
+
+### Miscellaneous Chores
+
+* release 2.5.0 ([b4b195d](https://github.com/sern-handler/handler/commit/b4b195dc9586736760d0b78caa8589f3d6131f8a))
+
+## [2.1.1](https://github.com/sern-handler/handler/compare/v2.1.0...v2.1.1) (2022-12-31)
+
+
+### Bug Fixes
+
+* modals remapping ([a13df6f](https://github.com/sern-handler/handler/commit/a13df6fb424d256476284da49024dbe56e82baab))
+
+## [2.1.0](https://github.com/sern-handler/handler/compare/v2.0.0...v2.1.0) (2022-12-30)
+
+
+### Features
+
+* grammar ([c30aac4](https://github.com/sern-handler/handler/commit/c30aac476cdc2094de34f9f67b5805204cc5e4dd))
+
+
+### Bug Fixes
+
+* multi parameter events ([e986535](https://github.com/sern-handler/handler/commit/e98653593566ef4635493e0c997bd107a7a3a2a2))
+
+## [2.0.0](https://github.com/sern-handler/handler/compare/v1.2.1...v2.0.0) (2022-12-28)
+
+
+### ⚠ BREAKING CHANGES
+
+* (2.0 global services) ([#156](https://github.com/sern-handler/handler/issues/156))
+
+### Features
+
+* (2.0 global services) ([#156](https://github.com/sern-handler/handler/issues/156)) ([1455622](https://github.com/sern-handler/handler/commit/14556223fd6f79b797fb2aee03e795d4f4e94a8b))
+
 ## [1.2.1](https://github.com/sern-handler/handler/compare/v1.2.0...v1.2.1) (2022-10-03)
 
 

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-**Copyright (c) 2022 Sern**
+Copyright (c) 2023 sern
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -19,5 +19,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
-
-End license text.

README.md

@@ -3,87 +3,75 @@
 </div>
 
 <h1 align="center">Handlers. Redefined.</h1>
-<h4 align="center">A customizable, batteries-included, powerful discord.js framework to streamline bot development.</h4>
+<h4 align="center">A complete, customizable, typesafe, & reactive framework for discord bots</h4>
 
 <div align="center" styles="margin-top: 10px">
   <img src="https://img.shields.io/badge/open-source-brightgreen" />
   <a href="https://www.npmjs.com/package/@sern/handler"><img src="https://img.shields.io/npm/v/@sern/handler?maxAge=3600" alt="NPM version" /></a>
   <a href="https://www.npmjs.com/package/@sern/handler"><img src="https://img.shields.io/npm/dt/@sern/handler?maxAge=3600" alt="NPM downloads" /></a>
   <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/license-MIT-brightgreen" alt="License MIT" /></a>
-  <a href="https://sern-handler.js.org"><img alt="docs.rs" src="https://img.shields.io/docsrs/docs" /></a>
+  <a href="https://sern.dev"><img alt="docs.rs" src="https://img.shields.io/docsrs/docs" /></a>
   <img alt="Lines of code" src="https://img.shields.io/badge/total%20lines-2k-blue" />
 </div>
 
+## Why?
+- For you. A framework that's tailored to your exact needs.
+- Lightweight. Does a lot while being small.
+- Latest features. Support for discord.js v14 and all of its interactions.
+- Start quickly. Plug and play or customize to your liking.
+- works with [bun](https://bun.sh/) and [node](https://nodejs.org/en) out the box!
+- 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
-```
-
-## 👀 Quick Look
-
-* Support for discord.js v14 and all interactions
-* Hybrid commands
-* lightweight and customizable
-* ESM, CommonJS and TypeScript support
-* A powerful cli and awesome community-made plugins
 
 ## 👶 Basic Usage
+<details><summary>ping.ts</summary>
 
-#### ` index.js (CommonJS)`
+```ts
-
+export default commandModule({
-```js
-// Import the discord.js Client and GatewayIntentBits
-const { Client, GatewayIntentBits } = require('discord.js');
-
-// Import Sern namespace
-const { Sern } = require('@sern/handler');
-
-// Our configuration file
-const { defaultPrefix, token } = require('./config.json');
-
-const client = new Client({
-  intents: [
-    GatewayIntentBits.Guilds,
-    GatewayIntentBits.GuildMembers,
-    GatewayIntentBits.GuildMessages
-  ]
-});
-
-Sern.init({
-  client,   
-  defaultPrefix,   
-  commands : 'src/commands',
-});
-
-client.login(token);
-```
-
-#### ` ping.js (CommonJS)`
-
-```js
-const { CommandType, commandModule } = require('@sern/handler');
-
-exports.default = commandModule({
-  name: 'ping',
-  description: 'A ping pong command',
   type: CommandType.Slash,
+  //Installed plugin to publish to discord api and allow access to owners only.
+  plugins: [publish(), ownerOnly()],
+  description: 'A ping pong command',
   execute(ctx) {
-    ctx.reply('pong!');
+    ctx.reply('Hello owner of the bot');
   }
 });
 ```
+</details>
+<details><summary>modal.ts</summary>
 
-See our [templates](https://github.com/sern-handler/templates) for TypeScript examples and more
+```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>
+
+
+## 🤖 Bots Using sern 
+- [Community Bot](https://github.com/sern-handler/sern-community), the community bot for our [discord server](https://sern.dev/discord).
+- [Vinci](https://github.com/SrIzan10/vinci), the bot for Mara Turing.
+- [Bask](https://github.com/baskbotml/bask), Listen your favorite artists on Discord.
+- [ava](https://github.com/SrIzan10/ava), A discord bot that plays KNGI and Gensokyo Radio.
+- [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.
 
 ## 💻 CLI
 
@@ -91,15 +79,11 @@ It is **highly encouraged** to use the [command line interface](https://github.c
 
 ## 🔗 Links
 
-- [Official Documentation and Guide](https://sern-handler.js.org)
+- [Official Documentation and Guide](https://sern.dev)
-- [Support Server](https://discord.com/invite/mmyCTnYtbF)
+- [Support Server](https://sern.dev/discord)
 
 ## 👋 Contribute
-
+- Read our contribution [guidelines](https://github.com/sern-handler/handler/blob/main/.github/CONTRIBUTING.md) carefully
-- Read our contribution [guidelines](https://github.com/sern-handler/handler) carefully
 - Pull up on [issues](https://github.com/sern-handler/handler/issues) and report bugs
 - All kinds of contributions are welcomed.
 
-## 🚈 Roadmap
-
-You can check our [roadmap](https://github.com/sern-handler/roadmap) to see what's going to be added or patched in the future.

fortnite

@@ -0,0 +1 @@
+

package.json

@@ -1,23 +1,29 @@
 {
     "name": "@sern/handler",
-    "version": "1.2.1",
+    "packageManager": "yarn@3.5.0",
-    "description": "A customizable, batteries-included, powerful discord.js framework to automate and streamline bot development.",
+    "version": "3.3.1",
-    "main": "dist/cjs/index.cjs",
+    "description": "A complete, customizable, typesafe, & reactive framework for discord bots.",
-    "module": "dist/esm/index.mjs",
+    "main": "./dist/index.js",
-    "types": "dist/index.d.ts",
+    "module": "./dist/index.mjs",
+    "types": "./dist/index.d.ts",
     "exports": {
         ".": {
-            "import": "./dist/esm/index.mjs",
+            "import": "./dist/index.mjs",
-            "require": "./dist/cjs/index.cjs"
+            "require": "./dist/index.js",
+            "types": "./dist/index.d.ts"
         }
     },
     "scripts": {
-        "watch": "tsup --watch --dts",
+        "watch": "tsup --watch",
-        "clean-modules": "rimraf node_modules/ && npm install",
         "lint": "eslint src/**/*.ts",
         "format": "eslint src/**/*.ts --fix",
-        "build": "tsup && node scripts/mkjson.mjs dist/cjs dist/esm && tsup --dts-only --outDir dist",
+        "build:dev": "tsup --metafile",
-        "publish": "npm run build && npm publish"
+        "build:prod": "tsup ",
+        "prepare": "npm run build:prod",
+        "pretty": "prettier --write .",
+        "tdd": "vitest",
+        "test": "vitest --run",
+        "analyze-imports": "npx depcruise src --include-only \"^src\" --output-type dot | dot -T svg > dependency-graph.svg"
     },
     "keywords": [
         "sern-handler",
@@ -31,24 +37,63 @@
     "author": "SernDevs",
     "license": "MIT",
     "dependencies": {
-        "rxjs": "^7.5.6",
+        "callsites": "^3.1.0",
-        "ts-pattern": "^4.0.2",
+        "iti": "^0.6.0",
-        "ts-results-es": "^3.5.0"
+        "rxjs": "^7.8.0",
+        "ts-results-es": "^4.0.0"
     },
     "devDependencies": {
-        "@typescript-eslint/eslint-plugin": "5.36.1",
+        "@faker-js/faker": "^8.0.1",
-        "@typescript-eslint/parser": "5.36.2",
+        "@types/node": "^18.15.11",
-        "eslint": "8.22.0",
+        "@typescript-eslint/eslint-plugin": "5.58.0",
-        "prettier": "2.7.1",
+        "@typescript-eslint/parser": "5.59.1",
-        "tsup": "^6.1.3",
+        "discord.js": "^14.11.0",
-        "typescript": "^4.8.3"
+        "esbuild": "^0.17.0",
+        "eslint": "8.39.0",
+        "prettier": "2.8.8",
+        "tsup": "^6.7.0",
+        "typescript": "5.0.2",
+        "vitest": "latest"
     },
-    "peerDependencies": {
+    "prettier": {
-        "discord.js": "^14.5.x"
+        "semi": true,
+        "trailingComma": "all",
+        "singleQuote": true,
+        "printWidth": 100,
+        "tabWidth": 4,
+        "arrowParens": "avoid"
+    },
+    "eslintConfig": {
+        "parser": "@typescript-eslint/parser",
+        "extends": [
+            "plugin:@typescript-eslint/recommended"
+        ],
+        "parserOptions": {
+            "ecmaVersion": "latest",
+            "sourceType": "script"
+        },
+        "rules": {
+            "@typescript-eslint/no-non-null-assertion": "off",
+            "quotes": [
+                2,
+                "single",
+                {
+                    "avoidEscape": true,
+                    "allowTemplateLiterals": true
+                }
+            ],
+            "semi": [
+                "error",
+                "always"
+            ],
+            "@typescript-eslint/no-empty-interface": 0,
+            "@typescript-eslint/ban-types": 0,
+            "@typescript-eslint/no-explicit-any": "off"
+        }
     },
     "repository": {
         "type": "git",
         "url": "git+https://github.com/sern-handler/handler.git"
     },
-    "homepage": "https://sern-handler.js.org"
+    "homepage": "https://sern.dev"
 }

renovate.json

@@ -1,4 +1,9 @@
 {
+    "extends": [
+        "config:base",
+        "helpers:pinGitHubActionDigests",
+        "group:allNonMajor"
+    ],
     "major": {
         "dependencyDashboardApproval": true,
         "reviewers": ["EvolutionX-10", "jacoobes", "Murtatrxx"]
@@ -9,6 +14,6 @@
     "schedule": ["every weekend"],
     "lockFileMaintenance": {
         "enabled": true,
-        "automerge": false
+        "automerge": true
     }
 }

scripts/mkjson.mjs

@@ -1,13 +0,0 @@
-import { writeFile } from 'fs/promises';
-import { join } from 'path';
-// A quick script to regenerate package.jsons for each cjs and esm after tsup cleans distributions
-const locations = process.argv;
-locations.shift();
-locations.shift();
-for (const loc of locations) {
-    if (loc.endsWith('cjs')) {
-        await writeFile(join(loc, 'package.json'), JSON.stringify({ type: 'commonjs' }));
-    } else {
-        await writeFile(join(loc, 'package.json'), JSON.stringify({ type: 'module' }));
-    }
-}

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'

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>;
+}

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;
+}

src/core/contracts/error-handling.ts

@@ -0,0 +1,18 @@
+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.
+     * @param error
+     */
+    updateAlive(error: Error): void;
+
+}

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'

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>;
+}

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 };

src/core/contracts/module-manager.ts

@@ -0,0 +1,27 @@
+import type {
+    CommandMeta,
+    CommandModule,
+    CommandModuleDefs,
+    Module,
+} from '../../types/core-modules';
+import { CommandType } from '../structures';
+
+interface MetadataAccess {
+    getMetadata(m: Module): CommandMeta | undefined;
+    setMetadata(m: Module, c: CommandMeta): void;
+}
+
+/**
+ * @since 2.0.0
+ * @internal - direct access to the module manager will be removed in version 4
+ */
+export interface ModuleManager extends MetadataAccess {
+    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;
+}

src/core/contracts/module-store.ts

@@ -0,0 +1,9 @@
+import type { CommandMeta, Module } 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>;
+}

src/core/create-plugins.ts

@@ -0,0 +1,72 @@
+import { CommandType, EventType, PluginType } from './structures';
+import type { Plugin, PluginResult, EventArgs, CommandArgs } from '../types/core-plugin';
+import type { ClientEvents } from 'discord.js';
+import { err, ok } from './functions';
+
+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);
+}
+
+/**
+ * @since 1.0.0
+ * The object passed into every plugin to control a command's behavior
+ */
+export const controller = {
+    next: ok,
+    stop: err,
+};

src/core/functions.ts

@@ -0,0 +1,83 @@
+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';
+
+//function wrappers for empty ok / err
+export const ok = /* @__PURE__*/ () => Ok.EMPTY;
+export const err = /* @__PURE__*/ () => Err.EMPTY;
+
+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;
+        }
+    }
+    return [controlPlugins, initPlugins];
+}
+
+/**
+ * Uses an iterative DFS to check if an autocomplete node exists on the option tree
+ * @param iAutocomplete
+ * @param options
+ */
+export function treeSearch(
+    iAutocomplete: AutocompleteInteraction,
+    options: SernOptionsData[] | undefined,
+): SernAutocompleteData & { parent?: string } | undefined {
+    if (options === undefined) return undefined;
+    //clone to prevent mutation of original command module
+    const _options = options.map(a => ({ ...a }));
+    let subcommands = new Set();
+    while (_options.length > 0) {
+        const cur = _options.pop()!;
+        switch (cur.type) {
+            case ApplicationCommandOptionType.Subcommand:
+                {
+                    subcommands.add(cur.name);
+                    for (const option of cur.options ?? []) _options.push(option);
+                }
+                break;
+            case ApplicationCommandOptionType.SubcommandGroup:
+                {
+                    for (const command of cur.options ?? []) _options.push(command);
+                }
+                break;
+            default:
+                {
+                    if ('autocomplete' in cur && cur.autocomplete) {
+                        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;
+        }
+    }
+}

src/core/id.ts

@@ -0,0 +1,74 @@
+import { ApplicationCommandType, ComponentType, Interaction, InteractionType } from 'discord.js';
+import { CommandType, EventType } from './structures';
+
+/**
+ * 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.
+ */
+export function reconstruct<T extends Interaction>(event: T) {
+    switch (event.type) {
+        case InteractionType.MessageComponent: {
+            return [`${event.customId}_C${event.componentType}`];
+        }
+        case InteractionType.ApplicationCommand:
+        case InteractionType.ApplicationCommandAutocomplete: {
+            return [`${event.commandName}_A${event.commandType}`, `${event.commandName}_B`];
+        }
+        //Modal interactions are classified as components for sern
+        case InteractionType.ModalSubmit: {
+            return [`${event.customId}_M`];
+        }
+    }
+}
+/**
+ *
+ * A magic number to represent any commandtype that is an ApplicationCommand.
+ */
+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.Modal, InteractionType.ModalSubmit],
+    [CommandType.StringSelect, ComponentType.StringSelect],
+    [CommandType.UserSelect, ComponentType.UserSelect],
+    [CommandType.MentionableSelect, ComponentType.MentionableSelect],
+    [CommandType.RoleSelect, ComponentType.RoleSelect],
+    [CommandType.ChannelSelect, 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) {
+    return TypeMap.get(t)!;
+}
+
+/*
+ * Generates an id based on name and CommandType.
+ * A is for any ApplicationCommand. C is for any ComponentCommand
+ * 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 = (appBitField & type) !== 0 ? 'A' : 'C';
+    return `${name}_${am}${apiType(type)}`
+}
+
+
+

src/core/index.ts

@@ -0,0 +1,4 @@
+export * from './contracts';
+export * from './create-plugins';
+export * from './structures';
+export * from './ioc';

src/core/ioc/base.ts

@@ -0,0 +1,111 @@
+import * as assert from 'assert';
+import { composeRoot, useContainer } from './dependency-injection';
+import type { DependencyConfiguration } from '../../types/ioc';
+import { CoreContainer } from './container';
+import { Result } from 'ts-results-es'
+import { DefaultServices } from '../_internal';
+import { AnyFunction } from '../../types/utility';
+import type { Logging } from '../contracts/logging';
+//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;
+}
+
+export function disposeAll(logger: Logging|undefined) {
+    containerSubject
+        ?.disposeAll()
+        .then(() => logger?.info({ message: 'Cleaning container and crashing' }));
+}
+
+const dependencyBuilder = (container: any, excluded: string[]) => {
+    type Insertable = 
+        | ((container: CoreContainer<Dependencies>) => unknown )
+        | Record<PropertyKey, unknown>
+    return {
+        /**
+          * Insert a dependency into your container.
+          * Supply the correct key and dependency
+          */
+        add(key: keyof Dependencies, v: Insertable) {
+            Result
+                .wrap(() => container.add({ [key]: v}))
+                .expect("Failed to add " + key);
+        },
+        /**
+          * Exclude any dependencies from being added.
+          * Warning: this could lead to bad errors if not used correctly
+          */
+        exclude(...keys: (keyof Dependencies)[]) {
+            keys.forEach(key => excluded.push(key));
+        },
+        /**
+          * @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) {
+            Result
+                .wrap(() => container.upsert({ [key]: v }))
+                .expect("Failed to update " + key);
+        },
+        /**
+          * @param key the key of the dependency
+          * @param cleanup Provide cleanup for the dependency at key. First parameter is the dependency itself 
+          * @example
+          * ```ts 
+          * addDisposer('dbConnection', (dbConnection) => dbConnection.end())
+          * ```
+          * Swap out a preexisting dependency.
+          */
+        addDisposer(key: keyof Dependencies, cleanup: AnyFunction) {
+            Result
+                .wrap(() => container.addDisposer({ [key] : cleanup }))
+                .expect("Failed to addDisposer for" + key);
+        }
+   };
+};
+
+type CallbackBuilder = (c: ReturnType<typeof dependencyBuilder>) => any
+
+type ValidDependencyConfig =
+    | CallbackBuilder
+    | DependencyConfiguration;
+    
+export const insertLogger = (containerSubject: CoreContainer<any>) => {
+    containerSubject
+        .upsert({'@sern/logger': () => new DefaultServices.DefaultLogging});
+}
+export async function makeDependencies<const T extends Dependencies>
+(conf: ValidDependencyConfig) {
+    containerSubject = new CoreContainer();
+    if(typeof conf === 'function') {
+        const excluded: string[] = [];
+        conf(dependencyBuilder(containerSubject, excluded));
+
+        if(!excluded.includes('@sern/logger') 
+           && !containerSubject.getTokens()['@sern/logger']) {
+            insertLogger(containerSubject);
+        }
+
+        containerSubject.ready();
+    } else {
+        composeRoot(containerSubject, conf);
+    }
+
+    return useContainer<T>();
+}
+
+
+

src/core/ioc/container.ts

@@ -0,0 +1,53 @@
+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();
+    }
+}

src/core/ioc/dependency-injection.ts

@@ -0,0 +1,77 @@
+import type { CoreDependencies, DependencyConfiguration, IntoDependencies } from '../../types/ioc';
+import { insertLogger, 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 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) {
+        insertLogger(container);
+    }
+    //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>;
+}

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
+    }
+}

src/core/ioc/index.ts

@@ -0,0 +1,2 @@
+export { makeDependencies } from './base';
+export { Service, Services, single, transient } from './dependency-injection';

src/core/module-loading.ts

@@ -0,0 +1,140 @@
+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 } from '../types/core-modules';
+import { existsSync } from 'fs';
+import { fileURLToPath } from 'node:url';
+
+export const shouldHandle = (path: string, fpath: string) => {
+    const newPath = new URL(fpath+extname(path), path).href;
+    return {
+        exists: existsSync(fileURLToPath(newPath)),
+        path: newPath
+    }
+}
+
+
+export type ModuleResult<T> = Promise<ImportPayload<T>>;
+/**
+ * Import any module based on the absolute path.
+ * This can accept four types of exported modules
+ * commonjs, javascript :
+ * ```js
+ * exports = commandModule({ })
+ *
+ * //or
+ * exports.default = commandModule({ })
+ * ```
+ * esm javascript, typescript, and commonjs typescript
+ * export default commandModule({})
+ */
+export async function importModule<T>(absPath: string) {
+    let fileModule = await import(absPath);
+
+    let commandModule = fileModule.default;
+
+    assert(commandModule , `Found no export @ ${absPath}. Forgot to ignore with "!"? (!${basename(absPath)})?`);
+    if ('default' in commandModule ) {
+        commandModule = commandModule.default;
+    }
+    return Result
+        .wrap(() => ({ module: commandModule.getInstance()  }))
+        .unwrapOr({ module: commandModule }) as T;
+}
+
+export async function defaultModuleLoader<T extends Module>(absPath: string): ModuleResult<T> {
+    let { module } = await importModule<{ module: T }>(absPath);
+    assert(module, `Found an undefined module: ${absPath}`);
+    return { module, absPath };
+}
+
+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),
+    };
+}
+
+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;
+                }
+            }
+        }
+    } 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,
+    };
+    
+}

src/core/modules.ts

@@ -0,0 +1,113 @@
+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,
+} from '../types/core-modules';
+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): CommandModule {
+    const [onEvent, plugins] = partitionPlugins(mod.plugins);
+    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): EventModule {
+    const [onEvent, plugins] = partitionPlugins(mod.plugins);
+    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;
+    plugins?: AnyEventPlugin[];
+    execute: (...args: ClientEvents[T]) => Awaitable<unknown>;
+}) {
+    return eventModule({
+        type: EventType.Discord,
+        ...mod,
+    });
+}
+
+
+/**
+ * @deprecated
+ */
+function prepareClassPlugins(c: Module) {
+    const [onEvent, initPlugins] = partitionPlugins(c.plugins);
+    c.plugins = initPlugins as InitPlugin[];
+    c.onEvent = onEvent as ControlPlugin[];
+}
+
+/**
+ * @deprecated
+ * Will be removed 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>;
+}
+
+/**
+  * @deprecated
+  * Will be removed 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>;
+}

src/core/operators.ts

@@ -0,0 +1,83 @@
+/**
+ * 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));
+}
+
+interface PluginExecutable {
+    execute: (...args: unknown[]) => PluginResult;
+};
+/**
+ * Calls any plugin with {args}.
+ * @param args if an array, its spread and plugin called.
+ */
+export function callPlugin(args: unknown): OperatorFunction<PluginExecutable, 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
+        }))
+
+

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;
+}

src/core/presences.ts

@@ -0,0 +1,70 @@
+import type { ActivitiesOptions } from "discord.js";
+import type { IntoDependencies } from "../types/ioc";
+import type { Emitter } from "./contracts/emitter";
+
+type Status = 'online' | 'idle' | 'invisible' | 'dnd'
+type PresenceReduce = (previous: Result) => Result;
+
+export interface Result { 
+    status?: Status;
+    afk?: boolean;
+    activities?: ActivitiesOptions[];
+    shardId?: number[];
+    repeat?: number | [Emitter, string];
+    onRepeat?: (previous: Result) => Result; 
+}
+
+export type Config <T extends (keyof Dependencies)[]> = 
+{
+    inject?: [...T]
+    execute: (...v: IntoDependencies<T>) => Result;
+};
+
+/**
+  * 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.
+  */
+export function module<T extends (keyof Dependencies)[]>
+(conf: Config<T>) {
+    return 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.
+  */
+export function of(root: Omit<Result, 'repeat' | 'onRepeat'>) {
+    return { 
+        /**
+         * @example
+         * Presence
+         *     .of({ 
+         *          activities: [{ name: "deez nuts" }] 
+         *     }) //starts the 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 returned one.
+         */
+        repeated: (onRepeat: PresenceReduce, repeat: number | [Emitter, string]) => {
+            return { repeat, onRepeat, ...root }
+        },
+        /**
+         * @example
+         * Presence
+         *     .of({
+         *        activities: [
+         *          { name: "Chilling out" }
+         *        ]
+         *      })
+         *     .once() // Sets the presence once, with what's provided in '.of()'
+         */
+        once: () => root
+    };
+}
+

src/core/structures/context.ts

@@ -0,0 +1,127 @@
+import {
+    BaseInteraction,
+    ChatInputCommandInteraction,
+    Client,
+    InteractionReplyOptions,
+    Message,
+    MessageReplyOptions,
+    Snowflake,
+    User,
+} from 'discord.js';
+import { CoreContext } from '../structures/core-context';
+import { Result, Ok, Err } from 'ts-results-es';
+import * as assert from 'assert';
+import { ReplyOptions } from '../../types/utility';
+
+
+/**
+ * @since 1.0.0
+ * Provides values shared between
+ * Message and ChatInputCommandInteraction
+ */
+export class Context extends CoreContext<Message, ChatInputCommandInteraction> {
+    /*
+     * @Experimental
+     */
+    get options() {
+        return this.interaction.options;
+    }
+    protected constructor(protected ctx: Result<Message, ChatInputCommandInteraction>) {
+        super(ctx);
+    }
+
+    public get id(): Snowflake {
+        return safeUnwrap(this.ctx
+                            .map(m => m.id)
+                            .mapErr(i => i.id));
+    }
+
+    public get channel() {
+        return safeUnwrap(this.ctx
+                            .map(m => m.channel)
+                            .mapErr(i => i.channel));
+    }
+
+    public get channelId(): Snowflake {
+        return safeUnwrap(this.ctx
+                            .map(m => m.channelId)
+                            .mapErr(i => i.channelId));
+    }
+    
+    /**
+     * If context is holding a message, message.author
+     * else, interaction.user
+     */
+    public get user(): User {
+        return safeUnwrap(this.ctx
+                            .map(m => m.author)
+                            .mapErr(i => i.user));
+    }
+
+    public get userId(): Snowflake {
+        return this.user.id;
+    }
+
+    public get createdTimestamp(): number {
+        return safeUnwrap(this.ctx 
+                            .map(m => m.createdTimestamp)
+                            .mapErr(i => i.createdTimestamp));
+    }
+
+    public get guild() {
+        return safeUnwrap(this.ctx
+                            .map(m => m.guild)
+                            .mapErr(i => i.guild));
+    }
+
+    public get guildId() {
+        return safeUnwrap(this.ctx
+                            .map(m => m.guildId)
+                            .mapErr(i => i.guildId));
+    }
+    /*
+     * interactions can return APIGuildMember if the guild it is emitted from is not cached
+     */
+    public get member() {
+        return safeUnwrap(this.ctx
+                            .map(m => m.member)
+                            .mapErr(i => i.member));
+    }
+
+    public get client(): Client {
+        return safeUnwrap(this.ctx
+                            .map(m => m.client)
+                            .mapErr(i => i.client));
+    }
+
+    public get inGuild(): boolean {
+        return safeUnwrap(this.ctx
+                            .map(m => m.inGuild())
+                            .mapErr(i => i.inGuild()));
+    }
+
+    public async reply(content: ReplyOptions) {
+        return safeUnwrap(
+            this.ctx
+                .map(m => m.reply(content as MessageReplyOptions))
+                .mapErr(i =>
+                    i.reply(content as InteractionReplyOptions).then(() => i.fetchReply()),
+                ),
+        );
+    }
+
+    static override wrap(wrappable: BaseInteraction | Message): Context {
+        if ('interaction' in wrappable) {
+            return new Context(Ok(wrappable));
+        }
+        assert.ok(wrappable.isChatInputCommand(), "Context created with bad interaction.");
+        return new Context(Err(wrappable));
+    }
+}
+
+function safeUnwrap<T>(res: Result<T, T>) {
+    if(res.isOk()) {
+        return res.expect("Tried unwrapping message field: " + res)
+    } 
+    return res.expectErr("Tried unwrapping interaction field" + res)
+}

src/core/structures/core-context.ts

@@ -0,0 +1,32 @@
+import { Result as Either } from 'ts-results-es';
+import { SernError } from '../_internal';
+import * as assert from 'node:assert';
+
+/**
+ * @since 3.0.0
+ */
+export abstract class CoreContext<M, I> {
+    protected constructor(protected ctx: Either<M, I>) {
+        assert.ok(typeof ctx === 'object' && ctx != null, "Context was nonobject or null");
+    }
+    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();
+    }
+
+    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');
+    }
+}

src/core/structures/enums.ts

@@ -0,0 +1,142 @@
+/**
+ * @since 1.0.0
+ * A bitfield that discriminates command modules
+ * @enum { number }
+ * @example
+ * ```ts
+ * export default commandModule({
+ *     // highlight-next-line
+ *     type : CommandType.Text,
+ *     name : 'a text command'
+ *     execute(message) {
+ *         console.log(message.content)
+ *     }
+ * })
+ * ```
+ */
+export enum CommandType {
+    Text = 1 << 0,
+    Slash = 1 << 1,
+    Both = 3,
+    CtxUser = 1 << 2,
+    CtxMsg = 1 << 3,
+    Button = 1 << 4,
+    StringSelect = 1 << 5,
+    Modal = 1 << 6,
+    UserSelect = 1 << 7,
+    RoleSelect = 1 << 8,
+    MentionableSelect = 1 << 9,
+    ChannelSelect = 1 << 10,
+}
+
+/**
+ * A bitfield that discriminates event modules
+ * @enum { number }
+ * @example
+ * ```ts
+ * export default eventModule({
+ *     //highlight-next-line
+ *     type : EventType.Discord,
+ *     name : 'guildMemberAdd'
+ *     execute(member : GuildMember) {
+ *         console.log(member)
+ *     }
+ * })
+ * ```
+ */
+export enum EventType {
+    /**
+     * The EventType for handling discord events
+     */
+    Discord = 1,
+    /**
+     * The EventType for handling sern events
+     */
+    Sern = 2,
+    /**
+     * The EventType for handling external events.
+     * Could be for example, `process` events, database events
+     */
+    External = 3,
+}
+
+/**
+ * A bitfield that discriminates plugins
+ * @enum { number }
+ * @example
+ * ```ts
+ * export default function myPlugin() : EventPlugin<CommandType.Text> {
+ *     //highlight-next-line
+ *     type : PluginType.Event,
+ *     execute([ctx, args], controller) {
+ *         return controller.next();
+ *     }
+ * }
+ * ```
+ */
+export enum PluginType {
+    /**
+     * The PluginType for InitPlugins
+     */
+    Init = 1,
+    /**
+     * The PluginType for EventPlugins
+     */
+    Control = 2,
+}
+/**
+ * @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',
+}
+
+/**
+ * @enum { string }
+ */
+export const enum SernError {
+    /**
+     * Throws when registering an invalid module.
+     * This means it is undefined or an invalid command type was provided
+     */
+    InvalidModuleType = 'Detected an unknown module type',
+    /**
+     * Attempted to lookup module in command module store. Nothing was found!
+     */
+    UndefinedModule = `A module could not be detected`,
+    /**
+     * Attempted to lookup module in command module store. Nothing was found!
+     */
+    MismatchModule = `A module type mismatched with event emitted!`,
+    /**
+     * Unsupported interaction at this moment.
+     */
+    NotSupportedInteraction = `This interaction is not supported.`,
+    /**
+     * One plugin called `controller.stop()` (end command execution / loading)
+     */
+    PluginFailure = `A plugin failed to call controller.next()`,
+    /**
+     * A crash that occurs when accessing an invalid property of Context
+     */
+    MismatchEvent = `You cannot use message when an interaction fired or vice versa`,
+    /**
+     * Unsupported feature attempted to access at this time
+     */
+    NotSupportedYet = `This feature is not supported yet`,
+    /**
+     * Required Dependency not found
+     */
+    MissingRequired = `@sern/client is required but was not found`,
+}

src/core/structures/index.ts

@@ -0,0 +1,5 @@
+export { CommandType, PluginType, PayloadType, EventType } from './enums';
+export * from './context';
+export * from './sern-emitter';
+export * from './services';
+export * from './module-store';

src/core/structures/module-store.ts

@@ -0,0 +1,12 @@
+import { CommandMeta, Module } 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 {
+    metadata = new WeakMap<Module, CommandMeta>();
+    commands = new Map<string, string>();
+}

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,
+        );
+    }
+}

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;
+        }
+    }
+}

src/core/structures/services/index.ts

@@ -0,0 +1,3 @@
+export * from './error-handling';
+export * from './logger';
+export * from './module-manager';

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}`);
+    }
+}

src/core/structures/services/module-manager.ts

@@ -0,0 +1,54 @@
+import * as Id from '../../../core/id';
+import { CoreModuleStore, ModuleManager } from '../../contracts';
+import { Files } from '../../_internal';
+import { CommandMeta, CommandModule, CommandModuleDefs, Module } 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) {}
+
+
+    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]) => {
+                    const last_entry = id.at(-1);
+                    return last_entry == 'B' ||  !(publishable & Number.parseInt(last_entry!));
+                })
+                .map(([, path]) => Files.importModule<CommandModule>(path)),
+        );
+    }
+}

src/handler/events/dispatchers.ts

@@ -1,110 +0,0 @@
-import type {
-    BothCommand,
-    ButtonCommand,
-    ContextMenuMsg,
-    ContextMenuUser,
-    ModalSubmitCommand,
-    SelectMenuCommand,
-    SlashCommand,
-} from '../structures/module';
-import Context from '../structures/context';
-import type { SlashOptions } from '../../types/handler';
-import { asyncResolveArray } from '../utilities/asyncResolveArray';
-import { controller } from '../sern';
-import type {
-    ButtonInteraction,
-    ModalSubmitInteraction,
-    SelectMenuInteraction,
-    AutocompleteInteraction,
-    ChatInputCommandInteraction,
-    Interaction,
-    UserContextMenuCommandInteraction,
-    MessageContextMenuCommandInteraction,
-} from 'discord.js';
-import { isAutocomplete } from '../utilities/predicates';
-import { SernError } from '../structures/errors';
-import treeSearch from '../utilities/treeSearch';
-
-export function applicationCommandDispatcher(interaction: Interaction) {
-    if (isAutocomplete(interaction)) {
-        return dispatchAutocomplete(interaction);
-    } else {
-        const ctx = Context.wrap(interaction as ChatInputCommandInteraction);
-        const args: ['slash', SlashOptions] = ['slash', ctx.interaction.options];
-        return (mod: BothCommand | SlashCommand) => ({
-            mod,
-            execute: () => mod.execute(ctx, args),
-            eventPluginRes: asyncResolveArray(
-                mod.onEvent.map(plugs => plugs.execute([ctx, args], controller)),
-            ),
-        });
-    }
-}
-
-export function dispatchAutocomplete(interaction: AutocompleteInteraction) {
-    return (mod: BothCommand | SlashCommand) => {
-        const selectedOption = treeSearch(interaction, mod.options);
-        if (selectedOption !== undefined) {
-            return {
-                mod,
-                execute: () => selectedOption.command.execute(interaction),
-                eventPluginRes: asyncResolveArray(
-                    selectedOption.command.onEvent.map(e => e.execute(interaction, controller)),
-                ),
-            };
-        }
-        throw Error(
-            SernError.NotSupportedInteraction + ` There is no autocomplete tag for this option`,
-        );
-    };
-}
-
-export function modalCommandDispatcher(interaction: ModalSubmitInteraction) {
-    return (mod: ModalSubmitCommand) => ({
-        mod,
-        execute: () => mod.execute(interaction),
-        eventPluginRes: asyncResolveArray(
-            mod.onEvent.map(plugs => plugs.execute([interaction], controller)),
-        ),
-    });
-}
-
-export function buttonCommandDispatcher(interaction: ButtonInteraction) {
-    return (mod: ButtonCommand) => ({
-        mod,
-        execute: () => mod.execute(interaction),
-        eventPluginRes: asyncResolveArray(
-            mod.onEvent.map(plugs => plugs.execute([interaction], controller)),
-        ),
-    });
-}
-
-export function selectMenuCommandDispatcher(interaction: SelectMenuInteraction) {
-    return (mod: SelectMenuCommand) => ({
-        mod,
-        execute: () => mod.execute(interaction),
-        eventPluginRes: asyncResolveArray(
-            mod.onEvent.map(plugs => plugs.execute([interaction], controller)),
-        ),
-    });
-}
-
-export function ctxMenuUserDispatcher(interaction: UserContextMenuCommandInteraction) {
-    return (mod: ContextMenuUser) => ({
-        mod,
-        execute: () => mod.execute(interaction),
-        eventPluginRes: asyncResolveArray(
-            mod.onEvent.map(plugs => plugs.execute([interaction], controller)),
-        ),
-    });
-}
-
-export function ctxMenuMsgDispatcher(interaction: MessageContextMenuCommandInteraction) {
-    return (mod: ContextMenuMsg) => ({
-        mod,
-        execute: () => mod.execute(interaction),
-        eventPluginRes: asyncResolveArray(
-            mod.onEvent.map(plugs => plugs.execute([interaction], controller)),
-        ),
-    });
-}

src/handler/events/eventsHandler.ts

@@ -1,10 +0,0 @@
-import type Wrapper from '../structures/wrapper';
-import { Subject, type Observable } from 'rxjs';
-
-export abstract class EventsHandler<T> {
-    protected payloadSubject = new Subject<T>();
-    protected abstract discordEvent: Observable<unknown>;
-    protected constructor(protected wrapper: Wrapper) {}
-    protected abstract init(): void;
-    protected abstract setState(state: T): void;
-}

src/handler/events/interactionHandler.ts

@@ -1,123 +0,0 @@
-import type { Interaction } from 'discord.js';
-import { catchError, concatMap, from, fromEvent, map, Observable } from 'rxjs';
-import type Wrapper from '../structures/wrapper';
-import { EventsHandler } from './eventsHandler';
-import {
-    isApplicationCommand,
-    isAutocomplete,
-    isMessageComponent,
-    isModalSubmit,
-} from '../utilities/predicates';
-import * as Files from '../utilities/readFile';
-import type { CommandModule } from '../structures/module';
-import { SernError } from '../structures/errors';
-import { CommandType, PayloadType } from '../structures/enums';
-import { match, P } from 'ts-pattern';
-import {
-    applicationCommandDispatcher,
-    buttonCommandDispatcher,
-    ctxMenuMsgDispatcher,
-    ctxMenuUserDispatcher,
-    modalCommandDispatcher,
-    selectMenuCommandDispatcher,
-} from './dispatchers';
-import type {
-    ButtonInteraction,
-    ModalSubmitInteraction,
-    SelectMenuInteraction,
-    UserContextMenuCommandInteraction,
-    MessageContextMenuCommandInteraction,
-} from 'discord.js';
-import { executeModule } from './observableHandling';
-
-export default class InteractionHandler extends EventsHandler<{
-    event: Interaction;
-    mod: CommandModule;
-}> {
-    protected override discordEvent: Observable<Interaction>;
-
-    constructor(protected wrapper: Wrapper) {
-        super(wrapper);
-        this.discordEvent = <Observable<Interaction>>fromEvent(wrapper.client, 'interactionCreate');
-        this.init();
-
-        this.payloadSubject
-            .pipe(
-                map(this.processModules),
-                concatMap(({ mod, execute, eventPluginRes }) => {
-                    //resolve all the Results from event plugins
-                    return from(eventPluginRes).pipe(map(res => ({ mod, res, execute })));
-                }),
-                concatMap(payload => executeModule(wrapper, payload)),
-                catchError((err, caught) => {
-                    wrapper.sernEmitter?.emit('error', err);
-                    return caught;
-                }),
-            )
-            .subscribe();
-    }
-
-    override init() {
-        this.discordEvent.subscribe({
-            next: event => {
-                if (isMessageComponent(event)) {
-                    const mod = Files.MessageCompCommands[event.componentType].get(event.customId);
-                    this.setState({ event, mod });
-                } else if (isApplicationCommand(event) || isAutocomplete(event)) {
-                    const mod =
-                        Files.ApplicationCommands[event.commandType].get(event.commandName) ??
-                        Files.BothCommands.get(event.commandName);
-                    this.setState({ event, mod });
-                } else if (isModalSubmit(event)) {
-                    /**
-                     * maybe move modal submits into message component object maps?
-                     */
-                    const mod = Files.ModalSubmitCommands.get(event.customId);
-                    this.setState({ event, mod });
-                } else {
-                    throw Error('This interaction is not supported yet');
-                }
-            },
-            error: reason => {
-                this.wrapper.sernEmitter?.emit('error', { type: PayloadType.Failure, reason });
-            },
-        });
-    }
-
-    protected setState(state: { event: Interaction; mod: CommandModule | undefined }): void {
-        if (state.mod === undefined) {
-            this.wrapper?.sernEmitter?.emit('warning', 'Found no module for this interaction');
-        } else {
-            //if statement above checks already, safe cast
-            this.payloadSubject.next(state as { event: Interaction; mod: CommandModule });
-        }
-    }
-
-    protected processModules({ mod, event }: { event: Interaction; mod: CommandModule }) {
-        return match(mod)
-            .with(
-                { type: P.union(CommandType.Slash, CommandType.Both) },
-                applicationCommandDispatcher(event),
-            )
-            .with(
-                { type: CommandType.Modal },
-                modalCommandDispatcher(event as ModalSubmitInteraction),
-            )
-            .with({ type: CommandType.Button }, buttonCommandDispatcher(event as ButtonInteraction))
-            .with(
-                { type: CommandType.MenuSelect },
-                selectMenuCommandDispatcher(event as SelectMenuInteraction),
-            )
-            .with(
-                { type: CommandType.MenuUser },
-                ctxMenuUserDispatcher(event as UserContextMenuCommandInteraction),
-            )
-            .with(
-                { type: CommandType.MenuMsg },
-                ctxMenuMsgDispatcher(event as MessageContextMenuCommandInteraction),
-            )
-            .otherwise(() => {
-                throw Error(SernError.MismatchModule);
-            });
-    }
-}

src/handler/events/messageHandler.ts

@@ -1,81 +0,0 @@
-import { EventsHandler } from './eventsHandler';
-import { catchError, concatMap, from, fromEvent, map, Observable, of, switchMap } from 'rxjs';
-import type Wrapper from '../structures/wrapper';
-import type { Message } from 'discord.js';
-import { executeModule, ignoreNonBot, isOneOfCorrectModules } from './observableHandling';
-import { fmt } from '../utilities/messageHelpers';
-import Context from '../structures/context';
-import * as Files from '../utilities/readFile';
-import type { TextCommand } from '../structures/module';
-import { CommandType, PayloadType } from '../structures/enums';
-import { asyncResolveArray } from '../utilities/asyncResolveArray';
-import { controller } from '../sern';
-
-export default class MessageHandler extends EventsHandler<{
-    ctx: Context;
-    args: ['text', string[]];
-    mod: TextCommand;
-}> {
-    protected discordEvent: Observable<Message>;
-    public constructor(wrapper: Wrapper) {
-        super(wrapper);
-        this.discordEvent = <Observable<Message>>fromEvent(wrapper.client, 'messageCreate');
-        this.init();
-        this.payloadSubject
-            .pipe(
-                switchMap(({ mod, ctx, args }) => {
-                    const res = asyncResolveArray(
-                        mod.onEvent.map(ePlug => {
-                            return ePlug.execute([ctx, args], controller);
-                        }),
-                    );
-                    const execute = () => {
-                        return mod.execute(ctx, args);
-                    };
-                    //resolves the promise and re-emits it back into source
-                    return from(res).pipe(map(res => ({ mod, execute, res })));
-                }),
-                concatMap(payload => executeModule(wrapper, payload)),
-                catchError((err, caught) => {
-                    wrapper.sernEmitter?.emit('error', err);
-                    return caught;
-                }),
-            )
-            .subscribe();
-    }
-
-    protected init(): void {
-        if (this.wrapper.defaultPrefix === undefined) return; //for now, just ignore if prefix doesn't exist
-        const { defaultPrefix } = this.wrapper;
-        this.discordEvent
-            .pipe(
-                ignoreNonBot(this.wrapper.defaultPrefix),
-                map(message => {
-                    const [prefix, ...rest] = fmt(message, defaultPrefix);
-                    return {
-                        ctx: Context.wrap(message),
-                        args: <['text', string[]]>['text', rest],
-                        mod:
-                            Files.TextCommands.text.get(prefix) ??
-                            Files.BothCommands.get(prefix) ??
-                            Files.TextCommands.aliases.get(prefix),
-                    };
-                }),
-                concatMap(element =>
-                    of(element.mod).pipe(
-                        isOneOfCorrectModules(CommandType.Text),
-                        map(mod => ({ ...element, mod })),
-                    ),
-                ),
-            )
-            .subscribe({
-                next: value => this.setState(value),
-                error: reason =>
-                    this.wrapper.sernEmitter?.emit('error', { type: PayloadType.Failure, reason }),
-            });
-    }
-
-    protected setState(state: { ctx: Context; args: ['text', string[]]; mod: TextCommand }) {
-        this.payloadSubject.next(state);
-    }
-}

src/handler/events/observableHandling.ts

@@ -1,112 +0,0 @@
-import type { Message } from 'discord.js';
-import { concatMap, from, Observable, of, tap, throwError } from 'rxjs';
-import { SernError } from '../structures/errors';
-import type { Module, CommandModuleDefs, CommandModule } from '../structures/module';
-import { Result } from 'ts-results-es';
-import type { CommandType } from '../structures/enums';
-import type Wrapper from '../structures/wrapper';
-import { PayloadType } from '../structures/enums';
-
-export function ignoreNonBot(prefix: string) {
-    return (src: Observable<Message>) =>
-        new Observable<Message>(subscriber => {
-            return src.subscribe({
-                next(m) {
-                    const messageFromHumanAndHasPrefix =
-                        !m.author.bot &&
-                        m.content
-                            .slice(0, prefix.length)
-                            .localeCompare(prefix, undefined, { sensitivity: 'accent' }) === 0;
-                    if (messageFromHumanAndHasPrefix) {
-                        subscriber.next(m);
-                    }
-                },
-                error: e => subscriber.error(e),
-                complete: () => subscriber.complete(),
-            });
-        });
-}
-
-/**
- * If the current value in Result stream is an error, calls callback.
- * @param cb
- */
-export function errTap<T extends Module>(cb: (err: SernError) => void) {
-    return (src: Observable<Result<{ mod: T; absPath: string }, SernError>>) =>
-        new Observable<{ mod: T; absPath: string }>(subscriber => {
-            return src.subscribe({
-                next(value) {
-                    if (value.err) {
-                        cb(value.val);
-                    } else {
-                        subscriber.next(value.val);
-                    }
-                },
-                error: e => subscriber.error(e),
-                complete: () => subscriber.complete(),
-            });
-        });
-}
-
-//POG
-export function isOneOfCorrectModules<T extends readonly CommandType[]>(...inputs: [...T]) {
-    return (src: Observable<CommandModule | undefined>) => {
-        return new Observable<CommandModuleDefs[T[number]]>(subscriber => {
-            return src.subscribe({
-                next(mod) {
-                    if (mod === undefined) {
-                        return throwError(() => SernError.UndefinedModule);
-                    }
-                    if (inputs.some(type => (mod.type & type) !== 0)) {
-                        subscriber.next(mod as CommandModuleDefs[T[number]]);
-                    } else {
-                        return throwError(() => SernError.MismatchModule);
-                    }
-                },
-                error: e => subscriber.error(e),
-                complete: () => subscriber.complete(),
-            });
-        });
-    };
-}
-
-export function executeModule(
-    wrapper: Wrapper,
-    payload: {
-        mod: CommandModule;
-        execute: () => unknown;
-        res: Result<void, void>[];
-    },
-) {
-    if (payload.res.every(el => el.ok)) {
-        const executeFn = Result.wrapAsync<unknown, Error | string>(() =>
-            Promise.resolve(payload.execute()),
-        );
-        return from(executeFn).pipe(
-            concatMap(res => {
-                if (res.err) {
-                    return throwError(() => ({
-                        type: PayloadType.Failure,
-                        reason: res.val,
-                        module: payload.mod,
-                    }));
-                }
-                return of(res.val).pipe(
-                    tap(() =>
-                        wrapper.sernEmitter?.emit('module.activate', {
-                            type: PayloadType.Success,
-                            module: payload.mod,
-                        }),
-                    ),
-                );
-            }),
-        );
-    } else {
-        wrapper.sernEmitter?.emit('module.activate', {
-            type: PayloadType.Failure,
-            module: payload.mod,
-            reason: SernError.PluginFailure,
-        });
-        return of(undefined);
-    }
-}

src/handler/events/readyHandler.ts

@@ -1,159 +0,0 @@
-import { EventsHandler } from './eventsHandler';
-import type Wrapper from '../structures/wrapper';
-import { concatMap, fromEvent, Observable, map, take, of, from, toArray, switchMap } from 'rxjs';
-import type { CommandModule } from '../structures/module';
-import * as Files from '../utilities/readFile';
-import { errTap } from './observableHandling';
-import type { DefinedCommandModule } from '../../types/handler';
-import { basename } from 'path';
-import { CommandType, PayloadType, PluginType } from '../structures/enums';
-import { processCommandPlugins } from './userDefinedEventsHandling';
-import type { Awaitable } from 'discord.js';
-import { SernError } from '../structures/errors';
-import { match } from 'ts-pattern';
-import { type Result, Err, Ok } from 'ts-results-es';
-import { ApplicationCommandType, ComponentType } from 'discord.js';
-
-export default class ReadyHandler extends EventsHandler<{
-    mod: DefinedCommandModule;
-    absPath: string;
-}> {
-    protected discordEvent!: Observable<{ mod: CommandModule; absPath: string }>;
-    constructor(wrapper: Wrapper) {
-        super(wrapper);
-        const ready$ = fromEvent(this.wrapper.client, 'ready').pipe(take(1));
-        this.discordEvent = ready$.pipe(
-            concatMap(() =>
-                Files.buildData<CommandModule>(this.wrapper.commands).pipe(
-                    errTap(reason =>
-                        wrapper.sernEmitter?.emit('module.register', {
-                            type: PayloadType.Failure,
-                            module: undefined,
-                            reason,
-                        }),
-                    ),
-                ),
-            ),
-        );
-        this.init();
-        this.payloadSubject
-            .pipe(
-                concatMap(payload => this.processPlugins(payload)),
-                concatMap(payload => this.resolvePlugins(payload)),
-            )
-            .subscribe(payload => {
-                const allPluginsSuccessful = payload.pluginRes.every(({ execute }) => execute.ok);
-                if (allPluginsSuccessful) {
-                    const res = registerModule(payload.mod);
-                    if (res.err) {
-                        throw Error(SernError.InvalidModuleType);
-                    }
-                    wrapper.sernEmitter?.emit('module.register', {
-                        type: PayloadType.Success,
-                        module: payload.mod,
-                    });
-                } else {
-                    wrapper.sernEmitter?.emit('module.register', {
-                        type: PayloadType.Failure,
-                        module: payload.mod,
-                        reason: SernError.PluginFailure,
-                    });
-                }
-            });
-    }
-    private static intoDefinedModule({ absPath, mod }: { absPath: string; mod: CommandModule }): {
-        absPath: string;
-        mod: DefinedCommandModule;
-    } {
-        return {
-            absPath,
-            mod: {
-                name: mod?.name ?? Files.fmtFileName(basename(absPath)),
-                description: mod?.description ?? '...',
-                ...mod,
-            },
-        };
-    }
-
-    private resolvePlugins({
-        mod,
-        cmdPluginRes,
-    }: {
-        mod: DefinedCommandModule;
-        cmdPluginRes: {
-            name: string;
-            description: string;
-            execute: Awaitable<Result<void, void>>;
-            type: PluginType.Command;
-        }[];
-    }) {
-        if (mod.plugins.length === 0) {
-            return of({ mod, pluginRes: [] });
-        }
-        // modules with no event plugins are ignored in the previous
-        return from(cmdPluginRes).pipe(
-            switchMap(pl =>
-                from(pl.execute).pipe(
-                    map(execute => ({ ...pl, execute })),
-                    toArray(),
-                ),
-            ),
-            map(pluginRes => ({ mod, pluginRes })),
-        );
-    }
-
-    private processPlugins(payload: { mod: DefinedCommandModule; absPath: string }) {
-        const cmdPluginRes = processCommandPlugins(this.wrapper, payload);
-        return of({ mod: payload.mod, cmdPluginRes });
-    }
-
-    protected init() {
-        this.discordEvent.pipe(map(ReadyHandler.intoDefinedModule)).subscribe({
-            next: value => this.setState(value),
-            complete: () => this.payloadSubject.unsubscribe(),
-        });
-    }
-    protected setState(state: { absPath: string; mod: DefinedCommandModule }): void {
-        this.payloadSubject.next(state);
-    }
-}
-
-function registerModule(mod: DefinedCommandModule): Result<void, void> {
-    const name = mod.name;
-    return match<DefinedCommandModule>(mod)
-        .with({ type: CommandType.Text }, mod => {
-            mod.alias?.forEach(a => Files.TextCommands.aliases.set(a, mod));
-            Files.TextCommands.text.set(name, mod);
-            return Ok.EMPTY;
-        })
-        .with({ type: CommandType.Slash }, mod => {
-            Files.ApplicationCommands[ApplicationCommandType.ChatInput].set(name, mod);
-            return Ok.EMPTY;
-        })
-        .with({ type: CommandType.Both }, mod => {
-            Files.BothCommands.set(name, mod);
-            mod.alias?.forEach(a => Files.TextCommands.aliases.set(a, mod));
-            return Ok.EMPTY;
-        })
-        .with({ type: CommandType.MenuUser }, mod => {
-            Files.ApplicationCommands[ApplicationCommandType.User].set(name, mod);
-            return Ok.EMPTY;
-        })
-        .with({ type: CommandType.MenuMsg }, mod => {
-            Files.ApplicationCommands[ApplicationCommandType.Message].set(name, mod);
-            return Ok.EMPTY;
-        })
-        .with({ type: CommandType.Button }, mod => {
-            Files.MessageCompCommands[ComponentType.Button].set(name, mod);
-            return Ok.EMPTY;
-        })
-        .with({ type: CommandType.MenuSelect }, mod => {
-            Files.MessageCompCommands[ComponentType.SelectMenu].set(name, mod);
-            return Ok.EMPTY;
-        })
-        .with({ type: CommandType.Modal }, mod => {
-            Files.ModalSubmitCommands.set(name, mod);
-            return Ok.EMPTY;
-        })
-        .otherwise(() => Err.EMPTY);
-}

src/handler/events/userDefinedEventsHandling.ts

@@ -1,87 +0,0 @@
-import { from, fromEvent, map } from 'rxjs';
-import * as Files from '../utilities/readFile';
-import { buildData, ExternalEventEmitters } from '../utilities/readFile';
-import { controller } from '../sern';
-import type {
-    DefinedCommandModule,
-    DefinedEventModule,
-    EventInput,
-    SpreadParams,
-} from '../../types/handler';
-import type { EventModule } from '../structures/module';
-import { PayloadType } from '../structures/enums';
-import type Wrapper from '../structures/wrapper';
-import { basename } from 'path';
-import { match } from 'ts-pattern';
-import { isDiscordEvent, isSernEvent } from '../utilities/predicates';
-import { errTap } from './observableHandling';
-
-/**
- * Utility function to process command plugins for all Modules
- * @param wrapper
- * @param payload
- */
-export function processCommandPlugins<T extends DefinedCommandModule>(
-    wrapper: Wrapper,
-    payload: { mod: T; absPath: string },
-) {
-    return payload.mod.plugins.map(plug => ({
-        ...plug,
-        name: plug?.name ?? 'Unnamed Plugin',
-        description: plug?.description ?? '...',
-        execute: plug.execute(wrapper, payload, controller),
-    }));
-}
-
-export function processEvents(wrapper: Wrapper, events: EventInput) {
-    const eventStream$ = eventObservable$(wrapper, events);
-    const normalize$ = eventStream$.pipe(
-        map(({ mod, absPath }) => {
-            return <DefinedEventModule>{
-                name: mod?.name ?? Files.fmtFileName(basename(absPath)),
-                description: mod?.description ?? '...',
-                ...mod,
-            };
-        }),
-    );
-    normalize$.subscribe(e => {
-        const emitter = isSernEvent(e)
-            ? wrapper?.sernEmitter
-            : isDiscordEvent(e)
-            ? wrapper.client
-            : ExternalEventEmitters.get(e.emitter);
-        if (emitter === undefined) {
-            throw new Error(`Cannot find event emitter as it is undefined`);
-        }
-        //Would add sern event emitter for events loaded, attached onto sern emitter, but could lead to unwanted behavior!
-        fromEvent(emitter, e.name, e.execute as SpreadParams<typeof e.execute>).subscribe();
-    });
-}
-
-function eventObservable$({ sernEmitter }: Wrapper, events: EventInput) {
-    return match(events)
-        .when(Array.isArray, (arr: { mod: EventModule; absPath: string }[]) => {
-            return from(arr);
-        })
-        .when(
-            e => typeof e === 'string',
-            (eventsDir: string) => {
-                return buildData<EventModule>(eventsDir).pipe(
-                    errTap(reason =>
-                        sernEmitter?.emit('module.register', {
-                            type: PayloadType.Failure,
-                            module: undefined,
-                            reason,
-                        }),
-                    ),
-                );
-            },
-        )
-        .when(
-            e => typeof e === 'function',
-            (evs: () => { mod: EventModule; absPath: string }[]) => {
-                return from(evs());
-            },
-        )
-        .run();
-}

src/handler/plugins/plugin.ts

@@ -1,184 +0,0 @@
-/*
- * Plugins can be inserted on all commands and are emitted
- *
- * 1. On ready event, where all commands are loaded.
- * 2. On corresponding observable (when command triggers)
- *
- * The goal of plugins is to organize commands and
- * provide extensions to repetitive patterns
- * examples include refreshing modules,
- * categorizing commands, cool-downs, permissions, etc.
- * Plugins are reminiscent of middleware in express.
- */
-
-import type { AutocompleteInteraction, Awaitable, Client, ClientEvents } from 'discord.js';
-import type { Result, Ok, Err } from 'ts-results-es';
-import type { CommandType, DefinitelyDefined, Override, SernEventsMapping } from '../../index';
-import { EventType, PluginType } from '../../index';
-import type { BaseModule, CommandModuleDefs, EventModuleDefs } from '../structures/module';
-import type { EventEmitter } from 'events';
-import type {
-    DiscordEventCommand,
-    ExternalEventCommand,
-    SernEventCommand,
-} from '../structures/events';
-import type SernEmitter from '../sernEmitter';
-import type Wrapper from '../structures/wrapper';
-
-export interface Controller {
-    next: () => Ok<void>;
-    stop: () => Err<void>;
-}
-
-type BasePlugin = Override<
-    BaseModule,
-    {
-        type: PluginType;
-    }
->;
-
-export type CommandPlugin<T extends keyof CommandModuleDefs = keyof CommandModuleDefs> = {
-    [K in T]: Override<
-        BasePlugin,
-        {
-            type: PluginType.Command;
-            execute: (
-                wrapper: Wrapper,
-                payload: {
-                    mod: DefinitelyDefined<CommandModuleDefs[T], 'name' | 'description'>;
-                    absPath: string;
-                },
-                controller: Controller,
-            ) => Awaitable<Result<void, void>>;
-        }
-    >;
-}[T];
-
-export type DiscordEmitterPlugin = Override<
-    BasePlugin,
-    {
-        type: PluginType.Command;
-        execute: (
-            wrapper: Client,
-            module: DefinitelyDefined<DiscordEventCommand, 'name' | 'description'>,
-            controller: Controller,
-        ) => Awaitable<Result<void, void>>;
-    }
->;
-export type ExternalEmitterPlugin<T extends EventEmitter = EventEmitter> = Override<
-    BasePlugin,
-    {
-        type: PluginType.Command;
-        execute: (
-            wrapper: T,
-            module: DefinitelyDefined<ExternalEventCommand, 'name' | 'description'>,
-            controller: Controller,
-        ) => Awaitable<Result<void, void>>;
-    }
->;
-
-export type SernEmitterPlugin = Override<
-    BasePlugin,
-    {
-        type: PluginType.Command;
-        execute: (
-            wrapper: SernEmitter,
-            module: DefinitelyDefined<SernEventCommand, 'name' | 'description'>,
-            controller: Controller,
-        ) => Awaitable<Result<void, void>>;
-    }
->;
-
-export type AutocompletePlugin = Override<
-    BaseModule,
-    {
-        type: PluginType.Event;
-        execute: (
-            autocmp: AutocompleteInteraction,
-            controlller: Controller,
-        ) => Awaitable<Result<void, void>>;
-    }
->;
-
-export type EventPlugin<T extends keyof CommandModuleDefs = keyof CommandModuleDefs> = {
-    [K in T]: Override<
-        BasePlugin,
-        {
-            type: PluginType.Event;
-            execute: (
-                event: Parameters<CommandModuleDefs[K]['execute']>,
-                controller: Controller,
-            ) => Awaitable<Result<void, void>>;
-        }
-    >;
-}[T];
-
-export type SernEventPlugin<T extends keyof SernEventsMapping = keyof SernEventsMapping> = Override<
-    BasePlugin,
-    {
-        name?: T;
-        type: PluginType.Event;
-        execute: (
-            args: SernEventsMapping[T],
-            controller: Controller,
-        ) => Awaitable<Result<void, void>>;
-    }
->;
-
-export type ExternalEventPlugin = Override<
-    BasePlugin,
-    {
-        type: PluginType.Event;
-        execute: (args: unknown[], controller: Controller) => Awaitable<Result<void, void>>;
-    }
->;
-
-export type DiscordEventPlugin<T extends keyof ClientEvents = keyof ClientEvents> = Override<
-    BasePlugin,
-    {
-        name?: T;
-        type: PluginType.Event;
-        execute: (args: ClientEvents[T], controller: Controller) => Awaitable<Result<void, void>>;
-    }
->;
-
-export type CommandModuleNoPlugins = {
-    [T in CommandType]: Omit<CommandModuleDefs[T], 'plugins' | 'onEvent'>;
-};
-export type EventModulesNoPlugins = {
-    [T in EventType]: Omit<EventModuleDefs[T], 'plugins' | 'onEvent'>;
-};
-/**
- * Event Module Event Plugins
- */
-export type EventModuleEventPluginDefs = {
-    [EventType.Discord]: DiscordEventPlugin;
-    [EventType.Sern]: SernEventPlugin;
-    [EventType.External]: ExternalEventPlugin;
-};
-
-/**
- * Event Module Command Plugins
- */
-export type EventModuleCommandPluginDefs = {
-    [EventType.Discord]: DiscordEmitterPlugin;
-    [EventType.Sern]: SernEmitterPlugin;
-    [EventType.External]: ExternalEmitterPlugin;
-};
-
-export type EventModulePlugin<T extends EventType> =
-    | EventModuleEventPluginDefs[T]
-    | EventModuleCommandPluginDefs[T];
-
-export type CommandModulePlugin<T extends CommandType> = EventPlugin<T> | CommandPlugin<T>;
-
-/**
- * User inputs this type. Sern processes behind the scenes for better usage
- */
-export type InputCommandModule = {
-    [T in CommandType]: CommandModuleNoPlugins[T] & { plugins?: CommandModulePlugin<T>[] };
-}[CommandType];
-
-export type InputEventModule = {
-    [T in EventType]: EventModulesNoPlugins[T] & { plugins?: EventModulePlugin<T>[] };
-}[EventType];

src/handler/sern.ts

@@ -1,140 +0,0 @@
-import type Wrapper from './structures/wrapper';
-import { Err, Ok } from 'ts-results-es';
-import { ExternalEventEmitters } from './utilities/readFile';
-import type { EventEmitter } from 'events';
-import { processEvents } from './events/userDefinedEventsHandling';
-import type {
-    CommandModule,
-    CommandModuleDefs,
-    EventModule,
-    EventModuleDefs,
-} from './structures/module';
-import { CommandType, EventType, PluginType } from './structures/enums';
-import type {
-    CommandPlugin,
-    EventModuleCommandPluginDefs,
-    EventModuleEventPluginDefs,
-    EventPlugin,
-    InputCommandModule,
-    InputEventModule,
-} from './plugins/plugin';
-import { SernError } from './structures/errors';
-import InteractionHandler from './events/interactionHandler';
-import ReadyHandler from './events/readyHandler';
-import MessageHandler from './events/messageHandler';
-
-/**
- *
- * @param wrapper Options to pass into sern.
- * Function to start the handler up
- * @example
- * ```ts title="src/index.ts"
- * Sern.init({
- *     client,
- *     defaultPrefix: '!',
- *     commands: 'dist/commands',
- * })
- * ```
- */
-export function init(wrapper: Wrapper) {
-    const { events } = wrapper;
-    if (events !== undefined) {
-        processEvents(wrapper, events);
-    }
-    new ReadyHandler(wrapper);
-    new MessageHandler(wrapper);
-    new InteractionHandler(wrapper);
-}
-
-/**
- * @deprecated - use Sern#makeDependencies instead
- * @param emitter Any external event emitter.
- * The object will be stored in a map, and then fetched by the name of the instance's class.
- * As there are infinite possibilities to adding external event emitters,
- * Most types aren't provided and are as narrow as possibly can.
- * @example
- * ```ts title="src/index.ts"
- * //Add this before initiating Sern!
- * Sern.addExternal(new Level())
- * ```
- * @example
- * ```ts title="events/level.ts"
- *  export default eventModule({
- *      emitter: 'Level',
- *      type : EventType.External,
- *      name: 'error',
- *      execute(args) {
- *          console.log(args)
- *      }
- *  })
- * ```
- */
-export function addExternal<T extends EventEmitter>(emitter: T) {
-    if (ExternalEventEmitters.has(emitter.constructor.name)) {
-        throw Error(`${emitter.constructor.name} already exists!`);
-    }
-    ExternalEventEmitters.set(emitter.constructor.name, emitter);
-}
-
-/**
- * The object passed into every plugin to control a command's behavior
- */
-export const controller = {
-    next: () => Ok.EMPTY,
-    stop: () => Err.EMPTY,
-};
-
-/**
- * The wrapper function to define command modules for sern
- * @param mod
- */
-export function commandModule(mod: InputCommandModule): CommandModule {
-    const onEvent: EventPlugin[] = [];
-    const plugins: CommandPlugin[] = [];
-    for (const pl of mod.plugins ?? []) {
-        if (pl.type === PluginType.Event) {
-            onEvent.push(pl);
-        } else {
-            plugins.push(pl as CommandPlugin);
-        }
-    }
-
-    return {
-        ...mod,
-        onEvent,
-        plugins,
-    } as CommandModule;
-}
-/**
- * The wrapper function to define event modules for sern
- * @param mod
- */
-export function eventModule(mod: InputEventModule): EventModule {
-    const onEvent: EventModuleEventPluginDefs[EventType][] = [];
-    const plugins: EventModuleCommandPluginDefs[EventType][] = [];
-    const hasPlugins = mod.plugins && mod.plugins.length > 0;
-    if (hasPlugins) {
-        throw Error(
-            SernError.NotSupportedYet + `: Plugins on event listeners are not supported yet`,
-        );
-    }
-    return {
-        ...mod,
-        onEvent,
-        plugins,
-    } as EventModule;
-}
-
-export abstract class CommandExecutable<Type extends CommandType> {
-    abstract type: Type;
-    plugins: CommandPlugin<Type>[] = [];
-    onEvent: EventPlugin<Type>[] = [];
-    abstract execute: CommandModuleDefs[Type]['execute'];
-}
-
-export abstract class EventExecutable<Type extends EventType> {
-    abstract type: Type;
-    plugins: EventModuleCommandPluginDefs[Type][] = [];
-    onEvent: EventModuleEventPluginDefs[Type][] = [];
-    abstract execute: EventModuleDefs[Type]['execute'];
-}

src/handler/sernEmitter.ts

@@ -1,40 +0,0 @@
-import { EventEmitter } from 'events';
-import type { SernEventsMapping } from '../types/handler';
-
-class SernEmitter extends EventEmitter {
-    /**
-     * 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);
-    }
-}
-
-export default SernEmitter;

src/handler/structures/context.ts

@@ -1,145 +0,0 @@
-import type { APIGuildMember } from 'discord-api-types/v10';
-import type {
-    ChatInputCommandInteraction,
-    Client,
-    Guild,
-    GuildMember,
-    InteractionReplyOptions,
-    Message,
-    Snowflake,
-    TextBasedChannel,
-    MessageReplyOptions,
-    User,
-} from 'discord.js';
-import { type Option, None, Some } from 'ts-results-es';
-import type { Nullish, ReplyOptions } from '../../types/handler';
-import { SernError } from './errors';
-
-function firstSome<T>(...args: Option<T>[]): Nullish<T> {
-    for (const op of args) {
-        if (op.some) return op.val;
-    }
-    return null;
-}
-
-//Could I refactor with Either monad?
-/**
- * Provides values shared between
- * Message and ChatInputCommandInteraction
- */
-export default class Context {
-    private constructor(
-        private oMsg: Option<Message> = None,
-        private oInterac: Option<ChatInputCommandInteraction> = None,
-    ) {
-        this.oMsg = oMsg;
-        this.oInterac = oInterac;
-    }
-
-    /**
-     * Getting the Message object. Crashes if module type is
-     * CommandType.Slash or the event fired in a Both command was
-     * ChatInputCommandInteraction
-     */
-    public get message() {
-        return this.oMsg.expect(SernError.MismatchEvent);
-    }
-    /**
-     * Getting the ChatInputCommandInteraction object. Crashes if module type is
-     * CommandType.Text or the event fired in a Both command was
-     * Message
-     */
-    public get interaction() {
-        return this.oInterac.expect(SernError.MismatchEvent);
-    }
-
-    public get id(): Snowflake {
-        return firstSome(
-            this.oInterac.map(i => i.id),
-            this.oMsg.map(m => m.id),
-        )!;
-    }
-
-    public get channel(): Nullish<TextBasedChannel> {
-        return firstSome(
-            this.oMsg.map(m => m.channel),
-            this.oInterac.map(i => i.channel),
-        );
-    }
-
-    public get user(): User {
-        return firstSome(
-            this.oMsg.map(m => m.author),
-            this.oInterac.map(i => i.user),
-        )!;
-    }
-
-    public get createdTimestamp(): number {
-        return firstSome(
-            this.oMsg.map(m => m.createdTimestamp),
-            this.oInterac.map(i => i.createdTimestamp),
-        )!;
-    }
-
-    public get guild(): Guild {
-        return firstSome(
-            this.oMsg.map(m => m.guild),
-            this.oInterac.map(i => i.guild),
-        )!;
-    }
-
-    public get guildId(): Snowflake {
-        return firstSome(
-            this.oMsg.map(m => m.guildId),
-            this.oInterac.map(i => i.guildId),
-        )!;
-    }
-
-    /*
-     * interactions can return APIGuildMember if the guild it is emitted from is not cached
-     */
-    public get member(): Nullish<GuildMember | APIGuildMember> {
-        return firstSome(
-            this.oMsg.map(m => m.member),
-            this.oInterac.map(i => i.member),
-        );
-    }
-
-    public get client(): Client {
-        return firstSome(
-            this.oMsg.map(m => m.client),
-            this.oInterac.map(i => i.client),
-        )!;
-    }
-
-    public get inGuild(): boolean {
-        return firstSome(
-            this.oMsg.map(m => m.inGuild()),
-            this.oInterac.map(i => i.inGuild()),
-        )!;
-    }
-
-    static wrap(wrappable: ChatInputCommandInteraction | Message): Context {
-        if ('token' in wrappable) {
-            return new Context(None, Some(wrappable));
-        }
-        return new Context(Some(wrappable), None);
-    }
-
-    public isEmpty() {
-        return this.oMsg.none && this.oInterac.none;
-    }
-    //Make queueable
-    public reply(content: ReplyOptions) {
-        return firstSome(
-            this.oInterac.map(i => {
-                return i
-                    .reply(content as string | InteractionReplyOptions)
-                    .then(() => i.fetchReply());
-            }),
-            this.oMsg.map(m => {
-                return m.reply(content as string | MessageReplyOptions);
-            }),
-        )!;
-    }
-}

src/handler/structures/enums.ts

@@ -1,119 +0,0 @@
-/**
- * @enum { number }
- * @example
- * ```ts
- * export default commandModule({
- *     // highlight-next-line
- *     type : CommandType.Text,
- *     name : 'a text command'
- *     execute(message) {
- *         console.log(message.content)
- *     }
- * })
- * ```
- */
-export enum CommandType {
-    /**
-     * The CommandType for text commands
-     */
-    Text = 0b00000000001,
-    /**
-     * The CommandType for slash commands
-     */
-    Slash = 0b00000000010,
-    /**
-     * The CommandType for hybrid commands, text and slash
-     */
-    Both = 0b0000011,
-    /**
-     * The CommandType for UserContextMenuInteraction commands
-     */
-    MenuUser = 0b00000000100,
-    /**
-     * The CommandType for MessageContextMenuInteraction commands
-     */
-    MenuMsg = 0b0000001000,
-    /**
-     * The CommandType for ButtonInteraction commands
-     */
-    Button = 0b00000010000,
-    /**
-     * The CommandType for SelectMenuInteraction commands
-     */
-    MenuSelect = 0b00000100000,
-    /**
-     * The CommandType for ModalSubmitInteraction commands
-     */
-    Modal = 0b00001000000,
-}
-
-/**
- * @enum { number }
- * @example
- * ```ts
- * export default eventModule({
- *     //highlight-next-line
- *     type : EventType.Discord,
- *     name : 'guildMemberAdd'
- *     execute(member : GuildMember) {
- *         console.log(member)
- *     }
- * })
- * ```
- */
-export enum EventType {
-    /**
-     * The EventType for handling discord events
-     */
-    Discord = 0b01,
-    /**
-     * The EventType for handling sern events
-     */
-    Sern = 0b10,
-    /**
-     * The EventType for handling external events.
-     * Could be for example, `process` events, database events
-     */
-    External = 0b11,
-}
-
-/**
- * @enum { number }
- * @example
- * ```ts
- * export default function myPlugin() : EventPlugin<CommandType.Text> {
- *     //highlight-next-line
- *     type : PluginType.Event,
- *     execute([ctx, args], controller) {
- *         return controller.next();
- *     }
- * }
- * ```
- */
-export enum PluginType {
-    /**
-     * The PluginType for CommandPlugins
-     */
-    Command = 0b01,
-    /**
-     * The PluginType for EventPlugins
-     */
-    Event = 0b10,
-}
-/**
- * @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',
-}

src/handler/structures/errors.ts

@@ -1,34 +0,0 @@
-/**
- * @enum { string }
- */
-export enum SernError {
-    /**
-     * Throws when registering an invalid module.
-     * This means it is undefined or an invalid command type was provided
-     */
-    InvalidModuleType = 'Detected an unknown module type',
-    /**
-     * Attempted to lookup module in command module store. Nothing was found!
-     */
-    UndefinedModule = `A module could not be detected`,
-    /**
-     * Attempted to lookup module in command module store. Nothing was found!
-     */
-    MismatchModule = `A module type mismatched with event emitted!`,
-    /**
-     * Unsupported interaction at this moment.
-     */
-    NotSupportedInteraction = `This interaction is not supported.`,
-    /**
-     * One plugin called `controller.stop()` (end command execution / loading)
-     */
-    PluginFailure = `A plugin failed to call controller.next()`,
-    /**
-     * A crash that occurs when accessing an invalid property of Context
-     */
-    MismatchEvent = `You cannot use message when an interaction fired or vice versa`,
-    /**
-     * Unsupported feature attempted to access at this time
-     */
-    NotSupportedYet = `This feature is not supported yet`,
-}

src/handler/structures/events.ts

@@ -1,53 +0,0 @@
-import type { Override, SernEventsMapping } from '../../types/handler';
-import type { BaseModule } from './module';
-import type {
-    DiscordEmitterPlugin,
-    DiscordEventPlugin,
-    ExternalEmitterPlugin,
-    ExternalEventPlugin,
-    SernEmitterPlugin,
-    SernEventPlugin,
-} from '../plugins/plugin';
-import type { Awaitable, ClientEvents } from 'discord.js';
-import type { EventType } from './enums';
-
-/*
- * Mapped type to generate all sern event modules
- */
-export type SernEventCommand<T extends keyof SernEventsMapping = keyof SernEventsMapping> =
-    Override<
-        BaseModule,
-        {
-            name?: T;
-            type: EventType.Sern;
-            onEvent: SernEventPlugin[];
-            plugins: SernEmitterPlugin[];
-            execute(...args: SernEventsMapping[T]): Awaitable<void | unknown>;
-        }
-    >;
-/*
- * Mapped type to generate all discord event modules
- */
-export type DiscordEventCommand<T extends keyof ClientEvents = keyof ClientEvents> = Override<
-    BaseModule,
-    {
-        name?: T;
-        type: EventType.Discord;
-        onEvent: DiscordEventPlugin[];
-        plugins: DiscordEmitterPlugin[];
-        execute(...args: ClientEvents[T]): Awaitable<void | unknown>;
-    }
->;
-/*
- * Type for any event emitter that can be handled by sern
- */
-export type ExternalEventCommand = Override<
-    BaseModule,
-    {
-        emitter: string;
-        type: EventType.External;
-        onEvent: ExternalEventPlugin[];
-        plugins: ExternalEmitterPlugin[];
-        execute(...args: unknown[]): Awaitable<void | unknown>;
-    }
->;

src/handler/structures/module.ts

@@ -1,210 +0,0 @@
-import type {
-    ApplicationCommandAttachmentOption,
-    ApplicationCommandChannelOptionData,
-    ApplicationCommandChoicesData,
-    ApplicationCommandNonOptionsData,
-    ApplicationCommandNumericOptionData,
-    ApplicationCommandOptionData,
-    ApplicationCommandOptionType,
-    ApplicationCommandSubCommandData,
-    ApplicationCommandSubGroupData,
-    AutocompleteInteraction,
-    Awaitable,
-    BaseApplicationCommandOptionsData,
-    ButtonInteraction,
-    MessageContextMenuCommandInteraction,
-    ModalSubmitInteraction,
-    SelectMenuInteraction,
-    UserContextMenuCommandInteraction,
-} from 'discord.js';
-import type { Args, Override, SlashOptions } from '../../types/handler';
-import type { AutocompletePlugin, CommandPlugin, EventPlugin } from '../plugins/plugin';
-import type Context from './context';
-import { CommandType, EventType, PluginType } from './enums';
-import type { DiscordEventCommand, ExternalEventCommand, SernEventCommand } from './events';
-
-export interface BaseModule {
-    type: CommandType | PluginType;
-    name?: string;
-    description?: string;
-    execute: (ctx: Context, args: Args) => Awaitable<void | unknown>;
-}
-
-export type TextCommand = Override<
-    BaseModule,
-    {
-        type: CommandType.Text;
-        onEvent: EventPlugin<CommandType.Text>[]; //maybe allow BothPlugins for this also?
-        plugins: CommandPlugin[]; //maybe allow BothPlugins for this also?
-        alias?: string[];
-        execute: (ctx: Context, args: ['text', string[]]) => Awaitable<void | unknown>;
-    }
->;
-
-export type SlashCommand = Override<
-    BaseModule,
-    {
-        type: CommandType.Slash;
-        onEvent: EventPlugin<CommandType.Slash>[]; //maybe allow BothPlugins for this also?
-        plugins: CommandPlugin[]; //maybe allow BothPlugins for this also?
-        options?: SernOptionsData[];
-        execute: (ctx: Context, args: ['slash', SlashOptions]) => Awaitable<void | unknown>;
-    }
->;
-
-export type BothCommand = Override<
-    BaseModule,
-    {
-        type: CommandType.Both;
-        onEvent: EventPlugin<CommandType.Both>[];
-        plugins: CommandPlugin[];
-        alias?: string[];
-        options?: SernOptionsData[];
-        execute: (ctx: Context, args: Args) => Awaitable<void | unknown>;
-    }
->;
-
-export type ContextMenuUser = Override<
-    BaseModule,
-    {
-        type: CommandType.MenuUser;
-        onEvent: EventPlugin<CommandType.MenuUser>[];
-        plugins: CommandPlugin[];
-        execute: (ctx: UserContextMenuCommandInteraction) => Awaitable<void | unknown>;
-    }
->;
-
-export type ContextMenuMsg = Override<
-    BaseModule,
-    {
-        type: CommandType.MenuMsg;
-        onEvent: EventPlugin<CommandType.MenuMsg>[];
-        plugins: CommandPlugin[];
-        execute: (ctx: MessageContextMenuCommandInteraction) => Awaitable<void | unknown>;
-    }
->;
-
-export type ButtonCommand = Override<
-    BaseModule,
-    {
-        type: CommandType.Button;
-        onEvent: EventPlugin<CommandType.Button>[];
-        plugins: CommandPlugin[];
-        execute: (ctx: ButtonInteraction) => Awaitable<void | unknown>;
-    }
->;
-
-export type SelectMenuCommand = Override<
-    BaseModule,
-    {
-        type: CommandType.MenuSelect;
-        onEvent: EventPlugin<CommandType.MenuSelect>[];
-        plugins: CommandPlugin[];
-        execute: (ctx: SelectMenuInteraction) => Awaitable<void | unknown>;
-    }
->;
-
-export type ModalSubmitCommand = Override<
-    BaseModule,
-    {
-        type: CommandType.Modal;
-        onEvent: EventPlugin<CommandType.Modal>[];
-        plugins: CommandPlugin[];
-        execute: (ctx: ModalSubmitInteraction) => Awaitable<void | unknown>;
-    }
->;
-
-// Autocomplete commands are a little different
-// They can't have command plugins as they are
-// in conjunction with chat input commands
-export type AutocompleteCommand = Override<
-    BaseModule,
-    {
-        name?: never;
-        description?: never;
-        type?: never;
-        onEvent: AutocompletePlugin[];
-        execute: (ctx: AutocompleteInteraction) => Awaitable<void | unknown>;
-    }
->;
-export type EventModule = DiscordEventCommand | SernEventCommand | ExternalEventCommand;
-export type CommandModule =
-    | TextCommand
-    | SlashCommand
-    | BothCommand
-    | ContextMenuUser
-    | ContextMenuMsg
-    | ButtonCommand
-    | SelectMenuCommand
-    | ModalSubmitCommand;
-
-export type Module = CommandModule | EventModule;
-
-//https://stackoverflow.com/questions/64092736/alternative-to-switch-statement-for-typescript-discriminated-union
-// Explicit Module Definitions for mapping
-export type CommandModuleDefs = {
-    [CommandType.Text]: TextCommand;
-    [CommandType.Slash]: SlashCommand;
-    [CommandType.Both]: BothCommand;
-    [CommandType.MenuMsg]: ContextMenuMsg;
-    [CommandType.MenuUser]: ContextMenuUser;
-    [CommandType.Button]: ButtonCommand;
-    [CommandType.MenuSelect]: SelectMenuCommand;
-    [CommandType.Modal]: ModalSubmitCommand;
-};
-
-export type EventModuleDefs = {
-    [EventType.Sern]: SernEventCommand;
-    [EventType.Discord]: DiscordEventCommand;
-    [EventType.External]: ExternalEventCommand;
-};
-
-//TODO: support deeply nested Autocomplete
-// objective: construct union of ApplicationCommandOptionData change any Autocomplete data
-// into Sern autocomplete data.
-
-export type SernAutocompleteData = Override<
-    BaseApplicationCommandOptionsData,
-    {
-        autocomplete: true;
-        type:
-            | ApplicationCommandOptionType.String
-            | ApplicationCommandOptionType.Number
-            | ApplicationCommandOptionType.Integer;
-        command: AutocompleteCommand;
-    }
->;
-
-/**
- * Type that replaces autocomplete with {@link SernAutocompleteData}
- */
-export type BaseOptions =
-    | ApplicationCommandChoicesData
-    | ApplicationCommandNonOptionsData
-    | ApplicationCommandChannelOptionData
-    | ApplicationCommandNumericOptionData
-    | ApplicationCommandAttachmentOption
-    | SernAutocompleteData;
-
-export type SernSubCommandData = Override<
-    Omit<BaseApplicationCommandOptionsData, 'required'>,
-    {
-        type: ApplicationCommandOptionType.Subcommand;
-        options?: BaseOptions[];
-    }
->;
-
-export type SernSubCommandGroupData = Override<
-    Omit<BaseApplicationCommandOptionsData, 'required'>,
-    {
-        type: ApplicationCommandOptionType.SubcommandGroup;
-        options?: SernSubCommandData[];
-    }
->;
-
-export type SernOptionsData<U extends ApplicationCommandOptionData = ApplicationCommandOptionData> =
-    U extends ApplicationCommandSubCommandData
-        ? SernSubCommandData
-        : U extends ApplicationCommandSubGroupData
-        ? SernSubCommandGroupData
-        : BaseOptions;

src/handler/structures/structxports.ts

@@ -1,28 +0,0 @@
-import Context from './context';
-import type {
-    BothCommand,
-    Module,
-    SlashCommand,
-    TextCommand,
-    SernOptionsData,
-    BaseOptions,
-    SernAutocompleteData,
-    SernSubCommandData,
-    SernSubCommandGroupData,
-} from './module';
-import type Wrapper from './wrapper';
-
-export * from './enums';
-export {
-    Context,
-    SlashCommand,
-    TextCommand,
-    BothCommand,
-    Module,
-    Wrapper,
-    SernOptionsData,
-    BaseOptions,
-    SernAutocompleteData,
-    SernSubCommandData,
-    SernSubCommandGroupData,
-};

src/handler/structures/wrapper.ts

@@ -1,24 +0,0 @@
-import type { Client } from 'discord.js';
-import type SernEmitter from '../sernEmitter';
-import type { EventModule } from './module';
-
-/**
- * An object to be passed into Sern#init() function.
- * @typedef {object} Wrapper
- */
-interface Wrapper {
-    //@deprecated - Use Sern#makeDependencies instead
-    readonly client: Client;
-    //@deprecated - Use Sern#makeDependencies instead
-    readonly sernEmitter?: SernEmitter;
-    readonly defaultPrefix?: string;
-    readonly commands: string;
-    readonly events?:
-        | string
-        //@deprecated - array and function options will be removed
-        | { mod: EventModule; absPath: string }[]
-        //@deprecated - array and function options will be removed
-        | (() => { mod: EventModule; absPath: string }[]);
-}
-
-export default Wrapper;

src/handler/utilities/asyncResolveArray.ts

@@ -1,9 +0,0 @@
-import type { Awaitable } from 'discord.js';
-
-export async function asyncResolveArray<T>(promiseLike: Awaitable<T>[]): Promise<T[]> {
-    const arr: T[] = [];
-    for await (const el of promiseLike) {
-        arr.push(el);
-    }
-    return arr;
-}

src/handler/utilities/messageHelpers.ts

@@ -1,15 +0,0 @@
-import type { Message } from 'discord.js';
-
-/**
- * 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: Message, prefix: string): string[] {
-    return msg.content.slice(prefix.length).trim().split(/\s+/g);
-}

src/handler/utilities/predicates.ts

@@ -1,70 +0,0 @@
-import type { CommandModuleDefs, EventModule, Module } from '../structures/module';
-import {
-    AutocompleteInteraction,
-    Interaction,
-    InteractionType,
-    type ModalSubmitInteraction,
-    type ButtonInteraction,
-    type SelectMenuInteraction,
-    type ChatInputCommandInteraction,
-    type UserContextMenuCommandInteraction,
-    type MessageContextMenuCommandInteraction,
-} from 'discord.js';
-import type {
-    DiscordEventCommand,
-    ExternalEventCommand,
-    SernEventCommand,
-} from '../structures/events';
-import { EventType } from '../..';
-
-export function correctModuleType<T extends keyof CommandModuleDefs>(
-    plug: Module | undefined,
-    type: T,
-): plug is CommandModuleDefs[T] {
-    // Another way to check if type is equivalent,
-    // It will check based on flag system instead
-    return plug !== undefined && (plug.type & type) !== 0;
-}
-
-export function isApplicationCommand(
-    interaction: Interaction,
-): interaction is
-    | ChatInputCommandInteraction
-    | UserContextMenuCommandInteraction
-    | MessageContextMenuCommandInteraction {
-    return interaction.type === InteractionType.ApplicationCommand;
-}
-
-export function isModalSubmit(interaction: Interaction): interaction is ModalSubmitInteraction {
-    return interaction.type === InteractionType.ModalSubmit;
-}
-export function isAutocomplete(interaction: Interaction): interaction is AutocompleteInteraction {
-    return interaction.type === InteractionType.ApplicationCommandAutocomplete;
-}
-export function isMessageComponent(
-    interaction: Interaction,
-): interaction is ButtonInteraction | SelectMenuInteraction {
-    return interaction.type === InteractionType.MessageComponent;
-}
-
-export function isDiscordEvent(el: EventModule): el is DiscordEventCommand {
-    return el.type === EventType.Discord;
-}
-export function isSernEvent(el: EventModule): el is SernEventCommand {
-    return el.type === EventType.Sern;
-}
-
-export function isExternalEvent(el: EventModule): el is ExternalEventCommand {
-    return el.type === EventType.External && 'emitter' in el;
-}
-
-// export function isEventPlugin<T extends CommandType>(
-//     e: CommandModulePlugin<T>,
-// ): e is EventPlugin<T> {
-//     return e.type === PluginType.Event;
-// }
-// export function isCommandPlugin<T extends CommandType>(
-//     e: CommandModulePlugin<T>,
-// ): e is CommandPlugin<T> {
-//     return !isEventPlugin(e);
-// }

src/handler/utilities/readFile.ts

@@ -1,90 +0,0 @@
-import { ApplicationCommandType, ComponentType } from 'discord.js';
-import { readdirSync, statSync } from 'fs';
-import { join } from 'path';
-import { type Observable, from, concatAll } from 'rxjs';
-import type { CommandModule } from '../structures/module';
-import { SernError } from '../structures/errors';
-import { type Result, Err, Ok } from 'ts-results-es';
-import type { EventEmitter } from 'events';
-
-//Maybe move this? this probably doesnt belong in utlities/
-export const BothCommands = new Map<string, CommandModule>();
-export const ApplicationCommands = {
-    [ApplicationCommandType.User]: new Map<string, CommandModule>(),
-    [ApplicationCommandType.Message]: new Map<string, CommandModule>(),
-    [ApplicationCommandType.ChatInput]: new Map<string, CommandModule>(),
-} as { [K in ApplicationCommandType]: Map<string, CommandModule> };
-
-export const MessageCompCommands = {
-    [ComponentType.Button]: new Map<string, CommandModule>(),
-    [ComponentType.SelectMenu]: new Map<string, CommandModule>(),
-    [ComponentType.TextInput]: new Map<string, CommandModule>(),
-};
-export const TextCommands = {
-    text: new Map<string, CommandModule>(),
-    aliases: new Map<string, CommandModule>(),
-};
-export const ModalSubmitCommands = new Map<string, CommandModule>();
-/**
- * keeps all external emitters stored here
- */
-export const ExternalEventEmitters = new Map<string, EventEmitter>();
-
-// Courtesy @Townsy45
-function readPath(dir: string, arrayOfFiles: string[] = []): string[] {
-    try {
-        const files = readdirSync(dir);
-        for (const file of files) {
-            if (statSync(dir + '/' + file).isDirectory()) readPath(dir + '/' + file, arrayOfFiles);
-            else arrayOfFiles.push(join(dir, '/', file));
-        }
-    } catch (err) {
-        throw err;
-    }
-
-    return arrayOfFiles;
-}
-
-export const fmtFileName = (n: string) => n.substring(0, n.length - 3);
-
-/**
- *
- * @returns {Observable<{ mod: Module; absPath: string; }[]>} data from command files
- * @param commandDir
- */
-
-export function buildData<T>(commandDir: string): Observable<
-    Result<
-        {
-            mod: T;
-            absPath: string;
-        },
-        SernError
-    >
-> {
-    const commands = getCommands(commandDir);
-    return from(
-        Promise.all(
-            commands.map(async absPath => {
-                let mod: T | undefined;
-                try {
-                    // eslint-disable-next-line @typescript-eslint/no-var-requires
-                    mod = require(absPath).default;
-                } catch {
-                    mod = (await import(`file:///` + absPath)).default;
-                }
-                if (mod === undefined) {
-                    return Err(SernError.UndefinedModule);
-                }
-                try {
-                    mod = new (mod as unknown as new () => T)();
-                } catch {}
-                return Ok({ mod, absPath });
-            }),
-        ),
-    ).pipe(concatAll());
-}
-
-export function getCommands(dir: string): string[] {
-    return readPath(join(process.cwd(), dir));
-}

src/handler/utilities/treeSearch.ts

@@ -1,42 +0,0 @@
-import type { SernAutocompleteData, SernOptionsData } from '../structures/module';
-import { ApplicationCommandOptionType, AutocompleteInteraction } from 'discord.js';
-
-export default function treeSearch(
-    iAutocomplete: AutocompleteInteraction,
-    options: SernOptionsData[] | undefined,
-): SernAutocompleteData {
-    if (options === undefined) return undefined;
-    const _options = options.slice(); // required to prevent direct mutation of options
-    let autocompleteData: SernAutocompleteData;
-
-    while (_options.length > 0) {
-        const cur = _options.pop()!;
-        switch (cur.type) {
-            case ApplicationCommandOptionType.Subcommand:
-                {
-                    for (const option of cur.options ?? []) {
-                        _options.push(option);
-                    }
-                }
-                break;
-            case ApplicationCommandOptionType.SubcommandGroup:
-                {
-                    for (const command of cur.options ?? []) {
-                        _options.push(command);
-                    }
-                }
-                break;
-            default:
-                {
-                    if (cur.autocomplete) {
-                        const choice = iAutocomplete.options.getFocused(true);
-                        if (cur.name === choice.name && cur.autocomplete) {
-                            autocompleteData = cur;
-                        }
-                    }
-                }
-                break;
-        }
-    }
-    return autocompleteData;
-}

src/handlers/_internal.ts

@@ -0,0 +1,2 @@
+export * from './dispatchers';
+export * from './event-utils';

src/handlers/dispatchers.ts

@@ -0,0 +1,98 @@
+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 { Args } from '../types/utility';
+import { inspect } from 'node:util'
+import type { CommandModule, Module, 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 intoPayload(module: Processed<Module>, ) {
+    return pipe(
+        arrayifySource,
+        map(args => ({ module, args, })),
+    );
+}
+
+const createResult = createResultResolver<
+    Processed<Module>,
+    { module: Processed<Module>; args: unknown[]  },
+    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>,  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),
+        concatMap(createResult),
+        execute,
+    );
+}
+
+export function createDispatcher(payload: {
+    module: Processed<CommandModule>;
+    event: BaseInteraction;
+}) {
+    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, SernError.NotSupportedInteraction + ` There is no autocomplete tag for ` + inspect(payload.module));
+                const { command } = option;
+            
+             	return {
+                    ...payload,
+             	    module: command as Processed<Module>, //autocomplete is not a true "module" warning cast!
+             	    args: [payload.event],
+             	};
+            }
+            return {
+                module: payload.module,
+                args: contextArgs(payload.event),
+            };
+        }
+        default: return { 
+            module: payload.module,
+            args: [payload.event],
+        };
+    }
+}

src/handlers/event-utils.ts

@@ -0,0 +1,269 @@
+import { Interaction, Message } from 'discord.js';
+import {
+    EMPTY,
+    Observable,
+    concatMap,
+    filter,
+    from,
+    of,
+    throwError,
+    tap,
+    MonoTypeOperatorFunction,
+    catchError,
+    finalize,
+} from 'rxjs';
+import {
+    Files,
+    Id,
+    callPlugin,
+    everyPluginOk,
+    filterMapTo,
+    handleError,
+    SernError,
+    VoidResult,
+} from '../core/_internal';
+import { 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 { Awaitable } from '../types/utility';
+import type { ControlPlugin } from '../types/core-plugin';
+import type { AnyModule, CommandModule, Module, Processed } from '../types/core-modules';
+import type { ImportPayload } from '../types/core';
+import { disposeAll } from '../core/ioc/base';
+
+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),
+            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);
+}
+
+/**
+ *
+ * Creates an RxJS observable that filters and maps incoming interactions to their respective modules.
+ * @param i An RxJS observable of interactions.
+ * @param mg The module manager instance used to retrieve the module path for each interaction.
+ * @returns A handler to create a RxJS observable of dispatchers that take incoming interactions and execute their corresponding modules.
+ */
+export function createInteractionHandler<T extends Interaction>(
+    source: Observable<Interaction>,
+    mg: ModuleManager,
+) {
+    return createGenericHandler<Interaction, T, Result<ReturnType<typeof createDispatcher>, void>>(
+        source,
+        async event => {
+            const possibleIds = Id.reconstruct(event);
+            let fullPaths= possibleIds
+                .map(id => mg.get(id))
+                .filter((id): id is string => id !== undefined);
+
+            if(fullPaths.length == 0) {
+                return Err.EMPTY;
+            }
+            const [ path ] = fullPaths;
+            return Files
+            .defaultModuleLoader<Processed<CommandModule>>(path)
+            .then(payload => Ok(createDispatcher({ 
+                                    module: payload.module, 
+                                    event,
+                                })));
+    },
+);
+}
+
+export function createMessageHandler(
+    source: Observable<Message>,
+    defaultPrefix: string,
+    mg: ModuleManager,
+) {
+    return createGenericHandler(source, async event => {
+        const [prefix, ...rest] = fmt(event.content, defaultPrefix);
+        let fullPath = mg.get(`${prefix}_T`);
+        if(!fullPath) {
+            fullPath = mg.get(`${prefix}_B`);
+            if(!fullPath) {
+                return Err('Possibly undefined behavior: could not find a static id to resolve');
+            }
+        }
+        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>;
+    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
+ * @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,
+    logger: Logging|undefined,
+    errHandler: ErrorHandling,
+    {
+        module,
+        task,
+        args
+    }: ExecutePayload,
+) {
+    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', SernEmitter.success(module));
+                return EMPTY;
+            } 
+            return throwError(() => SernEmitter.failure(module, result.error));
+            
+        }),
+    );
+}
+
+
+
+/**
+ * A higher order function that
+ * - 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 }
+ * emit config.onSuccess Observable
+ * @param config
+ * @returns receiver function for flattening a stream of data
+ */
+export function createResultResolver<
+    T extends { execute: (...args: any[]) => any; onEvent: ControlPlugin[] },
+    Args extends { module: T; [key: string]: unknown },
+    Output,
+>(config: {
+    onStop?: (module: T) => unknown;
+    onNext: (args: Args) => Output;
+    createStream: (args: Args) => Observable<VoidResult>;
+}) {
+    return (args: Args) => {
+        const task$ = config.createStream(args);
+        return task$.pipe(
+            tap(result => {
+                result.isErr() && config.onStop?.(args.module);
+            }),
+            everyPluginOk,
+            filterMapTo(() => config.onNext(args)),
+        );
+    };
+}
+
+/**
+ * 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 }) => {
+                sernEmitter.emit('module.register', SernEmitter.success(module));
+                return { module };
+            },
+        }),
+    );
+}
+
+/**
+ * Creates an executable task ( execute the command ) if  all control plugins are successful
+ * @param onStop emits a failure response to the SernEmitter
+ */
+export function makeModuleExecutor<
+    M extends Processed<Module>,
+    Args extends { 
+        module: M;
+        args: unknown[];
+    },
+>(onStop: (m: M) => unknown) {
+    const onNext = ({ args, module }: Args) => ({
+        task: () => module.execute(...args),
+        module,
+        args
+    });
+    return concatMap(
+        createResultResolver({
+            onStop,
+            createStream: ({ args, module }) => 
+                from(module.onEvent)
+                    .pipe(callPlugin(args)),
+            onNext,
+        }),
+    );
+}
+
+export const handleCrash = (err: ErrorHandling, log?: Logging) =>
+    pipe(
+        catchError(handleError(err, log)),
+        finalize(() => {
+            log?.info({
+                message: 'A stream closed or reached end of lifetime',
+            });
+            disposeAll(log);
+        }));

src/handlers/interaction-event.ts

@@ -0,0 +1,32 @@
+import { Interaction } from 'discord.js';
+import { mergeMap, 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))),
+            mergeMap(payload => executeModule(emitter, log, err, payload)));
+}

src/handlers/message-event.ts

@@ -0,0 +1,46 @@
+import { mergeMap, 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));
+        }),
+        mergeMap(payload => executeModule(emitter, log, err, payload)));
+}

src/handlers/presence.ts

@@ -0,0 +1,46 @@
+import { concatMap, from, interval, of, map, scan, startWith, fromEvent, take } from "rxjs"
+import { Files } from "../core/_internal";
+import * as Presence from "../core/presences";
+import { Services } from "../core/ioc";
+import assert from "node:assert";
+
+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));
+        }
+        //take 1?
+        return of(s).pipe(take(1));
+    })
+};
+
+export const presenceHandler = (path: string, setPresence: SetPresence) => {
+    interface PresenceModule  {
+        module: Presence.Config<(keyof Dependencies)[]>
+    }
+    const presence = Files
+        .importModule<PresenceModule>(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))));
+}

src/handlers/ready-event.ts

@@ -0,0 +1,50 @@
+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.alias?.forEach(a => manager.set(`${a}_B`, fullPath));
+    } else {
+        if(module.type === CommandType.Text){ 
+            module.alias?.forEach(a => manager.set(`${a}_T`, fullPath));
+        }
+    }
+    return Result.wrap(() => manager.set(id, fullPath));
+}

src/handlers/user-defined-events.ts

@@ -0,0 +1,36 @@
+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,  Processed } from '../types/core-modules';
+
+export function eventsHandler(
+    [emitter, err, log, moduleManager, client]: DependencyList,
+    allPaths: ObservableInput<string>,
+) {
+    //code smell
+    const intoDispatcher = (e: { module: Processed<EventModule> }) => {
+        switch (e.module.type) {
+            case EventType.Sern:
+                return eventDispatcher(e.module,  emitter);
+            case EventType.Discord:
+                return eventDispatcher(e.module,  client);
+            case EventType.External:
+                return eventDispatcher(e.module,  Service(e.module.emitter));
+            default:
+                throw Error(SernError.InvalidModuleType + ' while creating event handler');
+        }
+    };
+    buildModules<EventModule>(allPaths, moduleManager)
+        .pipe(
+            callInitPlugins(emitter),
+            map(intoDispatcher),
+            /**
+             * Where all events are turned on
+             */
+            mergeAll(),
+            handleCrash(err, log))
+        .subscribe();
+}

src/index.ts

@@ -1,7 +1,57 @@
-import SernEmitter from './handler/sernEmitter';
+export * as Sern from './sern';
-export { eventModule, commandModule, EventExecutable, CommandExecutable } from './handler/sern';
+export * from './core';
-export * as Sern from './handler/sern';
+export type {
-export * from './types/handler';
+    CommandModule,
-export * from './handler/structures/structxports';
+    EventModule,
-export * from './handler/plugins/plugin';
+    BothCommand,
-export { SernEmitter };
+    ContextMenuMsg,
+    ContextMenuUser,
+    SlashCommand,
+    TextCommand,
+    ButtonCommand,
+    StringSelectCommand,
+    MentionableSelectCommand,
+    UserSelectCommand,
+    ChannelSelectCommand,
+    RoleSelectCommand,
+    ModalSubmitCommand,
+    DiscordEventCommand,
+    SernEventCommand,
+    ExternalEventCommand,
+    CommandModuleDefs,
+    EventModuleDefs,
+    SernAutocompleteData,
+    SernOptionsData,
+    SernSubCommandData,
+    SernSubCommandGroupData,
+} from './types/core-modules';
+
+export type {
+    Controller,
+    PluginResult,
+    InitPlugin,
+    ControlPlugin,
+    Plugin,
+    AnyEventPlugin,
+    AnyCommandPlugin,
+} from './types/core-plugin';
+
+export type { Wrapper } from './types/core';
+
+export type { Args, SlashOptions, Payload, SernEventsMapping } from './types/utility';
+
+export type { Singleton, Transient, CoreDependencies, Initializable } from './types/ioc';
+
+export {
+    commandModule,
+    eventModule,
+    discordEvent,
+    EventExecutable,
+    CommandExecutable,
+} from './core/modules';
+
+export * as Presence from './core/presences'
+
+export {
+    useContainerRaw
+} from './core/_internal'

src/sern.ts

@@ -0,0 +1,69 @@
+import { handleCrash } from './handlers/_internal';
+import callsites from 'callsites';
+import { err, ok, Files } from './core/_internal';
+import { merge } from 'rxjs';
+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';
+import { presenceHandler } from './handlers/presence';
+import { Client } from 'discord.js';
+
+/**
+ * @since 1.0.0
+ * @param wrapper Options to pass into sern.
+ * Function to start the handler up
+ * @example
+ * ```ts title="src/index.ts"
+ * Sern.init({
+ *     commands: 'dist/commands',
+ *     events: 'dist/events',
+ * })
+ * ```
+ */
+
+export function init(maybeWrapper: Wrapper | 'file') {
+    const startTime = performance.now();
+    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
+    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`, });
+            if(presencePath.exists) {
+                const setPresence = async (p: any) => {
+                    return (dependencies[4] as Client).user?.setPresence(p);
+                }
+                presenceHandler(presencePath.path, setPresence).subscribe();
+            }
+        });
+
+    const messages$ = messageHandler(dependencies, wrapper.defaultPrefix);
+    const interactions$ = interactionHandler(dependencies);
+    // listening to the message stream and interaction stream
+    merge(messages$, interactions$).pipe(handleCrash(errorHandler, logger)).subscribe();
+}
+
+function useDependencies() {
+    return Services(
+        '@sern/emitter',
+        '@sern/errors',
+        '@sern/logger',
+        '@sern/modules',
+        '@sern/client',
+    );
+}
+
+

src/types/core-modules.ts

@@ -0,0 +1,216 @@
+import type {
+    APIApplicationCommandBasicOption,
+    APIApplicationCommandOptionBase,
+    ApplicationCommandOptionType,
+    BaseApplicationCommandOptionsData,
+    AutocompleteInteraction,
+    ButtonInteraction,
+    ChannelSelectMenuInteraction,
+    ClientEvents,
+    MentionableSelectMenuInteraction,
+    MessageContextMenuCommandInteraction,
+    ModalSubmitInteraction,
+    RoleSelectMenuInteraction,
+    StringSelectMenuInteraction,
+    UserContextMenuCommandInteraction,
+    UserSelectMenuInteraction,
+} from 'discord.js';
+import { CommandType, Context, EventType } from '../../src/core';
+import { AnyCommandPlugin, AnyEventPlugin, ControlPlugin, InitPlugin } from './core-plugin';
+import { Awaitable, Args, SlashOptions, SernEventsMapping } from './utility';
+
+
+
+export interface CommandMeta {
+    fullPath: string;
+    id: string;
+    isClass: boolean;
+}
+
+export type Processed<T> = T & { name: string; description: string };
+
+export interface Module {
+    type: CommandType | EventType;
+    name?: string;
+    onEvent: ControlPlugin[];
+    plugins: InitPlugin[];
+    description?: string;
+    execute(...args: any[]): Awaitable<any>;
+}
+
+export interface SernEventCommand<T extends keyof SernEventsMapping = keyof SernEventsMapping>
+    extends Module {
+    name?: T;
+    type: EventType.Sern;
+    execute(...args: SernEventsMapping[T]): Awaitable<unknown>;
+}
+export interface ExternalEventCommand extends Module {
+    name?: string;
+    emitter: keyof Dependencies;
+    type: EventType.External;
+    execute(...args: unknown[]): Awaitable<unknown>;
+}
+
+export interface ContextMenuUser extends Module {
+    type: CommandType.CtxUser;
+    execute: (ctx: UserContextMenuCommandInteraction) => Awaitable<unknown>;
+}
+
+export interface ContextMenuMsg extends Module {
+    type: CommandType.CtxMsg;
+    execute: (ctx: MessageContextMenuCommandInteraction) => Awaitable<unknown>;
+}
+
+export interface ButtonCommand extends Module {
+    type: CommandType.Button;
+    execute: (ctx: ButtonInteraction) => Awaitable<unknown>;
+}
+
+export interface StringSelectCommand extends Module {
+    type: CommandType.StringSelect;
+    execute: (ctx: StringSelectMenuInteraction) => Awaitable<unknown>;
+}
+
+export interface ChannelSelectCommand extends Module {
+    type: CommandType.ChannelSelect;
+    execute: (ctx: ChannelSelectMenuInteraction) => Awaitable<unknown>;
+}
+
+export interface RoleSelectCommand extends Module {
+    type: CommandType.RoleSelect;
+    execute: (ctx: RoleSelectMenuInteraction) => Awaitable<unknown>;
+}
+
+export interface MentionableSelectCommand extends Module {
+    type: CommandType.MentionableSelect;
+    execute: (ctx: MentionableSelectMenuInteraction) => Awaitable<unknown>;
+}
+
+export interface UserSelectCommand extends Module {
+    type: CommandType.UserSelect;
+    execute: (ctx: UserSelectMenuInteraction) => Awaitable<unknown>;
+}
+
+export interface ModalSubmitCommand extends Module {
+    type: CommandType.Modal;
+    execute: (ctx: ModalSubmitInteraction) => Awaitable<unknown>;
+}
+
+export interface AutocompleteCommand
+    extends Omit<Module, 'name' | 'type' | 'plugins' | 'description'> {
+    onEvent: ControlPlugin[];
+    execute: (ctx: AutocompleteInteraction) => Awaitable<unknown>;
+}
+
+export interface DiscordEventCommand<T extends keyof ClientEvents = keyof ClientEvents>
+    extends Module {
+    name?: T;
+    type: EventType.Discord;
+    execute(...args: ClientEvents[T]): Awaitable<unknown>;
+}
+export interface TextCommand extends Module {
+    type: CommandType.Text;
+    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, args: ['slash', SlashOptions]) => Awaitable<unknown>;
+}
+
+export interface BothCommand extends Module {
+    type: CommandType.Both;
+    alias?: string[];
+    description: string;
+    options?: SernOptionsData[];
+    execute: (ctx: Context, args: Args) => Awaitable<unknown>;
+}
+
+export type EventModule = DiscordEventCommand | SernEventCommand | ExternalEventCommand;
+export type CommandModule =
+    | TextCommand
+    | SlashCommand
+    | BothCommand
+    | ContextMenuUser
+    | ContextMenuMsg
+    | ButtonCommand
+    | StringSelectCommand
+    | MentionableSelectCommand
+    | UserSelectCommand
+    | ChannelSelectCommand
+    | 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 {
+    [CommandType.Text]: TextCommand;
+    [CommandType.Slash]: SlashCommand;
+    [CommandType.Both]: BothCommand;
+    [CommandType.CtxMsg]: ContextMenuMsg;
+    [CommandType.CtxUser]: ContextMenuUser;
+    [CommandType.Button]: ButtonCommand;
+    [CommandType.StringSelect]: StringSelectCommand;
+    [CommandType.RoleSelect]: RoleSelectCommand;
+    [CommandType.ChannelSelect]: ChannelSelectCommand;
+    [CommandType.MentionableSelect]: MentionableSelectCommand;
+    [CommandType.UserSelect]: UserSelectCommand;
+    [CommandType.Modal]: ModalSubmitCommand;
+}
+
+export interface EventModuleDefs {
+    [EventType.Sern]: SernEventCommand;
+    [EventType.Discord]: DiscordEventCommand;
+    [EventType.External]: ExternalEventCommand;
+}
+
+export interface SernAutocompleteData
+    extends Omit<BaseApplicationCommandOptionsData, 'autocomplete'> {
+    autocomplete: true;
+    type:
+        | ApplicationCommandOptionType.String
+        | ApplicationCommandOptionType.Number
+        | ApplicationCommandOptionType.Integer;
+    command: AutocompleteCommand;
+}
+
+type CommandModuleNoPlugins = {
+    [T in CommandType]: Omit<CommandModuleDefs[T], 'plugins' | 'onEvent'>;
+};
+type EventModulesNoPlugins = {
+    [T in EventType]: Omit<EventModuleDefs[T], 'plugins' | 'onEvent'>;
+};
+
+export type InputEvent = {
+    [T in EventType]: EventModulesNoPlugins[T] & { plugins?: AnyEventPlugin[] };
+}[EventType];
+
+export type InputCommand = {
+    [T in CommandType]: CommandModuleNoPlugins[T] & {
+        plugins?: AnyCommandPlugin[];
+    };
+}[CommandType];
+
+/**
+ * Type that replaces autocomplete with {@link SernAutocompleteData}
+ */
+export type SernOptionsData =
+    | SernSubCommandData
+    | SernSubCommandGroupData
+    | APIApplicationCommandBasicOption
+    | SernAutocompleteData;
+
+export interface SernSubCommandData
+    extends APIApplicationCommandOptionBase<ApplicationCommandOptionType.Subcommand> {
+    type: ApplicationCommandOptionType.Subcommand;
+    options?: SernOptionsData[];
+}
+
+export interface SernSubCommandGroupData extends BaseApplicationCommandOptionsData {
+    type: ApplicationCommandOptionType.SubcommandGroup;
+    options?: SernSubCommandData[];
+}

src/types/core-plugin.ts

@@ -0,0 +1,153 @@
+/*
+ * Plugins can be inserted on all commands and are emitted
+ *
+ * 1. On ready event, where all commands are loaded.
+ * 2. On corresponding observable (when command triggers)
+ *
+ * The goal of plugins is to organize commands and
+ * provide extensions to repetitive patterns
+ * examples include refreshing modules,
+ * categorizing commands, cool-downs, permissions, etc.
+ * Plugins are reminiscent of middleware in express.
+ */
+
+import type { Err, Ok, Result } from 'ts-results-es';
+import type {
+    BothCommand,
+    ButtonCommand,
+    ChannelSelectCommand,
+    CommandModule,
+    ContextMenuMsg,
+    ContextMenuUser,
+    DiscordEventCommand,
+    EventModule,
+    ExternalEventCommand,
+    MentionableSelectCommand,
+    ModalSubmitCommand,
+    Module,
+    Processed,
+    RoleSelectCommand,
+    SernEventCommand,
+    SlashCommand,
+    StringSelectCommand,
+    TextCommand,
+    UserSelectCommand,
+} from './core-modules';
+import { Args, Awaitable, Payload, SlashOptions } from './utility';
+import { CommandType, Context, EventType, PluginType } from '../core';
+import {
+    ButtonInteraction,
+    ChannelSelectMenuInteraction,
+    ClientEvents,
+    MentionableSelectMenuInteraction,
+    MessageContextMenuCommandInteraction,
+    ModalSubmitInteraction,
+    RoleSelectMenuInteraction,
+    StringSelectMenuInteraction,
+    UserContextMenuCommandInteraction,
+    UserSelectMenuInteraction,
+} from 'discord.js';
+
+export type PluginResult = Awaitable<VoidResult>;
+export type VoidResult = Result<void, void>;
+
+export interface InitArgs<T extends Processed<Module>> {
+    module: T;
+    absPath: string;
+}
+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[]> {
+    type: PluginType.Init;
+    execute: (...args: Args) => PluginResult;
+}
+export interface ControlPlugin<Args extends any[] = any[]> {
+    type: PluginType.Control;
+    execute: (...args: Args) => PluginResult;
+}
+
+export type AnyCommandPlugin = ControlPlugin | InitPlugin<[InitArgs<Processed<CommandModule>>]>;
+export type AnyEventPlugin = ControlPlugin | InitPlugin<[InitArgs<Processed<EventModule>>]>;
+
+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]: {
+        [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>>];
+    };
+}

src/types/core.ts

@@ -0,0 +1,23 @@
+
+export interface ImportPayload<T> {
+    module: T;
+    absPath: string;
+    [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[];
+    };
+}

src/types/dependencies.d.ts

@@ -0,0 +1,12 @@
+// This file serves an the interface for developers to augment the Dependencies interface
+// Developers will have to create a new file dependencies.d.ts in the root directory, augmenting
+// this type
+
+/* eslint-disable @typescript-eslint/consistent-type-imports */
+
+import { CoreDependencies } from './ioc';
+
+declare global {
+    interface Dependencies extends CoreDependencies {}
+
+}

src/types/handler.ts

@@ -1,58 +0,0 @@
-import type { CommandInteractionOptionResolver } from 'discord.js';
-import type { CommandModule, EventModule, Module } from '../handler/structures/module';
-import type { PayloadType } from '../handler/structures/enums';
-import type { InteractionReplyOptions, MessageReplyOptions } from 'discord.js';
-export type Nullish<T> = T | undefined | null;
-
-// Thanks to @kelsny
-export type ParseType<T> = {
-    [K in keyof T]: T[K] extends unknown ? [k: K, args: T[K]] : never;
-}[keyof T];
-
-export type Args = ParseType<{ text: string[]; slash: SlashOptions }>;
-
-export type SlashOptions = Omit<CommandInteractionOptionResolver, 'getMessage' | 'getFocused'>;
-
-// Source: https://dev.to/vborodulin/ts-how-to-override-properties-with-type-intersection-554l
-export type Override<T1, T2> = Omit<T1, keyof T2> & T2;
-
-export type DefinitelyDefined<T, K extends keyof T = keyof T> = {
-    [L in K]-?: T[L] extends Record<string, unknown>
-        ? DefinitelyDefined<T[L], keyof T[L]>
-        : Required<T>[L];
-} & T;
-
-export type EventInput =
-    | string
-    | { mod: EventModule; absPath: string }[]
-    | (() => { mod: EventModule; absPath: string }[]);
-
-/**
- * Turns a function with a union of array of args into a single union
- *  [ T , V , B ] | [ A ] => T | V | B | A
- */
-export type SpreadParams<T extends (...args: never) => unknown> = (
-    args: Parameters<T>[number],
-) => unknown;
-
-/**
- * After modules are transformed, name and description are given default values if none
- * are provided to Module. This type represents that transformation
- */
-export type DefinedModule = DefinitelyDefined<Module, 'name' | 'description'>;
-export type DefinedCommandModule = DefinitelyDefined<CommandModule, 'name' | 'description'>;
-export type DefinedEventModule = DefinitelyDefined<EventModule, 'name' | 'description'>;
-export type Payload =
-    | { type: PayloadType.Success; module: Module }
-    | { type: PayloadType.Failure; module?: Module; reason: string | Error };
-export type SernEventsMapping = {
-    ['module.register']: [Payload];
-    ['module.activate']: [Payload];
-    ['error']: [Payload];
-    ['warning']: [string];
-};
-
-export type ReplyOptions =
-    | string
-    | Omit<InteractionReplyOptions, 'fetchReply'>
-    | MessageReplyOptions;

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, {}>;
+}

src/types/utility.ts

@@ -0,0 +1,33 @@
+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 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: [Payload];
+    warning: [Payload];
+    modulesLoaded: [never?];
+}
+
+export type Payload =
+    | { type: PayloadType.Success; module: AnyModule }
+    | { type: PayloadType.Failure; module?: AnyModule; reason: string | Error }
+    | { type: PayloadType.Warning; reason: string };
+
+
+
+export type ReplyOptions = string | Omit<InteractionReplyOptions, 'fetchReply'> | MessageReplyOptions;

test/core/context.test.ts

@@ -0,0 +1,85 @@
+import { describe, vi, it, expect } from'vitest'
+import { Context } from '../../src';
+import { faker } from '@faker-js/faker'
+describe('Context', () => {
+    // Mocked message and interaction objects for testing
+    const mockMessage = {
+        id: 'messageId',
+        channel: 'channelId',
+        channelId: 'channelId',
+        interaction: { 
+            id: faker.string.uuid()
+        },
+        author: { id: 'userId' },
+        createdTimestamp: 1234567890,
+        guild: 'guildId',
+        guildId: 'guildId',
+        member: { id: 'memberId' },
+        client: { id: 'clientId' },
+        inGuild: vi.fn().mockReturnValue(true),
+        reply: vi.fn(),
+    };
+
+    const mockInteraction = {
+        id: 'interactionId',
+        user: { id: 'userId' },
+        channel: 'channelId',
+        channelId: 'channelId',
+        createdTimestamp: 1234567890,
+        guild: 'guildId',
+        guildId: 'guildId',
+        fetchReply: vi.fn().mockResolvedValue({}),
+        member: { id: 'memberId' },
+        client: { id: 'clientId' },
+        isChatInputCommand: vi.fn().mockResolvedValue(true),
+        inGuild: vi.fn().mockReturnValue(true),
+        reply: vi.fn().mockResolvedValue({}),
+    };
+
+    it('should create a context from a message', () => {
+        //@ts-ignore
+        const context = Context.wrap(mockMessage);
+        expect(context).toBeDefined();
+        expect(context.id).toBe('messageId');
+    });
+    it('should throw error if accessing interaction as message', () => {
+        //@ts-ignore
+        const context = Context.wrap(mockMessage);
+        expect(context).toBeDefined();
+        expect(() => context.interaction)
+            .toThrowError('You cannot use message when an interaction fired or vice versa');
+
+    })
+     it('should throw error if accessing message as interaction', () => {
+        //@ts-ignore
+        const context = Context.wrap(mockInteraction);
+        expect(context).toBeDefined();
+        expect(() => context.message)
+            .toThrowError('You cannot use message when an interaction fired or vice versa');
+
+    })
+
+    it('should create a context from an interaction', () => {
+        //@ts-ignore
+        const context = Context.wrap(mockInteraction);
+        expect(context).toBeDefined();
+        expect(context.id).toBe('interactionId'); 
+    });
+
+    it('should reply to a context with a message', async () => {
+        //@ts-ignore
+        const context = Context.wrap(mockMessage);
+        const replyOptions = { content: 'Hello, world!' };
+        await context.reply(replyOptions);
+        expect(mockMessage.reply).toHaveBeenCalledWith(replyOptions);
+    });
+
+    it('should reply to a context with an interaction', async () => {
+        //@ts-ignore
+        const context = Context.wrap(mockInteraction);
+        const replyOptions = { content: 'Hello, world!' };
+        await context.reply(replyOptions);
+        expect(mockInteraction.reply).toHaveBeenCalledWith(replyOptions);
+    });
+
+});

test/core/contracts.test.ts

@@ -0,0 +1,16 @@
+import { assertType, describe, it } from 'vitest';
+
+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 DefaultContracts.DefaultLogging());
+        assertType<Contracts.ErrorHandling>(new DefaultContracts.DefaultErrorHandling());
+        assertType<Contracts.ModuleManager>(
+            new DefaultContracts.DefaultModuleManager(new ModuleStore()),
+        );
+        assertType<Contracts.CoreModuleStore>(new ModuleStore());
+    });
+});

test/core/create-plugin.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest';
+import {
+    CommandControlPlugin,
+    CommandInitPlugin,
+    EventControlPlugin,
+    EventInitPlugin,
+} 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);
+        expect(pl2.execute).an('function');
+    });
+    it('should make proper init plugins', () => {
+        const pl = EventInitPlugin(() => controller.next());
+        expect(pl).to.have.all.keys(['type', 'execute']);
+        expect(pl.type).toBe(PluginType.Init);
+        expect(pl.execute).an('function');
+
+        const pl2 = CommandInitPlugin(() => controller.next());
+        expect(pl2).to.have.all.keys(['type', 'execute']);
+        expect(pl2.type).toBe(PluginType.Init);
+        expect(pl2.execute).an('function');
+    });
+});

test/core/functions.test.ts

@@ -0,0 +1,404 @@
+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', () => {
+    const Collection = Map;
+    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,
+        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,
+    };
+});
+
+describe('functions', () => {
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    function createRandomPlugins(len: number) {
+        const random = () => Math.floor(Math.random() * 2) + 1; // 1 or 2, plugin enum
+        return Array.from({ length: len }, () => ({
+            type: random(),
+            execute: () => (random() === 1 ? controller.next() : controller.stop()),
+        }));
+    }
+    function createRandomChoice() {
+        return {
+            type: faker.number.int({ min: 1, max: 11 }),
+            name: faker.word.noun(),
+            description: faker.word.adjective(),
+        };
+    }
+    it('should partition plugins correctly', () => {
+        const plugins = createRandomPlugins(100);
+        const [onEvent, init] = partitionPlugins(plugins);
+        for (const el of onEvent) expect(el.type).to.equal(PluginType.Control);
+
+        for (const el of init) expect(el.type).to.equal(PluginType.Init);
+    });
+
+    it('should tree search options tree depth 1', () => {
+        //@ts-expect-error mocking
+        let autocmpInteraction = new AutocompleteInteraction('autocomplete');
+        const options: SernOptionsData[] = [
+            createRandomChoice(),
+            createRandomChoice(),
+            createRandomChoice(),
+            {
+                type: ApplicationCommandOptionType.String,
+                name: 'autocomplete',
+                description: 'here',
+                autocomplete: true,
+                command: { onEvent: [], execute: vi.fn() },
+            },
+        ];
+        autocmpInteraction.options.getFocused.mockReturnValue({
+            name: 'autocomplete',
+            value: faker.string.alpha(),
+            focused: true,
+        });
+        const result = treeSearch(autocmpInteraction, options);
+        expect(result == undefined).to.be.false;
+        expect(result.name).to.be.eq('autocomplete');
+        expect(result.command).to.be.not.undefined;
+    }),
+        it('should tree search depth 2', () => {
+            //@ts-expect-error mocking
+            let autocmpInteraction = new AutocompleteInteraction('nested');
+            const subcommandName = faker.string.alpha();
+            const options: SernOptionsData[] = [
+                {
+                    type: ApplicationCommandOptionType.Subcommand,
+                    name: subcommandName,
+                    description: faker.string.alpha(),
+                    options: [
+                        createRandomChoice(),
+                        createRandomChoice(),
+                        createRandomChoice(),
+                        {
+                            type: ApplicationCommandOptionType.String,
+                            name: 'nested',
+                            description: faker.string.alpha(),
+                            autocomplete: true,
+                            command: {
+                                onEvent: [],
+                                execute: () => {},
+                            },
+                        },
+                    ],
+                },
+            ];
+            autocmpInteraction.options.getSubcommand.mockReturnValue(subcommandName);
+            autocmpInteraction.options.getFocused.mockReturnValue({
+                name: 'nested',
+                value: faker.string.alpha(),
+                focused: true,
+            });
+            const result = treeSearch(autocmpInteraction, options);
+            expect(result == undefined).to.be.false;
+            expect(result.name).to.be.eq('nested');
+            expect(result.command).to.be.not.undefined;
+        });
+
+    it('should tree search depth n > 2', () => {
+        //@ts-expect-error mocking
+        let autocmpInteraction = new AutocompleteInteraction('nested');
+        const subcommandName = faker.string.alpha();
+        const options: SernOptionsData[] = [
+            {
+                type: ApplicationCommandOptionType.SubcommandGroup,
+                name: faker.string.alpha(),
+                description: faker.string.alpha(),
+                options: [
+                    {
+                        type: ApplicationCommandOptionType.Subcommand,
+                        name: subcommandName,
+                        description: faker.string.alpha(),
+                        options: [
+                            createRandomChoice(),
+                            createRandomChoice(),
+                            {
+                                type: ApplicationCommandOptionType.String,
+                                name: 'nested',
+                                description: faker.string.alpha(),
+                                autocomplete: true,
+                                command: {
+                                    onEvent: [],
+                                    execute: () => {},
+                                },
+                            },
+                            createRandomChoice(),
+                        ],
+                    },
+                ],
+            },
+        ];
+        autocmpInteraction.options.getSubcommand.mockReturnValue(subcommandName);
+        autocmpInteraction.options.getFocused.mockReturnValue({
+            name: 'nested',
+            value: faker.string.alpha(),
+            focused: true,
+        });
+        const result = treeSearch(autocmpInteraction, options);
+        expect(result == undefined).to.be.false;
+        expect(result.name).to.be.eq('nested');
+        expect(result.command).to.be.not.undefined;
+    });
+    it('should correctly resolve suboption of the same name given two subcommands ', () => {
+        let autocmpInteraction = new AutocompleteInteraction('nested');
+        const subcommandName = faker.string.alpha();
+        const options: SernOptionsData[] = [
+            {
+                type: ApplicationCommandOptionType.SubcommandGroup,
+                name: faker.string.alpha(),
+                description: faker.string.alpha(),
+                options: [
+                    {
+                        type: ApplicationCommandOptionType.Subcommand,
+                        name: subcommandName,
+                        description: faker.string.alpha(),
+                        options: [
+                            createRandomChoice(),
+                            createRandomChoice(),
+                            {
+                                type: ApplicationCommandOptionType.String,
+                                name: 'nested',
+                                description: faker.string.alpha(),
+                                autocomplete: true,
+                                command: {
+                                    onEvent: [],
+                                    execute: () => {},
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        type: ApplicationCommandOptionType.Subcommand,
+                        name: subcommandName + 'a',
+                        description: faker.string.alpha(),
+                        options: [
+                            createRandomChoice(),
+                            {
+                                type: ApplicationCommandOptionType.String,
+                                name: 'nested',
+                                description: faker.string.alpha(),
+                                autocomplete: true,
+                                command: {
+                                    onEvent: [],
+                                    execute: () => {},
+                                },
+                            },
+                        ],
+                    },
+                ],
+            },
+        ];
+        autocmpInteraction.options.getSubcommand.mockReturnValue(subcommandName);
+        autocmpInteraction.options.getFocused.mockReturnValue({
+            name: 'nested',
+            value: faker.string.alpha(),
+            focused: true,
+        });
+        const result = treeSearch(autocmpInteraction, options);
+        expect(result).toBeTruthy();
+        expect(result.name).to.be.eq('nested');
+        expect(result.command).to.be.not.undefined;
+    });
+    it('two subcommands with an option of the same name', () => {
+        let autocmpInteraction = new AutocompleteInteraction('nested');
+        const subcommandName = faker.string.alpha();
+        const options: SernOptionsData[] = [
+            {
+                type: ApplicationCommandOptionType.SubcommandGroup,
+                name: faker.string.alpha(),
+                description: faker.string.alpha(),
+                options: [
+                    {
+                        type: ApplicationCommandOptionType.Subcommand,
+                        name: subcommandName,
+                        description: faker.string.alpha(),
+                        options: [
+                            createRandomChoice(),
+                            createRandomChoice(),
+                            {
+                                type: ApplicationCommandOptionType.String,
+                                name: 'nested',
+                                description: faker.string.alpha(),
+                                autocomplete: true,
+                                command: {
+                                    onEvent: [],
+                                    execute: () => {},
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        type: ApplicationCommandOptionType.Subcommand,
+                        name: subcommandName + 'a',
+                        description: faker.string.alpha(),
+                        options: [
+                            createRandomChoice(),
+                            {
+                                type: ApplicationCommandOptionType.String,
+                                name: 'nested',
+                                description: faker.string.alpha(),
+                                autocomplete: true,
+                                command: {
+                                    onEvent: [],
+                                    execute: () => {},
+                                },
+                            },
+                        ],
+                    },
+                ],
+            },
+        ];
+        autocmpInteraction.options.getSubcommand.mockReturnValue(subcommandName);
+        autocmpInteraction.options.getFocused.mockReturnValue({
+            name: 'nested',
+            value: faker.string.alpha(),
+            focused: true,
+        });
+        const result = treeSearch(autocmpInteraction, options);
+        expect(result).toBeTruthy();
+        expect(result.name).to.be.eq('nested');
+        expect(result.command).to.be.not.undefined;
+
+        let autocmpInteraction2 = new AutocompleteInteraction('nested');
+        autocmpInteraction2.options.getSubcommand.mockReturnValue(subcommandName + 'a');
+        autocmpInteraction2.options.getFocused.mockReturnValue({
+            name: 'nested',
+            value: faker.string.alpha(),
+            focused: true,
+        });
+        const result2 = treeSearch(autocmpInteraction2, options);
+        expect(result2).toBeTruthy();
+        expect(result2?.name).toEqual('nested');
+    });
+
+    it('simulates autocomplete typing and resolution', () => {
+        const subcommandName = faker.string.alpha();
+        const optionName = faker.word.noun();
+        const options: SernOptionsData[] = [
+            {
+                type: ApplicationCommandOptionType.SubcommandGroup,
+                name: faker.string.alpha(),
+                description: faker.string.alpha(),
+                options: [
+                    {
+                        type: ApplicationCommandOptionType.Subcommand,
+                        name: subcommandName,
+                        description: faker.string.alpha(),
+                        options: [
+                            createRandomChoice(),
+                            createRandomChoice(),
+                            {
+                                type: ApplicationCommandOptionType.String,
+                                name: optionName,
+                                description: faker.string.alpha(),
+                                autocomplete: true,
+                                command: {
+                                    onEvent: [],
+                                    execute: vi.fn(),
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        type: ApplicationCommandOptionType.Subcommand,
+                        name: subcommandName + 'a',
+                        description: faker.string.alpha(),
+                        options: [
+                            createRandomChoice(),
+                            {
+                                type: ApplicationCommandOptionType.String,
+                                name: optionName,
+                                description: faker.string.alpha(),
+                                autocomplete: true,
+                                command: {
+                                    onEvent: [],
+                                    execute: vi.fn(),
+                                },
+                            },
+                        ],
+                    },
+                ],
+            },
+        ];
+        let accumulator = '';
+        let result: unknown;
+        for (const char of optionName) {
+            accumulator += char;
+
+            const autocomplete = new AutocompleteInteraction(accumulator);
+            autocomplete.options.getSubcommand.mockReturnValue(subcommandName);
+            autocomplete.options.getFocused.mockReturnValue({
+                name: accumulator,
+                value: faker.string.alpha(),
+                focused: true,
+            });
+            result = treeSearch(autocomplete, options);
+        }
+        expect(result).toBeTruthy();
+    });
+});

test/core/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);
+    });
+});

test/core/module-loading.test.ts

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest'
+import { faker } from '@faker-js/faker'
+import * as Files from '../../src/core/module-loading'
+describe('module-loading', () => {
+    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)
+    })
+    
+//    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)
+//
+//    })
+})